Mocking was moved to .init() in order to separate it from test logic.
No functional changes.
Signed-off-by: Michał Winiarski <michal.winiar...@intel.com>
---
drivers/gpu/drm/selftests/Makefile | 5 +-
.../gpu/drm/selftests/drm_modeset_selftests.h | 21 -
.../drm/selftests/test-drm_damage_helper.c | 570 +++++++++---------
.../drm/selftests/test-drm_modeset_common.h | 21 -
4 files changed, 288 insertions(+), 329 deletions(-)
diff --git a/drivers/gpu/drm/selftests/Makefile
b/drivers/gpu/drm/selftests/Makefile
index 1235eadca884..35f2f40dbaf3 100644
--- a/drivers/gpu/drm/selftests/Makefile
+++ b/drivers/gpu/drm/selftests/Makefile
@@ -1,11 +1,12 @@
# SPDX-License-Identifier: GPL-2.0-only
test-drm_modeset-$(CONFIG_DRM_DEBUG_SELFTEST) := \
test-drm_modeset_common.o \
- test-drm_damage_helper.o test-drm_dp_mst_helper.o \
+ test-drm_dp_mst_helper.o \
test-drm_rect.o
obj-$(CONFIG_DRM_DEBUG_SELFTEST) += test-drm_mm.o test-drm_modeset.o
obj-$(CONFIG_DRM_KUNIT_TEST) := \
test-drm_cmdline_parser.o test-drm_plane_helper.o \
- test-drm_format.o test-drm_framebuffer.o
+ test-drm_format.o test-drm_framebuffer.o \
+ test-drm_damage_helper.o
diff --git a/drivers/gpu/drm/selftests/drm_modeset_selftests.h
b/drivers/gpu/drm/selftests/drm_modeset_selftests.h
index 66f6b31e1a7f..b6a6dba66b64 100644
--- a/drivers/gpu/drm/selftests/drm_modeset_selftests.h
+++ b/drivers/gpu/drm/selftests/drm_modeset_selftests.h
@@ -10,26 +10,5 @@ selftest(drm_rect_clip_scaled_div_by_zero,
igt_drm_rect_clip_scaled_div_by_zero)
selftest(drm_rect_clip_scaled_not_clipped,
igt_drm_rect_clip_scaled_not_clipped)
selftest(drm_rect_clip_scaled_clipped, igt_drm_rect_clip_scaled_clipped)
selftest(drm_rect_clip_scaled_signed_vs_unsigned,
igt_drm_rect_clip_scaled_signed_vs_unsigned)
-selftest(damage_iter_no_damage, igt_damage_iter_no_damage)
-selftest(damage_iter_no_damage_fractional_src,
igt_damage_iter_no_damage_fractional_src)
-selftest(damage_iter_no_damage_src_moved, igt_damage_iter_no_damage_src_moved)
-selftest(damage_iter_no_damage_fractional_src_moved,
igt_damage_iter_no_damage_fractional_src_moved)
-selftest(damage_iter_no_damage_not_visible,
igt_damage_iter_no_damage_not_visible)
-selftest(damage_iter_no_damage_no_crtc, igt_damage_iter_no_damage_no_crtc)
-selftest(damage_iter_no_damage_no_fb, igt_damage_iter_no_damage_no_fb)
-selftest(damage_iter_simple_damage, igt_damage_iter_simple_damage)
-selftest(damage_iter_single_damage, igt_damage_iter_single_damage)
-selftest(damage_iter_single_damage_intersect_src,
igt_damage_iter_single_damage_intersect_src)
-selftest(damage_iter_single_damage_outside_src,
igt_damage_iter_single_damage_outside_src)
-selftest(damage_iter_single_damage_fractional_src,
igt_damage_iter_single_damage_fractional_src)
-selftest(damage_iter_single_damage_intersect_fractional_src,
igt_damage_iter_single_damage_intersect_fractional_src)
-selftest(damage_iter_single_damage_outside_fractional_src,
igt_damage_iter_single_damage_outside_fractional_src)
-selftest(damage_iter_single_damage_src_moved,
igt_damage_iter_single_damage_src_moved)
-selftest(damage_iter_single_damage_fractional_src_moved,
igt_damage_iter_single_damage_fractional_src_moved)
-selftest(damage_iter_damage, igt_damage_iter_damage)
-selftest(damage_iter_damage_one_intersect,
igt_damage_iter_damage_one_intersect)
-selftest(damage_iter_damage_one_outside, igt_damage_iter_damage_one_outside)
-selftest(damage_iter_damage_src_moved, igt_damage_iter_damage_src_moved)
-selftest(damage_iter_damage_not_visible, igt_damage_iter_damage_not_visible)
selftest(dp_mst_calc_pbn_mode, igt_dp_mst_calc_pbn_mode)
selftest(dp_mst_sideband_msg_req_decode, igt_dp_mst_sideband_msg_req_decode)
diff --git a/drivers/gpu/drm/selftests/test-drm_damage_helper.c
b/drivers/gpu/drm/selftests/test-drm_damage_helper.c
index 8d8d8e214c28..685d87575c3a 100644
--- a/drivers/gpu/drm/selftests/test-drm_damage_helper.c
+++ b/drivers/gpu/drm/selftests/test-drm_damage_helper.c
@@ -3,39 +3,55 @@
* Test case for drm_damage_helper functions
*/
-#define pr_fmt(fmt) "drm_damage_helper: " fmt
+#include <kunit/test.h>
#include <drm/drm_damage_helper.h>
#include <drm/drm_plane.h>
#include <drm/drm_drv.h>
-#include "test-drm_modeset_common.h"
-
-struct drm_driver mock_driver;
-static struct drm_device mock_device;
-static struct drm_object_properties mock_obj_props;
-static struct drm_plane mock_plane;
-static struct drm_property mock_prop;
+/* common mocked structs many tests need */
+struct drm_damage_mock {
+ struct drm_framebuffer fb;
+ struct drm_driver driver;
+ struct drm_device device;
+ struct drm_object_properties obj_props;
+ struct drm_plane plane;
+ struct drm_property prop;
+ struct drm_plane_state state;
+ struct drm_plane_state old_state;
+};
-static void mock_setup(struct drm_plane_state *state)
+static int drm_damage_test_init(struct kunit *test)
{
- static bool setup_done = false;
+ struct drm_damage_mock *mock;
- state->plane = &mock_plane;
+ mock = kunit_kzalloc(test, sizeof(*mock), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, mock);
- if (setup_done)
- return;
+ mock->fb.width = 2048;
+ mock->fb.height = 2048;
/* just enough so that drm_plane_enable_fb_damage_clips() works */
- mock_device.driver = &mock_driver;
- mock_device.mode_config.prop_fb_damage_clips = &mock_prop;
- mock_plane.dev = &mock_device;
- mock_obj_props.count = 0;
- mock_plane.base.properties = &mock_obj_props;
- mock_prop.base.id = 1; /* 0 is an invalid id */
- mock_prop.dev = &mock_device;
-
- drm_plane_enable_fb_damage_clips(&mock_plane);
+ mock->device.driver = &mock->driver;
+ mock->device.mode_config.prop_fb_damage_clips = &mock->prop;
+ mock->plane.dev = &mock->device;
+ mock->obj_props.count = 0;
+ mock->plane.base.properties = &mock->obj_props;
+ mock->prop.base.id = 1; /* 0 is an invalid id */
+ mock->prop.dev = &mock->device;
+
+ drm_plane_enable_fb_damage_clips(&mock->plane);
+
+ mock->state.crtc = ZERO_SIZE_PTR;
+ mock->state.fb = &mock->fb;
+ mock->state.visible = true;
+ mock->state.plane = &mock->plane;
+
+ mock->old_state.plane = &mock->plane;
+
+ test->priv = mock;
+
+ return 0;
}
static void set_plane_src(struct drm_plane_state *state, int x1, int y1, int
x2,
@@ -69,8 +85,8 @@ static void set_plane_damage(struct drm_plane_state *state,
state->fb_damage_clips = damage_blob;
}
-static bool check_damage_clip(struct drm_plane_state *state, struct drm_rect
*r,
- int x1, int y1, int x2, int y2)
+static void check_damage_clip(struct kunit *test, struct drm_plane_state
*state,
+ struct drm_rect *r, int x1, int y1, int x2, int
y2)
{
/*
* Round down x1/y1 and round up x2/y2. This is because damage is not in
@@ -81,587 +97,571 @@ static bool check_damage_clip(struct drm_plane_state
*state, struct drm_rect *r,
int src_x2 = (state->src.x2 >> 16) + !!(state->src.x2 & 0xFFFF);
int src_y2 = (state->src.y2 >> 16) + !!(state->src.y2 & 0xFFFF);
- if (x1 >= x2 || y1 >= y2) {
- pr_err("Cannot have damage clip with no dimension.\n");
- return false;
- }
-
- if (x1 < src_x1 || y1 < src_y1 || x2 > src_x2 || y2 > src_y2) {
- pr_err("Damage cannot be outside rounded plane src.\n");
- return false;
- }
-
- if (r->x1 != x1 || r->y1 != y1 || r->x2 != x2 || r->y2 != y2) {
- pr_err("Damage = %d %d %d %d\n", r->x1, r->y1, r->x2, r->y2);
- return false;
- }
+ KUNIT_EXPECT_FALSE_MSG(test, x1 >= x2 || y1 >= y2,
+ "Cannot have damage clip with no dimension.");
+ KUNIT_EXPECT_FALSE_MSG(test, x1 < src_x1 || y1 < src_y1 || x2 > src_x2
|| y2 > src_y2,
+ "Damage cannot be outside rounded plane src.");
- return true;
+ KUNIT_EXPECT_TRUE_MSG(test, r->x1 == x1 && r->y1 == y1 && r->x2 == x2
&& r->y2 == y2,
+ "Damage = %d %d %d %d, expected = %d %d %d %d",
+ r->x1, r->y1, r->x2, r->y2,
+ x1, y1, x2, y2);
}
-const struct drm_framebuffer fb = {
- .width = 2048,
- .height = 2048
-};
-
-/* common mocked structs many tests need */
-#define MOCK_VARIABLES() \
- struct drm_plane_state old_state; \
- struct drm_plane_state state = { \
- .crtc = ZERO_SIZE_PTR, \
- .fb = (struct drm_framebuffer *) &fb, \
- .visible = true, \
- }; \
- mock_setup(&old_state); \
- mock_setup(&state);
-
-int igt_damage_iter_no_damage(void *ignored)
+static void drm_damage_iter_no_damage(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
+ struct drm_framebuffer *fb = &mock->fb;
struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
/* Plane src same as fb size. */
- set_plane_src(&old_state, 0, 0, fb.width << 16, fb.height << 16);
- set_plane_src(&state, 0, 0, fb.width << 16, fb.height << 16);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_src(old_state, 0, 0, fb->width << 16, fb->height << 16);
+ set_plane_src(state, 0, 0, fb->width << 16, fb->height << 16);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return plane src as damage.");
- FAIL_ON(!check_damage_clip(&state, &clip, 0, 0, 2048, 2048));
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return plane src as
damage.");
+ check_damage_clip(test, state, &clip, 0, 0, 2048, 2048);
}
-int igt_damage_iter_no_damage_fractional_src(void *ignored)
+static void drm_damage_iter_no_damage_fractional_src(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
/* Plane src has fractional part. */
- set_plane_src(&old_state, 0x3fffe, 0x3fffe,
+ set_plane_src(old_state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
- set_plane_src(&state, 0x3fffe, 0x3fffe,
+ set_plane_src(state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return rounded off plane src as damage.");
- FAIL_ON(!check_damage_clip(&state, &clip, 3, 3, 1028, 772));
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return rounded off plane
src as damage.");
+ check_damage_clip(test, state, &clip, 3, 3, 1028, 772);
}
-int igt_damage_iter_no_damage_src_moved(void *ignored)
+static void drm_damage_iter_no_damage_src_moved(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
/* Plane src moved since old plane state. */
- set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
- set_plane_src(&state, 10 << 16, 10 << 16,
+ set_plane_src(old_state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(state, 10 << 16, 10 << 16,
(10 + 1024) << 16, (10 + 768) << 16);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return plane src as damage.");
- FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 1034, 778));
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return plane src as
damage.");
+ check_damage_clip(test, state, &clip, 10, 10, 1034, 778);
}
-int igt_damage_iter_no_damage_fractional_src_moved(void *ignored)
+static void drm_damage_iter_no_damage_fractional_src_moved(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
/* Plane src has fractional part and it moved since old plane state. */
- set_plane_src(&old_state, 0x3fffe, 0x3fffe,
+ set_plane_src(old_state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
- set_plane_src(&state, 0x40002, 0x40002,
+ set_plane_src(state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return plane src as damage.");
- FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029, 773));
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return plane src as
damage.");
+ check_damage_clip(test, state, &clip, 4, 4, 1029, 773);
}
-int igt_damage_iter_no_damage_not_visible(void *ignored)
+static void drm_damage_iter_no_damage_not_visible(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
- state.visible = false;
+ state->visible = false;
- mock_setup(&old_state);
-
- set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
- set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_src(old_state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(state, 0, 0, 1024 << 16, 768 << 16);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 0, "Should have no damage.");
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
}
-int igt_damage_iter_no_damage_no_crtc(void *ignored)
+static void drm_damage_iter_no_damage_no_crtc(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
- state.crtc = NULL;
+ state->crtc = NULL;
- set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
- set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_src(old_state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(state, 0, 0, 1024 << 16, 768 << 16);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 0, "Should have no damage.");
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
}
-int igt_damage_iter_no_damage_no_fb(void *ignored)
+static void drm_damage_iter_no_damage_no_fb(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
- struct drm_plane_state old_state;
struct drm_rect clip;
uint32_t num_hits = 0;
- struct drm_plane_state state = {
- .crtc = ZERO_SIZE_PTR,
- .fb = 0,
- };
-
- mock_setup(&old_state);
+ state->fb = NULL;
- set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
- set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_src(old_state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(state, 0, 0, 1024 << 16, 768 << 16);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 0, "Should have no damage.");
-
- return 0;
+ KUNIT_EXPECT_EQ(test, num_hits, 0);
}
-int igt_damage_iter_simple_damage(void *ignored)
+static void drm_damage_iter_simple_damage(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
- set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
- set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(old_state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(state, 0, 0, 1024 << 16, 768 << 16);
/* Damage set to plane src */
set_damage_clip(&damage, 0, 0, 1024, 768);
set_damage_blob(&damage_blob, &damage, sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return damage when set.");
- FAIL_ON(!check_damage_clip(&state, &clip, 0, 0, 1024, 768));
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return damage when
set.");
+ check_damage_clip(test, state, &clip, 0, 0, 1024, 768);
}
-int igt_damage_iter_single_damage(void *ignored)
+static void drm_damage_iter_single_damage(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
- set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
- set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(old_state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(state, 0, 0, 1024 << 16, 768 << 16);
set_damage_clip(&damage, 256, 192, 768, 576);
set_damage_blob(&damage_blob, &damage, sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return damage when set.");
- FAIL_ON(!check_damage_clip(&state, &clip, 256, 192, 768, 576));
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return damage when
set.");
+ check_damage_clip(test, state, &clip, 256, 192, 768, 576);
}
-int igt_damage_iter_single_damage_intersect_src(void *ignored)
+static void drm_damage_iter_single_damage_intersect_src(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
- set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
- set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(old_state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(state, 0, 0, 1024 << 16, 768 << 16);
/* Damage intersect with plane src. */
set_damage_clip(&damage, 256, 192, 1360, 768);
set_damage_blob(&damage_blob, &damage, sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return damage clipped to src.");
- FAIL_ON(!check_damage_clip(&state, &clip, 256, 192, 1024, 768));
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return damage clipped to
src.");
+ check_damage_clip(test, state, &clip, 256, 192, 1024, 768);
}
-int igt_damage_iter_single_damage_outside_src(void *ignored)
+static void drm_damage_iter_single_damage_outside_src(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
- set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
- set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(old_state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(state, 0, 0, 1024 << 16, 768 << 16);
/* Damage clip outside plane src */
set_damage_clip(&damage, 1360, 1360, 1380, 1380);
set_damage_blob(&damage_blob, &damage, sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 0, "Should have no damage.");
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
}
-int igt_damage_iter_single_damage_fractional_src(void *ignored)
+static void drm_damage_iter_single_damage_fractional_src(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
/* Plane src has fractional part. */
- set_plane_src(&old_state, 0x40002, 0x40002,
+ set_plane_src(old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
- set_plane_src(&state, 0x40002, 0x40002,
+ set_plane_src(state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
set_damage_clip(&damage, 10, 10, 256, 330);
set_damage_blob(&damage_blob, &damage, sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return damage when set.");
- FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 256, 330));
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return damage when
set.");
+ check_damage_clip(test, state, &clip, 10, 10, 256, 330);
}
-int igt_damage_iter_single_damage_intersect_fractional_src(void *ignored)
+static void drm_damage_iter_single_damage_intersect_fractional_src(struct
kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
/* Plane src has fractional part. */
- set_plane_src(&old_state, 0x40002, 0x40002,
+ set_plane_src(old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
- set_plane_src(&state, 0x40002, 0x40002,
+ set_plane_src(state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
/* Damage intersect with plane src. */
set_damage_clip(&damage, 10, 1, 1360, 330);
set_damage_blob(&damage_blob, &damage, sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return damage clipped to rounded off src.");
- FAIL_ON(!check_damage_clip(&state, &clip, 10, 4, 1029, 330));
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return damage clipped to
rounded off src.");
+ check_damage_clip(test, state, &clip, 10, 4, 1029, 330);
}
-int igt_damage_iter_single_damage_outside_fractional_src(void *ignored)
+static void drm_damage_iter_single_damage_outside_fractional_src(struct kunit
*test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
/* Plane src has fractional part. */
- set_plane_src(&old_state, 0x40002, 0x40002,
+ set_plane_src(old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
- set_plane_src(&state, 0x40002, 0x40002,
+ set_plane_src(state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
/* Damage clip outside plane src */
set_damage_clip(&damage, 1360, 1360, 1380, 1380);
set_damage_blob(&damage_blob, &damage, sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 0, "Should have no damage.");
-
- return 0;
+ KUNIT_EXPECT_EQ(test, num_hits, 0);
}
-int igt_damage_iter_single_damage_src_moved(void *ignored)
+static void drm_damage_iter_single_damage_src_moved(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
/* Plane src moved since old plane state. */
- set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
- set_plane_src(&state, 10 << 16, 10 << 16,
+ set_plane_src(old_state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(state, 10 << 16, 10 << 16,
(10 + 1024) << 16, (10 + 768) << 16);
set_damage_clip(&damage, 20, 30, 256, 256);
set_damage_blob(&damage_blob, &damage, sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return plane src as damage.");
- FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 1034, 778));
-
- return 0;
+ KUNIT_EXPECT_EQ(test, num_hits, 1);
+ check_damage_clip(test, state, &clip, 10, 10, 1034, 778);
}
-int igt_damage_iter_single_damage_fractional_src_moved(void *ignored)
+static void drm_damage_iter_single_damage_fractional_src_moved(struct kunit
*test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage;
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
/* Plane src with fractional part moved since old plane state. */
- set_plane_src(&old_state, 0x3fffe, 0x3fffe,
+ set_plane_src(old_state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
- set_plane_src(&state, 0x40002, 0x40002,
+ set_plane_src(state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
/* Damage intersect with plane src. */
set_damage_clip(&damage, 20, 30, 1360, 256);
set_damage_blob(&damage_blob, &damage, sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return rounded off plane src as damage.");
- FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029, 773));
-
- return 0;
+ KUNIT_EXPECT_EQ(test, num_hits, 1);
+ check_damage_clip(test, state, &clip, 4, 4, 1029, 773);
}
-int igt_damage_iter_damage(void *ignored)
+static void drm_damage_iter_damage(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage[2];
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
- set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
- set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(old_state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(state, 0, 0, 1024 << 16, 768 << 16);
/* 2 damage clips. */
set_damage_clip(&damage[0], 20, 30, 200, 180);
set_damage_clip(&damage[1], 240, 200, 280, 250);
set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip) {
if (num_hits == 0)
- FAIL_ON(!check_damage_clip(&state, &clip, 20, 30, 200,
180));
+ check_damage_clip(test, state, &clip, 20, 30, 200, 180);
if (num_hits == 1)
- FAIL_ON(!check_damage_clip(&state, &clip, 240, 200,
280, 250));
+ check_damage_clip(test, state, &clip, 240, 200, 280,
250);
num_hits++;
}
- FAIL(num_hits != 2, "Should return damage when set.");
-
- return 0;
+ KUNIT_EXPECT_EQ(test, num_hits, 2);
}
-int igt_damage_iter_damage_one_intersect(void *ignored)
+static void drm_damage_iter_damage_one_intersect(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage[2];
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
- set_plane_src(&old_state, 0x40002, 0x40002,
+ set_plane_src(old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
- set_plane_src(&state, 0x40002, 0x40002,
+ set_plane_src(state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
/* 2 damage clips, one intersect plane src. */
set_damage_clip(&damage[0], 20, 30, 200, 180);
set_damage_clip(&damage[1], 2, 2, 1360, 1360);
set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip) {
if (num_hits == 0)
- FAIL_ON(!check_damage_clip(&state, &clip, 20, 30, 200,
180));
+ check_damage_clip(test, state, &clip, 20, 30, 200, 180);
if (num_hits == 1)
- FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029,
773));
+ check_damage_clip(test, state, &clip, 4, 4, 1029, 773);
num_hits++;
}
- FAIL(num_hits != 2, "Should return damage when set.");
-
- return 0;
+ KUNIT_EXPECT_EQ(test, num_hits, 2);
}
-int igt_damage_iter_damage_one_outside(void *ignored)
+static void drm_damage_iter_damage_one_outside(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage[2];
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
- set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16);
- set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(old_state, 0, 0, 1024 << 16, 768 << 16);
+ set_plane_src(state, 0, 0, 1024 << 16, 768 << 16);
/* 2 damage clips, one outside plane src. */
set_damage_clip(&damage[0], 1360, 1360, 1380, 1380);
set_damage_clip(&damage[1], 240, 200, 280, 250);
set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return damage when set.");
- FAIL_ON(!check_damage_clip(&state, &clip, 240, 200, 280, 250));
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return damage when
set.");
+ check_damage_clip(test, state, &clip, 240, 200, 280, 250);
}
-int igt_damage_iter_damage_src_moved(void *ignored)
+static void drm_damage_iter_damage_src_moved(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage[2];
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
-
- set_plane_src(&old_state, 0x40002, 0x40002,
+ set_plane_src(old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
- set_plane_src(&state, 0x3fffe, 0x3fffe,
+ set_plane_src(state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
/* 2 damage clips, one outside plane src. */
set_damage_clip(&damage[0], 1360, 1360, 1380, 1380);
set_damage_clip(&damage[1], 240, 200, 280, 250);
set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 1, "Should return round off plane src as damage.");
- FAIL_ON(!check_damage_clip(&state, &clip, 3, 3, 1028, 772));
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return round off plane
src as damage.");
+ check_damage_clip(test, state, &clip, 3, 3, 1028, 772);
}
-int igt_damage_iter_damage_not_visible(void *ignored)
+static void drm_damage_iter_damage_not_visible(struct kunit *test)
{
+ struct drm_damage_mock *mock = test->priv;
+ struct drm_plane_state *old_state = &mock->old_state;
+ struct drm_plane_state *state = &mock->state;
struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob;
struct drm_mode_rect damage[2];
struct drm_rect clip;
uint32_t num_hits = 0;
- MOCK_VARIABLES();
+ state->visible = false;
- state.visible = false;
-
- set_plane_src(&old_state, 0x40002, 0x40002,
+ set_plane_src(old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16));
- set_plane_src(&state, 0x3fffe, 0x3fffe,
+ set_plane_src(state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
/* 2 damage clips, one outside plane src. */
set_damage_clip(&damage[0], 1360, 1360, 1380, 1380);
set_damage_clip(&damage[1], 240, 200, 280, 250);
set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
- set_plane_damage(&state, &damage_blob);
- drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
+ set_plane_damage(state, &damage_blob);
+ drm_atomic_helper_damage_iter_init(&iter, old_state, state);
drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++;
- FAIL(num_hits != 0, "Should not return any damage.");
-
- return 0;
+ KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should not return any damage.");
}
+
+static struct kunit_case drm_damage_helper_tests[] = {
+ KUNIT_CASE(drm_damage_iter_no_damage),
+ KUNIT_CASE(drm_damage_iter_no_damage_fractional_src),
+ KUNIT_CASE(drm_damage_iter_no_damage_src_moved),
+ KUNIT_CASE(drm_damage_iter_no_damage_fractional_src_moved),
+ KUNIT_CASE(drm_damage_iter_no_damage_not_visible),
+ KUNIT_CASE(drm_damage_iter_no_damage_no_crtc),
+ KUNIT_CASE(drm_damage_iter_no_damage_no_fb),
+ KUNIT_CASE(drm_damage_iter_simple_damage),
+ KUNIT_CASE(drm_damage_iter_single_damage),
+ KUNIT_CASE(drm_damage_iter_single_damage_intersect_src),
+ KUNIT_CASE(drm_damage_iter_single_damage_outside_src),
+ KUNIT_CASE(drm_damage_iter_single_damage_fractional_src),
+ KUNIT_CASE(drm_damage_iter_single_damage_intersect_fractional_src),
+ KUNIT_CASE(drm_damage_iter_single_damage_outside_fractional_src),
+ KUNIT_CASE(drm_damage_iter_single_damage_src_moved),
+ KUNIT_CASE(drm_damage_iter_single_damage_fractional_src_moved),
+ KUNIT_CASE(drm_damage_iter_damage),
+ KUNIT_CASE(drm_damage_iter_damage_one_intersect),
+ KUNIT_CASE(drm_damage_iter_damage_one_outside),
+ KUNIT_CASE(drm_damage_iter_damage_src_moved),
+ KUNIT_CASE(drm_damage_iter_damage_not_visible),
+ {}
+};
+
+static struct kunit_suite drm_damage_helper_test_suite = {
+ .name = "drm_damage_helper_tests",
+ .init = drm_damage_test_init,
+ .test_cases = drm_damage_helper_tests,
+};
+
+kunit_test_suite(drm_damage_helper_test_suite);
diff --git a/drivers/gpu/drm/selftests/test-drm_modeset_common.h
b/drivers/gpu/drm/selftests/test-drm_modeset_common.h
index c09f38b791ad..1501d99aee2f 100644
--- a/drivers/gpu/drm/selftests/test-drm_modeset_common.h
+++ b/drivers/gpu/drm/selftests/test-drm_modeset_common.h
@@ -20,27 +20,6 @@ int igt_drm_rect_clip_scaled_div_by_zero(void *ignored);
int igt_drm_rect_clip_scaled_not_clipped(void *ignored);
int igt_drm_rect_clip_scaled_clipped(void *ignored);
int igt_drm_rect_clip_scaled_signed_vs_unsigned(void *ignored);
-int igt_damage_iter_no_damage(void *ignored);
-int igt_damage_iter_no_damage_fractional_src(void *ignored);
-int igt_damage_iter_no_damage_src_moved(void *ignored);
-int igt_damage_iter_no_damage_fractional_src_moved(void *ignored);
-int igt_damage_iter_no_damage_not_visible(void *ignored);
-int igt_damage_iter_no_damage_no_crtc(void *ignored);
-int igt_damage_iter_no_damage_no_fb(void *ignored);
-int igt_damage_iter_simple_damage(void *ignored);
-int igt_damage_iter_single_damage(void *ignored);
-int igt_damage_iter_single_damage_intersect_src(void *ignored);
-int igt_damage_iter_single_damage_outside_src(void *ignored);
-int igt_damage_iter_single_damage_fractional_src(void *ignored);
-int igt_damage_iter_single_damage_intersect_fractional_src(void *ignored);
-int igt_damage_iter_single_damage_outside_fractional_src(void *ignored);
-int igt_damage_iter_single_damage_src_moved(void *ignored);
-int igt_damage_iter_single_damage_fractional_src_moved(void *ignored);
-int igt_damage_iter_damage(void *ignored);
-int igt_damage_iter_damage_one_intersect(void *ignored);
-int igt_damage_iter_damage_one_outside(void *ignored);
-int igt_damage_iter_damage_src_moved(void *ignored);
-int igt_damage_iter_damage_not_visible(void *ignored);
int igt_dp_mst_calc_pbn_mode(void *ignored);
int igt_dp_mst_sideband_msg_req_decode(void *ignored);
--
2.34.1
