Skip to contentSkip to conversation

kms_atomic : Added subtest for Single Pipe DBUF validation

PATCH Superseded meghanelogal 3 participants 4 messages Oct 25, 2016 – Oct 26, 2016 1 message not in the archive

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): mailto:[email protected]

#1 lore raw

PATCH v2 1/1 kms_atomic : Added subtest for Single Pipe DBUF validation

Existing DDB algorithm divide the DDB wrt data rate, hence the planes with the less height but same width will be allocated less blocks and watermark are based on width which requires more DDB. With this data the flip may fail.

In new DDB algorithm, the DDB is divided based on watermark requirement.

In this subtest, dividing the htotal/200 will allocate ~2-4 blocks out of total(512/896), flip may fail with the exisiting algorithm.But with the new algorithm it will pass.

---
 tests/kms_atomic.c | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)
tests/kms_atomic.c +82 -0
index f27ee46..bfa4b35 100644
@@ -1280,6 +1280,60 @@ static void atomic_invalid_params(struct kms_atomic_crtc_state *crtc,
 	do_ioctl_err(desc->fd, DRM_IOCTL_MODE_ATOMIC, &ioc, EFAULT);
 }
 
+static void validate_dbuf(struct kms_atomic_crtc_state *crtc,
+				struct kms_atomic_plane_state **plane_array,
+				int plane_count)
+{
+	int i;
+	struct kms_atomic_desc *desc = crtc->state->desc;
+
+	/* for active crtc do modeset on the native resolution */
+	drmModeAtomicReq *req = drmModeAtomicAlloc();
+	struct drm_mode_modeinfo *mode = crtc->mode.data;
+	struct kms_atomic_plane_state plane;
+	struct igt_fb fb;
+
+	crtc_populate_req(crtc, req);
+
+	/* Add plane data to the structure...*/
+	uint32_t crtc_x = 0;
+	uint32_t crtc_y = 0;
+
+	for (i = 0; i < plane_count; i++) {
+		plane = *plane_array[i];
+		uint32_t format = plane_get_igt_format(&plane);
+
+		igt_require(format != 0);
+		plane.src_x = 0;
+		plane.src_y = 0;
+		plane.src_w = (mode->hdisplay / (1)) << 16;
+		plane.crtc_x = crtc_x;
+		plane.crtc_y = crtc_y;
+		plane.crtc_w = (mode->hdisplay) / (1);
+		plane.crtc_h = (mode->vdisplay) / (i + 1);
+
+		plane.crtc_id = crtc->obj;
+
+		if (i%2 == 0) {
+			plane.src_h = (mode->vdisplay / (1)) << 16;
+			plane.crtc_h = (mode->vdisplay) / (1);
+		}
+
+		if (i%2 == 1) {
+			plane.src_h = ceil((mode->vdisplay / 200) << 16);
+			plane.crtc_h = ceil((mode->vdisplay / 200));
+		}
+
+		plane.fb_id = igt_create_fb(plane.state->desc->fd,
+						plane.crtc_w, plane.crtc_h,
+						format, I915_TILING_NONE, &fb);
+		plane_populate_req(&plane, req);
+	}
+	do_atomic_commit(desc->fd, req, ATOMIC_RELAX_NONE);
+	drmModeAtomicFree(req);
+}
+
+
 igt_main
 {
 	struct kms_atomic_desc desc;
@@ -1373,6 +1427,34 @@ igt_main
 		atomic_state_free(scratch);
 	}
 
+	igt_subtest("validate_dbuf") {
+		int gen;
+
+		gen = intel_gen(intel_get_drm_devid(desc.fd));
+		igt_require(gen >= 9);
+
+		struct kms_atomic_state *scratch = atomic_state_dup(current);
+		struct kms_atomic_crtc_state *crtc = find_crtc(scratch, true);
+		struct kms_atomic_plane_state *plane;
+		struct kms_atomic_connector_state *connector =
+				find_connector(scratch, crtc);
+		struct kms_atomic_plane_state **plane_array = NULL;
+		/* Enabling Two planes */
+		plane_array = calloc(2, sizeof(struct kms_atomic_plane_state *));
+		int plane_count = 0;
+
+		igt_require(crtc);
+		plane = find_plane(scratch, PLANE_TYPE_PRIMARY, crtc);
+		igt_require(plane);
+		plane_array[plane_count] = plane; plane_count++;
+		plane = find_plane(scratch, PLANE_TYPE_OVERLAY, crtc);
+		igt_require(plane);
+		plane_array[plane_count] = plane; plane_count++;
+		igt_require(connector);
+		validate_dbuf(crtc, plane_array, plane_count);
+		atomic_state_free(scratch);
+	}
+
 	atomic_state_free(current);
 
 	igt_fixture
Signature · 6 lines
1.9.1

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#2 lore raw
Quoted 16 lines · meghanelogal
tests/kms_atomic.c +16 -0
+	igt_subtest("validate_dbuf") {
+		int gen;
+
+		gen = intel_gen(intel_get_drm_devid(desc.fd));
+		igt_require(gen >= 9);
+
+		struct kms_atomic_state *scratch = atomic_state_dup(current);
+		struct kms_atomic_crtc_state *crtc = find_crtc(scratch, true);
+		struct kms_atomic_plane_state *plane;
+		struct kms_atomic_connector_state *connector =
+				find_connector(scratch, crtc);
+		struct kms_atomic_plane_state **plane_array = NULL;
+		/* Enabling Two planes */
+		plane_array = calloc(2, sizeof(struct kms_atomic_plane_state *));
+		int plane_count = 0;
+

tests/kms_atomic.c igt_main · line 1455

Quoted 10 lines
tests/kms_atomic.c +10 -0
+		igt_require(crtc);
+		plane = find_plane(scratch, PLANE_TYPE_PRIMARY, crtc);
+		igt_require(plane);
+		plane_array[plane_count] = plane; plane_count++;
+		plane = find_plane(scratch, PLANE_TYPE_OVERLAY, crtc);
+		igt_require(plane);
+		plane_array[plane_count] = plane; plane_count++;
+		igt_require(connector);
+		validate_dbuf(crtc, plane_array, plane_count);
+		atomic_state_free(scratch);
	struct kms_atomic_state *scratch = atomic_state_dup(current);
	struct kms_atomic_crtc_state *crtc;
	struct kms_atomic_plane_state *planes[2];

	crtc = find_crtc(scratch, true);
	igt_require(crtc);

	igt_require(find_connector(scratch, crtc));

	planes[0] = find_plane(scratch, PLANE_TYPE_PRIMARY, crtc);
	igt_require(planes[0]);

	planes[1] = find_plane(scratch, PLANE_TYPE_OVERLAY, crtc);
	igt_require(planes[1]);

	validate_dbuf(crtc, planes, 2);
	atomic_state_free(scratch);

is a bit easier to read.
-Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#3 lore raw
In reply to meghanelogal
Quoted 6 lines · meghanelogal

Existing DDB algorithm divide the DDB wrt data rate, hence the planes with the less height but same width will be allocated less blocks and watermark are based on width which requires more DDB. With this data the flip may fail.

Quoted 8 lines

In new DDB algorithm, the DDB is divided based on watermark requirement.

In this subtest, dividing the htotal/200 will allocate ~2-4 blocks out of total(512/896), flip may fail with the exisiting algorithm.But with the new algorithm it will pass.

Pretty sure I mentioned this already, but how does this test work? It doesn't check for a specific platform/hw combo to make sure it's assumptions are valid, and you can't just assume that this will always work on all drivers/platforms.

tbh not entirely sure of the value this provides here ... -Daniel

Quoted 107 lines
---
 tests/kms_atomic.c | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)
tests/kms_atomic.c +82 -0
index f27ee46..bfa4b35 100644
@@ -1280,6 +1280,60 @@ static void atomic_invalid_params(struct kms_atomic_crtc_state *crtc,
 	do_ioctl_err(desc->fd, DRM_IOCTL_MODE_ATOMIC, &ioc, EFAULT);
 }
 
+static void validate_dbuf(struct kms_atomic_crtc_state *crtc,
+				struct kms_atomic_plane_state **plane_array,
+				int plane_count)
+{
+	int i;
+	struct kms_atomic_desc *desc = crtc->state->desc;
+
+	/* for active crtc do modeset on the native resolution */
+	drmModeAtomicReq *req = drmModeAtomicAlloc();
+	struct drm_mode_modeinfo *mode = crtc->mode.data;
+	struct kms_atomic_plane_state plane;
+	struct igt_fb fb;
+
+	crtc_populate_req(crtc, req);
+
+	/* Add plane data to the structure...*/
+	uint32_t crtc_x = 0;
+	uint32_t crtc_y = 0;
+
+	for (i = 0; i < plane_count; i++) {
+		plane = *plane_array[i];
+		uint32_t format = plane_get_igt_format(&plane);
+
+		igt_require(format != 0);
+		plane.src_x = 0;
+		plane.src_y = 0;
+		plane.src_w = (mode->hdisplay / (1)) << 16;
+		plane.crtc_x = crtc_x;
+		plane.crtc_y = crtc_y;
+		plane.crtc_w = (mode->hdisplay) / (1);
+		plane.crtc_h = (mode->vdisplay) / (i + 1);
+
+		plane.crtc_id = crtc->obj;
+
+		if (i%2 == 0) {
+			plane.src_h = (mode->vdisplay / (1)) << 16;
+			plane.crtc_h = (mode->vdisplay) / (1);
+		}
+
+		if (i%2 == 1) {
+			plane.src_h = ceil((mode->vdisplay / 200) << 16);
+			plane.crtc_h = ceil((mode->vdisplay / 200));
+		}
+
+		plane.fb_id = igt_create_fb(plane.state->desc->fd,
+						plane.crtc_w, plane.crtc_h,
+						format, I915_TILING_NONE, &fb);
+		plane_populate_req(&plane, req);
+	}
+	do_atomic_commit(desc->fd, req, ATOMIC_RELAX_NONE);
+	drmModeAtomicFree(req);
+}
+
+
 igt_main
 {
 	struct kms_atomic_desc desc;
@@ -1373,6 +1427,34 @@ igt_main
 		atomic_state_free(scratch);
 	}
 
+	igt_subtest("validate_dbuf") {
+		int gen;
+
+		gen = intel_gen(intel_get_drm_devid(desc.fd));
+		igt_require(gen >= 9);
+
+		struct kms_atomic_state *scratch = atomic_state_dup(current);
+		struct kms_atomic_crtc_state *crtc = find_crtc(scratch, true);
+		struct kms_atomic_plane_state *plane;
+		struct kms_atomic_connector_state *connector =
+				find_connector(scratch, crtc);
+		struct kms_atomic_plane_state **plane_array = NULL;
+		/* Enabling Two planes */
+		plane_array = calloc(2, sizeof(struct kms_atomic_plane_state *));
+		int plane_count = 0;
+
+		igt_require(crtc);
+		plane = find_plane(scratch, PLANE_TYPE_PRIMARY, crtc);
+		igt_require(plane);
+		plane_array[plane_count] = plane; plane_count++;
+		plane = find_plane(scratch, PLANE_TYPE_OVERLAY, crtc);
+		igt_require(plane);
+		plane_array[plane_count] = plane; plane_count++;
+		igt_require(connector);
+		validate_dbuf(crtc, plane_array, plane_count);
+		atomic_state_free(scratch);
+	}
+
 	atomic_state_free(current);
 
 	igt_fixture
Signature · 1 line
1.9.1
Signature · 7 lines
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
#4 lore raw

Daniel,

I have already added platform check and is valid for platforms>=gen 9 This subtest is for Watermark/DDB kernel patches floated by Mahesh Kumar ..

    reference -> https://patchwork.freedesktop.org/series/12222/

Regards,
Megha

Quoted 126 lines · Daniel Vetter
Quoted 6 lines · meghanelogal

Existing DDB algorithm divide the DDB wrt data rate, hence the planes with the less height but same width will be allocated less blocks and watermark are based on width which requires more DDB. With this data the flip may fail.

Quoted 8 lines

In new DDB algorithm, the DDB is divided based on watermark requirement.

In this subtest, dividing the htotal/200 will allocate ~2-4 blocks out of total(512/896), flip may fail with the exisiting algorithm.But with the new algorithm it will pass.

Pretty sure I mentioned this already, but how does this test work? It doesn't check for a specific platform/hw combo to make sure it's assumptions are valid, and you can't just assume that this will always work on all drivers/platforms.

tbh not entirely sure of the value this provides here ... -Daniel

Quoted 103 lines
---
  tests/kms_atomic.c | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1 file changed, 82 insertions(+)
tests/kms_atomic.c +82 -0
index f27ee46..bfa4b35 100644
@@ -1280,6 +1280,60 @@ static void atomic_invalid_params(struct kms_atomic_crtc_state *crtc,
  	do_ioctl_err(desc->fd, DRM_IOCTL_MODE_ATOMIC, &ioc, EFAULT);
  }
 
+static void validate_dbuf(struct kms_atomic_crtc_state *crtc,
+				struct kms_atomic_plane_state **plane_array,
+				int plane_count)
+{
+	int i;
+	struct kms_atomic_desc *desc = crtc->state->desc;
+
+	/* for active crtc do modeset on the native resolution */
+	drmModeAtomicReq *req = drmModeAtomicAlloc();
+	struct drm_mode_modeinfo *mode = crtc->mode.data;
+	struct kms_atomic_plane_state plane;
+	struct igt_fb fb;
+
+	crtc_populate_req(crtc, req);
+
+	/* Add plane data to the structure...*/
+	uint32_t crtc_x = 0;
+	uint32_t crtc_y = 0;
+
+	for (i = 0; i < plane_count; i++) {
+		plane = *plane_array[i];
+		uint32_t format = plane_get_igt_format(&plane);
+
+		igt_require(format != 0);
+		plane.src_x = 0;
+		plane.src_y = 0;
+		plane.src_w = (mode->hdisplay / (1)) << 16;
+		plane.crtc_x = crtc_x;
+		plane.crtc_y = crtc_y;
+		plane.crtc_w = (mode->hdisplay) / (1);
+		plane.crtc_h = (mode->vdisplay) / (i + 1);
+
+		plane.crtc_id = crtc->obj;
+
+		if (i%2 == 0) {
+			plane.src_h = (mode->vdisplay / (1)) << 16;
+			plane.crtc_h = (mode->vdisplay) / (1);
+		}
+
+		if (i%2 == 1) {
+			plane.src_h = ceil((mode->vdisplay / 200) << 16);
+			plane.crtc_h = ceil((mode->vdisplay / 200));
+		}
+
+		plane.fb_id = igt_create_fb(plane.state->desc->fd,
+						plane.crtc_w, plane.crtc_h,
+						format, I915_TILING_NONE, &fb);
+		plane_populate_req(&plane, req);
+	}
+	do_atomic_commit(desc->fd, req, ATOMIC_RELAX_NONE);
+	drmModeAtomicFree(req);
+}
+
+
  igt_main
  {
  	struct kms_atomic_desc desc;
@@ -1373,6 +1427,34 @@ igt_main
  		atomic_state_free(scratch);
  	}
 
+	igt_subtest("validate_dbuf") {
+		int gen;
+
+		gen = intel_gen(intel_get_drm_devid(desc.fd));
+		igt_require(gen >= 9);
+
+		struct kms_atomic_state *scratch = atomic_state_dup(current);
+		struct kms_atomic_crtc_state *crtc = find_crtc(scratch, true);
+		struct kms_atomic_plane_state *plane;
+		struct kms_atomic_connector_state *connector =
+				find_connector(scratch, crtc);
+		struct kms_atomic_plane_state **plane_array = NULL;
+		/* Enabling Two planes */
+		plane_array = calloc(2, sizeof(struct kms_atomic_plane_state *));
+		int plane_count = 0;
+
+		igt_require(crtc);
+		plane = find_plane(scratch, PLANE_TYPE_PRIMARY, crtc);
+		igt_require(plane);
+		plane_array[plane_count] = plane; plane_count++;
+		plane = find_plane(scratch, PLANE_TYPE_OVERLAY, crtc);
+		igt_require(plane);
+		plane_array[plane_count] = plane; plane_count++;
+		igt_require(connector);
+		validate_dbuf(crtc, plane_array, plane_count);
+		atomic_state_free(scratch);
+	}
+
  	atomic_state_free(current);
 
Quoted 4 lines
Quoted 4 lines
tests/kms_atomic.c +0 -0
  	igt_fixture
Signature · 1 line
1.9.1

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx