diff mbox

[i-g-t,v2] tests: Validate TEST_ONLY correctness against full atomic commit

Message ID 1485776227-3056-1-git-send-email-mika.kahola@intel.com (mailing list archive)
State New, archived
Headers show

Commit Message

Mika Kahola Jan. 30, 2017, 11:37 a.m. UTC 
Validate atomic commit correctness before actual commit.

For: VIZ-6956

v2: Add flag to toggle TEST_ONLY for atomic commit.
    Remove DRM_MODE_PAGE_FLIP_EVENT flag, if enabled, before trying atomic
    commit with TEST_ONLY flag (Maarten)

Cc: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>

Signed-off-by: Mika Kahola <mika.kahola@intel.com>
---
 lib/igt_kms.c                 | 32 ++++++++++++++++++++++++++++----
 lib/igt_kms.h                 |  3 ++-
 tests/kms_atomic_transition.c | 23 ++++++++++++++---------
 tests/kms_busy.c              | 21 +++++++++++++--------
 tests/kms_cursor_legacy.c     | 27 ++++++++++++++++-----------
 tests/kms_panel_fitting.c     | 10 +++++++---
 tests/kms_plane_multiple.c    |  8 ++++----
 7 files changed, 84 insertions(+), 40 deletions(-)
diff mbox

Patch

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index 35a6bc4..720b37d 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -2543,6 +2543,8 @@  int igt_display_try_commit_atomic(igt_display_t *display, uint32_t flags, void *
  * @display: #igt_display_t to commit.
  * @flags: Flags passed to drmModeAtomicCommit.
  * @user_data: User defined pointer passed to drmModeAtomicCommit.
+ * @with_test: test atomic commit with DRM_MODE_ATOMIC_TEST_ONLY
+ *             flag before actual atomic commit.
  *
  * This function is similar to #igt_display_commit2, but is
  * used when you want to pass different flags to the actual commit.
@@ -2554,13 +2556,35 @@  int igt_display_try_commit_atomic(igt_display_t *display, uint32_t flags, void *
  * @user_data is returned in the event if you pass
  * DRM_MODE_PAGE_FLIP_EVENT to @flags.
  *
- * This function will abort the test if commit fails.
+ * This function will return an error if commit fails.
  */
-void igt_display_commit_atomic(igt_display_t *display, uint32_t flags, void *user_data)
+int igt_display_commit_atomic(igt_display_t *display, uint32_t flags,
+			      void *user_data, bool with_test)
 {
-	int ret = igt_display_try_commit_atomic(display, flags, user_data);
+	int ret;
+	bool page_flip_event;
 
-	igt_assert_eq(ret, 0);
+	if (with_test) {
+		flags |= DRM_MODE_ATOMIC_TEST_ONLY;
+		page_flip_event = flags & DRM_MODE_PAGE_FLIP_EVENT;
+
+		if (page_flip_event)
+			flags &= ~DRM_MODE_PAGE_FLIP_EVENT;
+
+		ret = igt_display_try_commit_atomic(display, flags, user_data);
+		igt_assert(ret != -EINVAL);
+
+		flags &= ~DRM_MODE_ATOMIC_TEST_ONLY;
+
+		if (page_flip_event)
+			flags |= DRM_MODE_PAGE_FLIP_EVENT;
+
+		ret = igt_display_try_commit_atomic(display, flags, user_data);
+	} else {
+		ret = igt_display_try_commit_atomic(display, flags, user_data);
+	}
+
+	return ret;
 }
 
 /**
diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 171df66..f82864e 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -359,7 +359,8 @@  void igt_display_fini(igt_display_t *display);
 int  igt_display_commit2(igt_display_t *display, enum igt_commit_style s);
 int  igt_display_commit(igt_display_t *display);
 int  igt_display_try_commit_atomic(igt_display_t *display, uint32_t flags, void *user_data);
-void igt_display_commit_atomic(igt_display_t *display, uint32_t flags, void *user_data);
+int  igt_display_commit_atomic(igt_display_t *display, uint32_t flags,
+			       void *user_data, bool with_test);
 int  igt_display_try_commit2(igt_display_t *display, enum igt_commit_style s);
 int  igt_display_get_n_pipes(igt_display_t *display);
 
diff --git a/tests/kms_atomic_transition.c b/tests/kms_atomic_transition.c
index 851ffc9..fe1264c 100644
--- a/tests/kms_atomic_transition.c
+++ b/tests/kms_atomic_transition.c
@@ -79,9 +79,9 @@  static bool skip_on_unsupported_nonblocking_modeset(igt_display_t *display)
 	 * unsupported -EINVAL is returned. If the second commit returns
 	 * -EINVAL, it's from not being able to support nonblocking modeset.
 	 */
-	igt_display_commit_atomic(display, DRM_MODE_ATOMIC_TEST_ONLY | DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
-
-	ret = igt_display_try_commit_atomic(display, DRM_MODE_ATOMIC_ALLOW_MODESET | DRM_MODE_ATOMIC_NONBLOCK, NULL);
+	ret = igt_display_commit_atomic(display,
+					DRM_MODE_ATOMIC_ALLOW_MODESET | DRM_MODE_ATOMIC_NONBLOCK,
+					NULL, true);
 
 	if (ret == -EINVAL)
 		return true;
@@ -276,6 +276,7 @@  run_transition_test(igt_display_t *display, enum pipe pipe, igt_output_t *output
 	struct plane_parms parms[IGT_MAX_PLANES];
 	bool skip_test = false;
 	unsigned flags = DRM_MODE_PAGE_FLIP_EVENT;
+	int ret;
 
 	if (nonblocking)
 		flags |= DRM_MODE_ATOMIC_NONBLOCK;
@@ -315,7 +316,8 @@  run_transition_test(igt_display_t *display, enum pipe pipe, igt_output_t *output
 
 		wm_setup_plane(display, pipe, i, parms);
 
-		igt_display_commit_atomic(display, flags, (void *)(unsigned long)i);
+		ret = igt_display_commit_atomic(display, flags, (void *)(unsigned long)i, true);
+		igt_assert_eq(ret, 0);
 		drmHandleEvent(display->drm_fd, &drm_events);
 
 		if (type == TRANSITION_MODESET_DISABLE) {
@@ -323,8 +325,8 @@  run_transition_test(igt_display_t *display, enum pipe pipe, igt_output_t *output
 
 			wm_setup_plane(display, pipe, 0, parms);
 
-			igt_display_commit_atomic(display, flags, (void *)0UL);
-
+			ret = igt_display_commit_atomic(display, flags, (void *)0UL, true);
+			igt_assert_eq(ret, 0);
 			drmHandleEvent(display->drm_fd, &drm_events);
 		} else {
 			uint32_t j;
@@ -336,14 +338,16 @@  run_transition_test(igt_display_t *display, enum pipe pipe, igt_output_t *output
 				if (type == TRANSITION_MODESET)
 					igt_output_override_mode(output, &override_mode);
 
-				igt_display_commit_atomic(display, flags, (void *)(unsigned long)j);
+				ret = igt_display_commit_atomic(display, flags, (void *)(unsigned long)j, true);
+				igt_assert_eq(ret, 0);
 				drmHandleEvent(display->drm_fd, &drm_events);
 
 				wm_setup_plane(display, pipe, i, parms);
 				if (type == TRANSITION_MODESET)
 					igt_output_override_mode(output, NULL);
 
-				igt_display_commit_atomic(display, flags, (void *)(unsigned long)i);
+				ret = igt_display_commit_atomic(display, flags, (void *)(unsigned long)i, true);
+				igt_assert_eq(ret, 0);
 				drmHandleEvent(display->drm_fd, &drm_events);
 			}
 		}
@@ -374,7 +378,8 @@  static void commit_display(igt_display_t *display, unsigned event_mask, bool non
 	if (nonblocking)
 		flags |= DRM_MODE_ATOMIC_NONBLOCK;
 
-	igt_display_commit_atomic(display, flags, NULL);
+	ret = igt_display_commit_atomic(display, flags, NULL, true);
+	igt_assert_eq(ret, 0);
 
 	igt_debug("Event mask: %x, waiting for %i events\n", event_mask, num_events);
 
diff --git a/tests/kms_busy.c b/tests/kms_busy.c
index d2be721..66d7b13 100644
--- a/tests/kms_busy.c
+++ b/tests/kms_busy.c
@@ -97,6 +97,7 @@  static void flip_to_fb(igt_display_t *dpy, int pipe,
 	struct pollfd pfd = { .fd = dpy->drm_fd, .events = POLLIN };
 	struct timespec tv = { 1, 0 };
 	struct drm_event_vblank ev;
+	int ret;
 
 	igt_spin_t *t = igt_spin_batch_new(dpy->drm_fd, ring, fb->gem_handle);
 	igt_fork(child, 1) {
@@ -108,10 +109,11 @@  static void flip_to_fb(igt_display_t *dpy, int pipe,
 		else {
 			igt_plane_set_fb(igt_output_get_plane(output, IGT_PLANE_PRIMARY), fb);
 			igt_output_set_pipe(output, PIPE_NONE);
-			igt_display_commit_atomic(dpy,
-						  DRM_MODE_ATOMIC_NONBLOCK |
-						  DRM_MODE_PAGE_FLIP_EVENT |
-						  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+			ret = igt_display_commit_atomic(dpy,
+							DRM_MODE_ATOMIC_NONBLOCK |
+							DRM_MODE_PAGE_FLIP_EVENT |
+							DRM_MODE_ATOMIC_ALLOW_MODESET, NULL, true);
+			igt_assert_eq(ret, 0);
 		}
 
 		kill(getppid(), SIGALRM);
@@ -191,20 +193,23 @@  static void test_atomic_commit_hang(igt_display_t *dpy, igt_plane_t *primary,
 	struct pollfd pfd = { .fd = dpy->drm_fd, .events = POLLIN };
 	unsigned flags = 0;
 	struct drm_event_vblank ev;
-
+	int ret;
+
 	flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
 	flags |= DRM_MODE_ATOMIC_NONBLOCK;
 	flags |= DRM_MODE_PAGE_FLIP_EVENT;
 
-	igt_display_commit_atomic(dpy, flags, NULL);
-
+	ret = igt_display_commit_atomic(dpy, flags, NULL, true);
+	igt_assert_eq(ret, 0);
+
 	igt_fork(child, 1) {
 		/*
 		 * bit of a hack, just set atomic commit to NULL fb to make sure
 		 * that we don't wait for the new update to complete.
 		 */
 		igt_plane_set_fb(primary, NULL);
-		igt_display_commit_atomic(dpy, 0, NULL);
+		ret = igt_display_commit_atomic(dpy, 0, NULL, true);
+		igt_assert_eq(ret, 0);
 
 		if (completes_early)
 			igt_assert(gem_bo_busy(dpy->drm_fd, busy_fb->gem_handle));
diff --git a/tests/kms_cursor_legacy.c b/tests/kms_cursor_legacy.c
index 707546c..5e88849 100644
--- a/tests/kms_cursor_legacy.c
+++ b/tests/kms_cursor_legacy.c
@@ -253,6 +253,7 @@  static enum pipe find_connected_pipe(igt_display_t *display, bool second)
 static void flip_nonblocking(igt_display_t *display, enum pipe pipe, bool atomic, struct igt_fb *fb)
 {
 	igt_plane_t *primary = &display->pipes[pipe].planes[IGT_PLANE_PRIMARY];
+	int ret;
 
 	if (!atomic) {
 		/* Schedule a nonblocking flip for the next vblank */
@@ -260,7 +261,8 @@  static void flip_nonblocking(igt_display_t *display, enum pipe pipe, bool atomic
 					DRM_MODE_PAGE_FLIP_EVENT, fb));
 	} else {
 		igt_plane_set_fb(primary, fb);
-		igt_display_commit_atomic(display, DRM_MODE_ATOMIC_NONBLOCK | DRM_MODE_PAGE_FLIP_EVENT, fb);
+		ret = igt_display_commit_atomic(display, DRM_MODE_ATOMIC_NONBLOCK | DRM_MODE_PAGE_FLIP_EVENT, fb, true);
+		igt_assert_eq(ret, 0);
 	}
 }
 
@@ -304,17 +306,16 @@  static void transition_nonblocking(igt_display_t *display, enum pipe pipe,
 {
 	igt_plane_t *primary = &display->pipes[pipe].planes[IGT_PLANE_PRIMARY];
 	igt_plane_t *sprite = &display->pipes[pipe].planes[IGT_PLANE_2];
+	int ret;
 
 	if (hide_sprite) {
 		igt_plane_set_fb(primary, prim_fb);
 		igt_plane_set_fb(sprite, NULL);
 	} else {
-		int ret;
-
 		igt_plane_set_fb(primary, NULL);
 		igt_plane_set_fb(sprite, argb_fb);
 
-		ret = igt_display_try_commit_atomic(display, DRM_MODE_ATOMIC_NONBLOCK | DRM_MODE_PAGE_FLIP_EVENT, display);
+		ret = igt_display_commit_atomic(display, DRM_MODE_ATOMIC_NONBLOCK | DRM_MODE_PAGE_FLIP_EVENT, display, true);
 		if (!ret)
 			return;
 
@@ -322,7 +323,8 @@  static void transition_nonblocking(igt_display_t *display, enum pipe pipe,
 
 		igt_plane_set_fb(sprite, prim_fb);
 	}
-	igt_display_commit_atomic(display, DRM_MODE_ATOMIC_NONBLOCK | DRM_MODE_PAGE_FLIP_EVENT, display);
+	ret = igt_display_commit_atomic(display, DRM_MODE_ATOMIC_NONBLOCK | DRM_MODE_PAGE_FLIP_EVENT, display, true);
+	igt_assert_eq(ret, 0);
 }
 
 static void prepare_flip_test(igt_display_t *display,
@@ -835,9 +837,7 @@  static bool skip_on_unsupported_nonblocking_modeset(igt_display_t *display)
 	enum pipe pipe;
 	int ret;
 
-	igt_display_commit_atomic(display, DRM_MODE_ATOMIC_TEST_ONLY | DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
-
-	ret = igt_display_try_commit_atomic(display, DRM_MODE_ATOMIC_ALLOW_MODESET | DRM_MODE_ATOMIC_NONBLOCK, NULL);
+	ret = igt_display_commit_atomic(display, DRM_MODE_ATOMIC_ALLOW_MODESET | DRM_MODE_ATOMIC_NONBLOCK, NULL, true);
 
 	if (ret == -EINVAL)
 		return true;
@@ -859,6 +859,7 @@  static void nonblocking_modeset_vs_cursor(igt_display_t *display, int loops)
 	struct drm_mode_cursor arg[2];
 	bool skip_test;
 	igt_plane_t *cursor = NULL, *plane;
+	int ret;
 
 	igt_require(display->is_atomic);
 	igt_require((output = set_fb_on_crtc(display, pipe, &fb_info)));
@@ -904,7 +905,8 @@  static void nonblocking_modeset_vs_cursor(igt_display_t *display, int loops)
 
 		igt_output_set_pipe(output, pipe);
 		igt_plane_set_fb(cursor, NULL);
-		igt_display_commit_atomic(display, flags, NULL);
+		ret = igt_display_commit_atomic(display, flags, NULL, true);
+		igt_assert_eq(ret, 0);
 
 		igt_assert_eq(0, poll(&pfd, 1, 0));
 		igt_assert_eq(0, pfd.revents);
@@ -919,7 +921,8 @@  static void nonblocking_modeset_vs_cursor(igt_display_t *display, int loops)
 		igt_reset_timeout();
 
 		igt_output_set_pipe(output, PIPE_NONE);
-		igt_display_commit_atomic(display, flags, NULL);
+		ret = igt_display_commit_atomic(display, flags, NULL, true);
+		igt_assert_eq(ret, 0);
 
 		igt_assert_eq(0, poll(&pfd, 1, 0));
 		igt_assert_eq(0, pfd.revents);
@@ -954,6 +957,7 @@  static void two_screens_flip_vs_cursor(igt_display_t *display, int nloops, bool
 	enum pipe pipe2 = find_connected_pipe(display, true);
 	igt_output_t *output, *output2;
 	bool skip_test = false;
+	int ret;
 
 	igt_fail_on(modeset && !atomic);
 
@@ -1010,7 +1014,8 @@  static void two_screens_flip_vs_cursor(igt_display_t *display, int nloops, bool
 
 			igt_plane_set_fb(igt_output_get_plane(output, IGT_PLANE_PRIMARY), &fb_info);
 			igt_output_set_pipe(output2, (nloops & 1) ? PIPE_NONE : pipe2);
-			igt_display_commit_atomic(display, DRM_MODE_ATOMIC_ALLOW_MODESET | DRM_MODE_ATOMIC_NONBLOCK, NULL);
+			ret = igt_display_commit_atomic(display, DRM_MODE_ATOMIC_ALLOW_MODESET | DRM_MODE_ATOMIC_NONBLOCK, NULL, true);
+			igt_assert_eq(ret, 0);
 		}
 
 		igt_assert_eq(get_vblank(display->drm_fd, pipe, 0), vblank_start);
diff --git a/tests/kms_panel_fitting.c b/tests/kms_panel_fitting.c
index 1b35076..2dcf37e 100644
--- a/tests/kms_panel_fitting.c
+++ b/tests/kms_panel_fitting.c
@@ -220,6 +220,7 @@  test_panel_fitting_fastset(igt_display_t *display, const enum pipe pipe, igt_out
 	igt_plane_t *primary, *sprite;
 	drmModeModeInfo mode;
 	struct igt_fb red, green, blue;
+	int ret;
 
 	igt_assert(kmstest_get_connector_default_mode(display->drm_fd, output->config.connector, &mode));
 
@@ -254,19 +255,22 @@  test_panel_fitting_fastset(igt_display_t *display, const enum pipe pipe, igt_out
 	igt_plane_set_fb(primary, &red);
 
 	/* Don't pass ALLOW_MODESET with overridden mode, force fastset. */
-	igt_display_commit_atomic(display, 0, NULL);
+	ret = igt_display_commit_atomic(display, 0, NULL, true);
+	igt_assert_eq(ret, 0);
 
 	/* Test with different scaled mode */
 	mode.hdisplay = 800;
 	mode.vdisplay = 600;
 	igt_output_override_mode(output, &mode);
 	igt_plane_set_fb(primary, &green);
-	igt_display_commit_atomic(display, 0, NULL);
+	ret = igt_display_commit_atomic(display, 0, NULL, true);
+	igt_assert_eq(ret, 0);
 
 	/* Restore normal mode */
 	igt_plane_set_fb(primary, &blue);
 	igt_output_override_mode(output, NULL);
-	igt_display_commit_atomic(display, 0, NULL);
+	ret = igt_display_commit_atomic(display, 0, NULL, true);
+	igt_assert_eq(ret, 0);
 
 	igt_plane_set_fb(primary, NULL);
 	igt_output_set_pipe(output, PIPE_NONE);
diff --git a/tests/kms_plane_multiple.c b/tests/kms_plane_multiple.c
index 2b43f0c..93e5012 100644
--- a/tests/kms_plane_multiple.c
+++ b/tests/kms_plane_multiple.c
@@ -244,10 +244,10 @@  test_atomic_plane_position_with_output(data_t *data, enum pipe pipe,
 		vblank_start = kmstest_get_vblank(data->display.drm_fd, pipe,
 						  DRM_VBLANK_NEXTONMISS);
 
-		igt_display_commit_atomic(&data->display,
-					  DRM_MODE_PAGE_FLIP_EVENT,
-					  &data->display);
-
+		ret = igt_display_commit_atomic(&data->display,
+						DRM_MODE_PAGE_FLIP_EVENT,
+						&data->display, true);
+		igt_assert_eq(ret, 0);
 		igt_set_timeout(1, "Stuck on page flip");
 
 		ret = read(data->display.drm_fd, buf, sizeof(buf));