[Intel-gfx] [PATCH] tests/gem_reg_read: Extend and check for valid 36b counter

[Michał Winiarski]

When reading the timestamp register with single 64b read, we're observing
invalid values on x86_64:

[f = valid counter value | X = garbage]

i386:   0x0000000fffffffff
x86_64: 0xffffffffXXXXXXXX

Test checks if the counter is moving and increasing.
Add a check to see if we can use (reg | 1) flag to get a proper 36b timestamp,
shifting the value on x86_64 if we can't.

Cc: Chris Wilson <chris at chris-wilson.co.uk>
Signed-off-by: Michał Winiarski <michal.winiarski at intel.com>
---
 tests/gem_reg_read.c | 123 ++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 103 insertions(+), 20 deletions(-)

diff --git a/tests/gem_reg_read.c b/tests/gem_reg_read.c
index d3e68d9..ba12fb1 100644
--- a/tests/gem_reg_read.c
+++ b/tests/gem_reg_read.c
@@ -28,10 +28,14 @@
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
+#include <sys/utsname.h>
 
 #include "ioctl_wrappers.h"
 #include "drmtest.h"
 
+static bool is_x86_64;
+static bool has_proper_timestamp;
+
 struct local_drm_i915_reg_read {
 	__u64 offset;
 	__u64 val; /* Return value */
@@ -39,39 +43,118 @@ struct local_drm_i915_reg_read {
 
 #define REG_READ_IOCTL DRM_IOWR(DRM_COMMAND_BASE + 0x31, struct local_drm_i915_reg_read)
 
-static uint64_t timer_query(int fd)
+#define RENDER_RING_TIMESTAMP 0x2358
+
+static int read_register(int fd, uint64_t offset, uint64_t * val)
 {
+	int ret;
 	struct local_drm_i915_reg_read reg_read;
+	reg_read.offset = offset;
 
-	reg_read.offset = 0x2358;
-	igt_fail_on_f(drmIoctl(fd, REG_READ_IOCTL, &reg_read),
-		      "positive test case failed: ");
+	ret = drmIoctl(fd, REG_READ_IOCTL, &reg_read);
 
-	return reg_read.val;
+	*val = reg_read.val;
+
+	return ret;
 }
 
-igt_simple_main
+static bool check_kernel_x86_64(void)
 {
-	struct local_drm_i915_reg_read reg_read;
-	int fd, ret;
+	int ret;
+	struct utsname uts;
 
-	fd = drm_open_any();
+	ret = uname(&uts);
+	igt_assert(ret == 0);
 
-	reg_read.offset = 0x2358;
-	ret = drmIoctl(fd, REG_READ_IOCTL, &reg_read);
-	igt_assert(ret == 0 || errno == EINVAL);
-	igt_require(ret == 0);
+	if (!strcmp(uts.machine, "x86_64"))
+		return true;
+
+	return false;
+}
+
+static bool check_timestamp(int fd)
+{
+	int ret;
+	uint64_t val;
+
+	ret = read_register(fd, RENDER_RING_TIMESTAMP | 1, &val);
+	if (ret != 0 && errno == EINVAL)
+		return false;
+
+	return true;
+}
+
+static uint64_t timer_query(int fd, uint64_t * val)
+{
+	uint64_t offset;
+	int ret;
+
+	offset = RENDER_RING_TIMESTAMP;
+	if (has_proper_timestamp)
+		offset |= 1;
+
+	ret = read_register(fd, offset, val);
+
+	if (is_x86_64 && !has_proper_timestamp)
+		*val >>= 32;
 
-	reg_read.val = timer_query(fd);
+	return ret;
+}
+
+static void test_timestamp_moving(int fd)
+{
+	uint64_t first_val, second_val;
+
+	igt_fail_on(timer_query(fd, &first_val) != 0);
 	sleep(1);
-	/* Check that timer is moving and isn't busted. */
-	igt_assert(timer_query(fd) != reg_read.val);
+	igt_fail_on(timer_query(fd, &second_val) != 0);
+	igt_assert(second_val != first_val);
+}
 
-	/* bad reg */
-	reg_read.offset = 0x12345678;
-	ret = drmIoctl(fd, REG_READ_IOCTL, &reg_read);
+static void test_timestamp_monotonic(int fd)
+{
+	uint64_t first_val, second_val;
+	bool retry = true;
 
-	igt_assert(ret != 0 && errno == EINVAL);
+	igt_fail_on(timer_query(fd, &first_val) != 0);
 
+retry:
+	sleep(1);
+	igt_fail_on(timer_query(fd, &second_val) != 0);
+	if (second_val <= first_val && retry) {
+		retry = false;
+		first_val = second_val;
+		goto retry;
+	}
+
+	igt_assert(second_val > first_val);
+}
+
+igt_main
+{
+	uint64_t val = 0;
+	int fd = -1;
+
+	fd = drm_open_any();
+	is_x86_64 = check_kernel_x86_64();
+	has_proper_timestamp = check_timestamp(fd);
 	close(fd);
+
+	igt_fixture {
+		fd = drm_open_any();
+	}
+
+	igt_subtest("bad-register")
+		igt_assert(read_register(fd, 0x12345678, &val) == -1 &&
+				errno == EINVAL);
+
+	igt_subtest("timestamp-moving")
+		test_timestamp_moving(fd);
+
+	igt_subtest("timestamp-monotonic")
+		test_timestamp_monotonic(fd);
+
+	igt_fixture {
+		close(fd);
+	}
 }
-- 
2.4.3