Skip to contentSkip to conversation

Revert Color patches

PATCH In review Bhanuprakash Modem 5 participants 16 messages Sep 22, 2022 – Sep 25, 2022

lore
Share & tools
lore
#0 lore raw

v2 cover Revert Color patches

As we are suspecting dynamic subtests are causing regression, revert all the way back to before the dynamic subtest conversion.

Bhanuprakash Modem (8):
Revert "tests/kms_color: fix crc assert condition" Revert "tests/kms: Fix to use max_bpc constraint helper" Revert "tests/kms_color: Fix multiple failures in deep-color tests" Revert "tests/kms_color: Fix memory leaks"
Revert "tests/kms_color: Test Cleanup"
Revert "tests/kms_color: Convert tests to dynamic" Revert "tests/kms_color_chamelium: Convert tests to dynamic" tests/kms_color: Fix crc compare check in CTM tests

 tests/chamelium/kms_color_chamelium.c | 1034 +++++++++++++------------
 tests/kms_color.c                     |  665 ++++++++--------
 tests/kms_color_helper.h              |    2 -
 tests/kms_dither.c                    |   25 +-
 tests/kms_hdr.c                       |   44 +-
 5 files changed, 908 insertions(+), 862 deletions(-)

--
2.37.3

#1 lore raw

PATCH v2 1/8 Revert "tests/kms_color: fix crc assert condition"

This reverts commit c27dcb9e0baca05abce8527c245b513f7a8f1059.

---
 tests/kms_color.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
tests/kms_color.c +4 -4
index ab285af8..c202547e 100644
@@ -99,7 +99,7 @@ static bool test_pipe_degamma(data_t *data,
 	 * Verify that the CRC of the software computed output is
 	 * equal to the CRC of the degamma LUT transformation output.
 	 */
-	ret = igt_skip_crc_compare || igt_check_crc_equal(&crc_fullgamma, &crc_fullcolors);
+	ret = !igt_skip_crc_compare || igt_check_crc_equal(&crc_fullgamma, &crc_fullcolors);
 
 	disable_degamma(primary->pipe);
 	igt_plane_set_fb(primary, NULL);
@@ -188,7 +188,7 @@ static bool test_pipe_gamma(data_t *data,
 	 * Verify that the CRC of the software computed output is
 	 * equal to the CRC of the gamma LUT transformation output.
 	 */
-	ret = igt_skip_crc_compare || igt_check_crc_equal(&crc_fullgamma, &crc_fullcolors);
+	ret = !igt_skip_crc_compare || igt_check_crc_equal(&crc_fullgamma, &crc_fullcolors);
 
 	disable_gamma(primary->pipe);
 	igt_plane_set_fb(primary, NULL);
@@ -289,7 +289,7 @@ static bool test_pipe_legacy_gamma(data_t *data,
 	 * Verify that the CRC of the software computed output is
 	 * equal to the CRC of the gamma LUT transformation output.
 	 */
-	ret = igt_skip_crc_compare || igt_check_crc_equal(&crc_fullgamma, &crc_fullcolors);
+	ret = !igt_skip_crc_compare || igt_check_crc_equal(&crc_fullgamma, &crc_fullcolors);
 
 	/* Reset output. */
 	for (i = 1; i < legacy_lut_size; i++)
@@ -534,7 +534,7 @@ static bool test_pipe_ctm(data_t *data,
 	 * Verify that the CRC of the software computed output is
 	 * equal to the CRC of the CTM matrix transformation output.
 	 */
-	ret &= igt_skip_crc_compare || igt_check_crc_equal(&crc_software, &crc_hardware);
+	ret &= !igt_skip_crc_compare || igt_check_crc_equal(&crc_software, &crc_hardware);
 
 	igt_plane_set_fb(primary, NULL);
 	igt_output_set_pipe(output, PIPE_NONE);
Signature · 1 line
2.37.3
#2 lore raw

PATCH v2 2/8 Revert "tests/kms: Fix to use max_bpc constraint helper"

In reply to Bhanuprakash Modem

This reverts commit a37df4b538ae7b5bb1bb47be4804b4787410325d.

---
 tests/kms_color.c  | 24 +++++++++++++++++++++++-
 tests/kms_dither.c | 25 ++++++++++++++++++++++++-
 tests/kms_hdr.c    | 44 +++++++++++++++++++++++++++++---------------
 3 files changed, 76 insertions(+), 17 deletions(-)
tests/kms_color.c +23 -1
index c202547e..8c15c7be 100644
@@ -660,6 +660,28 @@ static void test_pipe_limited_range_ctm(data_t *data,
 }
 #endif
 
+static bool i915_clock_constraint(data_t *data, enum pipe pipe, int bpc)
+{
+	igt_output_t *output = data->output;
+	drmModeConnector *connector = output->config.connector;
+
+	igt_sort_connector_modes(connector, sort_drm_modes_by_clk_dsc);
+
+	for_each_connector_mode(output) {
+		igt_output_override_mode(output, &connector->modes[j__]);
+		igt_display_commit_atomic(&data->display, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+
+		if (!igt_check_output_bpc_equal(data->drm_fd, pipe,
+						data->output->name, bpc))
+			continue;
+
+		return true;
+	}
+
+	igt_output_override_mode(output, NULL);
+	return false;
+}
+
 static void
 prep_pipe(data_t *data, enum pipe p)
 {
@@ -823,7 +845,7 @@ run_deep_color_tests_for_pipe(data_t *data, enum pipe p)
 		igt_display_commit_atomic(&data->display, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
 
 		if (is_i915_device(data->drm_fd) &&
-		    !igt_max_bpc_constraint(&data->display, p, output, 10))
+		    !i915_clock_constraint(data, p, 10))
 			continue;
 
 		data->color_depth = 10;
tests/kms_dither.c +24 -1
index 43a25e20..3a44e797 100644
@@ -97,6 +97,29 @@ static dither_status_t get_dither_state(data_t *data, enum pipe pipe)
 	return status;
 }
 
+static bool i915_clock_constraint(data_t *data, enum pipe pipe,
+				  igt_output_t *output, int bpc)
+{
+	drmModeConnector *connector = output->config.connector;
+	igt_display_t *display = &data->display;
+
+	igt_sort_connector_modes(connector, sort_drm_modes_by_clk_dsc);
+
+	for_each_connector_mode(output) {
+		igt_output_override_mode(output, &connector->modes[j__]);
+		igt_display_commit2(display, display->is_atomic ? COMMIT_ATOMIC : COMMIT_LEGACY);
+
+		if (!igt_check_output_bpc_equal(data->drm_fd, pipe,
+						output->name, bpc))
+			continue;
+
+		return true;
+	}
+
+	igt_output_override_mode(output, NULL);
+	return false;
+}
+
 static void test_dithering(data_t *data, enum pipe pipe,
 			   igt_output_t *output,
 			   int fb_bpc, int fb_format,
@@ -129,7 +152,7 @@ static void test_dithering(data_t *data, enum pipe pipe,
 	if (ret)
 		goto cleanup;
 
-	constraint = igt_max_bpc_constraint(display, pipe, output, output_bpc);
+	constraint = i915_clock_constraint(data, pipe, output, output_bpc);
 	if (!constraint)
 		goto cleanup;
 
tests/kms_hdr.c +29 -15

70 lines not on this page · raw message

Signature · 1 line
2.37.3
#3 lore raw

PATCH v2 3/8 Revert "tests/kms_color: Fix multiple failures in deep-color tests"

In reply to Bhanuprakash Modem

This reverts commit 333ca8f6be43044d71ecf15d37a3e88e7a3ce821.

---
 tests/kms_color.c | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)
tests/kms_color.c +1 -7
index 8c15c7be..6ea721f1 100644
@@ -839,7 +839,6 @@ run_deep_color_tests_for_pipe(data_t *data, enum pipe p)
 		if (!panel_supports_deep_color(data->drm_fd, output->name))
 			continue;
 
-		igt_display_reset(&data->display);
 		igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, 10);
 		igt_output_set_pipe(output, p);
 		igt_display_commit_atomic(&data->display, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
@@ -851,10 +850,7 @@ run_deep_color_tests_for_pipe(data_t *data, enum pipe p)
 		data->color_depth = 10;
 		data->drm_format = DRM_FORMAT_XRGB2101010;
 		data->output = output;
-
-		data->mode = malloc(sizeof(drmModeModeInfo));
-		igt_assert(data->mode);
-		memcpy(data->mode, igt_output_get_mode(data->output), sizeof(drmModeModeInfo));
+		data->mode = igt_output_get_mode(data->output);
 
 		igt_dynamic_f("pipe-%s-%s-gamma", kmstest_pipe_name(p), output->name) {
 			igt_display_reset(&data->display);
@@ -888,8 +884,6 @@ run_deep_color_tests_for_pipe(data_t *data, enum pipe p)
 			igt_assert(ret);
 		}
 
-		free(data->mode);
-
 		break;
 	}
 
Signature · 1 line
2.37.3
#4 lore raw

PATCH v2 4/8 Revert "tests/kms_color: Fix memory leaks"

In reply to Bhanuprakash Modem

This reverts commit cd21565a5fffc451e2cae5f1a0fe20104dc2a2cf.

---
 tests/kms_color.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)
tests/kms_color.c +1 -10
index 6ea721f1..0b03fb9a 100644
@@ -397,13 +397,8 @@ static bool test_pipe_legacy_gamma_reset(data_t *data,
 	drmModeFreeCrtc(kms_crtc);
 
 	red_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
-	igt_assert(red_lut);
-
 	green_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
-	igt_assert(green_lut);
-
 	blue_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
-	igt_assert(blue_lut);
 
 	for (i = 0; i < legacy_lut_size; i++)
 		red_lut[i] = green_lut[i] = blue_lut[i] = 0xffff;
@@ -432,17 +427,13 @@ static bool test_pipe_legacy_gamma_reset(data_t *data,
 			   lut[i].blue == 0xffff);
 	drmModeFreePropertyBlob(blob);
 
-	free(red_lut);
-	free(green_lut);
-	free(blue_lut);
-
-end:
 	igt_plane_set_fb(primary, NULL);
 	igt_output_set_pipe(output, PIPE_NONE);
 	igt_display_commit(&data->display);
 
 	free_lut(degamma_linear);
 	free_lut(gamma_zero);
+end:
 	return ret;
 }
 
Signature · 1 line
2.37.3
#5 lore raw

PATCH v2 5/8 Revert "tests/kms_color: Test Cleanup"

In reply to Bhanuprakash Modem

This reverts commit 1a3ffecd400b8f82c35745fa2e07992f6bdeede2.

---
 tests/kms_color.c        | 96 ++++++++++++++++------------------------
 tests/kms_color_helper.h |  1 -
 2 files changed, 39 insertions(+), 58 deletions(-)
tests/kms_color.c +39 -57
index 0b03fb9a..85f3b32d 100644
@@ -37,7 +37,7 @@ static bool test_pipe_degamma(data_t *data,
 		{ 0.0, 1.0, 0.0 },
 		{ 0.0, 0.0, 1.0 }
 	};
-	drmModeModeInfo *mode = data->mode;
+	drmModeModeInfo *mode;
 	struct igt_fb fb_modeset, fb;
 	igt_crc_t crc_fullgamma, crc_fullcolors;
 	int fb_id, fb_modeset_id;
@@ -50,7 +50,7 @@ static bool test_pipe_degamma(data_t *data,
 	degamma_full = generate_table_max(data->degamma_lut_size);
 
 	igt_output_set_pipe(output, primary->pipe->pipe);
-	igt_output_override_mode(output, mode);
+	mode = igt_output_get_mode(output);
 
 	/* Create a framebuffer at the size of the output. */
 	fb_id = igt_create_fb(data->drm_fd,
@@ -83,8 +83,7 @@ static bool test_pipe_degamma(data_t *data,
 			    display->pipes[primary->pipe->pipe].crtc_offset);
 	igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors);
 
-	/*
-	 * Draw a gradient with degamma LUT to remap all
+	/* Draw a gradient with degamma LUT to remap all
 	 * values to max red/green/blue.
 	 */
 	paint_gradient_rectangles(data, mode, red_green_blue, &fb);
@@ -95,8 +94,7 @@ static bool test_pipe_degamma(data_t *data,
 			    display->pipes[primary->pipe->pipe].crtc_offset);
 	igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma);
 
-	/*
-	 * Verify that the CRC of the software computed output is
+	/* Verify that the CRC of the software computed output is
 	 * equal to the CRC of the degamma LUT transformation output.
 	 */
 	ret = !igt_skip_crc_compare || igt_check_crc_equal(&crc_fullgamma, &crc_fullcolors);
@@ -129,7 +127,7 @@ static bool test_pipe_gamma(data_t *data,
 		{ 0.0, 1.0, 0.0 },
 		{ 0.0, 0.0, 1.0 }
 	};
-	drmModeModeInfo *mode = data->mode;
+	drmModeModeInfo *mode;
 	struct igt_fb fb_modeset, fb;
 	igt_crc_t crc_fullgamma, crc_fullcolors;
 	int fb_id, fb_modeset_id;
@@ -140,7 +138,7 @@ static bool test_pipe_gamma(data_t *data,
 	gamma_full = generate_table_max(data->gamma_lut_size);
 
 	igt_output_set_pipe(output, primary->pipe->pipe);
-	igt_output_override_mode(output, mode);
+	mode = igt_output_get_mode(output);
 
 	/* Create a framebuffer at the size of the output. */
 	fb_id = igt_create_fb(data->drm_fd,
@@ -173,8 +171,7 @@ static bool test_pipe_gamma(data_t *data,
 			    display->pipes[primary->pipe->pipe].crtc_offset);
 	igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors);
 
-	/*
-	 * Draw a gradient with gamma LUT to remap all values
+	/* Draw a gradient with gamma LUT to remap all values
 	 * to max red/green/blue.
 	 */
 	paint_gradient_rectangles(data, mode, red_green_blue, &fb);
@@ -184,8 +181,7 @@ static bool test_pipe_gamma(data_t *data,
 			    display->pipes[primary->pipe->pipe].crtc_offset);
 	igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma);
 
-	/*
-	 * Verify that the CRC of the software computed output is
+	/* Verify that the CRC of the software computed output is
 	 * equal to the CRC of the gamma LUT transformation output.
 	 */
 	ret = !igt_skip_crc_compare || igt_check_crc_equal(&crc_fullgamma, &crc_fullcolors);
@@ -210,7 +206,7 @@ static bool test_pipe_gamma(data_t *data,
 static bool test_pipe_legacy_gamma(data_t *data,
 				   igt_plane_t *primary)
 {
-	igt_output_t *output = data->output;
+	igt_output_t *output;
 	igt_display_t *display = &data->display;
 	color_t red_green_blue[] = {
 		{ 1.0, 0.0, 0.0 },
@@ -220,7 +216,7 @@ static bool test_pipe_legacy_gamma(data_t *data,
 	drmModeCrtc *kms_crtc;
 	uint32_t i, legacy_lut_size;
 	uint16_t *red_lut, *green_lut, *blue_lut;
-	drmModeModeInfo *mode = data->mode;
+	drmModeModeInfo *mode;
 	struct igt_fb fb_modeset, fb;
 	igt_crc_t crc_fullgamma, crc_fullcolors;
 	int fb_id, fb_modeset_id;
@@ -234,8 +230,11 @@ static bool test_pipe_legacy_gamma(data_t *data,
 	green_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
 	blue_lut = malloc(sizeof(uint16_t) * legacy_lut_size);
 
+	output = igt_get_single_output_for_pipe(&data->display, primary->pipe->pipe);
+	igt_require(output);
+
 	igt_output_set_pipe(output, primary->pipe->pipe);
-	igt_output_override_mode(output, mode);
+	mode = igt_output_get_mode(output);
 
 	/* Create a framebuffer at the size of the output. */
 	fb_id = igt_create_fb(data->drm_fd,
@@ -268,8 +267,7 @@ static bool test_pipe_legacy_gamma(data_t *data,
 			    display->pipes[primary->pipe->pipe].crtc_offset);
 	igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullcolors);
 
-	/*
-	 * Draw a gradient with gamma LUT to remap all values
+	/* Draw a gradient with gamma LUT to remap all values
 	 * to max red/green/blue.
 	 */
 	paint_gradient_rectangles(data, mode, red_green_blue, &fb);
@@ -285,8 +283,7 @@ static bool test_pipe_legacy_gamma(data_t *data,
 			    display->pipes[primary->pipe->pipe].crtc_offset);
 	igt_pipe_crc_collect_crc(data->pipe_crc, &crc_fullgamma);
 
-	/*
-	 * Verify that the CRC of the software computed output is
+	/* Verify that the CRC of the software computed output is
 	 * equal to the CRC of the gamma LUT transformation output.
 	 */
 	ret = !igt_skip_crc_compare || igt_check_crc_equal(&crc_fullgamma, &crc_fullcolors);
@@ -301,7 +298,6 @@ static bool test_pipe_legacy_gamma(data_t *data,
 
 	igt_plane_set_fb(primary, NULL);
 	igt_output_set_pipe(output, PIPE_NONE);
-	igt_display_commit(&data->display);
 	igt_remove_fb(data->drm_fd, &fb);
 	igt_remove_fb(data->drm_fd, &fb_modeset);
 
@@ -330,7 +326,7 @@ static bool test_pipe_legacy_gamma_reset(data_t *data,
 	uint16_t *red_lut, *green_lut, *blue_lut;
 	struct drm_color_lut *lut;
 	drmModePropertyBlobPtr blob;
-	igt_output_t *output = data->output;
+	igt_output_t *output;
 	bool ret = true;
 
 	igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_GAMMA_LUT));
@@ -339,6 +335,9 @@ static bool test_pipe_legacy_gamma_reset(data_t *data,
 		degamma_linear = generate_table(data->degamma_lut_size, 1.0);
 	gamma_zero = generate_table_zero(data->gamma_lut_size);
 
+	output = igt_get_single_output_for_pipe(&data->display, primary->pipe->pipe);
+	igt_require(output);
+
 	igt_output_set_pipe(output, primary->pipe->pipe);
 
 	/* Ensure we have a clean state to start with. */
@@ -347,11 +346,9 @@ static bool test_pipe_legacy_gamma_reset(data_t *data,
 	disable_gamma(primary->pipe);
 	igt_display_commit(&data->display);
 
-	/*
-	 * Set a degama & gamma LUT and a CTM using the
+	/* Set a degama & gamma LUT and a CTM using the
 	 * properties and verify the content of the
-	 * properties.
-	 */
+	 * properties. */
 	if (igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_DEGAMMA_LUT))
 		set_degamma(data, primary->pipe, degamma_linear);
 	if (igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_CTM))
@@ -387,11 +384,9 @@ static bool test_pipe_legacy_gamma_reset(data_t *data,
 	if(!ret)
 		goto end;
 
-	/*
-	 * Set a gamma LUT using the legacy ioctl and verify
+	/* Set a gamma LUT using the legacy ioctl and verify
 	 * the content of the GAMMA_LUT property is changed
-	 * and that CTM and DEGAMMA_LUT are empty.
-	 */
+	 * and that CTM and DEGAMMA_LUT are empty. */
 	kms_crtc = drmModeGetCrtc(data->drm_fd, primary->pipe->crtc_id);
 	legacy_lut_size = kms_crtc->gamma_size;
 	drmModeFreeCrtc(kms_crtc);
@@ -429,7 +424,6 @@ static bool test_pipe_legacy_gamma_reset(data_t *data,
 
 	igt_plane_set_fb(primary, NULL);
 	igt_output_set_pipe(output, PIPE_NONE);
-	igt_display_commit(&data->display);
 
 	free_lut(degamma_linear);
 	free_lut(gamma_zero);
@@ -456,7 +450,7 @@ static bool test_pipe_ctm(data_t *data,
 	igt_output_t *output = data->output;
 	bool ret = true;
 	igt_display_t *display = &data->display;
-	drmModeModeInfo *mode = data->mode;
+	drmModeModeInfo *mode;
 	struct igt_fb fb_modeset, fb;
 	igt_crc_t crc_software, crc_hardware;
 	int fb_id, fb_modeset_id;
@@ -467,7 +461,7 @@ static bool test_pipe_ctm(data_t *data,
 	gamma_linear = generate_table(data->gamma_lut_size, 1.0);
 
 	igt_output_set_pipe(output, primary->pipe->pipe);
-	igt_output_override_mode(output, mode);
+	mode = igt_output_get_mode(output);
 
 	/* Create a framebuffer at the size of the output. */
 	fb_id = igt_create_fb(data->drm_fd,
@@ -521,15 +515,13 @@ static bool test_pipe_ctm(data_t *data,
 			    display->pipes[primary->pipe->pipe].crtc_offset);
 	igt_pipe_crc_collect_crc(data->pipe_crc, &crc_hardware);
 
-	/*
-	 * Verify that the CRC of the software computed output is
+	/* Verify that the CRC of the software computed output is
 	 * equal to the CRC of the CTM matrix transformation output.
 	 */
 	ret &= !igt_skip_crc_compare || igt_check_crc_equal(&crc_software, &crc_hardware);
 
 	igt_plane_set_fb(primary, NULL);
 	igt_output_set_pipe(output, PIPE_NONE);
-	igt_display_commit(&data->display);
 	igt_remove_fb(data->drm_fd, &fb);
 	igt_remove_fb(data->drm_fd, &fb_modeset);
 
@@ -711,12 +703,17 @@ static void test_setup(data_t *data, enum pipe p)
 	igt_display_require_output_on_pipe(&data->display, p);
 	data->output = igt_get_single_output_for_pipe(&data->display, p);
 	igt_require(data->output);
-
-	igt_display_reset(&data->display);
 }
 
 static void test_cleanup(data_t *data)
 {
+	igt_plane_t *primary = data->primary;
+
+	disable_degamma(primary->pipe);
+	disable_gamma(primary->pipe);
+	disable_ctm(primary->pipe);
+	igt_display_commit(&data->display);
+
 	igt_pipe_crc_free(data->pipe_crc);
 	data->pipe_crc = NULL;
 }
@@ -727,13 +724,10 @@ run_gamma_degamma_tests_for_pipe(data_t *data, enum pipe p,
 {
 	test_setup(data, p);
 
-	/*
-	 * We assume an 8bits depth per color for degamma/gamma LUTs
-	 * for CRC checks with framebuffer references.
-	 */
+	/* We assume an 8bits depth per color for degamma/gamma LUTs
+	 * for CRC checks with framebuffer references. */
 	data->color_depth = 8;
 	data->drm_format = DRM_FORMAT_XRGB8888;
-	data->mode = igt_output_get_mode(data->output);
 
 	igt_dynamic_f("pipe-%s-%s", kmstest_pipe_name(p), data->output->name)
 		igt_assert(test_t(data, data->primary));
@@ -763,7 +757,6 @@ run_ctm_tests_for_pipe(data_t *data, enum pipe p,
 	data->color_depth = 8;
 	delta = 1.0 / (1 << data->color_depth);
 	data->drm_format = DRM_FORMAT_XRGB8888;
-	data->mode = igt_output_get_mode(data->output);
 
 	igt_dynamic_f("pipe-%s-%s", kmstest_pipe_name(p), data->output->name) {
 		bool success = false;
@@ -830,6 +823,9 @@ run_deep_color_tests_for_pipe(data_t *data, enum pipe p)
 		if (!panel_supports_deep_color(data->drm_fd, output->name))
 			continue;
 
+		data->color_depth = 10;
+		data->drm_format = DRM_FORMAT_XRGB2101010;
+		data->output = output;
 		igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, 10);
 		igt_output_set_pipe(output, p);
 		igt_display_commit_atomic(&data->display, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
@@ -838,15 +834,7 @@ run_deep_color_tests_for_pipe(data_t *data, enum pipe p)
 		    !i915_clock_constraint(data, p, 10))
 			continue;
 
-		data->color_depth = 10;
-		data->drm_format = DRM_FORMAT_XRGB2101010;
-		data->output = output;
-		data->mode = igt_output_get_mode(data->output);
-
 		igt_dynamic_f("pipe-%s-%s-gamma", kmstest_pipe_name(p), output->name) {
-			igt_display_reset(&data->display);
-			igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, 10);
-
 			ret = test_pipe_gamma(data, data->primary);
 
 			igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, max_bpc);
@@ -854,9 +842,6 @@ run_deep_color_tests_for_pipe(data_t *data, enum pipe p)
 		}
 
 		igt_dynamic_f("pipe-%s-%s-degamma", kmstest_pipe_name(p), output->name) {
-			igt_display_reset(&data->display);
-			igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, 10);
-
 			ret = test_pipe_degamma(data, data->primary);
 
 			igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, max_bpc);
@@ -864,9 +849,6 @@ run_deep_color_tests_for_pipe(data_t *data, enum pipe p)
 		}
 
 		igt_dynamic_f("pipe-%s-%s-ctm", kmstest_pipe_name(p), output->name) {
-			igt_display_reset(&data->display);
-			igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, 10);
-
 			ret = test_pipe_ctm(data, data->primary,
 					    red_green_blue,
 					    blue_green_blue, ctm);
tests/kms_color_helper.h +0 -1
index f0ae30e3..2ea15bcd 100644
@@ -51,7 +51,6 @@ typedef struct {
 	igt_pipe_crc_t *pipe_crc;
 	igt_output_t *output;
 	igt_plane_t *primary;
-	drmModeModeInfo *mode;
 
 	uint32_t drm_format;
 	uint32_t color_depth;
Signature · 1 line
2.37.3
#6 lore raw

PATCH v2 6/8 Revert "tests/kms_color: Convert tests to dynamic"

In reply to Bhanuprakash Modem

This reverts commit d61e4598142e41fe5eb13295802ecf935bba85bc.

---
 tests/kms_color.c        | 556 ++++++++++++++++++---------------------
 tests/kms_color_helper.h |   1 -
 2 files changed, 259 insertions(+), 298 deletions(-)
tests/kms_color.c +259 -297
index 85f3b32d..ba06947b 100644
@@ -203,7 +203,7 @@ static bool test_pipe_gamma(data_t *data,
  * gamma LUT and verify we have the same CRC as drawing solid color rectangles
  * with linear legacy gamma LUT.
  */
-static bool test_pipe_legacy_gamma(data_t *data,
+static void test_pipe_legacy_gamma(data_t *data,
 				   igt_plane_t *primary)
 {
 	igt_output_t *output;
@@ -220,7 +220,6 @@ static bool test_pipe_legacy_gamma(data_t *data,
 	struct igt_fb fb_modeset, fb;
 	igt_crc_t crc_fullgamma, crc_fullcolors;
 	int fb_id, fb_modeset_id;
-	bool ret;
 
 	kms_crtc = drmModeGetCrtc(data->drm_fd, primary->pipe->crtc_id);
 	legacy_lut_size = kms_crtc->gamma_size;
@@ -286,7 +285,7 @@ static bool test_pipe_legacy_gamma(data_t *data,
 	/* Verify that the CRC of the software computed output is
 	 * equal to the CRC of the gamma LUT transformation output.
 	 */
-	ret = !igt_skip_crc_compare || igt_check_crc_equal(&crc_fullgamma, &crc_fullcolors);
+	igt_assert_crc_equal(&crc_fullgamma, &crc_fullcolors);
 
 	/* Reset output. */
 	for (i = 1; i < legacy_lut_size; i++)
@@ -304,15 +303,13 @@ static bool test_pipe_legacy_gamma(data_t *data,
 	free(red_lut);
 	free(green_lut);
 	free(blue_lut);
-
-	return ret;
 }
 
 /*
  * Verify that setting the legacy gamma LUT resets the gamma LUT set
  * through the GAMMA_LUT property.
  */
-static bool test_pipe_legacy_gamma_reset(data_t *data,
+static void test_pipe_legacy_gamma_reset(data_t *data,
 					 igt_plane_t *primary)
 {
 	const double ctm_identity[] = {
@@ -327,7 +324,6 @@ static bool test_pipe_legacy_gamma_reset(data_t *data,
 	struct drm_color_lut *lut;
 	drmModePropertyBlobPtr blob;
 	igt_output_t *output;
-	bool ret = true;
 
 	igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_GAMMA_LUT));
 
@@ -377,12 +373,10 @@ static bool test_pipe_legacy_gamma_reset(data_t *data,
 				    data->gamma_lut_size));
 	lut = (struct drm_color_lut *) blob->data;
 	for (i = 0; i < data->gamma_lut_size; i++)
-		ret &=(lut[i].red == 0 &&
+		igt_assert(lut[i].red == 0 &&
 			   lut[i].green == 0 &&
 			   lut[i].blue == 0);
 	drmModeFreePropertyBlob(blob);
-	if(!ret)
-		goto end;
 
 	/* Set a gamma LUT using the legacy ioctl and verify
 	 * the content of the GAMMA_LUT property is changed
@@ -417,7 +411,7 @@ static bool test_pipe_legacy_gamma_reset(data_t *data,
 				    legacy_lut_size));
 	lut = (struct drm_color_lut *) blob->data;
 	for (i = 0; i < legacy_lut_size; i++)
-		ret &= (lut[i].red == 0xffff &&
+		igt_assert(lut[i].red == 0xffff &&
 			   lut[i].green == 0xffff &&
 			   lut[i].blue == 0xffff);
 	drmModeFreePropertyBlob(blob);
@@ -427,8 +421,6 @@ static bool test_pipe_legacy_gamma_reset(data_t *data,
 
 	free_lut(degamma_linear);
 	free_lut(gamma_zero);
-end:
-	return ret;
 }
 
 /*
@@ -685,99 +677,130 @@ prep_pipe(data_t *data, enum pipe p)
 	}
 }
 
-static void test_setup(data_t *data, enum pipe p)
+static void
+run_tests_for_pipe(data_t *data, enum pipe p)
 {
 	igt_pipe_t *pipe;
+	igt_plane_t *primary;
+	double delta;
+	int i;
+	color_t red_green_blue[] = {
+		{ 1.0, 0.0, 0.0 },
+		{ 0.0, 1.0, 0.0 },
+		{ 0.0, 0.0, 1.0 }
+	};
 
-	prep_pipe(data, p);
-	igt_require_pipe_crc(data->drm_fd);
+	igt_fixture {
+		prep_pipe(data, p);
 
-	pipe = &data->display.pipes[p];
-	igt_require(pipe->n_planes >= 0);
+		igt_require_pipe_crc(data->drm_fd);
 
-	data->primary = igt_pipe_get_plane_type(pipe, DRM_PLANE_TYPE_PRIMARY);
-	data->pipe_crc = igt_pipe_crc_new(data->drm_fd,
-					  data->primary->pipe->pipe,
-					  INTEL_PIPE_CRC_SOURCE_AUTO);
+		pipe = &data->display.pipes[p];
+		igt_require(pipe->n_planes >= 0);
 
-	igt_display_require_output_on_pipe(&data->display, p);
-	data->output = igt_get_single_output_for_pipe(&data->display, p);
-	igt_require(data->output);
-}
+		primary = igt_pipe_get_plane_type(pipe, DRM_PLANE_TYPE_PRIMARY);
 
-static void test_cleanup(data_t *data)
-{
-	igt_plane_t *primary = data->primary;
+		data->pipe_crc = igt_pipe_crc_new(data->drm_fd,
+						  primary->pipe->pipe,
+						  INTEL_PIPE_CRC_SOURCE_AUTO);
 
-	disable_degamma(primary->pipe);
-	disable_gamma(primary->pipe);
-	disable_ctm(primary->pipe);
-	igt_display_commit(&data->display);
-
-	igt_pipe_crc_free(data->pipe_crc);
-	data->pipe_crc = NULL;
-}
-
-static void
-run_gamma_degamma_tests_for_pipe(data_t *data, enum pipe p,
-				 bool (*test_t)(data_t*, igt_plane_t*))
-{
-	test_setup(data, p);
+		igt_display_require_output_on_pipe(&data->display, p);
+		data->output = igt_get_single_output_for_pipe(&data->display, p);
+		igt_require(data->output);
+	}
 
 	/* We assume an 8bits depth per color for degamma/gamma LUTs
 	 * for CRC checks with framebuffer references. */
 	data->color_depth = 8;
+	delta = 1.0 / (1 << data->color_depth);
 	data->drm_format = DRM_FORMAT_XRGB8888;
 
-	igt_dynamic_f("pipe-%s-%s", kmstest_pipe_name(p), data->output->name)
-		igt_assert(test_t(data, data->primary));
+	igt_describe("Check the color transformation from red to blue");
+	igt_subtest_f("pipe-%s-ctm-red-to-blue", kmstest_pipe_name(p)) {
+		color_t blue_green_blue[] = {
+			{ 0.0, 0.0, 1.0 },
+			{ 0.0, 1.0, 0.0 },
+			{ 0.0, 0.0, 1.0 }
+		};
+		double ctm[] = { 0.0, 0.0, 0.0,
+				0.0, 1.0, 0.0,
+				1.0, 0.0, 1.0 };
+		igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+					 blue_green_blue, ctm));
+	}
 
-	test_cleanup(data);
-}
+	igt_describe("Check the color transformation from green to red");
+	igt_subtest_f("pipe-%s-ctm-green-to-red", kmstest_pipe_name(p)) {
+		color_t red_red_blue[] = {
+			{ 1.0, 0.0, 0.0 },
+			{ 1.0, 0.0, 0.0 },
+			{ 0.0, 0.0, 1.0 }
+		};
+		double ctm[] = { 1.0, 1.0, 0.0,
+				0.0, 0.0, 0.0,
+				0.0, 0.0, 1.0 };
+		igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+					 red_red_blue, ctm));
+	}
 
-static void
-run_ctm_tests_for_pipe(data_t *data, enum pipe p,
-		       color_t *expected_colors,
-		       double *ctm,
-		       int iter)
-{
-	double delta;
-	color_t red_green_blue[] = {
-		{ 1.0, 0.0, 0.0 },
-		{ 0.0, 1.0, 0.0 },
-		{ 0.0, 0.0, 1.0 }
-	};
+	igt_describe("Check the color transformation from blue to red");
+	igt_subtest_f("pipe-%s-ctm-blue-to-red", kmstest_pipe_name(p)) {
+		color_t red_green_red[] = {
+			{ 1.0, 0.0, 0.0 },
+			{ 0.0, 1.0, 0.0 },
+			{ 1.0, 0.0, 0.0 }
+		};
+		double ctm[] = { 1.0, 0.0, 1.0,
+				0.0, 1.0, 0.0,
+				0.0, 0.0, 0.0 };
+		igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+					 red_green_red, ctm));
+	}
 
-	test_setup(data, p);
+	/* We tests a few values around the expected result because
+	 * the it depends on the hardware we're dealing with, we can
+	 * either get clamped or rounded values and we also need to
+	 * account for odd number of items in the LUTs. */
+	igt_describe("Check the color transformation for 0.25 transparency");
+	igt_subtest_f("pipe-%s-ctm-0-25", kmstest_pipe_name(p)) {
+		color_t expected_colors[] = {
+			{ 0.0, }, { 0.0, }, { 0.0, }
+		};
+		double ctm[] = { 0.25, 0.0,  0.0,
+				 0.0,  0.25, 0.0,
+				 0.0,  0.0,  0.25 };
+		bool success = false;
 
-	/*
-	 * We assume an 8bits depth per color for degamma/gamma LUTs
-	 * for CRC checks with framebuffer references.
-	 */
-	data->color_depth = 8;
-	delta = 1.0 / (1 << data->color_depth);
-	data->drm_format = DRM_FORMAT_XRGB8888;
+		for (i = 0; i < 5; i++) {
+			expected_colors[0].r =
+				expected_colors[1].g =
+				expected_colors[2].b =
+				0.25 + delta * (i - 2);
+			if (test_pipe_ctm(data, primary, red_green_blue,
+					  expected_colors, ctm)) {
+				success = true;
+				break;
+			}
+		}
+		igt_assert(success);
+	}
 
-	igt_dynamic_f("pipe-%s-%s", kmstest_pipe_name(p), data->output->name) {
+	igt_describe("Check the color transformation for 0.5 transparency");
+	igt_subtest_f("pipe-%s-ctm-0-5", kmstest_pipe_name(p)) {
+		color_t expected_colors[] = {
+			{ 0.0, }, { 0.0, }, { 0.0, }
+		};
+		double ctm[] = { 0.5, 0.0, 0.0,
+				 0.0, 0.5, 0.0,
+				 0.0, 0.0, 0.5 };
 		bool success = false;
-		int i;
 
-		if (!iter)
-			success = test_pipe_ctm(data, data->primary, red_green_blue,
-						expected_colors, ctm);
-
-		/*
-		 * We tests a few values around the expected result because
-		 * it depends on the hardware we're dealing with, we can either
-		 * get clamped or rounded values and we also need to account
-		 * for odd number of items in the LUTs.
-		 */
-		for (i = 0; i < iter; i++) {
+		for (i = 0; i < 5; i++) {
 			expected_colors[0].r =
 				expected_colors[1].g =
 				expected_colors[2].b =
 				0.5 + delta * (i - 2);
-			if (test_pipe_ctm(data, data->primary, red_green_blue,
+			if (test_pipe_ctm(data, primary, red_green_blue,
 					  expected_colors, ctm)) {
 				success = true;
 				break;
@@ -786,249 +809,186 @@ run_ctm_tests_for_pipe(data_t *data, enum pipe p,
 		igt_assert(success);
 	}
 
-	test_cleanup(data);
-}
+	igt_describe("Check the color transformation for 0.75 transparency");
+	igt_subtest_f("pipe-%s-ctm-0-75", kmstest_pipe_name(p)) {
+		color_t expected_colors[] = {
+			{ 0.0, }, { 0.0, }, { 0.0, }
+		};
+		double ctm[] = { 0.75, 0.0,  0.0,
+				 0.0,  0.75, 0.0,
+				 0.0,  0.0,  0.75 };
+		bool success = false;
 
-static void
-run_deep_color_tests_for_pipe(data_t *data, enum pipe p)
-{
-	igt_output_t *output;
-	color_t blue_green_blue[] = {
-		{ 0.0, 0.0, 1.0 },
-		{ 0.0, 1.0, 0.0 },
-		{ 0.0, 0.0, 1.0 }
-	};
-	color_t red_green_blue[] = {
-		{ 1.0, 0.0, 0.0 },
-		{ 0.0, 1.0, 0.0 },
-		{ 0.0, 0.0, 1.0 }
-	};
-	double ctm[] = { 0.0, 0.0, 0.0,
-			 0.0, 1.0, 0.0,
-			 1.0, 0.0, 1.0 };
+		for (i = 0; i < 7; i++) {
+			expected_colors[0].r =
+				expected_colors[1].g =
+				expected_colors[2].b =
+				0.75 + delta * (i - 3);
+			if (test_pipe_ctm(data, primary, red_green_blue,
+						expected_colors, ctm)) {
+				success = true;
+				break;
+			}
+		}
+		igt_assert(success);
+	}
 
-	if (is_i915_device(data->drm_fd))
-		igt_require_f((intel_display_ver(data->devid) >= 11),
-				"At least GEN 11 is required to validate Deep-color.\n");
+	igt_describe("Check the color transformation for maximum transparency");
+	igt_subtest_f("pipe-%s-ctm-max", kmstest_pipe_name(p)) {
+		color_t full_rgb[] = {
+			{ 1.0, 0.0, 0.0 },
+			{ 0.0, 1.0, 0.0 },
+			{ 0.0, 0.0, 1.0 }
+		};
+		double ctm[] = { 100.0,   0.0,   0.0,
+				 0.0,   100.0,   0.0,
+				 0.0,     0.0, 100.0 };
+
+		/* CherryView generates values on 10bits that we
+		 * produce with an 8 bits per color framebuffer. */
+		igt_require(!IS_CHERRYVIEW(data->devid));
+
+		igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+					 full_rgb, ctm));
+	}
 
-	test_setup(data, p);
+	igt_describe("Check the color transformation for negative transparency");
+	igt_subtest_f("pipe-%s-ctm-negative", kmstest_pipe_name(p)) {
+		color_t all_black[] = {
+			{ 0.0, 0.0, 0.0 },
+			{ 0.0, 0.0, 0.0 },
+			{ 0.0, 0.0, 0.0 }
+		};
+		double ctm[] = { -1.0,  0.0,  0.0,
+				 0.0, -1.0,  0.0,
+				 0.0,  0.0, -1.0 };
+		igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+					 all_black, ctm));
+	}
 
-	for_each_valid_output_on_pipe(&data->display, p, output) {
-		uint64_t max_bpc = get_max_bpc(output);
-		bool ret;
+#if 0
+	igt_subtest_f("pipe-%s-ctm-limited-range", kmstest_pipe_name(p))
+		test_pipe_limited_range_ctm(data, primary);
+#endif
 
-		if (!max_bpc)
-			continue;
+	igt_describe("Verify that degamma LUT transformation works correctly");
+	igt_subtest_f("pipe-%s-degamma", kmstest_pipe_name(p))
+		igt_assert(test_pipe_degamma(data, primary));
 
-		if (!panel_supports_deep_color(data->drm_fd, output->name))
-			continue;
+	igt_describe("Verify that gamma LUT transformation works correctly");
+	igt_subtest_f("pipe-%s-gamma", kmstest_pipe_name(p))
+		igt_assert(test_pipe_gamma(data, primary));
 
-		data->color_depth = 10;
-		data->drm_format = DRM_FORMAT_XRGB2101010;
-		data->output = output;
-		igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, 10);
-		igt_output_set_pipe(output, p);
-		igt_display_commit_atomic(&data->display, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+	igt_describe("Verify that legacy gamma LUT transformation works correctly");
+	igt_subtest_f("pipe-%s-legacy-gamma", kmstest_pipe_name(p))
+		test_pipe_legacy_gamma(data, primary);
 
-		if (is_i915_device(data->drm_fd) &&
-		    !i915_clock_constraint(data, p, 10))
-			continue;
+	igt_describe("Verify that setting the legacy gamma LUT resets the gamma LUT set through "
+			"GAMMA_LUT property");
+	igt_subtest_f("pipe-%s-legacy-gamma-reset", kmstest_pipe_name(p))
+		test_pipe_legacy_gamma_reset(data, primary);
 
-		igt_dynamic_f("pipe-%s-%s-gamma", kmstest_pipe_name(p), output->name) {
-			ret = test_pipe_gamma(data, data->primary);
+	igt_fixture
+		igt_require(data->display.is_atomic);
 
-			igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, max_bpc);
-			igt_assert(ret);
-		}
+	igt_describe("Verify that deep color works correctly");
+	igt_subtest_with_dynamic_f("pipe-%s-deep-color", kmstest_pipe_name(p)) {
+		igt_output_t *output;
+		color_t blue_green_blue[] = {
+			{ 0.0, 0.0, 1.0 },
+			{ 0.0, 1.0, 0.0 },
+			{ 0.0, 0.0, 1.0 }
+		};
+		double ctm[] = { 0.0, 0.0, 0.0,
+				0.0, 1.0, 0.0,
+				1.0, 0.0, 1.0 };
+
+		if (is_i915_device(data->drm_fd))
+			igt_require_f((intel_display_ver(data->devid) >= 11),
+					"At least GEN 11 is required to validate Deep-color.\n");
+
+		for_each_valid_output_on_pipe(&data->display, p, output) {
+			uint64_t max_bpc = get_max_bpc(output);
+			bool ret;
+
+			if (!max_bpc)
+				continue;
+
+			if (!panel_supports_deep_color(data->drm_fd, output->name))
+				continue;
+
+			data->color_depth = 10;
+			data->drm_format = DRM_FORMAT_XRGB2101010;
+			data->output = output;
+			igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, 10);
+			igt_output_set_pipe(output, p);
+			igt_display_commit_atomic(&data->display, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+
+			if (is_i915_device(data->drm_fd) &&
+			    !i915_clock_constraint(data, p, 10))
+				continue;
+
+			igt_dynamic_f("gamma-%s", output->name) {
+				ret = test_pipe_gamma(data, primary);
+
+				igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, max_bpc);
+				igt_assert(ret);
+			}
 
-		igt_dynamic_f("pipe-%s-%s-degamma", kmstest_pipe_name(p), output->name) {
-			ret = test_pipe_degamma(data, data->primary);
+			igt_dynamic_f("degamma-%s", output->name) {
+				ret = test_pipe_degamma(data, primary);
 
-			igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, max_bpc);
-			igt_assert(ret);
-		}
+				igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, max_bpc);
+				igt_assert(ret);
+			}
 
-		igt_dynamic_f("pipe-%s-%s-ctm", kmstest_pipe_name(p), output->name) {
-			ret = test_pipe_ctm(data, data->primary,
-					    red_green_blue,
-					    blue_green_blue, ctm);
+			igt_dynamic_f("ctm-%s", output->name) {
+				ret = test_pipe_ctm(data, primary,
+						    red_green_blue,
+						    blue_green_blue, ctm);
 
-			igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, max_bpc);
-			igt_assert(ret);
-		}
+				igt_output_set_prop_value(output, IGT_CONNECTOR_MAX_BPC, max_bpc);
+				igt_assert(ret);
+			}
 
-		break;
+			break;
+		}
 	}
 
-	test_cleanup(data);
-}
-
-static void
-run_invalid_tests_for_pipe(data_t *data)
-{
-	enum pipe pipe;
-	struct {
-		const char *name;
-		void (*test_t) (data_t *data, enum pipe pipe);
-		const char *desc;
-	} tests[] = {
-		{ "invalid-gamma-lut-sizes", invalid_gamma_lut_sizes,
-			"Negative check for invalid gamma lut sizes" },
-
-		{ "invalid-degamma-lut-sizes", invalid_degamma_lut_sizes,
-			"Negative check for invalid degamma lut sizes" },
-
-		{ "invalid-ctm-matrix-sizes", invalid_ctm_matrix_sizes,
-			"Negative check for color tranformation matrix sizes" },
-	};
-	int i;
-
-	for (i = 0; i < ARRAY_SIZE(tests); i++) {
-		igt_describe_f("%s", tests[i].desc);
-		igt_subtest_with_dynamic_f("%s", tests[i].name) {
-			for_each_pipe(&data->display, pipe) {
-				prep_pipe(data, pipe);
+	igt_fixture {
+		disable_degamma(primary->pipe);
+		disable_gamma(primary->pipe);
+		disable_ctm(primary->pipe);
+		igt_display_commit(&data->display);
 
-				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe))
-					tests[i].test_t(data, pipe);
-			}
-		}
+		igt_pipe_crc_free(data->pipe_crc);
+		data->pipe_crc = NULL;
 	}
 }
 
 static void
-run_tests_for_pipe(data_t *data)
+run_invalid_tests_for_pipe(data_t *data, enum pipe p)
 {
-	enum pipe pipe;
-	struct {
-		const char *name;
-		bool (*test_t)(data_t*, igt_plane_t*);
-		const char *desc;
-	} gamma_degamma_tests[] = {
-		{ "degamma", test_pipe_degamma,
-		  "Verify that degamma LUT transformation works correctly" },
-
-		{ "gamma", test_pipe_gamma,
-		  "Verify that gamma LUT transformation works correctly" },
-
-		{ "legacy-gamma", test_pipe_legacy_gamma,
-		  "Verify that legacy gamma LUT transformation works correctly" },
-
-		{ "legacy-gamma-reset", test_pipe_legacy_gamma_reset,
-		  "Verify that setting the legacy gamma LUT resets the gamma LUT set through GAMMA_LUT property" },
-	};
-	struct {
-		const char *name;
-		int iter;
-		color_t colors[3];
-		double ctm[9];
-		const char *desc;
-	} ctm_tests[] = {
-		{ "ctm-red-to-blue", 0,
-			{{ 0.0, 0.0, 1.0 },
-			 { 0.0, 1.0, 0.0 },
-			 { 0.0, 0.0, 1.0 }},
-		  { 0.0, 0.0, 0.0,
-		    0.0, 1.0, 0.0,
-		    1.0, 0.0, 1.0 },
-		  "Check the color transformation from red to blue"
-		},
-		{ "ctm-green-to-red", 0,
-			{{ 1.0, 0.0, 0.0 },
-			 { 1.0, 0.0, 0.0 },
-			 { 0.0, 0.0, 1.0 }},
-		  { 1.0, 1.0, 0.0,
-		    0.0, 0.0, 0.0,
-		    0.0, 0.0, 1.0 },
-		  "Check the color transformation from green to red"
-		},
-		{ "ctm-blue-to-red", 0,
-			{{ 1.0, 0.0, 0.0 },
-			 { 0.0, 1.0, 0.0 },
-			 { 1.0, 0.0, 0.0 }},
-		  { 1.0, 0.0, 1.0,
-		    0.0, 1.0, 0.0,
-		    0.0, 0.0, 0.0 },
-		  "Check the color transformation from blue to red"
-		},
-		{ "ctm-max", 0,
-			{{ 1.0, 0.0, 0.0 },
-			 { 0.0, 1.0, 0.0 },
-			 { 0.0, 0.0, 1.0 }},
-		  { 100.0, 0.0, 0.0,
-		    0.0, 100.0, 0.0,
-		    0.0, 0.0, 100.0 },
-		  "Check the color transformation for maximum transparency"
-		},
-		{ "ctm-negative", 0,
-			{{ 0.0, 0.0, 0.0 },
-			 { 0.0, 0.0, 0.0 },
-			 { 0.0, 0.0, 0.0 }},
-		  { -1.0, 0.0, 0.0,
-		    0.0, -1.0, 0.0,
-		    0.0, 0.0, -1.0 },
-		  "Check the color transformation for negative transparency"
-		},
-		{ "ctm-0-25", 5,
-			{{ 0.0, }, { 0.0, }, { 0.0, }},
-		  { 0.25, 0.0,  0.0,
-		    0.0,  0.25, 0.0,
-		    0.0,  0.0,  0.25 },
-		  "Check the color transformation for 0.25 transparency"
-		},
-		{ "ctm-0-50", 5,
-			{{ 0.0, }, { 0.0, }, { 0.0, }},
-		  { 0.5,  0.0,  0.0,
-		    0.0,  0.5,  0.0,
-		    0.0,  0.0,  0.5 },
-		  "Check the color transformation for 0.5 transparency"
-		},
-		{ "ctm-0-75", 7,
-			{{ 0.0, }, { 0.0, }, { 0.0, }},
-		  { 0.75, 0.0,  0.0,
-		    0.0,  0.75, 0.0,
-		    0.0,  0.0,  0.75 },
-		  "Check the color transformation for 0.75 transparency"
-		},
-	};
-	int i;
-
-	for (i = 0; i < ARRAY_SIZE(gamma_degamma_tests); i++) {
-		igt_describe_f("%s", gamma_degamma_tests[i].desc);
-		igt_subtest_with_dynamic_f("%s", gamma_degamma_tests[i].name) {
-			for_each_pipe(&data->display, pipe) {
-				run_gamma_degamma_tests_for_pipe(data, pipe,
-								 gamma_degamma_tests[i].test_t);
-			}
-		}
-	}
+	igt_fixture
+		prep_pipe(data, p);
 
-	for (i = 0; i < ARRAY_SIZE(ctm_tests); i++) {
-		igt_describe_f("%s", ctm_tests[i].desc);
-		igt_subtest_with_dynamic_f("%s", ctm_tests[i].name) {
-			for_each_pipe(&data->display, pipe) {
-				run_ctm_tests_for_pipe(data, pipe,
-						       ctm_tests[i].colors,
-						       ctm_tests[i].ctm,
-						       ctm_tests[i].iter);
-			}
-		}
-	}
+	igt_describe("Negative check for invalid gamma lut sizes");
+	igt_subtest_f("pipe-%s-invalid-gamma-lut-sizes", kmstest_pipe_name(p))
+		invalid_gamma_lut_sizes(data, p);
 
-	igt_fixture
-		igt_require(data->display.is_atomic);
+	igt_describe("Negative check for invalid degamma lut sizes");
+	igt_subtest_f("pipe-%s-invalid-degamma-lut-sizes", kmstest_pipe_name(p))
+		invalid_degamma_lut_sizes(data, p);
 
-	igt_describe("Verify that deep color works correctly");
-	igt_subtest_with_dynamic("deep-color") {
-		for_each_pipe(&data->display, pipe) {
-			run_deep_color_tests_for_pipe(data, pipe);
-		}
-	}
+	igt_describe("Negative check for color tranformation matrix sizes");
+	igt_subtest_f("pipe-%s-invalid-ctm-matrix-sizes", kmstest_pipe_name(p))
+		invalid_ctm_matrix_sizes(data, p);
 }
 
 igt_main
 {
 	data_t data = {};
+	enum pipe pipe;
 
 	igt_fixture {
 		data.drm_fd = drm_open_driver_master(DRIVER_ANY);
@@ -1039,11 +999,13 @@ igt_main
 		igt_display_require(&data.display, data.drm_fd);
 	}
 
-	igt_subtest_group
-		run_tests_for_pipe(&data);
+	for_each_pipe_static(pipe) {
+		igt_subtest_group
+			run_tests_for_pipe(&data, pipe);
 
-	igt_subtest_group
-		run_invalid_tests_for_pipe(&data);
+		igt_subtest_group
+			run_invalid_tests_for_pipe(&data, pipe);
+	}
 
 	igt_fixture {
 		igt_display_fini(&data.display);
tests/kms_color_helper.h +0 -1
index 2ea15bcd..cc07f5ee 100644
@@ -50,7 +50,6 @@ typedef struct {
 	igt_display_t display;
 	igt_pipe_crc_t *pipe_crc;
 	igt_output_t *output;
-	igt_plane_t *primary;
 
 	uint32_t drm_format;
 	uint32_t color_depth;
Signature · 1 line
2.37.3
#7 lore raw

PATCH v2 7/8 Revert "tests/kms_color_chamelium: Convert tests to dynamic"

In reply to Bhanuprakash Modem

This reverts commit a98a66399db9939b16e1cb3b47055f400834affb.

---
 tests/chamelium/kms_color_chamelium.c | 1034 +++++++++++++------------
 1 file changed, 547 insertions(+), 487 deletions(-)
tests/chamelium/kms_color_chamelium.c +547 -487
index 678931aa..76f82d6d 100644
@@ -31,88 +31,115 @@ IGT_TEST_DESCRIPTION("Test Color Features at Pipe level using Chamelium to verif
  * degamma LUT and verify we have the same frame dump as drawing solid color
  * rectangles with linear degamma LUT.
  */
-static bool test_pipe_degamma(data_t *data,
-			      igt_plane_t *primary,
-			      struct chamelium_port *port)
+static void test_pipe_degamma(data_t *data,
+			      igt_plane_t *primary)
 {
-	igt_output_t *output = data->output;
-	gamma_lut_t *degamma_full;
-	drmModeModeInfo *mode = data->mode;
-	struct igt_fb fb_modeset, fb, fbref;
-	struct chamelium_frame_dump *frame_fullcolors;
-	int fb_id, fb_modeset_id, fbref_id;
+	igt_output_t *output;
+	gamma_lut_t *degamma_linear, *degamma_full;
 	color_t red_green_blue[] = {
 		{ 1.0, 0.0, 0.0 },
 		{ 0.0, 1.0, 0.0 },
 		{ 0.0, 0.0, 1.0 }
 	};
-	bool ret;
 
-	igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_DEGAMMA_LUT));
+	int i;
+	struct chamelium_port *port;
+	char *connected_ports[4];
 
-	degamma_full = generate_table_max(data->degamma_lut_size);
+	for (i = 0; i < data->port_count; i++)
+		connected_ports[i] =
+			(char *) chamelium_port_get_name(data->ports[i]);
 
-	igt_output_set_pipe(output, primary->pipe->pipe);
+	igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_DEGAMMA_LUT));
+	igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_GAMMA_LUT));
 
-	/* Create a framebuffer at the size of the output. */
-	fb_id = igt_create_fb(data->drm_fd,
-			      mode->hdisplay,
-			      mode->vdisplay,
-			      DRM_FORMAT_XRGB8888,
-			      DRM_FORMAT_MOD_LINEAR,
-			      &fb);
-	igt_assert(fb_id);
+	degamma_linear = generate_table(data->degamma_lut_size, 1.0);
+	degamma_full = generate_table_max(data->degamma_lut_size);
 
-	fb_modeset_id = igt_create_fb(data->drm_fd,
+	for_each_valid_output_on_pipe(&data->display,
+				      primary->pipe->pipe,
+				      output) {
+		drmModeModeInfo *mode;
+		struct igt_fb fb_modeset, fb, fbref;
+		struct chamelium_frame_dump *frame_fullcolors;
+		int fb_id, fb_modeset_id, fbref_id;
+		bool valid_output = false;
+
+		for (i = 0; i < data->port_count; i++)
+			valid_output |=
+				(strcmp(output->name, connected_ports[i]) == 0);
+		if (!valid_output)
+			continue;
+		else
+			for (i = 0; i < data->port_count; i++)
+				if (strcmp(output->name,
+					   connected_ports[i]) == 0)
+					port = data->ports[i];
+
+		igt_output_set_pipe(output, primary->pipe->pipe);
+		mode = igt_output_get_mode(output);
+
+		/* Create a framebuffer at the size of the output. */
+		fb_id = igt_create_fb(data->drm_fd,
 				      mode->hdisplay,
 				      mode->vdisplay,
 				      DRM_FORMAT_XRGB8888,
 				      DRM_FORMAT_MOD_LINEAR,
-				      &fb_modeset);
-	igt_assert(fb_modeset_id);
-
-	fbref_id = igt_create_fb(data->drm_fd,
-				 mode->hdisplay,
-				 mode->vdisplay,
-				 DRM_FORMAT_XRGB8888,
-				 DRM_FORMAT_MOD_LINEAR,
-				 &fbref);
-	igt_assert(fbref_id);
-
-	igt_plane_set_fb(primary, &fb_modeset);
-	disable_ctm(primary->pipe);
-	disable_gamma(primary->pipe);
-	igt_display_commit(&data->display);
-
-	/* Draw solid colors with linear degamma transformation. */
-	paint_rectangles(data, mode, red_green_blue, &fbref);
-
-	/* Draw a gradient with degamma LUT to remap all
-	 * values to max red/green/blue.
-	 */
-	paint_gradient_rectangles(data, mode, red_green_blue, &fb);
-	igt_plane_set_fb(primary, &fb);
-	set_degamma(data, primary->pipe, degamma_full);
-	igt_display_commit(&data->display);
-	chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
-	frame_fullcolors =
-		chamelium_read_captured_frame(data->chamelium, 0);
-
-	/* Verify that the framebuffer reference of the software
-	 * computed output is equal to the frame dump of the degamma
-	 * LUT transformation output.
-	 */
-	ret = chamelium_frame_match_or_dump(data->chamelium, port,
-					    frame_fullcolors, &fbref,
-					    CHAMELIUM_CHECK_ANALOG);
-
-	disable_degamma(primary->pipe);
-	igt_plane_set_fb(primary, NULL);
-	igt_output_set_pipe(output, PIPE_NONE);
-	igt_display_commit(&data->display);
-	free_lut(degamma_full);
+				      &fb);
+		igt_assert(fb_id);
+
+		fb_modeset_id = igt_create_fb(data->drm_fd,
+					      mode->hdisplay,
+					      mode->vdisplay,
+					      DRM_FORMAT_XRGB8888,
+					      DRM_FORMAT_MOD_LINEAR,
+					      &fb_modeset);
+		igt_assert(fb_modeset_id);
+
+		fbref_id = igt_create_fb(data->drm_fd,
+					      mode->hdisplay,
+					      mode->vdisplay,
+					      DRM_FORMAT_XRGB8888,
+					      DRM_FORMAT_MOD_LINEAR,
+					      &fbref);
+		igt_assert(fbref_id);
+
+		igt_plane_set_fb(primary, &fb_modeset);
+		disable_ctm(primary->pipe);
+		disable_gamma(primary->pipe);
+		set_degamma(data, primary->pipe, degamma_linear);
+		igt_display_commit(&data->display);
 
-	return ret;
+		/* Draw solid colors with linear degamma transformation. */
+		paint_rectangles(data, mode, red_green_blue, &fbref);
+
+		/* Draw a gradient with degamma LUT to remap all
+		 * values to max red/green/blue.
+		 */
+		paint_gradient_rectangles(data, mode, red_green_blue, &fb);
+		igt_plane_set_fb(primary, &fb);
+		set_degamma(data, primary->pipe, degamma_full);
+		igt_display_commit(&data->display);
+		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+		frame_fullcolors =
+			chamelium_read_captured_frame(data->chamelium, 0);
+
+		/* Verify that the framebuffer reference of the software
+		 * computed output is equal to the frame dump of the degamma
+		 * LUT transformation output.
+		 */
+		chamelium_frame_match_or_dump(data->chamelium, port,
+					      frame_fullcolors, &fbref,
+					      CHAMELIUM_CHECK_ANALOG);
+
+		disable_degamma(primary->pipe);
+		igt_plane_set_fb(primary, NULL);
+		igt_output_set_pipe(output, PIPE_NONE);
+		igt_display_commit(&data->display);
+	}
+
+	free_lut(degamma_linear);
+	free_lut(degamma_full);
 }
 
 /*
@@ -120,88 +147,111 @@ static bool test_pipe_degamma(data_t *data,
  * gamma LUT and verify we have the same frame dump as drawing solid
  * color rectangles.
  */
-static bool test_pipe_gamma(data_t *data,
-			    igt_plane_t *primary,
-			    struct chamelium_port *port)
+static void test_pipe_gamma(data_t *data,
+			    igt_plane_t *primary)
 {
-	igt_output_t *output = data->output;
+	igt_output_t *output;
 	gamma_lut_t *gamma_full;
-	drmModeModeInfo *mode = data->mode;
-	struct igt_fb fb_modeset, fb, fbref;
-	struct chamelium_frame_dump *frame_fullcolors;
-	int fb_id, fb_modeset_id, fbref_id;
 	color_t red_green_blue[] = {
 		{ 1.0, 0.0, 0.0 },
 		{ 0.0, 1.0, 0.0 },
 		{ 0.0, 0.0, 1.0 }
 	};
-	bool ret;
 
-	igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_GAMMA_LUT));
+	int i;
+	struct chamelium_port *port;
+	char *connected_ports[4];
 
-	gamma_full = generate_table_max(data->gamma_lut_size);
+	for (i = 0; i < data->port_count; i++)
+		connected_ports[i] =
+			(char *) chamelium_port_get_name(data->ports[i]);
 
-	igt_output_set_pipe(output, primary->pipe->pipe);
+	igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_GAMMA_LUT));
 
-	/* Create a framebuffer at the size of the output. */
-	fb_id = igt_create_fb(data->drm_fd,
-			      mode->hdisplay,
-			      mode->vdisplay,
-			      DRM_FORMAT_XRGB8888,
-			      DRM_FORMAT_MOD_LINEAR,
-			      &fb);
-	igt_assert(fb_id);
+	gamma_full = generate_table_max(data->gamma_lut_size);
 
-	fb_modeset_id = igt_create_fb(data->drm_fd,
+	for_each_valid_output_on_pipe(&data->display,
+				      primary->pipe->pipe,
+				      output) {
+		drmModeModeInfo *mode;
+		struct igt_fb fb_modeset, fb, fbref;
+		struct chamelium_frame_dump *frame_fullcolors;
+		int fb_id, fb_modeset_id, fbref_id;
+		bool valid_output = false;
+
+		for (i = 0; i < data->port_count; i++)
+			valid_output |=
+				(strcmp(output->name, connected_ports[i]) == 0);
+		if (!valid_output)
+			continue;
+		else
+			for (i = 0; i < data->port_count; i++)
+				if (strcmp(output->name,
+					   connected_ports[i]) == 0)
+					port = data->ports[i];
+
+		igt_output_set_pipe(output, primary->pipe->pipe);
+		mode = igt_output_get_mode(output);
+
+		/* Create a framebuffer at the size of the output. */
+		fb_id = igt_create_fb(data->drm_fd,
 				      mode->hdisplay,
 				      mode->vdisplay,
 				      DRM_FORMAT_XRGB8888,
 				      DRM_FORMAT_MOD_LINEAR,
-				      &fb_modeset);
-	igt_assert(fb_modeset_id);
-
-	fbref_id = igt_create_fb(data->drm_fd,
-			      mode->hdisplay,
-			      mode->vdisplay,
-			      DRM_FORMAT_XRGB8888,
-			      DRM_FORMAT_MOD_LINEAR,
-			      &fbref);
-	igt_assert(fbref_id);
-
-	igt_plane_set_fb(primary, &fbref);
-	disable_ctm(primary->pipe);
-	disable_degamma(primary->pipe);
-	set_gamma(data, primary->pipe, gamma_full);
-	igt_display_commit(&data->display);
-
-	/* Draw solid colors with no gamma transformation. */
-	paint_rectangles(data, mode, red_green_blue, &fbref);
-
-	/* Draw a gradient with gamma LUT to remap all values
-	 * to max red/green/blue.
-	 */
-	paint_gradient_rectangles(data, mode, red_green_blue, &fb);
-	igt_plane_set_fb(primary, &fb);
-	igt_display_commit(&data->display);
-	chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
-	frame_fullcolors =
-		chamelium_read_captured_frame(data->chamelium, 0);
-
-	/* Verify that the framebuffer reference of the software computed
-	 * output is equal to the frame dump of the degamma LUT
-	 * transformation output.
-	 */
-	ret = chamelium_frame_match_or_dump(data->chamelium, port,
-					    frame_fullcolors, &fbref,
-					    CHAMELIUM_CHECK_ANALOG);
-
-	disable_gamma(primary->pipe);
-	igt_plane_set_fb(primary, NULL);
-	igt_output_set_pipe(output, PIPE_NONE);
-	igt_display_commit(&data->display);
-	free_lut(gamma_full);
+				      &fb);
+		igt_assert(fb_id);
+
+		fb_modeset_id = igt_create_fb(data->drm_fd,
+					      mode->hdisplay,
+					      mode->vdisplay,
+					      DRM_FORMAT_XRGB8888,
+					      DRM_FORMAT_MOD_LINEAR,
+					      &fb_modeset);
+		igt_assert(fb_modeset_id);
+
+		fbref_id = igt_create_fb(data->drm_fd,
+				      mode->hdisplay,
+				      mode->vdisplay,
+				      DRM_FORMAT_XRGB8888,
+				      DRM_FORMAT_MOD_LINEAR,
+				      &fbref);
+		igt_assert(fbref_id);
 
-	return ret;
+		igt_plane_set_fb(primary, &fb_modeset);
+		disable_ctm(primary->pipe);
+		disable_degamma(primary->pipe);
+		set_gamma(data, primary->pipe, gamma_full);
+		igt_display_commit(&data->display);
+
+		/* Draw solid colors with no gamma transformation. */
+		paint_rectangles(data, mode, red_green_blue, &fbref);
+
+		/* Draw a gradient with gamma LUT to remap all values
+		 * to max red/green/blue.
+		 */
+		paint_gradient_rectangles(data, mode, red_green_blue, &fb);
+		igt_plane_set_fb(primary, &fb);
+		igt_display_commit(&data->display);
+		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+		frame_fullcolors =
+			chamelium_read_captured_frame(data->chamelium, 0);
+
+		/* Verify that the framebuffer reference of the software computed
+		 * output is equal to the frame dump of the degamma LUT
+		 * transformation output.
+		 */
+		chamelium_frame_match_or_dump(data->chamelium, port,
+					      frame_fullcolors, &fbref,
+					      CHAMELIUM_CHECK_ANALOG);
+
+		disable_gamma(primary->pipe);
+		igt_plane_set_fb(primary, NULL);
+		igt_output_set_pipe(output, PIPE_NONE);
+		igt_display_commit(&data->display);
+	}
+
+	free_lut(gamma_full);
 }
 
 /*
@@ -212,97 +262,119 @@ static bool test_pipe_ctm(data_t *data,
 			  igt_plane_t *primary,
 			  color_t *before,
 			  color_t *after,
-			  double *ctm_matrix,
-			  struct chamelium_port *port)
+			  double *ctm_matrix)
 {
 	gamma_lut_t *degamma_linear, *gamma_linear;
-	igt_output_t *output = data->output;
-	drmModeModeInfo *mode = data->mode;
-	struct igt_fb fb_modeset, fb, fbref;
-	struct chamelium_frame_dump *frame_hardware;
-	int fb_id, fb_modeset_id, fbref_id;
+	igt_output_t *output;
+
+	int i;
 	bool ret = true;
+	struct chamelium_port *port;
+	char *connected_ports[4];
 
 	igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_CTM));
 
+	for (i = 0; i < data->port_count; i++)
+		connected_ports[i] =
+			(char *) chamelium_port_get_name(data->ports[i]);
+
 	degamma_linear = generate_table(data->degamma_lut_size, 1.0);
 	gamma_linear = generate_table(data->gamma_lut_size, 1.0);
 
-	igt_output_set_pipe(output, primary->pipe->pipe);
-
-	/* Create a framebuffer at the size of the output. */
-	fb_id = igt_create_fb(data->drm_fd,
-			      mode->hdisplay,
-			      mode->vdisplay,
-			      DRM_FORMAT_XRGB8888,
-			      DRM_FORMAT_MOD_LINEAR,
-			      &fb);
-	igt_assert(fb_id);
-
-	fb_modeset_id = igt_create_fb(data->drm_fd,
+	for_each_valid_output_on_pipe(&data->display,
+				      primary->pipe->pipe,
+				      output) {
+		drmModeModeInfo *mode;
+		struct igt_fb fb_modeset, fb, fbref;
+		struct chamelium_frame_dump *frame_hardware;
+		int fb_id, fb_modeset_id, fbref_id;
+		bool valid_output = false;
+
+		for (i = 0; i < data->port_count; i++)
+			valid_output |=
+				(strcmp(output->name, connected_ports[i]) == 0);
+		if (!valid_output)
+			continue;
+		else
+			for (i = 0; i < data->port_count; i++)
+				if (strcmp(output->name,
+					   connected_ports[i]) == 0)
+					port = data->ports[i];
+
+		igt_output_set_pipe(output, primary->pipe->pipe);
+		mode = igt_output_get_mode(output);
+
+		/* Create a framebuffer at the size of the output. */
+		fb_id = igt_create_fb(data->drm_fd,
 				      mode->hdisplay,
 				      mode->vdisplay,
 				      DRM_FORMAT_XRGB8888,
 				      DRM_FORMAT_MOD_LINEAR,
-				      &fb_modeset);
-	igt_assert(fb_modeset_id);
-
-	fbref_id = igt_create_fb(data->drm_fd,
-				 mode->hdisplay,
-				 mode->vdisplay,
-				 DRM_FORMAT_XRGB8888,
-				 DRM_FORMAT_MOD_LINEAR,
-				 &fbref);
-	igt_assert(fbref_id);
+				      &fb);
+		igt_assert(fb_id);
+
+		fb_modeset_id = igt_create_fb(data->drm_fd,
+					      mode->hdisplay,
+					      mode->vdisplay,
+					      DRM_FORMAT_XRGB8888,
+					      DRM_FORMAT_MOD_LINEAR,
+					      &fb_modeset);
+		igt_assert(fb_modeset_id);
+
+		fbref_id = igt_create_fb(data->drm_fd,
+				      mode->hdisplay,
+				      mode->vdisplay,
+				      DRM_FORMAT_XRGB8888,
+				      DRM_FORMAT_MOD_LINEAR,
+				      &fbref);
+		igt_assert(fbref_id);
+
+		igt_plane_set_fb(primary, &fb_modeset);
+
+		if (memcmp(before, after, sizeof(color_t))) {
+			set_degamma(data, primary->pipe, degamma_linear);
+			set_gamma(data, primary->pipe, gamma_linear);
+		} else {
+			/* Disable Degamma and Gamma for ctm max test */
+			disable_degamma(primary->pipe);
+			disable_gamma(primary->pipe);
+		}
 
-	igt_plane_set_fb(primary, &fb_modeset);
+		disable_ctm(primary->pipe);
+		igt_display_commit(&data->display);
 
-	if (memcmp(before, after, sizeof(color_t))) {
-		set_degamma(data, primary->pipe, degamma_linear);
-		set_gamma(data, primary->pipe, gamma_linear);
-	} else {
-		/* Disable Degamma and Gamma for ctm max test */
-		disable_degamma(primary->pipe);
-		disable_gamma(primary->pipe);
-	}
+		paint_rectangles(data, mode, after, &fbref);
 
-	disable_ctm(primary->pipe);
-	igt_display_commit(&data->display);
+		/* With CTM transformation. */
+		paint_rectangles(data, mode, before, &fb);
+		igt_plane_set_fb(primary, &fb);
+		set_ctm(primary->pipe, ctm_matrix);
+		igt_display_commit(&data->display);
+		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+		frame_hardware =
+			chamelium_read_captured_frame(data->chamelium, 0);
 
-	paint_rectangles(data, mode, after, &fbref);
+		/* Verify that the framebuffer reference of the software
+		 * computed output is equal to the frame dump of the CTM
+		 * matrix transformation output.
+		 */
+		ret &= chamelium_frame_match_or_dump(data->chamelium, port,
+						     frame_hardware,
+						     &fbref,
+						     CHAMELIUM_CHECK_ANALOG);
 
-	/* With CTM transformation. */
-	paint_rectangles(data, mode, before, &fb);
-	igt_plane_set_fb(primary, &fb);
-	set_ctm(primary->pipe, ctm_matrix);
-	igt_display_commit(&data->display);
-	chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
-	frame_hardware =
-		chamelium_read_captured_frame(data->chamelium, 0);
+		igt_plane_set_fb(primary, NULL);
+		igt_output_set_pipe(output, PIPE_NONE);
+	}
 
-	/* Verify that the framebuffer reference of the software
-	 * computed output is equal to the frame dump of the CTM
-	 * matrix transformation output.
-	 */
-	ret &= chamelium_frame_match_or_dump(data->chamelium, port,
-					     frame_hardware,
-					     &fbref,
-					     CHAMELIUM_CHECK_ANALOG);
-
-	igt_plane_set_fb(primary, NULL);
-	disable_degamma(primary->pipe);
-	disable_gamma(primary->pipe);
-	igt_output_set_pipe(output, PIPE_NONE);
-	igt_display_commit(&data->display);
 	free_lut(degamma_linear);
 	free_lut(gamma_linear);
 
 	return ret;
 }
 
-static bool test_pipe_limited_range_ctm(data_t *data,
-					igt_plane_t *primary,
-					struct chamelium_port *port)
+static void test_pipe_limited_range_ctm(data_t *data,
+					igt_plane_t *primary)
 {
 	double limited_result = 235.0 / 255.0;
 	color_t red_green_blue_limited[] = {
@@ -319,355 +391,342 @@ static bool test_pipe_limited_range_ctm(data_t *data,
 			0.0, 1.0, 0.0,
 			0.0, 0.0, 1.0 };
 	gamma_lut_t *degamma_linear, *gamma_linear;
-	igt_output_t *output = data->output;
-	drmModeModeInfo *mode = data->mode;
-	struct igt_fb fb_modeset, fb, fbref;
-	struct chamelium_frame_dump *frame_limited;
-	int fb_id, fb_modeset_id, fbref_id;
-	bool ret = false;
+	igt_output_t *output;
+	bool has_broadcast_rgb_output = false;
+
+	int i;
+	struct chamelium_port *port;
+	char *connected_ports[4];
 
 	igt_require(igt_pipe_obj_has_prop(primary->pipe, IGT_CRTC_CTM));
 
 	degamma_linear = generate_table(data->degamma_lut_size, 1.0);
 	gamma_linear = generate_table(data->gamma_lut_size, 1.0);
 
-	igt_output_set_pipe(output, primary->pipe->pipe);
-
-	/* Create a framebuffer at the size of the output. */
-	fb_id = igt_create_fb(data->drm_fd,
-			      mode->hdisplay,
-			      mode->vdisplay,
-			      DRM_FORMAT_XRGB8888,
-			      DRM_FORMAT_MOD_LINEAR,
-			      &fb);
-	igt_assert(fb_id);
-
-	fb_modeset_id = igt_create_fb(data->drm_fd,
+	for (i = 0; i < data->port_count; i++)
+		connected_ports[i] =
+			(char *) chamelium_port_get_name(data->ports[i]);
+
+	for_each_valid_output_on_pipe(&data->display,
+				      primary->pipe->pipe,
+				      output) {
+		drmModeModeInfo *mode;
+		struct igt_fb fb_modeset, fb, fbref;
+		struct chamelium_frame_dump *frame_limited;
+		int fb_id, fb_modeset_id, fbref_id;
+		bool valid_output = false;
+
+		for (i = 0; i < data->port_count; i++)
+			valid_output |=
+				(strcmp(output->name, connected_ports[i]) == 0);
+		if (!valid_output)
+			continue;
+		else
+			for (i = 0; i < data->port_count; i++)
+				if (strcmp(output->name,
+				    connected_ports[i]) == 0)
+					port = data->ports[i];
+
+		if (!igt_output_has_prop(output, IGT_CONNECTOR_BROADCAST_RGB))
+			continue;
+
+		has_broadcast_rgb_output = true;
+
+		igt_output_set_pipe(output, primary->pipe->pipe);
+		mode = igt_output_get_mode(output);
+
+		/* Create a framebuffer at the size of the output. */
+		fb_id = igt_create_fb(data->drm_fd,
 				      mode->hdisplay,
 				      mode->vdisplay,
 				      DRM_FORMAT_XRGB8888,
 				      DRM_FORMAT_MOD_LINEAR,
-				      &fb_modeset);
-	igt_assert(fb_modeset_id);
-
-	fbref_id = igt_create_fb(data->drm_fd,
-				 mode->hdisplay,
-				 mode->vdisplay,
-				 DRM_FORMAT_XRGB8888,
-				 DRM_FORMAT_MOD_LINEAR,
-				 &fbref);
-	igt_assert(fbref_id);
-
-	igt_plane_set_fb(primary, &fb_modeset);
-
-	set_degamma(data, primary->pipe, degamma_linear);
-	set_gamma(data, primary->pipe, gamma_linear);
-	set_ctm(primary->pipe, ctm);
-
-	igt_output_set_prop_value(output,
-				  IGT_CONNECTOR_BROADCAST_RGB,
-				  BROADCAST_RGB_FULL);
-	paint_rectangles(data, mode, red_green_blue_limited, &fb);
-	igt_plane_set_fb(primary, &fb);
-	igt_display_commit(&data->display);
-
-	/* Set the output into limited range. */
-	igt_output_set_prop_value(output,
-				  IGT_CONNECTOR_BROADCAST_RGB,
-				  BROADCAST_RGB_16_235);
-	paint_rectangles(data, mode, red_green_blue_full, &fb);
-
-	/* And reset.. */
-	igt_output_set_prop_value(output,
-				  IGT_CONNECTOR_BROADCAST_RGB,
-				  BROADCAST_RGB_FULL);
-	igt_plane_set_fb(primary, NULL);
-	igt_output_set_pipe(output, PIPE_NONE);
-	chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
-	frame_limited =
-		chamelium_read_captured_frame(data->chamelium, 0);
-
-
-	/* Verify that the framebuffer reference of the software
-	 * computed output is equal to the frame dump of the CTM
-	 * matrix transformation output.
-	 */
-	ret = chamelium_frame_match_or_dump(data->chamelium, port,
-					    frame_limited, &fbref,
-					    CHAMELIUM_CHECK_ANALOG);
-
-	free_lut(gamma_linear);
-	free_lut(degamma_linear);
+				      &fb);
+		igt_assert(fb_id);
+
+		fb_modeset_id = igt_create_fb(data->drm_fd,
+					      mode->hdisplay,
+					      mode->vdisplay,
+					      DRM_FORMAT_XRGB8888,
+					      DRM_FORMAT_MOD_LINEAR,
+					      &fb_modeset);
+		igt_assert(fb_modeset_id);
+
+		fbref_id = igt_create_fb(data->drm_fd,
+				      mode->hdisplay,
+				      mode->vdisplay,
+				      DRM_FORMAT_XRGB8888,
+				      DRM_FORMAT_MOD_LINEAR,
+				      &fbref);
+		igt_assert(fbref_id);
 
-	return ret;
-}
+		igt_plane_set_fb(primary, &fb_modeset);
 
-static void
-prep_pipe(data_t *data, enum pipe p)
-{
-	igt_require_pipe(&data->display, p);
+		set_degamma(data, primary->pipe, degamma_linear);
+		set_gamma(data, primary->pipe, gamma_linear);
+		set_ctm(primary->pipe, ctm);
+
+		igt_output_set_prop_value(output,
+					  IGT_CONNECTOR_BROADCAST_RGB,
+					  BROADCAST_RGB_FULL);
+		paint_rectangles(data, mode, red_green_blue_limited, &fb);
+		igt_plane_set_fb(primary, &fb);
+		igt_display_commit(&data->display);
+
+		/* Set the output into limited range. */
+		igt_output_set_prop_value(output,
+					  IGT_CONNECTOR_BROADCAST_RGB,
+					  BROADCAST_RGB_16_235);
+		paint_rectangles(data, mode, red_green_blue_full, &fb);
+
+		/* And reset.. */
+		igt_output_set_prop_value(output,
+					  IGT_CONNECTOR_BROADCAST_RGB,
+					  BROADCAST_RGB_FULL);
+		igt_plane_set_fb(primary, NULL);
+		igt_output_set_pipe(output, PIPE_NONE);
+		chamelium_capture(data->chamelium, port, 0, 0, 0, 0, 1);
+		frame_limited =
+			chamelium_read_captured_frame(data->chamelium, 0);
+
+
+		/* Verify that the framebuffer reference of the software
+		 * computed output is equal to the frame dump of the CTM
+		 * matrix transformation output.
+		 */
+		chamelium_frame_match_or_dump(data->chamelium, port,
+					      frame_limited, &fbref,
+					      CHAMELIUM_CHECK_ANALOG);
 
-	if (igt_pipe_obj_has_prop(&data->display.pipes[p], IGT_CRTC_DEGAMMA_LUT_SIZE)) {
-		data->degamma_lut_size =
-			igt_pipe_obj_get_prop(&data->display.pipes[p],
-					      IGT_CRTC_DEGAMMA_LUT_SIZE);
-		igt_assert_lt(0, data->degamma_lut_size);
 	}
 
-	if (igt_pipe_obj_has_prop(&data->display.pipes[p], IGT_CRTC_GAMMA_LUT_SIZE)) {
-		data->gamma_lut_size =
-			igt_pipe_obj_get_prop(&data->display.pipes[p],
-					      IGT_CRTC_GAMMA_LUT_SIZE);
-		igt_assert_lt(0, data->gamma_lut_size);
-	}
+	free_lut(gamma_linear);
+	free_lut(degamma_linear);
+
+	igt_require(has_broadcast_rgb_output);
 }
 
-static int test_setup(data_t *data, enum pipe p)
+static void
+run_tests_for_pipe(data_t *data, enum pipe p)
 {
 	igt_pipe_t *pipe;
-	int i = 0;
+	igt_plane_t *primary;
+	double delta;
+	int i;
+	color_t red_green_blue[] = {
+		{ 1.0, 0.0, 0.0 },
+		{ 0.0, 1.0, 0.0 },
+		{ 0.0, 0.0, 1.0 }
+	};
 
-	igt_display_reset(&data->display);
-	prep_pipe(data, p);
+	igt_fixture {
 
-	pipe = &data->display.pipes[p];
-	igt_require(pipe->n_planes >= 0);
+		igt_require_pipe(&data->display, p);
 
-	data->primary = igt_pipe_get_plane_type(pipe, DRM_PLANE_TYPE_PRIMARY);
+		pipe = &data->display.pipes[p];
+		igt_require(pipe->n_planes >= 0);
 
-	for_each_valid_output_on_pipe(&data->display, p, data->output) {
-		for (i = 0; i < data->port_count; i++) {
-			if (strcmp(data->output->name,
-				   chamelium_port_get_name(data->ports[i])) == 0)
-				return i;
-		}
-	}
+		primary = igt_pipe_get_plane_type(pipe, DRM_PLANE_TYPE_PRIMARY);
 
-	return 0;
-}
+		if (igt_pipe_obj_has_prop(&data->display.pipes[p],
+					  IGT_CRTC_DEGAMMA_LUT_SIZE)) {
+			data->degamma_lut_size =
+				igt_pipe_obj_get_prop(&data->display.pipes[p],
+						IGT_CRTC_DEGAMMA_LUT_SIZE);
+			igt_assert_lt(0, data->degamma_lut_size);
+		}
 
-static void
-run_gamma_degamma_tests_for_pipe(data_t *data, enum pipe p,
-		bool (*test_t)(data_t*, igt_plane_t*, struct chamelium_port*))
-{
-	int port_idx = test_setup(data, p);
+		if (igt_pipe_obj_has_prop(&data->display.pipes[p],
+					  IGT_CRTC_GAMMA_LUT_SIZE)) {
+			data->gamma_lut_size =
+				igt_pipe_obj_get_prop(&data->display.pipes[p],
+						      IGT_CRTC_GAMMA_LUT_SIZE);
+			igt_assert_lt(0, data->gamma_lut_size);
+		}
 
-	igt_require(port_idx);
+		igt_display_require_output_on_pipe(&data->display, p);
+	}
 
 	data->color_depth = 8;
-	data->drm_format = DRM_FORMAT_XRGB8888;
-	data->mode = igt_output_get_mode(data->output);
+	delta = 1.0 / (1 << data->color_depth);
 
-	igt_dynamic_f("pipe-%s-%s", kmstest_pipe_name(p), data->output->name)
-		igt_assert(test_t(data, data->primary, data->ports[port_idx]));
-}
+	igt_describe("Compare after applying ctm matrix & identity matrix");
+	igt_subtest_f("pipe-%s-ctm-red-to-blue", kmstest_pipe_name(p)) {
+		color_t blue_green_blue[] = {
+			{ 0.0, 0.0, 1.0 },
+			{ 0.0, 1.0, 0.0 },
+			{ 0.0, 0.0, 1.0 }
+		};
+		double ctm[] = { 0.0, 0.0, 0.0,
+				0.0, 1.0, 0.0,
+				1.0, 0.0, 1.0 };
+		igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+					 blue_green_blue, ctm));
+	}
 
-static void
-run_ctm_tests_for_pipe(data_t *data, enum pipe p,
-		       color_t *expected_colors,
-		       double *ctm,
-		       int iter)
-{
-	double delta;
-	color_t red_green_blue[] = {
-		{ 1.0, 0.0, 0.0 },
-		{ 0.0, 1.0, 0.0 },
-		{ 0.0, 0.0, 1.0 }
-	};
-	int port_idx = test_setup(data, p);
+	igt_describe("Compare after applying ctm matrix & identity matrix");
+	igt_subtest_f("pipe-%s-ctm-green-to-red", kmstest_pipe_name(p)) {
+		color_t red_red_blue[] = {
+			{ 1.0, 0.0, 0.0 },
+			{ 1.0, 0.0, 0.0 },
+			{ 0.0, 0.0, 1.0 }
+		};
+		double ctm[] = { 1.0, 1.0, 0.0,
+				0.0, 0.0, 0.0,
+				0.0, 0.0, 1.0 };
+		igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+					 red_red_blue, ctm));
+	}
 
-	igt_require(port_idx);
-	/*
-	 * CherryView generates values on 10bits that we
-	 * produce with an 8 bits per color framebuffer.
-	 */
-	if (expected_colors[0].r == 1.0 && ctm[0] == 100)
-		igt_require(!IS_CHERRYVIEW(data->devid));
+	igt_describe("Compare after applying ctm matrix & identity matrix");
+	igt_subtest_f("pipe-%s-ctm-blue-to-red", kmstest_pipe_name(p)) {
+		color_t red_green_red[] = {
+			{ 1.0, 0.0, 0.0 },
+			{ 0.0, 1.0, 0.0 },
+			{ 1.0, 0.0, 0.0 }
+		};
+		double ctm[] = { 1.0, 0.0, 1.0,
+				0.0, 1.0, 0.0,
+				0.0, 0.0, 0.0 };
+		igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+					 red_green_red, ctm));
+	}
 
-	/*
-	 * We assume an 8bits depth per color for degamma/gamma LUTs
-	 * for CRC checks with framebuffer references.
+	/* We tests a few values around the expected result because
+	 * the it depends on the hardware we're dealing with, we can
+	 * either get clamped or rounded values and we also need to
+	 * account for odd number of items in the LUTs.
 	 */
-	data->color_depth = 8;
-	delta = 1.0 / (1 << data->color_depth);
-	data->drm_format = DRM_FORMAT_XRGB8888;
-	data->mode = igt_output_get_mode(data->output);
-
-	igt_dynamic_f("pipe-%s-%s", kmstest_pipe_name(p), data->output->name) {
+	igt_describe("Compare after applying ctm matrix & identity matrix");
+	igt_subtest_f("pipe-%s-ctm-0-25", kmstest_pipe_name(p)) {
+		color_t expected_colors[] = {
+			{ 0.0, }, { 0.0, }, { 0.0, }
+		};
+		double ctm[] = { 0.25, 0.0,  0.0,
+				 0.0,  0.25, 0.0,
+				 0.0,  0.0,  0.25 };
 		bool success = false;
-		int i;
-
-		if (!iter)
-			success = test_pipe_ctm(data, data->primary,
-						red_green_blue,
-						expected_colors, ctm,
-						data->ports[port_idx]);
-
-		/*
-		 * We tests a few values around the expected result because
-		 * it depends on the hardware we're dealing with, we can either
-		 * get clamped or rounded values and we also need to account
-		 * for odd number of items in the LUTs.
-		 */
-		for (i = 0; i < iter; i++) {
+
+		for (i = 0; i < 5; i++) {
 			expected_colors[0].r =
 				expected_colors[1].g =
 				expected_colors[2].b =
-				0.5 + delta * (i - 2);
-			if (test_pipe_ctm(data, data->primary,
-					  red_green_blue, expected_colors,
-					  ctm, data->ports[port_idx])) {
+				0.25 + delta * (i - 2);
+			if(test_pipe_ctm(data, primary, red_green_blue,
+					 expected_colors, ctm)) {
 				success = true;
 				break;
 			}
 		}
 		igt_assert(success);
 	}
-}
-
-static void
-run_limited_range_ctm_test_for_pipe(data_t *data, enum pipe p,
-		bool (*test_t)(data_t*, igt_plane_t*, struct chamelium_port*))
-{
-	int port_idx = test_setup(data, p);
-
-	igt_require(port_idx);
-	igt_require(igt_output_has_prop(data->output, IGT_CONNECTOR_BROADCAST_RGB));
 
-	data->color_depth = 8;
-	data->drm_format = DRM_FORMAT_XRGB8888;
-	data->mode = igt_output_get_mode(data->output);
-
-	igt_dynamic_f("pipe-%s-%s", kmstest_pipe_name(p), data->output->name)
-		igt_assert(test_t(data, data->primary, data->ports[port_idx]));
-}
-
-static void
-run_tests_for_pipe(data_t *data)
-{
-	enum pipe pipe;
-	struct {
-		const char *name;
-		bool (*test_t)(data_t*, igt_plane_t*, struct chamelium_port*);
-		const char *desc;
-	} gamma_degamma_tests[] = {
-		{ "degamma", test_pipe_degamma,
-		  "Verify that degamma LUT transformation works correctly" },
-
-		{ "gamma", test_pipe_gamma,
-		  "Verify that gamma LUT transformation works correctly" },
-	};
-	struct {
-		const char *name;
-		int iter;
-		color_t colors[3];
-		double ctm[9];
-		const char *desc;
-	} ctm_tests[] = {
-		{ "ctm-red-to-blue", 0,
-			{{ 0.0, 0.0, 1.0 },
-			 { 0.0, 1.0, 0.0 },
-			 { 0.0, 0.0, 1.0 }},
-		  { 0.0, 0.0, 0.0,
-		    0.0, 1.0, 0.0,
-		    1.0, 0.0, 1.0 },
-		  "Check the color transformation from red to blue"
-		},
-		{ "ctm-green-to-red", 0,
-			{{ 1.0, 0.0, 0.0 },
-			 { 1.0, 0.0, 0.0 },
-			 { 0.0, 0.0, 1.0 }},
-		  { 1.0, 1.0, 0.0,
-		    0.0, 0.0, 0.0,
-		    0.0, 0.0, 1.0 },
-		  "Check the color transformation from green to red"
-		},
-		{ "ctm-blue-to-red", 0,
-			{{ 1.0, 0.0, 0.0 },
-			 { 0.0, 1.0, 0.0 },
-			 { 1.0, 0.0, 0.0 }},
-		  { 1.0, 0.0, 1.0,
-		    0.0, 1.0, 0.0,
-		    0.0, 0.0, 0.0 },
-		  "Check the color transformation from blue to red"
-		},
-		{ "ctm-max", 0,
-			{{ 1.0, 0.0, 0.0 },
-			 { 0.0, 1.0, 0.0 },
-			 { 0.0, 0.0, 1.0 }},
-		  { 100.0, 0.0, 0.0,
-		    0.0, 100.0, 0.0,
-		    0.0, 0.0, 100.0 },
-		  "Check the color transformation for maximum transparency"
-		},
-		{ "ctm-negative", 0,
-			{{ 0.0, 0.0, 0.0 },
-			 { 0.0, 0.0, 0.0 },
-			 { 0.0, 0.0, 0.0 }},
-		  { -1.0, 0.0, 0.0,
-		    0.0, -1.0, 0.0,
-		    0.0, 0.0, -1.0 },
-		  "Check the color transformation for negative transparency"
-		},
-		{ "ctm-0-25", 5,
-			{{ 0.0, }, { 0.0, }, { 0.0, }},
-		  { 0.25, 0.0,  0.0,
-		    0.0,  0.25, 0.0,
-		    0.0,  0.0,  0.25 },
-		  "Check the color transformation for 0.25 transparency"
-		},
-		{ "ctm-0-50", 5,
-			{{ 0.0, }, { 0.0, }, { 0.0, }},
-		  { 0.5,  0.0,  0.0,
-		    0.0,  0.5,  0.0,
-		    0.0,  0.0,  0.5 },
-		  "Check the color transformation for 0.5 transparency"
-		},
-		{ "ctm-0-75", 7,
-			{{ 0.0, }, { 0.0, }, { 0.0, }},
-		  { 0.75, 0.0,  0.0,
-		    0.0,  0.75, 0.0,
-		    0.0,  0.0,  0.75 },
-		  "Check the color transformation for 0.75 transparency"
-		},
-	};
-	int i;
+	igt_describe("Compare after applying ctm matrix & identity matrix");
+	igt_subtest_f("pipe-%s-ctm-0-5", kmstest_pipe_name(p)) {
+		color_t expected_colors[] = {
+			{ 0.0, }, { 0.0, }, { 0.0, }
+		};
+		double ctm[] = { 0.5, 0.0, 0.0,
+				 0.0, 0.5, 0.0,
+				 0.0, 0.0, 0.5 };
+		bool success = false;
 
-	for (i = 0; i < ARRAY_SIZE(gamma_degamma_tests); i++) {
-		igt_describe_f("%s", gamma_degamma_tests[i].desc);
-		igt_subtest_with_dynamic_f("%s", gamma_degamma_tests[i].name) {
-			for_each_pipe(&data->display, pipe) {
-				run_gamma_degamma_tests_for_pipe(data, pipe,
-								 gamma_degamma_tests[i].test_t);
+		for (i = 0; i < 5; i++) {
+			expected_colors[0].r =
+				expected_colors[1].g =
+				expected_colors[2].b =
+				0.5 + delta * (i - 2);
+			if(test_pipe_ctm(data, primary, red_green_blue,
+					 expected_colors, ctm)) {
+				success = true;
+				break;
 			}
 		}
+		igt_assert(success);
 	}
 
-	for (i = 0; i < ARRAY_SIZE(ctm_tests); i++) {
-		igt_describe_f("%s", ctm_tests[i].desc);
-		igt_subtest_with_dynamic_f("%s", ctm_tests[i].name) {
-			for_each_pipe(&data->display, pipe) {
-				run_ctm_tests_for_pipe(data, pipe,
-						       ctm_tests[i].colors,
-						       ctm_tests[i].ctm,
-						       ctm_tests[i].iter);
+	igt_describe("Compare after applying ctm matrix & identity matrix");
+	igt_subtest_f("pipe-%s-ctm-0-75", kmstest_pipe_name(p)) {
+		color_t expected_colors[] = {
+			{ 0.0, }, { 0.0, }, { 0.0, }
+		};
+		double ctm[] = { 0.75, 0.0,  0.0,
+				 0.0,  0.75, 0.0,
+				 0.0,  0.0,  0.75 };
+		bool success = false;
+
+		for (i = 0; i < 7; i++) {
+			expected_colors[0].r =
+				expected_colors[1].g =
+				expected_colors[2].b =
+				0.75 + delta * (i - 3);
+			if(test_pipe_ctm(data, primary, red_green_blue,
+					 expected_colors, ctm)) {
+				success = true;
+				break;
 			}
 		}
+		igt_assert(success);
 	}
 
 	igt_describe("Compare after applying ctm matrix & identity matrix");
-	igt_subtest_with_dynamic("ctm-limited-range") {
-		for_each_pipe(&data->display, pipe) {
-			run_limited_range_ctm_test_for_pipe(data, pipe,
-							    test_pipe_limited_range_ctm);
-		}
+	igt_subtest_f("pipe-%s-ctm-max", kmstest_pipe_name(p)) {
+		color_t full_rgb[] = {
+			{ 1.0, 0.0, 0.0 },
+			{ 0.0, 1.0, 0.0 },
+			{ 0.0, 0.0, 1.0 }
+		};
+		double ctm[] = { 100.0,   0.0,   0.0,
+				 0.0,   100.0,   0.0,
+				 0.0,     0.0, 100.0 };
+
+		/* CherryView generates values on 10bits that we
+		 * produce with an 8 bits per color framebuffer.
+		 */
+		igt_require(!IS_CHERRYVIEW(data->devid));
+
+		igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+					 full_rgb, ctm));
+	}
+
+	igt_describe("Compare after applying ctm matrix & identity matrix");
+	igt_subtest_f("pipe-%s-ctm-negative", kmstest_pipe_name(p)) {
+		color_t all_black[] = {
+			{ 0.0, 0.0, 0.0 },
+			{ 0.0, 0.0, 0.0 },
+			{ 0.0, 0.0, 0.0 }
+		};
+		double ctm[] = { -1.0,  0.0,  0.0,
+				 0.0, -1.0,  0.0,
+				 0.0,  0.0, -1.0 };
+		igt_assert(test_pipe_ctm(data, primary, red_green_blue,
+					 all_black, ctm));
 	}
 
+	igt_describe("Compare after applying ctm matrix & identity matrix");
+	igt_subtest_f("pipe-%s-ctm-limited-range", kmstest_pipe_name(p))
+		test_pipe_limited_range_ctm(data, primary);
+
+	igt_describe("Compare maxed out gamma LUT and solid color linear LUT");
+	igt_subtest_f("pipe-%s-degamma", kmstest_pipe_name(p))
+		test_pipe_degamma(data, primary);
+
+	igt_describe("Compare maxed out gamma LUT and solid color linear LUT");
+	igt_subtest_f("pipe-%s-gamma", kmstest_pipe_name(p))
+		test_pipe_gamma(data, primary);
+
+	igt_fixture {
+		disable_degamma(primary->pipe);
+		disable_gamma(primary->pipe);
+		disable_ctm(primary->pipe);
+		igt_display_commit(&data->display);
+	}
 }
 
 igt_main
 {
 	data_t data = {};
+	enum pipe pipe;
 
 	igt_fixture {
 		data.drm_fd = drm_open_driver_master(DRIVER_ANY);
@@ -692,8 +751,9 @@ igt_main
 		kmstest_set_vt_graphics_mode();
 	}
 
-	igt_subtest_group
-		run_tests_for_pipe(&data);
+	for_each_pipe_static(pipe)
+		igt_subtest_group
+			run_tests_for_pipe(&data, pipe);
 
 	igt_fixture {
 		igt_display_fini(&data.display);
Signature · 1 line
2.37.3
#8 lore raw

PATCH v2 8/8 tests/kms_color: Fix crc compare check in CTM tests

In reply to Bhanuprakash Modem

!igt_skip_crc_compare || igt_check_crc_equal() is always true which is not correct.

Fixes 1a42910d
---
 tests/kms_color.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tests/kms_color.c +1 -1
index ba06947b..e2462aa3 100644
@@ -510,7 +510,7 @@ static bool test_pipe_ctm(data_t *data,
 	/* Verify that the CRC of the software computed output is
 	 * equal to the CRC of the CTM matrix transformation output.
 	 */
-	ret &= !igt_skip_crc_compare || igt_check_crc_equal(&crc_software, &crc_hardware);
+	ret = igt_skip_crc_compare || igt_check_crc_equal(&crc_software, &crc_hardware);
 
 	igt_plane_set_fb(primary, NULL);
 	igt_output_set_pipe(output, PIPE_NONE);

--
2.37.3

#9 lore raw

Re: [igt-dev] [i-g-t V2 8/8] tests/kms_color: Fix crc compare check in CTM tests

Quoted 4 lines · Bhanuprakash Modem

!igt_skip_crc_compare || igt_check_crc_equal() is always true which is not correct.

Fixes 1a42910d

Hang on. Now you're saying the regression in detecting actual failures was introduced in commit 1a42910d4f8b ("tests/kms_color: Don't opencode igt_check_crc_equal()") rather than the dynamic subtest conversion commit (which is what the previous Fixes line claimed)?

So apparently the test may have been broken for 1.5 years now and no one realize it.

Hmm. And idea just came to me. Could we introduce some kind of fairly generic (say, igt_fb level) knob that would attempt to introduce a real crc mismatch into all (or at least most) tests? Eg. maybe igt_fb could frob around with the pixels a bit or something? This would at least allow one to easily verify that the test *may* start to fail when turning that knob on. Whether it actually starts to fail for a given pixel frobbry isn't 100% guaraneed though since we could just end up with a crc collision by dumb luck. Ideally we would have some way to guarantee the failure, and then we would just make CI run every test a second time with knob turned on to validate that the test can actually detect the failure. But maybe this is a pipe dream.

Quoted 20 lines
---
 tests/kms_color.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tests/kms_color.c +1 -2
index ba06947b..e2462aa3 100644
@@ -510,7 +510,7 @@ static bool test_pipe_ctm(data_t *data,
 	/* Verify that the CRC of the software computed output is
 	 * equal to the CRC of the CTM matrix transformation output.
 	 */
-	ret &= !igt_skip_crc_compare || igt_check_crc_equal(&crc_software, &crc_hardware);
+	ret = igt_skip_crc_compare || igt_check_crc_equal(&crc_software, &crc_hardware);
 
 	igt_plane_set_fb(primary, NULL);
 	igt_output_set_pipe(output, PIPE_NONE);
--

2.37.3

Signature · 2 lines
Ville Syrjälä
Intel
#10 lore raw

Re: [igt-dev] [i-g-t V2 8/8] tests/kms_color: Fix crc compare check in CTM tests

Quoted 6 lines · Ville Syrjälä
Quoted 4 lines · Bhanuprakash Modem

!igt_skip_crc_compare || igt_check_crc_equal() is always true which is not correct.

Fixes 1a42910d
Quoted 7 lines

Hang on. Now you're saying the regression in detecting actual failures was introduced in commit 1a42910d4f8b ("tests/kms_color: Don't opencode igt_check_crc_equal()") rather than the dynamic subtest conversion commit (which is what the previous Fixes line claimed)?

So apparently the test may have been broken for 1.5 years now and no one realize it.

Looks like the tests were in fact failing (at least on some hw) before and CI did notice the change in the behaviour:
https://patchwork.freedesktop.org/series/88075/#rev2

But it did not raise any kind of stink about that, and still flagged the whole thing as an overall success. I presume Lyude neglected to look at the individual results in any detail once the overall succees was indicated (kinda dangerous thing to do with our CI it seems).

So why did CI not present that change in behaviour more prominently?

Is it because we went from FAIL to apparent SUCCESS and that's always considered sort of fine. I suppose flagging the thing a failure because something seems to have gotten fixed would be weird, but maybe it should at least present such changes in behaviour at the top of the list.

Or is it because it attributed that change to these bugs
https://gitlab.freedesktop.org/drm/intel/-/issues/1149
https://gitlab.freedesktop.org/drm/intel/-/issues/315
Does CI consider everything with an associated bug a potential ping pong and just basically hides any change it the result in that big list of CI noise in the report (which this series hit a lot)? If so we need to get that fixed. Expected fail should be handled differently from a known ping pong.

Signature · 2 lines
Ville Syrjälä
Intel
#11 lore raw

Re: [igt-dev] [i-g-t V2 8/8] tests/kms_color: Fix crc compare check in CTM tests

Quoted 19 lines · Ville Syrjälä
Quoted 6 lines · Ville Syrjälä
Quoted 4 lines · Bhanuprakash Modem

!igt_skip_crc_compare || igt_check_crc_equal() is always true which is not correct.

Fixes 1a42910d
Quoted 7 lines

Hang on. Now you're saying the regression in detecting actual failures was introduced in commit 1a42910d4f8b ("tests/kms_color: Don't opencode igt_check_crc_equal()") rather than the dynamic subtest conversion commit (which is what the previous Fixes line claimed)?

So apparently the test may have been broken for 1.5 years now and no one realize it.

Looks like the tests were in fact failing (at least on some hw) before and CI did notice the change in the behaviour:
https://patchwork.freedesktop.org/series/88075/#rev2

Quoted 5 lines

But it did not raise any kind of stink about that, and still flagged the whole thing as an overall success. I presume Lyude neglected to look at the individual results in any detail once the overall succees was indicated (kinda dangerous thing to do with our CI it seems).

The previous run was full of notruns, making the results all kinds of noisy =(

Quoted 9 lines

So why did CI not present that change in behaviour more prominently?

Is it because we went from FAIL to apparent SUCCESS and that's always considered sort of fine. I suppose flagging the thing a failure because something seems to have gotten fixed would be weird, but maybe it should at least present such changes in behaviour at the top of the list.

Are you saying the "Possible fixes" section should come before "Issues hit"? Reasonable ask.

But the "Possible fixes" section in that result had 18 tests change state to PASS. I suppose it's possible to just ctrl+f for kms_color there but to a non-i915 developer, how should one have noticed something is amiss? In a results email of ten billion status changes. As you said, the overall verdict of "success" sounds like something that could be followed.

Quoted 8 lines

Or is it because it attributed that change to these bugs
https://gitlab.freedesktop.org/drm/intel/-/issues/1149
https://gitlab.freedesktop.org/drm/intel/-/issues/315
Does CI consider everything with an associated bug a potential ping pong and just basically hides any change it the result in that big list of CI noise in the report (which this series hit a lot)? If so we need to get that fixed. Expected fail should be handled differently from a known ping pong.

Ah, the meat of the matter. The kms_color results indeed went from #1149 and #315 to PASS. Which possibly should have caused some alarm bells. The question is how to add that logic.

At this time we don't have the possibility of marking XFAIL in cibuglog to raise alarms on a test going PASS when it shouldn't. I suspect the need isn't that great for that functionality, a rough guesstimate for the amount of such bug reports is two, these kms_color ones. Having that functionality for SKIP results would be a nightmare to maintain, for skips that depend on, say, the display configuration.

Signature · 1 line
Petri Latvala
#12 lore raw

Re: [igt-dev] [i-g-t V2 8/8] tests/kms_color: Fix crc compare check in CTM tests

In reply to Ville Syrjälä
Quoted 19 lines · Ville Syrjälä
Quoted 6 lines · Ville Syrjälä
Quoted 4 lines · Bhanuprakash Modem

!igt_skip_crc_compare || igt_check_crc_equal() is always true which is not correct.

Fixes 1a42910d
Quoted 7 lines

Hang on. Now you're saying the regression in detecting actual failures was introduced in commit 1a42910d4f8b ("tests/kms_color: Don't opencode igt_check_crc_equal()") rather than the dynamic subtest conversion commit (which is what the previous Fixes line claimed)?

So apparently the test may have been broken for 1.5 years now and no one realize it.

Looks like the tests were in fact failing (at least on some hw) before and CI did notice the change in the behaviour:
https://patchwork.freedesktop.org/series/88075/#rev2

Quoted 5 lines

But it did not raise any kind of stink about that, and still flagged the whole thing as an overall success. I presume Lyude neglected to look at the individual results in any detail once the overall succees was indicated (kinda dangerous thing to do with our CI it seems).

sheesh, I'll definitely keep this in mind for the future. Glad it at least wasn't a clear cut case of me just missing the CI output entirely lol…

fwiw, feel fine to revert this change. it was a minor nitpick

Quoted 19 lines

So why did CI not present that change in behaviour more prominently?

Is it because we went from FAIL to apparent SUCCESS and that's always considered sort of fine. I suppose flagging the thing a failure because something seems to have gotten fixed would be weird, but maybe it should at least present such changes in behaviour at the top of the list.

Or is it because it attributed that change to these bugs
https://gitlab.freedesktop.org/drm/intel/-/issues/1149
https://gitlab.freedesktop.org/drm/intel/-/issues/315
Does CI consider everything with an associated bug a potential ping pong and just basically hides any change it the result in that big list of CI noise in the report (which this series hit a lot)? If so we need to get that fixed. Expected fail should be handled differently from a known ping pong.

Signature · 3 lines
Cheers,
 Lyude Paul (she/her)
 Software Engineer at Red Hat
#13 lore raw

Re: [igt-dev] [i-g-t V2 8/8] tests/kms_color: Fix crc compare check in CTM tests

Quoted 26 lines · Lyude Paul
Quoted 19 lines · Ville Syrjälä
Quoted 6 lines · Ville Syrjälä
Quoted 4 lines · Bhanuprakash Modem

!igt_skip_crc_compare || igt_check_crc_equal() is always true which is not correct.

Fixes 1a42910d
Quoted 7 lines

Hang on. Now you're saying the regression in detecting actual failures was introduced in commit 1a42910d4f8b ("tests/kms_color: Don't opencode igt_check_crc_equal()") rather than the dynamic subtest conversion commit (which is what the previous Fixes line claimed)?

So apparently the test may have been broken for 1.5 years now and no one realize it.

Looks like the tests were in fact failing (at least on some hw) before and CI did notice the change in the behaviour:
https://patchwork.freedesktop.org/series/88075/#rev2

Quoted 5 lines

But it did not raise any kind of stink about that, and still flagged the whole thing as an overall success. I presume Lyude neglected to look at the individual results in any detail once the overall succees was indicated (kinda dangerous thing to do with our CI it seems).

Quoted 4 lines

sheesh, I'll definitely keep this in mind for the future. Glad it at least wasn't a clear cut case of me just missing the CI output entirely lol…

fwiw, feel fine to revert this change. it was a minor nitpick

I guess some kind of mass revert is still needed, or someone needs to just figure out why the test is now broken. And I'm not talking about the failures on icl+ (or maybe glk+) since those are apparently expected. But the idle runs are now showing the test failing on absolutely all machines, so clearly a real regression has managed to sneak in.

Signature · 2 lines
Ville Syrjälä
Intel
#14 lore raw

Re: [igt-dev] [i-g-t V2 8/8] tests/kms_color: Fix crc compare check in CTM tests

Quoted 30 lines · Ville Syrjälä
Quoted 29 lines · Lyude Paul
Quoted 19 lines · Ville Syrjälä
Quoted 6 lines · Ville Syrjälä
Quoted 4 lines · Bhanuprakash Modem

!igt_skip_crc_compare || igt_check_crc_equal() is always true which is not correct.

Fixes 1a42910d
Quoted 7 lines

Hang on. Now you're saying the regression in detecting actual failures was introduced in commit 1a42910d4f8b ("tests/kms_color: Don't opencode igt_check_crc_equal()") rather than the dynamic subtest conversion commit (which is what the previous Fixes line claimed)?

So apparently the test may have been broken for 1.5 years now and no one realize it.

Looks like the tests were in fact failing (at least on some hw) before and CI did notice the change in the behaviour:
https://patchwork.freedesktop.org/series/88075/#rev2

Quoted 5 lines

But it did not raise any kind of stink about that, and still flagged the whole thing as an overall success. I presume Lyude neglected to look at the individual results in any detail once the overall succees was indicated (kinda dangerous thing to do with our CI it seems).

sheesh, I'll definitely keep this in mind for the future. Glad it at least wasn't a clear cut case of me just missing the CI output entirely lol…

Quoted 8 lines
Quoted 1 line

fwiw, feel fine to revert this change. it was a minor nitpick

I guess some kind of mass revert is still needed, or someone needs to just figure out why the test is now broken. And I'm not talking about the failures on icl+ (or maybe glk+) since those are apparently expected. But the idle runs are now showing the test failing on absolutely all machines, so clearly a real regression has managed to sneak in.

From this series (or the same series in try-bot [1]), it is clear that this regression is not due to the dynamic subtests.

I'll try to figure out why the test is failing.

[1] https://patchwork.freedesktop.org/series/108837/

- Bhanu

Quoted 1 line
#15 lore raw

[igt-dev] ✗ Fi.CI.BUILD: failure for Revert Color patches

In reply to Bhanuprakash Modem
== Series Details ==

== Series Details ==

Series: Revert Color patches
URL : https://patchwork.freedesktop.org/series/108864/
State : failure

== Summary ==

Applying: Revert "tests/kms_color: fix crc assert condition"
Applying: Revert "tests/kms: Fix to use max_bpc constraint helper"
Applying: Revert "tests/kms_color: Fix multiple failures in deep-color tests"
Applying: Revert "tests/kms_color: Fix memory leaks"
Applying: Revert "tests/kms_color: Test Cleanup"
Applying: Revert "tests/kms_color: Convert tests to dynamic"
Applying: Revert "tests/kms_color_chamelium: Convert tests to dynamic" Using index info to reconstruct a base tree...
M tests/chamelium/kms_color_chamelium.c
Falling back to patching base and 3-way merge...
Auto-merging tests/chamelium/kms_color_chamelium.c
CONFLICT (content): Merge conflict in tests/chamelium/kms_color_chamelium.c Patch failed at 0007 Revert "tests/kms_color_chamelium: Convert tests to dynamic" When you have resolved this problem, run "git am --continue".
If you prefer to skip this patch, run "git am --skip" instead.
To restore the original branch and stop patching, run "git am --abort".