niansa-misc/linux
1
0
Fork 0
mirror of synced 2025-03-06 20:59:54 +01:00
Code Issues Projects Releases Packages Wiki Activity

drm/tests: Change "igt_" prefix to "drm_test_"

Browse source 
With the introduction of KUnit, IGT is no longer the only option to run
the DRM unit tests, as the tests can be run through kunit-tool or on
real hardware with CONFIG_KUNIT.

Therefore, remove the "igt_" prefix from the tests and replace it with
the "drm_test_" prefix, making the tests' names independent from the tool
used.

Signed-off-by: Maíra Canal <mairacanal@riseup.net>
Acked-by: David Gow <davidgow@google.com>
Acked-by: Maxime Ripard <maxime@cerno.tech>
Link: https://patchwork.freedesktop.org/patch/msgid/20220911191756.203118-2-mairacanal@riseup.net
This commit is contained in:
Maíra Canal 2022-09-11 16:17:56 -03:00
parent b167259a12
commit 961bcdf956
9 changed files with 294 additions and 293 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

84
drivers/gpu/drm/tests/drm_buddy_test.c
View file

@ -13,7 +13,7 @@
#include "../lib/drm_random.h" #include "../lib/drm_random.h"
#define IGT_TIMEOUT(name__) \ #define TIMEOUT(name__) \
unsigned long name__ = jiffies + MAX_SCHEDULE_TIMEOUT unsigned long name__ = jiffies + MAX_SCHEDULE_TIMEOUT
static unsigned int random_seed; static unsigned int random_seed;
@ -24,7 +24,7 @@ static inline u64 get_size(int order, u64 chunk_size)
} }
__printf(2, 3) __printf(2, 3)
static bool __igt_timeout(unsigned long timeout, const char *fmt, ...) static bool __timeout(unsigned long timeout, const char *fmt, ...)
{ {
va_list va; va_list va;
@ -43,8 +43,8 @@ static bool __igt_timeout(unsigned long timeout, const char *fmt, ...)
return true; return true;
} }
static void __igt_dump_block(struct kunit *test, struct drm_buddy *mm, static void __dump_block(struct kunit *test, struct drm_buddy *mm,
struct drm_buddy_block *block, bool buddy) struct drm_buddy_block *block, bool buddy)
{ {
kunit_err(test, "block info: header=%llx, state=%u, order=%d, offset=%llx size=%llx root=%d buddy=%d\n", kunit_err(test, "block info: header=%llx, state=%u, order=%d, offset=%llx size=%llx root=%d buddy=%d\n",
block->header, drm_buddy_block_state(block), block->header, drm_buddy_block_state(block),
@ -52,20 +52,20 @@ static void __igt_dump_block(struct kunit *test, struct drm_buddy *mm,
drm_buddy_block_size(mm, block), !block->parent, buddy); drm_buddy_block_size(mm, block), !block->parent, buddy);
} }
static void igt_dump_block(struct kunit *test, struct drm_buddy *mm, static void dump_block(struct kunit *test, struct drm_buddy *mm,
struct drm_buddy_block *block) struct drm_buddy_block *block)
{ {
struct drm_buddy_block *buddy; struct drm_buddy_block *buddy;
__igt_dump_block(test, mm, block, false); __dump_block(test, mm, block, false);
buddy = drm_get_buddy(block); buddy = drm_get_buddy(block);
if (buddy) if (buddy)
__igt_dump_block(test, mm, buddy, true); __dump_block(test, mm, buddy, true);
} }
static int igt_check_block(struct kunit *test, struct drm_buddy *mm, static int check_block(struct kunit *test, struct drm_buddy *mm,
struct drm_buddy_block *block) struct drm_buddy_block *block)
{ {
struct drm_buddy_block *buddy; struct drm_buddy_block *buddy;
unsigned int block_state; unsigned int block_state;
@ -137,8 +137,8 @@ static int igt_check_block(struct kunit *test, struct drm_buddy *mm,
return err; return err;
} }
static int igt_check_blocks(struct kunit *test, struct drm_buddy *mm, static int check_blocks(struct kunit *test, struct drm_buddy *mm,
struct list_head *blocks, u64 expected_size, bool is_contiguous) struct list_head *blocks, u64 expected_size, bool is_contiguous)
{ {
struct drm_buddy_block *block; struct drm_buddy_block *block;
struct drm_buddy_block *prev; struct drm_buddy_block *prev;
@ -150,7 +150,7 @@ static int igt_check_blocks(struct kunit *test, struct drm_buddy *mm,
total = 0; total = 0;
list_for_each_entry(block, blocks, link) { list_for_each_entry(block, blocks, link) {
err = igt_check_block(test, mm, block); err = check_block(test, mm, block);
if (!drm_buddy_block_is_allocated(block)) { if (!drm_buddy_block_is_allocated(block)) {
kunit_err(test, "block not allocated\n"); kunit_err(test, "block not allocated\n");
@ -190,16 +190,16 @@ static int igt_check_blocks(struct kunit *test, struct drm_buddy *mm,
if (prev) { if (prev) {
kunit_err(test, "prev block, dump:\n"); kunit_err(test, "prev block, dump:\n");
igt_dump_block(test, mm, prev); dump_block(test, mm, prev);
} }
kunit_err(test, "bad block, dump:\n"); kunit_err(test, "bad block, dump:\n");
igt_dump_block(test, mm, block); dump_block(test, mm, block);
return err; return err;
} }
static int igt_check_mm(struct kunit *test, struct drm_buddy *mm) static int check_mm(struct kunit *test, struct drm_buddy *mm)
{ {
struct drm_buddy_block *root; struct drm_buddy_block *root;
struct drm_buddy_block *prev; struct drm_buddy_block *prev;
@ -233,7 +233,7 @@ static int igt_check_mm(struct kunit *test, struct drm_buddy *mm)
break; break;
} }
err = igt_check_block(test, mm, root); err = check_block(test, mm, root);
if (!drm_buddy_block_is_free(root)) { if (!drm_buddy_block_is_free(root)) {
kunit_err(test, "root not free\n"); kunit_err(test, "root not free\n");
@ -289,18 +289,18 @@ static int igt_check_mm(struct kunit *test, struct drm_buddy *mm)
if (prev) { if (prev) {
kunit_err(test, "prev root(%u), dump:\n", i - 1); kunit_err(test, "prev root(%u), dump:\n", i - 1);
igt_dump_block(test, mm, prev); dump_block(test, mm, prev);
} }
if (root) { if (root) {
kunit_err(test, "bad root(%u), dump:\n", i); kunit_err(test, "bad root(%u), dump:\n", i);
igt_dump_block(test, mm, root); dump_block(test, mm, root);
} }
return err; return err;
} }
static void igt_mm_config(u64 *size, u64 *chunk_size) static void mm_config(u64 *size, u64 *chunk_size)
{ {
DRM_RND_STATE(prng, random_seed); DRM_RND_STATE(prng, random_seed);
u32 s, ms; u32 s, ms;
@ -321,7 +321,7 @@ static void igt_mm_config(u64 *size, u64 *chunk_size)
*size = (u64)s << 12; *size = (u64)s << 12;
} }
static void igt_buddy_alloc_pathological(struct kunit *test) static void drm_test_buddy_alloc_pathological(struct kunit *test)
{ {
u64 mm_size, size, start = 0; u64 mm_size, size, start = 0;
struct drm_buddy_block *block; struct drm_buddy_block *block;
@ -402,7 +402,7 @@ static void igt_buddy_alloc_pathological(struct kunit *test)
drm_buddy_fini(&mm); drm_buddy_fini(&mm);
} }
static void igt_buddy_alloc_smoke(struct kunit *test) static void drm_test_buddy_alloc_smoke(struct kunit *test)
{ {
u64 mm_size, chunk_size, start = 0; u64 mm_size, chunk_size, start = 0;
unsigned long flags = 0; unsigned long flags = 0;
@ -411,9 +411,9 @@ static void igt_buddy_alloc_smoke(struct kunit *test)
int i; int i;
DRM_RND_STATE(prng, random_seed); DRM_RND_STATE(prng, random_seed);
IGT_TIMEOUT(end_time); TIMEOUT(end_time);
igt_mm_config(&mm_size, &chunk_size); mm_config(&mm_size, &chunk_size);
KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, chunk_size), KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, chunk_size),
"buddy_init failed\n"); "buddy_init failed\n");
@ -430,7 +430,7 @@ static void igt_buddy_alloc_smoke(struct kunit *test)
LIST_HEAD(tmp); LIST_HEAD(tmp);
int order, err; int order, err;
KUNIT_ASSERT_FALSE_MSG(test, igt_check_mm(test, &mm), KUNIT_ASSERT_FALSE_MSG(test, check_mm(test, &mm),
"pre-mm check failed, abort\n"); "pre-mm check failed, abort\n");
order = max_order; order = max_order;
@ -466,19 +466,19 @@ retry:
total += drm_buddy_block_size(&mm, block); total += drm_buddy_block_size(&mm, block);
if (__igt_timeout(end_time, NULL)) { if (__timeout(end_time, NULL)) {
timeout = true; timeout = true;
break; break;
} }
} while (total < mm.size); } while (total < mm.size);
if (!err) if (!err)
err = igt_check_blocks(test, &mm, &blocks, total, false); err = check_blocks(test, &mm, &blocks, total, false);
drm_buddy_free_list(&mm, &blocks); drm_buddy_free_list(&mm, &blocks);
if (!err) { if (!err) {
KUNIT_EXPECT_FALSE_MSG(test, igt_check_mm(test, &mm), KUNIT_EXPECT_FALSE_MSG(test, check_mm(test, &mm),
"post-mm check failed\n"); "post-mm check failed\n");
} }
@ -492,7 +492,7 @@ retry:
drm_buddy_fini(&mm); drm_buddy_fini(&mm);
} }
static void igt_buddy_alloc_pessimistic(struct kunit *test) static void drm_test_buddy_alloc_pessimistic(struct kunit *test)
{ {
u64 mm_size, size, start = 0; u64 mm_size, size, start = 0;
struct drm_buddy_block *block, *bn; struct drm_buddy_block *block, *bn;
@ -587,7 +587,7 @@ static void igt_buddy_alloc_pessimistic(struct kunit *test)
drm_buddy_fini(&mm); drm_buddy_fini(&mm);
} }
static void igt_buddy_alloc_optimistic(struct kunit *test) static void drm_test_buddy_alloc_optimistic(struct kunit *test)
{ {
u64 mm_size, size, start = 0; u64 mm_size, size, start = 0;
struct drm_buddy_block *block; struct drm_buddy_block *block;
@ -633,7 +633,7 @@ static void igt_buddy_alloc_optimistic(struct kunit *test)
drm_buddy_fini(&mm); drm_buddy_fini(&mm);
} }
static void igt_buddy_alloc_range(struct kunit *test) static void drm_test_buddy_alloc_range(struct kunit *test)
{ {
unsigned long flags = DRM_BUDDY_RANGE_ALLOCATION; unsigned long flags = DRM_BUDDY_RANGE_ALLOCATION;
u64 offset, size, rem, chunk_size, end; u64 offset, size, rem, chunk_size, end;
@ -641,12 +641,12 @@ static void igt_buddy_alloc_range(struct kunit *test)
struct drm_buddy mm; struct drm_buddy mm;
LIST_HEAD(blocks); LIST_HEAD(blocks);
igt_mm_config(&size, &chunk_size); mm_config(&size, &chunk_size);
KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, size, chunk_size), KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, size, chunk_size),
"buddy_init failed"); "buddy_init failed");
KUNIT_ASSERT_FALSE_MSG(test, igt_check_mm(test, &mm), KUNIT_ASSERT_FALSE_MSG(test, check_mm(test, &mm),
"pre-mm check failed, abort!"); "pre-mm check failed, abort!");
rem = mm.size; rem = mm.size;
@ -671,7 +671,7 @@ static void igt_buddy_alloc_range(struct kunit *test)
"alloc_range start offset mismatch, found=%llx, expected=%llx\n", "alloc_range start offset mismatch, found=%llx, expected=%llx\n",
drm_buddy_block_offset(block), offset); drm_buddy_block_offset(block), offset);
KUNIT_ASSERT_FALSE(test, igt_check_blocks(test, &mm, &tmp, size, true)); KUNIT_ASSERT_FALSE(test, check_blocks(test, &mm, &tmp, size, true));
list_splice_tail(&tmp, &blocks); list_splice_tail(&tmp, &blocks);
@ -686,12 +686,12 @@ static void igt_buddy_alloc_range(struct kunit *test)
drm_buddy_free_list(&mm, &blocks); drm_buddy_free_list(&mm, &blocks);
KUNIT_EXPECT_FALSE_MSG(test, igt_check_mm(test, &mm), "post-mm check failed\n"); KUNIT_EXPECT_FALSE_MSG(test, check_mm(test, &mm), "post-mm check failed\n");
drm_buddy_fini(&mm); drm_buddy_fini(&mm);
} }
static void igt_buddy_alloc_limit(struct kunit *test) static void drm_test_buddy_alloc_limit(struct kunit *test)
{ {
u64 size = U64_MAX, start = 0; u64 size = U64_MAX, start = 0;
struct drm_buddy_block *block; struct drm_buddy_block *block;
@ -735,12 +735,12 @@ static int drm_buddy_init_test(struct kunit *test)
} }
static struct kunit_case drm_buddy_tests[] = { static struct kunit_case drm_buddy_tests[] = {
KUNIT_CASE(igt_buddy_alloc_limit), KUNIT_CASE(drm_test_buddy_alloc_limit),
KUNIT_CASE(igt_buddy_alloc_range), KUNIT_CASE(drm_test_buddy_alloc_range),
KUNIT_CASE(igt_buddy_alloc_optimistic), KUNIT_CASE(drm_test_buddy_alloc_optimistic),
KUNIT_CASE(igt_buddy_alloc_pessimistic), KUNIT_CASE(drm_test_buddy_alloc_pessimistic),
KUNIT_CASE(igt_buddy_alloc_smoke), KUNIT_CASE(drm_test_buddy_alloc_smoke),
KUNIT_CASE(igt_buddy_alloc_pathological), KUNIT_CASE(drm_test_buddy_alloc_pathological),
{} {}
}; };

156
drivers/gpu/drm/tests/drm_cmdline_parser_test.c
View file

@ -11,7 +11,7 @@
static const struct drm_connector no_connector = {}; static const struct drm_connector no_connector = {};
static void drm_cmdline_test_force_e_only(struct kunit *test) static void drm_test_cmdline_force_e_only(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "e"; const char *cmdline = "e";
@ -29,7 +29,7 @@ static void drm_cmdline_test_force_e_only(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON);
} }
static void drm_cmdline_test_force_D_only_not_digital(struct kunit *test) static void drm_test_cmdline_force_D_only_not_digital(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "D"; const char *cmdline = "D";
@ -51,7 +51,7 @@ static const struct drm_connector connector_hdmi = {
.connector_type = DRM_MODE_CONNECTOR_HDMIB, .connector_type = DRM_MODE_CONNECTOR_HDMIB,
}; };
static void drm_cmdline_test_force_D_only_hdmi(struct kunit *test) static void drm_test_cmdline_force_D_only_hdmi(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "D"; const char *cmdline = "D";
@ -73,7 +73,7 @@ static const struct drm_connector connector_dvi = {
.connector_type = DRM_MODE_CONNECTOR_DVII, .connector_type = DRM_MODE_CONNECTOR_DVII,
}; };
static void drm_cmdline_test_force_D_only_dvi(struct kunit *test) static void drm_test_cmdline_force_D_only_dvi(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "D"; const char *cmdline = "D";
@ -91,7 +91,7 @@ static void drm_cmdline_test_force_D_only_dvi(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON_DIGITAL); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON_DIGITAL);
} }
static void drm_cmdline_test_force_d_only(struct kunit *test) static void drm_test_cmdline_force_d_only(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "d"; const char *cmdline = "d";
@ -109,7 +109,7 @@ static void drm_cmdline_test_force_d_only(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_OFF); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_OFF);
} }
static void drm_cmdline_test_res(struct kunit *test) static void drm_test_cmdline_res(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480"; const char *cmdline = "720x480";
@ -131,7 +131,7 @@ static void drm_cmdline_test_res(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_res_vesa(struct kunit *test) static void drm_test_cmdline_res_vesa(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480M"; const char *cmdline = "720x480M";
@ -153,7 +153,7 @@ static void drm_cmdline_test_res_vesa(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_res_vesa_rblank(struct kunit *test) static void drm_test_cmdline_res_vesa_rblank(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480MR"; const char *cmdline = "720x480MR";
@ -175,7 +175,7 @@ static void drm_cmdline_test_res_vesa_rblank(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_res_rblank(struct kunit *test) static void drm_test_cmdline_res_rblank(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480R"; const char *cmdline = "720x480R";
@ -197,7 +197,7 @@ static void drm_cmdline_test_res_rblank(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_res_bpp(struct kunit *test) static void drm_test_cmdline_res_bpp(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480-24"; const char *cmdline = "720x480-24";
@ -220,7 +220,7 @@ static void drm_cmdline_test_res_bpp(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_res_refresh(struct kunit *test) static void drm_test_cmdline_res_refresh(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480@60"; const char *cmdline = "720x480@60";
@ -243,7 +243,7 @@ static void drm_cmdline_test_res_refresh(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_res_bpp_refresh(struct kunit *test) static void drm_test_cmdline_res_bpp_refresh(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480-24@60"; const char *cmdline = "720x480-24@60";
@ -267,7 +267,7 @@ static void drm_cmdline_test_res_bpp_refresh(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_res_bpp_refresh_interlaced(struct kunit *test) static void drm_test_cmdline_res_bpp_refresh_interlaced(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480-24@60i"; const char *cmdline = "720x480-24@60i";
@ -291,7 +291,7 @@ static void drm_cmdline_test_res_bpp_refresh_interlaced(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_res_bpp_refresh_margins(struct kunit *test) static void drm_test_cmdline_res_bpp_refresh_margins(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480-24@60m"; const char *cmdline = "720x480-24@60m";
@ -315,7 +315,7 @@ static void drm_cmdline_test_res_bpp_refresh_margins(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_res_bpp_refresh_force_off(struct kunit *test) static void drm_test_cmdline_res_bpp_refresh_force_off(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480-24@60d"; const char *cmdline = "720x480-24@60d";
@ -339,7 +339,7 @@ static void drm_cmdline_test_res_bpp_refresh_force_off(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_OFF); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_OFF);
} }
static void drm_cmdline_test_res_bpp_refresh_force_on(struct kunit *test) static void drm_test_cmdline_res_bpp_refresh_force_on(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480-24@60e"; const char *cmdline = "720x480-24@60e";
@ -363,7 +363,7 @@ static void drm_cmdline_test_res_bpp_refresh_force_on(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON);
} }
static void drm_cmdline_test_res_bpp_refresh_force_on_analog(struct kunit *test) static void drm_test_cmdline_res_bpp_refresh_force_on_analog(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480-24@60D"; const char *cmdline = "720x480-24@60D";
@ -387,7 +387,7 @@ static void drm_cmdline_test_res_bpp_refresh_force_on_analog(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON);
} }
static void drm_cmdline_test_res_bpp_refresh_force_on_digital(struct kunit *test) static void drm_test_cmdline_res_bpp_refresh_force_on_digital(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
static const struct drm_connector connector = { static const struct drm_connector connector = {
@ -414,7 +414,7 @@ static void drm_cmdline_test_res_bpp_refresh_force_on_digital(struct kunit *test
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON_DIGITAL); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON_DIGITAL);
} }
static void drm_cmdline_test_res_bpp_refresh_interlaced_margins_force_on(struct kunit *test) static void drm_test_cmdline_res_bpp_refresh_interlaced_margins_force_on(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480-24@60ime"; const char *cmdline = "720x480-24@60ime";
@ -438,7 +438,7 @@ static void drm_cmdline_test_res_bpp_refresh_interlaced_margins_force_on(struct
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON);
} }
static void drm_cmdline_test_res_margins_force_on(struct kunit *test) static void drm_test_cmdline_res_margins_force_on(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480me"; const char *cmdline = "720x480me";
@ -460,7 +460,7 @@ static void drm_cmdline_test_res_margins_force_on(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON);
} }
static void drm_cmdline_test_res_vesa_margins(struct kunit *test) static void drm_test_cmdline_res_vesa_margins(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480Mm"; const char *cmdline = "720x480Mm";
@ -482,7 +482,7 @@ static void drm_cmdline_test_res_vesa_margins(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_name(struct kunit *test) static void drm_test_cmdline_name(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "NTSC"; const char *cmdline = "NTSC";
@ -494,7 +494,7 @@ static void drm_cmdline_test_name(struct kunit *test)
KUNIT_EXPECT_FALSE(test, mode.bpp_specified); KUNIT_EXPECT_FALSE(test, mode.bpp_specified);
} }
static void drm_cmdline_test_name_bpp(struct kunit *test) static void drm_test_cmdline_name_bpp(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "NTSC-24"; const char *cmdline = "NTSC-24";
@ -509,7 +509,7 @@ static void drm_cmdline_test_name_bpp(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.bpp, 24); KUNIT_EXPECT_EQ(test, mode.bpp, 24);
} }
static void drm_cmdline_test_name_option(struct kunit *test) static void drm_test_cmdline_name_option(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "NTSC,rotate=180"; const char *cmdline = "NTSC,rotate=180";
@ -521,7 +521,7 @@ static void drm_cmdline_test_name_option(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.rotation_reflection, DRM_MODE_ROTATE_180); KUNIT_EXPECT_EQ(test, mode.rotation_reflection, DRM_MODE_ROTATE_180);
} }
static void drm_cmdline_test_name_bpp_option(struct kunit *test) static void drm_test_cmdline_name_bpp_option(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "NTSC-24,rotate=180"; const char *cmdline = "NTSC-24,rotate=180";
@ -535,7 +535,7 @@ static void drm_cmdline_test_name_bpp_option(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.bpp, 24); KUNIT_EXPECT_EQ(test, mode.bpp, 24);
} }
static void drm_cmdline_test_rotate_0(struct kunit *test) static void drm_test_cmdline_rotate_0(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480,rotate=0"; const char *cmdline = "720x480,rotate=0";
@ -558,7 +558,7 @@ static void drm_cmdline_test_rotate_0(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_rotate_90(struct kunit *test) static void drm_test_cmdline_rotate_90(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480,rotate=90"; const char *cmdline = "720x480,rotate=90";
@ -581,7 +581,7 @@ static void drm_cmdline_test_rotate_90(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_rotate_180(struct kunit *test) static void drm_test_cmdline_rotate_180(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480,rotate=180"; const char *cmdline = "720x480,rotate=180";
@ -604,7 +604,7 @@ static void drm_cmdline_test_rotate_180(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_rotate_270(struct kunit *test) static void drm_test_cmdline_rotate_270(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480,rotate=270"; const char *cmdline = "720x480,rotate=270";
@ -627,7 +627,7 @@ static void drm_cmdline_test_rotate_270(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_hmirror(struct kunit *test) static void drm_test_cmdline_hmirror(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480,reflect_x"; const char *cmdline = "720x480,reflect_x";
@ -650,7 +650,7 @@ static void drm_cmdline_test_hmirror(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_vmirror(struct kunit *test) static void drm_test_cmdline_vmirror(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480,reflect_y"; const char *cmdline = "720x480,reflect_y";
@ -673,7 +673,7 @@ static void drm_cmdline_test_vmirror(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_margin_options(struct kunit *test) static void drm_test_cmdline_margin_options(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = const char *cmdline =
@ -700,7 +700,7 @@ static void drm_cmdline_test_margin_options(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_multiple_options(struct kunit *test) static void drm_test_cmdline_multiple_options(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480,rotate=270,reflect_x"; const char *cmdline = "720x480,rotate=270,reflect_x";
@ -723,7 +723,7 @@ static void drm_cmdline_test_multiple_options(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_bpp_extra_and_option(struct kunit *test) static void drm_test_cmdline_bpp_extra_and_option(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480-24e,rotate=180"; const char *cmdline = "720x480-24e,rotate=180";
@ -747,7 +747,7 @@ static void drm_cmdline_test_bpp_extra_and_option(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON);
} }
static void drm_cmdline_test_extra_and_option(struct kunit *test) static void drm_test_cmdline_extra_and_option(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "720x480e,rotate=180"; const char *cmdline = "720x480e,rotate=180";
@ -769,7 +769,7 @@ static void drm_cmdline_test_extra_and_option(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON);
} }
static void drm_cmdline_test_freestanding_options(struct kunit *test) static void drm_test_cmdline_freestanding_options(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "margin_right=14,margin_left=24,margin_bottom=36,margin_top=42"; const char *cmdline = "margin_right=14,margin_left=24,margin_bottom=36,margin_top=42";
@ -792,7 +792,7 @@ static void drm_cmdline_test_freestanding_options(struct kunit *test)
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_UNSPECIFIED);
} }
static void drm_cmdline_test_freestanding_force_e_and_options(struct kunit *test) static void drm_test_cmdline_freestanding_force_e_and_options(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "e,margin_right=14,margin_left=24,margin_bottom=36,margin_top=42"; const char *cmdline = "e,margin_right=14,margin_left=24,margin_bottom=36,margin_top=42";
@ -815,7 +815,7 @@ static void drm_cmdline_test_freestanding_force_e_and_options(struct kunit *test
KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON); KUNIT_EXPECT_EQ(test, mode.force, DRM_FORCE_ON);
} }
static void drm_cmdline_test_panel_orientation(struct kunit *test) static void drm_test_cmdline_panel_orientation(struct kunit *test)
{ {
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
const char *cmdline = "panel_orientation=upside_down"; const char *cmdline = "panel_orientation=upside_down";
@ -840,7 +840,7 @@ struct drm_cmdline_invalid_test {
const char *cmdline; const char *cmdline;
}; };
static void drm_cmdline_test_invalid(struct kunit *test) static void drm_test_cmdline_invalid(struct kunit *test)
{ {
const struct drm_cmdline_invalid_test *params = test->param_value; const struct drm_cmdline_invalid_test *params = test->param_value;
struct drm_cmdline_mode mode = { }; struct drm_cmdline_mode mode = { };
@ -938,45 +938,45 @@ static void drm_cmdline_invalid_desc(const struct drm_cmdline_invalid_test *t,
KUNIT_ARRAY_PARAM(drm_cmdline_invalid, drm_cmdline_invalid_tests, drm_cmdline_invalid_desc); KUNIT_ARRAY_PARAM(drm_cmdline_invalid, drm_cmdline_invalid_tests, drm_cmdline_invalid_desc);
static struct kunit_case drm_cmdline_parser_tests[] = { static struct kunit_case drm_cmdline_parser_tests[] = {
KUNIT_CASE(drm_cmdline_test_force_d_only), KUNIT_CASE(drm_test_cmdline_force_d_only),
KUNIT_CASE(drm_cmdline_test_force_D_only_dvi), KUNIT_CASE(drm_test_cmdline_force_D_only_dvi),
KUNIT_CASE(drm_cmdline_test_force_D_only_hdmi), KUNIT_CASE(drm_test_cmdline_force_D_only_hdmi),
KUNIT_CASE(drm_cmdline_test_force_D_only_not_digital), KUNIT_CASE(drm_test_cmdline_force_D_only_not_digital),
KUNIT_CASE(drm_cmdline_test_force_e_only), KUNIT_CASE(drm_test_cmdline_force_e_only),
KUNIT_CASE(drm_cmdline_test_res), KUNIT_CASE(drm_test_cmdline_res),
KUNIT_CASE(drm_cmdline_test_res_vesa), KUNIT_CASE(drm_test_cmdline_res_vesa),
KUNIT_CASE(drm_cmdline_test_res_vesa_rblank), KUNIT_CASE(drm_test_cmdline_res_vesa_rblank),
KUNIT_CASE(drm_cmdline_test_res_rblank), KUNIT_CASE(drm_test_cmdline_res_rblank),
KUNIT_CASE(drm_cmdline_test_res_bpp), KUNIT_CASE(drm_test_cmdline_res_bpp),
KUNIT_CASE(drm_cmdline_test_res_refresh), KUNIT_CASE(drm_test_cmdline_res_refresh),
KUNIT_CASE(drm_cmdline_test_res_bpp_refresh), KUNIT_CASE(drm_test_cmdline_res_bpp_refresh),
KUNIT_CASE(drm_cmdline_test_res_bpp_refresh_interlaced), KUNIT_CASE(drm_test_cmdline_res_bpp_refresh_interlaced),
KUNIT_CASE(drm_cmdline_test_res_bpp_refresh_margins), KUNIT_CASE(drm_test_cmdline_res_bpp_refresh_margins),
KUNIT_CASE(drm_cmdline_test_res_bpp_refresh_force_off), KUNIT_CASE(drm_test_cmdline_res_bpp_refresh_force_off),
KUNIT_CASE(drm_cmdline_test_res_bpp_refresh_force_on), KUNIT_CASE(drm_test_cmdline_res_bpp_refresh_force_on),
KUNIT_CASE(drm_cmdline_test_res_bpp_refresh_force_on_analog), KUNIT_CASE(drm_test_cmdline_res_bpp_refresh_force_on_analog),
KUNIT_CASE(drm_cmdline_test_res_bpp_refresh_force_on_digital), KUNIT_CASE(drm_test_cmdline_res_bpp_refresh_force_on_digital),
KUNIT_CASE(drm_cmdline_test_res_bpp_refresh_interlaced_margins_force_on), KUNIT_CASE(drm_test_cmdline_res_bpp_refresh_interlaced_margins_force_on),
KUNIT_CASE(drm_cmdline_test_res_margins_force_on), KUNIT_CASE(drm_test_cmdline_res_margins_force_on),
KUNIT_CASE(drm_cmdline_test_res_vesa_margins), KUNIT_CASE(drm_test_cmdline_res_vesa_margins),
KUNIT_CASE(drm_cmdline_test_name), KUNIT_CASE(drm_test_cmdline_name),
KUNIT_CASE(drm_cmdline_test_name_bpp), KUNIT_CASE(drm_test_cmdline_name_bpp),
KUNIT_CASE(drm_cmdline_test_name_option), KUNIT_CASE(drm_test_cmdline_name_option),
KUNIT_CASE(drm_cmdline_test_name_bpp_option), KUNIT_CASE(drm_test_cmdline_name_bpp_option),
KUNIT_CASE(drm_cmdline_test_rotate_0), KUNIT_CASE(drm_test_cmdline_rotate_0),
KUNIT_CASE(drm_cmdline_test_rotate_90), KUNIT_CASE(drm_test_cmdline_rotate_90),
KUNIT_CASE(drm_cmdline_test_rotate_180), KUNIT_CASE(drm_test_cmdline_rotate_180),
KUNIT_CASE(drm_cmdline_test_rotate_270), KUNIT_CASE(drm_test_cmdline_rotate_270),
KUNIT_CASE(drm_cmdline_test_hmirror), KUNIT_CASE(drm_test_cmdline_hmirror),
KUNIT_CASE(drm_cmdline_test_vmirror), KUNIT_CASE(drm_test_cmdline_vmirror),
KUNIT_CASE(drm_cmdline_test_margin_options), KUNIT_CASE(drm_test_cmdline_margin_options),
KUNIT_CASE(drm_cmdline_test_multiple_options), KUNIT_CASE(drm_test_cmdline_multiple_options),
KUNIT_CASE(drm_cmdline_test_bpp_extra_and_option), KUNIT_CASE(drm_test_cmdline_bpp_extra_and_option),
KUNIT_CASE(drm_cmdline_test_extra_and_option), KUNIT_CASE(drm_test_cmdline_extra_and_option),
KUNIT_CASE(drm_cmdline_test_freestanding_options), KUNIT_CASE(drm_test_cmdline_freestanding_options),
KUNIT_CASE(drm_cmdline_test_freestanding_force_e_and_options), KUNIT_CASE(drm_test_cmdline_freestanding_force_e_and_options),
KUNIT_CASE(drm_cmdline_test_panel_orientation), KUNIT_CASE(drm_test_cmdline_panel_orientation),
KUNIT_CASE_PARAM(drm_cmdline_test_invalid, drm_cmdline_invalid_gen_params), KUNIT_CASE_PARAM(drm_test_cmdline_invalid, drm_cmdline_invalid_gen_params),
{} {}
}; };

84
drivers/gpu/drm/tests/drm_damage_helper_test.c
View file

@ -116,7 +116,7 @@ static void check_damage_clip(struct kunit *test, struct drm_rect *r,
r->x1, r->y1, r->x2, r->y2, x1, y1, x2, y2); r->x1, r->y1, r->x2, r->y2, x1, y1, x2, y2);
} }
static void igt_damage_iter_no_damage(struct kunit *test) static void drm_test_damage_iter_no_damage(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -134,7 +134,7 @@ static void igt_damage_iter_no_damage(struct kunit *test)
check_damage_clip(test, &clip, 0, 0, 2048, 2048); check_damage_clip(test, &clip, 0, 0, 2048, 2048);
} }
static void igt_damage_iter_no_damage_fractional_src(struct kunit *test) static void drm_test_damage_iter_no_damage_fractional_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -155,7 +155,7 @@ static void igt_damage_iter_no_damage_fractional_src(struct kunit *test)
check_damage_clip(test, &clip, 3, 3, 1028, 772); check_damage_clip(test, &clip, 3, 3, 1028, 772);
} }
static void igt_damage_iter_no_damage_src_moved(struct kunit *test) static void drm_test_damage_iter_no_damage_src_moved(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -174,7 +174,7 @@ static void igt_damage_iter_no_damage_src_moved(struct kunit *test)
check_damage_clip(test, &clip, 10, 10, 1034, 778); check_damage_clip(test, &clip, 10, 10, 1034, 778);
} }
static void igt_damage_iter_no_damage_fractional_src_moved(struct kunit *test) static void drm_test_damage_iter_no_damage_fractional_src_moved(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -194,7 +194,7 @@ static void igt_damage_iter_no_damage_fractional_src_moved(struct kunit *test)
check_damage_clip(test, &clip, 4, 4, 1029, 773); check_damage_clip(test, &clip, 4, 4, 1029, 773);
} }
static void igt_damage_iter_no_damage_not_visible(struct kunit *test) static void drm_test_damage_iter_no_damage_not_visible(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -212,7 +212,7 @@ static void igt_damage_iter_no_damage_not_visible(struct kunit *test)
KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
} }
static void igt_damage_iter_no_damage_no_crtc(struct kunit *test) static void drm_test_damage_iter_no_damage_no_crtc(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -230,7 +230,7 @@ static void igt_damage_iter_no_damage_no_crtc(struct kunit *test)
KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
} }
static void igt_damage_iter_no_damage_no_fb(struct kunit *test) static void drm_test_damage_iter_no_damage_no_fb(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -248,7 +248,7 @@ static void igt_damage_iter_no_damage_no_fb(struct kunit *test)
KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
} }
static void igt_damage_iter_simple_damage(struct kunit *test) static void drm_test_damage_iter_simple_damage(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -271,7 +271,7 @@ static void igt_damage_iter_simple_damage(struct kunit *test)
check_damage_clip(test, &clip, 0, 0, 1024, 768); check_damage_clip(test, &clip, 0, 0, 1024, 768);
} }
static void igt_damage_iter_single_damage(struct kunit *test) static void drm_test_damage_iter_single_damage(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -293,7 +293,7 @@ static void igt_damage_iter_single_damage(struct kunit *test)
check_damage_clip(test, &clip, 256, 192, 768, 576); check_damage_clip(test, &clip, 256, 192, 768, 576);
} }
static void igt_damage_iter_single_damage_intersect_src(struct kunit *test) static void drm_test_damage_iter_single_damage_intersect_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -316,7 +316,7 @@ static void igt_damage_iter_single_damage_intersect_src(struct kunit *test)
check_damage_clip(test, &clip, 256, 192, 1024, 768); check_damage_clip(test, &clip, 256, 192, 1024, 768);
} }
static void igt_damage_iter_single_damage_outside_src(struct kunit *test) static void drm_test_damage_iter_single_damage_outside_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -338,7 +338,7 @@ static void igt_damage_iter_single_damage_outside_src(struct kunit *test)
KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
} }
static void igt_damage_iter_single_damage_fractional_src(struct kunit *test) static void drm_test_damage_iter_single_damage_fractional_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -363,7 +363,7 @@ static void igt_damage_iter_single_damage_fractional_src(struct kunit *test)
check_damage_clip(test, &clip, 10, 10, 256, 330); check_damage_clip(test, &clip, 10, 10, 256, 330);
} }
static void igt_damage_iter_single_damage_intersect_fractional_src(struct kunit *test) static void drm_test_damage_iter_single_damage_intersect_fractional_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -390,7 +390,7 @@ static void igt_damage_iter_single_damage_intersect_fractional_src(struct kunit
check_damage_clip(test, &clip, 10, 4, 1029, 330); check_damage_clip(test, &clip, 10, 4, 1029, 330);
} }
static void igt_damage_iter_single_damage_outside_fractional_src(struct kunit *test) static void drm_test_damage_iter_single_damage_outside_fractional_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -415,7 +415,7 @@ static void igt_damage_iter_single_damage_outside_fractional_src(struct kunit *t
KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
} }
static void igt_damage_iter_single_damage_src_moved(struct kunit *test) static void drm_test_damage_iter_single_damage_src_moved(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -440,7 +440,7 @@ static void igt_damage_iter_single_damage_src_moved(struct kunit *test)
check_damage_clip(test, &clip, 10, 10, 1034, 778); check_damage_clip(test, &clip, 10, 10, 1034, 778);
} }
static void igt_damage_iter_single_damage_fractional_src_moved(struct kunit *test) static void drm_test_damage_iter_single_damage_fractional_src_moved(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -467,7 +467,7 @@ static void igt_damage_iter_single_damage_fractional_src_moved(struct kunit *tes
check_damage_clip(test, &clip, 4, 4, 1029, 773); check_damage_clip(test, &clip, 4, 4, 1029, 773);
} }
static void igt_damage_iter_damage(struct kunit *test) static void drm_test_damage_iter_damage(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -495,7 +495,7 @@ static void igt_damage_iter_damage(struct kunit *test)
KUNIT_EXPECT_EQ_MSG(test, num_hits, 2, "Should return damage when set."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 2, "Should return damage when set.");
} }
static void igt_damage_iter_damage_one_intersect(struct kunit *test) static void drm_test_damage_iter_damage_one_intersect(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -525,7 +525,7 @@ static void igt_damage_iter_damage_one_intersect(struct kunit *test)
KUNIT_EXPECT_EQ_MSG(test, num_hits, 2, "Should return damage when set."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 2, "Should return damage when set.");
} }
static void igt_damage_iter_damage_one_outside(struct kunit *test) static void drm_test_damage_iter_damage_one_outside(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -549,7 +549,7 @@ static void igt_damage_iter_damage_one_outside(struct kunit *test)
check_damage_clip(test, &clip, 240, 200, 280, 250); check_damage_clip(test, &clip, 240, 200, 280, 250);
} }
static void igt_damage_iter_damage_src_moved(struct kunit *test) static void drm_test_damage_iter_damage_src_moved(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -576,7 +576,7 @@ static void igt_damage_iter_damage_src_moved(struct kunit *test)
check_damage_clip(test, &clip, 3, 3, 1028, 772); check_damage_clip(test, &clip, 3, 3, 1028, 772);
} }
static void igt_damage_iter_damage_not_visible(struct kunit *test) static void drm_test_damage_iter_damage_not_visible(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv; struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
@ -604,27 +604,27 @@ static void igt_damage_iter_damage_not_visible(struct kunit *test)
} }
static struct kunit_case drm_damage_helper_tests[] = { static struct kunit_case drm_damage_helper_tests[] = {
KUNIT_CASE(igt_damage_iter_no_damage), KUNIT_CASE(drm_test_damage_iter_no_damage),
KUNIT_CASE(igt_damage_iter_no_damage_fractional_src), KUNIT_CASE(drm_test_damage_iter_no_damage_fractional_src),
KUNIT_CASE(igt_damage_iter_no_damage_src_moved), KUNIT_CASE(drm_test_damage_iter_no_damage_src_moved),
KUNIT_CASE(igt_damage_iter_no_damage_fractional_src_moved), KUNIT_CASE(drm_test_damage_iter_no_damage_fractional_src_moved),
KUNIT_CASE(igt_damage_iter_no_damage_not_visible), KUNIT_CASE(drm_test_damage_iter_no_damage_not_visible),
KUNIT_CASE(igt_damage_iter_no_damage_no_crtc), KUNIT_CASE(drm_test_damage_iter_no_damage_no_crtc),
KUNIT_CASE(igt_damage_iter_no_damage_no_fb), KUNIT_CASE(drm_test_damage_iter_no_damage_no_fb),
KUNIT_CASE(igt_damage_iter_simple_damage), KUNIT_CASE(drm_test_damage_iter_simple_damage),
KUNIT_CASE(igt_damage_iter_single_damage), KUNIT_CASE(drm_test_damage_iter_single_damage),
KUNIT_CASE(igt_damage_iter_single_damage_intersect_src), KUNIT_CASE(drm_test_damage_iter_single_damage_intersect_src),
KUNIT_CASE(igt_damage_iter_single_damage_outside_src), KUNIT_CASE(drm_test_damage_iter_single_damage_outside_src),
KUNIT_CASE(igt_damage_iter_single_damage_fractional_src), KUNIT_CASE(drm_test_damage_iter_single_damage_fractional_src),
KUNIT_CASE(igt_damage_iter_single_damage_intersect_fractional_src), KUNIT_CASE(drm_test_damage_iter_single_damage_intersect_fractional_src),
KUNIT_CASE(igt_damage_iter_single_damage_outside_fractional_src), KUNIT_CASE(drm_test_damage_iter_single_damage_outside_fractional_src),
KUNIT_CASE(igt_damage_iter_single_damage_src_moved), KUNIT_CASE(drm_test_damage_iter_single_damage_src_moved),
KUNIT_CASE(igt_damage_iter_single_damage_fractional_src_moved), KUNIT_CASE(drm_test_damage_iter_single_damage_fractional_src_moved),
KUNIT_CASE(igt_damage_iter_damage), KUNIT_CASE(drm_test_damage_iter_damage),
KUNIT_CASE(igt_damage_iter_damage_one_intersect), KUNIT_CASE(drm_test_damage_iter_damage_one_intersect),
KUNIT_CASE(igt_damage_iter_damage_one_outside), KUNIT_CASE(drm_test_damage_iter_damage_one_outside),
KUNIT_CASE(igt_damage_iter_damage_src_moved), KUNIT_CASE(drm_test_damage_iter_damage_src_moved),
KUNIT_CASE(igt_damage_iter_damage_not_visible), KUNIT_CASE(drm_test_damage_iter_damage_not_visible),
{ } { }
}; };

8
drivers/gpu/drm/tests/drm_dp_mst_helper_test.c
View file

@ -16,7 +16,7 @@
#include "../display/drm_dp_mst_topology_internal.h" #include "../display/drm_dp_mst_topology_internal.h"
static void igt_dp_mst_calc_pbn_mode(struct kunit *test) static void drm_test_dp_mst_calc_pbn_mode(struct kunit *test)
{ {
int pbn, i; int pbn, i;
const struct { const struct {
@ -177,7 +177,7 @@ out:
return result; return result;
} }
static void igt_dp_mst_sideband_msg_req_decode(struct kunit *test) static void drm_test_dp_mst_sideband_msg_req_decode(struct kunit *test)
{ {
struct drm_dp_sideband_msg_req_body in = { 0 }; struct drm_dp_sideband_msg_req_body in = { 0 };
u8 data[] = { 0xff, 0x0, 0xdd }; u8 data[] = { 0xff, 0x0, 0xdd };
@ -271,8 +271,8 @@ static void igt_dp_mst_sideband_msg_req_decode(struct kunit *test)
} }
static struct kunit_case drm_dp_mst_helper_tests[] = { static struct kunit_case drm_dp_mst_helper_tests[] = {
KUNIT_CASE(igt_dp_mst_calc_pbn_mode), KUNIT_CASE(drm_test_dp_mst_calc_pbn_mode),
KUNIT_CASE(igt_dp_mst_sideband_msg_req_decode), KUNIT_CASE(drm_test_dp_mst_sideband_msg_req_decode),
{ } { }
}; };

8
drivers/gpu/drm/tests/drm_format_helper_test.c
View file

@ -192,7 +192,7 @@ static void convert_xrgb8888_case_desc(struct convert_xrgb8888_case *t,
KUNIT_ARRAY_PARAM(convert_xrgb8888, convert_xrgb8888_cases, KUNIT_ARRAY_PARAM(convert_xrgb8888, convert_xrgb8888_cases,
convert_xrgb8888_case_desc); convert_xrgb8888_case_desc);
static void xrgb8888_to_rgb332_test(struct kunit *test) static void drm_test_fb_xrgb8888_to_rgb332(struct kunit *test)
{ {
const struct convert_xrgb8888_case *params = test->param_value; const struct convert_xrgb8888_case *params = test->param_value;
const struct convert_to_rgb332_result *result = &params->rgb332_result; const struct convert_to_rgb332_result *result = &params->rgb332_result;
@ -222,7 +222,7 @@ static void xrgb8888_to_rgb332_test(struct kunit *test)
KUNIT_EXPECT_EQ(test, memcmp(buf, result->expected, dst_size), 0); KUNIT_EXPECT_EQ(test, memcmp(buf, result->expected, dst_size), 0);
} }
static void xrgb8888_to_rgb565_test(struct kunit *test) static void drm_test_fb_xrgb8888_to_rgb565(struct kunit *test)
{ {
const struct convert_xrgb8888_case *params = test->param_value; const struct convert_xrgb8888_case *params = test->param_value;
const struct convert_to_rgb565_result *result = &params->rgb565_result; const struct convert_to_rgb565_result *result = &params->rgb565_result;
@ -256,8 +256,8 @@ static void xrgb8888_to_rgb565_test(struct kunit *test)
} }
static struct kunit_case drm_format_helper_test_cases[] = { static struct kunit_case drm_format_helper_test_cases[] = {
KUNIT_CASE_PARAM(xrgb8888_to_rgb332_test, convert_xrgb8888_gen_params), KUNIT_CASE_PARAM(drm_test_fb_xrgb8888_to_rgb332, convert_xrgb8888_gen_params),
KUNIT_CASE_PARAM(xrgb8888_to_rgb565_test, convert_xrgb8888_gen_params), KUNIT_CASE_PARAM(drm_test_fb_xrgb8888_to_rgb565, convert_xrgb8888_gen_params),
{} {}
}; };

72
drivers/gpu/drm/tests/drm_format_test.c
View file

@ -9,7 +9,7 @@
#include <drm/drm_fourcc.h> #include <drm/drm_fourcc.h>
static void drm_format_block_width_invalid(struct kunit *test) static void drm_test_format_block_width_invalid(struct kunit *test)
{ {
const struct drm_format_info *info = NULL; const struct drm_format_info *info = NULL;
@ -18,7 +18,7 @@ static void drm_format_block_width_invalid(struct kunit *test)
KUNIT_EXPECT_EQ(test, drm_format_info_block_width(info, 1), 0); KUNIT_EXPECT_EQ(test, drm_format_info_block_width(info, 1), 0);
} }
static void drm_format_block_width_one_plane(struct kunit *test) static void drm_test_format_block_width_one_plane(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_XRGB4444); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_XRGB4444);
@ -29,7 +29,7 @@ static void drm_format_block_width_one_plane(struct kunit *test)
KUNIT_EXPECT_EQ(test, drm_format_info_block_width(info, -1), 0); KUNIT_EXPECT_EQ(test, drm_format_info_block_width(info, -1), 0);
} }
static void drm_format_block_width_two_plane(struct kunit *test) static void drm_test_format_block_width_two_plane(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_NV12); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_NV12);
@ -41,7 +41,7 @@ static void drm_format_block_width_two_plane(struct kunit *test)
KUNIT_EXPECT_EQ(test, drm_format_info_block_width(info, -1), 0); KUNIT_EXPECT_EQ(test, drm_format_info_block_width(info, -1), 0);
} }
static void drm_format_block_width_three_plane(struct kunit *test) static void drm_test_format_block_width_three_plane(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_YUV422); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_YUV422);
@ -54,7 +54,7 @@ static void drm_format_block_width_three_plane(struct kunit *test)
KUNIT_EXPECT_EQ(test, drm_format_info_block_width(info, -1), 0); KUNIT_EXPECT_EQ(test, drm_format_info_block_width(info, -1), 0);
} }
static void drm_format_block_width_tiled(struct kunit *test) static void drm_test_format_block_width_tiled(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_X0L0); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_X0L0);
@ -65,7 +65,7 @@ static void drm_format_block_width_tiled(struct kunit *test)
KUNIT_EXPECT_EQ(test, drm_format_info_block_width(info, -1), 0); KUNIT_EXPECT_EQ(test, drm_format_info_block_width(info, -1), 0);
} }
static void drm_format_block_height_invalid(struct kunit *test) static void drm_test_format_block_height_invalid(struct kunit *test)
{ {
const struct drm_format_info *info = NULL; const struct drm_format_info *info = NULL;
@ -74,7 +74,7 @@ static void drm_format_block_height_invalid(struct kunit *test)
KUNIT_EXPECT_EQ(test, drm_format_info_block_height(info, 1), 0); KUNIT_EXPECT_EQ(test, drm_format_info_block_height(info, 1), 0);
} }
static void drm_format_block_height_one_plane(struct kunit *test) static void drm_test_format_block_height_one_plane(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_XRGB4444); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_XRGB4444);
@ -85,7 +85,7 @@ static void drm_format_block_height_one_plane(struct kunit *test)
KUNIT_EXPECT_EQ(test, drm_format_info_block_height(info, 1), 0); KUNIT_EXPECT_EQ(test, drm_format_info_block_height(info, 1), 0);
} }
static void drm_format_block_height_two_plane(struct kunit *test) static void drm_test_format_block_height_two_plane(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_NV12); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_NV12);
@ -97,7 +97,7 @@ static void drm_format_block_height_two_plane(struct kunit *test)
KUNIT_EXPECT_EQ(test, drm_format_info_block_height(info, -1), 0); KUNIT_EXPECT_EQ(test, drm_format_info_block_height(info, -1), 0);
} }
static void drm_format_block_height_three_plane(struct kunit *test) static void drm_test_format_block_height_three_plane(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_YUV422); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_YUV422);
@ -110,7 +110,7 @@ static void drm_format_block_height_three_plane(struct kunit *test)
KUNIT_EXPECT_EQ(test, drm_format_info_block_height(info, -1), 0); KUNIT_EXPECT_EQ(test, drm_format_info_block_height(info, -1), 0);
} }
static void drm_format_block_height_tiled(struct kunit *test) static void drm_test_format_block_height_tiled(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_X0L0); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_X0L0);
@ -121,7 +121,7 @@ static void drm_format_block_height_tiled(struct kunit *test)
KUNIT_EXPECT_EQ(test, drm_format_info_block_height(info, -1), 0); KUNIT_EXPECT_EQ(test, drm_format_info_block_height(info, -1), 0);
} }
static void drm_format_min_pitch_invalid(struct kunit *test) static void drm_test_format_min_pitch_invalid(struct kunit *test)
{ {
const struct drm_format_info *info = NULL; const struct drm_format_info *info = NULL;
@ -130,7 +130,7 @@ static void drm_format_min_pitch_invalid(struct kunit *test)
KUNIT_EXPECT_EQ(test, drm_format_info_min_pitch(info, 1, 0), 0); KUNIT_EXPECT_EQ(test, drm_format_info_min_pitch(info, 1, 0), 0);
} }
static void drm_format_min_pitch_one_plane_8bpp(struct kunit *test) static void drm_test_format_min_pitch_one_plane_8bpp(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_RGB332); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_RGB332);
@ -153,7 +153,7 @@ static void drm_format_min_pitch_one_plane_8bpp(struct kunit *test)
(uint64_t)(UINT_MAX - 1)); (uint64_t)(UINT_MAX - 1));
} }
static void drm_format_min_pitch_one_plane_16bpp(struct kunit *test) static void drm_test_format_min_pitch_one_plane_16bpp(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_XRGB4444); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_XRGB4444);
@ -176,7 +176,7 @@ static void drm_format_min_pitch_one_plane_16bpp(struct kunit *test)
(uint64_t)(UINT_MAX - 1) * 2); (uint64_t)(UINT_MAX - 1) * 2);
} }
static void drm_format_min_pitch_one_plane_24bpp(struct kunit *test) static void drm_test_format_min_pitch_one_plane_24bpp(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_RGB888); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_RGB888);
@ -199,7 +199,7 @@ static void drm_format_min_pitch_one_plane_24bpp(struct kunit *test)
(uint64_t)(UINT_MAX - 1) * 3); (uint64_t)(UINT_MAX - 1) * 3);
} }
static void drm_format_min_pitch_one_plane_32bpp(struct kunit *test) static void drm_test_format_min_pitch_one_plane_32bpp(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_ABGR8888); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_ABGR8888);
@ -222,7 +222,7 @@ static void drm_format_min_pitch_one_plane_32bpp(struct kunit *test)
(uint64_t)(UINT_MAX - 1) * 4); (uint64_t)(UINT_MAX - 1) * 4);
} }
static void drm_format_min_pitch_two_plane(struct kunit *test) static void drm_test_format_min_pitch_two_plane(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_NV12); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_NV12);
@ -257,7 +257,7 @@ static void drm_format_min_pitch_two_plane(struct kunit *test)
(uint64_t)(UINT_MAX - 1)); (uint64_t)(UINT_MAX - 1));
} }
static void drm_format_min_pitch_three_plane_8bpp(struct kunit *test) static void drm_test_format_min_pitch_three_plane_8bpp(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_YUV422); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_YUV422);
@ -304,7 +304,7 @@ static void drm_format_min_pitch_three_plane_8bpp(struct kunit *test)
(uint64_t)(UINT_MAX - 1) / 2); (uint64_t)(UINT_MAX - 1) / 2);
} }
static void drm_format_min_pitch_tiled(struct kunit *test) static void drm_test_format_min_pitch_tiled(struct kunit *test)
{ {
const struct drm_format_info *info = drm_format_info(DRM_FORMAT_X0L2); const struct drm_format_info *info = drm_format_info(DRM_FORMAT_X0L2);
@ -328,24 +328,24 @@ static void drm_format_min_pitch_tiled(struct kunit *test)
} }
static struct kunit_case drm_format_tests[] = { static struct kunit_case drm_format_tests[] = {
KUNIT_CASE(drm_format_block_width_invalid), KUNIT_CASE(drm_test_format_block_width_invalid),
KUNIT_CASE(drm_format_block_width_one_plane), KUNIT_CASE(drm_test_format_block_width_one_plane),
KUNIT_CASE(drm_format_block_width_two_plane), KUNIT_CASE(drm_test_format_block_width_two_plane),
KUNIT_CASE(drm_format_block_width_three_plane), KUNIT_CASE(drm_test_format_block_width_three_plane),
KUNIT_CASE(drm_format_block_width_tiled), KUNIT_CASE(drm_test_format_block_width_tiled),
KUNIT_CASE(drm_format_block_height_invalid), KUNIT_CASE(drm_test_format_block_height_invalid),
KUNIT_CASE(drm_format_block_height_one_plane), KUNIT_CASE(drm_test_format_block_height_one_plane),
KUNIT_CASE(drm_format_block_height_two_plane), KUNIT_CASE(drm_test_format_block_height_two_plane),
KUNIT_CASE(drm_format_block_height_three_plane), KUNIT_CASE(drm_test_format_block_height_three_plane),
KUNIT_CASE(drm_format_block_height_tiled), KUNIT_CASE(drm_test_format_block_height_tiled),
KUNIT_CASE(drm_format_min_pitch_invalid), KUNIT_CASE(drm_test_format_min_pitch_invalid),
KUNIT_CASE(drm_format_min_pitch_one_plane_8bpp), KUNIT_CASE(drm_test_format_min_pitch_one_plane_8bpp),
KUNIT_CASE(drm_format_min_pitch_one_plane_16bpp), KUNIT_CASE(drm_test_format_min_pitch_one_plane_16bpp),
KUNIT_CASE(drm_format_min_pitch_one_plane_24bpp), KUNIT_CASE(drm_test_format_min_pitch_one_plane_24bpp),
KUNIT_CASE(drm_format_min_pitch_one_plane_32bpp), KUNIT_CASE(drm_test_format_min_pitch_one_plane_32bpp),
KUNIT_CASE(drm_format_min_pitch_two_plane), KUNIT_CASE(drm_test_format_min_pitch_two_plane),
KUNIT_CASE(drm_format_min_pitch_three_plane_8bpp), KUNIT_CASE(drm_test_format_min_pitch_three_plane_8bpp),
KUNIT_CASE(drm_format_min_pitch_tiled), KUNIT_CASE(drm_test_format_min_pitch_tiled),
{} {}
}; };

155
drivers/gpu/drm/tests/drm_mm_test.c
View file

@ -191,7 +191,7 @@ static bool assert_node(struct kunit *test, struct drm_mm_node *node, struct drm
return ok; return ok;
} }
static void igt_mm_init(struct kunit *test) static void drm_test_mm_init(struct kunit *test)
{ {
const unsigned int size = 4096; const unsigned int size = 4096;
struct drm_mm mm; struct drm_mm mm;
@ -245,7 +245,7 @@ out:
drm_mm_takedown(&mm); drm_mm_takedown(&mm);
} }
static void igt_mm_debug(struct kunit *test) static void drm_test_mm_debug(struct kunit *test)
{ {
struct drm_mm mm; struct drm_mm mm;
struct drm_mm_node nodes[2]; struct drm_mm_node nodes[2];
@ -341,7 +341,7 @@ static bool check_reserve_boundaries(struct kunit *test, struct drm_mm *mm,
return true; return true;
} }
static int __igt_reserve(struct kunit *test, unsigned int count, u64 size) static int __drm_test_mm_reserve(struct kunit *test, unsigned int count, u64 size)
{ {
DRM_RND_STATE(prng, random_seed); DRM_RND_STATE(prng, random_seed);
struct drm_mm mm; struct drm_mm mm;
@ -349,7 +349,7 @@ static int __igt_reserve(struct kunit *test, unsigned int count, u64 size)
unsigned int *order, n, m, o = 0; unsigned int *order, n, m, o = 0;
int ret, err; int ret, err;
/* For exercising drm_mm_reserve_node(struct kunit *test, ), we want to check that /* For exercising drm_mm_reserve_node(), we want to check that
* reservations outside of the drm_mm range are rejected, and to * reservations outside of the drm_mm range are rejected, and to
* overlapping and otherwise already occupied ranges. Afterwards, * overlapping and otherwise already occupied ranges. Afterwards,
* the tree and nodes should be intact. * the tree and nodes should be intact.
@ -463,7 +463,7 @@ err:
return ret; return ret;
} }
static void igt_mm_reserve(struct kunit *test) static void drm_test_mm_reserve(struct kunit *test)
{ {
const unsigned int count = min_t(unsigned int, BIT(10), max_iterations); const unsigned int count = min_t(unsigned int, BIT(10), max_iterations);
int n; int n;
@ -471,9 +471,9 @@ static void igt_mm_reserve(struct kunit *test)
for_each_prime_number_from(n, 1, 54) { for_each_prime_number_from(n, 1, 54) {
u64 size = BIT_ULL(n); u64 size = BIT_ULL(n);
KUNIT_ASSERT_FALSE(test, __igt_reserve(test, count, size - 1)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_reserve(test, count, size - 1));
KUNIT_ASSERT_FALSE(test, __igt_reserve(test, count, size)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_reserve(test, count, size));
KUNIT_ASSERT_FALSE(test, __igt_reserve(test, count, size + 1)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_reserve(test, count, size + 1));
cond_resched(); cond_resched();
} }
@ -524,7 +524,7 @@ static bool expect_insert_fail(struct kunit *test, struct drm_mm *mm, u64 size)
return false; return false;
} }
static int __igt_insert(struct kunit *test, unsigned int count, u64 size, bool replace) static int __drm_test_mm_insert(struct kunit *test, unsigned int count, u64 size, bool replace)
{ {
DRM_RND_STATE(prng, random_seed); DRM_RND_STATE(prng, random_seed);
const struct insert_mode *mode; const struct insert_mode *mode;
@ -660,7 +660,7 @@ err_nodes:
return ret; return ret;
} }
static void igt_mm_insert(struct kunit *test) static void drm_test_mm_insert(struct kunit *test)
{ {
const unsigned int count = min_t(unsigned int, BIT(10), max_iterations); const unsigned int count = min_t(unsigned int, BIT(10), max_iterations);
unsigned int n; unsigned int n;
@ -668,20 +668,20 @@ static void igt_mm_insert(struct kunit *test)
for_each_prime_number_from(n, 1, 54) { for_each_prime_number_from(n, 1, 54) {
u64 size = BIT_ULL(n); u64 size = BIT_ULL(n);
KUNIT_ASSERT_FALSE(test, __igt_insert(test, count, size - 1, false)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size - 1, false));
KUNIT_ASSERT_FALSE(test, __igt_insert(test, count, size, false)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size, false));
KUNIT_ASSERT_FALSE(test, __igt_insert(test, count, size + 1, false)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size + 1, false));
cond_resched(); cond_resched();
} }
} }
static void igt_mm_replace(struct kunit *test) static void drm_test_mm_replace(struct kunit *test)
{ {
const unsigned int count = min_t(unsigned int, BIT(10), max_iterations); const unsigned int count = min_t(unsigned int, BIT(10), max_iterations);
unsigned int n; unsigned int n;
/* Reuse igt_insert to exercise replacement by inserting a dummy node, /* Reuse __drm_test_mm_insert to exercise replacement by inserting a dummy node,
* then replacing it with the intended node. We want to check that * then replacing it with the intended node. We want to check that
* the tree is intact and all the information we need is carried * the tree is intact and all the information we need is carried
* across to the target node. * across to the target node.
@ -690,9 +690,9 @@ static void igt_mm_replace(struct kunit *test)
for_each_prime_number_from(n, 1, 54) { for_each_prime_number_from(n, 1, 54) {
u64 size = BIT_ULL(n); u64 size = BIT_ULL(n);
KUNIT_ASSERT_FALSE(test, __igt_insert(test, count, size - 1, true)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size - 1, true));
KUNIT_ASSERT_FALSE(test, __igt_insert(test, count, size, true)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size, true));
KUNIT_ASSERT_FALSE(test, __igt_insert(test, count, size + 1, true)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert(test, count, size + 1, true));
cond_resched(); cond_resched();
} }
@ -808,7 +808,8 @@ static bool assert_contiguous_in_range(struct kunit *test, struct drm_mm *mm,
return true; return true;
} }
static int __igt_insert_range(struct kunit *test, unsigned int count, u64 size, u64 start, u64 end) static int __drm_test_mm_insert_range(struct kunit *test, unsigned int count, u64 size,
u64 start, u64 end)
{ {
const struct insert_mode *mode; const struct insert_mode *mode;
struct drm_mm mm; struct drm_mm mm;
@ -820,7 +821,7 @@ static int __igt_insert_range(struct kunit *test, unsigned int count, u64 size,
DRM_MM_BUG_ON(!size); DRM_MM_BUG_ON(!size);
DRM_MM_BUG_ON(end <= start); DRM_MM_BUG_ON(end <= start);
/* Very similar to __igt_insert(struct kunit *test, ), but now instead of populating the /* Very similar to __drm_test_mm_insert(), but now instead of populating the
* full range of the drm_mm, we try to fill a small portion of it. * full range of the drm_mm, we try to fill a small portion of it.
*/ */
@ -921,7 +922,7 @@ static int insert_outside_range(struct kunit *test)
return 0; return 0;
} }
static void igt_mm_insert_range(struct kunit *test) static void drm_test_mm_insert_range(struct kunit *test)
{ {
const unsigned int count = min_t(unsigned int, BIT(13), max_iterations); const unsigned int count = min_t(unsigned int, BIT(13), max_iterations);
unsigned int n; unsigned int n;
@ -933,21 +934,21 @@ static void igt_mm_insert_range(struct kunit *test)
const u64 size = BIT_ULL(n); const u64 size = BIT_ULL(n);
const u64 max = count * size; const u64 max = count * size;
KUNIT_ASSERT_FALSE(test, __igt_insert_range(test, count, size, 0, max)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 0, max));
KUNIT_ASSERT_FALSE(test, __igt_insert_range(test, count, size, 1, max)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 1, max));
KUNIT_ASSERT_FALSE(test, __igt_insert_range(test, count, size, 0, max - 1)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 0, max - 1));
KUNIT_ASSERT_FALSE(test, __igt_insert_range(test, count, size, 0, max / 2)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size, 0, max / 2));
KUNIT_ASSERT_FALSE(test, __igt_insert_range(test, count, size, max / 2, max / 2)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size,
KUNIT_ASSERT_FALSE(test, __igt_insert_range(test, count, size, max / 2, max / 2));
max / 4 + 1, 3 * max / 4 - 1)); KUNIT_ASSERT_FALSE(test, __drm_test_mm_insert_range(test, count, size,
max / 4 + 1, 3 * max / 4 - 1));
cond_resched(); cond_resched();
} }
} }
static int prepare_igt_frag(struct kunit *test, struct drm_mm *mm, static int prepare_frag(struct kunit *test, struct drm_mm *mm, struct drm_mm_node *nodes,
struct drm_mm_node *nodes, unsigned int num_insert, unsigned int num_insert, const struct insert_mode *mode)
const struct insert_mode *mode)
{ {
unsigned int size = 4096; unsigned int size = 4096;
unsigned int i; unsigned int i;
@ -987,7 +988,7 @@ static u64 get_insert_time(struct kunit *test, struct drm_mm *mm,
return ktime_to_ns(ktime_sub(ktime_get(), start)); return ktime_to_ns(ktime_sub(ktime_get(), start));
} }
static void igt_mm_frag(struct kunit *test) static void drm_test_mm_frag(struct kunit *test)
{ {
struct drm_mm mm; struct drm_mm mm;
const struct insert_mode *mode; const struct insert_mode *mode;
@ -997,15 +998,15 @@ static void igt_mm_frag(struct kunit *test)
/* We need 4 * insert_size nodes to hold intermediate allocated /* We need 4 * insert_size nodes to hold intermediate allocated
* drm_mm nodes. * drm_mm nodes.
* 1 times for prepare_igt_frag(struct kunit *test, ) * 1 times for prepare_frag()
* 1 times for get_insert_time(struct kunit *test, ) * 1 times for get_insert_time()
* 2 times for get_insert_time(struct kunit *test, ) * 2 times for get_insert_time()
*/ */
nodes = vzalloc(array_size(insert_size * 4, sizeof(*nodes))); nodes = vzalloc(array_size(insert_size * 4, sizeof(*nodes)));
KUNIT_ASSERT_TRUE(test, nodes); KUNIT_ASSERT_TRUE(test, nodes);
/* For BOTTOMUP and TOPDOWN, we first fragment the /* For BOTTOMUP and TOPDOWN, we first fragment the
* address space using prepare_igt_frag(struct kunit *test, ) and then try to verify * address space using prepare_frag() and then try to verify
* that insertions scale quadratically from 10k to 20k insertions * that insertions scale quadratically from 10k to 20k insertions
*/ */
drm_mm_init(&mm, 1, U64_MAX - 2); drm_mm_init(&mm, 1, U64_MAX - 2);
@ -1016,7 +1017,7 @@ static void igt_mm_frag(struct kunit *test)
mode->mode != DRM_MM_INSERT_HIGH) mode->mode != DRM_MM_INSERT_HIGH)
continue; continue;
if (prepare_igt_frag(test, &mm, nodes, insert_size, mode)) if (prepare_frag(test, &mm, nodes, insert_size, mode))
goto err; goto err;
insert_time1 = get_insert_time(test, &mm, insert_size, insert_time1 = get_insert_time(test, &mm, insert_size,
@ -1049,7 +1050,7 @@ err:
vfree(nodes); vfree(nodes);
} }
static void igt_mm_align(struct kunit *test) static void drm_test_mm_align(struct kunit *test)
{ {
const struct insert_mode *mode; const struct insert_mode *mode;
const unsigned int max_count = min(8192u, max_prime); const unsigned int max_count = min(8192u, max_prime);
@ -1096,7 +1097,7 @@ out:
vfree(nodes); vfree(nodes);
} }
static void igt_align_pot(struct kunit *test, int max) static void drm_test_mm_align_pot(struct kunit *test, int max)
{ {
struct drm_mm mm; struct drm_mm mm;
struct drm_mm_node *node, *next; struct drm_mm_node *node, *next;
@ -1133,14 +1134,14 @@ out:
drm_mm_takedown(&mm); drm_mm_takedown(&mm);
} }
static void igt_mm_align32(struct kunit *test) static void drm_test_mm_align32(struct kunit *test)
{ {
igt_align_pot(test, 32); drm_test_mm_align_pot(test, 32);
} }
static void igt_mm_align64(struct kunit *test) static void drm_test_mm_align64(struct kunit *test)
{ {
igt_align_pot(test, 64); drm_test_mm_align_pot(test, 64);
} }
static void show_scan(struct kunit *test, const struct drm_mm_scan *scan) static void show_scan(struct kunit *test, const struct drm_mm_scan *scan)
@ -1386,7 +1387,7 @@ static int evict_something(struct kunit *test, struct drm_mm *mm,
return 0; return 0;
} }
static void igt_mm_evict(struct kunit *test) static void drm_test_mm_evict(struct kunit *test)
{ {
DRM_RND_STATE(prng, random_seed); DRM_RND_STATE(prng, random_seed);
const unsigned int size = 8192; const unsigned int size = 8192;
@ -1477,7 +1478,7 @@ err_nodes:
vfree(nodes); vfree(nodes);
} }
static void igt_mm_evict_range(struct kunit *test) static void drm_test_mm_evict_range(struct kunit *test)
{ {
DRM_RND_STATE(prng, random_seed); DRM_RND_STATE(prng, random_seed);
const unsigned int size = 8192; const unsigned int size = 8192;
@ -1490,7 +1491,7 @@ static void igt_mm_evict_range(struct kunit *test)
struct drm_mm_node *node, *next; struct drm_mm_node *node, *next;
unsigned int *order, n; unsigned int *order, n;
/* Like igt_evict() but now we are limiting the search to a /* Like drm_test_mm_evict() but now we are limiting the search to a
* small portion of the full drm_mm. * small portion of the full drm_mm.
*/ */
@ -1564,7 +1565,7 @@ static unsigned int node_index(const struct drm_mm_node *node)
return div64_u64(node->start, node->size); return div64_u64(node->start, node->size);
} }
static void igt_mm_topdown(struct kunit *test) static void drm_test_mm_topdown(struct kunit *test)
{ {
const struct insert_mode *topdown = &insert_modes[TOPDOWN]; const struct insert_mode *topdown = &insert_modes[TOPDOWN];
@ -1671,7 +1672,7 @@ err_nodes:
vfree(nodes); vfree(nodes);
} }
static void igt_mm_bottomup(struct kunit *test) static void drm_test_mm_bottomup(struct kunit *test)
{ {
const struct insert_mode *bottomup = &insert_modes[BOTTOMUP]; const struct insert_mode *bottomup = &insert_modes[BOTTOMUP];
@ -1683,7 +1684,7 @@ static void igt_mm_bottomup(struct kunit *test)
struct drm_mm_node *nodes, *node, *next; struct drm_mm_node *nodes, *node, *next;
unsigned int *order, n, m, o = 0; unsigned int *order, n, m, o = 0;
/* Like igt_topdown, but instead of searching for the last hole, /* Like drm_test_mm_topdown, but instead of searching for the last hole,
* we search for the first. * we search for the first.
*/ */
@ -1763,7 +1764,7 @@ err_nodes:
vfree(nodes); vfree(nodes);
} }
static void __igt_once(struct kunit *test, unsigned int mode) static void drm_test_mm_once(struct kunit *test, unsigned int mode)
{ {
struct drm_mm mm; struct drm_mm mm;
struct drm_mm_node rsvd_lo, rsvd_hi, node; struct drm_mm_node rsvd_lo, rsvd_hi, node;
@ -1806,14 +1807,14 @@ err:
drm_mm_takedown(&mm); drm_mm_takedown(&mm);
} }
static void igt_mm_lowest(struct kunit *test) static void drm_test_mm_lowest(struct kunit *test)
{ {
__igt_once(test, DRM_MM_INSERT_LOW); drm_test_mm_once(test, DRM_MM_INSERT_LOW);
} }
static void igt_mm_highest(struct kunit *test) static void drm_test_mm_highest(struct kunit *test)
{ {
__igt_once(test, DRM_MM_INSERT_HIGH); drm_test_mm_once(test, DRM_MM_INSERT_HIGH);
} }
static void separate_adjacent_colors(const struct drm_mm_node *node, static void separate_adjacent_colors(const struct drm_mm_node *node,
@ -1842,7 +1843,7 @@ static bool colors_abutt(struct kunit *test, const struct drm_mm_node *node)
return false; return false;
} }
static void igt_mm_color(struct kunit *test) static void drm_test_mm_color(struct kunit *test)
{ {
const unsigned int count = min(4096u, max_iterations); const unsigned int count = min(4096u, max_iterations);
const struct insert_mode *mode; const struct insert_mode *mode;
@ -2041,7 +2042,7 @@ static int evict_color(struct kunit *test, struct drm_mm *mm, u64 range_start,
return 0; return 0;
} }
static void igt_mm_color_evict(struct kunit *test) static void drm_test_mm_color_evict(struct kunit *test)
{ {
DRM_RND_STATE(prng, random_seed); DRM_RND_STATE(prng, random_seed);
const unsigned int total_size = min(8192u, max_iterations); const unsigned int total_size = min(8192u, max_iterations);
@ -2122,7 +2123,7 @@ err_nodes:
vfree(nodes); vfree(nodes);
} }
static void igt_mm_color_evict_range(struct kunit *test) static void drm_test_mm_color_evict_range(struct kunit *test)
{ {
DRM_RND_STATE(prng, random_seed); DRM_RND_STATE(prng, random_seed);
const unsigned int total_size = 8192; const unsigned int total_size = 8192;
@ -2136,7 +2137,7 @@ static void igt_mm_color_evict_range(struct kunit *test)
struct drm_mm_node *node, *next; struct drm_mm_node *node, *next;
unsigned int *order, n; unsigned int *order, n;
/* Like igt_color_evict(), but limited to small portion of the full /* Like drm_test_mm_color_evict(), but limited to small portion of the full
* drm_mm range. * drm_mm range.
*/ */
@ -2221,25 +2222,25 @@ module_param(max_iterations, uint, 0400);
module_param(max_prime, uint, 0400); module_param(max_prime, uint, 0400);
static struct kunit_case drm_mm_tests[] = { static struct kunit_case drm_mm_tests[] = {
KUNIT_CASE(igt_mm_init), KUNIT_CASE(drm_test_mm_init),
KUNIT_CASE(igt_mm_debug), KUNIT_CASE(drm_test_mm_debug),
KUNIT_CASE(igt_mm_reserve), KUNIT_CASE(drm_test_mm_reserve),
KUNIT_CASE(igt_mm_insert), KUNIT_CASE(drm_test_mm_insert),
KUNIT_CASE(igt_mm_replace), KUNIT_CASE(drm_test_mm_replace),
KUNIT_CASE(igt_mm_insert_range), KUNIT_CASE(drm_test_mm_insert_range),
KUNIT_CASE(igt_mm_frag), KUNIT_CASE(drm_test_mm_frag),
KUNIT_CASE(igt_mm_align), KUNIT_CASE(drm_test_mm_align),
KUNIT_CASE(igt_mm_align32), KUNIT_CASE(drm_test_mm_align32),
KUNIT_CASE(igt_mm_align64), KUNIT_CASE(drm_test_mm_align64),
KUNIT_CASE(igt_mm_evict), KUNIT_CASE(drm_test_mm_evict),
KUNIT_CASE(igt_mm_evict_range), KUNIT_CASE(drm_test_mm_evict_range),
KUNIT_CASE(igt_mm_topdown), KUNIT_CASE(drm_test_mm_topdown),
KUNIT_CASE(igt_mm_bottomup), KUNIT_CASE(drm_test_mm_bottomup),
KUNIT_CASE(igt_mm_lowest), KUNIT_CASE(drm_test_mm_lowest),
KUNIT_CASE(igt_mm_highest), KUNIT_CASE(drm_test_mm_highest),
KUNIT_CASE(igt_mm_color), KUNIT_CASE(drm_test_mm_color),
KUNIT_CASE(igt_mm_color_evict), KUNIT_CASE(drm_test_mm_color_evict),
KUNIT_CASE(igt_mm_color_evict_range), KUNIT_CASE(drm_test_mm_color_evict_range),
{} {}
}; };

4
drivers/gpu/drm/tests/drm_plane_helper_test.c
View file

@ -73,7 +73,7 @@ static bool check_crtc_eq(struct drm_plane_state *plane_state,
return true; return true;
} }
static void igt_check_plane_state(struct kunit *test) static void drm_test_check_plane_state(struct kunit *test)
{ {
int ret; int ret;
@ -223,7 +223,7 @@ static void igt_check_plane_state(struct kunit *test)
} }
static struct kunit_case drm_plane_helper_test[] = { static struct kunit_case drm_plane_helper_test[] = {
KUNIT_CASE(igt_check_plane_state), KUNIT_CASE(drm_test_check_plane_state),
{} {}
}; };

16
drivers/gpu/drm/tests/drm_rect_test.c
View file

@ -9,7 +9,7 @@
#include <drm/drm_rect.h> #include <drm/drm_rect.h>
static void igt_drm_rect_clip_scaled_div_by_zero(struct kunit *test) static void drm_test_rect_clip_scaled_div_by_zero(struct kunit *test)
{ {
struct drm_rect src, dst, clip; struct drm_rect src, dst, clip;
bool visible; bool visible;
@ -35,7 +35,7 @@ static void igt_drm_rect_clip_scaled_div_by_zero(struct kunit *test)
KUNIT_EXPECT_FALSE_MSG(test, drm_rect_visible(&src), "Source should not be visible\n"); KUNIT_EXPECT_FALSE_MSG(test, drm_rect_visible(&src), "Source should not be visible\n");
} }
static void igt_drm_rect_clip_scaled_not_clipped(struct kunit *test) static void drm_test_rect_clip_scaled_not_clipped(struct kunit *test)
{ {
struct drm_rect src, dst, clip; struct drm_rect src, dst, clip;
bool visible; bool visible;
@ -83,7 +83,7 @@ static void igt_drm_rect_clip_scaled_not_clipped(struct kunit *test)
KUNIT_EXPECT_TRUE_MSG(test, drm_rect_visible(&src), "Source should be visible\n"); KUNIT_EXPECT_TRUE_MSG(test, drm_rect_visible(&src), "Source should be visible\n");
} }
static void igt_drm_rect_clip_scaled_clipped(struct kunit *test) static void drm_test_rect_clip_scaled_clipped(struct kunit *test)
{ {
struct drm_rect src, dst, clip; struct drm_rect src, dst, clip;
bool visible; bool visible;
@ -173,7 +173,7 @@ static void igt_drm_rect_clip_scaled_clipped(struct kunit *test)
KUNIT_EXPECT_TRUE_MSG(test, drm_rect_visible(&src), "Source should be visible\n"); KUNIT_EXPECT_TRUE_MSG(test, drm_rect_visible(&src), "Source should be visible\n");
} }
static void igt_drm_rect_clip_scaled_signed_vs_unsigned(struct kunit *test) static void drm_test_rect_clip_scaled_signed_vs_unsigned(struct kunit *test)
{ {
struct drm_rect src, dst, clip; struct drm_rect src, dst, clip;
bool visible; bool visible;
@ -197,10 +197,10 @@ static void igt_drm_rect_clip_scaled_signed_vs_unsigned(struct kunit *test)
} }
static struct kunit_case drm_rect_tests[] = { static struct kunit_case drm_rect_tests[] = {
KUNIT_CASE(igt_drm_rect_clip_scaled_div_by_zero), KUNIT_CASE(drm_test_rect_clip_scaled_div_by_zero),
KUNIT_CASE(igt_drm_rect_clip_scaled_not_clipped), KUNIT_CASE(drm_test_rect_clip_scaled_not_clipped),
KUNIT_CASE(igt_drm_rect_clip_scaled_clipped), KUNIT_CASE(drm_test_rect_clip_scaled_clipped),
KUNIT_CASE(igt_drm_rect_clip_scaled_signed_vs_unsigned), KUNIT_CASE(drm_test_rect_clip_scaled_signed_vs_unsigned),
{ } { }
}; };