[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 <ch...@chris-wilson.co.uk>
Signed-off-by: Michał Winiarski <michal.winiar...@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

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/intel-gfx