[PATCH i-g-t 00/14] add test to validate fallback

[PATCH i-g-t 00/14] add test to validate fallback

[Kunal Joshi]

[1] provides debugfs interfaces to force link training
failures, retrain link, set/get current/max link rate/lane count.

add new test using newly exposed interfaces to validate fallback.

[1] https://patchwork.freedesktop.org/series/133624/

Kunal Joshi (14):
  lib/igt_kms: add enum for link rate and lane count
  lib/igt_kms: add helper to get current link rate/ lane count for
    connector
  lib/igt_kms: add function to get max link rate/lane count
  lib/igt_kms: add function to force link retrain
  lib/igt_kms: add function to force link training failure
  lib/igt_kms: add function to check if retrain disabled
  lib/igt_kms: add function to check force link training failure support
  lib/igt_kms: add helper to get pending lt failures
  lib/igt_kms: add helper to get pending retrain count
  lib/igt_kms: add helper to set connector link status
  lib/igt_kms: add function to reset link params
  lib/igt_kms: allow set and reset value to be same
  tests/intel/kms_dp_fallback: add test for validating fallback
  HAX: Do not merge

 lib/igt_kms.c                            | 334 ++++++++++++++-
 lib/igt_kms.h                            |  36 ++
 tests/intel-ci/fast-feedback.testlist    |   1 +
 tests/intel-ci/xe-fast-feedback.testlist |   2 +
 tests/intel/kms_fallback.c               | 506 +++++++++++++++++++++++
 tests/meson.build                        |   1 +
 6 files changed, 877 insertions(+), 3 deletions(-)
 create mode 100644 tests/intel/kms_fallback.c

-- 
2.43.0

[PATCH i-g-t 01/14] lib/igt_kms: add enum for link rate and lane count

[Kunal Joshi]

add enums for link rate, lane count

Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
---
 lib/igt_kms.h | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 25ba50916..999921f9f 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -258,6 +258,29 @@ enum intel_broadcast_rgb_mode {
 	BROADCAST_RGB_16_235
 };
 
+enum dp_link_rate {
+	DP_LINK_RATE_162000 = 162000,
+	DP_LINK_RATE_216000 = 216000,
+	DP_LINK_RATE_243000 = 243000,
+	DP_LINK_RATE_270000 = 270000,
+	DP_LINK_RATE_324000 = 324000,
+	DP_LINK_RATE_432000 = 432000,
+	DP_LINK_RATE_540000 = 540000,
+	DP_LINK_RATE_675000 = 675000,
+	DP_LINK_RATE_810000 = 810000,
+	DP_LINK_RATE_1000000 = 1000000,
+	DP_LINK_RATE_1350000 = 1350000,
+	DP_LINK_RATE_2000000 = 2000000
+};
+
+#define DP_MAX_LINK_RATE_COUNT 12
+
+enum dp_lane_count {
+	DP_LANE_COUNT_1 = 1,
+	DP_LANE_COUNT_2 = 2,
+	DP_LANE_COUNT_4 = 4
+};
+
 struct edid;
 
 bool kmstest_force_connector(int fd, drmModeConnector *connector,
-- 
2.43.0

[PATCH i-g-t 02/14] lib/igt_kms: add helper to get current link rate/ lane count for connector

[Kunal Joshi]

i915_dp_force_(lane_count/link_rate) debugfs files expoose
current link rate/lane count for connector.add helper to get
current link rate/ lane count for connector

Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
---
 lib/igt_kms.c | 58 +++++++++++++++++++++++++++++++++++++++++++++++++++
 lib/igt_kms.h |  2 ++
 2 files changed, 60 insertions(+)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index dd530dbab..4ef7f4d7f 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -6705,3 +6705,61 @@ int get_num_scalers(igt_display_t *display, enum pipe pipe)
 
 	return num_scalers;
 }
+
+/**
+ * igt_get_dp_link_rate_set_for_output:
+ * @drm_fd: A drm file descriptor
+ * @output: Target output
+ *
+ * Returns: Link rate set for the output.
+ */
+enum dp_link_rate igt_get_dp_link_rate_set_for_output(int drm_fd, igt_output_t *output)
+{
+	char buf[512];
+	int dir, res;
+	int link_rate;
+
+	igt_require_f(output->name, "Invalid output");
+	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_RDONLY);
+	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
+				 igt_output_name(output));
+	res = igt_debugfs_simple_read(dir, "i915_dp_force_link_rate", buf, sizeof(buf));
+	close(dir);
+	igt_require(res > 0);
+
+	if (strstr(buf, "[auto]"))
+		igt_assert(sscanf(strstr(buf, "*") - 6, "%d", &link_rate) == 1);
+	else
+		igt_assert(sscanf(strstr(buf, "[") + 1, "%d", &link_rate) == 1);
+
+	return link_rate;
+}
+
+/**
+ * igt_get_dp_lane_count_set_for_output:
+ * @drm_fd: A drm file descriptor
+ * @output: Target output
+ *
+ * Returns: Lane count set for the output.
+ */
+enum dp_lane_count igt_get_dp_lane_count_set_for_output(int drm_fd, igt_output_t *output)
+{
+	char buf[512];
+	int dir, res;
+	int lane_count;
+
+	igt_require_f(output->name, "Invalid output");
+	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_RDONLY);
+	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
+				 igt_output_name(output));
+	res = igt_debugfs_simple_read(dir, "i915_dp_force_lane_count", buf, sizeof(buf));
+	close(dir);
+	igt_require(res > 0);
+
+	if (strstr(buf, "[auto]"))
+		igt_assert(sscanf(strstr(buf, "*") - 2, "%d", &lane_count) == 1);
+	else
+		igt_assert(sscanf(strstr(buf, "[") + 1, "%d", &lane_count) == 1);
+
+	return lane_count;
+}
diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 999921f9f..9d42a2b35 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -1247,5 +1247,7 @@ bool intel_pipe_output_combo_valid(igt_display_t *display);
 bool igt_check_output_is_dp_mst(igt_output_t *output);
 int igt_get_dp_mst_connector_id(igt_output_t *output);
 int get_num_scalers(igt_display_t *display, enum pipe pipe);
+enum dp_link_rate igt_get_dp_link_rate_set_for_output(int drm_fd, igt_output_t *output);
+enum dp_lane_count igt_get_dp_lane_count_set_for_output(int drm_fd, igt_output_t *output);
 
 #endif /* __IGT_KMS_H__ */
-- 
2.43.0

[PATCH i-g-t 03/14] lib/igt_kms: add function to get max link rate/lane count

[Kunal Joshi]

i915_dp_max_(lane_count/link_rate) debugfs files expose max link
rate/lane count for connector.add function to get max link rate/lane
lane count for connector

Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
---
 lib/igt_kms.c | 58 +++++++++++++++++++++++++++++++++++++++++++++++++++
 lib/igt_kms.h |  2 ++
 2 files changed, 60 insertions(+)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index 4ef7f4d7f..21ea8550c 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -6763,3 +6763,61 @@ enum dp_lane_count igt_get_dp_lane_count_set_for_output(int drm_fd, igt_output_t
 
 	return lane_count;
 }
+
+/**
+ * igt_get_dp_max_link_rate:
+ * @drm_fd: A drm file descriptor
+ * @output: The output to query
+ *
+ * Get the max link rate supported by the sink.
+ *
+ * Returns: Max link rate supported by the sink.
+ */
+enum dp_link_rate igt_get_dp_max_link_rate(int drm_fd, igt_output_t *output)
+{
+	char buf[512];
+	int dir, res;
+	int max_link_rate;
+
+	igt_require_f(output->name, "Invalid output");
+	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_DIRECTORY);
+	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
+				 igt_output_name(output));
+	res = igt_debugfs_simple_read(dir, "i915_dp_max_link_rate",
+								  buf, sizeof(buf));
+	close(dir);
+	igt_require_f(res > 0, "Couldn't read i915_dp_max_link_rate");
+
+	igt_assert(sscanf(buf, "%d", &max_link_rate) == 1);
+
+	return max_link_rate;
+}
+
+/**
+ * igt_get_dp_max_lane_count:
+ * @drm_fd: A drm file descriptor
+ * @output: The output to query
+ *
+ * Get the max lane count supported by the sink.
+ *
+ * Returns: Max lane count supported by the sink.
+ */
+enum dp_lane_count igt_get_dp_max_lane_count(int drm_fd, igt_output_t *output)
+{
+	char buf[512];
+	int dir, res;
+	int max_lane_count;
+
+	igt_require_f(output->name, "Invalid output");
+	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_RDONLY);
+	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
+				 igt_output_name(output));
+	res = igt_debugfs_simple_read(dir, "i915_dp_max_lane_count",
+								  buf, sizeof(buf));
+	close(dir);
+	igt_require(res > 0);
+
+	igt_assert(sscanf(buf, "%d", &max_lane_count) == 1);
+
+	return max_lane_count;
+}
diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 9d42a2b35..1d3226c5c 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -1249,5 +1249,7 @@ int igt_get_dp_mst_connector_id(igt_output_t *output);
 int get_num_scalers(igt_display_t *display, enum pipe pipe);
 enum dp_link_rate igt_get_dp_link_rate_set_for_output(int drm_fd, igt_output_t *output);
 enum dp_lane_count igt_get_dp_lane_count_set_for_output(int drm_fd, igt_output_t *output);
+enum dp_link_rate igt_get_dp_max_link_rate(int drm_fd, igt_output_t *output);
+enum dp_lane_count igt_get_dp_max_lane_count(int drm_fd, igt_output_t *output);
 
 #endif /* __IGT_KMS_H__ */
-- 
2.43.0

[PATCH i-g-t 04/14] lib/igt_kms: add function to force link retrain

[Kunal Joshi]

i915_dp_force_link_retrain debugfs allow forcing retraing
on the connector. add a helper to write given retraining count
to the same.

Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
---
 lib/igt_kms.c | 22 ++++++++++++++++++++++
 lib/igt_kms.h |  1 +
 2 files changed, 23 insertions(+)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index 21ea8550c..553a08f2f 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -6821,3 +6821,25 @@ enum dp_lane_count igt_get_dp_max_lane_count(int drm_fd, igt_output_t *output)
 
 	return max_lane_count;
 }
+
+/**
+ * igt_force_link_retrain:
+ * @drm_fd: A drm file descriptor
+ * @output: Target output
+ * @retrain_count: number of retraining required
+ *
+ * Force link retrain on the output.
+ */
+void igt_force_link_retrain(int drm_fd, igt_output_t *output, int retrain_count)
+{
+	int dir;
+	char value[2];
+
+	snprintf(value, sizeof(value), "%d", retrain_count);
+	igt_require_f(output->name, "Invalid output");
+	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_RDONLY);
+	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
+			       igt_output_name(output));
+	igt_sysfs_write(dir, "i915_dp_force_link_retrain", value, sizeof(value));
+	close(dir);
+}
diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 1d3226c5c..9ba8c6394 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -1251,5 +1251,6 @@ enum dp_link_rate igt_get_dp_link_rate_set_for_output(int drm_fd, igt_output_t *
 enum dp_lane_count igt_get_dp_lane_count_set_for_output(int drm_fd, igt_output_t *output);
 enum dp_link_rate igt_get_dp_max_link_rate(int drm_fd, igt_output_t *output);
 enum dp_lane_count igt_get_dp_max_lane_count(int drm_fd, igt_output_t *output);
+void igt_force_link_retrain(int drm_fd, igt_output_t *output, int retrain_count);
 
 #endif /* __IGT_KMS_H__ */
-- 
2.43.0

[PATCH i-g-t 05/14] lib/igt_kms: add function to force link training failure

[Kunal Joshi]

i915_dp_force_link_training_failure debugfs
file is used to force link training failure.
add a function to force link training failure.

Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
---
 lib/igt_kms.c | 26 ++++++++++++++++++++++++++
 lib/igt_kms.h |  1 +
 2 files changed, 27 insertions(+)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index 553a08f2f..683989e84 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -6843,3 +6843,29 @@ void igt_force_link_retrain(int drm_fd, igt_output_t *output, int retrain_count)
 	igt_sysfs_write(dir, "i915_dp_force_link_retrain", value, sizeof(value));
 	close(dir);
 }
+
+/**
+ * igt_force_lt_failure:
+ * @drm_fd: A drm file descriptor
+ * @output: Target output
+ * @failure_count: 1 for same link param and
+ *                2 for reduced link params
+ *
+ * Force link training failure on the output.
+ * @failure_count: 1 for retraining with same link params
+ * 				   2 for retraining with reduced link params
+ */
+void igt_force_lt_failure(int drm_fd, igt_output_t *output, int failure_count)
+{
+	int dir;
+	char value[2];
+
+	snprintf(value, sizeof(value), "%d", failure_count);
+	igt_require_f(output->name, "Invalid output");
+	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_RDONLY);
+	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
+			       igt_output_name(output));
+	igt_sysfs_write(dir, "i915_dp_force_link_training_failure",
+			     value, sizeof(value));
+	close(dir);
+}
diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 9ba8c6394..57829416a 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -1252,5 +1252,6 @@ enum dp_lane_count igt_get_dp_lane_count_set_for_output(int drm_fd, igt_output_t
 enum dp_link_rate igt_get_dp_max_link_rate(int drm_fd, igt_output_t *output);
 enum dp_lane_count igt_get_dp_max_lane_count(int drm_fd, igt_output_t *output);
 void igt_force_link_retrain(int drm_fd, igt_output_t *output, int retrain_count);
+void igt_force_lt_failure(int drm_fd, igt_output_t *output, int failure_count);
 
 #endif /* __IGT_KMS_H__ */
-- 
2.43.0

[PATCH i-g-t 06/14] lib/igt_kms: add function to check if retrain disabled

[Kunal Joshi]

add helper to check if retraining is disabled,
retraining will be disable if we are at the lowest
link parameters or the lowest mode supported on a panel

Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
---
 lib/igt_kms.c | 24 ++++++++++++++++++++++++
 lib/igt_kms.h |  1 +
 2 files changed, 25 insertions(+)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index 683989e84..2720095d4 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -6869,3 +6869,27 @@ void igt_force_lt_failure(int drm_fd, igt_output_t *output, int failure_count)
 			     value, sizeof(value));
 	close(dir);
 }
+
+/**
+ * igt_get_dp_link_retrain_disabled:
+ * @drm_fd: A drm file descriptor
+ * @output: Target output
+ *
+ * Returns: True if link retrain disabled, false otherwise
+ */
+bool igt_get_dp_link_retrain_disabled(int drm_fd, igt_output_t *output)
+{
+	int dir, res;
+	char buf[512];
+
+	igt_require_f(output->name, "Invalid output");
+	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_RDONLY);
+	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
+			       igt_output_name(output));
+	res = igt_debugfs_simple_read(dir,
+				      "i915_dp_link_retrain_disabled",
+				      buf, sizeof(buf));
+	close(dir);
+	igt_require(res > 0);
+	return strstr(buf, "yes");
+}
diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 57829416a..2d69d794a 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -1253,5 +1253,6 @@ enum dp_link_rate igt_get_dp_max_link_rate(int drm_fd, igt_output_t *output);
 enum dp_lane_count igt_get_dp_max_lane_count(int drm_fd, igt_output_t *output);
 void igt_force_link_retrain(int drm_fd, igt_output_t *output, int retrain_count);
 void igt_force_lt_failure(int drm_fd, igt_output_t *output, int failure_count);
+bool igt_get_dp_link_retrain_disabled(int drm_fd, igt_output_t *output);
 
 #endif /* __IGT_KMS_H__ */
-- 
2.43.0

[PATCH i-g-t 07/14] lib/igt_kms: add function to check force link training failure support

[Kunal Joshi]

add helper to check if platform support forcing
link training failures

Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
---
 lib/igt_kms.c | 25 +++++++++++++++++++++++++
 lib/igt_kms.h |  1 +
 2 files changed, 26 insertions(+)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index 2720095d4..4ab47e2e9 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -6893,3 +6893,28 @@ bool igt_get_dp_link_retrain_disabled(int drm_fd, igt_output_t *output)
 	igt_require(res > 0);
 	return strstr(buf, "yes");
 }
+
+/**
+ * Checks if the force link training failure debugfs
+ * is available for a specific output.
+ *
+ * @drmfd: file descriptor of the DRM device.
+ * @output: output to check.
+ * Returns:
+ *  true if the debugfs is available, false otherwise.
+ */
+bool igt_has_force_link_training_failure_debugfs(int drmfd, igt_output_t *output)
+{
+	int debugfs_fd, ret;
+	char buf[512];
+
+	igt_assert_f(output->name, "Invalid output\n");
+	debugfs_fd = igt_debugfs_connector_dir(drmfd, output->name, O_RDONLY);
+	if (debugfs_fd < 0)
+		return false;
+	ret = igt_debugfs_simple_read(debugfs_fd,
+				      "i915_dp_force_link_training_failure",
+				      buf, sizeof(buf));
+	close(debugfs_fd);
+	return ret >= 0;
+}
diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 2d69d794a..5ae324f6f 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -1254,5 +1254,6 @@ enum dp_lane_count igt_get_dp_max_lane_count(int drm_fd, igt_output_t *output);
 void igt_force_link_retrain(int drm_fd, igt_output_t *output, int retrain_count);
 void igt_force_lt_failure(int drm_fd, igt_output_t *output, int failure_count);
 bool igt_get_dp_link_retrain_disabled(int drm_fd, igt_output_t *output);
+bool igt_has_force_link_training_failure_debugfs(int drmfd, igt_output_t *output);
 
 #endif /* __IGT_KMS_H__ */
-- 
2.43.0

[PATCH i-g-t 08/14] lib/igt_kms: add helper to get pending lt failures

[Kunal Joshi]

i915_dp_force_link_training_failure can be written to
written to trigger link trainig failures on retrain.
add helper to get pending link training failure count.

Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
---
 lib/igt_kms.c | 23 +++++++++++++++++++++++
 lib/igt_kms.h |  1 +
 2 files changed, 24 insertions(+)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index 4ab47e2e9..727fa83f1 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -6918,3 +6918,26 @@ bool igt_has_force_link_training_failure_debugfs(int drmfd, igt_output_t *output
 	close(debugfs_fd);
 	return ret >= 0;
 }
+
+/**
+ * igt_get_dp_pending_lt_failures:
+ * @drm_fd: A drm file descriptor
+ * @output: Target output
+ *
+ * Returns: Number of pending link training failures.
+ */
+int igt_get_dp_pending_lt_failures(int drm_fd, igt_output_t *output)
+{
+	int dir, res, ret;
+	char buf[512];
+
+	igt_require_f(output->name, "Invalid output");
+	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_RDONLY);
+	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
+			       igt_output_name(output));
+	res = igt_debugfs_simple_read(dir, "i915_dp_force_link_training_failure", buf, sizeof(buf));
+	close(dir);
+	igt_require(res > 0);
+	sscanf(buf, "%d", &ret);
+	return ret;
+}
diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 5ae324f6f..07dbcb263 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -1255,5 +1255,6 @@ void igt_force_link_retrain(int drm_fd, igt_output_t *output, int retrain_count)
 void igt_force_lt_failure(int drm_fd, igt_output_t *output, int failure_count);
 bool igt_get_dp_link_retrain_disabled(int drm_fd, igt_output_t *output);
 bool igt_has_force_link_training_failure_debugfs(int drmfd, igt_output_t *output);
+int igt_get_dp_pending_lt_failures(int drm_fd, igt_output_t *output);
 
 #endif /* __IGT_KMS_H__ */
-- 
2.43.0

[PATCH i-g-t 09/14] lib/igt_kms: add helper to get pending retrain count

[Kunal Joshi]

i915_dp_force_link_retrain can be written to trigger
link retraining. add helper to get pending retrainig
failure count.

Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
---
 lib/igt_kms.c | 23 +++++++++++++++++++++++
 lib/igt_kms.h |  1 +
 2 files changed, 24 insertions(+)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index 727fa83f1..91f75243d 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -6941,3 +6941,26 @@ int igt_get_dp_pending_lt_failures(int drm_fd, igt_output_t *output)
 	sscanf(buf, "%d", &ret);
 	return ret;
 }
+
+/**
+ * igt_dp_pending_retrain:
+ * @drm_fd: A drm file descriptor
+ * @output: Target output
+ * 
+ * Returns: Number of pending link retrains.
+ */
+int igt_get_dp_pending_retrain(int drm_fd, igt_output_t *output)
+{
+	int dir, res, ret;
+	char buf[512];
+
+	igt_require_f(output->name, "Invalid output");
+	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_RDONLY);
+	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
+			       igt_output_name(output));
+	res = igt_debugfs_simple_read(dir, "i915_dp_force_link_retrain", buf, sizeof(buf));
+	close(dir);
+	igt_require(res > 0);
+	sscanf(buf, "%d", &ret);
+	return ret;
+}
diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 07dbcb263..640ec4e09 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -1256,5 +1256,6 @@ void igt_force_lt_failure(int drm_fd, igt_output_t *output, int failure_count);
 bool igt_get_dp_link_retrain_disabled(int drm_fd, igt_output_t *output);
 bool igt_has_force_link_training_failure_debugfs(int drmfd, igt_output_t *output);
 int igt_get_dp_pending_lt_failures(int drm_fd, igt_output_t *output);
+int igt_get_dp_pending_retrain(int drm_fd, igt_output_t *output);
 
 #endif /* __IGT_KMS_H__ */
-- 
2.43.0

[PATCH i-g-t 10/14] lib/igt_kms: add helper to set connector link status

[Kunal Joshi]

add helper to set connector's link status property

Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
---
 lib/igt_kms.c | 36 ++++++++++++++++++++++++++++++++++++
 lib/igt_kms.h |  2 ++
 2 files changed, 38 insertions(+)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index 91f75243d..e0533f6ae 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -2213,6 +2213,42 @@ void kmstest_set_connector_dpms(int fd, drmModeConnector *connector, int mode)
 					       dpms, mode) == 0);
 }
 
+/**
+ * kmstest_set_connector_link_status
+ * @drm_fd: drm file descriptor
+ * @connector: libdrm connector
+ * @link_status: DRM link status value
+ * 
+ * This function sets the link status of @connector to @link_status.
+ */
+void kmstest_set_connector_link_status(int drm_fd, drmModeConnector *connector,
+				       int link_status)
+{
+	int i, link_status_prop = 0;
+	bool found_it = false;
+
+	for (i = 0; i < connector->count_props; i++) {
+		struct drm_mode_get_property prop = {
+			.prop_id = connector->props[i],
+		};
+
+		if (drmIoctl(drm_fd, DRM_IOCTL_MODE_GETPROPERTY, &prop))
+			continue;
+
+		if (strcmp(prop.name, "link-status"))
+			continue;
+
+		link_status_prop = prop.prop_id;
+		found_it = true;
+		break;
+	}
+	igt_assert_f(found_it, "LINK_STATUS property not found on %d\n",
+		     connector->connector_id);
+
+	igt_assert(drmModeConnectorSetProperty(drm_fd, connector->connector_id,
+					       link_status_prop, link_status) == 0);
+}
+
 /**
  * kmstest_get_property:
  * @drm_fd: drm file descriptor
diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 640ec4e09..3d7842b36 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -301,6 +301,8 @@ bool kmstest_probe_connector_config(int drm_fd, uint32_t connector_id,
 void kmstest_free_connector_config(struct kmstest_connector_config *config);
 
 void kmstest_set_connector_dpms(int fd, drmModeConnector *connector, int mode);
+void kmstest_set_connector_link_status(int drm_fd, drmModeConnector *connector,
+				       int link_status);
 bool kmstest_get_property(int drm_fd, uint32_t object_id, uint32_t object_type,
 			  const char *name, uint32_t *prop_id, uint64_t *value,
 			  drmModePropertyPtr *prop);
-- 
2.43.0

[PATCH i-g-t 11/14] lib/igt_kms: add function to reset link params

[Kunal Joshi]

Writing auto to i915_dp_force_(link_rate/lane_count) and retraing
afterwards sets max link param's supported by sink.Reset link rate
and lane count to auto, also installs exit handler to set link rate
and lane count to auto on exit
---
 lib/igt_kms.c | 36 ++++++++++++++++++++++++++++++++++++
 lib/igt_kms.h |  1 +
 2 files changed, 37 insertions(+)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index e0533f6ae..b7511ccfc 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -7000,3 +7000,39 @@ int igt_get_dp_pending_retrain(int drm_fd, igt_output_t *output)
 	sscanf(buf, "%d", &ret);
 	return ret;
 }
+
+/**
+ * igt_reset_link_params:
+ * @drm_fd: A drm file descriptor
+ * @output: Target output
+ *
+ * Reset link rate and lane count to auto, also installs exit handler
+ * to set link rate and lane count to auto on exit
+ */
+void igt_reset_link_params(int drm_fd, igt_output_t *output)
+{
+	bool valid;
+	drmModeConnector *temp;
+
+	igt_require_f(output->name, "Invalid output");
+	valid = true;
+	valid = valid && connector_attr_set_debugfs(drm_fd, output->config.connector,
+						    "i915_dp_force_link_rate",
+						    "auto", "auto");
+	valid = valid && connector_attr_set_debugfs(drm_fd, output->config.connector,
+						    "i915_dp_force_lane_count",
+						    "auto", "auto");
+	valid = valid && connector_attr_set_debugfs(drm_fd, output->config.connector,
+						    "i915_dp_force_link_retrain",
+						    "1", "1");
+	igt_assert_f(valid, "Unable to set attr or install exit handler\n");
+	dump_connector_attrs();
+	igt_install_exit_handler(reset_connectors_at_exit);
+
+	/*
+	 * To allow callers to always use GetConnectorCurrent we need to force a
+	 * redetection here.
+	 */
+	temp = drmModeGetConnector(drm_fd, output->config.connector->connector_id);
+	drmModeFreeConnector(temp);
+}
diff --git a/lib/igt_kms.h b/lib/igt_kms.h
index 3d7842b36..847609379 100644
--- a/lib/igt_kms.h
+++ b/lib/igt_kms.h
@@ -1259,5 +1259,6 @@ bool igt_get_dp_link_retrain_disabled(int drm_fd, igt_output_t *output);
 bool igt_has_force_link_training_failure_debugfs(int drmfd, igt_output_t *output);
 int igt_get_dp_pending_lt_failures(int drm_fd, igt_output_t *output);
 int igt_get_dp_pending_retrain(int drm_fd, igt_output_t *output);
+void igt_reset_link_params(int drm_fd, igt_output_t *output);
 
 #endif /* __IGT_KMS_H__ */
-- 
2.43.0

[PATCH i-g-t 12/14] lib/igt_kms: allow set and reset value to be same

[Kunal Joshi]

allow set and reset value to be same, let the caller handle
this scenario instead.

example scenario where this is required.
i915_dp_force_link_rate should be auto before starting test
should be auto at exit

Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
---
 lib/igt_kms.c | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/lib/igt_kms.c b/lib/igt_kms.c
index b7511ccfc..5427a849e 100644
--- a/lib/igt_kms.c
+++ b/lib/igt_kms.c
@@ -1572,9 +1572,6 @@ static bool connector_attr_set(int idx, drmModeConnector *connector,
 		return false;
 	}
 
-	if (!strcmp(c->value, c->reset_value))
-		connector_attr_free(c);
-
 	return true;
 }
 
-- 
2.43.0

[PATCH i-g-t 13/14] tests/intel/kms_dp_fallback: add test for validating fallback

[Kunal Joshi]

add test to valdiate fallback for DP connector,
eDP subtest will be added later.

How does test validates fallback?
- test start by doing initial modeset on default mode
   (if connector is DP then we enable just that connector,
    if its DP-MST we enable all on the same topology)
- force link training failures and retrain until we reach
  lowest param or retrain is disabled
- expect hotplug and link-status to turn bad
- expect link params reduce after fallback

v2: add test for mst (imre)
    refresh mode list (imre)
    monitor got hotplugs (imre)
    check link parameter are reduced (imre)

v3: call check_fn (Santosh)

v4: handle buggy lg monitor (Imre)
    remove reset in between (Imre)

Cc: Imre Deak <imre.deak@intel.com>
Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
Suggested-by: Imre Deak <imre.deak@intel.com>
---
 tests/intel/kms_fallback.c | 506 +++++++++++++++++++++++++++++++++++++
 tests/meson.build          |   1 +
 2 files changed, 507 insertions(+)
 create mode 100644 tests/intel/kms_fallback.c

diff --git a/tests/intel/kms_fallback.c b/tests/intel/kms_fallback.c
new file mode 100644
index 000000000..e5da3c579
--- /dev/null
+++ b/tests/intel/kms_fallback.c
@@ -0,0 +1,506 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2024 Intel Corporation
+ */
+
+/**
+ * TEST: kms fallback
+ * Category: Display
+ * Description: Test link training fallback for eDP/DP connectors
+ * Driver requirement: i915, xe
+ * Functionality: link training
+ * Mega feature: General Display Features
+ * Test category: functionality test
+ */
+
+#include <sys/types.h>
+
+#include "igt.h"
+#include "igt_psr.h"
+
+/**
+ * SUBTEST: dp-fallback
+ * Description: Test fallback on DP connectors
+ */
+
+#define RETRAIN_COUNT 1
+#define LT_FAILURE_SAME_CAPS 1
+#define LT_FAILURE_REDUCED_CAPS 2
+#define SPURIOUS_HPD_RETRY 3
+
+static int traversed_mst_outputs[IGT_MAX_PIPES];
+static int traversed_mst_output_count;
+typedef struct {
+	int drm_fd;
+	igt_display_t display;
+	drmModeModeInfo *mode;
+	igt_output_t *output;
+	enum pipe pipe;
+	struct igt_fb fb;
+	struct igt_plane *primary;
+	int n_pipes;
+} data_t;
+
+typedef int (*condition_check_fn)(int drm_fd, igt_output_t *output);
+
+IGT_TEST_DESCRIPTION("Test link training fallback");
+
+static const char *str_link_rate(enum dp_link_rate link_rate)
+{
+	switch (link_rate) {
+	case DP_LINK_RATE_162000:
+		return "1.62 Gbps";
+	case DP_LINK_RATE_216000:
+		return "2.16 Gbps";
+	case DP_LINK_RATE_243000:
+		return "2.43 Gbps";
+	case DP_LINK_RATE_270000:
+		return "2.70 Gbps";
+	case DP_LINK_RATE_324000:
+		return "3.24 Gbps";
+	case DP_LINK_RATE_432000:
+		return "4.32 Gbps";
+	case DP_LINK_RATE_540000:
+		return "5.40 Gbps";
+	case DP_LINK_RATE_675000:
+		return "6.75 Gbps";
+	case DP_LINK_RATE_810000:
+		return "8.10 Gbps";
+	case DP_LINK_RATE_1000000:
+		return "10.00 Gbps";
+	case DP_LINK_RATE_1350000:
+		return "13.50 Gbps";
+	case DP_LINK_RATE_2000000:
+		return "20.00 Gbps";
+	default:
+		igt_assert_f(0, "Invalid link rate %d\n", link_rate);
+	}
+}
+
+static const char *str_lane_count(enum dp_lane_count lane_count)
+{
+	switch (lane_count) {
+	case DP_LANE_COUNT_1:
+		return "1";
+	case DP_LANE_COUNT_2:
+		return "2";
+	case DP_LANE_COUNT_4:
+		return "4";
+	default:
+		igt_assert_f(0, "Invalid lane count %d\n", lane_count);
+	}
+}
+
+static void find_mst_outputs(int drm_fd, data_t *data,
+			     igt_output_t *output,
+			     igt_output_t **mst_outputs,
+			     int *num_mst_outputs)
+{
+	bool is_output_mst;
+	uint64_t path_blob_id;
+	igt_output_t *connector_output;
+	drmModePropertyPtr path_prop = NULL;
+	drmModePropertyPtr connector_path_prop = NULL;
+
+	igt_assert_f(output, "Invalid output\n");
+
+	/*
+	 * Check if given output is MST by checking if it has PATH property
+	 */
+	is_output_mst = kmstest_get_property(drm_fd,
+			output->config.connector->connector_id,
+			DRM_MODE_OBJECT_CONNECTOR, "PATH", NULL,
+			&path_blob_id, &path_prop);
+
+	if (!is_output_mst)
+		return;
+
+	/*
+	 * If output is MST check all other connected output which shares
+	 * same path and fill mst_outputs and num_mst_outputs
+	 */
+	for_each_connected_output(&data->display, connector_output) {
+
+		connector_path_prop = NULL;
+
+		kmstest_get_property(drm_fd,
+				     connector_output->config.connector->connector_id,
+				     DRM_MODE_OBJECT_CONNECTOR, "PATH",
+				     NULL, &path_blob_id,
+				     &connector_path_prop);
+
+		if (connector_path_prop && path_prop &&
+		    connector_path_prop->prop_id == path_prop->prop_id)
+			mst_outputs[(*num_mst_outputs)++] = connector_output;
+
+		if (connector_path_prop)
+			drmModeFreeProperty(connector_path_prop);
+	}
+	if (path_prop)
+		drmModeFreeProperty(path_prop);
+}
+
+static bool setup_mst_outputs(data_t *data, igt_output_t *mst_output[],
+			      int *dp_mst_outputs)
+{
+	int i;
+	igt_output_t *output;
+
+	igt_require_f(igt_check_output_is_dp_mst(data->output),
+		      "Not a valid MST connector\n");
+
+	/*
+	 * Check if this is already traversed
+	 */
+	for (i = 0; i < traversed_mst_output_count; i++)
+		if (traversed_mst_outputs[i] == data->output->config.connector->connector_id)
+			return false;
+
+	find_mst_outputs(data->drm_fd, data, data->output,
+			 mst_output, dp_mst_outputs);
+
+	for (i = 0; i < *dp_mst_outputs; i++) {
+		output = mst_output[i];
+		traversed_mst_outputs[traversed_mst_output_count++] = output->config.connector->connector_id;
+		igt_info("Output %s is in same topology as %s\n",
+			 igt_output_name(output),
+			 igt_output_name(data->output));
+	}
+
+	return true;
+}
+
+static void setup_pipe_on_mst_outputs(data_t *data,
+				      igt_output_t *mst_output[],
+				      int *dp_mst_outputs)
+{
+	int i = 0;
+
+	igt_require_f(data->n_pipes >= *dp_mst_outputs,
+		      "Need %d pipes to assign to %d MST outputs\n",
+		      data->n_pipes, *dp_mst_outputs);
+
+	for_each_pipe(&data->display, data->pipe) {
+		if (i >= *dp_mst_outputs)
+			break;
+		igt_info("Setting pipe %s on output %s\n",
+			 kmstest_pipe_name(data->pipe),
+			 igt_output_name(mst_output[i]));
+		igt_output_set_pipe(mst_output[i++], data->pipe);
+	}
+}
+
+static void setup_modeset_on_mst_outputs(data_t *data,
+					 igt_output_t *mst_output[],
+					 int *dp_mst_outputs,
+					 drmModeModeInfo *mode[],
+					 struct igt_fb fb[],
+					 struct igt_plane *primary[])
+{
+	int i;
+
+	for (i = 0; i < *dp_mst_outputs; i++) {
+		mst_output[i]->force_reprobe = true;
+		igt_output_refresh(mst_output[i]);
+		mode[i] = igt_output_get_mode(mst_output[i]);
+		igt_info("Mode %dx%d@%d on output %s\n",
+			 mode[i]->hdisplay, mode[i]->vdisplay,
+			 mode[i]->vrefresh,
+			 igt_output_name(mst_output[i]));
+		primary[i] = igt_output_get_plane_type(mst_output[i],
+							DRM_PLANE_TYPE_PRIMARY);
+		igt_create_color_fb(data->drm_fd,
+				    mode[i]->hdisplay,
+				    mode[i]->vdisplay,
+				    DRM_FORMAT_XRGB8888,
+				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
+				    &fb[i]);
+		igt_plane_set_fb(primary[i], &fb[i]);
+	}
+}
+
+static bool validate_modeset_mst_output(data_t *data,
+					igt_output_t *mst_output[],
+					int *dp_mst_outputs,
+					drmModeModeInfo *mode[],
+					struct igt_fb fb[],
+					struct igt_plane *primary[])
+{
+	bool found;
+	int ret;
+
+	igt_require_f(*dp_mst_outputs > 0, "No MST outputs found\n");
+	setup_pipe_on_mst_outputs(data, mst_output, dp_mst_outputs);
+	setup_modeset_on_mst_outputs(data, mst_output,
+				     dp_mst_outputs,
+				     mode, fb, primary);
+	if (!igt_display_try_commit2(&data->display, COMMIT_ATOMIC)) {
+		igt_info("Modes overridden\n");
+		found = igt_override_all_active_output_modes_to_fit_bw(&data->display);
+
+		igt_require_f(found,
+			      "No valid mode combo found for MST modeset\n");
+		ret = igt_display_try_commit2(&data->display, COMMIT_ATOMIC);
+		igt_require_f(ret == 0,
+			      "Commit failure during MST modeset\n");
+	}
+	return true;
+}
+
+static bool setup_mst(data_t *data, bool is_mst,
+		      igt_output_t *mst_output[],
+		      int *dp_mst_outputs, drmModeModeInfo *mode[],
+		      struct igt_fb fb[], struct igt_plane *primary[])
+{
+	bool ret;
+
+	*dp_mst_outputs = 0;
+	ret = setup_mst_outputs(data, mst_output, dp_mst_outputs);
+	if (!ret) {
+		igt_info("Skipping MST output %s as already tested\n",
+			 igt_output_name(data->output));
+		return false;
+	}
+
+	ret = validate_modeset_mst_output(data, mst_output,
+					  dp_mst_outputs, mode,
+					  fb, primary);
+	if (!ret) {
+		igt_info("Skipping MST output %s as validpipe/output combo not found\n",
+			 igt_output_name(data->output));
+		return false;
+	}
+
+	igt_display_commit2(&data->display, COMMIT_ATOMIC);
+	return true;
+}
+
+static int check_condition_with_timeout(int drm_fd, igt_output_t *output,
+					condition_check_fn check_fn,
+					double interval, double timeout)
+{
+	struct timespec start_time, current_time;
+	double elapsed_time;
+
+	clock_gettime(CLOCK_MONOTONIC, &start_time);
+
+	while (1) {
+		if (check_fn(drm_fd, output) == 0) {
+			return 0;
+		}
+
+		clock_gettime(CLOCK_MONOTONIC, &current_time);
+		elapsed_time = (current_time.tv_sec - start_time.tv_sec) +
+			(current_time.tv_nsec - start_time.tv_nsec) / 1e9;
+
+		if (elapsed_time >= timeout) {
+			return -1;
+		}
+
+		usleep((useconds_t)(interval * 1000000));
+	}
+}
+
+static void test_fallback(data_t *data, bool is_mst)
+{
+	int dp_mst_outputs, retries;
+	igt_output_t *mst_outputs[IGT_MAX_PIPES];
+	enum dp_link_rate max_link_rate, curr_link_rate, prev_link_rate;
+	enum dp_lane_count max_lane_count, curr_lane_count, prev_lane_count;
+	uint32_t link_status_prop_id;
+	uint64_t link_status_value;
+	drmModeModeInfo *mst_modes[IGT_MAX_PIPES], *mode;
+	drmModePropertyPtr link_status_prop;
+	struct igt_fb mst_fbs[IGT_MAX_PIPES], fb;
+	struct igt_plane *mst_primarys[IGT_MAX_PIPES], *primary;
+	struct udev_monitor *mon;
+
+	igt_display_reset(&data->display);
+	retries = SPURIOUS_HPD_RETRY;
+
+	if (is_mst) {
+		if (!setup_mst(data, is_mst, mst_outputs,
+			       &dp_mst_outputs, mst_modes, mst_fbs,
+			       mst_primarys))
+			return;
+	} else {
+		data->pipe = PIPE_A;
+		igt_output_set_pipe(data->output, data->pipe);
+		mode = igt_output_get_mode(data->output);
+		primary = igt_output_get_plane_type(data->output,
+						    DRM_PLANE_TYPE_PRIMARY);
+		igt_create_color_fb(data->drm_fd,
+				    mode->hdisplay, mode->vdisplay,
+				    DRM_FORMAT_XRGB8888,
+				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
+				    &fb);
+		igt_plane_set_fb(primary, &fb);
+		igt_display_commit2(&data->display, COMMIT_ATOMIC);
+	}
+
+	igt_info("Testing link training fallback on %s\n",
+		 igt_output_name(data->output));
+
+	igt_reset_link_params(data->drm_fd, data->output);
+	igt_assert_eq(check_condition_with_timeout(data->drm_fd,
+						   data->output,
+						   igt_get_dp_pending_retrain,
+						   1.0, 20.0), 0);
+
+	max_link_rate = igt_get_dp_max_link_rate(data->drm_fd, data->output);
+	max_lane_count = igt_get_dp_max_lane_count(data->drm_fd, data->output);
+
+	while (!igt_get_dp_link_retrain_disabled(data->drm_fd,
+						 data->output)) {
+
+		prev_link_rate = igt_get_dp_link_rate_set_for_output(data->drm_fd, data->output);
+		prev_lane_count = igt_get_dp_lane_count_set_for_output(data->drm_fd, data->output);
+
+		igt_info("Current link rate: %s, Current lane count: %s\n",
+			 str_link_rate(prev_link_rate),
+			 str_lane_count(prev_lane_count));
+		mon = igt_watch_uevents();
+		igt_force_lt_failure(data->drm_fd, data->output,
+				     LT_FAILURE_REDUCED_CAPS);
+		igt_force_link_retrain(data->drm_fd, data->output,
+				       RETRAIN_COUNT);
+
+		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
+							   data->output,
+							   igt_get_dp_pending_retrain,
+							   1.0, 20.0), 0);
+		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
+							   data->output,
+							   igt_get_dp_pending_lt_failures,
+							   1.0, 20.0), 0);
+
+		if (igt_get_dp_link_retrain_disabled(data->drm_fd,
+						     data->output)) {
+			igt_reset_connectors();
+			return;
+		}
+
+		igt_assert_f(igt_hotplug_detected(mon, 20),
+			     "Didn't get hotplug for force link training failure\n");
+
+		kmstest_get_property(data->drm_fd,
+				data->output->config.connector->connector_id,
+				DRM_MODE_OBJECT_CONNECTOR, "link-status",
+				&link_status_prop_id, &link_status_value,
+				&link_status_prop);
+
+		igt_assert_eq(link_status_value, DRM_MODE_LINK_STATUS_BAD);
+
+		igt_flush_uevents(mon);
+
+		if (is_mst) {
+			igt_assert_f(validate_modeset_mst_output(data,
+								 mst_outputs,
+								 &dp_mst_outputs,
+								 mst_modes,
+								 mst_fbs,
+								 mst_primarys),
+				     "MST modeset failed\n");
+		} else {
+			data->output->force_reprobe = true;
+			igt_output_refresh(data->output);
+			data->pipe = PIPE_A;
+			igt_output_set_pipe(data->output, data->pipe);
+			mode = igt_output_get_mode(data->output);
+			igt_info("Mode %dx%d@%d on output %s\n",
+				 mode->hdisplay, mode->vdisplay,
+				 mode->vrefresh,
+				 igt_output_name(data->output));
+			primary = igt_output_get_plane_type(data->output,
+							    DRM_PLANE_TYPE_PRIMARY);
+			igt_create_color_fb(data->drm_fd,
+					    mode->hdisplay,
+					    mode->vdisplay,
+					    DRM_FORMAT_XRGB8888,
+					    DRM_FORMAT_MOD_LINEAR,
+					    0.0, 1.0, 0.0, &fb);
+			igt_plane_set_fb(primary, &fb);
+		}
+
+		kmstest_set_connector_link_status(data->drm_fd,
+						  data->output->config.connector,
+						  DRM_MODE_LINK_STATUS_GOOD);
+		igt_display_commit2(&data->display, COMMIT_ATOMIC);
+
+		kmstest_get_property(data->drm_fd,
+				data->output->config.connector->connector_id,
+				DRM_MODE_OBJECT_CONNECTOR, "link-status",
+				&link_status_prop_id, &link_status_value,
+				&link_status_prop);
+		igt_assert_eq(link_status_value, DRM_MODE_LINK_STATUS_GOOD);
+
+		curr_link_rate = igt_get_dp_link_rate_set_for_output(data->drm_fd, data->output);
+		curr_lane_count = igt_get_dp_lane_count_set_for_output(data->drm_fd, data->output);
+
+		igt_assert_f((curr_link_rate < prev_link_rate ||
+			     curr_lane_count < prev_lane_count) ||
+			     ((curr_link_rate == max_link_rate && curr_lane_count == max_lane_count) && --retries),
+			     "Fallback unsuccessful\n");
+
+		prev_link_rate = curr_link_rate;
+		prev_lane_count = curr_lane_count;
+	}
+}
+
+igt_main
+{
+	data_t data = {};
+
+	igt_fixture {
+		data.drm_fd = drm_open_driver_master(DRIVER_INTEL |
+						     DRIVER_XE);
+		kmstest_set_vt_graphics_mode();
+		igt_display_require(&data.display, data.drm_fd);
+		igt_display_require_output(&data.display);
+		for_each_pipe(&data.display, data.pipe) {
+			data.n_pipes++;
+		}
+	}
+
+	igt_subtest("dp-fallback") {
+		bool ran = false;
+		igt_output_t *output;
+
+		for_each_connected_output(&data.display, output) {
+
+			data.output = output;
+			if (!igt_has_force_link_training_failure_debugfs(data.drm_fd,
+								    data.output)) {
+				igt_info("Output %s unsupported\n", igt_output_name(data.output));
+				continue;
+			}
+
+			if (output->config.connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort) {
+				igt_info("Skipping output %s as it's not DP\n", output->name);
+				continue;
+			}
+
+			ran = true;
+
+			/*
+			 * Check output is MST
+			 */
+			if (igt_check_output_is_dp_mst(data.output)) {
+				igt_info("Testing MST output %s\n",
+					 igt_output_name(data.output));
+				test_fallback(&data, true);
+			} else {
+				igt_info("Testing DP output %s\n",
+					 igt_output_name(data.output));
+				test_fallback(&data, false);
+			}
+		}
+		igt_require_f(ran, "No output supports fallback\n");
+	}
+
+	igt_fixture {
+		igt_remove_fb(data.drm_fd, &data.fb);
+		igt_display_fini(&data.display);
+		close(data.drm_fd);
+	}
+}
diff --git a/tests/meson.build b/tests/meson.build
index 00556c9d6..86fab423b 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -249,6 +249,7 @@ intel_kms_progs = [
 	'kms_dirtyfb',
 	'kms_draw_crc',
 	'kms_dsc',
+        'kms_fallback',
 	'kms_fb_coherency',
 	'kms_fbcon_fbt',
 	'kms_fence_pin_leak',
-- 
2.43.0

[PATCH i-g-t 14/14] HAX: Do not merge

[Kunal Joshi]

---
 tests/intel-ci/fast-feedback.testlist    | 1 +
 tests/intel-ci/xe-fast-feedback.testlist | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/tests/intel-ci/fast-feedback.testlist b/tests/intel-ci/fast-feedback.testlist
index be0965110..7b84ccffc 100644
--- a/tests/intel-ci/fast-feedback.testlist
+++ b/tests/intel-ci/fast-feedback.testlist
@@ -1,6 +1,7 @@
 # Try to load the driver if it's not available yet.
 igt@i915_module_load@load
 
+igt@kms_fallback@dp-fallback
 # Keep alphabetically sorted by default
 igt@core_auth@basic-auth
 igt@debugfs_test@read_all_entries
diff --git a/tests/intel-ci/xe-fast-feedback.testlist b/tests/intel-ci/xe-fast-feedback.testlist
index 01b01dcf9..110675cd3 100644
--- a/tests/intel-ci/xe-fast-feedback.testlist
+++ b/tests/intel-ci/xe-fast-feedback.testlist
@@ -1,6 +1,8 @@
 # Should be the first test
 igt@xe_module_load@load
 
+igt@kms_fallback@dp-fallback
+
 igt@fbdev@eof
 igt@fbdev@info
 igt@fbdev@nullptr
-- 
2.43.0

✗ CI.xeBAT: failure for add test to validate fallback (rev4)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 4072 bytes --]

== Series Details ==

Series: add test to validate fallback (rev4)
URL   : https://patchwork.freedesktop.org/series/134660/
State : failure

== Summary ==

CI Bug Log - changes from XEIGT_7990_BAT -> XEIGTPW_11632_BAT
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with XEIGTPW_11632_BAT absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in XEIGTPW_11632_BAT, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them
  to document this new failure mode, which will reduce false positives in CI.

  

Participating hosts (9 -> 9)
------------------------------

  No changes in participating hosts

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in XEIGTPW_11632_BAT:

### IGT changes ###

#### Possible regressions ####

  * igt@kms_fallback@dp-fallback (NEW):
    - {bat-bmg-2}:        NOTRUN -> [SKIP][1]
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/bat-bmg-2/igt@kms_fallback@dp-fallback.html
    - bat-adlp-7:         NOTRUN -> [SKIP][2]
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/bat-adlp-7/igt@kms_fallback@dp-fallback.html
    - bat-bmg-1:          NOTRUN -> [SKIP][3]
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/bat-bmg-1/igt@kms_fallback@dp-fallback.html
    - bat-lnl-2:          NOTRUN -> [SKIP][4]
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/bat-lnl-2/igt@kms_fallback@dp-fallback.html
    - bat-dg2-oem2:       NOTRUN -> [FAIL][5]
   [5]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/bat-dg2-oem2/igt@kms_fallback@dp-fallback.html
    - bat-adlp-vf:        NOTRUN -> [SKIP][6]
   [6]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/bat-adlp-vf/igt@kms_fallback@dp-fallback.html
    - bat-lnl-1:          NOTRUN -> [SKIP][7]
   [7]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/bat-lnl-1/igt@kms_fallback@dp-fallback.html

  
New tests
---------

  New tests have been introduced between XEIGT_7990_BAT and XEIGTPW_11632_BAT:

### New IGT tests (1) ###

  * igt@kms_fallback@dp-fallback:
    - Statuses : 1 fail(s) 8 skip(s)
    - Exec time: [0.0, 1.23] s

  

Known issues
------------

  Here are the changes found in XEIGTPW_11632_BAT that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@kms_fallback@dp-fallback (NEW):
    - bat-atsm-2:         NOTRUN -> [SKIP][8] ([Intel XE#1024])
   [8]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/bat-atsm-2/igt@kms_fallback@dp-fallback.html
    - bat-pvc-2:          NOTRUN -> [SKIP][9] ([Intel XE#1024])
   [9]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/bat-pvc-2/igt@kms_fallback@dp-fallback.html

  * igt@xe_exec_reset@cm-close-fd-no-exec:
    - bat-lnl-1:          [PASS][10] -> [FAIL][11] ([Intel XE#1069])
   [10]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/bat-lnl-1/igt@xe_exec_reset@cm-close-fd-no-exec.html
   [11]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/bat-lnl-1/igt@xe_exec_reset@cm-close-fd-no-exec.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [Intel XE#1024]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1024
  [Intel XE#1069]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1069


Build changes
-------------

  * IGT: IGT_7990 -> IGTPW_11632
  * Linux: xe-1822-411a047925bb7e169a075a2ddfb63ba96f26a8c8 -> xe-1823-5626fe5d6eeb0949727861375b27d67ee71feaa7

  IGTPW_11632: 11632
  IGT_7990: 9ca5ff0afa3636478b6ba5a97e5ba440cfb2e55e @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  xe-1822-411a047925bb7e169a075a2ddfb63ba96f26a8c8: 411a047925bb7e169a075a2ddfb63ba96f26a8c8
  xe-1823-5626fe5d6eeb0949727861375b27d67ee71feaa7: 5626fe5d6eeb0949727861375b27d67ee71feaa7

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/index.html

[-- Attachment #2: Type: text/html, Size: 4875 bytes --]

✗ Fi.CI.BAT: failure for add test to validate fallback (rev4)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 11193 bytes --]

== Series Details ==

Series: add test to validate fallback (rev4)
URL   : https://patchwork.freedesktop.org/series/134660/
State : failure

== Summary ==

CI Bug Log - changes from CI_DRM_15288 -> IGTPW_11632
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with IGTPW_11632 absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_11632, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/index.html

Participating hosts (38 -> 35)
------------------------------

  Additional (2): fi-cfl-8109u fi-kbl-8809g 
  Missing    (5): bat-dg1-7 fi-tgl-1115g4 fi-snb-2520m fi-glk-j4005 fi-blb-e6850 

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in IGTPW_11632:

### IGT changes ###

#### Possible regressions ####

  * igt@kms_fallback@dp-fallback (NEW):
    - fi-rkl-11600:       NOTRUN -> [SKIP][1]
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-rkl-11600/igt@kms_fallback@dp-fallback.html
    - fi-cfl-8109u:       NOTRUN -> [FAIL][2]
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-cfl-8109u/igt@kms_fallback@dp-fallback.html
    - bat-arls-2:         NOTRUN -> [SKIP][3]
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-arls-2/igt@kms_fallback@dp-fallback.html
    - bat-mtlp-8:         NOTRUN -> [SKIP][4]
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-mtlp-8/igt@kms_fallback@dp-fallback.html
    - bat-dg2-8:          NOTRUN -> [FAIL][5]
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-dg2-8/igt@kms_fallback@dp-fallback.html
    - bat-adls-6:         NOTRUN -> [FAIL][6]
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-adls-6/igt@kms_fallback@dp-fallback.html
    - bat-jsl-1:          NOTRUN -> [SKIP][7]
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-jsl-1/igt@kms_fallback@dp-fallback.html
    - bat-arls-1:         NOTRUN -> [SKIP][8]
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-arls-1/igt@kms_fallback@dp-fallback.html
    - bat-adlp-6:         NOTRUN -> [SKIP][9]
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-adlp-6/igt@kms_fallback@dp-fallback.html
    - bat-arlh-2:         NOTRUN -> [SKIP][10]
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-arlh-2/igt@kms_fallback@dp-fallback.html
    - bat-adlp-9:         NOTRUN -> [FAIL][11]
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-adlp-9/igt@kms_fallback@dp-fallback.html
    - bat-twl-2:          NOTRUN -> [SKIP][12]
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-twl-2/igt@kms_fallback@dp-fallback.html
    - bat-dg2-11:         NOTRUN -> [SKIP][13]
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-dg2-11/igt@kms_fallback@dp-fallback.html
    - bat-rpls-4:         NOTRUN -> [SKIP][14]
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-rpls-4/igt@kms_fallback@dp-fallback.html
    - fi-kbl-7567u:       NOTRUN -> [FAIL][15]
   [15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-kbl-7567u/igt@kms_fallback@dp-fallback.html
    - bat-twl-1:          NOTRUN -> [SKIP][16]
   [16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-twl-1/igt@kms_fallback@dp-fallback.html
    - bat-apl-1:          NOTRUN -> [FAIL][17]
   [17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-apl-1/igt@kms_fallback@dp-fallback.html
    - bat-dg2-14:         NOTRUN -> [SKIP][18]
   [18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-dg2-14/igt@kms_fallback@dp-fallback.html
    - bat-arls-5:         NOTRUN -> [FAIL][19]
   [19]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-arls-5/igt@kms_fallback@dp-fallback.html
    - bat-rplp-1:         NOTRUN -> [SKIP][20]
   [20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-rplp-1/igt@kms_fallback@dp-fallback.html

  
New tests
---------

  New tests have been introduced between CI_DRM_15288 and IGTPW_11632:

### New IGT tests (1) ###

  * igt@kms_fallback@dp-fallback:
    - Statuses : 7 fail(s) 27 skip(s)
    - Exec time: [0.0, 10.43] s

  

Known issues
------------

  Here are the changes found in IGTPW_11632 that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@gem_huc_copy@huc-copy:
    - fi-cfl-8109u:       NOTRUN -> [SKIP][21] ([i915#2190])
   [21]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-cfl-8109u/igt@gem_huc_copy@huc-copy.html
    - fi-kbl-8809g:       NOTRUN -> [SKIP][22] ([i915#2190])
   [22]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-kbl-8809g/igt@gem_huc_copy@huc-copy.html

  * igt@gem_lmem_swapping@basic:
    - fi-kbl-8809g:       NOTRUN -> [SKIP][23] ([i915#4613]) +3 other tests skip
   [23]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-kbl-8809g/igt@gem_lmem_swapping@basic.html

  * igt@gem_lmem_swapping@verify-random:
    - fi-cfl-8109u:       NOTRUN -> [SKIP][24] ([i915#4613]) +3 other tests skip
   [24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-cfl-8109u/igt@gem_lmem_swapping@verify-random.html

  * igt@i915_pm_rpm@module-reload:
    - bat-apl-1:          [PASS][25] -> [DMESG-WARN][26] ([i915#11621] / [i915#1982])
   [25]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_15288/bat-apl-1/igt@i915_pm_rpm@module-reload.html
   [26]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-apl-1/igt@i915_pm_rpm@module-reload.html

  * igt@i915_selftest@live@hangcheck:
    - bat-arls-2:         [PASS][27] -> [DMESG-WARN][28] ([i915#11349])
   [27]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_15288/bat-arls-2/igt@i915_selftest@live@hangcheck.html
   [28]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-arls-2/igt@i915_selftest@live@hangcheck.html
    - bat-adlm-1:         [PASS][29] -> [INCOMPLETE][30] ([i915#9413])
   [29]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_15288/bat-adlm-1/igt@i915_selftest@live@hangcheck.html
   [30]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-adlm-1/igt@i915_selftest@live@hangcheck.html
    - bat-arls-1:         [PASS][31] -> [DMESG-WARN][32] ([i915#11349])
   [31]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_15288/bat-arls-1/igt@i915_selftest@live@hangcheck.html
   [32]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-arls-1/igt@i915_selftest@live@hangcheck.html
    - bat-dg2-11:         [PASS][33] -> [DMESG-FAIL][34] ([i915#9500])
   [33]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_15288/bat-dg2-11/igt@i915_selftest@live@hangcheck.html
   [34]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-dg2-11/igt@i915_selftest@live@hangcheck.html

  * igt@i915_selftest@live@requests:
    - bat-apl-1:          [PASS][35] -> [DMESG-WARN][36] ([i915#11621]) +31 other tests dmesg-warn
   [35]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_15288/bat-apl-1/igt@i915_selftest@live@requests.html
   [36]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-apl-1/igt@i915_selftest@live@requests.html

  * igt@kms_fallback@dp-fallback (NEW):
    - fi-cfl-guc:         NOTRUN -> [SKIP][37]
   [37]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-cfl-guc/igt@kms_fallback@dp-fallback.html
    - bat-mtlp-6:         NOTRUN -> [SKIP][38] ([i915#9792])
   [38]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-mtlp-6/igt@kms_fallback@dp-fallback.html
    - bat-dg2-9:          NOTRUN -> [SKIP][39] ([i915#9197])
   [39]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-dg2-9/igt@kms_fallback@dp-fallback.html
    - fi-kbl-x1275:       NOTRUN -> [SKIP][40]
   [40]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-kbl-x1275/igt@kms_fallback@dp-fallback.html
    - bat-adlp-11:        NOTRUN -> [SKIP][41] ([i915#10470])
   [41]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-adlp-11/igt@kms_fallback@dp-fallback.html
    - fi-ivb-3770:        NOTRUN -> [SKIP][42]
   [42]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-ivb-3770/igt@kms_fallback@dp-fallback.html
    - fi-kbl-guc:         NOTRUN -> [SKIP][43]
   [43]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-kbl-guc/igt@kms_fallback@dp-fallback.html
    - fi-ilk-650:         NOTRUN -> [SKIP][44]
   [44]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-ilk-650/igt@kms_fallback@dp-fallback.html
    - fi-bsw-n3050:       NOTRUN -> [SKIP][45]
   [45]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-bsw-n3050/igt@kms_fallback@dp-fallback.html
    - fi-pnv-d510:        NOTRUN -> [SKIP][46]
   [46]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-pnv-d510/igt@kms_fallback@dp-fallback.html
    - fi-cfl-8700k:       NOTRUN -> [SKIP][47]
   [47]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-cfl-8700k/igt@kms_fallback@dp-fallback.html
    - bat-kbl-2:          NOTRUN -> [SKIP][48]
   [48]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-kbl-2/igt@kms_fallback@dp-fallback.html
    - bat-adlm-1:         NOTRUN -> [SKIP][49] ([i915#9900])
   [49]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/bat-adlm-1/igt@kms_fallback@dp-fallback.html

  * igt@kms_force_connector_basic@force-load-detect:
    - fi-kbl-8809g:       NOTRUN -> [SKIP][50] +31 other tests skip
   [50]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-kbl-8809g/igt@kms_force_connector_basic@force-load-detect.html

  * igt@kms_pm_backlight@basic-brightness:
    - fi-cfl-8109u:       NOTRUN -> [SKIP][51] +11 other tests skip
   [51]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/fi-cfl-8109u/igt@kms_pm_backlight@basic-brightness.html

  
  [i915#10470]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10470
  [i915#11349]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11349
  [i915#11621]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11621
  [i915#1982]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1982
  [i915#2190]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2190
  [i915#4613]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4613
  [i915#9197]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9197
  [i915#9413]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9413
  [i915#9500]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9500
  [i915#9792]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9792
  [i915#9900]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9900


Build changes
-------------

  * CI: CI-20190529 -> None
  * IGT: IGT_7990 -> IGTPW_11632

  CI-20190529: 20190529
  CI_DRM_15288: 5626fe5d6eeb0949727861375b27d67ee71feaa7 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_11632: 11632
  IGT_7990: 9ca5ff0afa3636478b6ba5a97e5ba440cfb2e55e @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11632/index.html

[-- Attachment #2: Type: text/html, Size: 12540 bytes --]

✗ CI.xeFULL: failure for add test to validate fallback (rev4)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 78136 bytes --]

== Series Details ==

Series: add test to validate fallback (rev4)
URL   : https://patchwork.freedesktop.org/series/134660/
State : failure

== Summary ==

CI Bug Log - changes from XEIGT_7990_full -> XEIGTPW_11632_full
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with XEIGTPW_11632_full absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in XEIGTPW_11632_full, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them
  to document this new failure mode, which will reduce false positives in CI.

  

Participating hosts (4 -> 4)
------------------------------

  No changes in participating hosts

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in XEIGTPW_11632_full:

### IGT changes ###

#### Possible regressions ####

  * igt@kms_fallback@dp-fallback (NEW):
    - {shard-bmg}:        NOTRUN -> [FAIL][1]
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-4/igt@kms_fallback@dp-fallback.html
    - shard-dg2-set2:     NOTRUN -> [FAIL][2]
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@kms_fallback@dp-fallback.html

  * igt@kms_pm_rpm@i2c:
    - shard-dg2-set2:     [PASS][3] -> [FAIL][4]
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_pm_rpm@i2c.html
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_pm_rpm@i2c.html

  * igt@kms_psr_stress_test@invalidate-primary-flip-overlay:
    - shard-lnl:          [PASS][5] -> [DMESG-WARN][6]
   [5]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-1/igt@kms_psr_stress_test@invalidate-primary-flip-overlay.html
   [6]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@kms_psr_stress_test@invalidate-primary-flip-overlay.html

  * igt@xe_exec_fault_mode@many-execqueues-bindexecqueue-imm:
    - shard-lnl:          [PASS][7] -> [FAIL][8]
   [7]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-8/igt@xe_exec_fault_mode@many-execqueues-bindexecqueue-imm.html
   [8]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-6/igt@xe_exec_fault_mode@many-execqueues-bindexecqueue-imm.html

  * igt@xe_exec_fault_mode@twice-userptr-prefetch:
    - shard-lnl:          NOTRUN -> [FAIL][9]
   [9]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-6/igt@xe_exec_fault_mode@twice-userptr-prefetch.html

  
#### Warnings ####

  * igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs:
    - shard-dg2-set2:     [SKIP][10] ([Intel XE#1201]) -> [SKIP][11] +2 other tests skip
   [10]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-436/igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs.html
   [11]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs.html

  
#### Suppressed ####

  The following results come from untrusted machines, tests, or statuses.
  They do not affect the overall result.

  * igt@kms_async_flips@crc@pipe-a-dp-2:
    - {shard-bmg}:        [FAIL][12] ([Intel XE#1656]) -> [DMESG-FAIL][13]
   [12]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-1/igt@kms_async_flips@crc@pipe-a-dp-2.html
   [13]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-7/igt@kms_async_flips@crc@pipe-a-dp-2.html

  * igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-180-hflip:
    - {shard-bmg}:        [FAIL][14] ([Intel XE#1659]) -> [SKIP][15]
   [14]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-4/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-180-hflip.html
   [15]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-180-hflip.html

  * igt@kms_big_fb@y-tiled-addfb-size-offset-overflow:
    - {shard-bmg}:        [SKIP][16] ([Intel XE#607]) -> [SKIP][17]
   [16]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-1/igt@kms_big_fb@y-tiled-addfb-size-offset-overflow.html
   [17]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_big_fb@y-tiled-addfb-size-offset-overflow.html

  * igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-0-hflip-async-flip:
    - {shard-bmg}:        [SKIP][18] ([Intel XE#1124]) -> [SKIP][19]
   [18]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-4/igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-0-hflip-async-flip.html
   [19]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-0-hflip-async-flip.html

  * igt@kms_bw@linear-tiling-2-displays-2160x1440p:
    - {shard-bmg}:        [SKIP][20] ([Intel XE#367]) -> [SKIP][21]
   [20]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-6/igt@kms_bw@linear-tiling-2-displays-2160x1440p.html
   [21]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_bw@linear-tiling-2-displays-2160x1440p.html

  * igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs:
    - {shard-bmg}:        [SKIP][22] ([Intel XE#2251]) -> [SKIP][23]
   [22]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-8/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs.html
   [23]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs.html

  * igt@kms_chamelium_edid@hdmi-edid-read:
    - {shard-bmg}:        [SKIP][24] ([Intel XE#2252]) -> [SKIP][25] +1 other test skip
   [24]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-5/igt@kms_chamelium_edid@hdmi-edid-read.html
   [25]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_chamelium_edid@hdmi-edid-read.html

  * igt@kms_content_protection@type1:
    - {shard-bmg}:        [SKIP][26] ([Intel XE#2341]) -> [SKIP][27]
   [26]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-4/igt@kms_content_protection@type1.html
   [27]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_content_protection@type1.html

  * igt@kms_cursor_crc@cursor-onscreen-32x10:
    - {shard-bmg}:        [SKIP][28] ([Intel XE#2320]) -> [SKIP][29]
   [28]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-6/igt@kms_cursor_crc@cursor-onscreen-32x10.html
   [29]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_cursor_crc@cursor-onscreen-32x10.html

  * igt@kms_flip@2x-plain-flip:
    - {shard-bmg}:        [PASS][30] -> [SKIP][31] +19 other tests skip
   [30]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-3/igt@kms_flip@2x-plain-flip.html
   [31]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_flip@2x-plain-flip.html

  * igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-upscaling:
    - {shard-bmg}:        [SKIP][32] ([Intel XE#2293] / [Intel XE#2380]) -> [SKIP][33]
   [32]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-4/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-upscaling.html
   [33]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-upscaling.html

  * igt@kms_frontbuffer_tracking@drrs-2p-primscrn-spr-indfb-move:
    - {shard-bmg}:        [SKIP][34] ([Intel XE#2311]) -> [SKIP][35] +1 other test skip
   [34]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-4/igt@kms_frontbuffer_tracking@drrs-2p-primscrn-spr-indfb-move.html
   [35]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_frontbuffer_tracking@drrs-2p-primscrn-spr-indfb-move.html

  * igt@kms_frontbuffer_tracking@fbc-2p-rte:
    - {shard-bmg}:        [FAIL][36] ([Intel XE#2333]) -> [SKIP][37]
   [36]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-6/igt@kms_frontbuffer_tracking@fbc-2p-rte.html
   [37]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_frontbuffer_tracking@fbc-2p-rte.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-spr-indfb-draw-mmap-wc:
    - {shard-bmg}:        NOTRUN -> [SKIP][38] +1 other test skip
   [38]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-spr-indfb-draw-mmap-wc.html

  * igt@kms_frontbuffer_tracking@psr-1p-offscren-pri-indfb-draw-blt:
    - {shard-bmg}:        [SKIP][39] ([Intel XE#2313]) -> [SKIP][40] +4 other tests skip
   [39]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-2/igt@kms_frontbuffer_tracking@psr-1p-offscren-pri-indfb-draw-blt.html
   [40]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_frontbuffer_tracking@psr-1p-offscren-pri-indfb-draw-blt.html

  * igt@kms_hdr@bpc-switch-suspend:
    - {shard-bmg}:        [PASS][41] -> [INCOMPLETE][42]
   [41]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-1/igt@kms_hdr@bpc-switch-suspend.html
   [42]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-8/igt@kms_hdr@bpc-switch-suspend.html

  * igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-75:
    - {shard-bmg}:        [SKIP][43] ([Intel XE#2318]) -> [SKIP][44]
   [43]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-3/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-75.html
   [44]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-75.html

  * igt@kms_pm_rpm@i2c:
    - {shard-bmg}:        [PASS][45] -> [FAIL][46]
   [45]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-1/igt@kms_pm_rpm@i2c.html
   [46]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-1/igt@kms_pm_rpm@i2c.html

  * igt@kms_psr2_sf@fbc-overlay-plane-move-continuous-sf:
    - {shard-bmg}:        [SKIP][47] ([Intel XE#1489]) -> [SKIP][48] +1 other test skip
   [47]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-1/igt@kms_psr2_sf@fbc-overlay-plane-move-continuous-sf.html
   [48]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_psr2_sf@fbc-overlay-plane-move-continuous-sf.html

  * igt@kms_psr@psr-cursor-plane-move:
    - {shard-bmg}:        [SKIP][49] ([Intel XE#2234]) -> [SKIP][50] +1 other test skip
   [49]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-8/igt@kms_psr@psr-cursor-plane-move.html
   [50]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_psr@psr-cursor-plane-move.html

  * igt@kms_rotation_crc@bad-tiling:
    - {shard-bmg}:        [SKIP][51] ([Intel XE#2329]) -> [SKIP][52] +1 other test skip
   [51]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-2/igt@kms_rotation_crc@bad-tiling.html
   [52]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_rotation_crc@bad-tiling.html

  * igt@kms_vrr@max-min:
    - {shard-bmg}:        [SKIP][53] ([Intel XE#1499]) -> [SKIP][54]
   [53]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-6/igt@kms_vrr@max-min.html
   [54]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-5/igt@kms_vrr@max-min.html

  * igt@xe_evict@evict-beng-mixed-threads-large:
    - {shard-bmg}:        [PASS][55] -> [DMESG-FAIL][56]
   [55]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-1/igt@xe_evict@evict-beng-mixed-threads-large.html
   [56]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-3/igt@xe_evict@evict-beng-mixed-threads-large.html

  
New tests
---------

  New tests have been introduced between XEIGT_7990_full and XEIGTPW_11632_full:

### New IGT tests (1) ###

  * igt@kms_fallback@dp-fallback:
    - Statuses : 2 fail(s)
    - Exec time: [5.08, 5.23] s

  

Known issues
------------

  Here are the changes found in XEIGTPW_11632_full that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@kms_addfb_basic@addfb25-y-tiled-small-legacy:
    - shard-lnl:          NOTRUN -> [SKIP][57] ([Intel XE#1466])
   [57]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-1/igt@kms_addfb_basic@addfb25-y-tiled-small-legacy.html

  * igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels@pipe-a-edp-1:
    - shard-lnl:          [PASS][58] -> [FAIL][59] ([Intel XE#1426]) +3 other tests fail
   [58]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-4/igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels@pipe-a-edp-1.html
   [59]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels@pipe-a-edp-1.html

  * igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-180-hflip:
    - shard-lnl:          [PASS][60] -> [FAIL][61] ([Intel XE#1659])
   [60]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-5/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-180-hflip.html
   [61]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-180-hflip.html

  * igt@kms_big_fb@linear-64bpp-rotate-270:
    - shard-dg2-set2:     NOTRUN -> [SKIP][62] ([Intel XE#1201] / [Intel XE#316])
   [62]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@kms_big_fb@linear-64bpp-rotate-270.html

  * igt@kms_big_fb@x-tiled-64bpp-rotate-90:
    - shard-lnl:          NOTRUN -> [SKIP][63] ([Intel XE#1407])
   [63]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-1/igt@kms_big_fb@x-tiled-64bpp-rotate-90.html

  * igt@kms_big_fb@yf-tiled-max-hw-stride-64bpp-rotate-0-async-flip:
    - shard-lnl:          NOTRUN -> [SKIP][64] ([Intel XE#1124]) +6 other tests skip
   [64]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-7/igt@kms_big_fb@yf-tiled-max-hw-stride-64bpp-rotate-0-async-flip.html

  * igt@kms_big_joiner@invalid-modeset:
    - shard-lnl:          NOTRUN -> [SKIP][65] ([Intel XE#346])
   [65]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-6/igt@kms_big_joiner@invalid-modeset.html

  * igt@kms_bw@linear-tiling-2-displays-2160x1440p:
    - shard-lnl:          NOTRUN -> [SKIP][66] ([Intel XE#367]) +1 other test skip
   [66]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@kms_bw@linear-tiling-2-displays-2160x1440p.html

  * igt@kms_ccs@bad-aux-stride-y-tiled-gen12-mc-ccs:
    - shard-dg2-set2:     NOTRUN -> [SKIP][67] ([Intel XE#1201] / [Intel XE#455] / [Intel XE#787]) +3 other tests skip
   [67]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_ccs@bad-aux-stride-y-tiled-gen12-mc-ccs.html

  * igt@kms_ccs@bad-aux-stride-y-tiled-gen12-mc-ccs@pipe-c-hdmi-a-6:
    - shard-dg2-set2:     NOTRUN -> [SKIP][68] ([Intel XE#1201] / [Intel XE#787]) +13 other tests skip
   [68]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_ccs@bad-aux-stride-y-tiled-gen12-mc-ccs@pipe-c-hdmi-a-6.html

  * igt@kms_ccs@random-ccs-data-4-tiled-mtl-rc-ccs:
    - shard-lnl:          NOTRUN -> [SKIP][69] ([Intel XE#1399]) +9 other tests skip
   [69]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-1/igt@kms_ccs@random-ccs-data-4-tiled-mtl-rc-ccs.html

  * igt@kms_ccs@random-ccs-data-y-tiled-gen12-rc-ccs-cc:
    - shard-dg2-set2:     NOTRUN -> [SKIP][70] ([Intel XE#455] / [Intel XE#787]) +1 other test skip
   [70]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_ccs@random-ccs-data-y-tiled-gen12-rc-ccs-cc.html

  * igt@kms_ccs@random-ccs-data-y-tiled-gen12-rc-ccs-cc@pipe-d-hdmi-a-6:
    - shard-dg2-set2:     NOTRUN -> [SKIP][71] ([Intel XE#787]) +6 other tests skip
   [71]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_ccs@random-ccs-data-y-tiled-gen12-rc-ccs-cc@pipe-d-hdmi-a-6.html

  * igt@kms_cdclk@mode-transition-all-outputs:
    - shard-lnl:          NOTRUN -> [SKIP][72] ([Intel XE#314])
   [72]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@kms_cdclk@mode-transition-all-outputs.html

  * igt@kms_chamelium_hpd@hdmi-hpd:
    - shard-dg2-set2:     NOTRUN -> [SKIP][73] ([Intel XE#1201] / [Intel XE#373]) +1 other test skip
   [73]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_chamelium_hpd@hdmi-hpd.html

  * igt@kms_chamelium_hpd@hdmi-hpd-storm:
    - shard-lnl:          NOTRUN -> [SKIP][74] ([Intel XE#373]) +4 other tests skip
   [74]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-6/igt@kms_chamelium_hpd@hdmi-hpd-storm.html

  * igt@kms_cursor_crc@cursor-onscreen-32x10:
    - shard-lnl:          NOTRUN -> [SKIP][75] ([Intel XE#1424])
   [75]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@kms_cursor_crc@cursor-onscreen-32x10.html

  * igt@kms_cursor_crc@cursor-random-32x10:
    - shard-dg2-set2:     NOTRUN -> [SKIP][76] ([Intel XE#1201] / [Intel XE#455])
   [76]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@kms_cursor_crc@cursor-random-32x10.html

  * igt@kms_cursor_crc@cursor-sliding-512x170:
    - shard-dg2-set2:     NOTRUN -> [SKIP][77] ([Intel XE#1201] / [Intel XE#308])
   [77]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@kms_cursor_crc@cursor-sliding-512x170.html

  * igt@kms_cursor_legacy@cursora-vs-flipb-varying-size:
    - shard-lnl:          NOTRUN -> [SKIP][78] ([Intel XE#309])
   [78]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-5/igt@kms_cursor_legacy@cursora-vs-flipb-varying-size.html

  * igt@kms_feature_discovery@chamelium:
    - shard-lnl:          NOTRUN -> [SKIP][79] ([Intel XE#701])
   [79]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-4/igt@kms_feature_discovery@chamelium.html

  * igt@kms_flip@2x-plain-flip-fb-recreate-interruptible:
    - shard-lnl:          NOTRUN -> [SKIP][80] ([Intel XE#1421]) +3 other tests skip
   [80]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-5/igt@kms_flip@2x-plain-flip-fb-recreate-interruptible.html

  * igt@kms_flip@blocking-wf_vblank:
    - shard-lnl:          NOTRUN -> [FAIL][81] ([Intel XE#886]) +1 other test fail
   [81]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-3/igt@kms_flip@blocking-wf_vblank.html

  * igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-64bpp-4tile-downscaling:
    - shard-lnl:          NOTRUN -> [SKIP][82] ([Intel XE#1397] / [Intel XE#1745])
   [82]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-64bpp-4tile-downscaling.html

  * igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-64bpp-4tile-downscaling@pipe-a-default-mode:
    - shard-lnl:          NOTRUN -> [SKIP][83] ([Intel XE#1397])
   [83]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-64bpp-4tile-downscaling@pipe-a-default-mode.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-64bpp-ytile-downscaling:
    - shard-lnl:          NOTRUN -> [SKIP][84] ([Intel XE#1401] / [Intel XE#1745]) +1 other test skip
   [84]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-7/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-64bpp-ytile-downscaling.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-64bpp-ytile-downscaling@pipe-a-default-mode:
    - shard-lnl:          NOTRUN -> [SKIP][85] ([Intel XE#1401]) +1 other test skip
   [85]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-7/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-64bpp-ytile-downscaling@pipe-a-default-mode.html

  * igt@kms_frontbuffer_tracking@drrs-suspend:
    - shard-dg2-set2:     NOTRUN -> [SKIP][86] ([Intel XE#1201] / [Intel XE#651]) +2 other tests skip
   [86]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@kms_frontbuffer_tracking@drrs-suspend.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-cur-indfb-draw-render:
    - shard-lnl:          NOTRUN -> [SKIP][87] ([Intel XE#656]) +21 other tests skip
   [87]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-5/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-cur-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-pri-shrfb-draw-blt:
    - shard-dg2-set2:     NOTRUN -> [SKIP][88] ([Intel XE#651])
   [88]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-pri-shrfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-rgb101010-draw-mmap-wc:
    - shard-lnl:          NOTRUN -> [SKIP][89] ([Intel XE#651]) +10 other tests skip
   [89]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-1/igt@kms_frontbuffer_tracking@fbcdrrs-rgb101010-draw-mmap-wc.html

  * igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-indfb-pgflip-blt:
    - shard-dg2-set2:     NOTRUN -> [SKIP][90] ([Intel XE#1201] / [Intel XE#653])
   [90]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-indfb-pgflip-blt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-spr-indfb-draw-render:
    - shard-dg2-set2:     NOTRUN -> [SKIP][91] ([Intel XE#653])
   [91]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-spr-indfb-draw-render.html

  * igt@kms_getfb@getfb-reject-ccs:
    - shard-lnl:          NOTRUN -> [SKIP][92] ([Intel XE#605])
   [92]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-4/igt@kms_getfb@getfb-reject-ccs.html

  * igt@kms_plane@plane-position-covered:
    - shard-lnl:          [PASS][93] -> [DMESG-FAIL][94] ([Intel XE#324]) +2 other tests dmesg-fail
   [93]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-8/igt@kms_plane@plane-position-covered.html
   [94]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-4/igt@kms_plane@plane-position-covered.html

  * igt@kms_plane@plane-position-covered@pipe-b-plane-4:
    - shard-lnl:          [PASS][95] -> [DMESG-WARN][96] ([Intel XE#324]) +2 other tests dmesg-warn
   [95]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-8/igt@kms_plane@plane-position-covered@pipe-b-plane-4.html
   [96]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-4/igt@kms_plane@plane-position-covered@pipe-b-plane-4.html

  * igt@kms_plane_scaling@intel-max-src-size@pipe-a-hdmi-a-6:
    - shard-dg2-set2:     [PASS][97] -> [FAIL][98] ([Intel XE#361]) +2 other tests fail
   [97]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-435/igt@kms_plane_scaling@intel-max-src-size@pipe-a-hdmi-a-6.html
   [98]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@kms_plane_scaling@intel-max-src-size@pipe-a-hdmi-a-6.html

  * igt@kms_plane_scaling@plane-downscale-factor-0-5-with-rotation@pipe-b-edp-1:
    - shard-lnl:          NOTRUN -> [SKIP][99] ([Intel XE#498]) +3 other tests skip
   [99]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-5/igt@kms_plane_scaling@plane-downscale-factor-0-5-with-rotation@pipe-b-edp-1.html

  * igt@kms_plane_scaling@planes-upscale-20x20-downscale-factor-0-5@pipe-b-edp-1:
    - shard-lnl:          NOTRUN -> [SKIP][100] ([Intel XE#2318]) +3 other tests skip
   [100]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-4/igt@kms_plane_scaling@planes-upscale-20x20-downscale-factor-0-5@pipe-b-edp-1.html

  * igt@kms_pm_dc@dc3co-vpb-simulation:
    - shard-lnl:          NOTRUN -> [SKIP][101] ([Intel XE#736])
   [101]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-3/igt@kms_pm_dc@dc3co-vpb-simulation.html

  * igt@kms_pm_dc@dc5-dpms:
    - shard-lnl:          [PASS][102] -> [FAIL][103] ([Intel XE#718])
   [102]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-4/igt@kms_pm_dc@dc5-dpms.html
   [103]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@kms_pm_dc@dc5-dpms.html

  * igt@kms_pm_rpm@modeset-non-lpsp-stress:
    - shard-lnl:          NOTRUN -> [SKIP][104] ([Intel XE#1439])
   [104]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-6/igt@kms_pm_rpm@modeset-non-lpsp-stress.html

  * igt@kms_psr2_sf@overlay-primary-update-sf-dmg-area:
    - shard-dg2-set2:     NOTRUN -> [SKIP][105] ([Intel XE#1201] / [Intel XE#1489])
   [105]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@kms_psr2_sf@overlay-primary-update-sf-dmg-area.html

  * igt@kms_psr2_su@page_flip-nv12:
    - shard-dg2-set2:     NOTRUN -> [SKIP][106] ([Intel XE#1122] / [Intel XE#1201])
   [106]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-434/igt@kms_psr2_su@page_flip-nv12.html

  * igt@kms_psr2_su@page_flip-xrgb8888:
    - shard-lnl:          NOTRUN -> [SKIP][107] ([Intel XE#1128])
   [107]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-5/igt@kms_psr2_su@page_flip-xrgb8888.html

  * igt@kms_psr@pr-sprite-plane-move:
    - shard-lnl:          NOTRUN -> [SKIP][108] ([Intel XE#1406]) +2 other tests skip
   [108]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-8/igt@kms_psr@pr-sprite-plane-move.html

  * igt@kms_psr@psr-cursor-blt:
    - shard-dg2-set2:     NOTRUN -> [SKIP][109] ([Intel XE#1201] / [Intel XE#929])
   [109]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-436/igt@kms_psr@psr-cursor-blt.html

  * igt@kms_rotation_crc@sprite-rotation-90-pos-100-0:
    - shard-lnl:          NOTRUN -> [SKIP][110] ([Intel XE#1437])
   [110]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-1/igt@kms_rotation_crc@sprite-rotation-90-pos-100-0.html

  * igt@kms_scaling_modes@scaling-mode-none:
    - shard-lnl:          NOTRUN -> [SKIP][111] ([Intel XE#374] / [Intel XE#599])
   [111]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-6/igt@kms_scaling_modes@scaling-mode-none.html

  * igt@kms_scaling_modes@scaling-mode-none@pipe-a-edp-1:
    - shard-lnl:          NOTRUN -> [SKIP][112] ([Intel XE#374]) +2 other tests skip
   [112]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-6/igt@kms_scaling_modes@scaling-mode-none@pipe-a-edp-1.html

  * igt@kms_universal_plane@cursor-fb-leak@pipe-c-hdmi-a-6:
    - shard-dg2-set2:     [PASS][113] -> [FAIL][114] ([Intel XE#899])
   [113]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-433/igt@kms_universal_plane@cursor-fb-leak@pipe-c-hdmi-a-6.html
   [114]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-436/igt@kms_universal_plane@cursor-fb-leak@pipe-c-hdmi-a-6.html

  * igt@kms_vblank@ts-continuation-suspend:
    - shard-dg2-set2:     [PASS][115] -> [DMESG-WARN][116] ([Intel XE#2019]) +3 other tests dmesg-warn
   [115]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-435/igt@kms_vblank@ts-continuation-suspend.html
   [116]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_vblank@ts-continuation-suspend.html

  * igt@kms_vrr@flip-basic:
    - shard-lnl:          NOTRUN -> [FAIL][117] ([Intel XE#2443]) +1 other test fail
   [117]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-4/igt@kms_vrr@flip-basic.html

  * igt@kms_vrr@negative-basic:
    - shard-lnl:          NOTRUN -> [SKIP][118] ([Intel XE#1499] / [Intel XE#599])
   [118]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-6/igt@kms_vrr@negative-basic.html

  * igt@sriov_basic@enable-vfs-autoprobe-off:
    - shard-dg2-set2:     NOTRUN -> [SKIP][119] ([Intel XE#1091] / [Intel XE#1201])
   [119]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@sriov_basic@enable-vfs-autoprobe-off.html

  * igt@xe_evict@evict-beng-mixed-threads-large:
    - shard-dg2-set2:     [PASS][120] -> [TIMEOUT][121] ([Intel XE#1473])
   [120]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@xe_evict@evict-beng-mixed-threads-large.html
   [121]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@xe_evict@evict-beng-mixed-threads-large.html

  * igt@xe_evict@evict-beng-threads-large-multi-vm:
    - shard-lnl:          NOTRUN -> [SKIP][122] ([Intel XE#688]) +4 other tests skip
   [122]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-7/igt@xe_evict@evict-beng-threads-large-multi-vm.html

  * igt@xe_exec_basic@multigpu-many-execqueues-many-vm-bindexecqueue-userptr-rebind:
    - shard-lnl:          NOTRUN -> [SKIP][123] ([Intel XE#1392]) +4 other tests skip
   [123]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@xe_exec_basic@multigpu-many-execqueues-many-vm-bindexecqueue-userptr-rebind.html

  * igt@xe_exec_compute_mode@once-userptr-invalidate:
    - shard-lnl:          [PASS][124] -> [FAIL][125] ([Intel XE#1069])
   [124]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-1/igt@xe_exec_compute_mode@once-userptr-invalidate.html
   [125]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-6/igt@xe_exec_compute_mode@once-userptr-invalidate.html

  * igt@xe_exec_fault_mode@many-execqueues-invalid-userptr-fault:
    - shard-dg2-set2:     NOTRUN -> [SKIP][126] ([Intel XE#1201] / [Intel XE#288]) +1 other test skip
   [126]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@xe_exec_fault_mode@many-execqueues-invalid-userptr-fault.html

  * igt@xe_gt_freq@freq_reset_multiple:
    - shard-lnl:          [PASS][127] -> [DMESG-FAIL][128] ([Intel XE#1620])
   [127]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-1/igt@xe_gt_freq@freq_reset_multiple.html
   [128]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@xe_gt_freq@freq_reset_multiple.html

  * igt@xe_live_ktest@xe_migrate:
    - shard-dg2-set2:     [PASS][129] -> [SKIP][130] ([Intel XE#1192] / [Intel XE#1201])
   [129]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-466/igt@xe_live_ktest@xe_migrate.html
   [130]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@xe_live_ktest@xe_migrate.html

  * igt@xe_live_ktest@xe_migrate@xe_validate_ccs_kunit:
    - shard-lnl:          NOTRUN -> [SKIP][131] ([Intel XE#2229])
   [131]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-5/igt@xe_live_ktest@xe_migrate@xe_validate_ccs_kunit.html

  * igt@xe_live_ktest@xe_mocs@xe_live_mocs_kernel_kunit:
    - shard-dg2-set2:     NOTRUN -> [FAIL][132] ([Intel XE#1999]) +1 other test fail
   [132]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@xe_live_ktest@xe_mocs@xe_live_mocs_kernel_kunit.html

  * igt@xe_oa@closed-fd-and-unmapped-access:
    - shard-dg2-set2:     NOTRUN -> [SKIP][133] ([Intel XE#1201] / [Intel XE#2541]) +1 other test skip
   [133]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-436/igt@xe_oa@closed-fd-and-unmapped-access.html

  * igt@xe_pm@d3hot-mmap-vram:
    - shard-lnl:          NOTRUN -> [SKIP][134] ([Intel XE#1948])
   [134]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-6/igt@xe_pm@d3hot-mmap-vram.html

  * igt@xe_pm@s2idle-multiple-execs:
    - shard-dg2-set2:     [PASS][135] -> [INCOMPLETE][136] ([Intel XE#1195] / [Intel XE#1358])
   [135]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-463/igt@xe_pm@s2idle-multiple-execs.html
   [136]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-434/igt@xe_pm@s2idle-multiple-execs.html

  * igt@xe_pm@s3-d3hot-basic-exec:
    - shard-dg2-set2:     [PASS][137] -> [DMESG-WARN][138] ([Intel XE#1551] / [Intel XE#569])
   [137]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@xe_pm@s3-d3hot-basic-exec.html
   [138]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@xe_pm@s3-d3hot-basic-exec.html

  * igt@xe_pm@s4-mocs:
    - shard-dg2-set2:     [PASS][139] -> [DMESG-WARN][140] ([Intel XE#2280])
   [139]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-434/igt@xe_pm@s4-mocs.html
   [140]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@xe_pm@s4-mocs.html

  * igt@xe_query@multigpu-query-invalid-query:
    - shard-lnl:          NOTRUN -> [SKIP][141] ([Intel XE#944])
   [141]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-4/igt@xe_query@multigpu-query-invalid-query.html

  * igt@xe_wedged@wedged-mode-toggle:
    - shard-lnl:          [PASS][142] -> [ABORT][143] ([Intel XE#2310])
   [142]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-7/igt@xe_wedged@wedged-mode-toggle.html
   [143]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-1/igt@xe_wedged@wedged-mode-toggle.html

  
#### Possible fixes ####

  * igt@kms_atomic_transition@plane-all-modeset-transition@pipe-a-hdmi-a-6:
    - shard-dg2-set2:     [FAIL][144] ([Intel XE#1426]) -> [PASS][145] +1 other test pass
   [144]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-436/igt@kms_atomic_transition@plane-all-modeset-transition@pipe-a-hdmi-a-6.html
   [145]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-435/igt@kms_atomic_transition@plane-all-modeset-transition@pipe-a-hdmi-a-6.html

  * igt@kms_ccs@crc-sprite-planes-basic-4-tiled-bmg-ccs:
    - {shard-bmg}:        [FAIL][146] ([Intel XE#2436]) -> [PASS][147] +1 other test pass
   [146]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-3/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-bmg-ccs.html
   [147]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-3/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-bmg-ccs.html

  * igt@kms_ccs@crc-sprite-planes-basic-4-tiled-bmg-ccs@pipe-c-dp-2:
    - {shard-bmg}:        [FAIL][148] -> [PASS][149]
   [148]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-3/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-bmg-ccs@pipe-c-dp-2.html
   [149]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-3/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-bmg-ccs@pipe-c-dp-2.html

  * igt@kms_cursor_crc@cursor-suspend:
    - shard-dg2-set2:     [DMESG-WARN][150] ([Intel XE#1551]) -> [PASS][151] +1 other test pass
   [150]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-435/igt@kms_cursor_crc@cursor-suspend.html
   [151]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_cursor_crc@cursor-suspend.html

  * igt@kms_flip@2x-flip-vs-panning-interruptible@cd-dp2-hdmi-a3:
    - {shard-bmg}:        [DMESG-WARN][152] ([Intel XE#877]) -> [PASS][153] +4 other tests pass
   [152]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-6/igt@kms_flip@2x-flip-vs-panning-interruptible@cd-dp2-hdmi-a3.html
   [153]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-4/igt@kms_flip@2x-flip-vs-panning-interruptible@cd-dp2-hdmi-a3.html

  * igt@kms_flip@2x-flip-vs-suspend-interruptible@ab-hdmi-a6-dp4:
    - shard-dg2-set2:     [DMESG-WARN][154] ([Intel XE#2019]) -> [PASS][155] +1 other test pass
   [154]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_flip@2x-flip-vs-suspend-interruptible@ab-hdmi-a6-dp4.html
   [155]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_flip@2x-flip-vs-suspend-interruptible@ab-hdmi-a6-dp4.html

  * igt@kms_flip@flip-vs-absolute-wf_vblank:
    - shard-lnl:          [FAIL][156] ([Intel XE#886]) -> [PASS][157] +2 other tests pass
   [156]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-3/igt@kms_flip@flip-vs-absolute-wf_vblank.html
   [157]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-4/igt@kms_flip@flip-vs-absolute-wf_vblank.html

  * igt@kms_flip@flip-vs-absolute-wf_vblank@c-hdmi-a3:
    - {shard-bmg}:        [INCOMPLETE][158] -> [PASS][159] +2 other tests pass
   [158]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-5/igt@kms_flip@flip-vs-absolute-wf_vblank@c-hdmi-a3.html
   [159]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-1/igt@kms_flip@flip-vs-absolute-wf_vblank@c-hdmi-a3.html

  * igt@kms_hdr@invalid-hdr:
    - {shard-bmg}:        [SKIP][160] ([Intel XE#1503]) -> [PASS][161]
   [160]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-1/igt@kms_hdr@invalid-hdr.html
   [161]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-8/igt@kms_hdr@invalid-hdr.html

  * igt@kms_pipe_crc_basic@suspend-read-crc@pipe-c-hdmi-a-6:
    - shard-dg2-set2:     [DMESG-WARN][162] ([Intel XE#1162]) -> [PASS][163]
   [162]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-434/igt@kms_pipe_crc_basic@suspend-read-crc@pipe-c-hdmi-a-6.html
   [163]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_pipe_crc_basic@suspend-read-crc@pipe-c-hdmi-a-6.html

  * igt@kms_plane_cursor@overlay:
    - shard-dg2-set2:     [INCOMPLETE][164] ([Intel XE#1195]) -> [PASS][165] +2 other tests pass
   [164]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-435/igt@kms_plane_cursor@overlay.html
   [165]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-436/igt@kms_plane_cursor@overlay.html

  * igt@kms_psr@fbc-psr-suspend:
    - shard-lnl:          [INCOMPLETE][166] -> [PASS][167]
   [166]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-4/igt@kms_psr@fbc-psr-suspend.html
   [167]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@kms_psr@fbc-psr-suspend.html

  * igt@kms_psr@fbc-psr-suspend@edp-1:
    - shard-lnl:          [INCOMPLETE][168] ([Intel XE#2497]) -> [PASS][169]
   [168]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-4/igt@kms_psr@fbc-psr-suspend@edp-1.html
   [169]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-2/igt@kms_psr@fbc-psr-suspend@edp-1.html

  * igt@kms_universal_plane@cursor-fb-leak:
    - {shard-bmg}:        [FAIL][170] ([Intel XE#899]) -> [PASS][171] +2 other tests pass
   [170]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-5/igt@kms_universal_plane@cursor-fb-leak.html
   [171]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-1/igt@kms_universal_plane@cursor-fb-leak.html

  * igt@kms_vrr@flipline:
    - shard-lnl:          [FAIL][172] ([Intel XE#2443]) -> [PASS][173] +1 other test pass
   [172]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-2/igt@kms_vrr@flipline.html
   [173]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-8/igt@kms_vrr@flipline.html

  * igt@xe_evict@evict-cm-threads-large:
    - shard-dg2-set2:     [TIMEOUT][174] ([Intel XE#1473]) -> [PASS][175] +1 other test pass
   [174]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-466/igt@xe_evict@evict-cm-threads-large.html
   [175]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@xe_evict@evict-cm-threads-large.html

  * igt@xe_evict@evict-threads-large:
    - {shard-bmg}:        [TIMEOUT][176] ([Intel XE#1473] / [Intel XE#2472]) -> [PASS][177]
   [176]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-bmg-6/igt@xe_evict@evict-threads-large.html
   [177]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-bmg-6/igt@xe_evict@evict-threads-large.html

  * igt@xe_pm@s4-basic-exec:
    - shard-lnl:          [ABORT][178] ([Intel XE#1358] / [Intel XE#1607] / [Intel XE#1794]) -> [PASS][179] +1 other test pass
   [178]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-2/igt@xe_pm@s4-basic-exec.html
   [179]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-5/igt@xe_pm@s4-basic-exec.html

  * igt@xe_pm_residency@toggle-gt-c6:
    - shard-lnl:          [FAIL][180] ([Intel XE#958]) -> [PASS][181]
   [180]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-lnl-8/igt@xe_pm_residency@toggle-gt-c6.html
   [181]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-lnl-6/igt@xe_pm_residency@toggle-gt-c6.html

  
#### Warnings ####

  * igt@kms_async_flips@invalid-async-flip:
    - shard-dg2-set2:     [SKIP][182] ([Intel XE#873]) -> [SKIP][183] ([Intel XE#1201] / [Intel XE#873])
   [182]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_async_flips@invalid-async-flip.html
   [183]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_async_flips@invalid-async-flip.html

  * igt@kms_big_fb@4-tiled-16bpp-rotate-270:
    - shard-dg2-set2:     [SKIP][184] ([Intel XE#316]) -> [SKIP][185] ([Intel XE#1201] / [Intel XE#316])
   [184]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_big_fb@4-tiled-16bpp-rotate-270.html
   [185]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-436/igt@kms_big_fb@4-tiled-16bpp-rotate-270.html

  * igt@kms_big_fb@4-tiled-32bpp-rotate-90:
    - shard-dg2-set2:     [SKIP][186] ([Intel XE#1201] / [Intel XE#316]) -> [SKIP][187] ([Intel XE#316]) +1 other test skip
   [186]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-434/igt@kms_big_fb@4-tiled-32bpp-rotate-90.html
   [187]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_big_fb@4-tiled-32bpp-rotate-90.html

  * igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-0-hflip:
    - shard-dg2-set2:     [SKIP][188] ([Intel XE#1124] / [Intel XE#1201]) -> [SKIP][189] ([Intel XE#1124]) +8 other tests skip
   [188]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-434/igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-0-hflip.html
   [189]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-0-hflip.html

  * igt@kms_big_fb@yf-tiled-32bpp-rotate-180:
    - shard-dg2-set2:     [SKIP][190] ([Intel XE#1124]) -> [SKIP][191] ([Intel XE#1124] / [Intel XE#1201]) +7 other tests skip
   [190]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_big_fb@yf-tiled-32bpp-rotate-180.html
   [191]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-436/igt@kms_big_fb@yf-tiled-32bpp-rotate-180.html

  * igt@kms_big_fb@yf-tiled-addfb:
    - shard-dg2-set2:     [SKIP][192] ([Intel XE#1201] / [Intel XE#619]) -> [SKIP][193] ([Intel XE#619])
   [192]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-436/igt@kms_big_fb@yf-tiled-addfb.html
   [193]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_big_fb@yf-tiled-addfb.html

  * igt@kms_big_fb@yf-tiled-addfb-size-offset-overflow:
    - shard-dg2-set2:     [SKIP][194] ([Intel XE#607]) -> [SKIP][195] ([Intel XE#1201] / [Intel XE#607])
   [194]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_big_fb@yf-tiled-addfb-size-offset-overflow.html
   [195]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-434/igt@kms_big_fb@yf-tiled-addfb-size-offset-overflow.html

  * igt@kms_bw@connected-linear-tiling-2-displays-2160x1440p:
    - shard-dg2-set2:     [SKIP][196] ([Intel XE#1201] / [Intel XE#367]) -> [SKIP][197] ([Intel XE#367]) +3 other tests skip
   [196]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-433/igt@kms_bw@connected-linear-tiling-2-displays-2160x1440p.html
   [197]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_bw@connected-linear-tiling-2-displays-2160x1440p.html

  * igt@kms_bw@connected-linear-tiling-2-displays-2560x1440p:
    - shard-dg2-set2:     [SKIP][198] ([Intel XE#367]) -> [SKIP][199] ([Intel XE#1201] / [Intel XE#367])
   [198]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_bw@connected-linear-tiling-2-displays-2560x1440p.html
   [199]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@kms_bw@connected-linear-tiling-2-displays-2560x1440p.html

  * igt@kms_ccs@bad-rotation-90-y-tiled-gen12-mc-ccs@pipe-d-dp-4:
    - shard-dg2-set2:     [SKIP][200] ([Intel XE#455] / [Intel XE#787]) -> [SKIP][201] ([Intel XE#1201] / [Intel XE#455] / [Intel XE#787]) +17 other tests skip
   [200]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_ccs@bad-rotation-90-y-tiled-gen12-mc-ccs@pipe-d-dp-4.html
   [201]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@kms_ccs@bad-rotation-90-y-tiled-gen12-mc-ccs@pipe-d-dp-4.html

  * igt@kms_ccs@crc-primary-basic-y-tiled-gen12-rc-ccs-cc@pipe-a-dp-4:
    - shard-dg2-set2:     [SKIP][202] ([Intel XE#787]) -> [SKIP][203] ([Intel XE#1201] / [Intel XE#787]) +62 other tests skip
   [202]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_ccs@crc-primary-basic-y-tiled-gen12-rc-ccs-cc@pipe-a-dp-4.html
   [203]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@kms_ccs@crc-primary-basic-y-tiled-gen12-rc-ccs-cc@pipe-a-dp-4.html

  * igt@kms_ccs@crc-primary-rotation-180-4-tiled-mtl-rc-ccs-cc@pipe-d-dp-4:
    - shard-dg2-set2:     [SKIP][204] ([Intel XE#1201] / [Intel XE#455] / [Intel XE#787]) -> [SKIP][205] ([Intel XE#455] / [Intel XE#787]) +19 other tests skip
   [204]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-463/igt@kms_ccs@crc-primary-rotation-180-4-tiled-mtl-rc-ccs-cc@pipe-d-dp-4.html
   [205]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_ccs@crc-primary-rotation-180-4-tiled-mtl-rc-ccs-cc@pipe-d-dp-4.html

  * igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs-cc@pipe-c-hdmi-a-6:
    - shard-dg2-set2:     [SKIP][206] ([Intel XE#1201] / [Intel XE#787]) -> [SKIP][207] ([Intel XE#787]) +69 other tests skip
   [206]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-466/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs-cc@pipe-c-hdmi-a-6.html
   [207]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs-cc@pipe-c-hdmi-a-6.html

  * igt@kms_chamelium_color@ctm-red-to-blue:
    - shard-dg2-set2:     [SKIP][208] ([Intel XE#1201] / [Intel XE#306]) -> [SKIP][209] ([Intel XE#306]) +1 other test skip
   [208]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-463/igt@kms_chamelium_color@ctm-red-to-blue.html
   [209]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_chamelium_color@ctm-red-to-blue.html

  * igt@kms_chamelium_edid@dp-edid-change-during-suspend:
    - shard-dg2-set2:     [SKIP][210] ([Intel XE#373]) -> [SKIP][211] ([Intel XE#1201] / [Intel XE#373]) +8 other tests skip
   [210]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_chamelium_edid@dp-edid-change-during-suspend.html
   [211]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@kms_chamelium_edid@dp-edid-change-during-suspend.html

  * igt@kms_chamelium_hpd@hdmi-hpd-with-enabled-mode:
    - shard-dg2-set2:     [SKIP][212] ([Intel XE#1201] / [Intel XE#373]) -> [SKIP][213] ([Intel XE#373]) +9 other tests skip
   [212]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-434/igt@kms_chamelium_hpd@hdmi-hpd-with-enabled-mode.html
   [213]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_chamelium_hpd@hdmi-hpd-with-enabled-mode.html

  * igt@kms_content_protection@dp-mst-type-0:
    - shard-dg2-set2:     [SKIP][214] ([Intel XE#1201] / [Intel XE#307]) -> [SKIP][215] ([Intel XE#307])
   [214]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-435/igt@kms_content_protection@dp-mst-type-0.html
   [215]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_content_protection@dp-mst-type-0.html

  * igt@kms_cursor_crc@cursor-rapid-movement-512x170:
    - shard-dg2-set2:     [SKIP][216] ([Intel XE#1201] / [Intel XE#308]) -> [SKIP][217] ([Intel XE#308]) +2 other tests skip
   [216]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-466/igt@kms_cursor_crc@cursor-rapid-movement-512x170.html
   [217]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_cursor_crc@cursor-rapid-movement-512x170.html

  * igt@kms_feature_discovery@chamelium:
    - shard-dg2-set2:     [SKIP][218] ([Intel XE#1201] / [Intel XE#701]) -> [SKIP][219] ([Intel XE#701])
   [218]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-466/igt@kms_feature_discovery@chamelium.html
   [219]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_feature_discovery@chamelium.html

  * igt@kms_feature_discovery@display-3x:
    - shard-dg2-set2:     [SKIP][220] ([Intel XE#703]) -> [SKIP][221] ([Intel XE#1201] / [Intel XE#703])
   [220]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_feature_discovery@display-3x.html
   [221]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_feature_discovery@display-3x.html

  * igt@kms_feature_discovery@psr1:
    - shard-dg2-set2:     [SKIP][222] ([Intel XE#1135] / [Intel XE#1201]) -> [SKIP][223] ([Intel XE#1135])
   [222]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-466/igt@kms_feature_discovery@psr1.html
   [223]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_feature_discovery@psr1.html

  * igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-64bpp-yftile-downscaling:
    - shard-dg2-set2:     [SKIP][224] ([Intel XE#455]) -> [SKIP][225] ([Intel XE#1201] / [Intel XE#455]) +6 other tests skip
   [224]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-64bpp-yftile-downscaling.html
   [225]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-64bpp-yftile-downscaling.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-downscaling:
    - shard-dg2-set2:     [SKIP][226] ([Intel XE#1201] / [Intel XE#455]) -> [SKIP][227] ([Intel XE#455]) +14 other tests skip
   [226]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-433/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-downscaling.html
   [227]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-downscaling.html

  * igt@kms_frontbuffer_tracking@drrs-2p-primscrn-cur-indfb-onoff:
    - shard-dg2-set2:     [SKIP][228] ([Intel XE#651]) -> [SKIP][229] ([Intel XE#1201] / [Intel XE#651]) +17 other tests skip
   [228]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_frontbuffer_tracking@drrs-2p-primscrn-cur-indfb-onoff.html
   [229]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_frontbuffer_tracking@drrs-2p-primscrn-cur-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-indfb-plflip-blt:
    - shard-dg2-set2:     [SKIP][230] ([Intel XE#1201] / [Intel XE#651]) -> [SKIP][231] ([Intel XE#651]) +24 other tests skip
   [230]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-435/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-indfb-plflip-blt.html
   [231]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_frontbuffer_tracking@fbcdrrs-2p-scndscrn-indfb-plflip-blt.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-tiling-y:
    - shard-dg2-set2:     [SKIP][232] ([Intel XE#658]) -> [SKIP][233] ([Intel XE#1201] / [Intel XE#658])
   [232]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_frontbuffer_tracking@fbcdrrs-tiling-y.html
   [233]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_frontbuffer_tracking@fbcdrrs-tiling-y.html

  * igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-spr-indfb-draw-blt:
    - shard-dg2-set2:     [SKIP][234] ([Intel XE#1201] / [Intel XE#653]) -> [SKIP][235] ([Intel XE#653]) +24 other tests skip
   [234]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-433/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-spr-indfb-draw-blt.html
   [235]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-spr-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@psr-1p-primscrn-pri-shrfb-draw-mmap-wc:
    - shard-dg2-set2:     [SKIP][236] ([Intel XE#653]) -> [SKIP][237] ([Intel XE#1201] / [Intel XE#653]) +16 other tests skip
   [236]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_frontbuffer_tracking@psr-1p-primscrn-pri-shrfb-draw-mmap-wc.html
   [237]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@kms_frontbuffer_tracking@psr-1p-primscrn-pri-shrfb-draw-mmap-wc.html

  * igt@kms_getfb@getfb-reject-ccs:
    - shard-dg2-set2:     [SKIP][238] ([Intel XE#1201] / [Intel XE#605]) -> [SKIP][239] ([Intel XE#605])
   [238]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-466/igt@kms_getfb@getfb-reject-ccs.html
   [239]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_getfb@getfb-reject-ccs.html

  * igt@kms_multipipe_modeset@basic-max-pipe-crc-check:
    - shard-dg2-set2:     [SKIP][240] ([Intel XE#1201] / [Intel XE#356]) -> [SKIP][241] ([Intel XE#356])
   [240]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-435/igt@kms_multipipe_modeset@basic-max-pipe-crc-check.html
   [241]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_multipipe_modeset@basic-max-pipe-crc-check.html

  * igt@kms_plane_scaling@plane-downscale-factor-0-25-with-pixel-format:
    - shard-dg2-set2:     [SKIP][242] ([Intel XE#455] / [Intel XE#498]) -> [SKIP][243] ([Intel XE#1201] / [Intel XE#455] / [Intel XE#498]) +1 other test skip
   [242]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_plane_scaling@plane-downscale-factor-0-25-with-pixel-format.html
   [243]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@kms_plane_scaling@plane-downscale-factor-0-25-with-pixel-format.html

  * igt@kms_plane_scaling@plane-downscale-factor-0-25-with-pixel-format@pipe-c-hdmi-a-6:
    - shard-dg2-set2:     [SKIP][244] ([Intel XE#498]) -> [SKIP][245] ([Intel XE#1201] / [Intel XE#498]) +2 other tests skip
   [244]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_plane_scaling@plane-downscale-factor-0-25-with-pixel-format@pipe-c-hdmi-a-6.html
   [245]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@kms_plane_scaling@plane-downscale-factor-0-25-with-pixel-format@pipe-c-hdmi-a-6.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-20x20@pipe-a-hdmi-a-6:
    - shard-dg2-set2:     [SKIP][246] ([Intel XE#1201] / [Intel XE#2318]) -> [SKIP][247] ([Intel XE#2318]) +2 other tests skip
   [246]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-466/igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-20x20@pipe-a-hdmi-a-6.html
   [247]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-20x20@pipe-a-hdmi-a-6.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-20x20@pipe-d-hdmi-a-6:
    - shard-dg2-set2:     [SKIP][248] ([Intel XE#1201] / [Intel XE#2318] / [Intel XE#455]) -> [SKIP][249] ([Intel XE#2318] / [Intel XE#455]) +1 other test skip
   [248]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-466/igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-20x20@pipe-d-hdmi-a-6.html
   [249]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-20x20@pipe-d-hdmi-a-6.html

  * igt@kms_plane_scaling@planes-unity-scaling-downscale-factor-0-25@pipe-a-hdmi-a-6:
    - shard-dg2-set2:     [SKIP][250] ([Intel XE#2318]) -> [SKIP][251] ([Intel XE#1201] / [Intel XE#2318]) +2 other tests skip
   [250]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_plane_scaling@planes-unity-scaling-downscale-factor-0-25@pipe-a-hdmi-a-6.html
   [251]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_plane_scaling@planes-unity-scaling-downscale-factor-0-25@pipe-a-hdmi-a-6.html

  * igt@kms_plane_scaling@planes-unity-scaling-downscale-factor-0-25@pipe-d-hdmi-a-6:
    - shard-dg2-set2:     [SKIP][252] ([Intel XE#2318] / [Intel XE#455]) -> [SKIP][253] ([Intel XE#1201] / [Intel XE#2318] / [Intel XE#455]) +1 other test skip
   [252]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_plane_scaling@planes-unity-scaling-downscale-factor-0-25@pipe-d-hdmi-a-6.html
   [253]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_plane_scaling@planes-unity-scaling-downscale-factor-0-25@pipe-d-hdmi-a-6.html

  * igt@kms_pm_backlight@bad-brightness:
    - shard-dg2-set2:     [SKIP][254] ([Intel XE#870]) -> [SKIP][255] ([Intel XE#1201] / [Intel XE#870])
   [254]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_pm_backlight@bad-brightness.html
   [255]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@kms_pm_backlight@bad-brightness.html

  * igt@kms_pm_backlight@basic-brightness:
    - shard-dg2-set2:     [SKIP][256] ([Intel XE#1201] / [Intel XE#870]) -> [SKIP][257] ([Intel XE#870])
   [256]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-436/igt@kms_pm_backlight@basic-brightness.html
   [257]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_pm_backlight@basic-brightness.html

  * igt@kms_pm_dc@dc5-psr:
    - shard-dg2-set2:     [SKIP][258] ([Intel XE#1129]) -> [SKIP][259] ([Intel XE#1129] / [Intel XE#1201]) +1 other test skip
   [258]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_pm_dc@dc5-psr.html
   [259]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@kms_pm_dc@dc5-psr.html

  * igt@kms_pm_dc@dc6-dpms:
    - shard-dg2-set2:     [SKIP][260] ([Intel XE#1201] / [Intel XE#908]) -> [SKIP][261] ([Intel XE#908]) +1 other test skip
   [260]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-433/igt@kms_pm_dc@dc6-dpms.html
   [261]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_pm_dc@dc6-dpms.html

  * igt@kms_psr2_sf@plane-move-sf-dmg-area:
    - shard-dg2-set2:     [SKIP][262] ([Intel XE#1201] / [Intel XE#1489]) -> [SKIP][263] ([Intel XE#1489]) +3 other tests skip
   [262]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-433/igt@kms_psr2_sf@plane-move-sf-dmg-area.html
   [263]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_psr2_sf@plane-move-sf-dmg-area.html

  * igt@kms_psr2_sf@primary-plane-update-sf-dmg-area-big-fb:
    - shard-dg2-set2:     [SKIP][264] ([Intel XE#1489]) -> [SKIP][265] ([Intel XE#1201] / [Intel XE#1489]) +3 other tests skip
   [264]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_psr2_sf@primary-plane-update-sf-dmg-area-big-fb.html
   [265]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@kms_psr2_sf@primary-plane-update-sf-dmg-area-big-fb.html

  * igt@kms_psr@fbc-psr2-cursor-plane-onoff:
    - shard-dg2-set2:     [SKIP][266] ([Intel XE#1201] / [Intel XE#929]) -> [SKIP][267] ([Intel XE#929]) +10 other tests skip
   [266]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-466/igt@kms_psr@fbc-psr2-cursor-plane-onoff.html
   [267]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_psr@fbc-psr2-cursor-plane-onoff.html

  * igt@kms_psr@fbc-psr2-sprite-plane-move:
    - shard-dg2-set2:     [SKIP][268] ([Intel XE#929]) -> [SKIP][269] ([Intel XE#1201] / [Intel XE#929]) +6 other tests skip
   [268]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_psr@fbc-psr2-sprite-plane-move.html
   [269]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@kms_psr@fbc-psr2-sprite-plane-move.html

  * igt@kms_rotation_crc@primary-rotation-270:
    - shard-dg2-set2:     [SKIP][270] ([Intel XE#1201] / [Intel XE#327]) -> [SKIP][271] ([Intel XE#327]) +1 other test skip
   [270]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-435/igt@kms_rotation_crc@primary-rotation-270.html
   [271]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@kms_rotation_crc@primary-rotation-270.html

  * igt@kms_rotation_crc@primary-y-tiled-reflect-x-90:
    - shard-dg2-set2:     [SKIP][272] ([Intel XE#327]) -> [SKIP][273] ([Intel XE#1201] / [Intel XE#327])
   [272]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@kms_rotation_crc@primary-y-tiled-reflect-x-90.html
   [273]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_rotation_crc@primary-y-tiled-reflect-x-90.html

  * igt@kms_tiled_display@basic-test-pattern-with-chamelium:
    - shard-dg2-set2:     [SKIP][274] ([Intel XE#1201] / [Intel XE#1500]) -> [SKIP][275] ([Intel XE#1201] / [Intel XE#362])
   [274]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-436/igt@kms_tiled_display@basic-test-pattern-with-chamelium.html
   [275]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@kms_tiled_display@basic-test-pattern-with-chamelium.html

  * igt@xe_compute_preempt@compute-preempt:
    - shard-dg2-set2:     [SKIP][276] ([Intel XE#1280] / [Intel XE#455]) -> [SKIP][277] ([Intel XE#1201] / [Intel XE#1280] / [Intel XE#455]) +1 other test skip
   [276]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@xe_compute_preempt@compute-preempt.html
   [277]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@xe_compute_preempt@compute-preempt.html

  * igt@xe_copy_basic@mem-set-linear-0xfffe:
    - shard-dg2-set2:     [SKIP][278] ([Intel XE#1126] / [Intel XE#1201]) -> [SKIP][279] ([Intel XE#1126]) +1 other test skip
   [278]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-434/igt@xe_copy_basic@mem-set-linear-0xfffe.html
   [279]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@xe_copy_basic@mem-set-linear-0xfffe.html

  * igt@xe_create@multigpu-create-massive-size:
    - shard-dg2-set2:     [SKIP][280] ([Intel XE#1201] / [Intel XE#944]) -> [SKIP][281] ([Intel XE#944]) +1 other test skip
   [280]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-463/igt@xe_create@multigpu-create-massive-size.html
   [281]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@xe_create@multigpu-create-massive-size.html

  * igt@xe_evict@evict-mixed-many-threads-large:
    - shard-dg2-set2:     [TIMEOUT][282] ([Intel XE#1041] / [Intel XE#1473]) -> [INCOMPLETE][283] ([Intel XE#1195] / [Intel XE#1473])
   [282]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-433/igt@xe_evict@evict-mixed-many-threads-large.html
   [283]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@xe_evict@evict-mixed-many-threads-large.html

  * igt@xe_evict@evict-threads-large:
    - shard-dg2-set2:     [TIMEOUT][284] ([Intel XE#1473]) -> [INCOMPLETE][285] ([Intel XE#1195] / [Intel XE#1473])
   [284]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@xe_evict@evict-threads-large.html
   [285]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@xe_evict@evict-threads-large.html

  * igt@xe_exec_fault_mode@once-invalid-userptr-fault:
    - shard-dg2-set2:     [SKIP][286] ([Intel XE#288]) -> [SKIP][287] ([Intel XE#1201] / [Intel XE#288]) +15 other tests skip
   [286]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@xe_exec_fault_mode@once-invalid-userptr-fault.html
   [287]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-463/igt@xe_exec_fault_mode@once-invalid-userptr-fault.html

  * igt@xe_exec_fault_mode@once-rebind-prefetch:
    - shard-dg2-set2:     [SKIP][288] ([Intel XE#1201] / [Intel XE#288]) -> [SKIP][289] ([Intel XE#288]) +22 other tests skip
   [288]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-434/igt@xe_exec_fault_mode@once-rebind-prefetch.html
   [289]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@xe_exec_fault_mode@once-rebind-prefetch.html

  * igt@xe_exec_mix_modes@exec-simple-batch-store-dma-fence:
    - shard-dg2-set2:     [SKIP][290] ([Intel XE#1201] / [Intel XE#2360]) -> [SKIP][291] ([Intel XE#2360])
   [290]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-435/igt@xe_exec_mix_modes@exec-simple-batch-store-dma-fence.html
   [291]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@xe_exec_mix_modes@exec-simple-batch-store-dma-fence.html

  * igt@xe_huc_copy@huc_copy:
    - shard-dg2-set2:     [SKIP][292] ([Intel XE#1201] / [Intel XE#255]) -> [SKIP][293] ([Intel XE#255])
   [292]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-436/igt@xe_huc_copy@huc_copy.html
   [293]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@xe_huc_copy@huc_copy.html

  * igt@xe_live_ktest@xe_bo:
    - shard-dg2-set2:     [SKIP][294] ([Intel XE#1192]) -> [SKIP][295] ([Intel XE#1192] / [Intel XE#1201])
   [294]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@xe_live_ktest@xe_bo.html
   [295]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@xe_live_ktest@xe_bo.html

  * igt@xe_live_ktest@xe_mocs:
    - shard-dg2-set2:     [SKIP][296] ([Intel XE#1192] / [Intel XE#1201]) -> [FAIL][297] ([Intel XE#1999])
   [296]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-434/igt@xe_live_ktest@xe_mocs.html
   [297]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-433/igt@xe_live_ktest@xe_mocs.html

  * igt@xe_oa@polling-small-buf:
    - shard-dg2-set2:     [SKIP][298] ([Intel XE#2541]) -> [SKIP][299] ([Intel XE#1201] / [Intel XE#2541]) +3 other tests skip
   [298]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@xe_oa@polling-small-buf.html
   [299]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-466/igt@xe_oa@polling-small-buf.html

  * igt@xe_oa@whitelisted-registers-userspace-config:
    - shard-dg2-set2:     [SKIP][300] ([Intel XE#1201] / [Intel XE#2541]) -> [SKIP][301] ([Intel XE#2541]) +7 other tests skip
   [300]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-434/igt@xe_oa@whitelisted-registers-userspace-config.html
   [301]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@xe_oa@whitelisted-registers-userspace-config.html

  * igt@xe_pat@pat-index-xe2:
    - shard-dg2-set2:     [SKIP][302] ([Intel XE#977]) -> [SKIP][303] ([Intel XE#1201] / [Intel XE#977])
   [302]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@xe_pat@pat-index-xe2.html
   [303]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-436/igt@xe_pat@pat-index-xe2.html

  * igt@xe_pat@pat-index-xelpg:
    - shard-dg2-set2:     [SKIP][304] ([Intel XE#979]) -> [SKIP][305] ([Intel XE#1201] / [Intel XE#979])
   [304]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@xe_pat@pat-index-xelpg.html
   [305]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-434/igt@xe_pat@pat-index-xelpg.html

  * igt@xe_pm@s3-d3cold-basic-exec:
    - shard-dg2-set2:     [SKIP][306] ([Intel XE#1201] / [Intel XE#2284] / [Intel XE#366]) -> [SKIP][307] ([Intel XE#2284] / [Intel XE#366])
   [306]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-436/igt@xe_pm@s3-d3cold-basic-exec.html
   [307]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-432/igt@xe_pm@s3-d3cold-basic-exec.html

  * igt@xe_query@multigpu-query-uc-fw-version-guc:
    - shard-dg2-set2:     [SKIP][308] ([Intel XE#944]) -> [SKIP][309] ([Intel XE#1201] / [Intel XE#944]) +1 other test skip
   [308]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-432/igt@xe_query@multigpu-query-uc-fw-version-guc.html
   [309]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-435/igt@xe_query@multigpu-query-uc-fw-version-guc.html

  * igt@xe_wedged@wedged-at-any-timeout:
    - shard-dg2-set2:     [DMESG-WARN][310] ([Intel XE#1760]) -> [DMESG-FAIL][311] ([Intel XE#1760])
   [310]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7990/shard-dg2-433/igt@xe_wedged@wedged-at-any-timeout.html
   [311]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/shard-dg2-435/igt@xe_wedged@wedged-at-any-timeout.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [Intel XE#1041]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1041
  [Intel XE#1069]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1069
  [Intel XE#1091]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1091
  [Intel XE#1122]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1122
  [Intel XE#1124]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1124
  [Intel XE#1126]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1126
  [Intel XE#1128]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1128
  [Intel XE#1129]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1129
  [Intel XE#1130]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1130
  [Intel XE#1135]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1135
  [Intel XE#1162]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1162
  [Intel XE#1188]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1188
  [Intel XE#1192]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1192
  [Intel XE#1195]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1195
  [Intel XE#1201]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1201
  [Intel XE#1280]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1280
  [Intel XE#1358]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1358
  [Intel XE#1392]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1392
  [Intel XE#1397]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1397
  [Intel XE#1399]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1399
  [Intel XE#1401]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1401
  [Intel XE#1406]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1406
  [Intel XE#1407]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1407
  [Intel XE#1420]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1420
  [Intel XE#1421]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1421
  [Intel XE#1424]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1424
  [Intel XE#1426]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1426
  [Intel XE#1437]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1437
  [Intel XE#1439]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1439
  [Intel XE#1466]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1466
  [Intel XE#1473]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1473
  [Intel XE#1489]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1489
  [Intel XE#1499]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1499
  [Intel XE#1500]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1500
  [Intel XE#1503]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1503
  [Intel XE#1551]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1551
  [Intel XE#1607]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1607
  [Intel XE#1616]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1616
  [Intel XE#1620]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1620
  [Intel XE#1656]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1656
  [Intel XE#1659]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1659
  [Intel XE#1695]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1695
  [Intel XE#1745]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1745
  [Intel XE#1760]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1760
  [Intel XE#1794]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1794
  [Intel XE#1948]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1948
  [Intel XE#1999]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1999
  [Intel XE#2019]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2019
  [Intel XE#2229]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2229
  [Intel XE#2234]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2234
  [Intel XE#2251]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2251
  [Intel XE#2252]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2252
  [Intel XE#2280]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2280
  [Intel XE#2284]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2284
  [Intel XE#2293]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2293
  [Intel XE#2310]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2310
  [Intel XE#2311]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2311
  [Intel XE#2313]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2313
  [Intel XE#2318]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2318
  [Intel XE#2320]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2320
  [Intel XE#2322]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2322
  [Intel XE#2327]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2327
  [Intel XE#2329]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2329
  [Intel XE#2333]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2333
  [Intel XE#2341]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2341
  [Intel XE#2357]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2357
  [Intel XE#2360]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2360
  [Intel XE#2380]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2380
  [Intel XE#2436]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2436
  [Intel XE#2443]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2443
  [Intel XE#2446]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2446
  [Intel XE#2472]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2472
  [Intel XE#2497]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2497
  [Intel XE#2514]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2514
  [Intel XE#2541]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2541
  [Intel XE#255]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/255
  [Intel XE#2567]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2567
  [Intel XE#288]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/288
  [Intel XE#306]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/306
  [Intel XE#307]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/307
  [Intel XE#308]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/308
  [Intel XE#309]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/309
  [Intel XE#314]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/314
  [Intel XE#316]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/316
  [Intel XE#324]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/324
  [Intel XE#327]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/327
  [Intel XE#346]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/346
  [Intel XE#356]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/356
  [Intel XE#361]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/361
  [Intel XE#362]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/362
  [Intel XE#366]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/366
  [Intel XE#367]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/367
  [Intel XE#373]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/373
  [Intel XE#374]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/374
  [Intel XE#455]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/455
  [Intel XE#498]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/498
  [Intel XE#569]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/569
  [Intel XE#599]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/599
  [Intel XE#605]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/605
  [Intel XE#607]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/607
  [Intel XE#619]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/619
  [Intel XE#651]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/651
  [Intel XE#653]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/653
  [Intel XE#656]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/656
  [Intel XE#658]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/658
  [Intel XE#688]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/688
  [Intel XE#701]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/701
  [Intel XE#703]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/703
  [Intel XE#718]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/718
  [Intel XE#736]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/736
  [Intel XE#787]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/787
  [Intel XE#870]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/870
  [Intel XE#873]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/873
  [Intel XE#877]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/877
  [Intel XE#886]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/886
  [Intel XE#899]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/899
  [Intel XE#908]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/908
  [Intel XE#929]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/929
  [Intel XE#944]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/944
  [Intel XE#958]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/958
  [Intel XE#977]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/977
  [Intel XE#979]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/979


Build changes
-------------

  * IGT: IGT_7990 -> IGTPW_11632
  * Linux: xe-1822-411a047925bb7e169a075a2ddfb63ba96f26a8c8 -> xe-1823-5626fe5d6eeb0949727861375b27d67ee71feaa7

  IGTPW_11632: 11632
  IGT_7990: 9ca5ff0afa3636478b6ba5a97e5ba440cfb2e55e @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  xe-1822-411a047925bb7e169a075a2ddfb63ba96f26a8c8: 411a047925bb7e169a075a2ddfb63ba96f26a8c8
  xe-1823-5626fe5d6eeb0949727861375b27d67ee71feaa7: 5626fe5d6eeb0949727861375b27d67ee71feaa7

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11632/index.html

[-- Attachment #2: Type: text/html, Size: 97928 bytes --]

[PATCH i-g-t 13/14] tests/intel/kms_dp_fallback: add test for validating fallback

[Kunal Joshi]

add test to valdiate fallback for DP connector,
eDP subtest will be added later.

How does test validates fallback?
- test start by doing initial modeset on default mode
   (if connector is DP then we enable just that connector,
    if its DP-MST we enable all on the same topology)
- force link training failures and retrain until we reach
  lowest param or retrain is disabled
- expect hotplug and link-status to turn bad
- expect link params reduce after fallback

v2: add test for mst (imre)
    refresh mode list (imre)
    monitor got hotplugs (imre)
    check link parameter are reduced (imre)

v3: call check_fn (Santosh)

v4: handle buggy lg monitor (Imre)
    remove reset in between (Imre)

v5: fit modes wrt to bw in non-mst case as well

Cc: Imre Deak <imre.deak@intel.com>
Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
Suggested-by: Imre Deak <imre.deak@intel.com>
---
 tests/intel/kms_fallback.c | 515 +++++++++++++++++++++++++++++++++++++
 tests/meson.build          |   1 +
 2 files changed, 516 insertions(+)
 create mode 100644 tests/intel/kms_fallback.c

diff --git a/tests/intel/kms_fallback.c b/tests/intel/kms_fallback.c
new file mode 100644
index 000000000..e97300c08
--- /dev/null
+++ b/tests/intel/kms_fallback.c
@@ -0,0 +1,515 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2024 Intel Corporation
+ */
+
+/**
+ * TEST: kms fallback
+ * Category: Display
+ * Description: Test link training fallback for eDP/DP connectors
+ * Driver requirement: i915, xe
+ * Functionality: link training
+ * Mega feature: General Display Features
+ * Test category: functionality test
+ */
+
+#include <sys/types.h>
+
+#include "igt.h"
+#include "igt_psr.h"
+
+/**
+ * SUBTEST: dp-fallback
+ * Description: Test fallback on DP connectors
+ */
+
+#define RETRAIN_COUNT 1
+#define LT_FAILURE_SAME_CAPS 1
+#define LT_FAILURE_REDUCED_CAPS 2
+#define SPURIOUS_HPD_RETRY 3
+
+static int traversed_mst_outputs[IGT_MAX_PIPES];
+static int traversed_mst_output_count;
+typedef struct {
+	int drm_fd;
+	igt_display_t display;
+	drmModeModeInfo *mode;
+	igt_output_t *output;
+	enum pipe pipe;
+	struct igt_fb fb;
+	struct igt_plane *primary;
+	int n_pipes;
+} data_t;
+
+typedef int (*condition_check_fn)(int drm_fd, igt_output_t *output);
+
+IGT_TEST_DESCRIPTION("Test link training fallback");
+
+static const char *str_link_rate(enum dp_link_rate link_rate)
+{
+	switch (link_rate) {
+	case DP_LINK_RATE_162000:
+		return "1.62 Gbps";
+	case DP_LINK_RATE_216000:
+		return "2.16 Gbps";
+	case DP_LINK_RATE_243000:
+		return "2.43 Gbps";
+	case DP_LINK_RATE_270000:
+		return "2.70 Gbps";
+	case DP_LINK_RATE_324000:
+		return "3.24 Gbps";
+	case DP_LINK_RATE_432000:
+		return "4.32 Gbps";
+	case DP_LINK_RATE_540000:
+		return "5.40 Gbps";
+	case DP_LINK_RATE_675000:
+		return "6.75 Gbps";
+	case DP_LINK_RATE_810000:
+		return "8.10 Gbps";
+	case DP_LINK_RATE_1000000:
+		return "10.00 Gbps";
+	case DP_LINK_RATE_1350000:
+		return "13.50 Gbps";
+	case DP_LINK_RATE_2000000:
+		return "20.00 Gbps";
+	default:
+		igt_assert_f(0, "Invalid link rate %d\n", link_rate);
+	}
+}
+
+static const char *str_lane_count(enum dp_lane_count lane_count)
+{
+	switch (lane_count) {
+	case DP_LANE_COUNT_1:
+		return "1";
+	case DP_LANE_COUNT_2:
+		return "2";
+	case DP_LANE_COUNT_4:
+		return "4";
+	default:
+		igt_assert_f(0, "Invalid lane count %d\n", lane_count);
+	}
+}
+
+static void find_mst_outputs(int drm_fd, data_t *data,
+			     igt_output_t *output,
+			     igt_output_t **mst_outputs,
+			     int *num_mst_outputs)
+{
+	bool is_output_mst;
+	uint64_t path_blob_id;
+	igt_output_t *connector_output;
+	drmModePropertyPtr path_prop = NULL;
+	drmModePropertyPtr connector_path_prop = NULL;
+
+	igt_assert_f(output, "Invalid output\n");
+
+	/*
+	 * Check if given output is MST by checking if it has PATH property
+	 */
+	is_output_mst = kmstest_get_property(drm_fd,
+			output->config.connector->connector_id,
+			DRM_MODE_OBJECT_CONNECTOR, "PATH", NULL,
+			&path_blob_id, &path_prop);
+
+	if (!is_output_mst)
+		return;
+
+	/*
+	 * If output is MST check all other connected output which shares
+	 * same path and fill mst_outputs and num_mst_outputs
+	 */
+	for_each_connected_output(&data->display, connector_output) {
+
+		connector_path_prop = NULL;
+
+		kmstest_get_property(drm_fd,
+				     connector_output->config.connector->connector_id,
+				     DRM_MODE_OBJECT_CONNECTOR, "PATH",
+				     NULL, &path_blob_id,
+				     &connector_path_prop);
+
+		if (connector_path_prop && path_prop &&
+		    connector_path_prop->prop_id == path_prop->prop_id)
+			mst_outputs[(*num_mst_outputs)++] = connector_output;
+
+		if (connector_path_prop)
+			drmModeFreeProperty(connector_path_prop);
+	}
+	if (path_prop)
+		drmModeFreeProperty(path_prop);
+}
+
+static bool setup_mst_outputs(data_t *data, igt_output_t *mst_output[],
+			      int *dp_mst_outputs)
+{
+	int i;
+	igt_output_t *output;
+
+	igt_require_f(igt_check_output_is_dp_mst(data->output),
+		      "Not a valid MST connector\n");
+
+	/*
+	 * Check if this is already traversed
+	 */
+	for (i = 0; i < traversed_mst_output_count; i++)
+		if (traversed_mst_outputs[i] == data->output->config.connector->connector_id)
+			return false;
+
+	find_mst_outputs(data->drm_fd, data, data->output,
+			 mst_output, dp_mst_outputs);
+
+	for (i = 0; i < *dp_mst_outputs; i++) {
+		output = mst_output[i];
+		traversed_mst_outputs[traversed_mst_output_count++] = output->config.connector->connector_id;
+		igt_info("Output %s is in same topology as %s\n",
+			 igt_output_name(output),
+			 igt_output_name(data->output));
+	}
+
+	return true;
+}
+
+static void setup_pipe_on_mst_outputs(data_t *data,
+				      igt_output_t *mst_output[],
+				      int *dp_mst_outputs)
+{
+	int i = 0;
+
+	igt_require_f(data->n_pipes >= *dp_mst_outputs,
+		      "Need %d pipes to assign to %d MST outputs\n",
+		      data->n_pipes, *dp_mst_outputs);
+
+	for_each_pipe(&data->display, data->pipe) {
+		if (i >= *dp_mst_outputs)
+			break;
+		igt_info("Setting pipe %s on output %s\n",
+			 kmstest_pipe_name(data->pipe),
+			 igt_output_name(mst_output[i]));
+		igt_output_set_pipe(mst_output[i++], data->pipe);
+	}
+}
+
+static void setup_modeset_on_mst_outputs(data_t *data,
+					 igt_output_t *mst_output[],
+					 int *dp_mst_outputs,
+					 drmModeModeInfo *mode[],
+					 struct igt_fb fb[],
+					 struct igt_plane *primary[])
+{
+	int i;
+
+	for (i = 0; i < *dp_mst_outputs; i++) {
+		mst_output[i]->force_reprobe = true;
+		igt_output_refresh(mst_output[i]);
+		mode[i] = igt_output_get_mode(mst_output[i]);
+		igt_info("Mode %dx%d@%d on output %s\n",
+			 mode[i]->hdisplay, mode[i]->vdisplay,
+			 mode[i]->vrefresh,
+			 igt_output_name(mst_output[i]));
+		primary[i] = igt_output_get_plane_type(mst_output[i],
+							DRM_PLANE_TYPE_PRIMARY);
+		igt_create_color_fb(data->drm_fd,
+				    mode[i]->hdisplay,
+				    mode[i]->vdisplay,
+				    DRM_FORMAT_XRGB8888,
+				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
+				    &fb[i]);
+		igt_plane_set_fb(primary[i], &fb[i]);
+	}
+}
+
+static bool fit_modes_in_bw(data_t *data)
+{
+	bool found;
+	int ret;
+
+	if (!igt_display_try_commit2(&data->display, COMMIT_ATOMIC)) {
+		igt_info("Modes overridden\n");
+		found = igt_override_all_active_output_modes_to_fit_bw(&data->display);
+                igt_require_f(found,
+                              "No valid mode combo found for MST modeset\n");
+                ret = igt_display_try_commit2(&data->display, COMMIT_ATOMIC);
+                igt_require_f(ret == 0,
+                              "Commit failure during MST modeset\n");
+        }
+        return true;
+}
+
+static bool validate_modeset_mst_output(data_t *data,
+					igt_output_t *mst_output[],
+					int *dp_mst_outputs,
+					drmModeModeInfo *mode[],
+					struct igt_fb fb[],
+					struct igt_plane *primary[])
+{
+
+	igt_require_f(*dp_mst_outputs > 0, "No MST outputs found\n");
+	setup_pipe_on_mst_outputs(data, mst_output, dp_mst_outputs);
+	setup_modeset_on_mst_outputs(data, mst_output,
+				     dp_mst_outputs,
+				     mode, fb, primary);
+	igt_assert_f(fit_modes_in_bw(data), "Unable to fit modes in bw\n");
+	return true;
+}
+
+static bool setup_mst(data_t *data, bool is_mst,
+		      igt_output_t *mst_output[],
+		      int *dp_mst_outputs, drmModeModeInfo *mode[],
+		      struct igt_fb fb[], struct igt_plane *primary[])
+{
+	bool ret;
+
+	*dp_mst_outputs = 0;
+	ret = setup_mst_outputs(data, mst_output, dp_mst_outputs);
+	if (!ret) {
+		igt_info("Skipping MST output %s as already tested\n",
+			 igt_output_name(data->output));
+		return false;
+	}
+
+	ret = validate_modeset_mst_output(data, mst_output,
+					  dp_mst_outputs, mode,
+					  fb, primary);
+	if (!ret) {
+		igt_info("Skipping MST output %s as validpipe/output combo not found\n",
+			 igt_output_name(data->output));
+		return false;
+	}
+
+	igt_display_commit2(&data->display, COMMIT_ATOMIC);
+	return true;
+}
+
+static int check_condition_with_timeout(int drm_fd, igt_output_t *output,
+					condition_check_fn check_fn,
+					double interval, double timeout)
+{
+	struct timespec start_time, current_time;
+	double elapsed_time;
+
+	clock_gettime(CLOCK_MONOTONIC, &start_time);
+
+	while (1) {
+		if (check_fn(drm_fd, output) == 0) {
+			return 0;
+		}
+
+		clock_gettime(CLOCK_MONOTONIC, &current_time);
+		elapsed_time = (current_time.tv_sec - start_time.tv_sec) +
+			(current_time.tv_nsec - start_time.tv_nsec) / 1e9;
+
+		if (elapsed_time >= timeout) {
+			return -1;
+		}
+
+		usleep((useconds_t)(interval * 1000000));
+	}
+}
+
+static void test_fallback(data_t *data, bool is_mst)
+{
+	int dp_mst_outputs, retries;
+	igt_output_t *mst_outputs[IGT_MAX_PIPES];
+	enum dp_link_rate max_link_rate, curr_link_rate, prev_link_rate;
+	enum dp_lane_count max_lane_count, curr_lane_count, prev_lane_count;
+	uint32_t link_status_prop_id;
+	uint64_t link_status_value;
+	drmModeModeInfo *mst_modes[IGT_MAX_PIPES], *mode;
+	drmModePropertyPtr link_status_prop;
+	struct igt_fb mst_fbs[IGT_MAX_PIPES], fb;
+	struct igt_plane *mst_primarys[IGT_MAX_PIPES], *primary;
+	struct udev_monitor *mon;
+
+	igt_display_reset(&data->display);
+	retries = SPURIOUS_HPD_RETRY;
+
+	if (is_mst) {
+		if (!setup_mst(data, is_mst, mst_outputs,
+			       &dp_mst_outputs, mst_modes, mst_fbs,
+			       mst_primarys))
+			return;
+	} else {
+		data->pipe = PIPE_A;
+		igt_output_set_pipe(data->output, data->pipe);
+		mode = igt_output_get_mode(data->output);
+		primary = igt_output_get_plane_type(data->output,
+						    DRM_PLANE_TYPE_PRIMARY);
+		igt_create_color_fb(data->drm_fd,
+				    mode->hdisplay, mode->vdisplay,
+				    DRM_FORMAT_XRGB8888,
+				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
+				    &fb);
+		igt_plane_set_fb(primary, &fb);
+		igt_display_commit2(&data->display, COMMIT_ATOMIC);
+	}
+
+	igt_info("Testing link training fallback on %s\n",
+		 igt_output_name(data->output));
+
+	igt_reset_link_params(data->drm_fd, data->output);
+	igt_assert_eq(check_condition_with_timeout(data->drm_fd,
+						   data->output,
+						   igt_get_dp_pending_retrain,
+						   1.0, 20.0), 0);
+
+	max_link_rate = igt_get_dp_max_link_rate(data->drm_fd, data->output);
+	max_lane_count = igt_get_dp_max_lane_count(data->drm_fd, data->output);
+
+	while (!igt_get_dp_link_retrain_disabled(data->drm_fd,
+						 data->output)) {
+
+		prev_link_rate = igt_get_dp_link_rate_set_for_output(data->drm_fd, data->output);
+		prev_lane_count = igt_get_dp_lane_count_set_for_output(data->drm_fd, data->output);
+
+		igt_info("Current link rate: %s, Current lane count: %s\n",
+			 str_link_rate(prev_link_rate),
+			 str_lane_count(prev_lane_count));
+		mon = igt_watch_uevents();
+		igt_force_lt_failure(data->drm_fd, data->output,
+				     LT_FAILURE_REDUCED_CAPS);
+		igt_force_link_retrain(data->drm_fd, data->output,
+				       RETRAIN_COUNT);
+
+		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
+							   data->output,
+							   igt_get_dp_pending_retrain,
+							   1.0, 20.0), 0);
+		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
+							   data->output,
+							   igt_get_dp_pending_lt_failures,
+							   1.0, 20.0), 0);
+
+		if (igt_get_dp_link_retrain_disabled(data->drm_fd,
+						     data->output)) {
+			igt_reset_connectors();
+			return;
+		}
+
+		igt_assert_f(igt_hotplug_detected(mon, 20),
+			     "Didn't get hotplug for force link training failure\n");
+
+		kmstest_get_property(data->drm_fd,
+				data->output->config.connector->connector_id,
+				DRM_MODE_OBJECT_CONNECTOR, "link-status",
+				&link_status_prop_id, &link_status_value,
+				&link_status_prop);
+
+		igt_assert_eq(link_status_value, DRM_MODE_LINK_STATUS_BAD);
+
+		igt_flush_uevents(mon);
+
+		if (is_mst) {
+			igt_assert_f(validate_modeset_mst_output(data,
+								 mst_outputs,
+								 &dp_mst_outputs,
+								 mst_modes,
+								 mst_fbs,
+								 mst_primarys),
+				     "MST modeset failed\n");
+		} else {
+			data->output->force_reprobe = true;
+			igt_output_refresh(data->output);
+			data->pipe = PIPE_A;
+			igt_assert_f(fit_modes_in_bw(data),
+				     "Unable to fit modes in bw\n");
+
+			igt_output_set_pipe(data->output, data->pipe);
+			mode = igt_output_get_mode(data->output);
+			igt_info("Mode %dx%d@%d on output %s\n",
+				 mode->hdisplay, mode->vdisplay,
+				 mode->vrefresh,
+				 igt_output_name(data->output));
+			primary = igt_output_get_plane_type(data->output,
+							    DRM_PLANE_TYPE_PRIMARY);
+			igt_create_color_fb(data->drm_fd,
+					    mode->hdisplay,
+					    mode->vdisplay,
+					    DRM_FORMAT_XRGB8888,
+					    DRM_FORMAT_MOD_LINEAR,
+					    0.0, 1.0, 0.0, &fb);
+			igt_plane_set_fb(primary, &fb);
+		}
+
+		kmstest_set_connector_link_status(data->drm_fd,
+						  data->output->config.connector,
+						  DRM_MODE_LINK_STATUS_GOOD);
+		igt_display_commit2(&data->display, COMMIT_ATOMIC);
+
+		kmstest_get_property(data->drm_fd,
+				data->output->config.connector->connector_id,
+				DRM_MODE_OBJECT_CONNECTOR, "link-status",
+				&link_status_prop_id, &link_status_value,
+				&link_status_prop);
+		igt_assert_eq(link_status_value, DRM_MODE_LINK_STATUS_GOOD);
+
+		curr_link_rate = igt_get_dp_link_rate_set_for_output(data->drm_fd, data->output);
+		curr_lane_count = igt_get_dp_lane_count_set_for_output(data->drm_fd, data->output);
+
+		igt_assert_f((curr_link_rate < prev_link_rate ||
+			     curr_lane_count < prev_lane_count) ||
+			     ((curr_link_rate == max_link_rate && curr_lane_count == max_lane_count) && --retries),
+			     "Fallback unsuccessful\n");
+
+		prev_link_rate = curr_link_rate;
+		prev_lane_count = curr_lane_count;
+	}
+}
+
+igt_main
+{
+	data_t data = {};
+
+	igt_fixture {
+		data.drm_fd = drm_open_driver_master(DRIVER_INTEL |
+						     DRIVER_XE);
+		kmstest_set_vt_graphics_mode();
+		igt_display_require(&data.display, data.drm_fd);
+		igt_display_require_output(&data.display);
+		for_each_pipe(&data.display, data.pipe) {
+			data.n_pipes++;
+		}
+	}
+
+	igt_subtest("dp-fallback") {
+		bool ran = false;
+		igt_output_t *output;
+
+		for_each_connected_output(&data.display, output) {
+
+			data.output = output;
+			if (!igt_has_force_link_training_failure_debugfs(data.drm_fd,
+								    data.output)) {
+				igt_info("Output %s unsupported\n", igt_output_name(data.output));
+				continue;
+			}
+
+			if (output->config.connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort) {
+				igt_info("Skipping output %s as it's not DP\n", output->name);
+				continue;
+			}
+
+			ran = true;
+
+			/*
+			 * Check output is MST
+			 */
+			if (igt_check_output_is_dp_mst(data.output)) {
+				igt_info("Testing MST output %s\n",
+					 igt_output_name(data.output));
+				test_fallback(&data, true);
+			} else {
+				igt_info("Testing DP output %s\n",
+					 igt_output_name(data.output));
+				test_fallback(&data, false);
+			}
+		}
+		igt_require_f(ran, "No output supports fallback\n");
+	}
+
+	igt_fixture {
+		igt_remove_fb(data.drm_fd, &data.fb);
+		igt_display_fini(&data.display);
+		close(data.drm_fd);
+	}
+}
diff --git a/tests/meson.build b/tests/meson.build
index 00556c9d6..86fab423b 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -249,6 +249,7 @@ intel_kms_progs = [
 	'kms_dirtyfb',
 	'kms_draw_crc',
 	'kms_dsc',
+        'kms_fallback',
 	'kms_fb_coherency',
 	'kms_fbcon_fbt',
 	'kms_fence_pin_leak',
-- 
2.34.1

RE: [PATCH i-g-t 01/14] lib/igt_kms: add enum for link rate and lane count

[B, Jeevan]

> -----Original Message-----
> From: igt-dev <igt-dev-bounces@lists.freedesktop.org> On Behalf Of Kunal
> Joshi
> Sent: Sunday, August 25, 2024 11:44 PM
> To: igt-dev@lists.freedesktop.org
> Cc: Joshi, Kunal1 <kunal1.joshi@intel.com>
> Subject: [PATCH i-g-t 01/14] lib/igt_kms: add enum for link rate and lane
> count
> 
> add enums for link rate, lane count
> 
> Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
LGTM.

Reviewed-by: Jeevan B <jeevan.b@intel.com>

> ---
>  lib/igt_kms.h | 23 +++++++++++++++++++++++
>  1 file changed, 23 insertions(+)
> 
> diff --git a/lib/igt_kms.h b/lib/igt_kms.h index 25ba50916..999921f9f
> 100644
> --- a/lib/igt_kms.h
> +++ b/lib/igt_kms.h
> @@ -258,6 +258,29 @@ enum intel_broadcast_rgb_mode {
>  	BROADCAST_RGB_16_235
>  };
> 
> +enum dp_link_rate {
> +	DP_LINK_RATE_162000 = 162000,
> +	DP_LINK_RATE_216000 = 216000,
> +	DP_LINK_RATE_243000 = 243000,
> +	DP_LINK_RATE_270000 = 270000,
> +	DP_LINK_RATE_324000 = 324000,
> +	DP_LINK_RATE_432000 = 432000,
> +	DP_LINK_RATE_540000 = 540000,
> +	DP_LINK_RATE_675000 = 675000,
> +	DP_LINK_RATE_810000 = 810000,
> +	DP_LINK_RATE_1000000 = 1000000,
> +	DP_LINK_RATE_1350000 = 1350000,
> +	DP_LINK_RATE_2000000 = 2000000
> +};
> +
> +#define DP_MAX_LINK_RATE_COUNT 12
> +
> +enum dp_lane_count {
> +	DP_LANE_COUNT_1 = 1,
> +	DP_LANE_COUNT_2 = 2,
> +	DP_LANE_COUNT_4 = 4
> +};
> +
>  struct edid;
> 
>  bool kmstest_force_connector(int fd, drmModeConnector *connector,
> --
> 2.43.0

RE: [PATCH i-g-t 13/14] tests/intel/kms_dp_fallback: add test for validating fallback

[Samala, Pranay]

> -----Original Message-----
> From: igt-dev <igt-dev-bounces@lists.freedesktop.org> On Behalf Of Kunal Joshi
> Sent: Monday, August 26, 2024 1:36 AM
> To: igt-dev@lists.freedesktop.org
> Cc: Joshi, Kunal1 <kunal1.joshi@intel.com>; Deak, Imre <imre.deak@intel.com>
> Subject: [PATCH i-g-t 13/14] tests/intel/kms_dp_fallback: add test for validating
> fallback
> 
> add test to valdiate fallback for DP connector, eDP subtest will be added later.
> 
> How does test validates fallback?
> - test start by doing initial modeset on default mode
>    (if connector is DP then we enable just that connector,
>     if its DP-MST we enable all on the same topology)
> - force link training failures and retrain until we reach
>   lowest param or retrain is disabled
> - expect hotplug and link-status to turn bad
> - expect link params reduce after fallback
> 
> v2: add test for mst (imre)
>     refresh mode list (imre)
>     monitor got hotplugs (imre)
>     check link parameter are reduced (imre)
> 
> v3: call check_fn (Santosh)
> 
> v4: handle buggy lg monitor (Imre)
>     remove reset in between (Imre)
> 
> v5: fit modes wrt to bw in non-mst case as well
> 
> Cc: Imre Deak <imre.deak@intel.com>
> Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
> Suggested-by: Imre Deak <imre.deak@intel.com>
> ---
>  tests/intel/kms_fallback.c | 515 +++++++++++++++++++++++++++++++++++++
>  tests/meson.build          |   1 +
>  2 files changed, 516 insertions(+)
>  create mode 100644 tests/intel/kms_fallback.c
> 
> diff --git a/tests/intel/kms_fallback.c b/tests/intel/kms_fallback.c new file mode
> 100644 index 000000000..e97300c08
> --- /dev/null
> +++ b/tests/intel/kms_fallback.c
> @@ -0,0 +1,515 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2024 Intel Corporation
> + */
> +
> +/**
> + * TEST: kms fallback
> + * Category: Display
> + * Description: Test link training fallback for eDP/DP connectors
> + * Driver requirement: i915, xe
> + * Functionality: link training
> + * Mega feature: General Display Features
> + * Test category: functionality test
> + */
> +
> +#include <sys/types.h>
> +
> +#include "igt.h"
> +#include "igt_psr.h"
> +
> +/**
> + * SUBTEST: dp-fallback
> + * Description: Test fallback on DP connectors  */
> +
> +#define RETRAIN_COUNT 1
> +#define LT_FAILURE_SAME_CAPS 1
> +#define LT_FAILURE_REDUCED_CAPS 2
> +#define SPURIOUS_HPD_RETRY 3
> +
> +static int traversed_mst_outputs[IGT_MAX_PIPES];
> +static int traversed_mst_output_count;
> +typedef struct {
> +	int drm_fd;
> +	igt_display_t display;
> +	drmModeModeInfo *mode;
> +	igt_output_t *output;
> +	enum pipe pipe;
> +	struct igt_fb fb;
> +	struct igt_plane *primary;
> +	int n_pipes;
> +} data_t;
> +
> +typedef int (*condition_check_fn)(int drm_fd, igt_output_t *output);
> +
> +IGT_TEST_DESCRIPTION("Test link training fallback");
> +
> +static const char *str_link_rate(enum dp_link_rate link_rate) {
> +	switch (link_rate) {
> +	case DP_LINK_RATE_162000:
> +		return "1.62 Gbps";
> +	case DP_LINK_RATE_216000:
> +		return "2.16 Gbps";
> +	case DP_LINK_RATE_243000:
> +		return "2.43 Gbps";
> +	case DP_LINK_RATE_270000:
> +		return "2.70 Gbps";
> +	case DP_LINK_RATE_324000:
> +		return "3.24 Gbps";
> +	case DP_LINK_RATE_432000:
> +		return "4.32 Gbps";
> +	case DP_LINK_RATE_540000:
> +		return "5.40 Gbps";
> +	case DP_LINK_RATE_675000:
> +		return "6.75 Gbps";
> +	case DP_LINK_RATE_810000:
> +		return "8.10 Gbps";
> +	case DP_LINK_RATE_1000000:
> +		return "10.00 Gbps";
> +	case DP_LINK_RATE_1350000:
> +		return "13.50 Gbps";
> +	case DP_LINK_RATE_2000000:
> +		return "20.00 Gbps";
> +	default:
> +		igt_assert_f(0, "Invalid link rate %d\n", link_rate);
> +	}
> +}
> +
> +static const char *str_lane_count(enum dp_lane_count lane_count) {
> +	switch (lane_count) {
> +	case DP_LANE_COUNT_1:
> +		return "1";
> +	case DP_LANE_COUNT_2:
> +		return "2";
> +	case DP_LANE_COUNT_4:
> +		return "4";
> +	default:
> +		igt_assert_f(0, "Invalid lane count %d\n", lane_count);
> +	}
> +}
> +
> +static void find_mst_outputs(int drm_fd, data_t *data,
> +			     igt_output_t *output,
> +			     igt_output_t **mst_outputs,
> +			     int *num_mst_outputs)
> +{
> +	bool is_output_mst;
> +	uint64_t path_blob_id;
> +	igt_output_t *connector_output;
> +	drmModePropertyPtr path_prop = NULL;
> +	drmModePropertyPtr connector_path_prop = NULL;
> +
> +	igt_assert_f(output, "Invalid output\n");
> +
> +	/*
> +	 * Check if given output is MST by checking if it has PATH property
> +	 */
> +	is_output_mst = kmstest_get_property(drm_fd,
> +			output->config.connector->connector_id,
> +			DRM_MODE_OBJECT_CONNECTOR, "PATH", NULL,
> +			&path_blob_id, &path_prop);
> +
> +	if (!is_output_mst)
> +		return;
> +
> +	/*
> +	 * If output is MST check all other connected output which shares
> +	 * same path and fill mst_outputs and num_mst_outputs
> +	 */
> +	for_each_connected_output(&data->display, connector_output) {
> +
> +		connector_path_prop = NULL;
> +
> +		kmstest_get_property(drm_fd,
> +				     connector_output->config.connector-
> >connector_id,
> +				     DRM_MODE_OBJECT_CONNECTOR, "PATH",
> +				     NULL, &path_blob_id,
> +				     &connector_path_prop);
> +
> +		if (connector_path_prop && path_prop &&
> +		    connector_path_prop->prop_id == path_prop->prop_id)
> +			mst_outputs[(*num_mst_outputs)++] =
> connector_output;
> +
> +		if (connector_path_prop)
> +			drmModeFreeProperty(connector_path_prop);
> +	}
> +	if (path_prop)
> +		drmModeFreeProperty(path_prop);
> +}
> +
> +static bool setup_mst_outputs(data_t *data, igt_output_t *mst_output[],
> +			      int *dp_mst_outputs)
> +{
> +	int i;
> +	igt_output_t *output;
> +
> +	igt_require_f(igt_check_output_is_dp_mst(data->output),
> +		      "Not a valid MST connector\n");
> +
> +	/*
> +	 * Check if this is already traversed
> +	 */
> +	for (i = 0; i < traversed_mst_output_count; i++)
> +		if (traversed_mst_outputs[i] == data->output->config.connector-
> >connector_id)
> +			return false;
> +
> +	find_mst_outputs(data->drm_fd, data, data->output,
> +			 mst_output, dp_mst_outputs);
> +
> +	for (i = 0; i < *dp_mst_outputs; i++) {
> +		output = mst_output[i];
> +		traversed_mst_outputs[traversed_mst_output_count++] =
> output->config.connector->connector_id;
> +		igt_info("Output %s is in same topology as %s\n",
> +			 igt_output_name(output),
> +			 igt_output_name(data->output));
> +	}
> +
> +	return true;
> +}
> +
> +static void setup_pipe_on_mst_outputs(data_t *data,
> +				      igt_output_t *mst_output[],
> +				      int *dp_mst_outputs)
> +{
> +	int i = 0;
> +
> +	igt_require_f(data->n_pipes >= *dp_mst_outputs,
> +		      "Need %d pipes to assign to %d MST outputs\n",
> +		      data->n_pipes, *dp_mst_outputs);
> +
> +	for_each_pipe(&data->display, data->pipe) {
> +		if (i >= *dp_mst_outputs)
> +			break;
> +		igt_info("Setting pipe %s on output %s\n",
> +			 kmstest_pipe_name(data->pipe),
> +			 igt_output_name(mst_output[i]));
> +		igt_output_set_pipe(mst_output[i++], data->pipe);
> +	}
> +}
> +
> +static void setup_modeset_on_mst_outputs(data_t *data,
> +					 igt_output_t *mst_output[],
> +					 int *dp_mst_outputs,
> +					 drmModeModeInfo *mode[],
> +					 struct igt_fb fb[],
> +					 struct igt_plane *primary[])
> +{
> +	int i;
> +
> +	for (i = 0; i < *dp_mst_outputs; i++) {
> +		mst_output[i]->force_reprobe = true;
> +		igt_output_refresh(mst_output[i]);
> +		mode[i] = igt_output_get_mode(mst_output[i]);
> +		igt_info("Mode %dx%d@%d on output %s\n",
> +			 mode[i]->hdisplay, mode[i]->vdisplay,
> +			 mode[i]->vrefresh,
> +			 igt_output_name(mst_output[i]));
> +		primary[i] = igt_output_get_plane_type(mst_output[i],
> +
> 	DRM_PLANE_TYPE_PRIMARY);
> +		igt_create_color_fb(data->drm_fd,
> +				    mode[i]->hdisplay,
> +				    mode[i]->vdisplay,
> +				    DRM_FORMAT_XRGB8888,
> +				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
> +				    &fb[i]);
> +		igt_plane_set_fb(primary[i], &fb[i]);
> +	}
> +}
> +
> +static bool fit_modes_in_bw(data_t *data) {
> +	bool found;
> +	int ret;
> +
> +	if (!igt_display_try_commit2(&data->display, COMMIT_ATOMIC)) {
> +		igt_info("Modes overridden\n");
> +		found =
> igt_override_all_active_output_modes_to_fit_bw(&data->display);
> +                igt_require_f(found,
> +                              "No valid mode combo found for MST modeset\n");
> +                ret = igt_display_try_commit2(&data->display, COMMIT_ATOMIC);
> +                igt_require_f(ret == 0,
> +                              "Commit failure during MST modeset\n");
> +        }
> +        return true;
> +}
> +
> +static bool validate_modeset_mst_output(data_t *data,
> +					igt_output_t *mst_output[],
> +					int *dp_mst_outputs,
> +					drmModeModeInfo *mode[],
> +					struct igt_fb fb[],
> +					struct igt_plane *primary[])
> +{
> +
> +	igt_require_f(*dp_mst_outputs > 0, "No MST outputs found\n");
> +	setup_pipe_on_mst_outputs(data, mst_output, dp_mst_outputs);
> +	setup_modeset_on_mst_outputs(data, mst_output,
> +				     dp_mst_outputs,
> +				     mode, fb, primary);
> +	igt_assert_f(fit_modes_in_bw(data), "Unable to fit modes in bw\n");
> +	return true;
> +}
> +
> +static bool setup_mst(data_t *data, bool is_mst,
> +		      igt_output_t *mst_output[],
> +		      int *dp_mst_outputs, drmModeModeInfo *mode[],
> +		      struct igt_fb fb[], struct igt_plane *primary[]) {
> +	bool ret;
> +
> +	*dp_mst_outputs = 0;
> +	ret = setup_mst_outputs(data, mst_output, dp_mst_outputs);
> +	if (!ret) {
> +		igt_info("Skipping MST output %s as already tested\n",
> +			 igt_output_name(data->output));
> +		return false;
> +	}
> +
> +	ret = validate_modeset_mst_output(data, mst_output,
> +					  dp_mst_outputs, mode,
> +					  fb, primary);
> +	if (!ret) {
> +		igt_info("Skipping MST output %s as validpipe/output combo not
> found\n",
> +			 igt_output_name(data->output));
> +		return false;
> +	}
> +
> +	igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +	return true;
> +}
> +
> +static int check_condition_with_timeout(int drm_fd, igt_output_t *output,
> +					condition_check_fn check_fn,
> +					double interval, double timeout)
> +{
> +	struct timespec start_time, current_time;
> +	double elapsed_time;
> +
> +	clock_gettime(CLOCK_MONOTONIC, &start_time);
> +
> +	while (1) {
> +		if (check_fn(drm_fd, output) == 0) {
> +			return 0;
> +		}
> +
> +		clock_gettime(CLOCK_MONOTONIC, &current_time);
> +		elapsed_time = (current_time.tv_sec - start_time.tv_sec) +
> +			(current_time.tv_nsec - start_time.tv_nsec) / 1e9;
> +
> +		if (elapsed_time >= timeout) {
> +			return -1;
> +		}
> +
> +		usleep((useconds_t)(interval * 1000000));
> +	}
> +}
> +
> +static void test_fallback(data_t *data, bool is_mst) {
> +	int dp_mst_outputs, retries;
> +	igt_output_t *mst_outputs[IGT_MAX_PIPES];
> +	enum dp_link_rate max_link_rate, curr_link_rate, prev_link_rate;
> +	enum dp_lane_count max_lane_count, curr_lane_count,
> prev_lane_count;
> +	uint32_t link_status_prop_id;
> +	uint64_t link_status_value;
> +	drmModeModeInfo *mst_modes[IGT_MAX_PIPES], *mode;
> +	drmModePropertyPtr link_status_prop;
> +	struct igt_fb mst_fbs[IGT_MAX_PIPES], fb;
> +	struct igt_plane *mst_primarys[IGT_MAX_PIPES], *primary;
> +	struct udev_monitor *mon;
> +
> +	igt_display_reset(&data->display);
> +	retries = SPURIOUS_HPD_RETRY;
> +
> +	if (is_mst) {
> +		if (!setup_mst(data, is_mst, mst_outputs,
> +			       &dp_mst_outputs, mst_modes, mst_fbs,
> +			       mst_primarys))
> +			return;
> +	} else {
> +		data->pipe = PIPE_A;
> +		igt_output_set_pipe(data->output, data->pipe);
> +		mode = igt_output_get_mode(data->output);
> +		primary = igt_output_get_plane_type(data->output,
> +
> DRM_PLANE_TYPE_PRIMARY);
> +		igt_create_color_fb(data->drm_fd,
> +				    mode->hdisplay, mode->vdisplay,
> +				    DRM_FORMAT_XRGB8888,
> +				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
> +				    &fb);
> +		igt_plane_set_fb(primary, &fb);
> +		igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +	}
> +
> +	igt_info("Testing link training fallback on %s\n",
> +		 igt_output_name(data->output));
> +
> +	igt_reset_link_params(data->drm_fd, data->output);
> +	igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +						   data->output,
> +						   igt_get_dp_pending_retrain,
> +						   1.0, 20.0), 0);
> +
> +	max_link_rate = igt_get_dp_max_link_rate(data->drm_fd, data->output);
> +	max_lane_count = igt_get_dp_max_lane_count(data->drm_fd,
> +data->output);
> +
> +	while (!igt_get_dp_link_retrain_disabled(data->drm_fd,
> +						 data->output)) {
> +
> +		prev_link_rate = igt_get_dp_link_rate_set_for_output(data-
> >drm_fd, data->output);
> +		prev_lane_count = igt_get_dp_lane_count_set_for_output(data-
> >drm_fd,
> +data->output);
> +
> +		igt_info("Current link rate: %s, Current lane count: %s\n",
> +			 str_link_rate(prev_link_rate),
> +			 str_lane_count(prev_lane_count));
> +		mon = igt_watch_uevents();
> +		igt_force_lt_failure(data->drm_fd, data->output,
> +				     LT_FAILURE_REDUCED_CAPS);
> +		igt_force_link_retrain(data->drm_fd, data->output,
> +				       RETRAIN_COUNT);
> +
> +		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +							   data->output,
> +
> igt_get_dp_pending_retrain,
> +							   1.0, 20.0), 0);
> +		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +							   data->output,
> +
> igt_get_dp_pending_lt_failures,
> +							   1.0, 20.0), 0);
> +
> +		if (igt_get_dp_link_retrain_disabled(data->drm_fd,
> +						     data->output)) {
> +			igt_reset_connectors();
> +			return;
> +		}
> +
> +		igt_assert_f(igt_hotplug_detected(mon, 20),
> +			     "Didn't get hotplug for force link training failure\n");
> +
> +		kmstest_get_property(data->drm_fd,
> +				data->output->config.connector->connector_id,
> +				DRM_MODE_OBJECT_CONNECTOR, "link-
> status",
> +				&link_status_prop_id, &link_status_value,
> +				&link_status_prop);
> +
> +		igt_assert_eq(link_status_value,
> DRM_MODE_LINK_STATUS_BAD);
> +
> +		igt_flush_uevents(mon);
> +
> +		if (is_mst) {
> +			igt_assert_f(validate_modeset_mst_output(data,
> +								 mst_outputs,
> +
> &dp_mst_outputs,
> +								 mst_modes,
> +								 mst_fbs,
> +
> mst_primarys),
> +				     "MST modeset failed\n");
> +		} else {
> +			data->output->force_reprobe = true;
> +			igt_output_refresh(data->output);
> +			data->pipe = PIPE_A;
> +			igt_assert_f(fit_modes_in_bw(data),
> +				     "Unable to fit modes in bw\n");
> +
> +			igt_output_set_pipe(data->output, data->pipe);
> +			mode = igt_output_get_mode(data->output);
> +			igt_info("Mode %dx%d@%d on output %s\n",
> +				 mode->hdisplay, mode->vdisplay,
> +				 mode->vrefresh,
> +				 igt_output_name(data->output));
> +			primary = igt_output_get_plane_type(data->output,
> +
> DRM_PLANE_TYPE_PRIMARY);
> +			igt_create_color_fb(data->drm_fd,
> +					    mode->hdisplay,
> +					    mode->vdisplay,
> +					    DRM_FORMAT_XRGB8888,
> +					    DRM_FORMAT_MOD_LINEAR,
> +					    0.0, 1.0, 0.0, &fb);
> +			igt_plane_set_fb(primary, &fb);
> +		}
> +
> +		kmstest_set_connector_link_status(data->drm_fd,
> +						  data->output-
> >config.connector,
> +
> DRM_MODE_LINK_STATUS_GOOD);
> +		igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +
> +		kmstest_get_property(data->drm_fd,
> +				data->output->config.connector->connector_id,
> +				DRM_MODE_OBJECT_CONNECTOR, "link-
> status",
> +				&link_status_prop_id, &link_status_value,
> +				&link_status_prop);
> +		igt_assert_eq(link_status_value,
> DRM_MODE_LINK_STATUS_GOOD);
> +
> +		curr_link_rate = igt_get_dp_link_rate_set_for_output(data-
> >drm_fd, data->output);
> +		curr_lane_count = igt_get_dp_lane_count_set_for_output(data-
> >drm_fd,
> +data->output);
> +
> +		igt_assert_f((curr_link_rate < prev_link_rate ||
> +			     curr_lane_count < prev_lane_count) ||
> +			     ((curr_link_rate == max_link_rate &&
> curr_lane_count == max_lane_count) && --retries),
> +			     "Fallback unsuccessful\n");
> +
> +		prev_link_rate = curr_link_rate;
> +		prev_lane_count = curr_lane_count;
> +	}
> +}
> +
> +igt_main
> +{
> +	data_t data = {};
> +
> +	igt_fixture {
> +		data.drm_fd = drm_open_driver_master(DRIVER_INTEL |
> +						     DRIVER_XE);
> +		kmstest_set_vt_graphics_mode();
> +		igt_display_require(&data.display, data.drm_fd);
> +		igt_display_require_output(&data.display);
> +		for_each_pipe(&data.display, data.pipe) {
> +			data.n_pipes++;
> +		}
> +	}
> +
> +	igt_subtest("dp-fallback") {
> +		bool ran = false;
> +		igt_output_t *output;
> +
> +		for_each_connected_output(&data.display, output) {
> +
> +			data.output = output;
> +			if
> (!igt_has_force_link_training_failure_debugfs(data.drm_fd,
> +
> data.output)) {
> +				igt_info("Output %s unsupported\n",
> igt_output_name(data.output));

If possible, we can convert this message to a more user-friendly way.

Igt_info("Output %s doesn't support force link training failure\n" 
Or anything similar.

Regards,
Pranay Samala

> +				continue;
> +			}
> +
> +			if (output->config.connector->connector_type !=
> DRM_MODE_CONNECTOR_DisplayPort) {
> +				igt_info("Skipping output %s as it's not DP\n",
> output->name);
> +				continue;
> +			}
> +
> +			ran = true;
> +
> +			/*
> +			 * Check output is MST
> +			 */
> +			if (igt_check_output_is_dp_mst(data.output)) {
> +				igt_info("Testing MST output %s\n",
> +					 igt_output_name(data.output));
> +				test_fallback(&data, true);
> +			} else {
> +				igt_info("Testing DP output %s\n",
> +					 igt_output_name(data.output));
> +				test_fallback(&data, false);
> +			}
> +		}
> +		igt_require_f(ran, "No output supports fallback\n");
> +	}
> +
> +	igt_fixture {
> +		igt_remove_fb(data.drm_fd, &data.fb);
> +		igt_display_fini(&data.display);
> +		close(data.drm_fd);
> +	}
> +}
> diff --git a/tests/meson.build b/tests/meson.build index 00556c9d6..86fab423b
> 100644
> --- a/tests/meson.build
> +++ b/tests/meson.build
> @@ -249,6 +249,7 @@ intel_kms_progs = [
>  	'kms_dirtyfb',
>  	'kms_draw_crc',
>  	'kms_dsc',
> +        'kms_fallback',
>  	'kms_fb_coherency',
>  	'kms_fbcon_fbt',
>  	'kms_fence_pin_leak',
> --
> 2.34.1

RE: [PATCH i-g-t 13/14] tests/intel/kms_dp_fallback: add test for validating fallback

[Samala, Pranay]

> -----Original Message-----
> From: igt-dev <igt-dev-bounces@lists.freedesktop.org> On Behalf Of Kunal Joshi
> Sent: Sunday, August 25, 2024 11:44 PM
> To: igt-dev@lists.freedesktop.org
> Cc: Joshi, Kunal1 <kunal1.joshi@intel.com>; Deak, Imre <imre.deak@intel.com>
> Subject: [PATCH i-g-t 13/14] tests/intel/kms_dp_fallback: add test for validating
> fallback
> 
> add test to valdiate fallback for DP connector, eDP subtest will be added later.
> 
> How does test validates fallback?
> - test start by doing initial modeset on default mode
>    (if connector is DP then we enable just that connector,
>     if its DP-MST we enable all on the same topology)
> - force link training failures and retrain until we reach
>   lowest param or retrain is disabled
> - expect hotplug and link-status to turn bad
> - expect link params reduce after fallback
> 
> v2: add test for mst (imre)
>     refresh mode list (imre)
>     monitor got hotplugs (imre)
>     check link parameter are reduced (imre)
> 
> v3: call check_fn (Santosh)
> 
> v4: handle buggy lg monitor (Imre)
>     remove reset in between (Imre)
> 
> Cc: Imre Deak <imre.deak@intel.com>
> Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
> Suggested-by: Imre Deak <imre.deak@intel.com>
> ---
>  tests/intel/kms_fallback.c | 506 +++++++++++++++++++++++++++++++++++++
>  tests/meson.build          |   1 +
>  2 files changed, 507 insertions(+)
>  create mode 100644 tests/intel/kms_fallback.c
> 
> diff --git a/tests/intel/kms_fallback.c b/tests/intel/kms_fallback.c new file mode
> 100644 index 000000000..e5da3c579
> --- /dev/null
> +++ b/tests/intel/kms_fallback.c
> @@ -0,0 +1,506 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2024 Intel Corporation
> + */
> +
> +/**
> + * TEST: kms fallback
> + * Category: Display
> + * Description: Test link training fallback for eDP/DP connectors
> + * Driver requirement: i915, xe
> + * Functionality: link training
> + * Mega feature: General Display Features
> + * Test category: functionality test
> + */
> +
> +#include <sys/types.h>
> +
> +#include "igt.h"
> +#include "igt_psr.h"
> +
> +/**
> + * SUBTEST: dp-fallback
> + * Description: Test fallback on DP connectors  */
> +
> +#define RETRAIN_COUNT 1
> +#define LT_FAILURE_SAME_CAPS 1
> +#define LT_FAILURE_REDUCED_CAPS 2
> +#define SPURIOUS_HPD_RETRY 3
> +
> +static int traversed_mst_outputs[IGT_MAX_PIPES];
> +static int traversed_mst_output_count;
> +typedef struct {
> +	int drm_fd;
> +	igt_display_t display;
> +	drmModeModeInfo *mode;
> +	igt_output_t *output;
> +	enum pipe pipe;
> +	struct igt_fb fb;
> +	struct igt_plane *primary;
> +	int n_pipes;
> +} data_t;
> +
> +typedef int (*condition_check_fn)(int drm_fd, igt_output_t *output);
> +
> +IGT_TEST_DESCRIPTION("Test link training fallback");
> +
> +static const char *str_link_rate(enum dp_link_rate link_rate) {
> +	switch (link_rate) {
> +	case DP_LINK_RATE_162000:
> +		return "1.62 Gbps";
> +	case DP_LINK_RATE_216000:
> +		return "2.16 Gbps";
> +	case DP_LINK_RATE_243000:
> +		return "2.43 Gbps";
> +	case DP_LINK_RATE_270000:
> +		return "2.70 Gbps";
> +	case DP_LINK_RATE_324000:
> +		return "3.24 Gbps";
> +	case DP_LINK_RATE_432000:
> +		return "4.32 Gbps";
> +	case DP_LINK_RATE_540000:
> +		return "5.40 Gbps";
> +	case DP_LINK_RATE_675000:
> +		return "6.75 Gbps";
> +	case DP_LINK_RATE_810000:
> +		return "8.10 Gbps";
> +	case DP_LINK_RATE_1000000:
> +		return "10.00 Gbps";
> +	case DP_LINK_RATE_1350000:
> +		return "13.50 Gbps";
> +	case DP_LINK_RATE_2000000:
> +		return "20.00 Gbps";
> +	default:
> +		igt_assert_f(0, "Invalid link rate %d\n", link_rate);
> +	}
> +}
> +
> +static const char *str_lane_count(enum dp_lane_count lane_count) {
> +	switch (lane_count) {
> +	case DP_LANE_COUNT_1:
> +		return "1";
> +	case DP_LANE_COUNT_2:
> +		return "2";
> +	case DP_LANE_COUNT_4:
> +		return "4";
> +	default:
> +		igt_assert_f(0, "Invalid lane count %d\n", lane_count);
> +	}
> +}
> +
> +static void find_mst_outputs(int drm_fd, data_t *data,
> +			     igt_output_t *output,
> +			     igt_output_t **mst_outputs,
> +			     int *num_mst_outputs)
> +{
> +	bool is_output_mst;
> +	uint64_t path_blob_id;
> +	igt_output_t *connector_output;
> +	drmModePropertyPtr path_prop = NULL;
> +	drmModePropertyPtr connector_path_prop = NULL;
> +
> +	igt_assert_f(output, "Invalid output\n");
> +
> +	/*
> +	 * Check if given output is MST by checking if it has PATH property
> +	 */
> +	is_output_mst = kmstest_get_property(drm_fd,
> +			output->config.connector->connector_id,
> +			DRM_MODE_OBJECT_CONNECTOR, "PATH", NULL,
> +			&path_blob_id, &path_prop);
> +
> +	if (!is_output_mst)
> +		return;
> +
> +	/*
> +	 * If output is MST check all other connected output which shares
> +	 * same path and fill mst_outputs and num_mst_outputs
> +	 */
> +	for_each_connected_output(&data->display, connector_output) {
> +
> +		connector_path_prop = NULL;
> +
> +		kmstest_get_property(drm_fd,
> +				     connector_output->config.connector-
> >connector_id,
> +				     DRM_MODE_OBJECT_CONNECTOR, "PATH",
> +				     NULL, &path_blob_id,
> +				     &connector_path_prop);
> +
> +		if (connector_path_prop && path_prop &&
> +		    connector_path_prop->prop_id == path_prop->prop_id)
> +			mst_outputs[(*num_mst_outputs)++] =
> connector_output;
> +
> +		if (connector_path_prop)
> +			drmModeFreeProperty(connector_path_prop);
> +	}
> +	if (path_prop)
> +		drmModeFreeProperty(path_prop);
> +}
> +
> +static bool setup_mst_outputs(data_t *data, igt_output_t *mst_output[],
> +			      int *dp_mst_outputs)
> +{
> +	int i;
> +	igt_output_t *output;
> +
> +	igt_require_f(igt_check_output_is_dp_mst(data->output),
> +		      "Not a valid MST connector\n");
> +
> +	/*
> +	 * Check if this is already traversed
> +	 */
> +	for (i = 0; i < traversed_mst_output_count; i++)
> +		if (traversed_mst_outputs[i] == data->output->config.connector-
> >connector_id)
> +			return false;
> +
> +	find_mst_outputs(data->drm_fd, data, data->output,
> +			 mst_output, dp_mst_outputs);
> +
> +	for (i = 0; i < *dp_mst_outputs; i++) {
> +		output = mst_output[i];
> +		traversed_mst_outputs[traversed_mst_output_count++] =
> output->config.connector->connector_id;
> +		igt_info("Output %s is in same topology as %s\n",
> +			 igt_output_name(output),
> +			 igt_output_name(data->output));
> +	}
> +
> +	return true;
> +}
> +
> +static void setup_pipe_on_mst_outputs(data_t *data,
> +				      igt_output_t *mst_output[],
> +				      int *dp_mst_outputs)
> +{
> +	int i = 0;
> +
> +	igt_require_f(data->n_pipes >= *dp_mst_outputs,
> +		      "Need %d pipes to assign to %d MST outputs\n",
> +		      data->n_pipes, *dp_mst_outputs);
> +
> +	for_each_pipe(&data->display, data->pipe) {
> +		if (i >= *dp_mst_outputs)
> +			break;
> +		igt_info("Setting pipe %s on output %s\n",
> +			 kmstest_pipe_name(data->pipe),
> +			 igt_output_name(mst_output[i]));
> +		igt_output_set_pipe(mst_output[i++], data->pipe);
> +	}
> +}
> +
> +static void setup_modeset_on_mst_outputs(data_t *data,
> +					 igt_output_t *mst_output[],
> +					 int *dp_mst_outputs,
> +					 drmModeModeInfo *mode[],
> +					 struct igt_fb fb[],
> +					 struct igt_plane *primary[])
> +{
> +	int i;
> +
> +	for (i = 0; i < *dp_mst_outputs; i++) {
> +		mst_output[i]->force_reprobe = true;
> +		igt_output_refresh(mst_output[i]);
> +		mode[i] = igt_output_get_mode(mst_output[i]);
> +		igt_info("Mode %dx%d@%d on output %s\n",
> +			 mode[i]->hdisplay, mode[i]->vdisplay,
> +			 mode[i]->vrefresh,
> +			 igt_output_name(mst_output[i]));
> +		primary[i] = igt_output_get_plane_type(mst_output[i],
> +
> 	DRM_PLANE_TYPE_PRIMARY);
> +		igt_create_color_fb(data->drm_fd,
> +				    mode[i]->hdisplay,
> +				    mode[i]->vdisplay,
> +				    DRM_FORMAT_XRGB8888,
> +				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
> +				    &fb[i]);
> +		igt_plane_set_fb(primary[i], &fb[i]);
> +	}
> +}
> +
> +static bool validate_modeset_mst_output(data_t *data,
> +					igt_output_t *mst_output[],
> +					int *dp_mst_outputs,
> +					drmModeModeInfo *mode[],
> +					struct igt_fb fb[],
> +					struct igt_plane *primary[])
> +{
> +	bool found;
> +	int ret;
> +
> +	igt_require_f(*dp_mst_outputs > 0, "No MST outputs found\n");
> +	setup_pipe_on_mst_outputs(data, mst_output, dp_mst_outputs);
> +	setup_modeset_on_mst_outputs(data, mst_output,
> +				     dp_mst_outputs,
> +				     mode, fb, primary);
> +	if (!igt_display_try_commit2(&data->display, COMMIT_ATOMIC)) {
> +		igt_info("Modes overridden\n");
> +		found =
> +igt_override_all_active_output_modes_to_fit_bw(&data->display);
> +
> +		igt_require_f(found,
> +			      "No valid mode combo found for MST modeset\n");
> +		ret = igt_display_try_commit2(&data->display,
> COMMIT_ATOMIC);
> +		igt_require_f(ret == 0,
> +			      "Commit failure during MST modeset\n");
> +	}
> +	return true;
> +}
> +
> +static bool setup_mst(data_t *data, bool is_mst,
> +		      igt_output_t *mst_output[],
> +		      int *dp_mst_outputs, drmModeModeInfo *mode[],
> +		      struct igt_fb fb[], struct igt_plane *primary[]) {
> +	bool ret;
> +
> +	*dp_mst_outputs = 0;
> +	ret = setup_mst_outputs(data, mst_output, dp_mst_outputs);
> +	if (!ret) {
> +		igt_info("Skipping MST output %s as already tested\n",
> +			 igt_output_name(data->output));
> +		return false;
> +	}
> +
> +	ret = validate_modeset_mst_output(data, mst_output,
> +					  dp_mst_outputs, mode,
> +					  fb, primary);
> +	if (!ret) {
> +		igt_info("Skipping MST output %s as validpipe/output combo not
> found\n",
> +			 igt_output_name(data->output));
> +		return false;
> +	}
> +
> +	igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +	return true;
> +}
> +
> +static int check_condition_with_timeout(int drm_fd, igt_output_t *output,
> +					condition_check_fn check_fn,
> +					double interval, double timeout)
> +{
> +	struct timespec start_time, current_time;
> +	double elapsed_time;
> +
> +	clock_gettime(CLOCK_MONOTONIC, &start_time);
> +
> +	while (1) {
> +		if (check_fn(drm_fd, output) == 0) {
> +			return 0;
> +		}
> +
> +		clock_gettime(CLOCK_MONOTONIC, &current_time);
> +		elapsed_time = (current_time.tv_sec - start_time.tv_sec) +
> +			(current_time.tv_nsec - start_time.tv_nsec) / 1e9;
> +
> +		if (elapsed_time >= timeout) {
> +			return -1;
> +		}
> +
> +		usleep((useconds_t)(interval * 1000000));
> +	}
> +}
> +
> +static void test_fallback(data_t *data, bool is_mst) {
> +	int dp_mst_outputs, retries;
> +	igt_output_t *mst_outputs[IGT_MAX_PIPES];
> +	enum dp_link_rate max_link_rate, curr_link_rate, prev_link_rate;
> +	enum dp_lane_count max_lane_count, curr_lane_count,
> prev_lane_count;
> +	uint32_t link_status_prop_id;
> +	uint64_t link_status_value;
> +	drmModeModeInfo *mst_modes[IGT_MAX_PIPES], *mode;
> +	drmModePropertyPtr link_status_prop;
> +	struct igt_fb mst_fbs[IGT_MAX_PIPES], fb;
> +	struct igt_plane *mst_primarys[IGT_MAX_PIPES], *primary;
> +	struct udev_monitor *mon;
> +
> +	igt_display_reset(&data->display);
> +	retries = SPURIOUS_HPD_RETRY;
> +
> +	if (is_mst) {
> +		if (!setup_mst(data, is_mst, mst_outputs,
> +			       &dp_mst_outputs, mst_modes, mst_fbs,
> +			       mst_primarys))
> +			return;
> +	} else {
> +		data->pipe = PIPE_A;
> +		igt_output_set_pipe(data->output, data->pipe);
> +		mode = igt_output_get_mode(data->output);
> +		primary = igt_output_get_plane_type(data->output,
> +
> DRM_PLANE_TYPE_PRIMARY);
> +		igt_create_color_fb(data->drm_fd,
> +				    mode->hdisplay, mode->vdisplay,
> +				    DRM_FORMAT_XRGB8888,
> +				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
> +				    &fb);
> +		igt_plane_set_fb(primary, &fb);
> +		igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +	}
> +
> +	igt_info("Testing link training fallback on %s\n",
> +		 igt_output_name(data->output));
> +
> +	igt_reset_link_params(data->drm_fd, data->output);
> +	igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +						   data->output,
> +						   igt_get_dp_pending_retrain,
> +						   1.0, 20.0), 0);
> +
> +	max_link_rate = igt_get_dp_max_link_rate(data->drm_fd, data->output);
> +	max_lane_count = igt_get_dp_max_lane_count(data->drm_fd,
> +data->output);
> +
> +	while (!igt_get_dp_link_retrain_disabled(data->drm_fd,
> +						 data->output)) {
> +
> +		prev_link_rate = igt_get_dp_link_rate_set_for_output(data-
> >drm_fd, data->output);
> +		prev_lane_count = igt_get_dp_lane_count_set_for_output(data-
> >drm_fd,
> +data->output);
> +
> +		igt_info("Current link rate: %s, Current lane count: %s\n",
> +			 str_link_rate(prev_link_rate),
> +			 str_lane_count(prev_lane_count));
> +		mon = igt_watch_uevents();
> +		igt_force_lt_failure(data->drm_fd, data->output,
> +				     LT_FAILURE_REDUCED_CAPS);
> +		igt_force_link_retrain(data->drm_fd, data->output,
> +				       RETRAIN_COUNT);
> +
> +		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +							   data->output,
> +
> igt_get_dp_pending_retrain,
> +							   1.0, 20.0), 0);
> +		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +							   data->output,
> +
> igt_get_dp_pending_lt_failures,
> +							   1.0, 20.0), 0);
> +
> +		if (igt_get_dp_link_retrain_disabled(data->drm_fd,
> +						     data->output)) {
> +			igt_reset_connectors();
> +			return;
> +		}
> +
> +		igt_assert_f(igt_hotplug_detected(mon, 20),
> +			     "Didn't get hotplug for force link training failure\n");
> +
> +		kmstest_get_property(data->drm_fd,
> +				data->output->config.connector->connector_id,
> +				DRM_MODE_OBJECT_CONNECTOR, "link-
> status",
> +				&link_status_prop_id, &link_status_value,
> +				&link_status_prop);
> +
> +		igt_assert_eq(link_status_value,
> DRM_MODE_LINK_STATUS_BAD);
> +
> +		igt_flush_uevents(mon);
> +
> +		if (is_mst) {
> +			igt_assert_f(validate_modeset_mst_output(data,
> +								 mst_outputs,
> +
> &dp_mst_outputs,
> +								 mst_modes,
> +								 mst_fbs,
> +
> mst_primarys),
> +				     "MST modeset failed\n");
> +		} else {
> +			data->output->force_reprobe = true;
> +			igt_output_refresh(data->output);
> +			data->pipe = PIPE_A;
> +			igt_output_set_pipe(data->output, data->pipe);
> +			mode = igt_output_get_mode(data->output);
> +			igt_info("Mode %dx%d@%d on output %s\n",
> +				 mode->hdisplay, mode->vdisplay,
> +				 mode->vrefresh,
> +				 igt_output_name(data->output));
> +			primary = igt_output_get_plane_type(data->output,
> +
> DRM_PLANE_TYPE_PRIMARY);
> +			igt_create_color_fb(data->drm_fd,
> +					    mode->hdisplay,
> +					    mode->vdisplay,
> +					    DRM_FORMAT_XRGB8888,
> +					    DRM_FORMAT_MOD_LINEAR,
> +					    0.0, 1.0, 0.0, &fb);
> +			igt_plane_set_fb(primary, &fb);
> +		}
> +
> +		kmstest_set_connector_link_status(data->drm_fd,
> +						  data->output-
> >config.connector,
> +
> DRM_MODE_LINK_STATUS_GOOD);
> +		igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +
> +		kmstest_get_property(data->drm_fd,
> +				data->output->config.connector->connector_id,
> +				DRM_MODE_OBJECT_CONNECTOR, "link-
> status",
> +				&link_status_prop_id, &link_status_value,
> +				&link_status_prop);
> +		igt_assert_eq(link_status_value,
> DRM_MODE_LINK_STATUS_GOOD);
> +
> +		curr_link_rate = igt_get_dp_link_rate_set_for_output(data-
> >drm_fd, data->output);
> +		curr_lane_count = igt_get_dp_lane_count_set_for_output(data-
> >drm_fd,
> +data->output);
> +
> +		igt_assert_f((curr_link_rate < prev_link_rate ||
> +			     curr_lane_count < prev_lane_count) ||
> +			     ((curr_link_rate == max_link_rate &&
> curr_lane_count == max_lane_count) && --retries),
> +			     "Fallback unsuccessful\n");
> +
> +		prev_link_rate = curr_link_rate;
> +		prev_lane_count = curr_lane_count;
> +	}
> +}
> +
> +igt_main
> +{
> +	data_t data = {};
> +
> +	igt_fixture {
> +		data.drm_fd = drm_open_driver_master(DRIVER_INTEL |
> +						     DRIVER_XE);
> +		kmstest_set_vt_graphics_mode();
> +		igt_display_require(&data.display, data.drm_fd);
> +		igt_display_require_output(&data.display);
> +		for_each_pipe(&data.display, data.pipe) {
> +			data.n_pipes++;
> +		}
> +	}
> +
> +	igt_subtest("dp-fallback") {
> +		bool ran = false;
> +		igt_output_t *output;
> +
> +		for_each_connected_output(&data.display, output) {
> +
> +			data.output = output;
> +			if
> (!igt_has_force_link_training_failure_debugfs(data.drm_fd,
> +
> data.output)) {
> +				igt_info("Output %s unsupported\n",
> igt_output_name(data.output));

If possible, we can convert this message to a more user-friendly way.

Igt_info("Output %s doesn't support force link training failure\n" 
Or anything similar.

Regards,
Pranay Samala
> +				continue;
> +			}
> +
> +			if (output->config.connector->connector_type !=
> DRM_MODE_CONNECTOR_DisplayPort) {
> +				igt_info("Skipping output %s as it's not DP\n",
> output->name);
> +				continue;
> +			}
> +
> +			ran = true;
> +
> +			/*
> +			 * Check output is MST
> +			 */
> +			if (igt_check_output_is_dp_mst(data.output)) {
> +				igt_info("Testing MST output %s\n",
> +					 igt_output_name(data.output));
> +				test_fallback(&data, true);
> +			} else {
> +				igt_info("Testing DP output %s\n",
> +					 igt_output_name(data.output));
> +				test_fallback(&data, false);
> +			}
> +		}
> +		igt_require_f(ran, "No output supports fallback\n");
> +	}
> +
> +	igt_fixture {
> +		igt_remove_fb(data.drm_fd, &data.fb);
> +		igt_display_fini(&data.display);
> +		close(data.drm_fd);
> +	}
> +}
> diff --git a/tests/meson.build b/tests/meson.build index 00556c9d6..86fab423b
> 100644
> --- a/tests/meson.build
> +++ b/tests/meson.build
> @@ -249,6 +249,7 @@ intel_kms_progs = [
>  	'kms_dirtyfb',
>  	'kms_draw_crc',
>  	'kms_dsc',
> +        'kms_fallback',
>  	'kms_fb_coherency',
>  	'kms_fbcon_fbt',
>  	'kms_fence_pin_leak',
> --
> 2.43.0

RE: [PATCH i-g-t 07/14] lib/igt_kms: add function to check force link training failure support

[Samala, Pranay]

> -----Original Message-----
> From: igt-dev <igt-dev-bounces@lists.freedesktop.org> On Behalf Of Kunal Joshi
> Sent: Sunday, August 25, 2024 11:44 PM
> To: igt-dev@lists.freedesktop.org
> Cc: Joshi, Kunal1 <kunal1.joshi@intel.com>
> Subject: [PATCH i-g-t 07/14] lib/igt_kms: add function to check force link training
> failure support
> 
> add helper to check if platform support forcing link training failures
> 
> Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
LGTM.

Reviewed-by: Pranay Samala <pranay.samala@intel.com>
> ---
>  lib/igt_kms.c | 25 +++++++++++++++++++++++++  lib/igt_kms.h |  1 +
>  2 files changed, 26 insertions(+)
> 
> diff --git a/lib/igt_kms.c b/lib/igt_kms.c index 2720095d4..4ab47e2e9 100644
> --- a/lib/igt_kms.c
> +++ b/lib/igt_kms.c
> @@ -6893,3 +6893,28 @@ bool igt_get_dp_link_retrain_disabled(int drm_fd,
> igt_output_t *output)
>  	igt_require(res > 0);
>  	return strstr(buf, "yes");
>  }
> +
> +/**
> + * Checks if the force link training failure debugfs
> + * is available for a specific output.
> + *
> + * @drmfd: file descriptor of the DRM device.
> + * @output: output to check.
> + * Returns:
> + *  true if the debugfs is available, false otherwise.
> + */
> +bool igt_has_force_link_training_failure_debugfs(int drmfd,
> +igt_output_t *output) {
> +	int debugfs_fd, ret;
> +	char buf[512];
> +
> +	igt_assert_f(output->name, "Invalid output\n");
> +	debugfs_fd = igt_debugfs_connector_dir(drmfd, output->name,
> O_RDONLY);
> +	if (debugfs_fd < 0)
> +		return false;
> +	ret = igt_debugfs_simple_read(debugfs_fd,
> +				      "i915_dp_force_link_training_failure",
> +				      buf, sizeof(buf));
> +	close(debugfs_fd);
> +	return ret >= 0;
> +}
> diff --git a/lib/igt_kms.h b/lib/igt_kms.h index 2d69d794a..5ae324f6f 100644
> --- a/lib/igt_kms.h
> +++ b/lib/igt_kms.h
> @@ -1254,5 +1254,6 @@ enum dp_lane_count igt_get_dp_max_lane_count(int
> drm_fd, igt_output_t *output);  void igt_force_link_retrain(int drm_fd,
> igt_output_t *output, int retrain_count);  void igt_force_lt_failure(int drm_fd,
> igt_output_t *output, int failure_count);  bool
> igt_get_dp_link_retrain_disabled(int drm_fd, igt_output_t *output);
> +bool igt_has_force_link_training_failure_debugfs(int drmfd,
> +igt_output_t *output);
> 
>  #endif /* __IGT_KMS_H__ */
> --
> 2.43.0

Re: [PATCH i-g-t 13/14] tests/intel/kms_dp_fallback: add test for validating fallback

[Imre Deak]

On Mon, Aug 26, 2024 at 01:36:11AM +0530, Kunal Joshi wrote:
> add test to valdiate fallback for DP connector,
> eDP subtest will be added later.
> 
> How does test validates fallback?
> - test start by doing initial modeset on default mode
>    (if connector is DP then we enable just that connector,
>     if its DP-MST we enable all on the same topology)
> - force link training failures and retrain until we reach
>   lowest param or retrain is disabled
> - expect hotplug and link-status to turn bad
> - expect link params reduce after fallback
> 
> v2: add test for mst (imre)
>     refresh mode list (imre)
>     monitor got hotplugs (imre)
>     check link parameter are reduced (imre)
> 
> v3: call check_fn (Santosh)
> 
> v4: handle buggy lg monitor (Imre)
>     remove reset in between (Imre)
> 
> v5: fit modes wrt to bw in non-mst case as well
> 
> Cc: Imre Deak <imre.deak@intel.com>
> Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
> Suggested-by: Imre Deak <imre.deak@intel.com>
> ---
>  tests/intel/kms_fallback.c | 515 +++++++++++++++++++++++++++++++++++++
>  tests/meson.build          |   1 +
>  2 files changed, 516 insertions(+)
>  create mode 100644 tests/intel/kms_fallback.c
> 
> diff --git a/tests/intel/kms_fallback.c b/tests/intel/kms_fallback.c
> new file mode 100644
> index 000000000..e97300c08
> --- /dev/null
> +++ b/tests/intel/kms_fallback.c
> @@ -0,0 +1,515 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2024 Intel Corporation
> + */
> +
> +/**
> + * TEST: kms fallback
> + * Category: Display
> + * Description: Test link training fallback for eDP/DP connectors
> + * Driver requirement: i915, xe
> + * Functionality: link training
> + * Mega feature: General Display Features
> + * Test category: functionality test
> + */
> +
> +#include <sys/types.h>
> +
> +#include "igt.h"
> +#include "igt_psr.h"
> +
> +/**
> + * SUBTEST: dp-fallback
> + * Description: Test fallback on DP connectors
> + */
> +
> +#define RETRAIN_COUNT 1
> +#define LT_FAILURE_SAME_CAPS 1

This is not used. Maybe add a comment instead why 2 LT failure will lead
to reducing the link params?

> +#define LT_FAILURE_REDUCED_CAPS 2
> +#define SPURIOUS_HPD_RETRY 3
> +
> +static int traversed_mst_outputs[IGT_MAX_PIPES];
> +static int traversed_mst_output_count;
> +typedef struct {
> +	int drm_fd;
> +	igt_display_t display;
> +	drmModeModeInfo *mode;
> +	igt_output_t *output;
> +	enum pipe pipe;
> +	struct igt_fb fb;
> +	struct igt_plane *primary;
> +	int n_pipes;
> +} data_t;
> +
> +typedef int (*condition_check_fn)(int drm_fd, igt_output_t *output);
> +
> +IGT_TEST_DESCRIPTION("Test link training fallback");
> +
> +static const char *str_link_rate(enum dp_link_rate link_rate)
> +{
> +	switch (link_rate) {
> +	case DP_LINK_RATE_162000:
> +		return "1.62 Gbps";
> +	case DP_LINK_RATE_216000:
> +		return "2.16 Gbps";
> +	case DP_LINK_RATE_243000:
> +		return "2.43 Gbps";
> +	case DP_LINK_RATE_270000:
> +		return "2.70 Gbps";
> +	case DP_LINK_RATE_324000:
> +		return "3.24 Gbps";
> +	case DP_LINK_RATE_432000:
> +		return "4.32 Gbps";
> +	case DP_LINK_RATE_540000:
> +		return "5.40 Gbps";
> +	case DP_LINK_RATE_675000:
> +		return "6.75 Gbps";
> +	case DP_LINK_RATE_810000:
> +		return "8.10 Gbps";
> +	case DP_LINK_RATE_1000000:
> +		return "10.00 Gbps";
> +	case DP_LINK_RATE_1350000:
> +		return "13.50 Gbps";
> +	case DP_LINK_RATE_2000000:
> +		return "20.00 Gbps";
> +	default:
> +		igt_assert_f(0, "Invalid link rate %d\n", link_rate);
> +	}
> +}
> +
> +static const char *str_lane_count(enum dp_lane_count lane_count)
> +{
> +	switch (lane_count) {
> +	case DP_LANE_COUNT_1:
> +		return "1";
> +	case DP_LANE_COUNT_2:
> +		return "2";
> +	case DP_LANE_COUNT_4:
> +		return "4";
> +	default:
> +		igt_assert_f(0, "Invalid lane count %d\n", lane_count);
> +	}
> +}
> +
> +static void find_mst_outputs(int drm_fd, data_t *data,
> +			     igt_output_t *output,
> +			     igt_output_t **mst_outputs,
> +			     int *num_mst_outputs)
> +{
> +	bool is_output_mst;
> +	uint64_t path_blob_id;
> +	igt_output_t *connector_output;
> +	drmModePropertyPtr path_prop = NULL;
> +	drmModePropertyPtr connector_path_prop = NULL;
> +
> +	igt_assert_f(output, "Invalid output\n");
> +
> +	/*
> +	 * Check if given output is MST by checking if it has PATH property
> +	 */
> +	is_output_mst = kmstest_get_property(drm_fd,
> +			output->config.connector->connector_id,
> +			DRM_MODE_OBJECT_CONNECTOR, "PATH", NULL,
> +			&path_blob_id, &path_prop);
> +
> +	if (!is_output_mst)
> +		return;
> +
> +	/*
> +	 * If output is MST check all other connected output which shares
> +	 * same path and fill mst_outputs and num_mst_outputs
> +	 */
> +	for_each_connected_output(&data->display, connector_output) {
> +
> +		connector_path_prop = NULL;
> +
> +		kmstest_get_property(drm_fd,
> +				     connector_output->config.connector->connector_id,
> +				     DRM_MODE_OBJECT_CONNECTOR, "PATH",
> +				     NULL, &path_blob_id,
> +				     &connector_path_prop);
> +
> +		if (connector_path_prop && path_prop &&
> +		    connector_path_prop->prop_id == path_prop->prop_id)
> +			mst_outputs[(*num_mst_outputs)++] = connector_output;
> +
> +		if (connector_path_prop)
> +			drmModeFreeProperty(connector_path_prop);
> +	}
> +	if (path_prop)
> +		drmModeFreeProperty(path_prop);
> +}
> +
> +static bool setup_mst_outputs(data_t *data, igt_output_t *mst_output[],
> +			      int *dp_mst_outputs)
> +{
> +	int i;
> +	igt_output_t *output;
> +
> +	igt_require_f(igt_check_output_is_dp_mst(data->output),
> +		      "Not a valid MST connector\n");
> +
> +	/*
> +	 * Check if this is already traversed
> +	 */
> +	for (i = 0; i < traversed_mst_output_count; i++)
> +		if (traversed_mst_outputs[i] == data->output->config.connector->connector_id)
> +			return false;
> +
> +	find_mst_outputs(data->drm_fd, data, data->output,
> +			 mst_output, dp_mst_outputs);
> +
> +	for (i = 0; i < *dp_mst_outputs; i++) {
> +		output = mst_output[i];
> +		traversed_mst_outputs[traversed_mst_output_count++] = output->config.connector->connector_id;
> +		igt_info("Output %s is in same topology as %s\n",
> +			 igt_output_name(output),
> +			 igt_output_name(data->output));
> +	}
> +
> +	return true;
> +}
> +
> +static void setup_pipe_on_mst_outputs(data_t *data,
> +				      igt_output_t *mst_output[],
> +				      int *dp_mst_outputs)
> +{
> +	int i = 0;
> +
> +	igt_require_f(data->n_pipes >= *dp_mst_outputs,
> +		      "Need %d pipes to assign to %d MST outputs\n",
> +		      data->n_pipes, *dp_mst_outputs);
> +
> +	for_each_pipe(&data->display, data->pipe) {
> +		if (i >= *dp_mst_outputs)
> +			break;
> +		igt_info("Setting pipe %s on output %s\n",
> +			 kmstest_pipe_name(data->pipe),
> +			 igt_output_name(mst_output[i]));
> +		igt_output_set_pipe(mst_output[i++], data->pipe);
> +	}
> +}
> +
> +static void setup_modeset_on_mst_outputs(data_t *data,
> +					 igt_output_t *mst_output[],
> +					 int *dp_mst_outputs,
> +					 drmModeModeInfo *mode[],
> +					 struct igt_fb fb[],
> +					 struct igt_plane *primary[])
> +{
> +	int i;
> +
> +	for (i = 0; i < *dp_mst_outputs; i++) {
> +		mst_output[i]->force_reprobe = true;
> +		igt_output_refresh(mst_output[i]);
> +		mode[i] = igt_output_get_mode(mst_output[i]);
> +		igt_info("Mode %dx%d@%d on output %s\n",
> +			 mode[i]->hdisplay, mode[i]->vdisplay,
> +			 mode[i]->vrefresh,
> +			 igt_output_name(mst_output[i]));
> +		primary[i] = igt_output_get_plane_type(mst_output[i],
> +							DRM_PLANE_TYPE_PRIMARY);
> +		igt_create_color_fb(data->drm_fd,
> +				    mode[i]->hdisplay,
> +				    mode[i]->vdisplay,
> +				    DRM_FORMAT_XRGB8888,
> +				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
> +				    &fb[i]);
> +		igt_plane_set_fb(primary[i], &fb[i]);
> +	}
> +}
> +
> +static bool fit_modes_in_bw(data_t *data)
> +{
> +	bool found;
> +	int ret;
> +
> +	if (!igt_display_try_commit2(&data->display, COMMIT_ATOMIC)) {
> +		igt_info("Modes overridden\n");
> +		found = igt_override_all_active_output_modes_to_fit_bw(&data->display);
> +                igt_require_f(found,
> +                              "No valid mode combo found for MST modeset\n");
> +                ret = igt_display_try_commit2(&data->display, COMMIT_ATOMIC);
> +                igt_require_f(ret == 0,
> +                              "Commit failure during MST modeset\n");
> +        }
> +        return true;
> +}
> +
> +static bool validate_modeset_mst_output(data_t *data,
> +					igt_output_t *mst_output[],
> +					int *dp_mst_outputs,
> +					drmModeModeInfo *mode[],
> +					struct igt_fb fb[],
> +					struct igt_plane *primary[])
> +{
> +
> +	igt_require_f(*dp_mst_outputs > 0, "No MST outputs found\n");
> +	setup_pipe_on_mst_outputs(data, mst_output, dp_mst_outputs);
> +	setup_modeset_on_mst_outputs(data, mst_output,
> +				     dp_mst_outputs,
> +				     mode, fb, primary);
> +	igt_assert_f(fit_modes_in_bw(data), "Unable to fit modes in bw\n");
> +	return true;
> +}
> +
> +static bool setup_mst(data_t *data, bool is_mst,
> +		      igt_output_t *mst_output[],
> +		      int *dp_mst_outputs, drmModeModeInfo *mode[],
> +		      struct igt_fb fb[], struct igt_plane *primary[])
> +{
> +	bool ret;
> +
> +	*dp_mst_outputs = 0;
> +	ret = setup_mst_outputs(data, mst_output, dp_mst_outputs);
> +	if (!ret) {
> +		igt_info("Skipping MST output %s as already tested\n",
> +			 igt_output_name(data->output));
> +		return false;
> +	}
> +
> +	ret = validate_modeset_mst_output(data, mst_output,
> +					  dp_mst_outputs, mode,
> +					  fb, primary);
> +	if (!ret) {
> +		igt_info("Skipping MST output %s as validpipe/output combo not found\n",
> +			 igt_output_name(data->output));
> +		return false;
> +	}
> +
> +	igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +	return true;
> +}
> +
> +static int check_condition_with_timeout(int drm_fd, igt_output_t *output,
> +					condition_check_fn check_fn,
> +					double interval, double timeout)
> +{
> +	struct timespec start_time, current_time;
> +	double elapsed_time;
> +
> +	clock_gettime(CLOCK_MONOTONIC, &start_time);
> +
> +	while (1) {
> +		if (check_fn(drm_fd, output) == 0) {
> +			return 0;
> +		}
> +
> +		clock_gettime(CLOCK_MONOTONIC, &current_time);
> +		elapsed_time = (current_time.tv_sec - start_time.tv_sec) +
> +			(current_time.tv_nsec - start_time.tv_nsec) / 1e9;
> +
> +		if (elapsed_time >= timeout) {
> +			return -1;
> +		}
> +
> +		usleep((useconds_t)(interval * 1000000));
> +	}
> +}
> +
> +static void test_fallback(data_t *data, bool is_mst)
> +{
> +	int dp_mst_outputs, retries;
> +	igt_output_t *mst_outputs[IGT_MAX_PIPES];
> +	enum dp_link_rate max_link_rate, curr_link_rate, prev_link_rate;
> +	enum dp_lane_count max_lane_count, curr_lane_count, prev_lane_count;
> +	uint32_t link_status_prop_id;
> +	uint64_t link_status_value;
> +	drmModeModeInfo *mst_modes[IGT_MAX_PIPES], *mode;
> +	drmModePropertyPtr link_status_prop;
> +	struct igt_fb mst_fbs[IGT_MAX_PIPES], fb;
> +	struct igt_plane *mst_primarys[IGT_MAX_PIPES], *primary;
> +	struct udev_monitor *mon;
> +
> +	igt_display_reset(&data->display);
> +	retries = SPURIOUS_HPD_RETRY;
> +
> +	if (is_mst) {
> +		if (!setup_mst(data, is_mst, mst_outputs,
> +			       &dp_mst_outputs, mst_modes, mst_fbs,
> +			       mst_primarys))
> +			return;
> +	} else {
> +		data->pipe = PIPE_A;
> +		igt_output_set_pipe(data->output, data->pipe);
> +		mode = igt_output_get_mode(data->output);
> +		primary = igt_output_get_plane_type(data->output,
> +						    DRM_PLANE_TYPE_PRIMARY);
> +		igt_create_color_fb(data->drm_fd,
> +				    mode->hdisplay, mode->vdisplay,
> +				    DRM_FORMAT_XRGB8888,
> +				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
> +				    &fb);
> +		igt_plane_set_fb(primary, &fb);
> +		igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +	}

Would be better to have a separate function for the above and make
dp_mst_outputs more generic, also used for the non-MST case (adding to
the array then only a single output).

> +
> +	igt_info("Testing link training fallback on %s\n",
> +		 igt_output_name(data->output));
> +
> +	igt_reset_link_params(data->drm_fd, data->output);

Could this be done before the above setup part? Then the modes chosen
there should be based already on the updated link params and the commit
would also retrain the link if needed.

> +	igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +						   data->output,
> +						   igt_get_dp_pending_retrain,
> +						   1.0, 20.0), 0);
> +
> +	max_link_rate = igt_get_dp_max_link_rate(data->drm_fd, data->output);
> +	max_lane_count = igt_get_dp_max_lane_count(data->drm_fd, data->output);
> +
> +	while (!igt_get_dp_link_retrain_disabled(data->drm_fd,
> +						 data->output)) {
> +

Extra w/s.

> +		prev_link_rate = igt_get_dp_link_rate_set_for_output(data->drm_fd, data->output);
> +		prev_lane_count = igt_get_dp_lane_count_set_for_output(data->drm_fd, data->output);

Moving these before the loop would avoid the duplication wrt. setting
them at the end of the loop.

> +
> +		igt_info("Current link rate: %s, Current lane count: %s\n",
> +			 str_link_rate(prev_link_rate),
> +			 str_lane_count(prev_lane_count));
> +		mon = igt_watch_uevents();
> +		igt_force_lt_failure(data->drm_fd, data->output,
> +				     LT_FAILURE_REDUCED_CAPS);
> +		igt_force_link_retrain(data->drm_fd, data->output,
> +				       RETRAIN_COUNT);
> +
> +		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +							   data->output,
> +							   igt_get_dp_pending_retrain,
> +							   1.0, 20.0), 0);
> +		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +							   data->output,
> +							   igt_get_dp_pending_lt_failures,
> +							   1.0, 20.0), 0);
> +
> +		if (igt_get_dp_link_retrain_disabled(data->drm_fd,
> +						     data->output)) {
> +			igt_reset_connectors();
> +			return;
> +		}
> +
> +		igt_assert_f(igt_hotplug_detected(mon, 20),
> +			     "Didn't get hotplug for force link training failure\n");
> +
> +		kmstest_get_property(data->drm_fd,
> +				data->output->config.connector->connector_id,
> +				DRM_MODE_OBJECT_CONNECTOR, "link-status",
> +				&link_status_prop_id, &link_status_value,
> +				&link_status_prop);
> +
> +		igt_assert_eq(link_status_value, DRM_MODE_LINK_STATUS_BAD);
> +
> +		igt_flush_uevents(mon);
> +
> +		if (is_mst) {
> +			igt_assert_f(validate_modeset_mst_output(data,
> +								 mst_outputs,
> +								 &dp_mst_outputs,
> +								 mst_modes,
> +								 mst_fbs,
> +								 mst_primarys),
> +				     "MST modeset failed\n");
> +		} else {
> +			data->output->force_reprobe = true;
> +			igt_output_refresh(data->output);
> +			data->pipe = PIPE_A;
> +			igt_assert_f(fit_modes_in_bw(data),
> +				     "Unable to fit modes in bw\n");
> +
> +			igt_output_set_pipe(data->output, data->pipe);
> +			mode = igt_output_get_mode(data->output);
> +			igt_info("Mode %dx%d@%d on output %s\n",
> +				 mode->hdisplay, mode->vdisplay,
> +				 mode->vrefresh,
> +				 igt_output_name(data->output));
> +			primary = igt_output_get_plane_type(data->output,
> +							    DRM_PLANE_TYPE_PRIMARY);
> +			igt_create_color_fb(data->drm_fd,
> +					    mode->hdisplay,
> +					    mode->vdisplay,
> +					    DRM_FORMAT_XRGB8888,
> +					    DRM_FORMAT_MOD_LINEAR,
> +					    0.0, 1.0, 0.0, &fb);
> +			igt_plane_set_fb(primary, &fb);
> +		}

The above would be better in a separate function and make the MST and
non-MST cases more unified. For instance setup_modeset_on_mst_outputs()
looks quite similar to the above non-MST setup.

> +
> +		kmstest_set_connector_link_status(data->drm_fd,
> +						  data->output->config.connector,
> +						  DRM_MODE_LINK_STATUS_GOOD);
> +		igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +
> +		kmstest_get_property(data->drm_fd,
> +				data->output->config.connector->connector_id,
> +				DRM_MODE_OBJECT_CONNECTOR, "link-status",

Could use the cached property name here instead of hard-coding it.

> +				&link_status_prop_id, &link_status_value,
> +				&link_status_prop);
> +		igt_assert_eq(link_status_value, DRM_MODE_LINK_STATUS_GOOD);
> +
> +		curr_link_rate = igt_get_dp_link_rate_set_for_output(data->drm_fd, data->output);
> +		curr_lane_count = igt_get_dp_lane_count_set_for_output(data->drm_fd, data->output);
> +
> +		igt_assert_f((curr_link_rate < prev_link_rate ||
> +			     curr_lane_count < prev_lane_count) ||
> +			     ((curr_link_rate == max_link_rate && curr_lane_count == max_lane_count) && --retries),
> +			     "Fallback unsuccessful\n");

I wonder if having separate asserts would make it easier to parse the
logs.

> +
> +		prev_link_rate = curr_link_rate;
> +		prev_lane_count = curr_lane_count;
> +	}
> +}
> +
> +igt_main
> +{
> +	data_t data = {};
> +
> +	igt_fixture {
> +		data.drm_fd = drm_open_driver_master(DRIVER_INTEL |
> +						     DRIVER_XE);
> +		kmstest_set_vt_graphics_mode();
> +		igt_display_require(&data.display, data.drm_fd);
> +		igt_display_require_output(&data.display);
> +		for_each_pipe(&data.display, data.pipe) {

One liners don't the { }.

> +			data.n_pipes++;
> +		}
> +	}
> +
> +	igt_subtest("dp-fallback") {
> +		bool ran = false;
> +		igt_output_t *output;
> +
> +		for_each_connected_output(&data.display, output) {
> +

Extra w/s.

> +			data.output = output;
> +			if (!igt_has_force_link_training_failure_debugfs(data.drm_fd,
> +								    data.output)) {
> +				igt_info("Output %s unsupported\n", igt_output_name(data.output));
> +				continue;
> +			}
> +
> +			if (output->config.connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort) {
> +				igt_info("Skipping output %s as it's not DP\n", output->name);
> +				continue;
> +			}
> +
> +			ran = true;
> +
> +			/*
> +			 * Check output is MST
> +			 */
> +			if (igt_check_output_is_dp_mst(data.output)) {
> +				igt_info("Testing MST output %s\n",
> +					 igt_output_name(data.output));
> +				test_fallback(&data, true);
> +			} else {
> +				igt_info("Testing DP output %s\n",
> +					 igt_output_name(data.output));
> +				test_fallback(&data, false);
> +			}
> +		}
> +		igt_require_f(ran, "No output supports fallback\n");

Would be better to have a separate function for the above.

> +	}
> +
> +	igt_fixture {
> +		igt_remove_fb(data.drm_fd, &data.fb);
> +		igt_display_fini(&data.display);
> +		close(data.drm_fd);
> +	}
> +}
> diff --git a/tests/meson.build b/tests/meson.build
> index 00556c9d6..86fab423b 100644
> --- a/tests/meson.build
> +++ b/tests/meson.build
> @@ -249,6 +249,7 @@ intel_kms_progs = [
>  	'kms_dirtyfb',
>  	'kms_draw_crc',
>  	'kms_dsc',
> +        'kms_fallback',
>  	'kms_fb_coherency',
>  	'kms_fbcon_fbt',
>  	'kms_fence_pin_leak',
> -- 
> 2.34.1
> 

RE: [PATCH i-g-t 03/14] lib/igt_kms: add function to get max link rate/lane count

[Samala, Pranay]

> -----Original Message-----
> From: igt-dev <igt-dev-bounces@lists.freedesktop.org> On Behalf Of Kunal Joshi
> Sent: Sunday, August 25, 2024 11:44 PM
> To: igt-dev@lists.freedesktop.org
> Cc: Joshi, Kunal1 <kunal1.joshi@intel.com>
> Subject: [PATCH i-g-t 03/14] lib/igt_kms: add function to get max link rate/lane
> count
> 
> i915_dp_max_(lane_count/link_rate) debugfs files expose max link rate/lane
> count for connector.add function to get max link rate/lane lane count for
> connector
> 
> Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
> ---
>  lib/igt_kms.c | 58
> +++++++++++++++++++++++++++++++++++++++++++++++++++
>  lib/igt_kms.h |  2 ++
>  2 files changed, 60 insertions(+)
> 
> diff --git a/lib/igt_kms.c b/lib/igt_kms.c index 4ef7f4d7f..21ea8550c 100644
> --- a/lib/igt_kms.c
> +++ b/lib/igt_kms.c
> @@ -6763,3 +6763,61 @@ enum dp_lane_count
> igt_get_dp_lane_count_set_for_output(int drm_fd, igt_output_t
> 
>  	return lane_count;
>  }
> +
> +/**
> + * igt_get_dp_max_link_rate:
> + * @drm_fd: A drm file descriptor
> + * @output: The output to query
> + *
> + * Get the max link rate supported by the sink.
> + *
> + * Returns: Max link rate supported by the sink.
> + */
> +enum dp_link_rate igt_get_dp_max_link_rate(int drm_fd, igt_output_t
> +*output) {
> +	char buf[512];
> +	int dir, res;
> +	int max_link_rate;
> +
> +	igt_require_f(output->name, "Invalid output");
> +	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_DIRECTORY);
> +	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
> +				 igt_output_name(output));

Alignment should match open parenthesis

> +	res = igt_debugfs_simple_read(dir, "i915_dp_max_link_rate",
> +								  buf,
> sizeof(buf));

Same as above

> +	close(dir);
> +	igt_require_f(res > 0, "Couldn't read i915_dp_max_link_rate");
> +
> +	igt_assert(sscanf(buf, "%d", &max_link_rate) == 1);
> +
> +	return max_link_rate;
> +}
> +
> +/**
> + * igt_get_dp_max_lane_count:
> + * @drm_fd: A drm file descriptor
> + * @output: The output to query
> + *
> + * Get the max lane count supported by the sink.
> + *
> + * Returns: Max lane count supported by the sink.
> + */
> +enum dp_lane_count igt_get_dp_max_lane_count(int drm_fd, igt_output_t
> +*output) {
> +	char buf[512];
> +	int dir, res;
> +	int max_lane_count;
> +
> +	igt_require_f(output->name, "Invalid output");
> +	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_RDONLY);
> +	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
> +				 igt_output_name(output));

Same as above

> +	res = igt_debugfs_simple_read(dir, "i915_dp_max_lane_count",
> +								  buf,
> sizeof(buf));

Same as above

Regards,
Pranay Samala
> +	close(dir);
> +	igt_require(res > 0);
> +
> +	igt_assert(sscanf(buf, "%d", &max_lane_count) == 1);
> +
> +	return max_lane_count;
> +}
> diff --git a/lib/igt_kms.h b/lib/igt_kms.h index 9d42a2b35..1d3226c5c 100644
> --- a/lib/igt_kms.h
> +++ b/lib/igt_kms.h
> @@ -1249,5 +1249,7 @@ int igt_get_dp_mst_connector_id(igt_output_t
> *output);  int get_num_scalers(igt_display_t *display, enum pipe pipe);  enum
> dp_link_rate igt_get_dp_link_rate_set_for_output(int drm_fd, igt_output_t
> *output);  enum dp_lane_count igt_get_dp_lane_count_set_for_output(int
> drm_fd, igt_output_t *output);
> +enum dp_link_rate igt_get_dp_max_link_rate(int drm_fd, igt_output_t
> +*output); enum dp_lane_count igt_get_dp_max_lane_count(int drm_fd,
> +igt_output_t *output);
> 
>  #endif /* __IGT_KMS_H__ */
> --
> 2.43.0

RE: [PATCH i-g-t 06/14] lib/igt_kms: add function to check if retrain disabled

[Samala, Pranay]

> -----Original Message-----
> From: igt-dev <igt-dev-bounces@lists.freedesktop.org> On Behalf Of Kunal Joshi
> Sent: Sunday, August 25, 2024 11:44 PM
> To: igt-dev@lists.freedesktop.org
> Cc: Joshi, Kunal1 <kunal1.joshi@intel.com>
> Subject: [PATCH i-g-t 06/14] lib/igt_kms: add function to check if retrain disabled
> 
> add helper to check if retraining is disabled, retraining will be disable if we are at
> the lowest link parameters or the lowest mode supported on a panel
> 
> Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
> ---
>  lib/igt_kms.c | 24 ++++++++++++++++++++++++  lib/igt_kms.h |  1 +
>  2 files changed, 25 insertions(+)
> 
> diff --git a/lib/igt_kms.c b/lib/igt_kms.c index 683989e84..2720095d4 100644
> --- a/lib/igt_kms.c
> +++ b/lib/igt_kms.c
> @@ -6869,3 +6869,27 @@ void igt_force_lt_failure(int drm_fd, igt_output_t
> *output, int failure_count)
>  			     value, sizeof(value));
>  	close(dir);
>  }
> +
> +/**
> + * igt_get_dp_link_retrain_disabled:
> + * @drm_fd: A drm file descriptor
> + * @output: Target output
> + *
> + * Returns: True if link retrain disabled, false otherwise  */ bool
> +igt_get_dp_link_retrain_disabled(int drm_fd, igt_output_t *output) {
> +	int dir, res;
> +	char buf[512];
> +
> +	igt_require_f(output->name, "Invalid output");
> +	dir = igt_debugfs_connector_dir(drm_fd, output->name, O_RDONLY);
> +	igt_assert_f(dir >= 0, "Failed to open debugfs dir for connector %s\n",
> +			       igt_output_name(output));

Alignment should match open parenthesis.

Otherwise, code looks good to me.
Regards,
Pranay Samala

> +	res = igt_debugfs_simple_read(dir,
> +				      "i915_dp_link_retrain_disabled",
> +				      buf, sizeof(buf));
> +	close(dir);
> +	igt_require(res > 0);
> +	return strstr(buf, "yes");
> +}
> diff --git a/lib/igt_kms.h b/lib/igt_kms.h index 57829416a..2d69d794a 100644
> --- a/lib/igt_kms.h
> +++ b/lib/igt_kms.h
> @@ -1253,5 +1253,6 @@ enum dp_link_rate igt_get_dp_max_link_rate(int
> drm_fd, igt_output_t *output);  enum dp_lane_count
> igt_get_dp_max_lane_count(int drm_fd, igt_output_t *output);  void
> igt_force_link_retrain(int drm_fd, igt_output_t *output, int retrain_count);  void
> igt_force_lt_failure(int drm_fd, igt_output_t *output, int failure_count);
> +bool igt_get_dp_link_retrain_disabled(int drm_fd, igt_output_t
> +*output);
> 
>  #endif /* __IGT_KMS_H__ */
> --
> 2.43.0

RE: [PATCH i-g-t 13/14] tests/intel/kms_dp_fallback: add test for validating fallback

[Joshi, Kunal1]

Hello Imre,

-----Original Message-----
From: Deak, Imre <imre.deak@intel.com> 
Sent: Tuesday, September 3, 2024 8:25 PM
To: Joshi, Kunal1 <kunal1.joshi@intel.com>
Cc: igt-dev@lists.freedesktop.org
Subject: Re: [PATCH i-g-t 13/14] tests/intel/kms_dp_fallback: add test for validating fallback

On Mon, Aug 26, 2024 at 01:36:11AM +0530, Kunal Joshi wrote:
> add test to valdiate fallback for DP connector, eDP subtest will be 
> added later.
> 
> How does test validates fallback?
> - test start by doing initial modeset on default mode
>    (if connector is DP then we enable just that connector,
>     if its DP-MST we enable all on the same topology)
> - force link training failures and retrain until we reach
>   lowest param or retrain is disabled
> - expect hotplug and link-status to turn bad
> - expect link params reduce after fallback
> 
> v2: add test for mst (imre)
>     refresh mode list (imre)
>     monitor got hotplugs (imre)
>     check link parameter are reduced (imre)
> 
> v3: call check_fn (Santosh)
> 
> v4: handle buggy lg monitor (Imre)
>     remove reset in between (Imre)
> 
> v5: fit modes wrt to bw in non-mst case as well
> 
> Cc: Imre Deak <imre.deak@intel.com>
> Signed-off-by: Kunal Joshi <kunal1.joshi@intel.com>
> Suggested-by: Imre Deak <imre.deak@intel.com>
> ---
>  tests/intel/kms_fallback.c | 515 +++++++++++++++++++++++++++++++++++++
>  tests/meson.build          |   1 +
>  2 files changed, 516 insertions(+)
>  create mode 100644 tests/intel/kms_fallback.c
> 
> diff --git a/tests/intel/kms_fallback.c b/tests/intel/kms_fallback.c 
> new file mode 100644 index 000000000..e97300c08
> --- /dev/null
> +++ b/tests/intel/kms_fallback.c
> @@ -0,0 +1,515 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright (c) 2024 Intel Corporation  */
> +
> +/**
> + * TEST: kms fallback
> + * Category: Display
> + * Description: Test link training fallback for eDP/DP connectors
> + * Driver requirement: i915, xe
> + * Functionality: link training
> + * Mega feature: General Display Features
> + * Test category: functionality test
> + */
> +
> +#include <sys/types.h>
> +
> +#include "igt.h"
> +#include "igt_psr.h"
> +
> +/**
> + * SUBTEST: dp-fallback
> + * Description: Test fallback on DP connectors  */
> +
> +#define RETRAIN_COUNT 1
> +#define LT_FAILURE_SAME_CAPS 1

This is not used. Maybe add a comment instead why 2 LT failure will lead to reducing the link params?
----------------------------------------------------------------------------------------------
Ok will remove LT_FAILURE_SAME_CAPS and add a comment for LT_FAILURE_REDUCED_CAPS

> +#define LT_FAILURE_REDUCED_CAPS 2
> +#define SPURIOUS_HPD_RETRY 3
> +
> +static int traversed_mst_outputs[IGT_MAX_PIPES];
> +static int traversed_mst_output_count; typedef struct {
> +	int drm_fd;
> +	igt_display_t display;
> +	drmModeModeInfo *mode;
> +	igt_output_t *output;
> +	enum pipe pipe;
> +	struct igt_fb fb;
> +	struct igt_plane *primary;
> +	int n_pipes;
> +} data_t;
> +
> +typedef int (*condition_check_fn)(int drm_fd, igt_output_t *output);
> +
> +IGT_TEST_DESCRIPTION("Test link training fallback");
> +
> +static const char *str_link_rate(enum dp_link_rate link_rate) {
> +	switch (link_rate) {
> +	case DP_LINK_RATE_162000:
> +		return "1.62 Gbps";
> +	case DP_LINK_RATE_216000:
> +		return "2.16 Gbps";
> +	case DP_LINK_RATE_243000:
> +		return "2.43 Gbps";
> +	case DP_LINK_RATE_270000:
> +		return "2.70 Gbps";
> +	case DP_LINK_RATE_324000:
> +		return "3.24 Gbps";
> +	case DP_LINK_RATE_432000:
> +		return "4.32 Gbps";
> +	case DP_LINK_RATE_540000:
> +		return "5.40 Gbps";
> +	case DP_LINK_RATE_675000:
> +		return "6.75 Gbps";
> +	case DP_LINK_RATE_810000:
> +		return "8.10 Gbps";
> +	case DP_LINK_RATE_1000000:
> +		return "10.00 Gbps";
> +	case DP_LINK_RATE_1350000:
> +		return "13.50 Gbps";
> +	case DP_LINK_RATE_2000000:
> +		return "20.00 Gbps";
> +	default:
> +		igt_assert_f(0, "Invalid link rate %d\n", link_rate);
> +	}
> +}
> +
> +static const char *str_lane_count(enum dp_lane_count lane_count) {
> +	switch (lane_count) {
> +	case DP_LANE_COUNT_1:
> +		return "1";
> +	case DP_LANE_COUNT_2:
> +		return "2";
> +	case DP_LANE_COUNT_4:
> +		return "4";
> +	default:
> +		igt_assert_f(0, "Invalid lane count %d\n", lane_count);
> +	}
> +}
> +
> +static void find_mst_outputs(int drm_fd, data_t *data,
> +			     igt_output_t *output,
> +			     igt_output_t **mst_outputs,
> +			     int *num_mst_outputs)
> +{
> +	bool is_output_mst;
> +	uint64_t path_blob_id;
> +	igt_output_t *connector_output;
> +	drmModePropertyPtr path_prop = NULL;
> +	drmModePropertyPtr connector_path_prop = NULL;
> +
> +	igt_assert_f(output, "Invalid output\n");
> +
> +	/*
> +	 * Check if given output is MST by checking if it has PATH property
> +	 */
> +	is_output_mst = kmstest_get_property(drm_fd,
> +			output->config.connector->connector_id,
> +			DRM_MODE_OBJECT_CONNECTOR, "PATH", NULL,
> +			&path_blob_id, &path_prop);
> +
> +	if (!is_output_mst)
> +		return;
> +
> +	/*
> +	 * If output is MST check all other connected output which shares
> +	 * same path and fill mst_outputs and num_mst_outputs
> +	 */
> +	for_each_connected_output(&data->display, connector_output) {
> +
> +		connector_path_prop = NULL;
> +
> +		kmstest_get_property(drm_fd,
> +				     connector_output->config.connector->connector_id,
> +				     DRM_MODE_OBJECT_CONNECTOR, "PATH",
> +				     NULL, &path_blob_id,
> +				     &connector_path_prop);
> +
> +		if (connector_path_prop && path_prop &&
> +		    connector_path_prop->prop_id == path_prop->prop_id)
> +			mst_outputs[(*num_mst_outputs)++] = connector_output;
> +
> +		if (connector_path_prop)
> +			drmModeFreeProperty(connector_path_prop);
> +	}
> +	if (path_prop)
> +		drmModeFreeProperty(path_prop);
> +}
> +
> +static bool setup_mst_outputs(data_t *data, igt_output_t *mst_output[],
> +			      int *dp_mst_outputs)
> +{
> +	int i;
> +	igt_output_t *output;
> +
> +	igt_require_f(igt_check_output_is_dp_mst(data->output),
> +		      "Not a valid MST connector\n");
> +
> +	/*
> +	 * Check if this is already traversed
> +	 */
> +	for (i = 0; i < traversed_mst_output_count; i++)
> +		if (traversed_mst_outputs[i] == data->output->config.connector->connector_id)
> +			return false;
> +
> +	find_mst_outputs(data->drm_fd, data, data->output,
> +			 mst_output, dp_mst_outputs);
> +
> +	for (i = 0; i < *dp_mst_outputs; i++) {
> +		output = mst_output[i];
> +		traversed_mst_outputs[traversed_mst_output_count++] = output->config.connector->connector_id;
> +		igt_info("Output %s is in same topology as %s\n",
> +			 igt_output_name(output),
> +			 igt_output_name(data->output));
> +	}
> +
> +	return true;
> +}
> +
> +static void setup_pipe_on_mst_outputs(data_t *data,
> +				      igt_output_t *mst_output[],
> +				      int *dp_mst_outputs)
> +{
> +	int i = 0;
> +
> +	igt_require_f(data->n_pipes >= *dp_mst_outputs,
> +		      "Need %d pipes to assign to %d MST outputs\n",
> +		      data->n_pipes, *dp_mst_outputs);
> +
> +	for_each_pipe(&data->display, data->pipe) {
> +		if (i >= *dp_mst_outputs)
> +			break;
> +		igt_info("Setting pipe %s on output %s\n",
> +			 kmstest_pipe_name(data->pipe),
> +			 igt_output_name(mst_output[i]));
> +		igt_output_set_pipe(mst_output[i++], data->pipe);
> +	}
> +}
> +
> +static void setup_modeset_on_mst_outputs(data_t *data,
> +					 igt_output_t *mst_output[],
> +					 int *dp_mst_outputs,
> +					 drmModeModeInfo *mode[],
> +					 struct igt_fb fb[],
> +					 struct igt_plane *primary[])
> +{
> +	int i;
> +
> +	for (i = 0; i < *dp_mst_outputs; i++) {
> +		mst_output[i]->force_reprobe = true;
> +		igt_output_refresh(mst_output[i]);
> +		mode[i] = igt_output_get_mode(mst_output[i]);
> +		igt_info("Mode %dx%d@%d on output %s\n",
> +			 mode[i]->hdisplay, mode[i]->vdisplay,
> +			 mode[i]->vrefresh,
> +			 igt_output_name(mst_output[i]));
> +		primary[i] = igt_output_get_plane_type(mst_output[i],
> +							DRM_PLANE_TYPE_PRIMARY);
> +		igt_create_color_fb(data->drm_fd,
> +				    mode[i]->hdisplay,
> +				    mode[i]->vdisplay,
> +				    DRM_FORMAT_XRGB8888,
> +				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
> +				    &fb[i]);
> +		igt_plane_set_fb(primary[i], &fb[i]);
> +	}
> +}
> +
> +static bool fit_modes_in_bw(data_t *data) {
> +	bool found;
> +	int ret;
> +
> +	if (!igt_display_try_commit2(&data->display, COMMIT_ATOMIC)) {
> +		igt_info("Modes overridden\n");
> +		found = igt_override_all_active_output_modes_to_fit_bw(&data->display);
> +                igt_require_f(found,
> +                              "No valid mode combo found for MST modeset\n");
> +                ret = igt_display_try_commit2(&data->display, COMMIT_ATOMIC);
> +                igt_require_f(ret == 0,
> +                              "Commit failure during MST modeset\n");
> +        }
> +        return true;
> +}
> +
> +static bool validate_modeset_mst_output(data_t *data,
> +					igt_output_t *mst_output[],
> +					int *dp_mst_outputs,
> +					drmModeModeInfo *mode[],
> +					struct igt_fb fb[],
> +					struct igt_plane *primary[])
> +{
> +
> +	igt_require_f(*dp_mst_outputs > 0, "No MST outputs found\n");
> +	setup_pipe_on_mst_outputs(data, mst_output, dp_mst_outputs);
> +	setup_modeset_on_mst_outputs(data, mst_output,
> +				     dp_mst_outputs,
> +				     mode, fb, primary);
> +	igt_assert_f(fit_modes_in_bw(data), "Unable to fit modes in bw\n");
> +	return true;
> +}
> +
> +static bool setup_mst(data_t *data, bool is_mst,
> +		      igt_output_t *mst_output[],
> +		      int *dp_mst_outputs, drmModeModeInfo *mode[],
> +		      struct igt_fb fb[], struct igt_plane *primary[]) {
> +	bool ret;
> +
> +	*dp_mst_outputs = 0;
> +	ret = setup_mst_outputs(data, mst_output, dp_mst_outputs);
> +	if (!ret) {
> +		igt_info("Skipping MST output %s as already tested\n",
> +			 igt_output_name(data->output));
> +		return false;
> +	}
> +
> +	ret = validate_modeset_mst_output(data, mst_output,
> +					  dp_mst_outputs, mode,
> +					  fb, primary);
> +	if (!ret) {
> +		igt_info("Skipping MST output %s as validpipe/output combo not found\n",
> +			 igt_output_name(data->output));
> +		return false;
> +	}
> +
> +	igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +	return true;
> +}
> +
> +static int check_condition_with_timeout(int drm_fd, igt_output_t *output,
> +					condition_check_fn check_fn,
> +					double interval, double timeout) {
> +	struct timespec start_time, current_time;
> +	double elapsed_time;
> +
> +	clock_gettime(CLOCK_MONOTONIC, &start_time);
> +
> +	while (1) {
> +		if (check_fn(drm_fd, output) == 0) {
> +			return 0;
> +		}
> +
> +		clock_gettime(CLOCK_MONOTONIC, &current_time);
> +		elapsed_time = (current_time.tv_sec - start_time.tv_sec) +
> +			(current_time.tv_nsec - start_time.tv_nsec) / 1e9;
> +
> +		if (elapsed_time >= timeout) {
> +			return -1;
> +		}
> +
> +		usleep((useconds_t)(interval * 1000000));
> +	}
> +}
> +
> +static void test_fallback(data_t *data, bool is_mst) {
> +	int dp_mst_outputs, retries;
> +	igt_output_t *mst_outputs[IGT_MAX_PIPES];
> +	enum dp_link_rate max_link_rate, curr_link_rate, prev_link_rate;
> +	enum dp_lane_count max_lane_count, curr_lane_count, prev_lane_count;
> +	uint32_t link_status_prop_id;
> +	uint64_t link_status_value;
> +	drmModeModeInfo *mst_modes[IGT_MAX_PIPES], *mode;
> +	drmModePropertyPtr link_status_prop;
> +	struct igt_fb mst_fbs[IGT_MAX_PIPES], fb;
> +	struct igt_plane *mst_primarys[IGT_MAX_PIPES], *primary;
> +	struct udev_monitor *mon;
> +
> +	igt_display_reset(&data->display);
> +	retries = SPURIOUS_HPD_RETRY;
> +
> +	if (is_mst) {
> +		if (!setup_mst(data, is_mst, mst_outputs,
> +			       &dp_mst_outputs, mst_modes, mst_fbs,
> +			       mst_primarys))
> +			return;
> +	} else {
> +		data->pipe = PIPE_A;
> +		igt_output_set_pipe(data->output, data->pipe);
> +		mode = igt_output_get_mode(data->output);
> +		primary = igt_output_get_plane_type(data->output,
> +						    DRM_PLANE_TYPE_PRIMARY);
> +		igt_create_color_fb(data->drm_fd,
> +				    mode->hdisplay, mode->vdisplay,
> +				    DRM_FORMAT_XRGB8888,
> +				    DRM_FORMAT_MOD_LINEAR, 0.0, 1.0, 0.0,
> +				    &fb);
> +		igt_plane_set_fb(primary, &fb);
> +		igt_display_commit2(&data->display, COMMIT_ATOMIC);
> +	}

Would be better to have a separate function for the above and make dp_mst_outputs more generic, also used for the non-MST case (adding to the array then only a single output).
----------------------------------------------------------------------------------------------
Ok sure will reuse the mst functions after renaming them

> +
> +	igt_info("Testing link training fallback on %s\n",
> +		 igt_output_name(data->output));
> +
> +	igt_reset_link_params(data->drm_fd, data->output);

Could this be done before the above setup part? Then the modes chosen there should be based already on the updated link params and the commit would also retrain the link if needed.
----------------------------------------------------------------------------------------------
Ok sure will do as suggested
> +	igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +						   data->output,
> +						   igt_get_dp_pending_retrain,
> +						   1.0, 20.0), 0);
> +
> +	max_link_rate = igt_get_dp_max_link_rate(data->drm_fd, data->output);
> +	max_lane_count = igt_get_dp_max_lane_count(data->drm_fd, 
> +data->output);
> +
> +	while (!igt_get_dp_link_retrain_disabled(data->drm_fd,
> +						 data->output)) {
> +

Extra w/s.
----------------------------------------------------------------------------------------------
Noted

> +		prev_link_rate = igt_get_dp_link_rate_set_for_output(data->drm_fd, data->output);
> +		prev_lane_count = 
> +igt_get_dp_lane_count_set_for_output(data->drm_fd, data->output);

Moving these before the loop would avoid the duplication wrt. setting them at the end of the loop.
----------------------------------------------------------------------------------------------
Right will move this out of the loop

> +
> +		igt_info("Current link rate: %s, Current lane count: %s\n",
> +			 str_link_rate(prev_link_rate),
> +			 str_lane_count(prev_lane_count));
> +		mon = igt_watch_uevents();
> +		igt_force_lt_failure(data->drm_fd, data->output,
> +				     LT_FAILURE_REDUCED_CAPS);
> +		igt_force_link_retrain(data->drm_fd, data->output,
> +				       RETRAIN_COUNT);
> +
> +		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +							   data->output,
> +							   igt_get_dp_pending_retrain,
> +							   1.0, 20.0), 0);
> +		igt_assert_eq(check_condition_with_timeout(data->drm_fd,
> +							   data->output,
> +							   igt_get_dp_pending_lt_failures,
> +							   1.0, 20.0), 0);
> +
> +		if (igt_get_dp_link_retrain_disabled(data->drm_fd,
> +						     data->output)) {
> +			igt_reset_connectors();
> +			return;
> +		}
> +
> +		igt_assert_f(igt_hotplug_detected(mon, 20),
> +			     "Didn't get hotplug for force link training failure\n");
> +
> +		kmstest_get_property(data->drm_fd,
> +				data->output->config.connector->connector_id,
> +				DRM_MODE_OBJECT_CONNECTOR, "link-status",
> +				&link_status_prop_id, &link_status_value,
> +				&link_status_prop);
> +
> +		igt_assert_eq(link_status_value, DRM_MODE_LINK_STATUS_BAD);
> +
> +		igt_flush_uevents(mon);
> +
> +		if (is_mst) {
> +			igt_assert_f(validate_modeset_mst_output(data,
> +								 mst_outputs,
> +								 &dp_mst_outputs,
> +								 mst_modes,
> +								 mst_fbs,
> +								 mst_primarys),
> +				     "MST modeset failed\n");
> +		} else {
> +			data->output->force_reprobe = true;
> +			igt_output_refresh(data->output);
> +			data->pipe = PIPE_A;
> +			igt_assert_f(fit_modes_in_bw(data),
> +				     "Unable to fit modes in bw\n");
> +
> +			igt_output_set_pipe(data->output, data->pipe);
> +			mode = igt_output_get_mode(data->output);
> +			igt_info("Mode %dx%d@%d on output %s\n",
> +				 mode->hdisplay, mode->vdisplay,
> +				 mode->vrefresh,
> +				 igt_output_name(data->output));
> +			primary = igt_output_get_plane_type(data->output,
> +							    DRM_PLANE_TYPE_PRIMARY);
> +			igt_create_color_fb(data->drm_fd,
> +					    mode->hdisplay,
> +					    mode->vdisplay,
> +					    DRM_FORMAT_XRGB8888,
> +					    DRM_FORMAT_MOD_LINEAR,
> +					    0.0, 1.0, 0.0, &fb);
> +			igt_plane_set_fb(primary, &fb);
> +		}

The above would be better in a separate function and make the MST and non-MST cases more unified. For instance setup_modeset_on_mst_outputs() looks quite similar to the above non-MST setup.[Joshi, Kunal1