Skip to content

L
linux
Commit ba8f16cd authored by Maíra Canal's avatar Maíra Canal Committed by Javier Martinez Canillas
Browse files
Options

drm: selftest: convert drm_damage_helper selftest to KUnit 

Considering the current adoption of the KUnit framework, convert the
DRM damage helper selftest to the KUnit API.
Co-developed-by: default avatarArthur Grillo <arthur.grillo@usp.br>
Signed-off-by: default avatarArthur Grillo <arthur.grillo@usp.br>
Tested-by: default avatarDavid Gow <davidgow@google.com>
Acked-by: default avatarDaniel Latypov <dlatypov@google.com>
Reviewed-by: default avatarJavier Martinez Canillas <javierm@redhat.com>
Signed-off-by: default avatarMaíra Canal <maira.canal@usp.br>
Signed-off-by: default avatarJavier Martinez Canillas <javierm@redhat.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20220708203052.236290-2-maira.canal@usp.br
parent 4d8f6854
Hide whitespace changes
Inline Side-by-side
Showing with 643 additions and 46 deletions
drivers/gpu/drm/Kconfig
View file @ ba8f16cd
...@@ -72,8 +72,14 @@ config DRM_DEBUG_SELFTEST ...@@ -72,8 +72,14 @@ config DRM_DEBUG_SELFTEST
config DRM_KUNIT_TEST config DRM_KUNIT_TEST
tristate "KUnit tests for DRM" if !KUNIT_ALL_TESTS tristate "KUnit tests for DRM" if !KUNIT_ALL_TESTS
depends on DRM && KUNIT=y depends on DRM && KUNIT
select PRIME_NUMBERS
select DRM_DISPLAY_DP_HELPER
select DRM_DISPLAY_HELPER
select DRM_LIB_RANDOM
select DRM_KMS_HELPER select DRM_KMS_HELPER
select DRM_BUDDY
select DRM_EXPORT_FOR_TESTS if m
default KUNIT_ALL_TESTS default KUNIT_ALL_TESTS
help help
This builds unit tests for DRM. This option is not useful for This builds unit tests for DRM. This option is not useful for
......
drivers/gpu/drm/selftests/Makefile
View file @ ba8f16cd
# SPDX-License-Identifier: GPL-2.0-only # SPDX-License-Identifier: GPL-2.0-only
test-drm_modeset-y := test-drm_modeset_common.o test-drm_plane_helper.o \ test-drm_modeset-y := test-drm_modeset_common.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 test-drm_dp_mst_helper.o \ test-drm_dp_mst_helper.o test-drm_rect.o
test-drm_rect.o
obj-$(CONFIG_DRM_DEBUG_SELFTEST) += test-drm_mm.o test-drm_modeset.o test-drm_cmdline_parser.o \ obj-$(CONFIG_DRM_DEBUG_SELFTEST) += test-drm_mm.o test-drm_modeset.o test-drm_cmdline_parser.o \
test-drm_buddy.o test-drm_buddy.o
drivers/gpu/drm/selftests/drm_modeset_selftests.h
View file @ ba8f16cd
...@@ -15,26 +15,5 @@ selftest(check_drm_format_block_width, igt_check_drm_format_block_width) ...@@ -15,26 +15,5 @@ selftest(check_drm_format_block_width, igt_check_drm_format_block_width)
selftest(check_drm_format_block_height, igt_check_drm_format_block_height) selftest(check_drm_format_block_height, igt_check_drm_format_block_height)
selftest(check_drm_format_min_pitch, igt_check_drm_format_min_pitch) selftest(check_drm_format_min_pitch, igt_check_drm_format_min_pitch)
selftest(check_drm_framebuffer_create, igt_check_drm_framebuffer_create) selftest(check_drm_framebuffer_create, igt_check_drm_framebuffer_create)
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_calc_pbn_mode, igt_dp_mst_calc_pbn_mode)
selftest(dp_mst_sideband_msg_req_decode, igt_dp_mst_sideband_msg_req_decode) selftest(dp_mst_sideband_msg_req_decode, igt_dp_mst_sideband_msg_req_decode)
drivers/gpu/drm/selftests/test-drm_modeset_common.h
View file @ ba8f16cd
...@@ -25,27 +25,6 @@ int igt_check_drm_format_block_width(void *ignored); ...@@ -25,27 +25,6 @@ int igt_check_drm_format_block_width(void *ignored);
int igt_check_drm_format_block_height(void *ignored); int igt_check_drm_format_block_height(void *ignored);
int igt_check_drm_format_min_pitch(void *ignored); int igt_check_drm_format_min_pitch(void *ignored);
int igt_check_drm_framebuffer_create(void *ignored); int igt_check_drm_framebuffer_create(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_calc_pbn_mode(void *ignored);
int igt_dp_mst_sideband_msg_req_decode(void *ignored); int igt_dp_mst_sideband_msg_req_decode(void *ignored);
......
drivers/gpu/drm/tests/Makefile
View file @ ba8f16cd
# SPDX-License-Identifier: GPL-2.0 # SPDX-License-Identifier: GPL-2.0
obj-$(CONFIG_DRM_KUNIT_TEST) += drm_format_helper_test.o obj-$(CONFIG_DRM_KUNIT_TEST) += drm_format_helper_test.o drm_damage_helper_test.o
drivers/gpu/drm/selftests/test-drm_damage_helper.c → drivers/gpu/drm/tests/drm_damage_helper_test.c
View file @ ba8f16cd
// SPDX-License-Identifier: GPL-2.0 // SPDX-License-Identifier: GPL-2.0
/* /*
* Test case for drm_damage_helper functions * Test case for drm_damage_helper functions
*
* Copyright (c) 2022 Maíra Canal <mairacanal@riseup.net>
*/ */
#define pr_fmt(fmt) "drm_damage_helper: " fmt #include <kunit/test.h>
#include <drm/drm_damage_helper.h> #include <drm/drm_damage_helper.h>
#include <drm/drm_framebuffer.h> #include <drm/drm_framebuffer.h>
#include <drm/drm_plane.h> #include <drm/drm_plane.h>
#include <drm/drm_drv.h> #include <drm/drm_drv.h>
#include "test-drm_modeset_common.h" struct drm_damage_mock {
struct drm_driver driver;
struct drm_driver mock_driver; struct drm_device device;
static struct drm_device mock_device; struct drm_object_properties obj_props;
static struct drm_object_properties mock_obj_props; struct drm_plane plane;
static struct drm_plane mock_plane; struct drm_property prop;
static struct drm_property mock_prop; struct drm_framebuffer fb;
struct drm_plane_state state;
struct drm_plane_state old_state;
};
static void mock_setup(struct drm_plane_state *state) static int drm_damage_helper_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) mock->fb.width = 2048;
return; mock->fb.height = 2048;
mock->state.crtc = ZERO_SIZE_PTR;
mock->state.fb = &mock->fb;
mock->state.visible = true;
mock->old_state.plane = &mock->plane;
mock->state.plane = &mock->plane;
/* just enough so that drm_plane_enable_fb_damage_clips() works */ /* just enough so that drm_plane_enable_fb_damage_clips() works */
mock_device.driver = &mock_driver; mock->device.driver = &mock->driver;
mock_device.mode_config.prop_fb_damage_clips = &mock_prop; mock->device.mode_config.prop_fb_damage_clips = &mock->prop;
mock_plane.dev = &mock_device; mock->plane.dev = &mock->device;
mock_obj_props.count = 0; mock->obj_props.count = 0;
mock_plane.base.properties = &mock_obj_props; mock->plane.base.properties = &mock->obj_props;
mock_prop.base.id = 1; /* 0 is an invalid id */ mock->prop.base.id = 1; /* 0 is an invalid id */
mock_prop.dev = &mock_device; mock->prop.dev = &mock->device;
drm_plane_enable_fb_damage_clips(&mock_plane); drm_plane_enable_fb_damage_clips(&mock->plane);
test->priv = mock;
return 0;
} }
static void set_plane_src(struct drm_plane_state *state, int x1, int y1, int x2, static void set_plane_src(struct drm_plane_state *state, int x1, int y1, int x2,
...@@ -58,7 +75,7 @@ static void set_damage_clip(struct drm_mode_rect *r, int x1, int y1, int x2, ...@@ -58,7 +75,7 @@ static void set_damage_clip(struct drm_mode_rect *r, int x1, int y1, int x2,
} }
static void set_damage_blob(struct drm_property_blob *damage_blob, static void set_damage_blob(struct drm_property_blob *damage_blob,
struct drm_mode_rect *r, uint32_t size) struct drm_mode_rect *r, u32 size)
{ {
damage_blob->length = size; damage_blob->length = size;
damage_blob->data = r; damage_blob->data = r;
...@@ -70,599 +87,548 @@ static void set_plane_damage(struct drm_plane_state *state, ...@@ -70,599 +87,548 @@ static void set_plane_damage(struct drm_plane_state *state,
state->fb_damage_clips = damage_blob; state->fb_damage_clips = damage_blob;
} }
static bool check_damage_clip(struct drm_plane_state *state, struct drm_rect *r, static void check_damage_clip(struct kunit *test, struct drm_rect *r,
int x1, int y1, int x2, int y2) int x1, int y1, int x2, int y2)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_plane_state state = mock->state;
/* /*
* Round down x1/y1 and round up x2/y2. This is because damage is not in * Round down x1/y1 and round up x2/y2. This is because damage is not in
* 16.16 fixed point so to catch all pixels. * 16.16 fixed point so to catch all pixels.
*/ */
int src_x1 = state->src.x1 >> 16; int src_x1 = state.src.x1 >> 16;
int src_y1 = state->src.y1 >> 16; int src_y1 = state.src.y1 >> 16;
int src_x2 = (state->src.x2 >> 16) + !!(state->src.x2 & 0xFFFF); int src_x2 = (state.src.x2 >> 16) + !!(state.src.x2 & 0xFFFF);
int src_y2 = (state->src.y2 >> 16) + !!(state->src.y2 & 0xFFFF); int src_y2 = (state.src.y2 >> 16) + !!(state.src.y2 & 0xFFFF);
if (x1 >= x2 || y1 >= y2) { if (x1 >= x2 || y1 >= y2)
pr_err("Cannot have damage clip with no dimension.\n"); KUNIT_FAIL(test, "Cannot have damage clip with no dimension.");
return false; if (x1 < src_x1 || y1 < src_y1 || x2 > src_x2 || y2 > src_y2)
} KUNIT_FAIL(test, "Damage cannot be outside rounded plane src.");
if (r->x1 != x1 || r->y1 != y1 || r->x2 != x2 || r->y2 != y2)
if (x1 < src_x1 || y1 < src_y1 || x2 > src_x2 || y2 > src_y2) { KUNIT_FAIL(test, "Damage = %d %d %d %d, want = %d %d %d %d",
pr_err("Damage cannot be outside rounded plane src.\n"); r->x1, r->y1, r->x2, r->y2, x1, y1, x2, y2);
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;
}
return true;
} }
const struct drm_framebuffer fb = { static void igt_damage_iter_no_damage(struct kunit *test)
.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)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
/* Plane src same as fb size. */ /* Plane src same as fb size. */
set_plane_src(&old_state, 0, 0, fb.width << 16, fb.height << 16); set_plane_src(&mock->old_state, 0, 0, mock->fb.width << 16, mock->fb.height << 16);
set_plane_src(&state, 0, 0, fb.width << 16, fb.height << 16); set_plane_src(&mock->state, 0, 0, mock->fb.width << 16, mock->fb.height << 16);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return plane src as damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return plane src as damage.");
FAIL_ON(!check_damage_clip(&state, &clip, 0, 0, 2048, 2048)); check_damage_clip(test, &clip, 0, 0, 2048, 2048);
return 0;
} }
int igt_damage_iter_no_damage_fractional_src(void *ignored) static void igt_damage_iter_no_damage_fractional_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
/* Plane src has fractional part. */ /* Plane src has fractional part. */
set_plane_src(&old_state, 0x3fffe, 0x3fffe, set_plane_src(&mock->old_state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16)); 0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
set_plane_src(&state, 0x3fffe, 0x3fffe, set_plane_src(&mock->state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16)); 0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return rounded off plane src as damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1,
FAIL_ON(!check_damage_clip(&state, &clip, 3, 3, 1028, 772)); "Should return rounded off plane src as damage.");
check_damage_clip(test, &clip, 3, 3, 1028, 772);
return 0;
} }
int igt_damage_iter_no_damage_src_moved(void *ignored) static void igt_damage_iter_no_damage_src_moved(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
/* Plane src moved since old plane state. */ /* Plane src moved since old plane state. */
set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->old_state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&state, 10 << 16, 10 << 16, set_plane_src(&mock->state, 10 << 16, 10 << 16,
(10 + 1024) << 16, (10 + 768) << 16); (10 + 1024) << 16, (10 + 768) << 16);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return plane src as damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return plane src as damage.");
FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 1034, 778)); check_damage_clip(test, &clip, 10, 10, 1034, 778);
return 0;
} }
int igt_damage_iter_no_damage_fractional_src_moved(void *ignored) static void igt_damage_iter_no_damage_fractional_src_moved(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
/* Plane src has fractional part and it moved since old plane state. */ /* Plane src has fractional part and it moved since old plane state. */
set_plane_src(&old_state, 0x3fffe, 0x3fffe, set_plane_src(&mock->old_state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16)); 0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
set_plane_src(&state, 0x40002, 0x40002, set_plane_src(&mock->state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return plane src as damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return plane src as damage.");
FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029, 773)); check_damage_clip(test, &clip, 4, 4, 1029, 773);
return 0;
} }
int igt_damage_iter_no_damage_not_visible(void *ignored) static void igt_damage_iter_no_damage_not_visible(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
state.visible = false;
mock_setup(&old_state); mock->state.visible = false;
set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->old_state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->state, 0, 0, 1024 << 16, 768 << 16);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 0, "Should have no damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
return 0;
} }
int igt_damage_iter_no_damage_no_crtc(void *ignored) static void igt_damage_iter_no_damage_no_crtc(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES(); mock->state.crtc = NULL;
state.crtc = NULL; set_plane_src(&mock->old_state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&mock->state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
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) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 0, "Should have no damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
return 0;
} }
int igt_damage_iter_no_damage_no_fb(void *ignored) static void igt_damage_iter_no_damage_no_fb(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_plane_state old_state;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
struct drm_plane_state state = {
.crtc = ZERO_SIZE_PTR,
.fb = 0,
};
mock_setup(&old_state); mock->state.fb = NULL;
set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->old_state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->state, 0, 0, 1024 << 16, 768 << 16);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 0, "Should have no damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
return 0;
} }
int igt_damage_iter_simple_damage(void *ignored) static void igt_damage_iter_simple_damage(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage; struct drm_mode_rect damage;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->old_state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->state, 0, 0, 1024 << 16, 768 << 16);
/* Damage set to plane src */ /* Damage set to plane src */
set_damage_clip(&damage, 0, 0, 1024, 768); set_damage_clip(&damage, 0, 0, 1024, 768);
set_damage_blob(&damage_blob, &damage, sizeof(damage)); set_damage_blob(&damage_blob, &damage, sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return damage when set."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return damage when set.");
FAIL_ON(!check_damage_clip(&state, &clip, 0, 0, 1024, 768)); check_damage_clip(test, &clip, 0, 0, 1024, 768);
return 0;
} }
int igt_damage_iter_single_damage(void *ignored) static void igt_damage_iter_single_damage(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage; struct drm_mode_rect damage;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->old_state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->state, 0, 0, 1024 << 16, 768 << 16);
set_damage_clip(&damage, 256, 192, 768, 576); set_damage_clip(&damage, 256, 192, 768, 576);
set_damage_blob(&damage_blob, &damage, sizeof(damage)); set_damage_blob(&damage_blob, &damage, sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return damage when set."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return damage when set.");
FAIL_ON(!check_damage_clip(&state, &clip, 256, 192, 768, 576)); check_damage_clip(test, &clip, 256, 192, 768, 576);
return 0;
} }
int igt_damage_iter_single_damage_intersect_src(void *ignored) static void igt_damage_iter_single_damage_intersect_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage; struct drm_mode_rect damage;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->old_state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->state, 0, 0, 1024 << 16, 768 << 16);
/* Damage intersect with plane src. */ /* Damage intersect with plane src. */
set_damage_clip(&damage, 256, 192, 1360, 768); set_damage_clip(&damage, 256, 192, 1360, 768);
set_damage_blob(&damage_blob, &damage, sizeof(damage)); set_damage_blob(&damage_blob, &damage, sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return damage clipped to src."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return damage clipped to src.");
FAIL_ON(!check_damage_clip(&state, &clip, 256, 192, 1024, 768)); check_damage_clip(test, &clip, 256, 192, 1024, 768);
return 0;
} }
int igt_damage_iter_single_damage_outside_src(void *ignored) static void igt_damage_iter_single_damage_outside_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage; struct drm_mode_rect damage;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->old_state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->state, 0, 0, 1024 << 16, 768 << 16);
/* Damage clip outside plane src */ /* Damage clip outside plane src */
set_damage_clip(&damage, 1360, 1360, 1380, 1380); set_damage_clip(&damage, 1360, 1360, 1380, 1380);
set_damage_blob(&damage_blob, &damage, sizeof(damage)); set_damage_blob(&damage_blob, &damage, sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 0, "Should have no damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
return 0;
} }
int igt_damage_iter_single_damage_fractional_src(void *ignored) static void igt_damage_iter_single_damage_fractional_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage; struct drm_mode_rect damage;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
/* Plane src has fractional part. */ /* Plane src has fractional part. */
set_plane_src(&old_state, 0x40002, 0x40002, set_plane_src(&mock->old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
set_plane_src(&state, 0x40002, 0x40002, set_plane_src(&mock->state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
set_damage_clip(&damage, 10, 10, 256, 330); set_damage_clip(&damage, 10, 10, 256, 330);
set_damage_blob(&damage_blob, &damage, sizeof(damage)); set_damage_blob(&damage_blob, &damage, sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return damage when set."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return damage when set.");
FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 256, 330)); check_damage_clip(test, &clip, 10, 10, 256, 330);
return 0;
} }
int igt_damage_iter_single_damage_intersect_fractional_src(void *ignored) static void igt_damage_iter_single_damage_intersect_fractional_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage; struct drm_mode_rect damage;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
/* Plane src has fractional part. */ /* Plane src has fractional part. */
set_plane_src(&old_state, 0x40002, 0x40002, set_plane_src(&mock->old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
set_plane_src(&state, 0x40002, 0x40002, set_plane_src(&mock->state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
/* Damage intersect with plane src. */ /* Damage intersect with plane src. */
set_damage_clip(&damage, 10, 1, 1360, 330); set_damage_clip(&damage, 10, 1, 1360, 330);
set_damage_blob(&damage_blob, &damage, sizeof(damage)); set_damage_blob(&damage_blob, &damage, sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return damage clipped to rounded off src."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1,
FAIL_ON(!check_damage_clip(&state, &clip, 10, 4, 1029, 330)); "Should return damage clipped to rounded off src.");
check_damage_clip(test, &clip, 10, 4, 1029, 330);
return 0;
} }
int igt_damage_iter_single_damage_outside_fractional_src(void *ignored) static void igt_damage_iter_single_damage_outside_fractional_src(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage; struct drm_mode_rect damage;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
/* Plane src has fractional part. */ /* Plane src has fractional part. */
set_plane_src(&old_state, 0x40002, 0x40002, set_plane_src(&mock->old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
set_plane_src(&state, 0x40002, 0x40002, set_plane_src(&mock->state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
/* Damage clip outside plane src */ /* Damage clip outside plane src */
set_damage_clip(&damage, 1360, 1360, 1380, 1380); set_damage_clip(&damage, 1360, 1360, 1380, 1380);
set_damage_blob(&damage_blob, &damage, sizeof(damage)); set_damage_blob(&damage_blob, &damage, sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 0, "Should have no damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should have no damage.");
return 0;
} }
int igt_damage_iter_single_damage_src_moved(void *ignored) static void igt_damage_iter_single_damage_src_moved(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage; struct drm_mode_rect damage;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
/* Plane src moved since old plane state. */ /* Plane src moved since old plane state. */
set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->old_state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&state, 10 << 16, 10 << 16, set_plane_src(&mock->state, 10 << 16, 10 << 16,
(10 + 1024) << 16, (10 + 768) << 16); (10 + 1024) << 16, (10 + 768) << 16);
set_damage_clip(&damage, 20, 30, 256, 256); set_damage_clip(&damage, 20, 30, 256, 256);
set_damage_blob(&damage_blob, &damage, sizeof(damage)); set_damage_blob(&damage_blob, &damage, sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return plane src as damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1,
FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 1034, 778)); "Should return plane src as damage.");
check_damage_clip(test, &clip, 10, 10, 1034, 778);
return 0;
} }
int igt_damage_iter_single_damage_fractional_src_moved(void *ignored) static void igt_damage_iter_single_damage_fractional_src_moved(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage; struct drm_mode_rect damage;
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
/* Plane src with fractional part moved since old plane state. */ /* Plane src with fractional part moved since old plane state. */
set_plane_src(&old_state, 0x3fffe, 0x3fffe, set_plane_src(&mock->old_state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16)); 0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
set_plane_src(&state, 0x40002, 0x40002, set_plane_src(&mock->state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
/* Damage intersect with plane src. */ /* Damage intersect with plane src. */
set_damage_clip(&damage, 20, 30, 1360, 256); set_damage_clip(&damage, 20, 30, 1360, 256);
set_damage_blob(&damage_blob, &damage, sizeof(damage)); set_damage_blob(&damage_blob, &damage, sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return rounded off plane src as damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1,
FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029, 773)); "Should return rounded off plane as damage.");
check_damage_clip(test, &clip, 4, 4, 1029, 773);
return 0;
} }
int igt_damage_iter_damage(void *ignored) static void igt_damage_iter_damage(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage[2]; struct drm_mode_rect damage[2];
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->old_state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->state, 0, 0, 1024 << 16, 768 << 16);
/* 2 damage clips. */ /* 2 damage clips. */
set_damage_clip(&damage[0], 20, 30, 200, 180); set_damage_clip(&damage[0], 20, 30, 200, 180);
set_damage_clip(&damage[1], 240, 200, 280, 250); set_damage_clip(&damage[1], 240, 200, 280, 250);
set_damage_blob(&damage_blob, &damage[0], sizeof(damage)); set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) { drm_atomic_for_each_plane_damage(&iter, &clip) {
if (num_hits == 0) if (num_hits == 0)
FAIL_ON(!check_damage_clip(&state, &clip, 20, 30, 200, 180)); check_damage_clip(test, &clip, 20, 30, 200, 180);
if (num_hits == 1) if (num_hits == 1)
FAIL_ON(!check_damage_clip(&state, &clip, 240, 200, 280, 250)); check_damage_clip(test, &clip, 240, 200, 280, 250);
num_hits++; num_hits++;
} }
FAIL(num_hits != 2, "Should return damage when set."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 2, "Should return damage when set.");
return 0;
} }
int igt_damage_iter_damage_one_intersect(void *ignored) static void igt_damage_iter_damage_one_intersect(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage[2]; struct drm_mode_rect damage[2];
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
set_plane_src(&old_state, 0x40002, 0x40002, set_plane_src(&mock->old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
set_plane_src(&state, 0x40002, 0x40002, set_plane_src(&mock->state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
/* 2 damage clips, one intersect plane src. */ /* 2 damage clips, one intersect plane src. */
set_damage_clip(&damage[0], 20, 30, 200, 180); set_damage_clip(&damage[0], 20, 30, 200, 180);
set_damage_clip(&damage[1], 2, 2, 1360, 1360); set_damage_clip(&damage[1], 2, 2, 1360, 1360);
set_damage_blob(&damage_blob, &damage[0], sizeof(damage)); set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) { drm_atomic_for_each_plane_damage(&iter, &clip) {
if (num_hits == 0) if (num_hits == 0)
FAIL_ON(!check_damage_clip(&state, &clip, 20, 30, 200, 180)); check_damage_clip(test, &clip, 20, 30, 200, 180);
if (num_hits == 1) if (num_hits == 1)
FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029, 773)); check_damage_clip(test, &clip, 4, 4, 1029, 773);
num_hits++; num_hits++;
} }
FAIL(num_hits != 2, "Should return damage when set."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 2, "Should return damage when set.");
return 0;
} }
int igt_damage_iter_damage_one_outside(void *ignored) static void igt_damage_iter_damage_one_outside(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage[2]; struct drm_mode_rect damage[2];
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
set_plane_src(&old_state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->old_state, 0, 0, 1024 << 16, 768 << 16);
set_plane_src(&state, 0, 0, 1024 << 16, 768 << 16); set_plane_src(&mock->state, 0, 0, 1024 << 16, 768 << 16);
/* 2 damage clips, one outside plane src. */ /* 2 damage clips, one outside plane src. */
set_damage_clip(&damage[0], 1360, 1360, 1380, 1380); set_damage_clip(&damage[0], 1360, 1360, 1380, 1380);
set_damage_clip(&damage[1], 240, 200, 280, 250); set_damage_clip(&damage[1], 240, 200, 280, 250);
set_damage_blob(&damage_blob, &damage[0], sizeof(damage)); set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return damage when set."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1, "Should return damage when set.");
FAIL_ON(!check_damage_clip(&state, &clip, 240, 200, 280, 250)); check_damage_clip(test, &clip, 240, 200, 280, 250);
return 0;
} }
int igt_damage_iter_damage_src_moved(void *ignored) static void igt_damage_iter_damage_src_moved(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage[2]; struct drm_mode_rect damage[2];
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
set_plane_src(&old_state, 0x40002, 0x40002, set_plane_src(&mock->old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
set_plane_src(&state, 0x3fffe, 0x3fffe, set_plane_src(&mock->state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16)); 0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
/* 2 damage clips, one outside plane src. */ /* 2 damage clips, one outside plane src. */
set_damage_clip(&damage[0], 1360, 1360, 1380, 1380); set_damage_clip(&damage[0], 1360, 1360, 1380, 1380);
set_damage_clip(&damage[1], 240, 200, 280, 250); set_damage_clip(&damage[1], 240, 200, 280, 250);
set_damage_blob(&damage_blob, &damage[0], sizeof(damage)); set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 1, "Should return round off plane src as damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 1,
FAIL_ON(!check_damage_clip(&state, &clip, 3, 3, 1028, 772)); "Should return round off plane src as damage.");
check_damage_clip(test, &clip, 3, 3, 1028, 772);
return 0;
} }
int igt_damage_iter_damage_not_visible(void *ignored) static void igt_damage_iter_damage_not_visible(struct kunit *test)
{ {
struct drm_damage_mock *mock = test->priv;
struct drm_atomic_helper_damage_iter iter; struct drm_atomic_helper_damage_iter iter;
struct drm_property_blob damage_blob; struct drm_property_blob damage_blob;
struct drm_mode_rect damage[2]; struct drm_mode_rect damage[2];
struct drm_rect clip; struct drm_rect clip;
uint32_t num_hits = 0; u32 num_hits = 0;
MOCK_VARIABLES();
state.visible = false; mock->state.visible = false;
set_plane_src(&old_state, 0x40002, 0x40002, set_plane_src(&mock->old_state, 0x40002, 0x40002,
0x40002 + (1024 << 16), 0x40002 + (768 << 16)); 0x40002 + (1024 << 16), 0x40002 + (768 << 16));
set_plane_src(&state, 0x3fffe, 0x3fffe, set_plane_src(&mock->state, 0x3fffe, 0x3fffe,
0x3fffe + (1024 << 16), 0x3fffe + (768 << 16)); 0x3fffe + (1024 << 16), 0x3fffe + (768 << 16));
/* 2 damage clips, one outside plane src. */ /* 2 damage clips, one outside plane src. */
set_damage_clip(&damage[0], 1360, 1360, 1380, 1380); set_damage_clip(&damage[0], 1360, 1360, 1380, 1380);
set_damage_clip(&damage[1], 240, 200, 280, 250); set_damage_clip(&damage[1], 240, 200, 280, 250);
set_damage_blob(&damage_blob, &damage[0], sizeof(damage)); set_damage_blob(&damage_blob, &damage[0], sizeof(damage));
set_plane_damage(&state, &damage_blob); set_plane_damage(&mock->state, &damage_blob);
drm_atomic_helper_damage_iter_init(&iter, &old_state, &state); drm_atomic_helper_damage_iter_init(&iter, &mock->old_state, &mock->state);
drm_atomic_for_each_plane_damage(&iter, &clip) drm_atomic_for_each_plane_damage(&iter, &clip)
num_hits++; num_hits++;
FAIL(num_hits != 0, "Should not return any damage."); KUNIT_EXPECT_EQ_MSG(test, num_hits, 0, "Should not return any damage.");
return 0;
} }
static struct kunit_case drm_damage_helper_tests[] = {
KUNIT_CASE(igt_damage_iter_no_damage),
KUNIT_CASE(igt_damage_iter_no_damage_fractional_src),
KUNIT_CASE(igt_damage_iter_no_damage_src_moved),
KUNIT_CASE(igt_damage_iter_no_damage_fractional_src_moved),
KUNIT_CASE(igt_damage_iter_no_damage_not_visible),
KUNIT_CASE(igt_damage_iter_no_damage_no_crtc),
KUNIT_CASE(igt_damage_iter_no_damage_no_fb),
KUNIT_CASE(igt_damage_iter_simple_damage),
KUNIT_CASE(igt_damage_iter_single_damage),
KUNIT_CASE(igt_damage_iter_single_damage_intersect_src),
KUNIT_CASE(igt_damage_iter_single_damage_outside_src),
KUNIT_CASE(igt_damage_iter_single_damage_fractional_src),
KUNIT_CASE(igt_damage_iter_single_damage_intersect_fractional_src),
KUNIT_CASE(igt_damage_iter_single_damage_outside_fractional_src),
KUNIT_CASE(igt_damage_iter_single_damage_src_moved),
KUNIT_CASE(igt_damage_iter_single_damage_fractional_src_moved),
KUNIT_CASE(igt_damage_iter_damage),
KUNIT_CASE(igt_damage_iter_damage_one_intersect),
KUNIT_CASE(igt_damage_iter_damage_one_outside),
KUNIT_CASE(igt_damage_iter_damage_src_moved),
KUNIT_CASE(igt_damage_iter_damage_not_visible),
{ }
};
static struct kunit_suite drm_damage_helper_test_suite = {
.name = "drm_damage_helper",
.init = drm_damage_helper_init,
.test_cases = drm_damage_helper_tests,
};
kunit_test_suite(drm_damage_helper_test_suite);
MODULE_LICENSE("GPL");
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7