[PATCH i-g-t v1] tests/intel/kms_fbc_dirty_rect: cleanup the dirty rect tests
Vinod Govindapillai
vinod.govindapillai at intel.com
Fri Mar 7 15:48:54 UTC 2025
These tests rely on FBC is enabled, some FIFO underruns can
disable FBC and can trigger asserts. In case if such asserts
are triggered, we end up not clearing the used fbs and crcs.
Use common functions to prepare and clear igt test parameters
as required for each tests
Signed-off-by: Vinod Govindapillai <vinod.govindapillai at intel.com>
---
tests/intel/kms_fbc_dirty_rect.c | 231 ++++++++++++-------------------
1 file changed, 90 insertions(+), 141 deletions(-)
diff --git a/tests/intel/kms_fbc_dirty_rect.c b/tests/intel/kms_fbc_dirty_rect.c
index ea7a73124..4484355b2 100644
--- a/tests/intel/kms_fbc_dirty_rect.c
+++ b/tests/intel/kms_fbc_dirty_rect.c
@@ -51,6 +51,10 @@
#define SQUARE_OFFSET 100
#define SQUARE_OFFSET_2 600
+#define N_FBS 4
+#define MAIN_FB_IDX 0
+#define DIRTY_RECT_FBS_START_IDX 1
+
typedef struct {
int drm_fd;
int debugfs_fd;
@@ -61,7 +65,7 @@ typedef struct {
enum pipe pipe;
u32 format;
- igt_crc_t ref_crc;
+ struct igt_fb fb[N_FBS];
enum {
FEATURE_NONE = 0,
@@ -73,17 +77,12 @@ typedef struct {
} feature;
} data_t;
-static void set_damage_clip(struct drm_mode_rect *damage, int x1, int y1, int x2, int y2)
+static void set_damage_clip_w(struct drm_mode_rect *damage, int x1, int y1, int width, int height)
{
damage->x1 = x1;
damage->y1 = y1;
- damage->x2 = x2;
- damage->y2 = y2;
-}
-
-static void set_damage_clip_w(struct drm_mode_rect *damage, int x1, int y1, int width, int height)
-{
- set_damage_clip(damage, x1, y1, x1 + width, y1 + height);
+ damage->x2 = x1 + width;
+ damage->y2 = y1 + height;
}
static void dirty_rect_draw_white_rects(data_t *data, struct igt_fb *fb,
@@ -116,16 +115,11 @@ set_damage_area(igt_plane_t *plane, struct drm_mode_rect *rects,
static void
set_fb_and_collect_crc(data_t *data, igt_plane_t *plane, struct igt_fb *fb,
- igt_pipe_crc_t *pipe_crc, igt_crc_t *crc)
+ igt_crc_t *crc)
{
igt_plane_set_fb(plane, fb);
igt_display_commit2(&data->display, COMMIT_ATOMIC);
- if (!data->pipe_crc) {
- data->pipe_crc = igt_pipe_crc_new(data->drm_fd, data->pipe,
- IGT_PIPE_CRC_SOURCE_AUTO);
- }
-
igt_pipe_crc_start(data->pipe_crc);
igt_pipe_crc_get_current(data->drm_fd, data->pipe_crc, crc);
igt_pipe_crc_stop(data->pipe_crc);
@@ -186,52 +180,45 @@ update_rect_with_dirtyfb(data_t *data, struct igt_fb *fb1, struct igt_fb *fb2,
static void fbc_dirty_rectangle_dirtyfb(data_t *data)
{
- igt_pipe_crc_t *pipe_crc = data->pipe_crc;
- igt_display_t *display = &data->display;
- igt_output_t *output = data->output;
igt_plane_t *primary;
- drmModeModeInfo *mode;
- struct igt_fb main_fb, fb2, fb3;
struct drm_mode_rect full_rect, rect1, rect2;
igt_crc_t main_crc, fb2_crc, fb3_crc, crc;
- mode = igt_output_get_mode(output);
- igt_output_set_pipe(output, data->pipe);
- primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
+ primary = igt_output_get_plane_type(data->output, DRM_PLANE_TYPE_PRIMARY);
- set_damage_clip_w(&full_rect, 0, 0, mode->hdisplay, mode->vdisplay);
+ set_damage_clip_w(&full_rect, 0, 0, data->mode->hdisplay, data->mode->vdisplay);
set_damage_clip_w(&rect1, SQUARE_OFFSET, SQUARE_OFFSET, SQUARE_SIZE, SQUARE_SIZE);
set_damage_clip_w(&rect2, SQUARE_OFFSET_2, SQUARE_OFFSET_2, SQUARE_SIZE, SQUARE_SIZE);
igt_create_color_fb(data->drm_fd, data->mode->hdisplay, data->mode->vdisplay,
- data->format, DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &main_fb);
+ data->format, DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &data->fb[MAIN_FB_IDX]);
igt_create_color_fb(data->drm_fd, data->mode->hdisplay, data->mode->vdisplay,
- data->format, DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &fb2);
- dirty_rect_draw_white_rects(data, &fb2, 1, &rect1);
+ data->format, DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &data->fb[1]);
+ dirty_rect_draw_white_rects(data, &data->fb[1], 1, &rect1);
igt_create_color_fb(data->drm_fd, data->mode->hdisplay, data->mode->vdisplay,
- data->format, DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &fb3);
- dirty_rect_draw_white_rects(data, &fb3, 1, &rect2);
+ data->format, DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &data->fb[2]);
+ dirty_rect_draw_white_rects(data, &data->fb[2], 1, &rect2);
/* 1st screen - Empty blue screen */
set_damage_area(primary, &full_rect, sizeof(full_rect));
- set_fb_and_collect_crc(data, primary, &main_fb, pipe_crc, &main_crc);
+ set_fb_and_collect_crc(data, primary, &data->fb[MAIN_FB_IDX], &main_crc);
/* 2nd screen - 1st white rect at 100, 100 - using damage area */
set_damage_area(primary, &rect1, sizeof(rect1));
- set_fb_and_collect_crc(data, primary, &fb2, pipe_crc, &fb2_crc);
+ set_fb_and_collect_crc(data, primary, &data->fb[1], &fb2_crc);
/* 3rd screen - 2nd white rect at 600, 600 - using damage area.
* Now two white rects on screen
*/
set_damage_area(primary, &rect2, sizeof(rect2));
- set_fb_and_collect_crc(data, primary, &fb3, pipe_crc, &fb3_crc);
+ set_fb_and_collect_crc(data, primary, &data->fb[2], &fb3_crc);
/* 4th screen - clear the 2nd white rect at 600,600 with dirtyfb.
* Copy rect2 area from main_fb to fb3.
*/
- update_rect_with_dirtyfb(data, &main_fb, &fb3, &rect2);
+ update_rect_with_dirtyfb(data, &data->fb[MAIN_FB_IDX], &data->fb[2], &rect2);
/* Now the screen must match 1st screen - with whole blue */
igt_pipe_crc_collect_crc(data->pipe_crc, &crc);
igt_assert_crc_equal(&crc, &main_crc);
@@ -239,21 +226,10 @@ static void fbc_dirty_rectangle_dirtyfb(data_t *data)
/* 5th screen - Copy the first rect at 100,100 with dirtyfb.
* Copy rect1 area from fb2 to fb3.
*/
- update_rect_with_dirtyfb(data, &fb2, &fb3, &rect1);
+ update_rect_with_dirtyfb(data, &data->fb[1], &data->fb[2], &rect1);
/* Now the screen must match 2nd screen - with one rect at 100,100 */
igt_pipe_crc_collect_crc(data->pipe_crc, &crc);
igt_assert_crc_equal(&crc, &fb2_crc);
-
- igt_plane_set_fb(primary, NULL);
- igt_remove_fb(data->drm_fd, &main_fb);
- igt_remove_fb(data->drm_fd, &fb2);
- igt_remove_fb(data->drm_fd, &fb3);
- igt_display_commit2(display, COMMIT_ATOMIC);
-
- if (data->pipe_crc) {
- igt_pipe_crc_free(data->pipe_crc);
- data->pipe_crc = NULL;
- }
}
/**
@@ -270,56 +246,43 @@ static void fbc_dirty_rectangle_dirtyfb(data_t *data)
*/
static void fbc_dirty_rectangle_outside_visible_region(data_t *data)
{
- igt_pipe_crc_t *pipe_crc = data->pipe_crc;
- igt_display_t *display = &data->display;
- igt_output_t *output = data->output;
igt_plane_t *primary;
- struct igt_fb main_fb, rect_fb[3];
- struct drm_mode_rect rect[3], full_rect;
- igt_crc_t main_crc, rect_crc[3];
+ struct drm_mode_rect rect[N_FBS];
+ igt_crc_t rect_crc[N_FBS];
- igt_output_set_pipe(output, data->pipe);
- primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
+ primary = igt_output_get_plane_type(data->output, DRM_PLANE_TYPE_PRIMARY);
+
+ set_damage_clip_w(&rect[0], 0, 0, data->mode->hdisplay + 200, data->mode->vdisplay + 200);
- set_damage_clip(&full_rect, 0, 0, data->mode->hdisplay + 200, data->mode->vdisplay + 200);
/* Rect Horizontally outside visible region */
- set_damage_clip_w(&rect[0], data->mode->hdisplay + 10, 100, SQUARE_SIZE, SQUARE_SIZE);
+ set_damage_clip_w(&rect[1], data->mode->hdisplay + 10, 100, SQUARE_SIZE, SQUARE_SIZE);
+
/* Rect vertically outside visible region */
- set_damage_clip_w(&rect[1], 10, data->mode->vdisplay + 50, SQUARE_SIZE, SQUARE_SIZE);
+ set_damage_clip_w(&rect[2], 10, data->mode->vdisplay + 50, SQUARE_SIZE, SQUARE_SIZE);
+
/* Rect Horizontally and vertically outside visible region */
- set_damage_clip_w(&rect[2], data->mode->hdisplay + 10, data->mode->vdisplay + 50,
+ set_damage_clip_w(&rect[3], data->mode->hdisplay + 10, data->mode->vdisplay + 50,
SQUARE_SIZE, SQUARE_SIZE);
igt_create_color_fb(data->drm_fd, data->mode->hdisplay + 200,
data->mode->vdisplay + 200, data->format,
- DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0, &main_fb);
+ DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0, &data->fb[MAIN_FB_IDX]);
- for (int i = 0; i < 3; i++) {
+ for (int i = DIRTY_RECT_FBS_START_IDX; i < N_FBS; i++) {
igt_create_color_fb(data->drm_fd, data->mode->hdisplay + 200,
data->mode->vdisplay + 200, data->format,
- DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0, &rect_fb[i]);
- dirty_rect_draw_white_rects(data, &rect_fb[i], 1, &rect[i]);
+ DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0, &data->fb[i]);
+ dirty_rect_draw_white_rects(data, &data->fb[i], 1, &rect[i]);
}
/* Main rect */
- set_damage_area(primary, &full_rect, sizeof(full_rect));
- set_fb_and_collect_crc(data, primary, &main_fb, pipe_crc, &main_crc);
+ set_damage_area(primary, &rect[MAIN_FB_IDX], sizeof(rect[MAIN_FB_IDX]));
+ set_fb_and_collect_crc(data, primary, &data->fb[MAIN_FB_IDX], &rect_crc[MAIN_FB_IDX]);
- for (int i = 0; i < 3; i++) {
+ for (int i = DIRTY_RECT_FBS_START_IDX; i < N_FBS; i++) {
set_damage_area(primary, &rect[i], sizeof(rect[i]));
- set_fb_and_collect_crc(data, primary, &rect_fb[i], pipe_crc, &rect_crc[i]);
- igt_assert_crc_equal(&rect_crc[i], &main_crc);
- }
-
- igt_plane_set_fb(primary, NULL);
- igt_remove_fb(data->drm_fd, &main_fb);
- for (int i = 0; i < 3; i++)
- igt_remove_fb(data->drm_fd, &rect_fb[i]);
- igt_display_commit2(display, COMMIT_ATOMIC);
-
- if (data->pipe_crc) {
- igt_pipe_crc_free(data->pipe_crc);
- data->pipe_crc = NULL;
+ set_fb_and_collect_crc(data, primary, &data->fb[i], &rect_crc[i]);
+ igt_assert_crc_equal(&rect_crc[i], &rect_crc[MAIN_FB_IDX]);
}
}
@@ -359,115 +322,119 @@ static void fbc_dirty_rectangle_outside_visible_region(data_t *data)
*/
static void fbc_dirty_rectangle_basic(data_t *data)
{
- igt_display_t *display = &data->display;
- igt_output_t *output = data->output;
igt_plane_t *primary;
- struct igt_fb main_fb;
- struct igt_fb rect_1_fb;
- struct igt_fb rect_2_fb;
- struct igt_fb rect_combined_fb;
struct drm_mode_rect rect1;
struct drm_mode_rect rect2;
struct drm_mode_rect rect_combined[2];
struct drm_mode_rect full_rect;
igt_crc_t main_fb_crc, rect_1_fb_crc, rect_2_fb_crc, rect_combined_fb_crc, crc;
- igt_output_set_pipe(output, data->pipe);
- primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
+ primary = igt_output_get_plane_type(data->output, DRM_PLANE_TYPE_PRIMARY);
- set_damage_clip(&full_rect, 0, 0, data->mode->hdisplay-1, data->mode->vdisplay-1);
- set_damage_clip(&rect1, SQUARE_OFFSET, SQUARE_OFFSET, SQUARE_OFFSET + SQUARE_SIZE,
- SQUARE_OFFSET + SQUARE_SIZE);
- set_damage_clip(&rect2, SQUARE_OFFSET_2, SQUARE_OFFSET_2, SQUARE_OFFSET_2 + SQUARE_SIZE,
- SQUARE_OFFSET_2 + SQUARE_SIZE);
- set_damage_clip(&rect_combined[0], rect1.x1, rect1.y1, rect1.x2, rect1.y2);
- set_damage_clip(&rect_combined[1], rect2.x1, rect2.y1, rect2.x2, rect2.y2);
+ set_damage_clip_w(&full_rect, 0, 0, data->mode->hdisplay, data->mode->vdisplay);
+ set_damage_clip_w(&rect1, SQUARE_OFFSET, SQUARE_OFFSET, SQUARE_SIZE, SQUARE_SIZE);
+ set_damage_clip_w(&rect2, SQUARE_OFFSET_2, SQUARE_OFFSET_2, SQUARE_SIZE, SQUARE_SIZE);
+ rect_combined[0] = rect1;
+ rect_combined[1] = rect2;
igt_create_color_fb(data->drm_fd, data->mode->hdisplay, data->mode->vdisplay, data->format,
- DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &main_fb);
+ DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &data->fb[MAIN_FB_IDX]);
igt_create_color_fb(data->drm_fd, data->mode->hdisplay, data->mode->vdisplay, data->format,
- DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &rect_1_fb);
- dirty_rect_draw_white_rects(data, &rect_1_fb, 1, &rect1);
+ DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &data->fb[1]);
+ dirty_rect_draw_white_rects(data, &data->fb[1], 1, &rect1);
igt_create_color_fb(data->drm_fd, data->mode->hdisplay, data->mode->vdisplay, data->format,
- DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &rect_2_fb);
- dirty_rect_draw_white_rects(data, &rect_2_fb, 1, &rect2);
+ DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &data->fb[2]);
+ dirty_rect_draw_white_rects(data, &data->fb[2], 1, &rect2);
igt_create_color_fb(data->drm_fd, data->mode->hdisplay, data->mode->vdisplay, data->format,
- DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &rect_combined_fb);
- dirty_rect_draw_white_rects(data, &rect_combined_fb, ARRAY_SIZE(rect_combined),
+ DRM_FORMAT_MOD_LINEAR, 0.0, 0.0, 1.0, &data->fb[3]);
+ dirty_rect_draw_white_rects(data, &data->fb[3], ARRAY_SIZE(rect_combined),
rect_combined);
/* main_fb blank blue screen - get and store crc */
- set_fb_and_collect_crc(data, primary, &main_fb, data->pipe_crc, &main_fb_crc);
+ set_fb_and_collect_crc(data, primary, &data->fb[MAIN_FB_IDX], &main_fb_crc);
/* Whole blue screen with one white rect and collect crc */
set_damage_area(primary, &full_rect, sizeof(full_rect));
- set_fb_and_collect_crc(data, primary, &rect_1_fb, data->pipe_crc, &rect_1_fb_crc);
+ set_fb_and_collect_crc(data, primary, &data->fb[1], &rect_1_fb_crc);
/* Second white rect and collect crc */
set_damage_area(primary, &full_rect, sizeof(full_rect));
- set_fb_and_collect_crc(data, primary, &rect_2_fb, data->pipe_crc, &rect_2_fb_crc);
+ set_fb_and_collect_crc(data, primary, &data->fb[2], &rect_2_fb_crc);
/* Both rects and collect crc */
set_damage_area(primary, &full_rect, sizeof(full_rect));
- set_fb_and_collect_crc(data, primary, &rect_combined_fb, data->pipe_crc,
- &rect_combined_fb_crc);
+ set_fb_and_collect_crc(data, primary, &data->fb[3], &rect_combined_fb_crc);
/* Put full blank screen back */
set_damage_area(primary, &full_rect, sizeof(full_rect));
- set_fb_and_collect_crc(data, primary, &main_fb, data->pipe_crc, &crc);
+ set_fb_and_collect_crc(data, primary, &data->fb[MAIN_FB_IDX], &crc);
igt_assert_crc_equal(&crc, &main_fb_crc);
/* Set combined rect - draw two white rects using damage area */
set_damage_area(primary, rect_combined, sizeof(rect_combined));
- set_fb_and_collect_crc(data, primary, &rect_combined_fb, data->pipe_crc, &crc);
+ set_fb_and_collect_crc(data, primary, &data->fb[3], &crc);
igt_assert_crc_equal(&crc, &rect_combined_fb_crc);
/* Clear first rect using damage area. Only the second rect should be visible here! */
set_damage_area(primary, &rect1, sizeof(rect1));
- set_fb_and_collect_crc(data, primary, &main_fb, data->pipe_crc, &crc);
+ set_fb_and_collect_crc(data, primary, &data->fb[MAIN_FB_IDX], &crc);
igt_assert_crc_equal(&crc, &rect_2_fb_crc);
/* Clear the second rect as well. Now back to original blank screen */
set_damage_area(primary, &rect2, sizeof(rect2));
- set_fb_and_collect_crc(data, primary, &main_fb, data->pipe_crc, &crc);
+ set_fb_and_collect_crc(data, primary, &data->fb[MAIN_FB_IDX], &crc);
igt_assert_crc_equal(&crc, &main_fb_crc);
+}
- igt_plane_set_fb(primary, NULL);
- igt_remove_fb(data->drm_fd, &main_fb);
- igt_remove_fb(data->drm_fd, &rect_1_fb);
- igt_remove_fb(data->drm_fd, &rect_2_fb);
- igt_remove_fb(data->drm_fd, &rect_combined_fb);
- igt_display_commit2(display, COMMIT_ATOMIC);
+static void cleanup(data_t *data)
+{
+ igt_remove_fb(data->drm_fd, &data->fb[0]);
+ igt_remove_fb(data->drm_fd, &data->fb[1]);
+ igt_remove_fb(data->drm_fd, &data->fb[2]);
+ igt_remove_fb(data->drm_fd, &data->fb[3]);
- if (data->pipe_crc) {
- igt_pipe_crc_free(data->pipe_crc);
- data->pipe_crc = NULL;
- }
+ igt_pipe_crc_free(data->pipe_crc);
+
+ igt_output_set_pipe(data->output, PIPE_NONE);
+
+ igt_display_commit2(&data->display, COMMIT_ATOMIC);
}
-static void prepare_test(data_t *data, igt_output_t *output)
+static bool prepare_test(data_t *data)
{
+ igt_display_reset(&data->display);
+
+ data->mode = igt_output_get_mode(data->output);
+ igt_output_set_pipe(data->output, data->pipe);
+ data->pipe_crc = igt_pipe_crc_new(data->drm_fd, data->pipe,
+ IGT_PIPE_CRC_SOURCE_AUTO);
+
igt_require_f(intel_fbc_supported_on_chipset(data->drm_fd, data->pipe),
"FBC not supported by the chipset on pipe\n");
if (psr_sink_support(data->drm_fd, data->debugfs_fd, PSR_MODE_1, NULL) ||
- psr_sink_support(data->drm_fd, data->debugfs_fd, PSR_MODE_2, NULL) ||
- psr_sink_support(data->drm_fd, data->debugfs_fd, PR_MODE, NULL)) {
+ psr_sink_support(data->drm_fd, data->debugfs_fd, PSR_MODE_2, NULL) ||
+ psr_sink_support(data->drm_fd, data->debugfs_fd, PR_MODE, NULL)) {
igt_info("PSR is supported by the sink. Disabling PSR to test Dirty FBC functionality.\n");
- psr_disable(data->drm_fd, data->debugfs_fd, output);
+ psr_disable(data->drm_fd, data->debugfs_fd, data->output);
}
if (data->feature & FEATURE_FBC)
intel_fbc_enable(data->drm_fd);
+
+ return intel_pipe_output_combo_valid(&data->display);
}
static void fbc_dirty_rectangle_test(data_t *data, void (*test_func)(data_t *))
{
- prepare_test(data, data->output);
+ if (!prepare_test(data))
+ return;
+
test_func(data);
+ cleanup(data);
}
igt_main
@@ -491,13 +458,7 @@ igt_main
for_each_pipe(&data.display, data.pipe) {
for_each_valid_output_on_pipe(&data.display, data.pipe, data.output) {
- data.mode = igt_output_get_mode(data.output);
data.format = DRM_FORMAT_XRGB8888;
- igt_display_reset(&data.display);
- igt_output_set_pipe(data.output, data.pipe);
-
- if (!intel_pipe_output_combo_valid(&data.display))
- continue;
igt_dynamic_f("pipe-%s-%s",
kmstest_pipe_name(data.pipe),
@@ -514,13 +475,7 @@ igt_main
for_each_pipe(&data.display, data.pipe) {
for_each_valid_output_on_pipe(&data.display, data.pipe, data.output) {
- data.mode = igt_output_get_mode(data.output);
data.format = DRM_FORMAT_XRGB8888;
- igt_display_reset(&data.display);
- igt_output_set_pipe(data.output, data.pipe);
-
- if (!intel_pipe_output_combo_valid(&data.display))
- continue;
igt_dynamic_f("pipe-%s-%s",
kmstest_pipe_name(data.pipe),
@@ -540,12 +495,6 @@ igt_main
for_each_pipe(&data.display, data.pipe) {
for_each_valid_output_on_pipe(&data.display, data.pipe, data.output) {
- data.mode = igt_output_get_mode(data.output);
- igt_display_reset(&data.display);
- igt_output_set_pipe(data.output, data.pipe);
-
- if (!intel_pipe_output_combo_valid(&data.display))
- continue;
for (int i = 0; i < num_formats; i++) {
igt_dynamic_f("pipe-%s-%s-format-%s",
--
2.43.0
More information about the igt-dev
mailing list