[igt-dev] [PATCH i-g-t] tests/kms_rotation_crc: Create dynamic subtests

* [igt-dev] [PATCH i-g-t] tests/kms_rotation_crc: Create dynamic subtests
@ 2022-06-23 16:02 Jeevan B
  2022-06-23 17:08 ` [igt-dev] ✓ Fi.CI.BAT: success for " Patchwork
                   ` (3 more replies)
  0 siblings, 4 replies; 5+ messages in thread
From: Jeevan B @ 2022-06-23 16:02 UTC (permalink / raw)
  To: igt-dev

Convert the existing subtests to dynamic subtests at pipe level.

Signed-off-by: Jeevan B <jeevan.b@intel.com>
---
 tests/kms_rotation_crc.c | 591 +++++++++++++++++++++------------------
 1 file changed, 316 insertions(+), 275 deletions(-)

diff --git a/tests/kms_rotation_crc.c b/tests/kms_rotation_crc.c
index 50869a08..ae925844 100644
--- a/tests/kms_rotation_crc.c
+++ b/tests/kms_rotation_crc.c
@@ -454,13 +454,13 @@ static bool test_format(data_t *data,
 	return true;
 }
 
-static void test_plane_rotation(data_t *data, int plane_type, bool test_bad_format)
+static void test_plane_rotation(data_t *data, int plane_type, bool test_bad_format, int pipe,
+				igt_output_t *output)
 {
 	igt_display_t *display = &data->display;
 	drmModeModeInfo *mode;
-	igt_output_t *output;
-	enum pipe pipe;
-	int pipe_count = 0, connected_outputs = 0;
+	igt_plane_t *plane;
+	int i, j, c;
 
 	if (is_amdgpu_device(data->gfx_fd))
 		igt_require(plane_type != DRM_PLANE_TYPE_OVERLAY &&
@@ -471,105 +471,90 @@ static void test_plane_rotation(data_t *data, int plane_type, bool test_bad_form
 
 	igt_display_require_output(display);
 
-	for_each_connected_output(&data->display, output)
-		connected_outputs++;
-
-	for_each_pipe_with_valid_output(display, pipe, output) {
-		igt_plane_t *plane;
-		int i, j, c;
-
-		mode = igt_output_get_mode(output);
-
-		/*
-		 * Find mode which is in use in connector. If this is mode
-		 * which was not run on earlier we'll end up on zeroed
-		 * struct crc_rect and recalculate reference crcs.
-		 */
-		for (data->output_crc_in_use = 0;
-		     data->output_crc_in_use < data->max_crc_in_use &&
-		     data->crc_rect[data->output_crc_in_use][0].mode != mode->vdisplay;
-		     data->output_crc_in_use++)
-			;
+	mode = igt_output_get_mode(output);
 
-		/*
-		 * This is if there was different mode on different connector
-		 * and this mode was not run on before.
-		 */
-		if (data->crc_rect[data->output_crc_in_use][0].mode != mode->vdisplay) {
-			data->crc_rect[data->output_crc_in_use][0].mode = mode->vdisplay;
-			data->max_crc_in_use++;
+	/*
+	 * Find mode which is in use in connector. If this is mode
+	 * which was not run on earlier we'll end up on zeroed
+	 * struct crc_rect and recalculate reference crcs.
+	 */
+	for (data->output_crc_in_use = 0;
+	     data->output_crc_in_use < data->max_crc_in_use &&
+	     data->crc_rect[data->output_crc_in_use][0].mode != mode->vdisplay;
+	     data->output_crc_in_use++)
+		;
 
+	/*
+	 * This is if there was different mode on different connector
+	 * and this mode was not run on before.
+	 */
+	if (data->crc_rect[data->output_crc_in_use][0].mode != mode->vdisplay) {
+		data->crc_rect[data->output_crc_in_use][0].mode = mode->vdisplay;
+		data->max_crc_in_use++;
 			if (data->max_crc_in_use >= MAX_TESTED_MODES)
 				data->max_crc_in_use = MAX_TESTED_MODES - 1;
-		}
-
-		for (c = 0; c < num_rectangle_types; c++)
-			data->crc_rect[data->output_crc_in_use][c].valid = false;
-
-		/* restricting the execution to 2 pipes to reduce execution time*/
-		if (pipe_count == 2 * connected_outputs && !data->extended)
-			break;
-		pipe_count++;
-
-		igt_output_set_pipe(output, pipe);
+	}
 
-		plane = igt_output_get_plane_type(output, plane_type);
-		igt_require(igt_plane_has_prop(plane, IGT_PLANE_ROTATION));
-		igt_require(igt_plane_has_rotation(plane, data->rotation));
-		/* CHV can't rotate and reflect simultaneously */
-		igt_require(!is_i915_device(data->gfx_fd) ||
-			    !IS_CHERRYVIEW(data->devid) ||
-			    data->rotation != (IGT_ROTATION_180 | IGT_REFLECT_X));
+	for (c = 0; c < num_rectangle_types; c++)
+		data->crc_rect[data->output_crc_in_use][c].valid = false;
 
-		prepare_crtc(data, output, pipe, plane, true);
+	igt_output_set_pipe(output, pipe);
 
-		for (i = 0; i < num_rectangle_types; i++) {
-			/* Unsupported on i915 */
-			if (plane_type == DRM_PLANE_TYPE_CURSOR &&
-			    i != square)
+	plane = igt_output_get_plane_type(output, plane_type);
+	igt_require(igt_plane_has_prop(plane, IGT_PLANE_ROTATION));
+	igt_require(igt_plane_has_rotation(plane, data->rotation));
+	/* CHV can't rotate and reflect simultaneously */
+	igt_require(!is_i915_device(data->gfx_fd) ||
+		    !IS_CHERRYVIEW(data->devid) ||
+		    data->rotation != (IGT_ROTATION_180 | IGT_REFLECT_X));
+
+	prepare_crtc(data, output, pipe, plane, true);
+
+	for (i = 0; i < num_rectangle_types; i++) {
+		/* Unsupported on i915 */
+		if (plane_type == DRM_PLANE_TYPE_CURSOR &&
+		    i != square)
+			continue;
+
+		/* Only support partial covering primary plane on gen9+ */
+		if (is_amdgpu_device(data->gfx_fd) ||
+			(plane_type == DRM_PLANE_TYPE_PRIMARY &&
+			 is_i915_device(data->gfx_fd) &&
+			 intel_display_ver(
+				 intel_get_drm_devid(data->gfx_fd)) < 9)) {
+			if (i != rectangle)
 				continue;
+			else
+				data->use_native_resolution = true;
+		} else {
+			data->use_native_resolution = false;
+		}
 
-			/* Only support partial covering primary plane on gen9+ */
-			if (is_amdgpu_device(data->gfx_fd) ||
-				(plane_type == DRM_PLANE_TYPE_PRIMARY &&
-				 is_i915_device(data->gfx_fd) &&
-				 intel_display_ver(
-					 intel_get_drm_devid(data->gfx_fd)) < 9)) {
-				if (i != rectangle)
-					continue;
-				else
-					data->use_native_resolution = true;
-			} else {
-				data->use_native_resolution = false;
-			}
-
-			if (!data->override_fmt) {
-				struct igt_vec tested_formats;
-
-				igt_vec_init(&tested_formats, sizeof(uint32_t));
+		if (!data->override_fmt) {
+			struct igt_vec tested_formats;
 
-				for (j = 0; j < plane->drm_plane->count_formats; j++) {
-					uint32_t format = plane->drm_plane->formats[j];
+			igt_vec_init(&tested_formats, sizeof(uint32_t));
 
-					if (!test_format(data, &tested_formats, format))
-						continue;
+			for (j = 0; j < plane->drm_plane->count_formats; j++) {
+				uint32_t format = plane->drm_plane->formats[j];
 
-					test_single_case(data, pipe, output, plane, i,
-							 format, test_bad_format);
-				}
-
-				igt_vec_fini(&tested_formats);
-			} else {
+				if (!test_format(data, &tested_formats, format))
+					continue;
 				test_single_case(data, pipe, output, plane, i,
-						 data->override_fmt, test_bad_format);
+						 format, test_bad_format);
 			}
+				igt_vec_fini(&tested_formats);
+		} else {
+			test_single_case(data, pipe, output, plane, i,
+					 data->override_fmt, test_bad_format);
 		}
-		if (is_i915_device(data->gfx_fd)) {
-			igt_pipe_crc_stop(data->pipe_crc);
-		}
+	}
+	if (is_i915_device(data->gfx_fd)) {
+		igt_pipe_crc_stop(data->pipe_crc);
 	}
 }
 
+
 typedef struct {
 	int32_t x1, y1;
 	uint64_t width, height, modifier, format;
@@ -665,10 +650,9 @@ static void pointlocation(data_t *data, planeinfos *p, drmModeModeInfo *mode,
  * It is left here if this test ever was wanted to be run on
  * different pipes.
  */
-static void test_multi_plane_rotation(data_t *data, enum pipe pipe)
+static void test_multi_plane_rotation(data_t *data, enum pipe pipe, igt_output_t *output)
 {
 	igt_display_t *display = &data->display;
-	igt_output_t *output;
 	igt_crc_t retcrc_sw, retcrc_hw;
 	planeinfos p[2];
 	int used_w, used_h, lastroundirotation = 0, lastroundjrotation = 0,
@@ -706,182 +690,189 @@ static void test_multi_plane_rotation(data_t *data, enum pipe pipe)
 	{IGT_ROTATION_270, .2f, .4f, I915_FORMAT_MOD_Yf_TILED },
 	};
 
-	for_each_valid_output_on_pipe(display, pipe, output) {
-		int i, j, k, l, flipsw, fliphw;
-		igt_output_set_pipe(output, pipe);
-		mode = igt_output_get_mode(output);
-		igt_display_require_output(display);
-		igt_display_commit2(display, COMMIT_ATOMIC);
-
-		used_w = TEST_WIDTH(mode);
-		used_h = TEST_HEIGHT(mode);
-
-		p[0].plane = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
-		p[1].plane = igt_output_get_plane_type(output, DRM_PLANE_TYPE_OVERLAY);
-
-		data->pipe_crc = igt_pipe_crc_new(data->gfx_fd, pipe,
-						  INTEL_PIPE_CRC_SOURCE_AUTO);
-		igt_pipe_crc_start(data->pipe_crc);
-
-		for (i = 0; i < ARRAY_SIZE(planeconfigs); i++) {
-			p[0].width = (uint64_t)(planeconfigs[i].width * used_w);
-			p[0].height = (uint64_t)(planeconfigs[i].height * used_h);
-			p[0].modifier = planeconfigs[i].modifier;
-			pointlocation(data, (planeinfos *)&p, mode, 0);
-
-			for (k = 0; k < ARRAY_SIZE(formatlist); k++) {
-				p[0].format = formatlist[k];
+	int i, j, k, l, flipsw, fliphw;
 
-				for (j = 0; j < ARRAY_SIZE(planeconfigs); j++) {
-					p[1].width = (uint64_t)(planeconfigs[j].width * used_w);
-					p[1].height = (uint64_t)(planeconfigs[j].height * used_h);
-					p[1].modifier = planeconfigs[j].modifier;
-					pointlocation(data, (planeinfos *)&p,
-						      mode, 1);
-
-					for (l = 0; l < ARRAY_SIZE(formatlist); l++) {
-						p[1].format = formatlist[l];
-						/*
-						 * RGB565 90/270 degrees rotation is supported
-						 * from gen11 onwards.
-						 */
-						if (p[0].format == DRM_FORMAT_RGB565 &&
-						     igt_rotation_90_or_270(planeconfigs[i].rotation)
-						     && intel_display_ver(data->devid) < 11)
-							continue;
+	igt_output_set_pipe(output, pipe);
+	mode = igt_output_get_mode(output);
+	igt_display_require_output(display);
+	igt_display_commit2(display, COMMIT_ATOMIC);
+
+	used_w = TEST_WIDTH(mode);
+	used_h = TEST_HEIGHT(mode);
+
+	p[0].plane = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
+	p[1].plane = igt_output_get_plane_type(output, DRM_PLANE_TYPE_OVERLAY);
+
+	data->pipe_crc = igt_pipe_crc_new(data->gfx_fd, pipe,
+					  INTEL_PIPE_CRC_SOURCE_AUTO);
+	igt_pipe_crc_start(data->pipe_crc);
+
+	for (i = 0; i < ARRAY_SIZE(planeconfigs); i++) {
+		p[0].width = (uint64_t)(planeconfigs[i].width * used_w);
+		p[0].height = (uint64_t)(planeconfigs[i].height * used_h);
+		p[0].modifier = planeconfigs[i].modifier;
+		pointlocation(data, (planeinfos *)&p, mode, 0);
+
+		for (k = 0; k < ARRAY_SIZE(formatlist); k++) {
+			p[0].format = formatlist[k];
+
+			for (j = 0; j < ARRAY_SIZE(planeconfigs); j++) {
+				p[1].width = (uint64_t)(planeconfigs[j].width * used_w);
+				p[1].height = (uint64_t)(planeconfigs[j].height * used_h);
+				p[1].modifier = planeconfigs[j].modifier;
+				pointlocation(data, (planeinfos *)&p,
+					      mode, 1);
+
+				for (l = 0; l < ARRAY_SIZE(formatlist); l++) {
+					p[1].format = formatlist[l];
+					/*
+					 * RGB565 90/270 degrees rotation is supported
+					 * from gen11 onwards.
+					 */
+					if (p[0].format == DRM_FORMAT_RGB565 &&
+					     igt_rotation_90_or_270(planeconfigs[i].rotation)
+					     && intel_display_ver(data->devid) < 11)
+						continue;
 
-						if (p[1].format == DRM_FORMAT_RGB565 &&
-						     igt_rotation_90_or_270(planeconfigs[j].rotation)
-						     && intel_display_ver(data->devid) < 11)
-							continue;
+					if (p[1].format == DRM_FORMAT_RGB565 &&
+					     igt_rotation_90_or_270(planeconfigs[j].rotation)
+					     && intel_display_ver(data->devid) < 11)
+						continue;
 
-						if (!igt_plane_has_rotation(p[0].plane,
-									    planeconfigs[i].rotation))
-							continue;
+					if (!igt_plane_has_rotation(p[0].plane,
+								    planeconfigs[i].rotation))
+						continue;
 
-						if (!igt_plane_has_rotation(p[1].plane,
-									    planeconfigs[j].rotation))
-							continue;
+					if (!igt_plane_has_rotation(p[1].plane,
+								    planeconfigs[j].rotation))
+						continue;
 
+					/*
+					 * if using packed formats crc's will be
+					 * same and can store them so there's
+					 * no need to redo comparison image and
+					 * just use stored crc.
+					 */
+					if (!igt_format_is_yuv_semiplanar(p[0].format) &&
+					    !igt_format_is_yuv_semiplanar(p[1].format) &&
+					    crclog[ctz(planeconfigs[i].rotation) |
+					    (ctz(planeconfigs[j].rotation) << 2)].frame != 0) {
+						retcrc_sw = crclog[ctz(planeconfigs[i].rotation) |
+							    (ctz(planeconfigs[j].rotation) << 2)];
+						have_crc = true;
+					} else if ((p[0].format == DRM_FORMAT_NV12 ||
+						  p[0].format == DRM_FORMAT_P010) &&
+						  p[1].format != DRM_FORMAT_NV12 &&
+						  p[1].format != DRM_FORMAT_P010 &&
+						  lastroundjformat != DRM_FORMAT_NV12 &&
+						  lastroundjformat != DRM_FORMAT_P010 &&
+						  planeconfigs[i].rotation == lastroundirotation &&
+						  planeconfigs[j].rotation == lastroundjrotation) {
 						/*
-						 * if using packed formats crc's will be
-						 * same and can store them so there's
-						 * no need to redo comparison image and
-						 * just use stored crc.
+						 * With NV12 can benefit from
+						 * previous crc if rotations
+						 * stay same. If both planes
+						 * have NV12 in use we need to
+						 * skip that case.
+						 * If last round right plane
+						 * had NV12 need to skip this.
 						 */
-						if (!igt_format_is_yuv_semiplanar(p[0].format) && !igt_format_is_yuv_semiplanar(p[1].format) &&
-						    crclog[ctz(planeconfigs[i].rotation) | (ctz(planeconfigs[j].rotation) << 2)].frame != 0) {
-							retcrc_sw = crclog[ctz(planeconfigs[i].rotation) | (ctz(planeconfigs[j].rotation) << 2)];
-							have_crc = true;
-						} else if((p[0].format == DRM_FORMAT_NV12 || p[0].format == DRM_FORMAT_P010) &&
-							   p[1].format != DRM_FORMAT_NV12 && p[1].format != DRM_FORMAT_P010 &&
-							   lastroundjformat != DRM_FORMAT_NV12 && lastroundjformat != DRM_FORMAT_P010 &&
-							   planeconfigs[i].rotation == lastroundirotation &&
-							   planeconfigs[j].rotation == lastroundjrotation) {
-							/*
-							 * With NV12 can benefit from
-							 * previous crc if rotations
-							 * stay same. If both planes
-							 * have NV12 in use we need to
-							 * skip that case.
-							 * If last round right plane
-							 * had NV12 need to skip this.
-							 */
-							have_crc = true;
-						} else {
-							/*
-							 * here will be created
-							 * comparison image and get crc
-							 * if didn't have stored crc
-							 * or planar format is in use.
-							 * have_crc flag will control
-							 * crc comparison part.
-							 */
-							p[0].rotation_sw = planeconfigs[i].rotation;
-							p[0].rotation_hw = IGT_ROTATION_0;
-							p[1].rotation_sw = planeconfigs[j].rotation;
-							p[1].rotation_hw = IGT_ROTATION_0;
-							if (!setup_multiplane(data,
-									(planeinfos *)&p,
-									&planeconfigs[i].fbs[k][MULTIPLANE_REFERENCE],
-									&planeconfigs[j].fbs[l][MULTIPLANE_REFERENCE]))
-								continue;
-							igt_display_commit_atomic(display, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
-							flipsw = kmstest_get_vblank(data->gfx_fd, pipe, 0) + 1;
-							have_crc = false;
-						}
-
+						have_crc = true;
+					} else {
 						/*
-						 * create hw rotated image and
-						 * get vblank where interesting
-						 * crc will be at, grab crc bit later
+						 * here will be created
+						 * comparison image and get crc
+						 * if didn't have stored crc
+						 * or planar format is in use.
+						 * have_crc flag will control
+						 * crc comparison part.
 						 */
-						p[0].rotation_sw = IGT_ROTATION_0;
-						p[0].rotation_hw = planeconfigs[i].rotation;
-						p[1].rotation_sw = IGT_ROTATION_0;
-						p[1].rotation_hw = planeconfigs[j].rotation;
-
+						p[0].rotation_sw = planeconfigs[i].rotation;
+						p[0].rotation_hw = IGT_ROTATION_0;
+						p[1].rotation_sw = planeconfigs[j].rotation;
+						p[1].rotation_hw = IGT_ROTATION_0;
 						if (!setup_multiplane(data,
-								      (planeinfos *)&p,
-								      &planeconfigs[i].fbs[k][MULTIPLANE_ROTATED],
-								      &planeconfigs[j].fbs[l][MULTIPLANE_ROTATED]))
+						    (planeinfos *)&p,
+						    &planeconfigs[i].fbs[k][MULTIPLANE_REFERENCE],
+						    &planeconfigs[j].fbs[l][MULTIPLANE_REFERENCE]))
 							continue;
+						igt_display_commit_atomic(display,
+									  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+						flipsw = kmstest_get_vblank(data->gfx_fd, pipe, 0) + 1;
+						have_crc = false;
+					}
 
-						igt_display_commit_atomic(display, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
-						fliphw = kmstest_get_vblank(data->gfx_fd, pipe, 0) + 1;
+					/*
+					 * create hw rotated image and
+					 * get vblank where interesting
+					 * crc will be at, grab crc bit later
+					 */
+					p[0].rotation_sw = IGT_ROTATION_0;
+					p[0].rotation_hw = planeconfigs[i].rotation;
+					p[1].rotation_sw = IGT_ROTATION_0;
+					p[1].rotation_hw = planeconfigs[j].rotation;
+
+					if (!setup_multiplane(data,
+							      (planeinfos *)&p,
+							      &planeconfigs[i].fbs[k][MULTIPLANE_ROTATED],
+							      &planeconfigs[j].fbs[l][MULTIPLANE_ROTATED]))
+						continue;
 
-						if (!have_crc) {
-							igt_pipe_crc_get_for_frame(data->gfx_fd,
-										   data->pipe_crc,
-										   flipsw,
-										   &retcrc_sw);
+					igt_display_commit_atomic(display, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+					fliphw = kmstest_get_vblank(data->gfx_fd, pipe, 0) + 1;
 
-							if (!igt_format_is_yuv_semiplanar(p[0].format) &&!igt_format_is_yuv_semiplanar(p[1].format))
-								crclog[ctz(planeconfigs[i].rotation) | (ctz(planeconfigs[j].rotation) << 2)]
-								= retcrc_sw;
-						}
-						igt_pipe_crc_get_for_frame(data->gfx_fd, data->pipe_crc, fliphw, &retcrc_hw);
+					if (!have_crc) {
+						igt_pipe_crc_get_for_frame(data->gfx_fd,
+									   data->pipe_crc,
+									   flipsw,
+									   &retcrc_sw);
 
-						str1 = igt_crc_to_string(&retcrc_sw);
-						str2 = igt_crc_to_string(&retcrc_hw);
+						if (!igt_format_is_yuv_semiplanar(p[0].format) &&
+						    !igt_format_is_yuv_semiplanar(p[1].format))
+							crclog[ctz(planeconfigs[i].rotation) | (ctz(planeconfigs[j].rotation) << 2)]
+							= retcrc_sw;
+					}
+					igt_pipe_crc_get_for_frame(data->gfx_fd, data->pipe_crc, fliphw, &retcrc_hw);
 
-						igt_debug("crc %.8s vs %.8s -- %.4s - %.4s crc buffered:%s rot1 %d rot2 %d\n",
-							str1, str2,
-							(char *) &p[0].format, (char *) &p[1].format,
-							have_crc?"yes":" no",
-							(int[]) {0, 90, 180, 270} [ctz(planeconfigs[i].rotation)],
-							(int[]) {0, 90, 180, 270} [ctz(planeconfigs[j].rotation)]);
+					str1 = igt_crc_to_string(&retcrc_sw);
+					str2 = igt_crc_to_string(&retcrc_hw);
 
-						free(str1);
-						free(str2);
+					igt_debug("crc %.8s vs %.8s -- %.4s - %.4s crc buffered:%s rot1 %d rot2 %d\n",
+						str1, str2,
+						(char *) &p[0].format, (char *) &p[1].format,
+						have_crc?"yes":" no",
+						(int[]) {0, 90, 180, 270} [ctz(planeconfigs[i].rotation)],
+						(int[]) {0, 90, 180, 270} [ctz(planeconfigs[j].rotation)]);
 
+					free(str1);
+					free(str2);
 
-						igt_assert_crc_equal(&retcrc_sw, &retcrc_hw);
 
-						lastroundjformat = p[1].format;
-						lastroundirotation = planeconfigs[i].rotation;
-						lastroundjrotation = planeconfigs[j].rotation;
-					}
+					igt_assert_crc_equal(&retcrc_sw, &retcrc_hw);
+
+					lastroundjformat = p[1].format;
+					lastroundirotation = planeconfigs[i].rotation;
+					lastroundjrotation = planeconfigs[j].rotation;
 				}
 			}
 		}
-		igt_pipe_crc_stop(data->pipe_crc);
-		igt_pipe_crc_free(data->pipe_crc);
+	}
+	igt_pipe_crc_stop(data->pipe_crc);
+	igt_pipe_crc_free(data->pipe_crc);
+	igt_plane_set_fb(p[0].plane, NULL);
+	igt_plane_set_fb(p[1].plane, NULL);
+	igt_display_commit_atomic(display, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
 
-		igt_plane_set_fb(p[0].plane, NULL);
-		igt_plane_set_fb(p[1].plane, NULL);
-		igt_display_commit_atomic(display, DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+	for (i = 0; i < ARRAY_SIZE(crclog); i++)
+		crclog[i].frame = 0;
 
-		for (i = 0; i < ARRAY_SIZE(crclog); i++)
-			crclog[i].frame = 0;
+	lastroundjformat = 0;
+	lastroundirotation = 0;
+	lastroundjrotation = 0;
 
-		lastroundjformat = 0;
-		lastroundirotation = 0;
-		lastroundjrotation = 0;
 
+	igt_output_set_pipe(output, PIPE_NONE);
 
-		igt_output_set_pipe(output, PIPE_NONE);
-	}
 	data->pipe_crc = NULL;
 
 	for (c = 0; c < ARRAY_SIZE(planeconfigs); c++) {
@@ -1049,6 +1040,8 @@ igt_main_args("", long_opts, help_str, opt_handler, &data)
 	};
 
 	int gen = 0;
+	enum pipe pipe;
+	igt_output_t *output;
 
 	igt_fixture {
 		data.gfx_fd = drm_open_driver_master(DRIVER_ANY);
@@ -1066,67 +1059,96 @@ igt_main_args("", long_opts, help_str, opt_handler, &data)
 	}
 
 	igt_describe("Rotation test with 90/270 degree for primary and sprite planes of gen9+");
-	for (subtest = subtests; subtest->rot; subtest++) {
-		igt_subtest_f("%s-rotation-%s",
-			      plane_test_str(subtest->plane),
-			      rot_test_str(subtest->rot)) {
-			if (is_amdgpu_device(data.gfx_fd)) {
-				data.override_fmt = DRM_FORMAT_XRGB8888;
-				if (igt_rotation_90_or_270(subtest->rot))
-					data.override_modifier = AMD_FMT_MOD |
-						AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX9_64K_S) |
-						AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX9);
-				else
-					data.override_modifier = DRM_FORMAT_MOD_LINEAR;
+	igt_subtest_with_dynamic("rotation") {
+		for (subtest = subtests; subtest->rot; subtest++) {
+			for_each_pipe(&data.display, pipe) {
+				for_each_valid_output_on_pipe(&data.display, pipe, output) {
+					igt_dynamic_f("%s-rotation-%s-%s-pipe-%s",
+						      plane_test_str(subtest->plane),
+						      rot_test_str(subtest->rot),
+						      output->name, kmstest_pipe_name(pipe)) {
+						if (is_amdgpu_device(data.gfx_fd)) {
+							data.override_fmt = DRM_FORMAT_XRGB8888;
+							if (igt_rotation_90_or_270(subtest->rot))
+								data.override_modifier = AMD_FMT_MOD |
+								AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX9_64K_S) |
+								AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX9);
+							else
+								data.override_modifier = DRM_FORMAT_MOD_LINEAR;
+						}
+					data.rotation = subtest->rot;
+					test_plane_rotation(&data, subtest->plane, false, pipe, output);
+					}
+				}
 			}
-			data.rotation = subtest->rot;
-			test_plane_rotation(&data, subtest->plane, false);
 		}
 	}
 
 	igt_describe("Rotation test with 90 degree for a plane of gen9+ with given position");
-	igt_subtest_f("sprite-rotation-90-pos-100-0") {
+	igt_subtest_with_dynamic("sprite-rotation-90-pos-100-0") {
 		data.rotation = IGT_ROTATION_90;
 		data.pos_x = 100,
 		data.pos_y = 0;
-		test_plane_rotation(&data, DRM_PLANE_TYPE_OVERLAY, false);
+		for_each_pipe(&data.display, pipe) {
+			for_each_valid_output_on_pipe(&data.display, pipe, output) {
+				igt_dynamic_f("%s-pipe-%s", output->name, kmstest_pipe_name(pipe))
+					test_plane_rotation(&data, DRM_PLANE_TYPE_OVERLAY, false, pipe, output);
+			}
+		}
 	}
 	data.pos_x = 0,
 	data.pos_y = 0;
 
 	igt_describe("Checking unsupported pixel format for gen9+ with 90 degree of rotation");
-	igt_subtest_f("bad-pixel-format") {
+	igt_subtest_with_dynamic("bad-pixel-format") {
 		 /* gen11 enables RGB565 rotation for 90/270 degrees.
 		  * so apart from this, any other gen11+ pixel format
 		  * can be used which doesn't support 90/270 degree
 		  * rotation */
 		data.rotation = IGT_ROTATION_90;
 		data.override_fmt = gen < 11 ? DRM_FORMAT_RGB565 : DRM_FORMAT_Y212;
-		test_plane_rotation(&data, DRM_PLANE_TYPE_PRIMARY, true);
+		for_each_pipe(&data.display, pipe) {
+			for_each_valid_output_on_pipe(&data.display, pipe, output) {
+				igt_dynamic_f("%s-pipe-%s", output->name, kmstest_pipe_name(pipe))
+					test_plane_rotation(&data, DRM_PLANE_TYPE_PRIMARY, true, pipe, output);
+			}
+		}
 	}
 	data.override_fmt = 0;
 
 	igt_describe("Checking unsupported tiling for gen9+ with 90 degree of rotation");
-	igt_subtest_f("bad-tiling") {
+	igt_subtest_with_dynamic("bad-tiling") {
 		data.rotation = IGT_ROTATION_90;
 		data.override_modifier = I915_FORMAT_MOD_X_TILED;
-		test_plane_rotation(&data, DRM_PLANE_TYPE_PRIMARY, true);
+		for_each_pipe(&data.display, pipe) {
+			for_each_valid_output_on_pipe(&data.display, pipe, output) {
+				igt_dynamic_f("%s-pipe-%s", output->name, kmstest_pipe_name(pipe))
+					test_plane_rotation(&data, DRM_PLANE_TYPE_PRIMARY, true, pipe, output);
+			}
+		}
 	}
 	data.override_modifier = 0;
 
 	igt_describe("Tiling and Rotation test for gen 10+ for primary plane");
-	for (reflect_x = reflect_x_subtests; reflect_x->modifier; reflect_x++) {
-		igt_subtest_f("primary-%s-reflect-x-%s",
-			      modifier_test_str(reflect_x->modifier),
-			      rot_test_str(reflect_x->rot)) {
-			data.rotation = (IGT_REFLECT_X | reflect_x->rot);
-			data.override_modifier = reflect_x->modifier;
-			test_plane_rotation(&data, DRM_PLANE_TYPE_PRIMARY, false);
+	igt_subtest_with_dynamic("reflect") {
+		for (reflect_x = reflect_x_subtests; reflect_x->modifier; reflect_x++) {
+			for_each_pipe(&data.display, pipe) {
+				for_each_valid_output_on_pipe(&data.display, pipe, output) {
+					igt_dynamic_f("primary-%s-reflect-x-%s-%s-pipe-%s",
+						       modifier_test_str(reflect_x->modifier),
+						       rot_test_str(reflect_x->rot),
+						       output->name, kmstest_pipe_name(pipe)) {
+						data.rotation = (IGT_REFLECT_X | reflect_x->rot);
+						data.override_modifier = reflect_x->modifier;
+						test_plane_rotation(&data, DRM_PLANE_TYPE_PRIMARY, false, pipe, output);
+					}
+				}
+			}
 		}
 	}
 
 	igt_describe("Rotation test on both planes by making them fully visible");
-	igt_subtest_f("multiplane-rotation") {
+	igt_subtest_with_dynamic("multiplane-rotation") {
 		igt_require(gen >= 9);
 		cleanup_crtc(&data);
 		data.planepos[0].origo = p_top | p_left;
@@ -1135,12 +1157,18 @@ igt_main_args("", long_opts, help_str, opt_handler, &data)
 		data.planepos[1].origo = p_top | p_right;
 		data.planepos[1].x = -.4f;
 		data.planepos[1].y = .1f;
-		test_multi_plane_rotation(&data, 0);
+		for_each_pipe(&data.display, pipe) {
+			for_each_valid_output_on_pipe(&data.display, pipe, output) {
+				igt_dynamic_f("%s-pipe-%s", output->name, kmstest_pipe_name(pipe)) {
+					test_multi_plane_rotation(&data, pipe, output);
+				}
+			}
+		}
 	}
 
 	igt_describe("Rotation test on both planes by cropping left/top corner of primary plane and"
 			"right/top corner of sprite plane");
-	igt_subtest_f("multiplane-rotation-cropping-top") {
+	igt_subtest_with_dynamic("multiplane-rotation-cropping-top") {
 		igt_require(gen >= 9);
 		cleanup_crtc(&data);
 		data.planepos[0].origo = p_top | p_left;
@@ -1149,12 +1177,18 @@ igt_main_args("", long_opts, help_str, opt_handler, &data)
 		data.planepos[1].origo = p_top | p_right;
 		data.planepos[1].x = -.15f;
 		data.planepos[1].y = -.15f;
-		test_multi_plane_rotation(&data, 0);
+		for_each_pipe(&data.display, pipe) {
+			for_each_valid_output_on_pipe(&data.display, pipe, output) {
+				igt_dynamic_f("%s-pipe-%s", output->name, kmstest_pipe_name(pipe)) {
+					test_multi_plane_rotation(&data, pipe, output);
+				}
+			}
+		}
 	}
 
 	igt_describe("Rotation test on both planes by cropping left/bottom corner of primary plane"
 			"and right/bottom corner of sprite plane");
-	igt_subtest_f("multiplane-rotation-cropping-bottom") {
+	igt_subtest_with_dynamic("multiplane-rotation-cropping-bottom") {
 		igt_require(gen >= 9);
 		cleanup_crtc(&data);
 		data.planepos[0].origo = p_bottom | p_left;
@@ -1163,7 +1197,13 @@ igt_main_args("", long_opts, help_str, opt_handler, &data)
 		data.planepos[1].origo = p_bottom | p_right;
 		data.planepos[1].x = -.15f;
 		data.planepos[1].y = -.20f;
-		test_multi_plane_rotation(&data, 0);
+		for_each_pipe(&data.display, pipe) {
+			for_each_valid_output_on_pipe(&data.display, pipe, output) {
+				igt_dynamic_f("%s-pipe-%s", output->name, kmstest_pipe_name(pipe)) {
+					test_multi_plane_rotation(&data, pipe, output);
+				}
+			}
+		}
 	}
 
 	/*
@@ -1171,17 +1211,18 @@ igt_main_args("", long_opts, help_str, opt_handler, &data)
 	 * the following subtests otherwise.
 	 */
 	igt_describe("This test intends to check for fence leaks exhaustively");
-	igt_subtest_f("exhaust-fences") {
-		enum pipe pipe;
-		igt_output_t *output;
+	igt_subtest_with_dynamic("exhaust-fences") {
 
 		igt_display_require_output(&data.display);
 
-		for_each_pipe_with_valid_output(&data.display, pipe, output) {
-			igt_plane_t *primary = &data.display.pipes[pipe].planes[0];
+		for_each_pipe(&data.display, pipe) {
+			for_each_pipe_with_valid_output(&data.display, pipe, output) {
+				igt_plane_t *primary = &data.display.pipes[pipe].planes[0];
+				igt_dynamic_f("%s-pipe-%s", output->name, kmstest_pipe_name(pipe)) {
 
-			test_plane_rotation_exhaust_fences(&data, pipe, output, primary);
-			break;
+					test_plane_rotation_exhaust_fences(&data, pipe, output, primary);
+				}
+			}
 		}
 	}
 
-- 
2.36.0

^ permalink raw reply related	[flat|nested] 5+ messages in thread