[PATCH igt 1/2] lib/igt_aux: Add support for various system suspend/resume options

[Imre Deak <imre.deak@intel.com>]

To have a more accurate idea about any suspend/resume issues we can
perform the s/r until various phases in the s/r sequence. This way we
can isolate the given problem as being a device driver, kernel core or
BIOS related issue. Actual subtests using these new s/r phases will be
added as follow-up.

While at it also add the freeze suspend target, it's something we also
would need to test.

Signed-off-by: Imre Deak <imre.deak@intel.com>
---
 lib/igt_aux.c                    | 172 ++++++++++++++++++++++++++++++---------
 lib/igt_aux.h                    |  24 +++++-
 tests/drv_suspend.c              |  24 ++++--
 tests/gem_exec_suspend.c         |   6 +-
 tests/gem_mocs_settings.c        |  24 ++++--
 tests/gem_ringfill.c             |   6 +-
 tests/gem_softpin.c              |   6 +-
 tests/gem_stolen.c               |   2 +-
 tests/gem_workarounds.c          |   2 +-
 tests/kms_cursor_crc.c           |   3 +-
 tests/kms_fbcon_fbt.c            |   6 +-
 tests/kms_flip.c                 |   3 +-
 tests/kms_frontbuffer_tracking.c |   4 +-
 tests/kms_pipe_crc_basic.c       |   3 +-
 tests/kms_plane.c                |   3 +-
 tests/kms_psr_sink_crc.c         |   6 +-
 tests/pm_rpm.c                   |   6 +-
 17 files changed, 224 insertions(+), 76 deletions(-)

diff --git a/lib/igt_aux.c b/lib/igt_aux.c
index 5eaf35e..ba4dbf7 100644
--- a/lib/igt_aux.c
+++ b/lib/igt_aux.c
@@ -63,6 +63,7 @@
 #include "ioctl_wrappers.h"
 #include "igt_kms.h"
 #include "igt_stats.h"
+#include "igt_sysfs.h"
 
 /**
  * SECTION:igt_aux
@@ -625,60 +626,157 @@ void igt_cleanup_aperture_trashers(void)
 	free(trash_bos);
 }
 
+static const char *suspend_state_name[] = {
+	[SUSPEND_STATE_FREEZE] = "freeze",
+	[SUSPEND_STATE_MEM] = "mem",
+	[SUSPEND_STATE_DISK] = "disk",
+};
+
+static const char *suspend_test_name[] = {
+	[SUSPEND_TEST_NONE] = "none",
+	[SUSPEND_TEST_FREEZER] = "freezer",
+	[SUSPEND_TEST_DEVICES] = "devices",
+	[SUSPEND_TEST_PLATFORM] = "platform",
+	[SUSPEND_TEST_PROCESSORS] = "processors",
+	[SUSPEND_TEST_CORE] = "core",
+};
+
+static enum igt_suspend_test get_suspend_test(int power_dir)
+{
+	char *test_line;
+	char *test_name;
+	enum igt_suspend_test test;
+
+	if (faccessat(power_dir, "pm_test", R_OK, 0))
+		return SUSPEND_TEST_NONE;
+
+	igt_assert((test_line = igt_sysfs_get(power_dir, "pm_test")));
+	for (test_name = strtok(test_line, " "); test_name;
+	     test_name = strtok(NULL, " "))
+		if (test_name[0] == '[') {
+			test_name[strlen(test_name) - 1] = '\0';
+			test_name++;
+			break;
+		}
+
+	for (test = SUSPEND_TEST_NONE; test < SUSPEND_TEST_NUM; test++)
+		if (strcmp(suspend_test_name[test], test_name) == 0)
+			break;
+
+	igt_assert(test < SUSPEND_TEST_NUM);
+
+	free(test_line);
+
+	return test;
+}
+
+static void set_suspend_test(int power_dir, enum igt_suspend_test test)
+{
+	igt_assert(test < SUSPEND_TEST_NUM);
+
+	if (faccessat(power_dir, "pm_test", W_OK, 0)) {
+		igt_require(test == SUSPEND_TEST_NONE);
+		return;
+	}
+
+	igt_assert(igt_sysfs_set(power_dir, "pm_test", suspend_test_name[test]));
+}
+
 #define SQUELCH ">/dev/null 2>&1"
 
+static void suspend_via_rtcwake(enum igt_suspend_state state)
+{
+	char cmd[128];
+	int delay;
+
+	igt_assert(state < SUSPEND_STATE_NUM);
+
+	delay = state == SUSPEND_STATE_DISK ? 30 : 15;
+
+	/*
+	 * Skip if rtcwake would fail for a reason not related to the kernel's
+	 * suspend functionality.
+	 */
+	snprintf(cmd, sizeof(cmd), "rtcwake -n -s %d -m %s " SQUELCH,
+		 delay, suspend_state_name[state]);
+	igt_require(system(cmd) == 0);
+
+	snprintf(cmd, sizeof(cmd), "rtcwake -s %d -m %s ",
+		 delay, suspend_state_name[state]);
+	igt_assert_f(system(cmd) == 0,
+		     "This failure means that something is wrong with "
+		     "the rtcwake tool or how your distro is set up. "
+		     "This is not a i915.ko or i-g-t bug.\n");
+}
+
+static void suspend_via_sysfs(int power_dir, enum igt_suspend_state state)
+{
+	igt_assert(state < SUSPEND_STATE_NUM);
+	igt_assert(igt_sysfs_set(power_dir, "state",
+				 suspend_state_name[state]));
+}
+
+static uint32_t get_supported_suspend_states(int power_dir)
+{
+	char *states;
+	char *state_name;
+	uint32_t state_mask;
+
+	igt_assert((states = igt_sysfs_get(power_dir, "state")));
+	state_mask = 0;
+	for (state_name = strtok(states, " "); state_name;
+	     state_name = strtok(NULL, " ")) {
+		enum igt_suspend_state state;
+
+		for (state = SUSPEND_STATE_FREEZE; state < SUSPEND_STATE_NUM;
+		     state++)
+			if (strcmp(state_name, suspend_state_name[state]) == 0)
+				break;
+		igt_assert(state < SUSPEND_STATE_NUM);
+		state_mask |= 1 << state;
+	}
+
+	free(states);
+
+	return state_mask;
+}
+
 /**
  * igt_system_suspend_autoresume:
  *
- * Execute a system suspend-to-mem cycle and automatically wake up again using
- * the firmware's resume timer.
+ * Execute a system suspend (to idle, memory, disk) cycle optionally
+ * completing the cycle at a given test point and automaically wake up again.
+ * Waking up is either achieved using the RTC wake-up alarm for a full suspend
+ * cycle or a kernel timer for a suspend test cycle.
  *
  * This is very handy for implementing any kind of suspend/resume test.
  */
-void igt_system_suspend_autoresume(void)
+void igt_system_suspend_autoresume(enum igt_suspend_state state,
+				   enum igt_suspend_test test)
 {
+	int power_dir;
+	enum igt_suspend_test orig_test;
+
 	/* FIXME: Simulation doesn't like suspend/resume, and not even a lighter
 	 * approach using /sys/power/pm_test to just test our driver's callbacks
 	 * seems to fare better. We need to investigate what's going on. */
 	igt_skip_on_simulation();
 
-	/* skip if system doesn't support suspend-to-mem */
-	igt_require(system("rtcwake -n -s 15 -m mem" SQUELCH) == 0);
-
-	igt_assert_f(system("rtcwake -s 15 -m mem") == 0,
-		     "This failure means that something is wrong with the "
-		     "rtcwake tool or how your distro is set up. This is not "
-		     "a i915.ko or i-g-t bug.\n");
-}
+	igt_require((power_dir = open("/sys/power", O_RDONLY)) >= 0);
+	igt_require(get_supported_suspend_states(power_dir) & (1 << state));
+	igt_require(test == SUSPEND_TEST_NONE ||
+		    faccessat(power_dir, "pm_test", R_OK | W_OK, 0) == 0);
 
-/**
- * igt_system_hibernate_autoresume:
- *
- * Execute a system suspend-to-disk cycle and automatically wake up again using
- * the firmware's resume timer.
- *
- * This is very handy for implementing any kind of hibernate/resume test.
- */
-void igt_system_hibernate_autoresume(void)
-{
-	/* FIXME: I'm guessing simulation behaves the same way as with
-	 * suspend/resume, but it might be prudent to make sure
-	 */
-	/* FIXME: Simulation doesn't like suspend/resume, and not even a lighter
-	 * approach using /sys/power/pm_test to just test our driver's callbacks
-	 * seems to fare better. We need to investigate what's going on. */
-	igt_skip_on_simulation();
+	orig_test = get_suspend_test(power_dir);
+	set_suspend_test(power_dir, test);
 
-	/* skip if system doesn't support suspend-to-disk */
-	igt_require(system("rtcwake -n -s 30 -m disk" SQUELCH) == 0);
+	if (test == SUSPEND_TEST_NONE)
+		suspend_via_rtcwake(state);
+	else
+		suspend_via_sysfs(power_dir, state);
 
-	/* The timeout might need to be adjusted if hibernation takes too long
-	 * or if we have to wait excessively long before resume
-	 */
-	igt_assert_f(system("rtcwake -s 30 -m disk") == 0,
-		     "This failure means that something is wrong with the "
-		     "rtcwake tool or how your distro is set up. This is not "
-		     "a i915.ko or i-g-t bug.\n");
+	set_suspend_test(power_dir, orig_test);
+	close(power_dir);
 }
 
 /**
diff --git a/lib/igt_aux.h b/lib/igt_aux.h
index 7f5a7cf..f338504 100644
--- a/lib/igt_aux.h
+++ b/lib/igt_aux.h
@@ -115,8 +115,28 @@ void igt_trash_aperture(void);
 void igt_cleanup_aperture_trashers(void);
 
 /* suspend/hibernate and auto-resume system */
-void igt_system_suspend_autoresume(void);
-void igt_system_hibernate_autoresume(void);
+
+enum igt_suspend_state {
+	SUSPEND_STATE_FREEZE,
+	SUSPEND_STATE_MEM,
+	SUSPEND_STATE_DISK,
+
+	SUSPEND_STATE_NUM,
+};
+
+enum igt_suspend_test {
+	SUSPEND_TEST_NONE,
+	SUSPEND_TEST_FREEZER,
+	SUSPEND_TEST_DEVICES,
+	SUSPEND_TEST_PLATFORM,
+	SUSPEND_TEST_PROCESSORS,
+	SUSPEND_TEST_CORE,
+
+	SUSPEND_TEST_NUM,
+};
+
+void igt_system_suspend_autoresume(enum igt_suspend_state state,
+				   enum igt_suspend_test test);
 
 /* dropping priviledges */
 void igt_drop_root(void);
diff --git a/tests/drv_suspend.c b/tests/drv_suspend.c
index 601a32e..0a459e3 100644
--- a/tests/drv_suspend.c
+++ b/tests/drv_suspend.c
@@ -77,9 +77,11 @@ test_fence_restore(int fd, bool tiled2untiled, bool hibernate)
 		gem_set_tiling(fd, handle_tiled, I915_TILING_X, 2048);
 
 	if (hibernate)
-		igt_system_hibernate_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
+					      SUSPEND_TEST_NONE);
 	else
-		igt_system_suspend_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+					      SUSPEND_TEST_NONE);
 
 	igt_info("checking the first canary object\n");
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
@@ -117,9 +119,11 @@ test_debugfs_reader(bool hibernate)
 	sleep(1);
 
 	if (hibernate)
-		igt_system_hibernate_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
+					      SUSPEND_TEST_NONE);
 	else
-		igt_system_suspend_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+					      SUSPEND_TEST_NONE);
 
 	sleep(1);
 
@@ -145,9 +149,11 @@ test_sysfs_reader(bool hibernate)
 	sleep(1);
 
 	if (hibernate)
-		igt_system_hibernate_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
+					      SUSPEND_TEST_NONE);
 	else
-		igt_system_suspend_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+					      SUSPEND_TEST_NONE);
 
 	sleep(1);
 
@@ -163,9 +169,11 @@ test_forcewake(bool hibernate)
 	igt_assert_lte(0, fw_fd);
 
 	if (hibernate)
-		igt_system_hibernate_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
+					      SUSPEND_TEST_NONE);
 	else
-		igt_system_suspend_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+					      SUSPEND_TEST_NONE);
 
 	close (fw_fd);
 }
diff --git a/tests/gem_exec_suspend.c b/tests/gem_exec_suspend.c
index a45082e..b953afb 100644
--- a/tests/gem_exec_suspend.c
+++ b/tests/gem_exec_suspend.c
@@ -206,11 +206,13 @@ static void run_test(int fd, unsigned engine, unsigned flags)
 		break;
 
 	case SUSPEND:
-		igt_system_suspend_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+					      SUSPEND_TEST_NONE);
 		break;
 
 	case HIBERNATE:
-		igt_system_hibernate_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
+					      SUSPEND_TEST_NONE);
 		break;
 	}
 
diff --git a/tests/gem_mocs_settings.c b/tests/gem_mocs_settings.c
index 2b85749..7c7a9af 100644
--- a/tests/gem_mocs_settings.c
+++ b/tests/gem_mocs_settings.c
@@ -384,8 +384,10 @@ static void default_context_tests(unsigned mode)
 	switch (mode) {
 	case NONE:	break;
 	case RESET:	igt_force_gpu_reset();	break;
-	case SUSPEND:	igt_system_suspend_autoresume(); break;
-	case HIBERNATE:	igt_system_hibernate_autoresume(); break;
+	case SUSPEND:	igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+						      SUSPEND_TEST_NONE); break;
+	case HIBERNATE:	igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
+						      SUSPEND_TEST_NONE); break;
 	}
 
 	test_mocs_values(fd);
@@ -423,8 +425,10 @@ static void default_dirty_tests(unsigned mode)
 	switch (mode) {
 	case NONE:	break;
 	case RESET:	igt_force_gpu_reset();	break;
-	case SUSPEND:	igt_system_suspend_autoresume(); break;
-	case HIBERNATE:	igt_system_hibernate_autoresume(); break;
+	case SUSPEND:	igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+						      SUSPEND_TEST_NONE); break;
+	case HIBERNATE:	igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
+						      SUSPEND_TEST_NONE); break;
 	}
 
 	close(fd);
@@ -446,8 +450,10 @@ static void context_save_restore_test(unsigned mode)
 	switch (mode) {
 	case NONE:	break;
 	case RESET:	igt_force_gpu_reset();	break;
-	case SUSPEND:	igt_system_suspend_autoresume(); break;
-	case HIBERNATE:	igt_system_hibernate_autoresume(); break;
+	case SUSPEND:	igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+						      SUSPEND_TEST_NONE); break;
+	case HIBERNATE:	igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
+						      SUSPEND_TEST_NONE); break;
 	}
 
 	check_control_registers(fd, I915_EXEC_RENDER, ctx_id, false);
@@ -489,8 +495,10 @@ static void context_dirty_test(unsigned mode)
 	switch (mode) {
 	case NONE:	break;
 	case RESET:	igt_force_gpu_reset();	break;
-	case SUSPEND:	igt_system_suspend_autoresume(); break;
-	case HIBERNATE:	igt_system_hibernate_autoresume(); break;
+	case SUSPEND:	igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+						      SUSPEND_TEST_NONE); break;
+	case HIBERNATE:	igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
+						      SUSPEND_TEST_NONE); break;
 	}
 
 	check_control_registers(fd, I915_EXEC_RENDER, ctx_id, true);
diff --git a/tests/gem_ringfill.c b/tests/gem_ringfill.c
index 8047042..eff0775 100644
--- a/tests/gem_ringfill.c
+++ b/tests/gem_ringfill.c
@@ -175,10 +175,12 @@ static void run_test(int fd, unsigned ring, unsigned flags)
 			fill_ring(fd, &execbuf, flags);
 
 		if (flags & SUSPEND)
-			igt_system_suspend_autoresume();
+			igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+						      SUSPEND_TEST_NONE);
 
 		if (flags & HIBERNATE)
-			igt_system_hibernate_autoresume();
+			igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
+						      SUSPEND_TEST_NONE);
 
 		igt_waitchildren();
 	} else
diff --git a/tests/gem_softpin.c b/tests/gem_softpin.c
index cac4669..ea162c8 100644
--- a/tests/gem_softpin.c
+++ b/tests/gem_softpin.c
@@ -451,10 +451,12 @@ static void test_noreloc(int fd, enum sleep sleep)
 			case NOSLEEP:
 				break;
 			case SUSPEND:
-				igt_system_suspend_autoresume();
+				igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+							      SUSPEND_TEST_NONE);
 				break;
 			case HIBERNATE:
-				igt_system_hibernate_autoresume();
+				igt_system_suspend_autoresume(SUSPEND_STATE_DISK,
+							      SUSPEND_TEST_NONE);
 				break;
 			}
 		}
diff --git a/tests/gem_stolen.c b/tests/gem_stolen.c
index 7d329dd..1d48997 100644
--- a/tests/gem_stolen.c
+++ b/tests/gem_stolen.c
@@ -359,7 +359,7 @@ static void stolen_hibernate(int fd)
 
 	drm_intel_bo_unreference(src);
 
-	igt_system_hibernate_autoresume();
+	igt_system_suspend_autoresume(SUSPEND_STATE_DISK, SUSPEND_TEST_NONE);
 	/* Check if the object's memory contents are intact
 	 * across hibernation.
 	 */
diff --git a/tests/gem_workarounds.c b/tests/gem_workarounds.c
index d15cf91..e512dd3 100644
--- a/tests/gem_workarounds.c
+++ b/tests/gem_workarounds.c
@@ -60,7 +60,7 @@ static void test_hang_gpu(void)
 static void test_suspend_resume(void)
 {
 	igt_info("Suspending the device ...\n");
-	igt_system_suspend_autoresume();
+	igt_system_suspend_autoresume(SUSPEND_STATE_MEM, SUSPEND_TEST_NONE);
 }
 
 static int workaround_fail_count(void)
diff --git a/tests/kms_cursor_crc.c b/tests/kms_cursor_crc.c
index d1de450..926579d 100644
--- a/tests/kms_cursor_crc.c
+++ b/tests/kms_cursor_crc.c
@@ -140,7 +140,8 @@ static void do_single_test(data_t *data, int x, int y)
 		}
 
 		if (data->flags & TEST_SUSPEND)
-			igt_system_suspend_autoresume();
+			igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+						      SUSPEND_TEST_NONE);
 
 		igt_pipe_crc_collect_crc(pipe_crc, &crc_after);
 		igt_assert_crc_equal(&crc, &crc_after);
diff --git a/tests/kms_fbcon_fbt.c b/tests/kms_fbcon_fbt.c
index 586cdf5..6342289 100644
--- a/tests/kms_fbcon_fbt.c
+++ b/tests/kms_fbcon_fbt.c
@@ -217,7 +217,8 @@ static void subtest(struct feature *feature, bool suspend)
 	igt_assert(feature->wait_until_enabled());
 
 	if (suspend) {
-		igt_system_suspend_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+					      SUSPEND_TEST_NONE);
 		sleep(5);
 		igt_assert(feature->wait_until_enabled());
 	}
@@ -232,7 +233,8 @@ static void subtest(struct feature *feature, bool suspend)
 	igt_assert(!feature->wait_until_enabled());
 
 	if (suspend) {
-		igt_system_suspend_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+					      SUSPEND_TEST_NONE);
 		sleep(5);
 		igt_assert(!feature->wait_until_enabled());
 	}
diff --git a/tests/kms_flip.c b/tests/kms_flip.c
index 065ad66..7646aaf 100644
--- a/tests/kms_flip.c
+++ b/tests/kms_flip.c
@@ -1013,7 +1013,8 @@ static unsigned int run_test_step(struct test_output *o)
 		igt_assert(igt_wait_for_pm_status(IGT_RUNTIME_PM_STATUS_SUSPENDED));
 
 	if (o->flags & TEST_SUSPEND)
-		igt_system_suspend_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+					      SUSPEND_TEST_NONE);
 
 	if (do_vblank && (o->flags & TEST_EINVAL) && o->vblank_state.count > 0)
 		igt_assert(do_wait_for_vblank(o, o->pipe, target_seq, &vbl_reply)
diff --git a/tests/kms_frontbuffer_tracking.c b/tests/kms_frontbuffer_tracking.c
index 02ccbeb..3a8b458 100644
--- a/tests/kms_frontbuffer_tracking.c
+++ b/tests/kms_frontbuffer_tracking.c
@@ -2865,13 +2865,13 @@ static void suspend_subtest(const struct test_mode *t)
 
 	prepare_subtest(t, NULL);
 	sleep(5);
-	igt_system_suspend_autoresume();
+	igt_system_suspend_autoresume(SUSPEND_STATE_MEM, SUSPEND_TEST_NONE);
 	sleep(5);
 	do_assertions(0);
 
 	unset_all_crtcs();
 	sleep(5);
-	igt_system_suspend_autoresume();
+	igt_system_suspend_autoresume(SUSPEND_STATE_MEM, SUSPEND_TEST_NONE);
 	sleep(5);
 	do_assertions(ASSERT_FBC_DISABLED | ASSERT_PSR_DISABLED |
 		      DONT_ASSERT_CRC);
diff --git a/tests/kms_pipe_crc_basic.c b/tests/kms_pipe_crc_basic.c
index 2d2f2d6..04d5a13 100644
--- a/tests/kms_pipe_crc_basic.c
+++ b/tests/kms_pipe_crc_basic.c
@@ -223,7 +223,8 @@ igt_main
 
 		igt_subtest_f("suspend-read-crc-pipe-%c", 'A'+i) {
 			igt_skip_on(i >= data.display.n_pipes);
-			igt_system_suspend_autoresume();
+			igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+						      SUSPEND_TEST_NONE);
 
 			test_read_crc(&data, i, 0);
 		}
diff --git a/tests/kms_plane.c b/tests/kms_plane.c
index 7c01fe9..ce5e310 100644
--- a/tests/kms_plane.c
+++ b/tests/kms_plane.c
@@ -328,7 +328,8 @@ test_plane_panning_with_output(data_t *data,
 	igt_display_commit(&data->display);
 
 	if (flags & TEST_SUSPEND_RESUME)
-		igt_system_suspend_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+					      SUSPEND_TEST_NONE);
 
 	igt_pipe_crc_collect_crc(data->pipe_crc, &crc);
 
diff --git a/tests/kms_psr_sink_crc.c b/tests/kms_psr_sink_crc.c
index 68310d8..224e63c 100644
--- a/tests/kms_psr_sink_crc.c
+++ b/tests/kms_psr_sink_crc.c
@@ -604,7 +604,8 @@ int main(int argc, char *argv[])
 		setup_test_plane(&data);
 		igt_assert(wait_psr_entry(&data));
 
-		igt_system_suspend_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+					      SUSPEND_TEST_NONE);
 
 		run_test(&data);
 		test_cleanup(&data);
@@ -615,7 +616,8 @@ int main(int argc, char *argv[])
 		data.op = PLANE_ONOFF;
 		setup_test_plane(&data);
 
-		igt_system_suspend_autoresume();
+		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
+					      SUSPEND_TEST_NONE);
 
 		igt_assert(wait_psr_entry(&data));
 		run_test(&data);
diff --git a/tests/pm_rpm.c b/tests/pm_rpm.c
index 8297207..d0600d5 100644
--- a/tests/pm_rpm.c
+++ b/tests/pm_rpm.c
@@ -1369,7 +1369,7 @@ static void __attribute__((noreturn)) stay_subtest(void)
 static void system_suspend_subtest(void)
 {
 	disable_all_screens_and_wait(&ms_data);
-	igt_system_suspend_autoresume();
+	igt_system_suspend_autoresume(SUSPEND_STATE_MEM, SUSPEND_TEST_NONE);
 	igt_assert(wait_for_suspended());
 }
 
@@ -1401,7 +1401,7 @@ static void system_suspend_execbuf_subtest(void)
 	i915_execbuffer2_set_context_id(execbuf, 0);
 
 	disable_all_screens_and_wait(&ms_data);
-	igt_system_suspend_autoresume();
+	igt_system_suspend_autoresume(SUSPEND_STATE_MEM, SUSPEND_TEST_NONE);
 	igt_assert(wait_for_suspended());
 
 	for (i = 0; i < 20; i++) {
@@ -1415,7 +1415,7 @@ static void system_suspend_execbuf_subtest(void)
 static void system_suspend_modeset_subtest(void)
 {
 	disable_all_screens_and_wait(&ms_data);
-	igt_system_suspend_autoresume();
+	igt_system_suspend_autoresume(SUSPEND_STATE_MEM, SUSPEND_TEST_NONE);
 	igt_assert(wait_for_suspended());
 
 	enable_one_screen_and_wait(&ms_data);
-- 
2.5.0

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