[PATCH 0/4] drm/xe/rtp: WA table context testing

[PATCH 0/4] drm/xe/rtp: WA table context testing

[Violet Monti]

This series adds testing for existing WA lists within
drm/xe/xe_wa.c, which previously were allowed to match
rules for contexts that were not valid at their initialization
time.

These tests function by parsing each target RTP table,
checking for invalid contexts rules determined by an
enumeration of match types, and raises an expectation fail
if an improper match is found

Gustavo Sousa (1):
  drm/xe/rtp: Add struct types for RTP tables

Violet Monti (3):
  drm/xe/rtp: Add GT WAs rule checking
  drm/xe/rtp: Add OOB WAs rule checking
  drm/xe/rtp: Add Device OOB WA checks

 drivers/gpu/drm/xe/tests/Makefile             |   1 +
 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c | 133 ++++++++++++++++++
 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h |  35 +++++
 drivers/gpu/drm/xe/tests/xe_rtp_test.c        | 118 ++++++----------
 drivers/gpu/drm/xe/xe_hw_engine.c             |  14 +-
 drivers/gpu/drm/xe/xe_reg_whitelist.c         |   7 +-
 drivers/gpu/drm/xe/xe_rtp.c                   |  31 ++--
 drivers/gpu/drm/xe/xe_rtp.h                   |  16 ++-
 drivers/gpu/drm/xe/xe_rtp_types.h             |  10 ++
 drivers/gpu/drm/xe/xe_tuning.c                |  45 +++---
 drivers/gpu/drm/xe/xe_wa.c                    |  89 ++++++------
 drivers/gpu/drm/xe/xe_wa.h                    |   7 +
 12 files changed, 338 insertions(+), 168 deletions(-)
 create mode 100644 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
 create mode 100644 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h

-- 
2.43.0

[PATCH 1/4] drm/xe/rtp: Add struct types for RTP tables

[Violet Monti]

From: Gustavo Sousa <gustavo.sousa@intel.com>

We currently have a mixture of styles for our RTP tables with respect of
how we define the number of entries:

  * xe_rtp_process_to_sr() expects to receive the number of entries as
    arguments;
  * xe_rtp_process() expects the array to have a sentinel at the end of
    the array;
  * in xe_rtp_test.c, even though xe_rtp_process_to_sr() does not
    require a sentinel value, we need to rely on that technique to be
    able to count xe_rtp_entry_sr entries because simply using
    ARRAY_SIZE() is not possible.

The style used by xe_rtp_process_to_sr() makes it hard to share the
tables with other compilation units (e.g. kunit tests), since the number
of entries is calculated with ARRAY_SIZE(), which is done at compile
time.

Since we use the size of the tables to create some bitmasks, using a
sentinel style doesn't seem great either.

A way to reconcile things into a single style is to have a struct type
that would hold the entries array and the number of entries.  Since we
have xe_rtp_entry and xe_rtp_entry_sr, we would have one type for each.

The advantage of the proposed approach is that now we have a nice way to
share the tables directly to kunit tests with information about their
size.

Signed-off-by: Gustavo Sousa <gustavo.sousa@intel.com>
Signed-off-by: Violet Monti <violet.monti@intel.com>
---
 drivers/gpu/drm/xe/tests/xe_rtp_test.c | 118 ++++++++++---------------
 drivers/gpu/drm/xe/xe_hw_engine.c      |  14 ++-
 drivers/gpu/drm/xe/xe_reg_whitelist.c  |   7 +-
 drivers/gpu/drm/xe/xe_rtp.c            |  31 +++----
 drivers/gpu/drm/xe/xe_rtp.h            |  16 +++-
 drivers/gpu/drm/xe/xe_rtp_types.h      |  10 +++
 drivers/gpu/drm/xe/xe_tuning.c         |  45 +++++-----
 drivers/gpu/drm/xe/xe_wa.c             |  89 ++++++++++---------
 8 files changed, 162 insertions(+), 168 deletions(-)

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
index e5a0f985a700..e26b69a03cec 100644
--- a/drivers/gpu/drm/xe/tests/xe_rtp_test.c
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
@@ -39,13 +39,13 @@ struct rtp_to_sr_test_case {
 	unsigned long expected_count_sr_entries;
 	unsigned int expected_sr_errors;
 	unsigned long expected_active;
-	const struct xe_rtp_entry_sr *entries;
+	const struct xe_rtp_table_sr table;
 };
 
 struct rtp_test_case {
 	const char *name;
 	unsigned long expected_active;
-	const struct xe_rtp_entry *entries;
+	const struct xe_rtp_table table;
 };
 
 static bool match_yes(const struct xe_device *xe, const struct xe_gt *gt,
@@ -69,7 +69,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 		.expected_active = BIT(0) | BIT(1),
 		.expected_count_sr_entries = 1,
 		/* Different bits on the same register: create a single entry */
-		.entries = (const struct xe_rtp_entry_sr[]) {
+		.table = XE_RTP_TABLE_SR(
 			{ XE_RTP_NAME("basic-1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -78,8 +78,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(1)))
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "no-match-no-add",
@@ -89,7 +88,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 		.expected_active = BIT(0),
 		.expected_count_sr_entries = 1,
 		/* Don't coalesce second entry since rules don't match */
-		.entries = (const struct xe_rtp_entry_sr[]) {
+		.table = XE_RTP_TABLE_SR(
 			{ XE_RTP_NAME("basic-1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -98,8 +97,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 			  XE_RTP_RULES(FUNC(match_no)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(1)))
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "match-or",
@@ -108,7 +106,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 		.expected_clr_bits = REG_BIT(0) | REG_BIT(1) | REG_BIT(2),
 		.expected_active = BIT(0) | BIT(1) | BIT(2),
 		.expected_count_sr_entries = 1,
-		.entries = (const struct xe_rtp_entry_sr[]) {
+		.table = XE_RTP_TABLE_SR(
 			{ XE_RTP_NAME("first"),
 			  XE_RTP_RULES(FUNC(match_yes), OR, FUNC(match_no)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -127,14 +125,13 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 			  XE_RTP_RULES(FUNC(match_no), OR, FUNC(match_no)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(3)))
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "match-or-xfail",
 		.expected_reg = REGULAR_REG1,
 		.expected_count_sr_entries = 0,
-		.entries = (const struct xe_rtp_entry_sr[]) {
+		.table = XE_RTP_TABLE_SR(
 			{ XE_RTP_NAME("leading-or"),
 			  XE_RTP_RULES(OR, FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -152,8 +149,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 			  XE_RTP_RULES(FUNC(match_no), OR, OR, FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(2)))
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "no-match-no-add-multiple-rules",
@@ -163,7 +159,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 		.expected_active = BIT(0),
 		.expected_count_sr_entries = 1,
 		/* Don't coalesce second entry due to one of the rules */
-		.entries = (const struct xe_rtp_entry_sr[]) {
+		.table = XE_RTP_TABLE_SR(
 			{ XE_RTP_NAME("basic-1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -172,8 +168,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 			  XE_RTP_RULES(FUNC(match_yes), FUNC(match_no)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(1)))
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "two-regs-two-entries",
@@ -183,7 +178,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 		.expected_active = BIT(0) | BIT(1),
 		.expected_count_sr_entries = 2,
 		/* Same bits on different registers are not coalesced */
-		.entries = (const struct xe_rtp_entry_sr[]) {
+		.table = XE_RTP_TABLE_SR(
 			{ XE_RTP_NAME("basic-1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -192,8 +187,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG2, REG_BIT(0)))
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "clr-one-set-other",
@@ -203,7 +197,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 		.expected_active = BIT(0) | BIT(1),
 		.expected_count_sr_entries = 1,
 		/* Check clr vs set actions on different bits */
-		.entries = (const struct xe_rtp_entry_sr[]) {
+		.table = XE_RTP_TABLE_SR(
 			{ XE_RTP_NAME("basic-1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -212,8 +206,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(CLR(REGULAR_REG1, REG_BIT(1)))
 			},
-			{}
-		},
+		),
 	},
 	{
 #define TEMP_MASK	REG_GENMASK(10, 8)
@@ -225,14 +218,13 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 		.expected_active = BIT(0),
 		.expected_count_sr_entries = 1,
 		/* Check FIELD_SET works */
-		.entries = (const struct xe_rtp_entry_sr[]) {
+		.table = XE_RTP_TABLE_SR(
 			{ XE_RTP_NAME("basic-1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(FIELD_SET(REGULAR_REG1,
 						   TEMP_MASK, TEMP_FIELD))
 			},
-			{}
-		},
+		),
 #undef TEMP_MASK
 #undef TEMP_FIELD
 	},
@@ -244,7 +236,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 		.expected_active = BIT(0) | BIT(1),
 		.expected_count_sr_entries = 1,
 		.expected_sr_errors = 1,
-		.entries = (const struct xe_rtp_entry_sr[]) {
+		.table = XE_RTP_TABLE_SR(
 			{ XE_RTP_NAME("basic-1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -254,8 +246,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "conflict-not-disjoint",
@@ -265,7 +256,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 		.expected_active = BIT(0) | BIT(1),
 		.expected_count_sr_entries = 1,
 		.expected_sr_errors = 1,
-		.entries = (const struct xe_rtp_entry_sr[]) {
+		.table = XE_RTP_TABLE_SR(
 			{ XE_RTP_NAME("basic-1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -275,8 +266,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(CLR(REGULAR_REG1, REG_GENMASK(1, 0)))
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "conflict-reg-type",
@@ -286,7 +276,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 		.expected_active = BIT(0) | BIT(1) | BIT(2),
 		.expected_count_sr_entries = 1,
 		.expected_sr_errors = 2,
-		.entries = (const struct xe_rtp_entry_sr[]) {
+		.table = XE_RTP_TABLE_SR(
 			{ XE_RTP_NAME("basic-1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
@@ -301,8 +291,7 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 			  XE_RTP_RULES(FUNC(match_yes)),
 			  XE_RTP_ACTIONS(SET(MASKED_REG1, REG_BIT(0)))
 			},
-			{}
-		},
+		),
 	},
 };
 
@@ -314,16 +303,12 @@ static void xe_rtp_process_to_sr_tests(struct kunit *test)
 	struct xe_reg_sr *reg_sr = &gt->reg_sr;
 	const struct xe_reg_sr_entry *sre, *sr_entry = NULL;
 	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(gt);
-	unsigned long idx, count_sr_entries = 0, count_rtp_entries = 0, active = 0;
+	unsigned long idx, count_sr_entries = 0, active = 0;
 
 	xe_reg_sr_init(reg_sr, "xe_rtp_to_sr_tests", xe);
 
-	while (param->entries[count_rtp_entries].rules)
-		count_rtp_entries++;
-
-	xe_rtp_process_ctx_enable_active_tracking(&ctx, &active, count_rtp_entries);
-	xe_rtp_process_to_sr(&ctx, param->entries, count_rtp_entries,
-			     reg_sr, false);
+	xe_rtp_process_ctx_enable_active_tracking(&ctx, &active, param->table.n_entries);
+	xe_rtp_process_to_sr(&ctx, &param->table, reg_sr, false);
 
 	xa_for_each(&reg_sr->xa, idx, sre) {
 		if (idx == param->expected_reg.addr)
@@ -356,56 +341,52 @@ static const struct rtp_test_case rtp_cases[] = {
 	{
 		.name = "active1",
 		.expected_active = BIT(0),
-		.entries = (const struct xe_rtp_entry[]) {
+		.table = XE_RTP_TABLE(
 			{ XE_RTP_NAME("r1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "active2",
 		.expected_active = BIT(0) | BIT(1),
-		.entries = (const struct xe_rtp_entry[]) {
+		.table = XE_RTP_TABLE(
 			{ XE_RTP_NAME("r1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			},
 			{ XE_RTP_NAME("r2"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "active-inactive",
 		.expected_active = BIT(0),
-		.entries = (const struct xe_rtp_entry[]) {
+		.table = XE_RTP_TABLE(
 			{ XE_RTP_NAME("r1"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			},
 			{ XE_RTP_NAME("r2"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "inactive-active",
 		.expected_active = BIT(1),
-		.entries = (const struct xe_rtp_entry[]) {
+		.table = XE_RTP_TABLE(
 			{ XE_RTP_NAME("r1"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
 			{ XE_RTP_NAME("r2"),
 			  XE_RTP_RULES(FUNC(match_yes)),
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "inactive-1st_or_active-inactive",
 		.expected_active = BIT(1),
-		.entries = (const struct xe_rtp_entry[]) {
+		.table = XE_RTP_TABLE(
 			{ XE_RTP_NAME("r1"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
@@ -416,13 +397,12 @@ static const struct rtp_test_case rtp_cases[] = {
 			{ XE_RTP_NAME("r3"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "inactive-2nd_or_active-inactive",
 		.expected_active = BIT(1),
-		.entries = (const struct xe_rtp_entry[]) {
+		.table = XE_RTP_TABLE(
 			{ XE_RTP_NAME("r1"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
@@ -433,13 +413,12 @@ static const struct rtp_test_case rtp_cases[] = {
 			{ XE_RTP_NAME("r3"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "inactive-last_or_active-inactive",
 		.expected_active = BIT(1),
-		.entries = (const struct xe_rtp_entry[]) {
+		.table = XE_RTP_TABLE(
 			{ XE_RTP_NAME("r1"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
@@ -450,13 +429,12 @@ static const struct rtp_test_case rtp_cases[] = {
 			{ XE_RTP_NAME("r3"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
-			{}
-		},
+		),
 	},
 	{
 		.name = "inactive-no_or_active-inactive",
 		.expected_active = 0,
-		.entries = (const struct xe_rtp_entry[]) {
+		.table = XE_RTP_TABLE(
 			{ XE_RTP_NAME("r1"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
@@ -467,8 +445,7 @@ static const struct rtp_test_case rtp_cases[] = {
 			{ XE_RTP_NAME("r3"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
-			{}
-		},
+		),
 	},
 };
 
@@ -478,13 +455,10 @@ static void xe_rtp_process_tests(struct kunit *test)
 	struct xe_device *xe = test->priv;
 	struct xe_gt *gt = xe_device_get_root_tile(xe)->primary_gt;
 	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(gt);
-	unsigned long count_rtp_entries = 0, active = 0;
-
-	while (param->entries[count_rtp_entries].rules)
-		count_rtp_entries++;
+	unsigned long active = 0;
 
-	xe_rtp_process_ctx_enable_active_tracking(&ctx, &active, count_rtp_entries);
-	xe_rtp_process(&ctx, param->entries);
+	xe_rtp_process_ctx_enable_active_tracking(&ctx, &active, param->table.n_entries);
+	xe_rtp_process(&ctx, &param->table);
 
 	KUNIT_EXPECT_EQ(test, active, param->expected_active);
 }
diff --git a/drivers/gpu/drm/xe/xe_hw_engine.c b/drivers/gpu/drm/xe/xe_hw_engine.c
index 0f0e08bcc182..bc5e16de02fd 100644
--- a/drivers/gpu/drm/xe/xe_hw_engine.c
+++ b/drivers/gpu/drm/xe/xe_hw_engine.c
@@ -346,7 +346,7 @@ xe_hw_engine_setup_default_lrc_state(struct xe_hw_engine *hwe)
 	u32 blit_cctl_val = REG_FIELD_PREP(BLIT_CCTL_DST_MOCS_MASK, mocs_write_idx) |
 			    REG_FIELD_PREP(BLIT_CCTL_SRC_MOCS_MASK, mocs_read_idx);
 	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(hwe);
-	const struct xe_rtp_entry_sr lrc_setup[] = {
+	const struct xe_rtp_table_sr lrc_setup = XE_RTP_TABLE_SR(
 		/*
 		 * Some blitter commands do not have a field for MOCS, those
 		 * commands will use MOCS index pointed by BLIT_CCTL.
@@ -369,10 +369,9 @@ xe_hw_engine_setup_default_lrc_state(struct xe_hw_engine *hwe)
 					   PREEMPT_GPGPU_THREAD_GROUP_LEVEL)),
 		  XE_RTP_ENTRY_FLAG(FOREACH_ENGINE)
 		},
-	};
+	);
 
-	xe_rtp_process_to_sr(&ctx, lrc_setup, ARRAY_SIZE(lrc_setup),
-			     &hwe->reg_lrc, true);
+	xe_rtp_process_to_sr(&ctx, &lrc_setup, &hwe->reg_lrc, true);
 }
 
 static void
@@ -397,7 +396,7 @@ hw_engine_setup_default_state(struct xe_hw_engine *hwe)
 	u32 ring_cmd_cctl_val = REG_FIELD_PREP(CMD_CCTL_WRITE_OVERRIDE_MASK, mocs_write_idx) |
 				REG_FIELD_PREP(CMD_CCTL_READ_OVERRIDE_MASK, mocs_read_idx);
 	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(hwe);
-	const struct xe_rtp_entry_sr engine_entries[] = {
+	const struct xe_rtp_table_sr engine_sr = XE_RTP_TABLE_SR(
 		{ XE_RTP_NAME("RING_CMD_CCTL_default_MOCS"),
 		  XE_RTP_RULES(FUNC(xe_rtp_match_always)),
 		  XE_RTP_ACTIONS(FIELD_SET(RING_CMD_CCTL(0),
@@ -454,10 +453,9 @@ hw_engine_setup_default_state(struct xe_hw_engine *hwe)
 		  XE_RTP_ACTIONS(SET(GFX_MODE(0), GFX_MSIX_INTERRUPT_ENABLE,
 				     XE_RTP_ACTION_FLAG(ENGINE_BASE)))
 		},
-	};
+	);
 
-	xe_rtp_process_to_sr(&ctx, engine_entries, ARRAY_SIZE(engine_entries),
-			     &hwe->reg_sr, false);
+	xe_rtp_process_to_sr(&ctx, &engine_sr, &hwe->reg_sr, false);
 }
 
 static const struct engine_info *find_engine_info(enum xe_engine_class class, int instance)
diff --git a/drivers/gpu/drm/xe/xe_reg_whitelist.c b/drivers/gpu/drm/xe/xe_reg_whitelist.c
index fb65940848d7..2e84b1c49f37 100644
--- a/drivers/gpu/drm/xe/xe_reg_whitelist.c
+++ b/drivers/gpu/drm/xe/xe_reg_whitelist.c
@@ -41,7 +41,7 @@ static bool match_multi_queue_class(const struct xe_device *xe,
 	return xe_gt_supports_multi_queue(gt, hwe->class);
 }
 
-static const struct xe_rtp_entry_sr register_whitelist[] = {
+static const struct xe_rtp_table_sr register_whitelist = XE_RTP_TABLE_SR(
 	{ XE_RTP_NAME("WaAllowPMDepthAndInvocationCountAccessFromUMD, 1408556865"),
 	  XE_RTP_RULES(GRAPHICS_VERSION_RANGE(1200, 1210), ENGINE_CLASS(RENDER)),
 	  XE_RTP_ACTIONS(WHITELIST(PS_INVOCATION_COUNT,
@@ -154,7 +154,7 @@ static const struct xe_rtp_entry_sr register_whitelist[] = {
 	  XE_RTP_RULES(FUNC(match_has_mert), ENGINE_CLASS(COPY)),
 	  XE_RTP_ACTIONS(WHITELIST_OA_MERT_MMIO_TRG)
 	},
-};
+);
 
 static void whitelist_apply_to_hwe(struct xe_hw_engine *hwe)
 {
@@ -202,8 +202,7 @@ void xe_reg_whitelist_process_engine(struct xe_hw_engine *hwe)
 {
 	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(hwe);
 
-	xe_rtp_process_to_sr(&ctx, register_whitelist, ARRAY_SIZE(register_whitelist),
-			     &hwe->reg_whitelist, false);
+	xe_rtp_process_to_sr(&ctx, &register_whitelist, &hwe->reg_whitelist, false);
 	whitelist_apply_to_hwe(hwe);
 }
 
diff --git a/drivers/gpu/drm/xe/xe_rtp.c b/drivers/gpu/drm/xe/xe_rtp.c
index 1a4dcbbbc176..90bbba079260 100644
--- a/drivers/gpu/drm/xe/xe_rtp.c
+++ b/drivers/gpu/drm/xe/xe_rtp.c
@@ -273,8 +273,7 @@ static void rtp_mark_active(struct xe_device *xe,
  * xe_rtp_process_to_sr - Process all rtp @entries, adding the matching ones to
  *                        the save-restore argument.
  * @ctx: The context for processing the table, with one of device, gt or hwe
- * @entries: Table with RTP definitions
- * @n_entries: Number of entries to process, usually ARRAY_SIZE(entries)
+ * @table: Table with RTP definitions
  * @sr: Save-restore struct where matching rules execute the action. This can be
  *      viewed as the "coalesced view" of multiple the tables. The bits for each
  *      register set are expected not to collide with previously added entries
@@ -286,12 +285,10 @@ static void rtp_mark_active(struct xe_device *xe,
  * used to calculate the right register offset
  */
 void xe_rtp_process_to_sr(struct xe_rtp_process_ctx *ctx,
-			  const struct xe_rtp_entry_sr *entries,
-			  size_t n_entries,
+			  const struct xe_rtp_table_sr *table,
 			  struct xe_reg_sr *sr,
 			  bool process_in_vf)
 {
-	const struct xe_rtp_entry_sr *entry;
 	struct xe_hw_engine *hwe = NULL;
 	struct xe_gt *gt = NULL;
 	struct xe_device *xe = NULL;
@@ -301,9 +298,10 @@ void xe_rtp_process_to_sr(struct xe_rtp_process_ctx *ctx,
 	if (!process_in_vf && IS_SRIOV_VF(xe))
 		return;
 
-	xe_assert(xe, entries);
+	xe_assert(xe, table->entries);
 
-	for (entry = entries; entry - entries < n_entries; entry++) {
+	for (size_t i = 0; i < table->n_entries; i++) {
+		const struct xe_rtp_entry_sr *entry = &table->entries[i];
 		bool match = false;
 
 		if (entry->flags & XE_RTP_ENTRY_FLAG_FOREACH_ENGINE) {
@@ -318,37 +316,40 @@ void xe_rtp_process_to_sr(struct xe_rtp_process_ctx *ctx,
 		}
 
 		if (match)
-			rtp_mark_active(xe, ctx, entry - entries);
+			rtp_mark_active(xe, ctx, i);
 	}
 }
 EXPORT_SYMBOL_IF_KUNIT(xe_rtp_process_to_sr);
 
 /**
- * xe_rtp_process - Process all rtp @entries, without running any action
+ * xe_rtp_process - Process all entries in rtp @table, without running any action
  * @ctx: The context for processing the table, with one of device, gt or hwe
- * @entries: Table with RTP definitions
+ * @table: Table with RTP definitions
  *
- * Walk the table pointed by @entries (with an empty sentinel), executing the
+ * Walk the table pointed by @table, executing the
  * rules. One difference from xe_rtp_process_to_sr(): there is no action
  * associated with each entry since this uses struct xe_rtp_entry. Its main use
  * is for marking active workarounds via
  * xe_rtp_process_ctx_enable_active_tracking().
  */
 void xe_rtp_process(struct xe_rtp_process_ctx *ctx,
-		    const struct xe_rtp_entry *entries)
+		    const struct xe_rtp_table *table)
 {
-	const struct xe_rtp_entry *entry;
 	struct xe_hw_engine *hwe;
 	struct xe_gt *gt;
 	struct xe_device *xe;
 
 	rtp_get_context(ctx, &hwe, &gt, &xe);
 
-	for (entry = entries; entry && entry->rules; entry++) {
+	xe_assert(xe, table->entries);
+
+	for (size_t i = 0; i < table->n_entries; i++) {
+		const struct xe_rtp_entry *entry = &table->entries[i];
+
 		if (!rule_matches(xe, gt, hwe, entry->rules, entry->n_rules))
 			continue;
 
-		rtp_mark_active(xe, ctx, entry - entries);
+		rtp_mark_active(xe, ctx, i);
 	}
 }
 EXPORT_SYMBOL_IF_KUNIT(xe_rtp_process);
diff --git a/drivers/gpu/drm/xe/xe_rtp.h b/drivers/gpu/drm/xe/xe_rtp.h
index 562082b18d7b..40c41cf9304f 100644
--- a/drivers/gpu/drm/xe/xe_rtp.h
+++ b/drivers/gpu/drm/xe/xe_rtp.h
@@ -440,6 +440,16 @@ struct xe_reg_sr;
 		XE_RTP_PASTE_FOREACH(ACTION_, COMMA, (__VA_ARGS__))	\
 	}
 
+#define XE_RTP_TABLE_SR(...) { \
+	.entries = (const struct xe_rtp_entry_sr[]){__VA_ARGS__}, \
+	.n_entries = ARRAY_SIZE(((const struct xe_rtp_entry_sr[]){__VA_ARGS__})), \
+}
+
+#define XE_RTP_TABLE(...) { \
+	.entries = (const struct xe_rtp_entry[]){__VA_ARGS__}, \
+	.n_entries = ARRAY_SIZE(((const struct xe_rtp_entry[]){__VA_ARGS__})), \
+}
+
 #define XE_RTP_PROCESS_CTX_INITIALIZER(arg__) _Generic((arg__),							\
 	struct xe_hw_engine * :	(struct xe_rtp_process_ctx){ { (void *)(arg__) }, XE_RTP_PROCESS_TYPE_ENGINE },	\
 	struct xe_gt * :	(struct xe_rtp_process_ctx){ { (void *)(arg__) }, XE_RTP_PROCESS_TYPE_GT },	\
@@ -450,12 +460,12 @@ void xe_rtp_process_ctx_enable_active_tracking(struct xe_rtp_process_ctx *ctx,
 					       size_t n_entries);
 
 void xe_rtp_process_to_sr(struct xe_rtp_process_ctx *ctx,
-			  const struct xe_rtp_entry_sr *entries,
-			  size_t n_entries, struct xe_reg_sr *sr,
+			  const struct xe_rtp_table_sr *table,
+			  struct xe_reg_sr *sr,
 			  bool process_in_vf);
 
 void xe_rtp_process(struct xe_rtp_process_ctx *ctx,
-		    const struct xe_rtp_entry *entries);
+		    const struct xe_rtp_table *table);
 
 /* Match functions to be used with XE_RTP_MATCH_FUNC */
 
diff --git a/drivers/gpu/drm/xe/xe_rtp_types.h b/drivers/gpu/drm/xe/xe_rtp_types.h
index 0265c16d2762..58018ae4f8cc 100644
--- a/drivers/gpu/drm/xe/xe_rtp_types.h
+++ b/drivers/gpu/drm/xe/xe_rtp_types.h
@@ -112,6 +112,16 @@ struct xe_rtp_entry {
 	u8 n_rules;
 };
 
+struct xe_rtp_table_sr {
+	const struct xe_rtp_entry_sr *entries;
+	size_t n_entries;
+};
+
+struct xe_rtp_table {
+	const struct xe_rtp_entry *entries;
+	size_t n_entries;
+};
+
 enum xe_rtp_process_type {
 	XE_RTP_PROCESS_TYPE_DEVICE,
 	XE_RTP_PROCESS_TYPE_GT,
diff --git a/drivers/gpu/drm/xe/xe_tuning.c b/drivers/gpu/drm/xe/xe_tuning.c
index ce39b77a084a..752ea4e47cbb 100644
--- a/drivers/gpu/drm/xe/xe_tuning.c
+++ b/drivers/gpu/drm/xe/xe_tuning.c
@@ -20,7 +20,7 @@
 #undef XE_REG_MCR
 #define XE_REG_MCR(...)     XE_REG(__VA_ARGS__, .mcr = 1)
 
-static const struct xe_rtp_entry_sr gt_tunings[] = {
+static const struct xe_rtp_table_sr gt_tunings = XE_RTP_TABLE_SR(
 	{ XE_RTP_NAME("Tuning: Blend Fill Caching Optimization Disable"),
 	  XE_RTP_RULES(PLATFORM(DG2)),
 	  XE_RTP_ACTIONS(SET(XEHP_L3SCQREG7, BLEND_FILL_CACHING_OPT_DIS))
@@ -100,9 +100,9 @@ static const struct xe_rtp_entry_sr gt_tunings[] = {
 	  XE_RTP_ACTIONS(FIELD_SET(GAMSTLB_CTRL, BANK_HASH_MODE,
 				   BANK_HASH_4KB_MODE))
 	},
-};
+);
 
-static const struct xe_rtp_entry_sr engine_tunings[] = {
+static const struct xe_rtp_table_sr engine_tunings = XE_RTP_TABLE_SR(
 	{ XE_RTP_NAME("Tuning: L3 Hashing Mask"),
 	  XE_RTP_RULES(GRAPHICS_VERSION_RANGE(1200, 1210),
 		       FUNC(xe_rtp_match_first_render_or_compute)),
@@ -129,9 +129,9 @@ static const struct xe_rtp_entry_sr engine_tunings[] = {
 		       FUNC(xe_rtp_match_first_render_or_compute)),
 	  XE_RTP_ACTIONS(SET(TDL_TSL_CHICKEN2, TILEY_LOCALID))
 	},
-};
+);
 
-static const struct xe_rtp_entry_sr lrc_tunings[] = {
+static const struct xe_rtp_table_sr lrc_tunings = XE_RTP_TABLE_SR(
 	{ XE_RTP_NAME("Tuning: Windower HW Filtering"),
 	  XE_RTP_RULES(GRAPHICS_VERSION_RANGE(3000, 3599), ENGINE_CLASS(RENDER)),
 	  XE_RTP_ACTIONS(SET(COMMON_SLICE_CHICKEN4, HW_FILTERING))
@@ -171,7 +171,7 @@ static const struct xe_rtp_entry_sr lrc_tunings[] = {
 	  XE_RTP_ACTIONS(FIELD_SET(FF_MODE, VS_HIT_MAX_VALUE_MASK,
 				   REG_FIELD_PREP(VS_HIT_MAX_VALUE_MASK, 0x3f)))
 	},
-};
+);
 
 /**
  * xe_tuning_init - initialize gt with tunings bookkeeping
@@ -185,9 +185,9 @@ int xe_tuning_init(struct xe_gt *gt)
 	size_t n_lrc, n_engine, n_gt, total;
 	unsigned long *p;
 
-	n_gt = BITS_TO_LONGS(ARRAY_SIZE(gt_tunings));
-	n_engine = BITS_TO_LONGS(ARRAY_SIZE(engine_tunings));
-	n_lrc = BITS_TO_LONGS(ARRAY_SIZE(lrc_tunings));
+	n_gt = BITS_TO_LONGS(gt_tunings.n_entries);
+	n_engine = BITS_TO_LONGS(engine_tunings.n_entries);
+	n_lrc = BITS_TO_LONGS(lrc_tunings.n_entries);
 	total = n_gt + n_engine + n_lrc;
 
 	p = drmm_kzalloc(&xe->drm, sizeof(*p) * total, GFP_KERNEL);
@@ -210,9 +210,8 @@ void xe_tuning_process_gt(struct xe_gt *gt)
 
 	xe_rtp_process_ctx_enable_active_tracking(&ctx,
 						  gt->tuning_active.gt,
-						  ARRAY_SIZE(gt_tunings));
-	xe_rtp_process_to_sr(&ctx, gt_tunings, ARRAY_SIZE(gt_tunings),
-			     &gt->reg_sr, false);
+						  gt_tunings.n_entries);
+	xe_rtp_process_to_sr(&ctx, &gt_tunings, &gt->reg_sr, false);
 }
 EXPORT_SYMBOL_IF_KUNIT(xe_tuning_process_gt);
 
@@ -222,9 +221,8 @@ void xe_tuning_process_engine(struct xe_hw_engine *hwe)
 
 	xe_rtp_process_ctx_enable_active_tracking(&ctx,
 						  hwe->gt->tuning_active.engine,
-						  ARRAY_SIZE(engine_tunings));
-	xe_rtp_process_to_sr(&ctx, engine_tunings, ARRAY_SIZE(engine_tunings),
-			     &hwe->reg_sr, false);
+						  engine_tunings.n_entries);
+	xe_rtp_process_to_sr(&ctx, &engine_tunings, &hwe->reg_sr, false);
 }
 EXPORT_SYMBOL_IF_KUNIT(xe_tuning_process_engine);
 
@@ -242,9 +240,8 @@ void xe_tuning_process_lrc(struct xe_hw_engine *hwe)
 
 	xe_rtp_process_ctx_enable_active_tracking(&ctx,
 						  hwe->gt->tuning_active.lrc,
-						  ARRAY_SIZE(lrc_tunings));
-	xe_rtp_process_to_sr(&ctx, lrc_tunings, ARRAY_SIZE(lrc_tunings),
-			     &hwe->reg_lrc, true);
+						  lrc_tunings.n_entries);
+	xe_rtp_process_to_sr(&ctx, &lrc_tunings, &hwe->reg_lrc, true);
 }
 
 /**
@@ -259,18 +256,18 @@ int xe_tuning_dump(struct xe_gt *gt, struct drm_printer *p)
 	size_t idx;
 
 	drm_printf(p, "GT Tunings\n");
-	for_each_set_bit(idx, gt->tuning_active.gt, ARRAY_SIZE(gt_tunings))
-		drm_printf_indent(p, 1, "%s\n", gt_tunings[idx].name);
+	for_each_set_bit(idx, gt->tuning_active.gt, gt_tunings.n_entries)
+		drm_printf_indent(p, 1, "%s\n", gt_tunings.entries[idx].name);
 
 	drm_puts(p, "\n");
 	drm_printf(p, "Engine Tunings\n");
-	for_each_set_bit(idx, gt->tuning_active.engine, ARRAY_SIZE(engine_tunings))
-		drm_printf_indent(p, 1, "%s\n", engine_tunings[idx].name);
+	for_each_set_bit(idx, gt->tuning_active.engine, engine_tunings.n_entries)
+		drm_printf_indent(p, 1, "%s\n", engine_tunings.entries[idx].name);
 
 	drm_puts(p, "\n");
 	drm_printf(p, "LRC Tunings\n");
-	for_each_set_bit(idx, gt->tuning_active.lrc, ARRAY_SIZE(lrc_tunings))
-		drm_printf_indent(p, 1, "%s\n", lrc_tunings[idx].name);
+	for_each_set_bit(idx, gt->tuning_active.lrc, lrc_tunings.n_entries)
+		drm_printf_indent(p, 1, "%s\n", lrc_tunings.entries[idx].name);
 
 	return 0;
 }
diff --git a/drivers/gpu/drm/xe/xe_wa.c b/drivers/gpu/drm/xe/xe_wa.c
index 49f5e3e4c7cc..39c507edb8ce 100644
--- a/drivers/gpu/drm/xe/xe_wa.c
+++ b/drivers/gpu/drm/xe/xe_wa.c
@@ -130,7 +130,7 @@
 __diag_push();
 __diag_ignore_all("-Woverride-init", "Allow field overrides in table");
 
-static const struct xe_rtp_entry_sr gt_was[] = {
+static const struct xe_rtp_table_sr gt_was = XE_RTP_TABLE_SR(
 	/* Workarounds applying over a range of IPs */
 
 	{ XE_RTP_NAME("14011060649"),
@@ -306,9 +306,9 @@ static const struct xe_rtp_entry_sr gt_was[] = {
 	  XE_RTP_RULES(GRAPHICS_VERSION(3510), GRAPHICS_STEP(A0, B0)),
 	  XE_RTP_ACTIONS(SET(GUC_INTR_CHICKEN, DISABLE_SIGNALING_ENGINES))
 	},
-};
+);
 
-static const struct xe_rtp_entry_sr engine_was[] = {
+static const struct xe_rtp_table_sr engine_was = XE_RTP_TABLE_SR(
 	/* Workarounds applying over a range of IPs */
 
 	{ XE_RTP_NAME("22010931296, 18011464164, 14010919138"),
@@ -614,9 +614,9 @@ static const struct xe_rtp_entry_sr engine_was[] = {
 		       FUNC(xe_rtp_match_first_render_or_compute)),
 	  XE_RTP_ACTIONS(SET(TDL_CHICKEN, BIT_APQ_OPT_DIS))
 	},
-};
+);
 
-static const struct xe_rtp_entry_sr lrc_was[] = {
+static const struct xe_rtp_table_sr lrc_was = XE_RTP_TABLE_SR(
 	{ XE_RTP_NAME("16011163337"),
 	  XE_RTP_RULES(GRAPHICS_VERSION_RANGE(1200, 1210), ENGINE_CLASS(RENDER)),
 	  /* read verification is ignored due to 1608008084. */
@@ -794,21 +794,29 @@ static const struct xe_rtp_entry_sr lrc_was[] = {
 		       ENGINE_CLASS(RENDER)),
 	  XE_RTP_ACTIONS(SET(CHICKEN_RASTER_1, DIS_CLIP_NEGATIVE_BOUNDING_BOX))
 	},
-};
+);
 
-static __maybe_unused const struct xe_rtp_entry oob_was[] = {
+static const struct xe_rtp_entry oob_was_entries[] = {
 #include <generated/xe_wa_oob.c>
-	{}
 };
 
-static_assert(ARRAY_SIZE(oob_was) - 1 == _XE_WA_OOB_COUNT);
+static_assert(ARRAY_SIZE(oob_was_entries)  == _XE_WA_OOB_COUNT);
 
-static __maybe_unused const struct xe_rtp_entry device_oob_was[] = {
+static __maybe_unused const struct xe_rtp_table oob_was = {
+	.entries = oob_was_entries,
+	.n_entries = ARRAY_SIZE(oob_was_entries),
+};
+
+static const struct xe_rtp_entry device_oob_was_entries[] = {
 #include <generated/xe_device_wa_oob.c>
-	{}
 };
 
-static_assert(ARRAY_SIZE(device_oob_was) - 1 == _XE_DEVICE_WA_OOB_COUNT);
+static_assert(ARRAY_SIZE(device_oob_was_entries) == _XE_DEVICE_WA_OOB_COUNT);
+
+static __maybe_unused const struct xe_rtp_table device_oob_was = {
+	.entries = device_oob_was_entries,
+	.n_entries = ARRAY_SIZE(device_oob_was_entries),
+};
 
 __diag_pop();
 
@@ -824,10 +832,10 @@ void xe_wa_process_device_oob(struct xe_device *xe)
 {
 	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(xe);
 
-	xe_rtp_process_ctx_enable_active_tracking(&ctx, xe->wa_active.oob, ARRAY_SIZE(device_oob_was));
+	xe_rtp_process_ctx_enable_active_tracking(&ctx, xe->wa_active.oob, device_oob_was.n_entries);
 
 	xe->wa_active.oob_initialized = true;
-	xe_rtp_process(&ctx, device_oob_was);
+	xe_rtp_process(&ctx, &device_oob_was);
 }
 
 /**
@@ -842,9 +850,9 @@ void xe_wa_process_gt_oob(struct xe_gt *gt)
 	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(gt);
 
 	xe_rtp_process_ctx_enable_active_tracking(&ctx, gt->wa_active.oob,
-						  ARRAY_SIZE(oob_was));
+						  oob_was.n_entries);
 	gt->wa_active.oob_initialized = true;
-	xe_rtp_process(&ctx, oob_was);
+	xe_rtp_process(&ctx, &oob_was);
 }
 
 /**
@@ -859,9 +867,8 @@ void xe_wa_process_gt(struct xe_gt *gt)
 	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(gt);
 
 	xe_rtp_process_ctx_enable_active_tracking(&ctx, gt->wa_active.gt,
-						  ARRAY_SIZE(gt_was));
-	xe_rtp_process_to_sr(&ctx, gt_was, ARRAY_SIZE(gt_was),
-			     &gt->reg_sr, false);
+						  gt_was.n_entries);
+	xe_rtp_process_to_sr(&ctx, &gt_was, &gt->reg_sr, false);
 }
 EXPORT_SYMBOL_IF_KUNIT(xe_wa_process_gt);
 
@@ -878,9 +885,8 @@ void xe_wa_process_engine(struct xe_hw_engine *hwe)
 	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(hwe);
 
 	xe_rtp_process_ctx_enable_active_tracking(&ctx, hwe->gt->wa_active.engine,
-						  ARRAY_SIZE(engine_was));
-	xe_rtp_process_to_sr(&ctx, engine_was, ARRAY_SIZE(engine_was),
-			     &hwe->reg_sr, false);
+						  engine_was.n_entries);
+	xe_rtp_process_to_sr(&ctx, &engine_was, &hwe->reg_sr, false);
 }
 
 /**
@@ -896,9 +902,8 @@ void xe_wa_process_lrc(struct xe_hw_engine *hwe)
 	struct xe_rtp_process_ctx ctx = XE_RTP_PROCESS_CTX_INITIALIZER(hwe);
 
 	xe_rtp_process_ctx_enable_active_tracking(&ctx, hwe->gt->wa_active.lrc,
-						  ARRAY_SIZE(lrc_was));
-	xe_rtp_process_to_sr(&ctx, lrc_was, ARRAY_SIZE(lrc_was),
-			     &hwe->reg_lrc, true);
+						  lrc_was.n_entries);
+	xe_rtp_process_to_sr(&ctx, &lrc_was, &hwe->reg_lrc, true);
 }
 
 /**
@@ -912,7 +917,7 @@ int xe_wa_device_init(struct xe_device *xe)
 	unsigned long *p;
 
 	p = drmm_kzalloc(&xe->drm,
-			 sizeof(*p) * BITS_TO_LONGS(ARRAY_SIZE(device_oob_was)),
+			 sizeof(*p) * BITS_TO_LONGS(device_oob_was.n_entries),
 			 GFP_KERNEL);
 
 	if (!p)
@@ -935,10 +940,10 @@ int xe_wa_gt_init(struct xe_gt *gt)
 	size_t n_oob, n_lrc, n_engine, n_gt, total;
 	unsigned long *p;
 
-	n_gt = BITS_TO_LONGS(ARRAY_SIZE(gt_was));
-	n_engine = BITS_TO_LONGS(ARRAY_SIZE(engine_was));
-	n_lrc = BITS_TO_LONGS(ARRAY_SIZE(lrc_was));
-	n_oob = BITS_TO_LONGS(ARRAY_SIZE(oob_was));
+	n_gt = BITS_TO_LONGS(gt_was.n_entries);
+	n_engine = BITS_TO_LONGS(engine_was.n_entries);
+	n_lrc = BITS_TO_LONGS(lrc_was.n_entries);
+	n_oob = BITS_TO_LONGS(oob_was.n_entries);
 	total = n_gt + n_engine + n_lrc + n_oob;
 
 	p = drmm_kzalloc(&xe->drm, sizeof(*p) * total, GFP_KERNEL);
@@ -962,9 +967,9 @@ void xe_wa_device_dump(struct xe_device *xe, struct drm_printer *p)
 	size_t idx;
 
 	drm_printf(p, "Device OOB Workarounds\n");
-	for_each_set_bit(idx, xe->wa_active.oob, ARRAY_SIZE(device_oob_was))
-		if (device_oob_was[idx].name)
-			drm_printf_indent(p, 1, "%s\n", device_oob_was[idx].name);
+	for_each_set_bit(idx, xe->wa_active.oob, device_oob_was.n_entries)
+		if (device_oob_was.entries[idx].name)
+			drm_printf_indent(p, 1, "%s\n", device_oob_was.entries[idx].name);
 }
 
 /**
@@ -979,24 +984,24 @@ int xe_wa_gt_dump(struct xe_gt *gt, struct drm_printer *p)
 	size_t idx;
 
 	drm_printf(p, "GT Workarounds\n");
-	for_each_set_bit(idx, gt->wa_active.gt, ARRAY_SIZE(gt_was))
-		drm_printf_indent(p, 1, "%s\n", gt_was[idx].name);
+	for_each_set_bit(idx, gt->wa_active.gt, gt_was.n_entries)
+		drm_printf_indent(p, 1, "%s\n", gt_was.entries[idx].name);
 
 	drm_puts(p, "\n");
 	drm_printf(p, "Engine Workarounds\n");
-	for_each_set_bit(idx, gt->wa_active.engine, ARRAY_SIZE(engine_was))
-		drm_printf_indent(p, 1, "%s\n", engine_was[idx].name);
+	for_each_set_bit(idx, gt->wa_active.engine, engine_was.n_entries)
+		drm_printf_indent(p, 1, "%s\n", engine_was.entries[idx].name);
 
 	drm_puts(p, "\n");
 	drm_printf(p, "LRC Workarounds\n");
-	for_each_set_bit(idx, gt->wa_active.lrc, ARRAY_SIZE(lrc_was))
-		drm_printf_indent(p, 1, "%s\n", lrc_was[idx].name);
+	for_each_set_bit(idx, gt->wa_active.lrc, lrc_was.n_entries)
+		drm_printf_indent(p, 1, "%s\n", lrc_was.entries[idx].name);
 
 	drm_puts(p, "\n");
 	drm_printf(p, "OOB Workarounds\n");
-	for_each_set_bit(idx, gt->wa_active.oob, ARRAY_SIZE(oob_was))
-		if (oob_was[idx].name)
-			drm_printf_indent(p, 1, "%s\n", oob_was[idx].name);
+	for_each_set_bit(idx, gt->wa_active.oob, oob_was.n_entries)
+		if (oob_was.entries[idx].name)
+			drm_printf_indent(p, 1, "%s\n", oob_was.entries[idx].name);
 	return 0;
 }
 
-- 
2.43.0

[PATCH 2/4] drm/xe/rtp: Add GT WAs rule checking

[Violet Monti]

It is currently possible for a RTP rule, and subsequently a workaround,
to expect contexts that may not be present when the workaround is
applied. For example, the workarounds in the engine_was[] in drm/xe/xe_wa.c
expect an engine entity to be active. Conversely, the gt_was[] is not
depending on an engine entity to implement its workarounds. This kunit
test addition checks the gt_was[] workaround list for any workarounds
with specifically an engine_class rule. If a workaround does have an
engine_class rule, the workaround is then checked for the
"FOREACH_ENGINE" flag, which ensures the workaround is not implemented
in an improper context.

The result of this test is an expectation failure if a workaround has an
improper engine_class rule, and aims to prevent future issues of
gt_was being applied without proper contexts.

Signed-off-by: Violet Monti <violet.monti@intel.com>
---
 drivers/gpu/drm/xe/tests/Makefile             |  1 +
 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c | 76 +++++++++++++++++++
 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h | 24 ++++++
 drivers/gpu/drm/xe/xe_wa.c                    |  2 +-
 drivers/gpu/drm/xe/xe_wa.h                    |  5 ++
 5 files changed, 107 insertions(+), 1 deletion(-)
 create mode 100644 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
 create mode 100644 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h

diff --git a/drivers/gpu/drm/xe/tests/Makefile b/drivers/gpu/drm/xe/tests/Makefile
index 0e3408f4952c..f7aa47f11a36 100644
--- a/drivers/gpu/drm/xe/tests/Makefile
+++ b/drivers/gpu/drm/xe/tests/Makefile
@@ -9,5 +9,6 @@ obj-$(CONFIG_DRM_XE_KUNIT_TEST) += xe_test.o
 xe_test-y = xe_test_mod.o \
 	xe_args_test.o \
 	xe_pci_test.o \
+	xe_rtp_tables_test.o \
 	xe_rtp_test.o \
 	xe_wa_test.o
diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
new file mode 100644
index 000000000000..100cac379b08
--- /dev/null
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright © 2026 Intel Corporation
+ */
+
+#include <drm/drm_kunit_helpers.h>
+
+#include "xe_kunit_helpers.h"
+#include "xe_pci_test.h"
+#include "xe_rtp.h"
+#include "xe_rtp_tables_test.h"
+#include "xe_wa.h"
+
+static void xe_rtp_table_gt_test(struct kunit *test)
+{
+	const struct xe_rtp_entry_sr *param = test->param_value;
+
+	for (int i = 0; i < param->n_rules; i++) {
+		if (param->rules[i].match_type == XE_RTP_MATCH_ENGINE_CLASS)
+			KUNIT_EXPECT_EQ_MSG(test, param->flags,
+					    XE_RTP_ENTRY_FLAG_FOREACH_ENGINE,
+					    "GT WA %s has an invalid engine class rule setup",
+					    param->name);
+	}
+}
+
+static int xe_rtp_table_test_init(struct kunit *test)
+{
+	struct xe_device *xe;
+	struct device *dev;
+	int ret;
+
+	dev = drm_kunit_helper_alloc_device(test);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
+
+	xe = xe_kunit_helper_alloc_xe_device(test, dev);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, xe);
+
+	/* Initialize an empty device */
+	test->priv = NULL;
+
+	ret = xe_pci_fake_device_init(xe);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+	xe->drm.dev = dev;
+	test->priv = xe;
+
+	return 0;
+}
+
+static void xe_rtp_table_test_exit(struct kunit *test)
+{
+	struct xe_device *xe = test->priv;
+
+	drm_kunit_helper_free_device(test, xe->drm.dev);
+}
+
+static void rtp_table_gt_test_desc(const struct xe_rtp_entry_sr *t, char *desc)
+{
+	strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
+}
+
+RTP_KUNIT_ARRAY_PARAM(rtp_table_gt, gt_was, rtp_table_gt_test_desc);
+
+static struct kunit_case xe_rtp_table_tests[] = {
+	KUNIT_CASE_PARAM(xe_rtp_table_gt_test, rtp_table_gt_gen_params),
+	{}
+};
+
+static struct kunit_suite xe_rtp_tables_test_suite = {
+	.name = "xe_rtp_tables_test",
+	.init = xe_rtp_table_test_init,
+	.exit = xe_rtp_table_test_exit,
+	.test_cases = xe_rtp_table_tests,
+};
+
+kunit_test_suite(xe_rtp_tables_test_suite);
diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
new file mode 100644
index 000000000000..3e91dd08f854
--- /dev/null
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
@@ -0,0 +1,24 @@
+/* SPDX-License-Identifier: GPL-2.0 AND MIT */
+/*
+ * Copyright © 2026 Intel Corporation
+ */
+
+// The "gen_params" function functionality does not work to dynamically collect the size
+// of the WA array, even with the new n_entries pointer. This addition builds on that framework
+// to allow dynamic sizing
+#define RTP_KUNIT_ARRAY_PARAM(name, array, get_desc)						\
+	static const void *name##_gen_params(struct kunit *test,				\
+					     const void *prev, char *desc)			\
+	{											\
+		typeof((array.entries)[0]) *__next = prev ?					\
+			((typeof(__next))prev) + 1 : (array.entries);				\
+		if (!prev)									\
+			kunit_register_params_array(test, array.entries, array.n_entries, NULL);\
+		if (__next - array.entries < array.n_entries) {					\
+			void (*__get_desc)(typeof(__next), char *) = get_desc;			\
+			if (__get_desc)								\
+				__get_desc(__next, desc);					\
+			return __next;								\
+		}										\
+		return NULL;									\
+	}
diff --git a/drivers/gpu/drm/xe/xe_wa.c b/drivers/gpu/drm/xe/xe_wa.c
index 39c507edb8ce..285072fe0a47 100644
--- a/drivers/gpu/drm/xe/xe_wa.c
+++ b/drivers/gpu/drm/xe/xe_wa.c
@@ -130,7 +130,7 @@
 __diag_push();
 __diag_ignore_all("-Woverride-init", "Allow field overrides in table");
 
-static const struct xe_rtp_table_sr gt_was = XE_RTP_TABLE_SR(
+VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was = XE_RTP_TABLE_SR(
 	/* Workarounds applying over a range of IPs */
 
 	{ XE_RTP_NAME("14011060649"),
diff --git a/drivers/gpu/drm/xe/xe_wa.h b/drivers/gpu/drm/xe/xe_wa.h
index a5f7d33c1b32..17dff615e507 100644
--- a/drivers/gpu/drm/xe/xe_wa.h
+++ b/drivers/gpu/drm/xe/xe_wa.h
@@ -6,6 +6,7 @@
 #ifndef _XE_WA_H_
 #define _XE_WA_H_
 
+#include <kunit/visibility.h>
 #include "xe_assert.h"
 
 struct drm_printer;
@@ -24,6 +25,10 @@ void xe_wa_apply_tile_workarounds(struct xe_tile *tile);
 void xe_wa_device_dump(struct xe_device *xe, struct drm_printer *p);
 int xe_wa_gt_dump(struct xe_gt *gt, struct drm_printer *p);
 
+#if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST)
+extern VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was;
+#endif
+
 /**
  * XE_GT_WA - Out-of-band GT workarounds, to be queried and called as needed.
  * @gt__: gt instance
-- 
2.43.0

[PATCH 3/4] drm/xe/rtp: Add OOB WAs rule checking

[Violet Monti]

This commit builds on the implementation of the GT WA testing, increasing
the scope of testing to include the OOB workaround list. The added test
checks for workarounds with an engine_class rule, and raises an expectation
failure if any are found. Unlike the GT workarounds, there are no flags
within this workaround list, so all engine_class rules will fail.

This test prevents future implementation of rules that would apply an
engine_class rule without an active engine in context, preventing rule
errors or mishaps.

Signed-off-by: Violet Monti <violet.monti@intel.com>
---
 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c | 20 +++++++++++++++++++
 drivers/gpu/drm/xe/xe_wa.c                    |  2 +-
 drivers/gpu/drm/xe/xe_wa.h                    |  1 +
 3 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
index 100cac379b08..eae3262775bb 100644
--- a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
@@ -24,6 +24,18 @@ static void xe_rtp_table_gt_test(struct kunit *test)
 	}
 }
 
+static void xe_rtp_table_oob_test(struct kunit *test)
+{
+	const struct xe_rtp_entry *param = test->param_value;
+
+	for (int i = 0; i < param->n_rules; i++) {
+		KUNIT_EXPECT_NE_MSG(test, param->rules[i].match_type,
+				    XE_RTP_MATCH_ENGINE_CLASS,
+				    "OOB_WA %s has an engine class rule",
+				    param->name);
+	}
+}
+
 static int xe_rtp_table_test_init(struct kunit *test)
 {
 	struct xe_device *xe;
@@ -61,8 +73,16 @@ static void rtp_table_gt_test_desc(const struct xe_rtp_entry_sr *t, char *desc)
 
 RTP_KUNIT_ARRAY_PARAM(rtp_table_gt, gt_was, rtp_table_gt_test_desc);
 
+static void rtp_table_oob_test_desc(const struct xe_rtp_entry *t, char *desc)
+{
+	strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
+}
+
+RTP_KUNIT_ARRAY_PARAM(rtp_table_oob, oob_was, rtp_table_oob_test_desc);
+
 static struct kunit_case xe_rtp_table_tests[] = {
 	KUNIT_CASE_PARAM(xe_rtp_table_gt_test, rtp_table_gt_gen_params),
+	KUNIT_CASE_PARAM(xe_rtp_table_oob_test, rtp_table_oob_gen_params),
 	{}
 };
 
diff --git a/drivers/gpu/drm/xe/xe_wa.c b/drivers/gpu/drm/xe/xe_wa.c
index 285072fe0a47..5744bd3f8be9 100644
--- a/drivers/gpu/drm/xe/xe_wa.c
+++ b/drivers/gpu/drm/xe/xe_wa.c
@@ -802,7 +802,7 @@ static const struct xe_rtp_entry oob_was_entries[] = {
 
 static_assert(ARRAY_SIZE(oob_was_entries)  == _XE_WA_OOB_COUNT);
 
-static __maybe_unused const struct xe_rtp_table oob_was = {
+VISIBLE_IF_KUNIT __maybe_unused const struct xe_rtp_table oob_was = {
 	.entries = oob_was_entries,
 	.n_entries = ARRAY_SIZE(oob_was_entries),
 };
diff --git a/drivers/gpu/drm/xe/xe_wa.h b/drivers/gpu/drm/xe/xe_wa.h
index 17dff615e507..7ac6d365b65f 100644
--- a/drivers/gpu/drm/xe/xe_wa.h
+++ b/drivers/gpu/drm/xe/xe_wa.h
@@ -27,6 +27,7 @@ int xe_wa_gt_dump(struct xe_gt *gt, struct drm_printer *p);
 
 #if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST)
 extern VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was;
+extern VISIBLE_IF_KUNIT __maybe_unused const struct xe_rtp_table oob_was;
 #endif
 
 /**
-- 
2.43.0

[PATCH 4/4] drm/xe/rtp: Add Device OOB WA checks

[Violet Monti]

This commit builds on the implementation of the GT WA testing, increasing
the scope of testing to include the device OOB workaround list. The added
test checks for workarounds with an engine_class rule, and raises an
expectation failure if any are found. Unlike the GT workarounds, there are
no flags within this workaround list, so all engine_class rules will fail.
The device OOB is also more strict, and requires IP rules to be
invalidated as well (MEDIA_* and GRAPHICS_* rules).

This test prevents future implementation of rules that would go against
known contexts for the workarounds implementations.

Signed-off-by: Violet Monti <violet.monti@intel.com>
---
 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c | 37 +++++++++++++++++++
 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h | 17 +++++++--
 drivers/gpu/drm/xe/xe_wa.c                    |  2 +-
 drivers/gpu/drm/xe/xe_wa.h                    |  1 +
 4 files changed, 53 insertions(+), 4 deletions(-)

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
index eae3262775bb..ae228a40fd52 100644
--- a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
@@ -36,6 +36,35 @@ static void xe_rtp_table_oob_test(struct kunit *test)
 	}
 }
 
+static void xe_rtp_table_dev_oob_test(struct kunit *test)
+{
+	bool match;
+	int test_matches[] = {
+		XE_RTP_MATCH_ENGINE_CLASS,
+		XE_RTP_MATCH_GRAPHICS_VERSION,
+		XE_RTP_MATCH_GRAPHICS_VERSION_RANGE,
+		XE_RTP_MATCH_GRAPHICS_VERSION_ANY_GT,
+		XE_RTP_MATCH_GRAPHICS_STEP,
+		XE_RTP_MATCH_MEDIA_VERSION,
+		XE_RTP_MATCH_MEDIA_VERSION_RANGE,
+		XE_RTP_MATCH_MEDIA_VERSION_ANY_GT,
+		XE_RTP_MATCH_MEDIA_STEP,
+	};
+	int size = ARRAY_SIZE(test_matches);
+	const struct xe_rtp_entry *param = test->param_value;
+
+	for (int i = 0; i < param->n_rules; i++) {
+		for (int j = 0; j < size; j++) {
+			KUNIT_EXPECT_NE_MSG(test,
+					    param->rules[i].match_type,
+					    test_matches[j],
+					    "Device OOB WA %s has an invalid rule (type: %d)",
+					    param->name,
+					    j);
+		}
+	}
+}
+
 static int xe_rtp_table_test_init(struct kunit *test)
 {
 	struct xe_device *xe;
@@ -80,9 +109,17 @@ static void rtp_table_oob_test_desc(const struct xe_rtp_entry *t, char *desc)
 
 RTP_KUNIT_ARRAY_PARAM(rtp_table_oob, oob_was, rtp_table_oob_test_desc);
 
+static void rtp_table_dev_oob_test_desc(const struct xe_rtp_entry *t, char *desc)
+{
+	strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
+}
+
+RTP_KUNIT_ARRAY_PARAM(rtp_table_dev_oob, device_oob_was, rtp_table_dev_oob_test_desc);
+
 static struct kunit_case xe_rtp_table_tests[] = {
 	KUNIT_CASE_PARAM(xe_rtp_table_gt_test, rtp_table_gt_gen_params),
 	KUNIT_CASE_PARAM(xe_rtp_table_oob_test, rtp_table_oob_gen_params),
+	KUNIT_CASE_PARAM(xe_rtp_table_dev_oob_test, rtp_table_dev_oob_gen_params),
 	{}
 };
 
diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
index 3e91dd08f854..e7f1d73b44c3 100644
--- a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
@@ -3,9 +3,20 @@
  * Copyright © 2026 Intel Corporation
  */
 
-// The "gen_params" function functionality does not work to dynamically collect the size
-// of the WA array, even with the new n_entries pointer. This addition builds on that framework
-// to allow dynamic sizing
+/**
+ * The "KUNIT_ARRAY_PARAM()" function functionality does not work to dynamically collect the
+ * size of the WA array, even with the new n_entries value. This addition builds on that
+ * framework to utilize these new values.
+ */
+
+/**
+ * RTP_KUNIT_ARRAY_PARAM() - Define test parameter generator from an array.
+ * @name:  prefix for the test parameter generator function.
+ * @array: array of test parameters which includes a n_entries value
+ * @get_desc: function to convert param to description; NULL to use default
+ *
+ * Define function @name_gen_params which uses @array to generate parameters.
+ */
 #define RTP_KUNIT_ARRAY_PARAM(name, array, get_desc)						\
 	static const void *name##_gen_params(struct kunit *test,				\
 					     const void *prev, char *desc)			\
diff --git a/drivers/gpu/drm/xe/xe_wa.c b/drivers/gpu/drm/xe/xe_wa.c
index 5744bd3f8be9..0a4cf6d6c468 100644
--- a/drivers/gpu/drm/xe/xe_wa.c
+++ b/drivers/gpu/drm/xe/xe_wa.c
@@ -813,7 +813,7 @@ static const struct xe_rtp_entry device_oob_was_entries[] = {
 
 static_assert(ARRAY_SIZE(device_oob_was_entries) == _XE_DEVICE_WA_OOB_COUNT);
 
-static __maybe_unused const struct xe_rtp_table device_oob_was = {
+VISIBLE_IF_KUNIT __maybe_unused const struct xe_rtp_table device_oob_was = {
 	.entries = device_oob_was_entries,
 	.n_entries = ARRAY_SIZE(device_oob_was_entries),
 };
diff --git a/drivers/gpu/drm/xe/xe_wa.h b/drivers/gpu/drm/xe/xe_wa.h
index 7ac6d365b65f..568e05e49bf9 100644
--- a/drivers/gpu/drm/xe/xe_wa.h
+++ b/drivers/gpu/drm/xe/xe_wa.h
@@ -28,6 +28,7 @@ int xe_wa_gt_dump(struct xe_gt *gt, struct drm_printer *p);
 #if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST)
 extern VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was;
 extern VISIBLE_IF_KUNIT __maybe_unused const struct xe_rtp_table oob_was;
+extern VISIBLE_IF_KUNIT __maybe_unused const struct xe_rtp_table device_oob_was;
 #endif
 
 /**
-- 
2.43.0

✗ CI.checkpatch: warning for drm/xe/rtp: WA table context testing

[Patchwork]

== Series Details ==

Series: drm/xe/rtp: WA table context testing
URL   : https://patchwork.freedesktop.org/series/166549/
State : warning

== Summary ==

+ KERNEL=/kernel
+ git clone https://gitlab.freedesktop.org/drm/maintainer-tools mt
Cloning into 'mt'...
warning: redirecting to https://gitlab.freedesktop.org/drm/maintainer-tools.git/
+ git -C mt rev-list -n1 origin/master
061140b9bc586ae7f40abc1249c97e1cc72d1b9d
+ cd /kernel
+ git config --global --add safe.directory /kernel
+ git log -n1
commit b71066a2036f142d874bb90cf35a6befb429b129
Author: Violet Monti <violet.monti@intel.com>
Date:   Wed May 13 14:21:28 2026 -0700

    drm/xe/rtp: Add Device OOB WA checks
    
    This commit builds on the implementation of the GT WA testing, increasing
    the scope of testing to include the device OOB workaround list. The added
    test checks for workarounds with an engine_class rule, and raises an
    expectation failure if any are found. Unlike the GT workarounds, there are
    no flags within this workaround list, so all engine_class rules will fail.
    The device OOB is also more strict, and requires IP rules to be
    invalidated as well (MEDIA_* and GRAPHICS_* rules).
    
    This test prevents future implementation of rules that would go against
    known contexts for the workarounds implementations.
    
    Signed-off-by: Violet Monti <violet.monti@intel.com>
+ /mt/dim checkpatch e54a14bbf920aa5eefc70aba9927482ebe630f8b drm-intel
cb1de8c6512a drm/xe/rtp: Add struct types for RTP tables
-:62: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#62: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:72:
+		.table = XE_RTP_TABLE_SR(

-:81: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#81: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:91:
+		.table = XE_RTP_TABLE_SR(

-:100: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#100: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:109:
+		.table = XE_RTP_TABLE_SR(

-:117: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#117: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:134:
+		.table = XE_RTP_TABLE_SR(

-:136: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#136: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:162:
+		.table = XE_RTP_TABLE_SR(

-:155: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#155: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:181:
+		.table = XE_RTP_TABLE_SR(

-:174: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#174: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:200:
+		.table = XE_RTP_TABLE_SR(

-:193: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#193: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:221:
+		.table = XE_RTP_TABLE_SR(

-:210: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#210: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:239:
+		.table = XE_RTP_TABLE_SR(

-:229: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#229: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:259:
+		.table = XE_RTP_TABLE_SR(

-:248: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#248: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:279:
+		.table = XE_RTP_TABLE_SR(

-:287: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#287: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:344:
+		.table = XE_RTP_TABLE(

-:299: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#299: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:353:
+		.table = XE_RTP_TABLE(

-:314: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#314: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:365:
+		.table = XE_RTP_TABLE(

-:329: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#329: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:377:
+		.table = XE_RTP_TABLE(

-:344: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#344: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:389:
+		.table = XE_RTP_TABLE(

-:360: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#360: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:405:
+		.table = XE_RTP_TABLE(

-:376: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#376: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:421:
+		.table = XE_RTP_TABLE(

-:392: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#392: FILE: drivers/gpu/drm/xe/tests/xe_rtp_test.c:437:
+		.table = XE_RTP_TABLE(

-:432: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#432: FILE: drivers/gpu/drm/xe/xe_hw_engine.c:349:
+	const struct xe_rtp_table_sr lrc_setup = XE_RTP_TABLE_SR(

-:454: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#454: FILE: drivers/gpu/drm/xe/xe_hw_engine.c:399:
+	const struct xe_rtp_table_sr engine_sr = XE_RTP_TABLE_SR(

-:480: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#480: FILE: drivers/gpu/drm/xe/xe_reg_whitelist.c:44:
+static const struct xe_rtp_table_sr register_whitelist = XE_RTP_TABLE_SR(

-:660: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#660: FILE: drivers/gpu/drm/xe/xe_tuning.c:23:
+static const struct xe_rtp_table_sr gt_tunings = XE_RTP_TABLE_SR(

-:672: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#672: FILE: drivers/gpu/drm/xe/xe_tuning.c:105:
+static const struct xe_rtp_table_sr engine_tunings = XE_RTP_TABLE_SR(

-:684: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#684: FILE: drivers/gpu/drm/xe/xe_tuning.c:134:
+static const struct xe_rtp_table_sr lrc_tunings = XE_RTP_TABLE_SR(

-:780: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#780: FILE: drivers/gpu/drm/xe/xe_wa.c:133:
+static const struct xe_rtp_table_sr gt_was = XE_RTP_TABLE_SR(

-:792: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#792: FILE: drivers/gpu/drm/xe/xe_wa.c:311:
+static const struct xe_rtp_table_sr engine_was = XE_RTP_TABLE_SR(

-:804: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#804: FILE: drivers/gpu/drm/xe/xe_wa.c:619:
+static const struct xe_rtp_table_sr lrc_was = XE_RTP_TABLE_SR(

-:850: WARNING:LONG_LINE: line length of 101 exceeds 100 columns
#850: FILE: drivers/gpu/drm/xe/xe_wa.c:835:
+	xe_rtp_process_ctx_enable_active_tracking(&ctx, xe->wa_active.oob, device_oob_was.n_entries);

total: 0 errors, 1 warnings, 28 checks, 844 lines checked
8b777509aaab drm/xe/rtp: Add GT WAs rule checking
-:35: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating?
#35: 
new file mode 100644

-:130: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'array' - possible side-effects?
#130: FILE: drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h:9:
+#define RTP_KUNIT_ARRAY_PARAM(name, array, get_desc)						\
+	static const void *name##_gen_params(struct kunit *test,				\
+					     const void *prev, char *desc)			\
+	{											\
+		typeof((array.entries)[0]) *__next = prev ?					\
+			((typeof(__next))prev) + 1 : (array.entries);				\
+		if (!prev)									\
+			kunit_register_params_array(test, array.entries, array.n_entries, NULL);\
+		if (__next - array.entries < array.n_entries) {					\
+			void (*__get_desc)(typeof(__next), char *) = get_desc;			\
+			if (__get_desc)								\
+				__get_desc(__next, desc);					\
+			return __next;								\
+		}										\
+		return NULL;									\
+	}

-:134: CHECK:SPACING: spaces preferred around that '*' (ctx:WxV)
#134: FILE: drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h:13:
+		typeof((array.entries)[0]) *__next = prev ?					\
 		                           ^

-:155: CHECK:OPEN_ENDED_LINE: Lines should not end with a '('
#155: FILE: drivers/gpu/drm/xe/xe_wa.c:133:
+VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was = XE_RTP_TABLE_SR(

total: 0 errors, 1 warnings, 3 checks, 131 lines checked
4d5f0225e78a drm/xe/rtp: Add OOB WAs rule checking
b71066a2036f drm/xe/rtp: Add Device OOB WA checks

✓ CI.KUnit: success for drm/xe/rtp: WA table context testing

[Patchwork]

== Series Details ==

Series: drm/xe/rtp: WA table context testing
URL   : https://patchwork.freedesktop.org/series/166549/
State : success

== Summary ==

+ trap cleanup EXIT
+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/xe/.kunitconfig
[21:28:04] Configuring KUnit Kernel ...
Generating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[21:28:08] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
../drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c: In function ‘xe_rtp_table_dev_oob_test’:
../drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c:41:14: warning: unused variable ‘match’ [-Wunused-variable]
   41 |         bool match;
      |              ^~~~~

[21:28:40] Starting KUnit Kernel (1/1)...
[21:28:40] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[21:28:40] ================== guc_buf (11 subtests) ===================
[21:28:40] [PASSED] test_smallest
[21:28:40] [PASSED] test_largest
[21:28:40] [PASSED] test_granular
[21:28:40] [PASSED] test_unique
[21:28:40] [PASSED] test_overlap
[21:28:40] [PASSED] test_reusable
[21:28:40] [PASSED] test_too_big
[21:28:40] [PASSED] test_flush
[21:28:40] [PASSED] test_lookup
[21:28:40] [PASSED] test_data
[21:28:40] [PASSED] test_class
[21:28:40] ===================== [PASSED] guc_buf =====================
[21:28:40] =================== guc_dbm (7 subtests) ===================
[21:28:40] [PASSED] test_empty
[21:28:40] [PASSED] test_default
[21:28:40] ======================== test_size  ========================
[21:28:40] [PASSED] 4
[21:28:40] [PASSED] 8
[21:28:40] [PASSED] 32
[21:28:40] [PASSED] 256
[21:28:40] ==================== [PASSED] test_size ====================
[21:28:40] ======================= test_reuse  ========================
[21:28:40] [PASSED] 4
[21:28:40] [PASSED] 8
[21:28:40] [PASSED] 32
[21:28:40] [PASSED] 256
[21:28:40] =================== [PASSED] test_reuse ====================
[21:28:40] =================== test_range_overlap  ====================
[21:28:40] [PASSED] 4
[21:28:40] [PASSED] 8
[21:28:40] [PASSED] 32
[21:28:40] [PASSED] 256
[21:28:40] =============== [PASSED] test_range_overlap ================
[21:28:40] =================== test_range_compact  ====================
[21:28:40] [PASSED] 4
[21:28:40] [PASSED] 8
[21:28:40] [PASSED] 32
[21:28:40] [PASSED] 256
[21:28:40] =============== [PASSED] test_range_compact ================
[21:28:40] ==================== test_range_spare  =====================
[21:28:40] [PASSED] 4
[21:28:40] [PASSED] 8
[21:28:40] [PASSED] 32
[21:28:40] [PASSED] 256
[21:28:40] ================ [PASSED] test_range_spare =================
[21:28:40] ===================== [PASSED] guc_dbm =====================
[21:28:40] =================== guc_idm (6 subtests) ===================
[21:28:40] [PASSED] bad_init
[21:28:40] [PASSED] no_init
[21:28:40] [PASSED] init_fini
[21:28:40] [PASSED] check_used
[21:28:40] [PASSED] check_quota
[21:28:40] [PASSED] check_all
[21:28:40] ===================== [PASSED] guc_idm =====================
[21:28:40] ================== no_relay (3 subtests) ===================
[21:28:40] [PASSED] xe_drops_guc2pf_if_not_ready
[21:28:40] [PASSED] xe_drops_guc2vf_if_not_ready
[21:28:40] [PASSED] xe_rejects_send_if_not_ready
[21:28:40] ==================== [PASSED] no_relay =====================
[21:28:40] ================== pf_relay (14 subtests) ==================
[21:28:40] [PASSED] pf_rejects_guc2pf_too_short
[21:28:40] [PASSED] pf_rejects_guc2pf_too_long
[21:28:40] [PASSED] pf_rejects_guc2pf_no_payload
[21:28:40] [PASSED] pf_fails_no_payload
[21:28:40] [PASSED] pf_fails_bad_origin
[21:28:40] [PASSED] pf_fails_bad_type
[21:28:40] [PASSED] pf_txn_reports_error
[21:28:40] [PASSED] pf_txn_sends_pf2guc
[21:28:40] [PASSED] pf_sends_pf2guc
[21:28:40] [SKIPPED] pf_loopback_nop
[21:28:40] [SKIPPED] pf_loopback_echo
[21:28:40] [SKIPPED] pf_loopback_fail
[21:28:40] [SKIPPED] pf_loopback_busy
[21:28:40] [SKIPPED] pf_loopback_retry
[21:28:40] ==================== [PASSED] pf_relay =====================
[21:28:40] ================== vf_relay (3 subtests) ===================
[21:28:40] [PASSED] vf_rejects_guc2vf_too_short
[21:28:40] [PASSED] vf_rejects_guc2vf_too_long
[21:28:40] [PASSED] vf_rejects_guc2vf_no_payload
[21:28:40] ==================== [PASSED] vf_relay =====================
[21:28:40] ================ pf_gt_config (9 subtests) =================
[21:28:40] [PASSED] fair_contexts_1vf
[21:28:40] [PASSED] fair_doorbells_1vf
[21:28:40] [PASSED] fair_ggtt_1vf
[21:28:40] ====================== fair_vram_1vf  ======================
[21:28:40] [PASSED] 3.50 GiB
[21:28:40] [PASSED] 11.5 GiB
[21:28:40] [PASSED] 15.5 GiB
[21:28:40] [PASSED] 31.5 GiB
[21:28:40] [PASSED] 63.5 GiB
[21:28:40] [PASSED] 1.91 GiB
[21:28:40] ================== [PASSED] fair_vram_1vf ==================
[21:28:40] ================ fair_vram_1vf_admin_only  =================
[21:28:40] [PASSED] 3.50 GiB
[21:28:40] [PASSED] 11.5 GiB
[21:28:40] [PASSED] 15.5 GiB
[21:28:40] [PASSED] 31.5 GiB
[21:28:40] [PASSED] 63.5 GiB
[21:28:40] [PASSED] 1.91 GiB
[21:28:40] ============ [PASSED] fair_vram_1vf_admin_only =============
[21:28:40] ====================== fair_contexts  ======================
[21:28:40] [PASSED] 1 VF
[21:28:40] [PASSED] 2 VFs
[21:28:40] [PASSED] 3 VFs
[21:28:40] [PASSED] 4 VFs
[21:28:40] [PASSED] 5 VFs
[21:28:40] [PASSED] 6 VFs
[21:28:40] [PASSED] 7 VFs
[21:28:40] [PASSED] 8 VFs
[21:28:40] [PASSED] 9 VFs
[21:28:40] [PASSED] 10 VFs
[21:28:40] [PASSED] 11 VFs
[21:28:40] [PASSED] 12 VFs
[21:28:40] [PASSED] 13 VFs
[21:28:40] [PASSED] 14 VFs
[21:28:40] [PASSED] 15 VFs
[21:28:40] [PASSED] 16 VFs
[21:28:40] [PASSED] 17 VFs
[21:28:40] [PASSED] 18 VFs
[21:28:40] [PASSED] 19 VFs
[21:28:40] [PASSED] 20 VFs
[21:28:40] [PASSED] 21 VFs
[21:28:40] [PASSED] 22 VFs
[21:28:40] [PASSED] 23 VFs
[21:28:40] [PASSED] 24 VFs
[21:28:40] [PASSED] 25 VFs
[21:28:40] [PASSED] 26 VFs
[21:28:40] [PASSED] 27 VFs
[21:28:40] [PASSED] 28 VFs
[21:28:40] [PASSED] 29 VFs
[21:28:40] [PASSED] 30 VFs
[21:28:40] [PASSED] 31 VFs
[21:28:40] [PASSED] 32 VFs
[21:28:40] [PASSED] 33 VFs
[21:28:40] [PASSED] 34 VFs
[21:28:40] [PASSED] 35 VFs
[21:28:40] [PASSED] 36 VFs
[21:28:40] [PASSED] 37 VFs
[21:28:40] [PASSED] 38 VFs
[21:28:40] [PASSED] 39 VFs
[21:28:40] [PASSED] 40 VFs
[21:28:40] [PASSED] 41 VFs
[21:28:40] [PASSED] 42 VFs
[21:28:40] [PASSED] 43 VFs
[21:28:40] [PASSED] 44 VFs
[21:28:40] [PASSED] 45 VFs
[21:28:40] [PASSED] 46 VFs
[21:28:40] [PASSED] 47 VFs
[21:28:40] [PASSED] 48 VFs
[21:28:40] [PASSED] 49 VFs
[21:28:40] [PASSED] 50 VFs
[21:28:40] [PASSED] 51 VFs
[21:28:40] [PASSED] 52 VFs
[21:28:40] [PASSED] 53 VFs
[21:28:40] [PASSED] 54 VFs
[21:28:40] [PASSED] 55 VFs
[21:28:40] [PASSED] 56 VFs
[21:28:40] [PASSED] 57 VFs
[21:28:40] [PASSED] 58 VFs
[21:28:40] [PASSED] 59 VFs
[21:28:40] [PASSED] 60 VFs
[21:28:40] [PASSED] 61 VFs
[21:28:40] [PASSED] 62 VFs
[21:28:40] [PASSED] 63 VFs
[21:28:40] ================== [PASSED] fair_contexts ==================
[21:28:40] ===================== fair_doorbells  ======================
[21:28:40] [PASSED] 1 VF
[21:28:40] [PASSED] 2 VFs
[21:28:40] [PASSED] 3 VFs
[21:28:40] [PASSED] 4 VFs
[21:28:40] [PASSED] 5 VFs
[21:28:40] [PASSED] 6 VFs
[21:28:40] [PASSED] 7 VFs
[21:28:40] [PASSED] 8 VFs
[21:28:40] [PASSED] 9 VFs
[21:28:40] [PASSED] 10 VFs
[21:28:40] [PASSED] 11 VFs
[21:28:40] [PASSED] 12 VFs
[21:28:40] [PASSED] 13 VFs
[21:28:40] [PASSED] 14 VFs
[21:28:40] [PASSED] 15 VFs
[21:28:40] [PASSED] 16 VFs
[21:28:40] [PASSED] 17 VFs
[21:28:40] [PASSED] 18 VFs
[21:28:40] [PASSED] 19 VFs
[21:28:40] [PASSED] 20 VFs
[21:28:40] [PASSED] 21 VFs
[21:28:40] [PASSED] 22 VFs
[21:28:40] [PASSED] 23 VFs
[21:28:40] [PASSED] 24 VFs
[21:28:40] [PASSED] 25 VFs
[21:28:40] [PASSED] 26 VFs
[21:28:40] [PASSED] 27 VFs
[21:28:40] [PASSED] 28 VFs
[21:28:40] [PASSED] 29 VFs
[21:28:40] [PASSED] 30 VFs
[21:28:40] [PASSED] 31 VFs
[21:28:40] [PASSED] 32 VFs
[21:28:40] [PASSED] 33 VFs
[21:28:40] [PASSED] 34 VFs
[21:28:40] [PASSED] 35 VFs
[21:28:40] [PASSED] 36 VFs
[21:28:40] [PASSED] 37 VFs
[21:28:40] [PASSED] 38 VFs
[21:28:40] [PASSED] 39 VFs
[21:28:40] [PASSED] 40 VFs
[21:28:40] [PASSED] 41 VFs
[21:28:40] [PASSED] 42 VFs
[21:28:40] [PASSED] 43 VFs
[21:28:40] [PASSED] 44 VFs
[21:28:40] [PASSED] 45 VFs
[21:28:40] [PASSED] 46 VFs
[21:28:40] [PASSED] 47 VFs
[21:28:40] [PASSED] 48 VFs
[21:28:40] [PASSED] 49 VFs
[21:28:40] [PASSED] 50 VFs
[21:28:40] [PASSED] 51 VFs
[21:28:40] [PASSED] 52 VFs
[21:28:40] [PASSED] 53 VFs
[21:28:40] [PASSED] 54 VFs
[21:28:40] [PASSED] 55 VFs
[21:28:40] [PASSED] 56 VFs
[21:28:40] [PASSED] 57 VFs
[21:28:40] [PASSED] 58 VFs
[21:28:40] [PASSED] 59 VFs
[21:28:40] [PASSED] 60 VFs
[21:28:40] [PASSED] 61 VFs
[21:28:40] [PASSED] 62 VFs
[21:28:40] [PASSED] 63 VFs
[21:28:40] ================= [PASSED] fair_doorbells ==================
[21:28:40] ======================== fair_ggtt  ========================
[21:28:40] [PASSED] 1 VF
[21:28:40] [PASSED] 2 VFs
[21:28:40] [PASSED] 3 VFs
[21:28:40] [PASSED] 4 VFs
[21:28:40] [PASSED] 5 VFs
[21:28:40] [PASSED] 6 VFs
[21:28:40] [PASSED] 7 VFs
[21:28:40] [PASSED] 8 VFs
[21:28:40] [PASSED] 9 VFs
[21:28:40] [PASSED] 10 VFs
[21:28:40] [PASSED] 11 VFs
[21:28:40] [PASSED] 12 VFs
[21:28:40] [PASSED] 13 VFs
[21:28:40] [PASSED] 14 VFs
[21:28:40] [PASSED] 15 VFs
[21:28:40] [PASSED] 16 VFs
[21:28:40] [PASSED] 17 VFs
[21:28:40] [PASSED] 18 VFs
[21:28:40] [PASSED] 19 VFs
[21:28:40] [PASSED] 20 VFs
[21:28:40] [PASSED] 21 VFs
[21:28:40] [PASSED] 22 VFs
[21:28:40] [PASSED] 23 VFs
[21:28:40] [PASSED] 24 VFs
[21:28:40] [PASSED] 25 VFs
[21:28:40] [PASSED] 26 VFs
[21:28:40] [PASSED] 27 VFs
[21:28:40] [PASSED] 28 VFs
[21:28:40] [PASSED] 29 VFs
[21:28:40] [PASSED] 30 VFs
[21:28:40] [PASSED] 31 VFs
[21:28:40] [PASSED] 32 VFs
[21:28:40] [PASSED] 33 VFs
[21:28:40] [PASSED] 34 VFs
[21:28:40] [PASSED] 35 VFs
[21:28:40] [PASSED] 36 VFs
[21:28:40] [PASSED] 37 VFs
[21:28:40] [PASSED] 38 VFs
[21:28:40] [PASSED] 39 VFs
[21:28:40] [PASSED] 40 VFs
[21:28:40] [PASSED] 41 VFs
[21:28:40] [PASSED] 42 VFs
[21:28:40] [PASSED] 43 VFs
[21:28:40] [PASSED] 44 VFs
[21:28:40] [PASSED] 45 VFs
[21:28:40] [PASSED] 46 VFs
[21:28:40] [PASSED] 47 VFs
[21:28:40] [PASSED] 48 VFs
[21:28:40] [PASSED] 49 VFs
[21:28:40] [PASSED] 50 VFs
[21:28:40] [PASSED] 51 VFs
[21:28:40] [PASSED] 52 VFs
[21:28:40] [PASSED] 53 VFs
[21:28:40] [PASSED] 54 VFs
[21:28:40] [PASSED] 55 VFs
[21:28:40] [PASSED] 56 VFs
[21:28:40] [PASSED] 57 VFs
[21:28:40] [PASSED] 58 VFs
[21:28:40] [PASSED] 59 VFs
[21:28:40] [PASSED] 60 VFs
[21:28:40] [PASSED] 61 VFs
[21:28:40] [PASSED] 62 VFs
[21:28:40] [PASSED] 63 VFs
[21:28:40] ==================== [PASSED] fair_ggtt ====================
[21:28:40] ======================== fair_vram  ========================
[21:28:40] [PASSED] 1 VF
[21:28:40] [PASSED] 2 VFs
[21:28:40] [PASSED] 3 VFs
[21:28:40] [PASSED] 4 VFs
[21:28:40] [PASSED] 5 VFs
[21:28:40] [PASSED] 6 VFs
[21:28:40] [PASSED] 7 VFs
[21:28:40] [PASSED] 8 VFs
[21:28:40] [PASSED] 9 VFs
[21:28:40] [PASSED] 10 VFs
[21:28:40] [PASSED] 11 VFs
[21:28:40] [PASSED] 12 VFs
[21:28:40] [PASSED] 13 VFs
[21:28:40] [PASSED] 14 VFs
[21:28:40] [PASSED] 15 VFs
[21:28:40] [PASSED] 16 VFs
[21:28:40] [PASSED] 17 VFs
[21:28:40] [PASSED] 18 VFs
[21:28:40] [PASSED] 19 VFs
[21:28:40] [PASSED] 20 VFs
[21:28:40] [PASSED] 21 VFs
[21:28:40] [PASSED] 22 VFs
[21:28:40] [PASSED] 23 VFs
[21:28:40] [PASSED] 24 VFs
[21:28:40] [PASSED] 25 VFs
[21:28:40] [PASSED] 26 VFs
[21:28:40] [PASSED] 27 VFs
[21:28:40] [PASSED] 28 VFs
[21:28:40] [PASSED] 29 VFs
[21:28:40] [PASSED] 30 VFs
[21:28:40] [PASSED] 31 VFs
[21:28:40] [PASSED] 32 VFs
[21:28:40] [PASSED] 33 VFs
[21:28:40] [PASSED] 34 VFs
[21:28:40] [PASSED] 35 VFs
[21:28:40] [PASSED] 36 VFs
[21:28:40] [PASSED] 37 VFs
[21:28:40] [PASSED] 38 VFs
[21:28:40] [PASSED] 39 VFs
[21:28:40] [PASSED] 40 VFs
[21:28:40] [PASSED] 41 VFs
[21:28:40] [PASSED] 42 VFs
[21:28:40] [PASSED] 43 VFs
[21:28:40] [PASSED] 44 VFs
[21:28:40] [PASSED] 45 VFs
[21:28:40] [PASSED] 46 VFs
[21:28:40] [PASSED] 47 VFs
[21:28:40] [PASSED] 48 VFs
[21:28:40] [PASSED] 49 VFs
[21:28:40] [PASSED] 50 VFs
[21:28:40] [PASSED] 51 VFs
[21:28:40] [PASSED] 52 VFs
[21:28:40] [PASSED] 53 VFs
[21:28:40] [PASSED] 54 VFs
[21:28:40] [PASSED] 55 VFs
[21:28:40] [PASSED] 56 VFs
[21:28:40] [PASSED] 57 VFs
[21:28:40] [PASSED] 58 VFs
[21:28:40] [PASSED] 59 VFs
[21:28:40] [PASSED] 60 VFs
[21:28:40] [PASSED] 61 VFs
[21:28:40] [PASSED] 62 VFs
[21:28:40] [PASSED] 63 VFs
[21:28:40] ==================== [PASSED] fair_vram ====================
[21:28:40] ================== [PASSED] pf_gt_config ===================
[21:28:40] ===================== lmtt (1 subtest) =====================
[21:28:40] ======================== test_ops  =========================
[21:28:40] [PASSED] 2-level
[21:28:40] [PASSED] multi-level
[21:28:40] ==================== [PASSED] test_ops =====================
[21:28:40] ====================== [PASSED] lmtt =======================
[21:28:40] ================= pf_service (11 subtests) =================
[21:28:40] [PASSED] pf_negotiate_any
[21:28:40] [PASSED] pf_negotiate_base_match
[21:28:40] [PASSED] pf_negotiate_base_newer
[21:28:40] [PASSED] pf_negotiate_base_next
[21:28:40] [SKIPPED] pf_negotiate_base_older
[21:28:40] [PASSED] pf_negotiate_base_prev
[21:28:40] [PASSED] pf_negotiate_latest_match
[21:28:40] [PASSED] pf_negotiate_latest_newer
[21:28:40] [PASSED] pf_negotiate_latest_next
[21:28:40] [SKIPPED] pf_negotiate_latest_older
[21:28:40] [SKIPPED] pf_negotiate_latest_prev
[21:28:40] =================== [PASSED] pf_service ====================
[21:28:40] ================= xe_guc_g2g (2 subtests) ==================
[21:28:40] ============== xe_live_guc_g2g_kunit_default  ==============
[21:28:40] ========= [SKIPPED] xe_live_guc_g2g_kunit_default ==========
[21:28:40] ============== xe_live_guc_g2g_kunit_allmem  ===============
[21:28:40] ========== [SKIPPED] xe_live_guc_g2g_kunit_allmem ==========
[21:28:40] =================== [SKIPPED] xe_guc_g2g ===================
[21:28:40] =================== xe_mocs (2 subtests) ===================
[21:28:40] ================ xe_live_mocs_kernel_kunit  ================
[21:28:40] =========== [SKIPPED] xe_live_mocs_kernel_kunit ============
[21:28:40] ================ xe_live_mocs_reset_kunit  =================
[21:28:40] ============ [SKIPPED] xe_live_mocs_reset_kunit ============
[21:28:40] ==================== [SKIPPED] xe_mocs =====================
[21:28:40] ================= xe_migrate (2 subtests) ==================
[21:28:40] ================= xe_migrate_sanity_kunit  =================
[21:28:40] ============ [SKIPPED] xe_migrate_sanity_kunit =============
[21:28:40] ================== xe_validate_ccs_kunit  ==================
[21:28:40] ============= [SKIPPED] xe_validate_ccs_kunit ==============
[21:28:40] =================== [SKIPPED] xe_migrate ===================
[21:28:40] ================== xe_dma_buf (1 subtest) ==================
[21:28:40] ==================== xe_dma_buf_kunit  =====================
[21:28:40] ================ [SKIPPED] xe_dma_buf_kunit ================
[21:28:40] =================== [SKIPPED] xe_dma_buf ===================
[21:28:40] ================= xe_bo_shrink (1 subtest) =================
[21:28:40] =================== xe_bo_shrink_kunit  ====================
[21:28:40] =============== [SKIPPED] xe_bo_shrink_kunit ===============
[21:28:40] ================== [SKIPPED] xe_bo_shrink ==================
[21:28:40] ==================== xe_bo (2 subtests) ====================
[21:28:40] ================== xe_ccs_migrate_kunit  ===================
[21:28:40] ============== [SKIPPED] xe_ccs_migrate_kunit ==============
[21:28:40] ==================== xe_bo_evict_kunit  ====================
[21:28:40] =============== [SKIPPED] xe_bo_evict_kunit ================
[21:28:40] ===================== [SKIPPED] xe_bo ======================
[21:28:40] ==================== args (13 subtests) ====================
[21:28:40] [PASSED] count_args_test
[21:28:40] [PASSED] call_args_example
[21:28:40] [PASSED] call_args_test
[21:28:40] [PASSED] drop_first_arg_example
[21:28:40] [PASSED] drop_first_arg_test
[21:28:40] [PASSED] first_arg_example
[21:28:40] [PASSED] first_arg_test
[21:28:40] [PASSED] last_arg_example
[21:28:40] [PASSED] last_arg_test
[21:28:40] [PASSED] pick_arg_example
[21:28:40] [PASSED] if_args_example
[21:28:40] [PASSED] if_args_test
[21:28:40] [PASSED] sep_comma_example
[21:28:40] ====================== [PASSED] args =======================
[21:28:40] =================== xe_pci (3 subtests) ====================
[21:28:40] ==================== check_graphics_ip  ====================
[21:28:40] [PASSED] 12.00 Xe_LP
[21:28:40] [PASSED] 12.10 Xe_LP+
[21:28:40] [PASSED] 12.55 Xe_HPG
[21:28:40] [PASSED] 12.60 Xe_HPC
[21:28:40] [PASSED] 12.70 Xe_LPG
[21:28:40] [PASSED] 12.71 Xe_LPG
[21:28:40] [PASSED] 12.74 Xe_LPG+
[21:28:40] [PASSED] 20.01 Xe2_HPG
[21:28:40] [PASSED] 20.02 Xe2_HPG
[21:28:40] [PASSED] 20.04 Xe2_LPG
[21:28:40] [PASSED] 30.00 Xe3_LPG
[21:28:40] [PASSED] 30.01 Xe3_LPG
[21:28:40] [PASSED] 30.03 Xe3_LPG
[21:28:40] [PASSED] 30.04 Xe3_LPG
[21:28:40] [PASSED] 30.05 Xe3_LPG
[21:28:40] [PASSED] 35.10 Xe3p_LPG
[21:28:40] [PASSED] 35.11 Xe3p_XPC
[21:28:40] ================ [PASSED] check_graphics_ip ================
[21:28:40] ===================== check_media_ip  ======================
[21:28:40] [PASSED] 12.00 Xe_M
[21:28:40] [PASSED] 12.55 Xe_HPM
[21:28:40] [PASSED] 13.00 Xe_LPM+
[21:28:40] [PASSED] 13.01 Xe2_HPM
[21:28:40] [PASSED] 20.00 Xe2_LPM
[21:28:40] [PASSED] 30.00 Xe3_LPM
[21:28:40] [PASSED] 30.02 Xe3_LPM
[21:28:40] [PASSED] 35.00 Xe3p_LPM
[21:28:40] [PASSED] 35.03 Xe3p_HPM
[21:28:40] ================= [PASSED] check_media_ip ==================
[21:28:40] =================== check_platform_desc  ===================
[21:28:40] [PASSED] 0x9A60 (TIGERLAKE)
[21:28:40] [PASSED] 0x9A68 (TIGERLAKE)
[21:28:40] [PASSED] 0x9A70 (TIGERLAKE)
[21:28:40] [PASSED] 0x9A40 (TIGERLAKE)
[21:28:40] [PASSED] 0x9A49 (TIGERLAKE)
[21:28:40] [PASSED] 0x9A59 (TIGERLAKE)
[21:28:40] [PASSED] 0x9A78 (TIGERLAKE)
[21:28:40] [PASSED] 0x9AC0 (TIGERLAKE)
[21:28:40] [PASSED] 0x9AC9 (TIGERLAKE)
[21:28:40] [PASSED] 0x9AD9 (TIGERLAKE)
[21:28:40] [PASSED] 0x9AF8 (TIGERLAKE)
[21:28:40] [PASSED] 0x4C80 (ROCKETLAKE)
[21:28:40] [PASSED] 0x4C8A (ROCKETLAKE)
[21:28:40] [PASSED] 0x4C8B (ROCKETLAKE)
[21:28:40] [PASSED] 0x4C8C (ROCKETLAKE)
[21:28:40] [PASSED] 0x4C90 (ROCKETLAKE)
[21:28:40] [PASSED] 0x4C9A (ROCKETLAKE)
[21:28:40] [PASSED] 0x4680 (ALDERLAKE_S)
[21:28:40] [PASSED] 0x4682 (ALDERLAKE_S)
[21:28:40] [PASSED] 0x4688 (ALDERLAKE_S)
[21:28:40] [PASSED] 0x468A (ALDERLAKE_S)
[21:28:40] [PASSED] 0x468B (ALDERLAKE_S)
[21:28:40] [PASSED] 0x4690 (ALDERLAKE_S)
[21:28:40] [PASSED] 0x4692 (ALDERLAKE_S)
[21:28:40] [PASSED] 0x4693 (ALDERLAKE_S)
[21:28:40] [PASSED] 0x46A0 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46A1 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46A2 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46A3 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46A6 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46A8 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46AA (ALDERLAKE_P)
[21:28:40] [PASSED] 0x462A (ALDERLAKE_P)
[21:28:40] [PASSED] 0x4626 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x4628 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46B0 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46B1 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46B2 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46B3 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46C0 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46C1 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46C2 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46C3 (ALDERLAKE_P)
[21:28:40] [PASSED] 0x46D0 (ALDERLAKE_N)
[21:28:40] [PASSED] 0x46D1 (ALDERLAKE_N)
[21:28:40] [PASSED] 0x46D2 (ALDERLAKE_N)
[21:28:40] [PASSED] 0x46D3 (ALDERLAKE_N)
[21:28:40] [PASSED] 0x46D4 (ALDERLAKE_N)
[21:28:40] [PASSED] 0xA721 (ALDERLAKE_P)
[21:28:40] [PASSED] 0xA7A1 (ALDERLAKE_P)
[21:28:40] [PASSED] 0xA7A9 (ALDERLAKE_P)
[21:28:40] [PASSED] 0xA7AC (ALDERLAKE_P)
[21:28:40] [PASSED] 0xA7AD (ALDERLAKE_P)
[21:28:40] [PASSED] 0xA720 (ALDERLAKE_P)
[21:28:40] [PASSED] 0xA7A0 (ALDERLAKE_P)
[21:28:40] [PASSED] 0xA7A8 (ALDERLAKE_P)
[21:28:40] [PASSED] 0xA7AA (ALDERLAKE_P)
[21:28:40] [PASSED] 0xA7AB (ALDERLAKE_P)
[21:28:40] [PASSED] 0xA780 (ALDERLAKE_S)
[21:28:40] [PASSED] 0xA781 (ALDERLAKE_S)
[21:28:40] [PASSED] 0xA782 (ALDERLAKE_S)
[21:28:40] [PASSED] 0xA783 (ALDERLAKE_S)
[21:28:40] [PASSED] 0xA788 (ALDERLAKE_S)
[21:28:40] [PASSED] 0xA789 (ALDERLAKE_S)
[21:28:40] [PASSED] 0xA78A (ALDERLAKE_S)
[21:28:40] [PASSED] 0xA78B (ALDERLAKE_S)
[21:28:40] [PASSED] 0x4905 (DG1)
[21:28:40] [PASSED] 0x4906 (DG1)
[21:28:40] [PASSED] 0x4907 (DG1)
[21:28:40] [PASSED] 0x4908 (DG1)
[21:28:40] [PASSED] 0x4909 (DG1)
[21:28:40] [PASSED] 0x56C0 (DG2)
[21:28:40] [PASSED] 0x56C2 (DG2)
[21:28:40] [PASSED] 0x56C1 (DG2)
[21:28:40] [PASSED] 0x7D51 (METEORLAKE)
[21:28:40] [PASSED] 0x7DD1 (METEORLAKE)
[21:28:40] [PASSED] 0x7D41 (METEORLAKE)
[21:28:40] [PASSED] 0x7D67 (METEORLAKE)
[21:28:40] [PASSED] 0xB640 (METEORLAKE)
[21:28:40] [PASSED] 0x56A0 (DG2)
[21:28:40] [PASSED] 0x56A1 (DG2)
[21:28:40] [PASSED] 0x56A2 (DG2)
[21:28:40] [PASSED] 0x56BE (DG2)
[21:28:40] [PASSED] 0x56BF (DG2)
[21:28:40] [PASSED] 0x5690 (DG2)
[21:28:40] [PASSED] 0x5691 (DG2)
[21:28:40] [PASSED] 0x5692 (DG2)
[21:28:40] [PASSED] 0x56A5 (DG2)
[21:28:40] [PASSED] 0x56A6 (DG2)
[21:28:40] [PASSED] 0x56B0 (DG2)
[21:28:40] [PASSED] 0x56B1 (DG2)
[21:28:40] [PASSED] 0x56BA (DG2)
[21:28:40] [PASSED] 0x56BB (DG2)
[21:28:40] [PASSED] 0x56BC (DG2)
[21:28:40] [PASSED] 0x56BD (DG2)
[21:28:40] [PASSED] 0x5693 (DG2)
[21:28:40] [PASSED] 0x5694 (DG2)
[21:28:40] [PASSED] 0x5695 (DG2)
[21:28:40] [PASSED] 0x56A3 (DG2)
[21:28:40] [PASSED] 0x56A4 (DG2)
[21:28:40] [PASSED] 0x56B2 (DG2)
[21:28:40] [PASSED] 0x56B3 (DG2)
[21:28:40] [PASSED] 0x5696 (DG2)
[21:28:40] [PASSED] 0x5697 (DG2)
[21:28:40] [PASSED] 0xB69 (PVC)
[21:28:40] [PASSED] 0xB6E (PVC)
[21:28:40] [PASSED] 0xBD4 (PVC)
[21:28:40] [PASSED] 0xBD5 (PVC)
[21:28:40] [PASSED] 0xBD6 (PVC)
[21:28:40] [PASSED] 0xBD7 (PVC)
[21:28:40] [PASSED] 0xBD8 (PVC)
[21:28:40] [PASSED] 0xBD9 (PVC)
[21:28:40] [PASSED] 0xBDA (PVC)
[21:28:40] [PASSED] 0xBDB (PVC)
[21:28:40] [PASSED] 0xBE0 (PVC)
[21:28:40] [PASSED] 0xBE1 (PVC)
[21:28:40] [PASSED] 0xBE5 (PVC)
[21:28:40] [PASSED] 0x7D40 (METEORLAKE)
[21:28:40] [PASSED] 0x7D45 (METEORLAKE)
[21:28:40] [PASSED] 0x7D55 (METEORLAKE)
[21:28:40] [PASSED] 0x7D60 (METEORLAKE)
[21:28:40] [PASSED] 0x7DD5 (METEORLAKE)
[21:28:40] [PASSED] 0x6420 (LUNARLAKE)
[21:28:40] [PASSED] 0x64A0 (LUNARLAKE)
[21:28:40] [PASSED] 0x64B0 (LUNARLAKE)
[21:28:40] [PASSED] 0xE202 (BATTLEMAGE)
[21:28:40] [PASSED] 0xE209 (BATTLEMAGE)
[21:28:40] [PASSED] 0xE20B (BATTLEMAGE)
[21:28:40] [PASSED] 0xE20C (BATTLEMAGE)
[21:28:40] [PASSED] 0xE20D (BATTLEMAGE)
[21:28:40] [PASSED] 0xE210 (BATTLEMAGE)
[21:28:40] [PASSED] 0xE211 (BATTLEMAGE)
[21:28:40] [PASSED] 0xE212 (BATTLEMAGE)
[21:28:40] [PASSED] 0xE216 (BATTLEMAGE)
[21:28:40] [PASSED] 0xE220 (BATTLEMAGE)
[21:28:40] [PASSED] 0xE221 (BATTLEMAGE)
[21:28:40] [PASSED] 0xE222 (BATTLEMAGE)
[21:28:40] [PASSED] 0xE223 (BATTLEMAGE)
[21:28:40] [PASSED] 0xB080 (PANTHERLAKE)
[21:28:40] [PASSED] 0xB081 (PANTHERLAKE)
[21:28:40] [PASSED] 0xB082 (PANTHERLAKE)
[21:28:40] [PASSED] 0xB083 (PANTHERLAKE)
[21:28:40] [PASSED] 0xB084 (PANTHERLAKE)
[21:28:40] [PASSED] 0xB085 (PANTHERLAKE)
[21:28:40] [PASSED] 0xB086 (PANTHERLAKE)
[21:28:40] [PASSED] 0xB087 (PANTHERLAKE)
[21:28:40] [PASSED] 0xB08F (PANTHERLAKE)
[21:28:40] [PASSED] 0xB090 (PANTHERLAKE)
[21:28:40] [PASSED] 0xB0A0 (PANTHERLAKE)
[21:28:40] [PASSED] 0xB0B0 (PANTHERLAKE)
[21:28:40] [PASSED] 0xFD80 (PANTHERLAKE)
[21:28:40] [PASSED] 0xFD81 (PANTHERLAKE)
[21:28:40] [PASSED] 0xD740 (NOVALAKE_S)
[21:28:40] [PASSED] 0xD741 (NOVALAKE_S)
[21:28:40] [PASSED] 0xD742 (NOVALAKE_S)
[21:28:40] [PASSED] 0xD743 (NOVALAKE_S)
[21:28:40] [PASSED] 0xD744 (NOVALAKE_S)
[21:28:40] [PASSED] 0xD745 (NOVALAKE_S)
[21:28:40] [PASSED] 0x674C (CRESCENTISLAND)
[21:28:40] [PASSED] 0x674D (CRESCENTISLAND)
[21:28:40] [PASSED] 0x674E (CRESCENTISLAND)
[21:28:40] [PASSED] 0x674F (CRESCENTISLAND)
[21:28:40] [PASSED] 0x6750 (CRESCENTISLAND)
[21:28:40] [PASSED] 0xD750 (NOVALAKE_P)
[21:28:40] [PASSED] 0xD751 (NOVALAKE_P)
[21:28:40] [PASSED] 0xD752 (NOVALAKE_P)
[21:28:40] [PASSED] 0xD753 (NOVALAKE_P)
[21:28:40] [PASSED] 0xD754 (NOVALAKE_P)
[21:28:40] [PASSED] 0xD755 (NOVALAKE_P)
[21:28:40] [PASSED] 0xD756 (NOVALAKE_P)
[21:28:40] [PASSED] 0xD757 (NOVALAKE_P)
[21:28:40] [PASSED] 0xD75F (NOVALAKE_P)
[21:28:40] =============== [PASSED] check_platform_desc ===============
[21:28:40] ===================== [PASSED] xe_pci ======================
[21:28:40] ============= xe_rtp_tables_test (3 subtests) ==============
[21:28:40] ================== xe_rtp_table_gt_test  ===================
[21:28:40] [PASSED] 14011060649
[21:28:40] [PASSED] 14011059788
[21:28:40] [PASSED] 14015795083
[21:28:40] [PASSED] 16021867713
[21:28:40] [PASSED] 14019449301
[21:28:40] [PASSED] 16028005424
[21:28:40] [PASSED] 14026578760
[21:28:40] [PASSED] 1409420604
[21:28:40] [PASSED] 1408615072
[21:28:40] [PASSED] 22010523718
[21:28:40] [PASSED] 14011006942
[21:28:40] [PASSED] 14014830051
[21:28:40] [PASSED] 18018781329
[21:28:40] [PASSED] 1509235366
[21:28:40] [PASSED] 18018781329
[21:28:40] [PASSED] 16016694945
[21:28:40] [PASSED] 14018575942
[21:28:40] [PASSED] 22016670082
[21:28:40] [PASSED] 22016670082
[21:28:40] [PASSED] 14017421178
[21:28:40] [PASSED] 16025250150
[21:28:40] [PASSED] 14021871409
[21:28:40] [PASSED] 16021865536
[21:28:40] [PASSED] 14021486841
[21:28:40] [PASSED] 14025160223
[21:28:40] [PASSED] 14026144927, 16029437861
[21:28:40] [PASSED] 14025635424
[21:28:40] [PASSED] 16028005424
[21:28:40] ============== [PASSED] xe_rtp_table_gt_test ===============
[21:28:40] ================== xe_rtp_table_oob_test  ==================
[21:28:40] [PASSED] 1607983814
[21:28:40] [PASSED] 16010904313
[21:28:40] [PASSED] 18022495364
[21:28:40] [PASSED] 22012773006
[21:28:40] [PASSED] 14014475959
[21:28:40] [PASSED] 22011391025
[21:28:40] [PASSED] 22012727170
[21:28:40] [PASSED] 22012727685
[21:28:40] [PASSED] 22016596838
[21:28:40] [PASSED] 18020744125
[21:28:40] [PASSED] 1409600907
[21:28:40] [PASSED] 22014953428
[21:28:40] [PASSED] 16017236439
[21:28:40] [PASSED] 14019821291
[21:28:40] [PASSED] 14015076503
[21:28:40] [PASSED] 14018913170
[21:28:40] [PASSED] 14018094691
[21:28:40] [PASSED] 18024947630
[21:28:40] [PASSED] 16022287689
[21:28:40] [PASSED] 13011645652
[21:28:40] [PASSED] 14022293748
[21:28:40] [PASSED] 22019794406
[21:28:40] [PASSED] 22019338487
[21:28:40] [PASSED] 16023588340
[21:28:40] [PASSED] 14019789679
[21:28:40] [PASSED] 14022866841
[21:28:40] [PASSED] 16021333562
[21:28:40] [PASSED] 14016712196
[21:28:40] [PASSED] 14015568240
[21:28:40] [PASSED] 18013179988
[21:28:40] [PASSED] 1508761755
[21:28:40] [PASSED] 16023105232
[21:28:40] [PASSED] 16026508708
[21:28:40] [PASSED] 14020001231
[21:28:40] [PASSED] 16023683509
[21:28:40] [PASSED] 14025515070
[21:28:40] [PASSED] 15015404425_disable
[21:28:40] [PASSED] 16026007364
[21:28:40] [PASSED] 14020316580
[21:28:40] [PASSED] 14025883347
[21:28:40] ============== [PASSED] xe_rtp_table_oob_test ==============
[21:28:40] ================ xe_rtp_table_dev_oob_test  ================
[21:28:40] [PASSED] 22010954014
[21:28:40] [PASSED] 15015404425
[21:28:40] [PASSED] 22019338487_display
[21:28:40] [PASSED] 14022085890
[21:28:40] [PASSED] 14026539277
[21:28:40] [PASSED] 14026633728
[21:28:40] [PASSED] 14026746987
[21:28:40] [PASSED] 14026779378
[21:28:40] ============ [PASSED] xe_rtp_table_dev_oob_test ============
[21:28:40] =============== [PASSED] xe_rtp_tables_test ================
[21:28:40] =================== xe_rtp (2 subtests) ====================
[21:28:40] =============== xe_rtp_process_to_sr_tests  ================
[21:28:40] [PASSED] coalesce-same-reg
[21:28:40] [PASSED] no-match-no-add
[21:28:40] [PASSED] match-or
[21:28:40] [PASSED] match-or-xfail
[21:28:40] [PASSED] no-match-no-add-multiple-rules
[21:28:40] [PASSED] two-regs-two-entries
[21:28:40] [PASSED] clr-one-set-other
[21:28:40] [PASSED] set-field
[21:28:40] [PASSED] conflict-duplicate
[21:28:40] [PASSED] conflict-not-disjoint
[21:28:40] [PASSED] conflict-reg-type
[21:28:40] =========== [PASSED] xe_rtp_process_to_sr_tests ============
[21:28:40] ================== xe_rtp_process_tests  ===================
[21:28:40] [PASSED] active1
[21:28:40] [PASSED] active2
[21:28:40] [PASSED] active-inactive
[21:28:40] [PASSED] inactive-active
[21:28:40] [PASSED] inactive-1st_or_active-inactive
[21:28:40] [PASSED] inactive-2nd_or_active-inactive
[21:28:40] [PASSED] inactive-last_or_active-inactive
[21:28:40] [PASSED] inactive-no_or_active-inactive
[21:28:40] ============== [PASSED] xe_rtp_process_tests ===============
[21:28:40] ===================== [PASSED] xe_rtp ======================
[21:28:40] ==================== xe_wa (1 subtest) =====================
[21:28:40] ======================== xe_wa_gt  =========================
[21:28:40] [PASSED] TIGERLAKE B0
[21:28:40] [PASSED] DG1 A0
[21:28:40] [PASSED] DG1 B0
[21:28:40] [PASSED] ALDERLAKE_S A0
[21:28:40] [PASSED] ALDERLAKE_S B0
[21:28:40] [PASSED] ALDERLAKE_S C0
[21:28:40] [PASSED] ALDERLAKE_S D0
[21:28:40] [PASSED] ALDERLAKE_P A0
[21:28:40] [PASSED] ALDERLAKE_P B0
[21:28:40] [PASSED] ALDERLAKE_P C0
[21:28:40] [PASSED] ALDERLAKE_S RPLS D0
[21:28:40] [PASSED] ALDERLAKE_P RPLU E0
[21:28:40] [PASSED] DG2 G10 C0
[21:28:40] [PASSED] DG2 G11 B1
[21:28:40] [PASSED] DG2 G12 A1
[21:28:40] [PASSED] METEORLAKE 12.70(Xe_LPG) A0 13.00(Xe_LPM+) A0
[21:28:40] [PASSED] METEORLAKE 12.71(Xe_LPG) A0 13.00(Xe_LPM+) A0
[21:28:40] [PASSED] METEORLAKE 12.74(Xe_LPG+) A0 13.00(Xe_LPM+) A0
[21:28:40] [PASSED] LUNARLAKE 20.04(Xe2_LPG) A0 20.00(Xe2_LPM) A0
[21:28:40] [PASSED] LUNARLAKE 20.04(Xe2_LPG) B0 20.00(Xe2_LPM) A0
[21:28:40] [PASSED] BATTLEMAGE 20.01(Xe2_HPG) A0 13.01(Xe2_HPM) A1
[21:28:40] [PASSED] PANTHERLAKE 30.00(Xe3_LPG) A0 30.00(Xe3_LPM) A0
[21:28:40] ==================== [PASSED] xe_wa_gt =====================
[21:28:40] ====================== [PASSED] xe_wa ======================
[21:28:40] ============================================================
[21:28:40] Testing complete. Ran 677 tests: passed: 659, skipped: 18
[21:28:40] Elapsed time: 36.411s total, 4.328s configuring, 31.417s building, 0.613s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/tests/.kunitconfig
[21:28:40] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[21:28:42] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[21:29:06] Starting KUnit Kernel (1/1)...
[21:29:06] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[21:29:06] ============ drm_test_pick_cmdline (2 subtests) ============
[21:29:06] [PASSED] drm_test_pick_cmdline_res_1920_1080_60
[21:29:06] =============== drm_test_pick_cmdline_named  ===============
[21:29:06] [PASSED] NTSC
[21:29:06] [PASSED] NTSC-J
[21:29:06] [PASSED] PAL
[21:29:06] [PASSED] PAL-M
[21:29:06] =========== [PASSED] drm_test_pick_cmdline_named ===========
[21:29:06] ============== [PASSED] drm_test_pick_cmdline ==============
[21:29:06] == drm_test_atomic_get_connector_for_encoder (1 subtest) ===
[21:29:06] [PASSED] drm_test_drm_atomic_get_connector_for_encoder
[21:29:06] ==== [PASSED] drm_test_atomic_get_connector_for_encoder ====
[21:29:06] =========== drm_validate_clone_mode (2 subtests) ===========
[21:29:06] ============== drm_test_check_in_clone_mode  ===============
[21:29:06] [PASSED] in_clone_mode
[21:29:06] [PASSED] not_in_clone_mode
[21:29:06] ========== [PASSED] drm_test_check_in_clone_mode ===========
[21:29:06] =============== drm_test_check_valid_clones  ===============
[21:29:06] [PASSED] not_in_clone_mode
[21:29:06] [PASSED] valid_clone
[21:29:06] [PASSED] invalid_clone
[21:29:06] =========== [PASSED] drm_test_check_valid_clones ===========
[21:29:06] ============= [PASSED] drm_validate_clone_mode =============
[21:29:06] ============= drm_validate_modeset (1 subtest) =============
[21:29:06] [PASSED] drm_test_check_connector_changed_modeset
[21:29:06] ============== [PASSED] drm_validate_modeset ===============
[21:29:06] ====== drm_test_bridge_get_current_state (2 subtests) ======
[21:29:06] [PASSED] drm_test_drm_bridge_get_current_state_atomic
[21:29:06] [PASSED] drm_test_drm_bridge_get_current_state_legacy
[21:29:06] ======== [PASSED] drm_test_bridge_get_current_state ========
[21:29:06] ====== drm_test_bridge_helper_reset_crtc (3 subtests) ======
[21:29:06] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic
[21:29:06] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic_disabled
[21:29:06] [PASSED] drm_test_drm_bridge_helper_reset_crtc_legacy
[21:29:06] ======== [PASSED] drm_test_bridge_helper_reset_crtc ========
[21:29:06] ============== drm_bridge_alloc (2 subtests) ===============
[21:29:06] [PASSED] drm_test_drm_bridge_alloc_basic
[21:29:06] [PASSED] drm_test_drm_bridge_alloc_get_put
[21:29:06] ================ [PASSED] drm_bridge_alloc =================
[21:29:06] ============= drm_cmdline_parser (40 subtests) =============
[21:29:06] [PASSED] drm_test_cmdline_force_d_only
[21:29:06] [PASSED] drm_test_cmdline_force_D_only_dvi
[21:29:06] [PASSED] drm_test_cmdline_force_D_only_hdmi
[21:29:06] [PASSED] drm_test_cmdline_force_D_only_not_digital
[21:29:06] [PASSED] drm_test_cmdline_force_e_only
[21:29:06] [PASSED] drm_test_cmdline_res
[21:29:06] [PASSED] drm_test_cmdline_res_vesa
[21:29:06] [PASSED] drm_test_cmdline_res_vesa_rblank
[21:29:06] [PASSED] drm_test_cmdline_res_rblank
[21:29:06] [PASSED] drm_test_cmdline_res_bpp
[21:29:06] [PASSED] drm_test_cmdline_res_refresh
[21:29:06] [PASSED] drm_test_cmdline_res_bpp_refresh
[21:29:06] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced
[21:29:06] [PASSED] drm_test_cmdline_res_bpp_refresh_margins
[21:29:06] [PASSED] drm_test_cmdline_res_bpp_refresh_force_off
[21:29:06] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on
[21:29:06] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_analog
[21:29:06] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_digital
[21:29:06] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced_margins_force_on
[21:29:06] [PASSED] drm_test_cmdline_res_margins_force_on
[21:29:06] [PASSED] drm_test_cmdline_res_vesa_margins
[21:29:06] [PASSED] drm_test_cmdline_name
[21:29:06] [PASSED] drm_test_cmdline_name_bpp
[21:29:06] [PASSED] drm_test_cmdline_name_option
[21:29:06] [PASSED] drm_test_cmdline_name_bpp_option
[21:29:06] [PASSED] drm_test_cmdline_rotate_0
[21:29:06] [PASSED] drm_test_cmdline_rotate_90
[21:29:06] [PASSED] drm_test_cmdline_rotate_180
[21:29:06] [PASSED] drm_test_cmdline_rotate_270
[21:29:06] [PASSED] drm_test_cmdline_hmirror
[21:29:06] [PASSED] drm_test_cmdline_vmirror
[21:29:06] [PASSED] drm_test_cmdline_margin_options
[21:29:06] [PASSED] drm_test_cmdline_multiple_options
[21:29:06] [PASSED] drm_test_cmdline_bpp_extra_and_option
[21:29:06] [PASSED] drm_test_cmdline_extra_and_option
[21:29:06] [PASSED] drm_test_cmdline_freestanding_options
[21:29:06] [PASSED] drm_test_cmdline_freestanding_force_e_and_options
[21:29:06] [PASSED] drm_test_cmdline_panel_orientation
[21:29:06] ================ drm_test_cmdline_invalid  =================
[21:29:06] [PASSED] margin_only
[21:29:06] [PASSED] interlace_only
[21:29:06] [PASSED] res_missing_x
[21:29:06] [PASSED] res_missing_y
[21:29:06] [PASSED] res_bad_y
[21:29:06] [PASSED] res_missing_y_bpp
[21:29:06] [PASSED] res_bad_bpp
[21:29:06] [PASSED] res_bad_refresh
[21:29:06] [PASSED] res_bpp_refresh_force_on_off
[21:29:06] [PASSED] res_invalid_mode
[21:29:06] [PASSED] res_bpp_wrong_place_mode
[21:29:06] [PASSED] name_bpp_refresh
[21:29:06] [PASSED] name_refresh
[21:29:06] [PASSED] name_refresh_wrong_mode
[21:29:06] [PASSED] name_refresh_invalid_mode
[21:29:06] [PASSED] rotate_multiple
[21:29:06] [PASSED] rotate_invalid_val
[21:29:06] [PASSED] rotate_truncated
[21:29:06] [PASSED] invalid_option
[21:29:06] [PASSED] invalid_tv_option
[21:29:06] [PASSED] truncated_tv_option
[21:29:06] ============ [PASSED] drm_test_cmdline_invalid =============
[21:29:06] =============== drm_test_cmdline_tv_options  ===============
[21:29:06] [PASSED] NTSC
[21:29:06] [PASSED] NTSC_443
[21:29:06] [PASSED] NTSC_J
[21:29:06] [PASSED] PAL
[21:29:06] [PASSED] PAL_M
[21:29:06] [PASSED] PAL_N
[21:29:06] [PASSED] SECAM
[21:29:06] [PASSED] MONO_525
[21:29:06] [PASSED] MONO_625
[21:29:06] =========== [PASSED] drm_test_cmdline_tv_options ===========
[21:29:06] =============== [PASSED] drm_cmdline_parser ================
[21:29:06] ========== drmm_connector_hdmi_init (20 subtests) ==========
[21:29:06] [PASSED] drm_test_connector_hdmi_init_valid
[21:29:06] [PASSED] drm_test_connector_hdmi_init_bpc_8
[21:29:06] [PASSED] drm_test_connector_hdmi_init_bpc_10
[21:29:06] [PASSED] drm_test_connector_hdmi_init_bpc_12
[21:29:06] [PASSED] drm_test_connector_hdmi_init_bpc_invalid
[21:29:06] [PASSED] drm_test_connector_hdmi_init_bpc_null
[21:29:06] [PASSED] drm_test_connector_hdmi_init_formats_empty
[21:29:06] [PASSED] drm_test_connector_hdmi_init_formats_no_rgb
[21:29:06] === drm_test_connector_hdmi_init_formats_yuv420_allowed  ===
[21:29:06] [PASSED] supported_formats=0x9 yuv420_allowed=1
[21:29:06] [PASSED] supported_formats=0x9 yuv420_allowed=0
[21:29:06] [PASSED] supported_formats=0x5 yuv420_allowed=1
[21:29:06] [PASSED] supported_formats=0x5 yuv420_allowed=0
[21:29:06] === [PASSED] drm_test_connector_hdmi_init_formats_yuv420_allowed ===
[21:29:06] [PASSED] drm_test_connector_hdmi_init_null_ddc
[21:29:06] [PASSED] drm_test_connector_hdmi_init_null_product
[21:29:06] [PASSED] drm_test_connector_hdmi_init_null_vendor
[21:29:06] [PASSED] drm_test_connector_hdmi_init_product_length_exact
[21:29:06] [PASSED] drm_test_connector_hdmi_init_product_length_too_long
[21:29:06] [PASSED] drm_test_connector_hdmi_init_product_valid
[21:29:06] [PASSED] drm_test_connector_hdmi_init_vendor_length_exact
[21:29:06] [PASSED] drm_test_connector_hdmi_init_vendor_length_too_long
[21:29:06] [PASSED] drm_test_connector_hdmi_init_vendor_valid
[21:29:06] ========= drm_test_connector_hdmi_init_type_valid  =========
[21:29:06] [PASSED] HDMI-A
[21:29:06] [PASSED] HDMI-B
[21:29:06] ===== [PASSED] drm_test_connector_hdmi_init_type_valid =====
[21:29:06] ======== drm_test_connector_hdmi_init_type_invalid  ========
[21:29:06] [PASSED] Unknown
[21:29:06] [PASSED] VGA
[21:29:06] [PASSED] DVI-I
[21:29:06] [PASSED] DVI-D
[21:29:06] [PASSED] DVI-A
[21:29:06] [PASSED] Composite
[21:29:06] [PASSED] SVIDEO
[21:29:06] [PASSED] LVDS
[21:29:06] [PASSED] Component
[21:29:06] [PASSED] DIN
[21:29:06] [PASSED] DP
[21:29:06] [PASSED] TV
[21:29:06] [PASSED] eDP
[21:29:06] [PASSED] Virtual
[21:29:06] [PASSED] DSI
[21:29:06] [PASSED] DPI
[21:29:06] [PASSED] Writeback
[21:29:06] [PASSED] SPI
[21:29:06] [PASSED] USB
[21:29:06] ==== [PASSED] drm_test_connector_hdmi_init_type_invalid ====
[21:29:06] ============ [PASSED] drmm_connector_hdmi_init =============
[21:29:06] ============= drmm_connector_init (3 subtests) =============
[21:29:06] [PASSED] drm_test_drmm_connector_init
[21:29:06] [PASSED] drm_test_drmm_connector_init_null_ddc
[21:29:06] ========= drm_test_drmm_connector_init_type_valid  =========
[21:29:06] [PASSED] Unknown
[21:29:06] [PASSED] VGA
[21:29:06] [PASSED] DVI-I
[21:29:06] [PASSED] DVI-D
[21:29:06] [PASSED] DVI-A
[21:29:06] [PASSED] Composite
[21:29:06] [PASSED] SVIDEO
[21:29:06] [PASSED] LVDS
[21:29:06] [PASSED] Component
[21:29:06] [PASSED] DIN
[21:29:06] [PASSED] DP
[21:29:06] [PASSED] HDMI-A
[21:29:06] [PASSED] HDMI-B
[21:29:06] [PASSED] TV
[21:29:06] [PASSED] eDP
[21:29:06] [PASSED] Virtual
[21:29:06] [PASSED] DSI
[21:29:06] [PASSED] DPI
[21:29:06] [PASSED] Writeback
[21:29:06] [PASSED] SPI
[21:29:06] [PASSED] USB
[21:29:06] ===== [PASSED] drm_test_drmm_connector_init_type_valid =====
[21:29:06] =============== [PASSED] drmm_connector_init ===============
[21:29:06] ========= drm_connector_dynamic_init (6 subtests) ==========
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_init
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_init_null_ddc
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_init_not_added
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_init_properties
[21:29:06] ===== drm_test_drm_connector_dynamic_init_type_valid  ======
[21:29:06] [PASSED] Unknown
[21:29:06] [PASSED] VGA
[21:29:06] [PASSED] DVI-I
[21:29:06] [PASSED] DVI-D
[21:29:06] [PASSED] DVI-A
[21:29:06] [PASSED] Composite
[21:29:06] [PASSED] SVIDEO
[21:29:06] [PASSED] LVDS
[21:29:06] [PASSED] Component
[21:29:06] [PASSED] DIN
[21:29:06] [PASSED] DP
[21:29:06] [PASSED] HDMI-A
[21:29:06] [PASSED] HDMI-B
[21:29:06] [PASSED] TV
[21:29:06] [PASSED] eDP
[21:29:06] [PASSED] Virtual
[21:29:06] [PASSED] DSI
[21:29:06] [PASSED] DPI
[21:29:06] [PASSED] Writeback
[21:29:06] [PASSED] SPI
[21:29:06] [PASSED] USB
[21:29:06] = [PASSED] drm_test_drm_connector_dynamic_init_type_valid ==
[21:29:06] ======== drm_test_drm_connector_dynamic_init_name  =========
[21:29:06] [PASSED] Unknown
[21:29:06] [PASSED] VGA
[21:29:06] [PASSED] DVI-I
[21:29:06] [PASSED] DVI-D
[21:29:06] [PASSED] DVI-A
[21:29:06] [PASSED] Composite
[21:29:06] [PASSED] SVIDEO
[21:29:06] [PASSED] LVDS
[21:29:06] [PASSED] Component
[21:29:06] [PASSED] DIN
[21:29:06] [PASSED] DP
[21:29:06] [PASSED] HDMI-A
[21:29:06] [PASSED] HDMI-B
[21:29:06] [PASSED] TV
[21:29:06] [PASSED] eDP
[21:29:06] [PASSED] Virtual
[21:29:06] [PASSED] DSI
[21:29:06] [PASSED] DPI
[21:29:06] [PASSED] Writeback
[21:29:06] [PASSED] SPI
[21:29:06] [PASSED] USB
[21:29:06] ==== [PASSED] drm_test_drm_connector_dynamic_init_name =====
[21:29:06] =========== [PASSED] drm_connector_dynamic_init ============
[21:29:06] ==== drm_connector_dynamic_register_early (4 subtests) =====
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_register_early_on_list
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_register_early_defer
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_register_early_no_init
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_register_early_no_mode_object
[21:29:06] ====== [PASSED] drm_connector_dynamic_register_early =======
[21:29:06] ======= drm_connector_dynamic_register (7 subtests) ========
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_register_on_list
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_register_no_defer
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_register_no_init
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_register_mode_object
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_register_sysfs
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_register_sysfs_name
[21:29:06] [PASSED] drm_test_drm_connector_dynamic_register_debugfs
[21:29:06] ========= [PASSED] drm_connector_dynamic_register ==========
[21:29:06] = drm_connector_attach_broadcast_rgb_property (2 subtests) =
[21:29:06] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property
[21:29:06] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property_hdmi_connector
[21:29:06] === [PASSED] drm_connector_attach_broadcast_rgb_property ===
[21:29:06] ========== drm_get_tv_mode_from_name (2 subtests) ==========
[21:29:06] ========== drm_test_get_tv_mode_from_name_valid  ===========
[21:29:06] [PASSED] NTSC
[21:29:06] [PASSED] NTSC-443
[21:29:06] [PASSED] NTSC-J
[21:29:06] [PASSED] PAL
[21:29:06] [PASSED] PAL-M
[21:29:06] [PASSED] PAL-N
[21:29:06] [PASSED] SECAM
[21:29:06] [PASSED] Mono
[21:29:06] ====== [PASSED] drm_test_get_tv_mode_from_name_valid =======
[21:29:06] [PASSED] drm_test_get_tv_mode_from_name_truncated
[21:29:06] ============ [PASSED] drm_get_tv_mode_from_name ============
[21:29:06] = drm_test_connector_hdmi_compute_mode_clock (12 subtests) =
[21:29:06] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb
[21:29:06] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc
[21:29:06] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc_vic_1
[21:29:06] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc
[21:29:06] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc_vic_1
[21:29:06] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_double
[21:29:06] = drm_test_connector_hdmi_compute_mode_clock_yuv420_valid  =
[21:29:06] [PASSED] VIC 96
[21:29:06] [PASSED] VIC 97
[21:29:06] [PASSED] VIC 101
[21:29:06] [PASSED] VIC 102
[21:29:06] [PASSED] VIC 106
[21:29:06] [PASSED] VIC 107
[21:29:06] === [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_valid ===
[21:29:06] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_10_bpc
[21:29:06] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_12_bpc
[21:29:06] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_8_bpc
[21:29:06] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_10_bpc
[21:29:06] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_12_bpc
[21:29:06] === [PASSED] drm_test_connector_hdmi_compute_mode_clock ====
[21:29:06] == drm_hdmi_connector_get_broadcast_rgb_name (2 subtests) ==
[21:29:06] === drm_test_drm_hdmi_connector_get_broadcast_rgb_name  ====
[21:29:06] [PASSED] Automatic
[21:29:06] [PASSED] Full
[21:29:06] [PASSED] Limited 16:235
[21:29:06] === [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name ===
[21:29:06] [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name_invalid
[21:29:06] ==== [PASSED] drm_hdmi_connector_get_broadcast_rgb_name ====
[21:29:06] == drm_hdmi_connector_get_output_format_name (2 subtests) ==
[21:29:06] === drm_test_drm_hdmi_connector_get_output_format_name  ====
[21:29:06] [PASSED] RGB
[21:29:06] [PASSED] YUV 4:2:0
[21:29:06] [PASSED] YUV 4:2:2
[21:29:06] [PASSED] YUV 4:4:4
[21:29:06] === [PASSED] drm_test_drm_hdmi_connector_get_output_format_name ===
[21:29:06] [PASSED] drm_test_drm_hdmi_connector_get_output_format_name_invalid
[21:29:06] ==== [PASSED] drm_hdmi_connector_get_output_format_name ====
[21:29:06] ============= drm_damage_helper (21 subtests) ==============
[21:29:06] [PASSED] drm_test_damage_iter_no_damage
[21:29:06] [PASSED] drm_test_damage_iter_no_damage_fractional_src
[21:29:06] [PASSED] drm_test_damage_iter_no_damage_src_moved
[21:29:06] [PASSED] drm_test_damage_iter_no_damage_fractional_src_moved
[21:29:06] [PASSED] drm_test_damage_iter_no_damage_not_visible
[21:29:06] [PASSED] drm_test_damage_iter_no_damage_no_crtc
[21:29:06] [PASSED] drm_test_damage_iter_no_damage_no_fb
[21:29:06] [PASSED] drm_test_damage_iter_simple_damage
[21:29:06] [PASSED] drm_test_damage_iter_single_damage
[21:29:06] [PASSED] drm_test_damage_iter_single_damage_intersect_src
[21:29:06] [PASSED] drm_test_damage_iter_single_damage_outside_src
[21:29:06] [PASSED] drm_test_damage_iter_single_damage_fractional_src
[21:29:06] [PASSED] drm_test_damage_iter_single_damage_intersect_fractional_src
[21:29:06] [PASSED] drm_test_damage_iter_single_damage_outside_fractional_src
[21:29:06] [PASSED] drm_test_damage_iter_single_damage_src_moved
[21:29:06] [PASSED] drm_test_damage_iter_single_damage_fractional_src_moved
[21:29:06] [PASSED] drm_test_damage_iter_damage
[21:29:06] [PASSED] drm_test_damage_iter_damage_one_intersect
[21:29:06] [PASSED] drm_test_damage_iter_damage_one_outside
[21:29:06] [PASSED] drm_test_damage_iter_damage_src_moved
[21:29:06] [PASSED] drm_test_damage_iter_damage_not_visible
[21:29:06] ================ [PASSED] drm_damage_helper ================
[21:29:06] ============== drm_dp_mst_helper (3 subtests) ==============
[21:29:06] ============== drm_test_dp_mst_calc_pbn_mode  ==============
[21:29:06] [PASSED] Clock 154000 BPP 30 DSC disabled
[21:29:06] [PASSED] Clock 234000 BPP 30 DSC disabled
[21:29:06] [PASSED] Clock 297000 BPP 24 DSC disabled
[21:29:06] [PASSED] Clock 332880 BPP 24 DSC enabled
[21:29:06] [PASSED] Clock 324540 BPP 24 DSC enabled
[21:29:06] ========== [PASSED] drm_test_dp_mst_calc_pbn_mode ==========
[21:29:06] ============== drm_test_dp_mst_calc_pbn_div  ===============
[21:29:06] [PASSED] Link rate 2000000 lane count 4
[21:29:06] [PASSED] Link rate 2000000 lane count 2
[21:29:06] [PASSED] Link rate 2000000 lane count 1
[21:29:06] [PASSED] Link rate 1350000 lane count 4
[21:29:06] [PASSED] Link rate 1350000 lane count 2
[21:29:06] [PASSED] Link rate 1350000 lane count 1
[21:29:06] [PASSED] Link rate 1000000 lane count 4
[21:29:06] [PASSED] Link rate 1000000 lane count 2
[21:29:06] [PASSED] Link rate 1000000 lane count 1
[21:29:06] [PASSED] Link rate 810000 lane count 4
[21:29:06] [PASSED] Link rate 810000 lane count 2
[21:29:06] [PASSED] Link rate 810000 lane count 1
[21:29:06] [PASSED] Link rate 540000 lane count 4
[21:29:06] [PASSED] Link rate 540000 lane count 2
[21:29:06] [PASSED] Link rate 540000 lane count 1
[21:29:06] [PASSED] Link rate 270000 lane count 4
[21:29:06] [PASSED] Link rate 270000 lane count 2
[21:29:06] [PASSED] Link rate 270000 lane count 1
[21:29:06] [PASSED] Link rate 162000 lane count 4
[21:29:06] [PASSED] Link rate 162000 lane count 2
[21:29:06] [PASSED] Link rate 162000 lane count 1
[21:29:06] ========== [PASSED] drm_test_dp_mst_calc_pbn_div ===========
[21:29:06] ========= drm_test_dp_mst_sideband_msg_req_decode  =========
[21:29:06] [PASSED] DP_ENUM_PATH_RESOURCES with port number
[21:29:06] [PASSED] DP_POWER_UP_PHY with port number
[21:29:06] [PASSED] DP_POWER_DOWN_PHY with port number
[21:29:06] [PASSED] DP_ALLOCATE_PAYLOAD with SDP stream sinks
[21:29:06] [PASSED] DP_ALLOCATE_PAYLOAD with port number
[21:29:06] [PASSED] DP_ALLOCATE_PAYLOAD with VCPI
[21:29:06] [PASSED] DP_ALLOCATE_PAYLOAD with PBN
[21:29:06] [PASSED] DP_QUERY_PAYLOAD with port number
[21:29:06] [PASSED] DP_QUERY_PAYLOAD with VCPI
[21:29:06] [PASSED] DP_REMOTE_DPCD_READ with port number
[21:29:06] [PASSED] DP_REMOTE_DPCD_READ with DPCD address
[21:29:06] [PASSED] DP_REMOTE_DPCD_READ with max number of bytes
[21:29:06] [PASSED] DP_REMOTE_DPCD_WRITE with port number
[21:29:06] [PASSED] DP_REMOTE_DPCD_WRITE with DPCD address
[21:29:06] [PASSED] DP_REMOTE_DPCD_WRITE with data array
[21:29:06] [PASSED] DP_REMOTE_I2C_READ with port number
[21:29:06] [PASSED] DP_REMOTE_I2C_READ with I2C device ID
[21:29:06] [PASSED] DP_REMOTE_I2C_READ with transactions array
[21:29:06] [PASSED] DP_REMOTE_I2C_WRITE with port number
[21:29:06] [PASSED] DP_REMOTE_I2C_WRITE with I2C device ID
[21:29:06] [PASSED] DP_REMOTE_I2C_WRITE with data array
[21:29:06] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream ID
[21:29:06] [PASSED] DP_QUERY_STREAM_ENC_STATUS with client ID
[21:29:06] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream event
[21:29:06] [PASSED] DP_QUERY_STREAM_ENC_STATUS with valid stream event
[21:29:06] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream behavior
[21:29:06] [PASSED] DP_QUERY_STREAM_ENC_STATUS with a valid stream behavior
[21:29:06] ===== [PASSED] drm_test_dp_mst_sideband_msg_req_decode =====
[21:29:06] ================ [PASSED] drm_dp_mst_helper ================
[21:29:06] ================== drm_exec (7 subtests) ===================
[21:29:06] [PASSED] sanitycheck
[21:29:06] [PASSED] test_lock
[21:29:06] [PASSED] test_lock_unlock
[21:29:06] [PASSED] test_duplicates
[21:29:06] [PASSED] test_prepare
[21:29:06] [PASSED] test_prepare_array
[21:29:06] [PASSED] test_multiple_loops
[21:29:06] ==================== [PASSED] drm_exec =====================
[21:29:06] =========== drm_format_helper_test (17 subtests) ===========
[21:29:06] ============== drm_test_fb_xrgb8888_to_gray8  ==============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ========== [PASSED] drm_test_fb_xrgb8888_to_gray8 ==========
[21:29:06] ============= drm_test_fb_xrgb8888_to_rgb332  ==============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb332 ==========
[21:29:06] ============= drm_test_fb_xrgb8888_to_rgb565  ==============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb565 ==========
[21:29:06] ============ drm_test_fb_xrgb8888_to_xrgb1555  =============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ======== [PASSED] drm_test_fb_xrgb8888_to_xrgb1555 =========
[21:29:06] ============ drm_test_fb_xrgb8888_to_argb1555  =============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ======== [PASSED] drm_test_fb_xrgb8888_to_argb1555 =========
[21:29:06] ============ drm_test_fb_xrgb8888_to_rgba5551  =============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ======== [PASSED] drm_test_fb_xrgb8888_to_rgba5551 =========
[21:29:06] ============= drm_test_fb_xrgb8888_to_rgb888  ==============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb888 ==========
[21:29:06] ============= drm_test_fb_xrgb8888_to_bgr888  ==============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ========= [PASSED] drm_test_fb_xrgb8888_to_bgr888 ==========
[21:29:06] ============ drm_test_fb_xrgb8888_to_argb8888  =============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ======== [PASSED] drm_test_fb_xrgb8888_to_argb8888 =========
[21:29:06] =========== drm_test_fb_xrgb8888_to_xrgb2101010  ===========
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ======= [PASSED] drm_test_fb_xrgb8888_to_xrgb2101010 =======
[21:29:06] =========== drm_test_fb_xrgb8888_to_argb2101010  ===========
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ======= [PASSED] drm_test_fb_xrgb8888_to_argb2101010 =======
[21:29:06] ============== drm_test_fb_xrgb8888_to_mono  ===============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ========== [PASSED] drm_test_fb_xrgb8888_to_mono ===========
[21:29:06] ==================== drm_test_fb_swab  =====================
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ================ [PASSED] drm_test_fb_swab =================
[21:29:06] ============ drm_test_fb_xrgb8888_to_xbgr8888  =============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ======== [PASSED] drm_test_fb_xrgb8888_to_xbgr8888 =========
[21:29:06] ============ drm_test_fb_xrgb8888_to_abgr8888  =============
[21:29:06] [PASSED] single_pixel_source_buffer
[21:29:06] [PASSED] single_pixel_clip_rectangle
[21:29:06] [PASSED] well_known_colors
[21:29:06] [PASSED] destination_pitch
[21:29:06] ======== [PASSED] drm_test_fb_xrgb8888_to_abgr8888 =========
[21:29:06] ================= drm_test_fb_clip_offset  =================
[21:29:06] [PASSED] pass through
[21:29:06] [PASSED] horizontal offset
[21:29:06] [PASSED] vertical offset
[21:29:06] [PASSED] horizontal and vertical offset
[21:29:06] [PASSED] horizontal offset (custom pitch)
[21:29:06] [PASSED] vertical offset (custom pitch)
[21:29:06] [PASSED] horizontal and vertical offset (custom pitch)
[21:29:06] ============= [PASSED] drm_test_fb_clip_offset =============
[21:29:06] =================== drm_test_fb_memcpy  ====================
[21:29:06] [PASSED] single_pixel_source_buffer: XR24 little-endian (0x34325258)
[21:29:06] [PASSED] single_pixel_source_buffer: XRA8 little-endian (0x38415258)
[21:29:06] [PASSED] single_pixel_source_buffer: YU24 little-endian (0x34325559)
[21:29:06] [PASSED] single_pixel_clip_rectangle: XB24 little-endian (0x34324258)
[21:29:06] [PASSED] single_pixel_clip_rectangle: XRA8 little-endian (0x38415258)
[21:29:06] [PASSED] single_pixel_clip_rectangle: YU24 little-endian (0x34325559)
[21:29:06] [PASSED] well_known_colors: XB24 little-endian (0x34324258)
[21:29:06] [PASSED] well_known_colors: XRA8 little-endian (0x38415258)
[21:29:06] [PASSED] well_known_colors: YU24 little-endian (0x34325559)
[21:29:06] [PASSED] destination_pitch: XB24 little-endian (0x34324258)
[21:29:06] [PASSED] destination_pitch: XRA8 little-endian (0x38415258)
[21:29:06] [PASSED] destination_pitch: YU24 little-endian (0x34325559)
[21:29:06] =============== [PASSED] drm_test_fb_memcpy ================
[21:29:06] ============= [PASSED] drm_format_helper_test ==============
[21:29:06] ================= drm_format (18 subtests) =================
[21:29:06] [PASSED] drm_test_format_block_width_invalid
[21:29:06] [PASSED] drm_test_format_block_width_one_plane
[21:29:06] [PASSED] drm_test_format_block_width_two_plane
[21:29:06] [PASSED] drm_test_format_block_width_three_plane
[21:29:06] [PASSED] drm_test_format_block_width_tiled
[21:29:06] [PASSED] drm_test_format_block_height_invalid
[21:29:06] [PASSED] drm_test_format_block_height_one_plane
[21:29:06] [PASSED] drm_test_format_block_height_two_plane
[21:29:06] [PASSED] drm_test_format_block_height_three_plane
[21:29:06] [PASSED] drm_test_format_block_height_tiled
[21:29:06] [PASSED] drm_test_format_min_pitch_invalid
[21:29:06] [PASSED] drm_test_format_min_pitch_one_plane_8bpp
[21:29:06] [PASSED] drm_test_format_min_pitch_one_plane_16bpp
[21:29:06] [PASSED] drm_test_format_min_pitch_one_plane_24bpp
[21:29:06] [PASSED] drm_test_format_min_pitch_one_plane_32bpp
[21:29:06] [PASSED] drm_test_format_min_pitch_two_plane
[21:29:06] [PASSED] drm_test_format_min_pitch_three_plane_8bpp
[21:29:06] [PASSED] drm_test_format_min_pitch_tiled
[21:29:06] =================== [PASSED] drm_format ====================
[21:29:06] ============== drm_framebuffer (10 subtests) ===============
[21:29:06] ========== drm_test_framebuffer_check_src_coords  ==========
[21:29:06] [PASSED] Success: source fits into fb
[21:29:06] [PASSED] Fail: overflowing fb with x-axis coordinate
[21:29:06] [PASSED] Fail: overflowing fb with y-axis coordinate
[21:29:06] [PASSED] Fail: overflowing fb with source width
[21:29:06] [PASSED] Fail: overflowing fb with source height
[21:29:06] ====== [PASSED] drm_test_framebuffer_check_src_coords ======
[21:29:06] [PASSED] drm_test_framebuffer_cleanup
[21:29:06] =============== drm_test_framebuffer_create  ===============
[21:29:06] [PASSED] ABGR8888 normal sizes
[21:29:06] [PASSED] ABGR8888 max sizes
[21:29:06] [PASSED] ABGR8888 pitch greater than min required
[21:29:06] [PASSED] ABGR8888 pitch less than min required
[21:29:06] [PASSED] ABGR8888 Invalid width
[21:29:06] [PASSED] ABGR8888 Invalid buffer handle
[21:29:06] [PASSED] No pixel format
[21:29:06] [PASSED] ABGR8888 Width 0
[21:29:06] [PASSED] ABGR8888 Height 0
[21:29:06] [PASSED] ABGR8888 Out of bound height * pitch combination
[21:29:06] [PASSED] ABGR8888 Large buffer offset
[21:29:06] [PASSED] ABGR8888 Buffer offset for inexistent plane
[21:29:06] [PASSED] ABGR8888 Invalid flag
[21:29:06] [PASSED] ABGR8888 Set DRM_MODE_FB_MODIFIERS without modifiers
[21:29:06] [PASSED] ABGR8888 Valid buffer modifier
[21:29:06] [PASSED] ABGR8888 Invalid buffer modifier(DRM_FORMAT_MOD_SAMSUNG_64_32_TILE)
[21:29:06] [PASSED] ABGR8888 Extra pitches without DRM_MODE_FB_MODIFIERS
[21:29:06] [PASSED] ABGR8888 Extra pitches with DRM_MODE_FB_MODIFIERS
[21:29:06] [PASSED] NV12 Normal sizes
[21:29:06] [PASSED] NV12 Max sizes
[21:29:06] [PASSED] NV12 Invalid pitch
[21:29:06] [PASSED] NV12 Invalid modifier/missing DRM_MODE_FB_MODIFIERS flag
[21:29:06] [PASSED] NV12 different  modifier per-plane
[21:29:06] [PASSED] NV12 with DRM_FORMAT_MOD_SAMSUNG_64_32_TILE
[21:29:06] [PASSED] NV12 Valid modifiers without DRM_MODE_FB_MODIFIERS
[21:29:06] [PASSED] NV12 Modifier for inexistent plane
[21:29:06] [PASSED] NV12 Handle for inexistent plane
[21:29:06] [PASSED] NV12 Handle for inexistent plane without DRM_MODE_FB_MODIFIERS
[21:29:06] [PASSED] YVU420 DRM_MODE_FB_MODIFIERS set without modifier
[21:29:06] [PASSED] YVU420 Normal sizes
[21:29:06] [PASSED] YVU420 Max sizes
[21:29:06] [PASSED] YVU420 Invalid pitch
[21:29:06] [PASSED] YVU420 Different pitches
[21:29:06] [PASSED] YVU420 Different buffer offsets/pitches
[21:29:06] [PASSED] YVU420 Modifier set just for plane 0, without DRM_MODE_FB_MODIFIERS
[21:29:06] [PASSED] YVU420 Modifier set just for planes 0, 1, without DRM_MODE_FB_MODIFIERS
[21:29:06] [PASSED] YVU420 Modifier set just for plane 0, 1, with DRM_MODE_FB_MODIFIERS
[21:29:06] [PASSED] YVU420 Valid modifier
[21:29:06] [PASSED] YVU420 Different modifiers per plane
[21:29:06] [PASSED] YVU420 Modifier for inexistent plane
[21:29:06] [PASSED] YUV420_10BIT Invalid modifier(DRM_FORMAT_MOD_LINEAR)
[21:29:06] [PASSED] X0L2 Normal sizes
[21:29:06] [PASSED] X0L2 Max sizes
[21:29:06] [PASSED] X0L2 Invalid pitch
[21:29:06] [PASSED] X0L2 Pitch greater than minimum required
[21:29:06] [PASSED] X0L2 Handle for inexistent plane
[21:29:06] [PASSED] X0L2 Offset for inexistent plane, without DRM_MODE_FB_MODIFIERS set
[21:29:06] [PASSED] X0L2 Modifier without DRM_MODE_FB_MODIFIERS set
[21:29:06] [PASSED] X0L2 Valid modifier
[21:29:06] [PASSED] X0L2 Modifier for inexistent plane
[21:29:06] =========== [PASSED] drm_test_framebuffer_create ===========
[21:29:06] [PASSED] drm_test_framebuffer_free
[21:29:06] [PASSED] drm_test_framebuffer_init
[21:29:06] [PASSED] drm_test_framebuffer_init_bad_format
[21:29:06] [PASSED] drm_test_framebuffer_init_dev_mismatch
[21:29:06] [PASSED] drm_test_framebuffer_lookup
[21:29:06] [PASSED] drm_test_framebuffer_lookup_inexistent
[21:29:06] [PASSED] drm_test_framebuffer_modifiers_not_supported
[21:29:06] ================= [PASSED] drm_framebuffer =================
[21:29:06] ================ drm_gem_shmem (8 subtests) ================
[21:29:06] [PASSED] drm_gem_shmem_test_obj_create
[21:29:06] [PASSED] drm_gem_shmem_test_obj_create_private
[21:29:06] [PASSED] drm_gem_shmem_test_pin_pages
[21:29:06] [PASSED] drm_gem_shmem_test_vmap
[21:29:06] [PASSED] drm_gem_shmem_test_get_sg_table
[21:29:06] [PASSED] drm_gem_shmem_test_get_pages_sgt
[21:29:06] [PASSED] drm_gem_shmem_test_madvise
[21:29:06] [PASSED] drm_gem_shmem_test_purge
[21:29:06] ================== [PASSED] drm_gem_shmem ==================
[21:29:06] === drm_atomic_helper_connector_hdmi_check (27 subtests) ===
[21:29:06] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode
[21:29:06] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode_vic_1
[21:29:06] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode
[21:29:06] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode_vic_1
[21:29:06] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode
[21:29:06] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode_vic_1
[21:29:06] ====== drm_test_check_broadcast_rgb_cea_mode_yuv420  =======
[21:29:06] [PASSED] Automatic
[21:29:06] [PASSED] Full
[21:29:06] [PASSED] Limited 16:235
[21:29:06] == [PASSED] drm_test_check_broadcast_rgb_cea_mode_yuv420 ===
[21:29:06] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_changed
[21:29:06] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_not_changed
[21:29:06] [PASSED] drm_test_check_disable_connector
[21:29:06] [PASSED] drm_test_check_hdmi_funcs_reject_rate
[21:29:06] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_rgb
[21:29:06] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_yuv420
[21:29:06] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv422
[21:29:06] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv420
[21:29:06] [PASSED] drm_test_check_driver_unsupported_fallback_yuv420
[21:29:06] [PASSED] drm_test_check_output_bpc_crtc_mode_changed
[21:29:06] [PASSED] drm_test_check_output_bpc_crtc_mode_not_changed
[21:29:06] [PASSED] drm_test_check_output_bpc_dvi
[21:29:06] [PASSED] drm_test_check_output_bpc_format_vic_1
[21:29:06] [PASSED] drm_test_check_output_bpc_format_display_8bpc_only
[21:29:06] [PASSED] drm_test_check_output_bpc_format_display_rgb_only
[21:29:06] [PASSED] drm_test_check_output_bpc_format_driver_8bpc_only
[21:29:06] [PASSED] drm_test_check_output_bpc_format_driver_rgb_only
[21:29:06] [PASSED] drm_test_check_tmds_char_rate_rgb_8bpc
[21:29:06] [PASSED] drm_test_check_tmds_char_rate_rgb_10bpc
[21:29:06] [PASSED] drm_test_check_tmds_char_rate_rgb_12bpc
[21:29:06] ===== [PASSED] drm_atomic_helper_connector_hdmi_check ======
[21:29:06] === drm_atomic_helper_connector_hdmi_reset (6 subtests) ====
[21:29:06] [PASSED] drm_test_check_broadcast_rgb_value
[21:29:06] [PASSED] drm_test_check_bpc_8_value
[21:29:06] [PASSED] drm_test_check_bpc_10_value
[21:29:06] [PASSED] drm_test_check_bpc_12_value
[21:29:06] [PASSED] drm_test_check_format_value
[21:29:06] [PASSED] drm_test_check_tmds_char_value
[21:29:06] ===== [PASSED] drm_atomic_helper_connector_hdmi_reset ======
[21:29:06] = drm_atomic_helper_connector_hdmi_mode_valid (4 subtests) =
[21:29:06] [PASSED] drm_test_check_mode_valid
[21:29:06] [PASSED] drm_test_check_mode_valid_reject
[21:29:06] [PASSED] drm_test_check_mode_valid_reject_rate
[21:29:06] [PASSED] drm_test_check_mode_valid_reject_max_clock
[21:29:06] === [PASSED] drm_atomic_helper_connector_hdmi_mode_valid ===
[21:29:06] = drm_atomic_helper_connector_hdmi_infoframes (5 subtests) =
[21:29:06] [PASSED] drm_test_check_infoframes
[21:29:06] [PASSED] drm_test_check_reject_avi_infoframe
[21:29:06] [PASSED] drm_test_check_reject_hdr_infoframe_bpc_8
[21:29:06] [PASSED] drm_test_check_reject_hdr_infoframe_bpc_10
[21:29:06] [PASSED] drm_test_check_reject_audio_infoframe
[21:29:06] === [PASSED] drm_atomic_helper_connector_hdmi_infoframes ===
[21:29:06] ================= drm_managed (2 subtests) =================
[21:29:06] [PASSED] drm_test_managed_release_action
[21:29:06] [PASSED] drm_test_managed_run_action
[21:29:06] =================== [PASSED] drm_managed ===================
[21:29:06] =================== drm_mm (6 subtests) ====================
[21:29:06] [PASSED] drm_test_mm_init
[21:29:06] [PASSED] drm_test_mm_debug
[21:29:06] [PASSED] drm_test_mm_align32
[21:29:06] [PASSED] drm_test_mm_align64
[21:29:06] [PASSED] drm_test_mm_lowest
[21:29:06] [PASSED] drm_test_mm_highest
[21:29:06] ===================== [PASSED] drm_mm ======================
[21:29:06] ============= drm_modes_analog_tv (5 subtests) =============
[21:29:06] [PASSED] drm_test_modes_analog_tv_mono_576i
[21:29:06] [PASSED] drm_test_modes_analog_tv_ntsc_480i
[21:29:06] [PASSED] drm_test_modes_analog_tv_ntsc_480i_inlined
[21:29:06] [PASSED] drm_test_modes_analog_tv_pal_576i
[21:29:06] [PASSED] drm_test_modes_analog_tv_pal_576i_inlined
[21:29:06] =============== [PASSED] drm_modes_analog_tv ===============
[21:29:06] ============== drm_plane_helper (2 subtests) ===============
[21:29:06] =============== drm_test_check_plane_state  ================
[21:29:06] [PASSED] clipping_simple
[21:29:06] [PASSED] clipping_rotate_reflect
[21:29:06] [PASSED] positioning_simple
[21:29:06] [PASSED] upscaling
[21:29:06] [PASSED] downscaling
[21:29:06] [PASSED] rounding1
[21:29:06] [PASSED] rounding2
[21:29:06] [PASSED] rounding3
[21:29:06] [PASSED] rounding4
[21:29:06] =========== [PASSED] drm_test_check_plane_state ============
[21:29:06] =========== drm_test_check_invalid_plane_state  ============
[21:29:06] [PASSED] positioning_invalid
[21:29:06] [PASSED] upscaling_invalid
[21:29:06] [PASSED] downscaling_invalid
[21:29:06] ======= [PASSED] drm_test_check_invalid_plane_state ========
[21:29:06] ================ [PASSED] drm_plane_helper =================
[21:29:06] ====== drm_connector_helper_tv_get_modes (1 subtest) =======
[21:29:06] ====== drm_test_connector_helper_tv_get_modes_check  =======
[21:29:06] [PASSED] None
[21:29:06] [PASSED] PAL
[21:29:06] [PASSED] NTSC
[21:29:06] [PASSED] Both, NTSC Default
[21:29:06] [PASSED] Both, PAL Default
[21:29:06] [PASSED] Both, NTSC Default, with PAL on command-line
[21:29:06] [PASSED] Both, PAL Default, with NTSC on command-line
[21:29:06] == [PASSED] drm_test_connector_helper_tv_get_modes_check ===
[21:29:06] ======== [PASSED] drm_connector_helper_tv_get_modes ========
[21:29:06] ================== drm_rect (9 subtests) ===================
[21:29:06] [PASSED] drm_test_rect_clip_scaled_div_by_zero
[21:29:06] [PASSED] drm_test_rect_clip_scaled_not_clipped
[21:29:06] [PASSED] drm_test_rect_clip_scaled_clipped
[21:29:06] [PASSED] drm_test_rect_clip_scaled_signed_vs_unsigned
[21:29:06] ================= drm_test_rect_intersect  =================
[21:29:06] [PASSED] top-left x bottom-right: 2x2+1+1 x 2x2+0+0
[21:29:06] [PASSED] top-right x bottom-left: 2x2+0+0 x 2x2+1-1
[21:29:06] [PASSED] bottom-left x top-right: 2x2+1-1 x 2x2+0+0
[21:29:06] [PASSED] bottom-right x top-left: 2x2+0+0 x 2x2+1+1
[21:29:06] [PASSED] right x left: 2x1+0+0 x 3x1+1+0
[21:29:06] [PASSED] left x right: 3x1+1+0 x 2x1+0+0
[21:29:06] [PASSED] up x bottom: 1x2+0+0 x 1x3+0-1
[21:29:06] [PASSED] bottom x up: 1x3+0-1 x 1x2+0+0
[21:29:06] [PASSED] touching corner: 1x1+0+0 x 2x2+1+1
[21:29:06] [PASSED] touching side: 1x1+0+0 x 1x1+1+0
[21:29:06] [PASSED] equal rects: 2x2+0+0 x 2x2+0+0
[21:29:06] [PASSED] inside another: 2x2+0+0 x 1x1+1+1
[21:29:06] [PASSED] far away: 1x1+0+0 x 1x1+3+6
[21:29:06] [PASSED] points intersecting: 0x0+5+10 x 0x0+5+10
[21:29:06] [PASSED] points not intersecting: 0x0+0+0 x 0x0+5+10
[21:29:06] ============= [PASSED] drm_test_rect_intersect =============
[21:29:06] ================ drm_test_rect_calc_hscale  ================
[21:29:06] [PASSED] normal use
[21:29:06] [PASSED] out of max range
[21:29:06] [PASSED] out of min range
[21:29:06] [PASSED] zero dst
[21:29:06] [PASSED] negative src
[21:29:06] [PASSED] negative dst
[21:29:06] ============ [PASSED] drm_test_rect_calc_hscale ============
[21:29:06] ================ drm_test_rect_calc_vscale  ================
[21:29:06] [PASSED] normal use
[21:29:06] [PASSED] out of max range
[21:29:06] [PASSED] out of min range
[21:29:06] [PASSED] zero dst
[21:29:06] [PASSED] negative src
[21:29:06] [PASSED] negative dst
[21:29:06] ============ [PASSED] drm_test_rect_calc_vscale ============
[21:29:06] ================== drm_test_rect_rotate  ===================
[21:29:06] [PASSED] reflect-x
[21:29:06] [PASSED] reflect-y
[21:29:06] [PASSED] rotate-0
[21:29:06] [PASSED] rotate-90
[21:29:06] [PASSED] rotate-180
[21:29:06] [PASSED] rotate-270
[21:29:06] ============== [PASSED] drm_test_rect_rotate ===============
[21:29:06] ================ drm_test_rect_rotate_inv  =================
[21:29:06] [PASSED] reflect-x
[21:29:06] [PASSED] reflect-y
[21:29:06] [PASSED] rotate-0
[21:29:06] [PASSED] rotate-90
[21:29:06] [PASSED] rotate-180
[21:29:06] [PASSED] rotate-270
[21:29:06] ============ [PASSED] drm_test_rect_rotate_inv =============
[21:29:06] ==================== [PASSED] drm_rect =====================
[21:29:06] ============ drm_sysfb_modeset_test (1 subtest) ============
[21:29:06] ============ drm_test_sysfb_build_fourcc_list  =============
[21:29:06] [PASSED] no native formats
[21:29:06] [PASSED] XRGB8888 as native format
[21:29:06] [PASSED] remove duplicates
[21:29:06] [PASSED] convert alpha formats
[21:29:06] [PASSED] random formats
[21:29:06] ======== [PASSED] drm_test_sysfb_build_fourcc_list =========
[21:29:06] ============= [PASSED] drm_sysfb_modeset_test ==============
[21:29:06] ================== drm_fixp (2 subtests) ===================
[21:29:06] [PASSED] drm_test_int2fixp
[21:29:06] [PASSED] drm_test_sm2fixp
[21:29:06] ==================== [PASSED] drm_fixp =====================
[21:29:06] ============================================================
[21:29:06] Testing complete. Ran 621 tests: passed: 621
[21:29:06] Elapsed time: 25.885s total, 1.745s configuring, 23.971s building, 0.136s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/ttm/tests/.kunitconfig
[21:29:06] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[21:29:08] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[21:29:18] Starting KUnit Kernel (1/1)...
[21:29:18] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[21:29:18] ================= ttm_device (5 subtests) ==================
[21:29:18] [PASSED] ttm_device_init_basic
[21:29:18] [PASSED] ttm_device_init_multiple
[21:29:18] [PASSED] ttm_device_fini_basic
[21:29:18] [PASSED] ttm_device_init_no_vma_man
[21:29:18] ================== ttm_device_init_pools  ==================
[21:29:18] [PASSED] No DMA allocations, no DMA32 required
[21:29:18] [PASSED] DMA allocations, DMA32 required
[21:29:18] [PASSED] No DMA allocations, DMA32 required
[21:29:18] [PASSED] DMA allocations, no DMA32 required
[21:29:18] ============== [PASSED] ttm_device_init_pools ==============
[21:29:18] =================== [PASSED] ttm_device ====================
[21:29:18] ================== ttm_pool (8 subtests) ===================
[21:29:18] ================== ttm_pool_alloc_basic  ===================
[21:29:18] [PASSED] One page
[21:29:18] [PASSED] More than one page
[21:29:18] [PASSED] Above the allocation limit
[21:29:18] [PASSED] One page, with coherent DMA mappings enabled
[21:29:18] [PASSED] Above the allocation limit, with coherent DMA mappings enabled
[21:29:18] ============== [PASSED] ttm_pool_alloc_basic ===============
[21:29:18] ============== ttm_pool_alloc_basic_dma_addr  ==============
[21:29:18] [PASSED] One page
[21:29:18] [PASSED] More than one page
[21:29:18] [PASSED] Above the allocation limit
[21:29:18] [PASSED] One page, with coherent DMA mappings enabled
[21:29:18] [PASSED] Above the allocation limit, with coherent DMA mappings enabled
[21:29:18] ========== [PASSED] ttm_pool_alloc_basic_dma_addr ==========
[21:29:18] [PASSED] ttm_pool_alloc_order_caching_match
[21:29:18] [PASSED] ttm_pool_alloc_caching_mismatch
[21:29:18] [PASSED] ttm_pool_alloc_order_mismatch
[21:29:18] [PASSED] ttm_pool_free_dma_alloc
[21:29:18] [PASSED] ttm_pool_free_no_dma_alloc
[21:29:18] [PASSED] ttm_pool_fini_basic
[21:29:18] ==================== [PASSED] ttm_pool =====================
[21:29:18] ================ ttm_resource (8 subtests) =================
[21:29:18] ================= ttm_resource_init_basic  =================
[21:29:18] [PASSED] Init resource in TTM_PL_SYSTEM
[21:29:18] [PASSED] Init resource in TTM_PL_VRAM
[21:29:18] [PASSED] Init resource in a private placement
[21:29:18] [PASSED] Init resource in TTM_PL_SYSTEM, set placement flags
[21:29:18] ============= [PASSED] ttm_resource_init_basic =============
[21:29:18] [PASSED] ttm_resource_init_pinned
[21:29:18] [PASSED] ttm_resource_fini_basic
[21:29:18] [PASSED] ttm_resource_manager_init_basic
[21:29:18] [PASSED] ttm_resource_manager_usage_basic
[21:29:18] [PASSED] ttm_resource_manager_set_used_basic
[21:29:18] [PASSED] ttm_sys_man_alloc_basic
[21:29:18] [PASSED] ttm_sys_man_free_basic
[21:29:18] ================== [PASSED] ttm_resource ===================
[21:29:18] =================== ttm_tt (15 subtests) ===================
[21:29:18] ==================== ttm_tt_init_basic  ====================
[21:29:18] [PASSED] Page-aligned size
[21:29:18] [PASSED] Extra pages requested
[21:29:18] ================ [PASSED] ttm_tt_init_basic ================
[21:29:18] [PASSED] ttm_tt_init_misaligned
[21:29:18] [PASSED] ttm_tt_fini_basic
[21:29:18] [PASSED] ttm_tt_fini_sg
[21:29:18] [PASSED] ttm_tt_fini_shmem
[21:29:18] [PASSED] ttm_tt_create_basic
[21:29:18] [PASSED] ttm_tt_create_invalid_bo_type
[21:29:18] [PASSED] ttm_tt_create_ttm_exists
[21:29:18] [PASSED] ttm_tt_create_failed
[21:29:18] [PASSED] ttm_tt_destroy_basic
[21:29:18] [PASSED] ttm_tt_populate_null_ttm
[21:29:18] [PASSED] ttm_tt_populate_populated_ttm
[21:29:18] [PASSED] ttm_tt_unpopulate_basic
[21:29:18] [PASSED] ttm_tt_unpopulate_empty_ttm
[21:29:18] [PASSED] ttm_tt_swapin_basic
[21:29:18] ===================== [PASSED] ttm_tt ======================
[21:29:18] =================== ttm_bo (14 subtests) ===================
[21:29:18] =========== ttm_bo_reserve_optimistic_no_ticket  ===========
[21:29:18] [PASSED] Cannot be interrupted and sleeps
[21:29:18] [PASSED] Cannot be interrupted, locks straight away
[21:29:18] [PASSED] Can be interrupted, sleeps
[21:29:18] ======= [PASSED] ttm_bo_reserve_optimistic_no_ticket =======
[21:29:18] [PASSED] ttm_bo_reserve_locked_no_sleep
[21:29:18] [PASSED] ttm_bo_reserve_no_wait_ticket
[21:29:18] [PASSED] ttm_bo_reserve_double_resv
[21:29:18] [PASSED] ttm_bo_reserve_interrupted
[21:29:18] [PASSED] ttm_bo_reserve_deadlock
[21:29:18] [PASSED] ttm_bo_unreserve_basic
[21:29:18] [PASSED] ttm_bo_unreserve_pinned
[21:29:18] [PASSED] ttm_bo_unreserve_bulk
[21:29:18] [PASSED] ttm_bo_fini_basic
[21:29:18] [PASSED] ttm_bo_fini_shared_resv
[21:29:18] [PASSED] ttm_bo_pin_basic
[21:29:18] [PASSED] ttm_bo_pin_unpin_resource
[21:29:18] [PASSED] ttm_bo_multiple_pin_one_unpin
[21:29:18] ===================== [PASSED] ttm_bo ======================
[21:29:18] ============== ttm_bo_validate (22 subtests) ===============
[21:29:18] ============== ttm_bo_init_reserved_sys_man  ===============
[21:29:18] [PASSED] Buffer object for userspace
[21:29:18] [PASSED] Kernel buffer object
[21:29:18] [PASSED] Shared buffer object
[21:29:18] ========== [PASSED] ttm_bo_init_reserved_sys_man ===========
[21:29:18] ============== ttm_bo_init_reserved_mock_man  ==============
[21:29:18] [PASSED] Buffer object for userspace
[21:29:18] [PASSED] Kernel buffer object
[21:29:18] [PASSED] Shared buffer object
[21:29:18] ========== [PASSED] ttm_bo_init_reserved_mock_man ==========
[21:29:18] [PASSED] ttm_bo_init_reserved_resv
[21:29:18] ================== ttm_bo_validate_basic  ==================
[21:29:18] [PASSED] Buffer object for userspace
[21:29:18] [PASSED] Kernel buffer object
[21:29:18] [PASSED] Shared buffer object
[21:29:18] ============== [PASSED] ttm_bo_validate_basic ==============
[21:29:18] [PASSED] ttm_bo_validate_invalid_placement
[21:29:18] ============= ttm_bo_validate_same_placement  ==============
[21:29:18] [PASSED] System manager
[21:29:18] [PASSED] VRAM manager
[21:29:18] ========= [PASSED] ttm_bo_validate_same_placement ==========
[21:29:18] [PASSED] ttm_bo_validate_failed_alloc
[21:29:18] [PASSED] ttm_bo_validate_pinned
[21:29:18] [PASSED] ttm_bo_validate_busy_placement
[21:29:18] ================ ttm_bo_validate_multihop  =================
[21:29:18] [PASSED] Buffer object for userspace
[21:29:18] [PASSED] Kernel buffer object
[21:29:18] [PASSED] Shared buffer object
[21:29:18] ============ [PASSED] ttm_bo_validate_multihop =============
[21:29:18] ========== ttm_bo_validate_no_placement_signaled  ==========
[21:29:18] [PASSED] Buffer object in system domain, no page vector
[21:29:18] [PASSED] Buffer object in system domain with an existing page vector
[21:29:18] ====== [PASSED] ttm_bo_validate_no_placement_signaled ======
[21:29:18] ======== ttm_bo_validate_no_placement_not_signaled  ========
[21:29:18] [PASSED] Buffer object for userspace
[21:29:18] [PASSED] Kernel buffer object
[21:29:18] [PASSED] Shared buffer object
[21:29:18] ==== [PASSED] ttm_bo_validate_no_placement_not_signaled ====
[21:29:18] [PASSED] ttm_bo_validate_move_fence_signaled
[21:29:18] ========= ttm_bo_validate_move_fence_not_signaled  =========
[21:29:18] [PASSED] Waits for GPU
[21:29:18] [PASSED] Tries to lock straight away
[21:29:18] ===== [PASSED] ttm_bo_validate_move_fence_not_signaled =====
[21:29:18] [PASSED] ttm_bo_validate_swapout
[21:29:18] [PASSED] ttm_bo_validate_happy_evict
[21:29:18] [PASSED] ttm_bo_validate_all_pinned_evict
[21:29:18] [PASSED] ttm_bo_validate_allowed_only_evict
[21:29:18] [PASSED] ttm_bo_validate_deleted_evict
[21:29:18] [PASSED] ttm_bo_validate_busy_domain_evict
[21:29:18] [PASSED] ttm_bo_validate_evict_gutting
[21:29:18] [PASSED] ttm_bo_validate_recrusive_evict
[21:29:18] ================= [PASSED] ttm_bo_validate =================
[21:29:18] ============================================================
[21:29:18] Testing complete. Ran 102 tests: passed: 102
[21:29:18] Elapsed time: 11.683s total, 1.760s configuring, 9.659s building, 0.225s running

+ cleanup
++ stat -c %u:%g /kernel
+ chown -R 1003:1003 /kernel

Re: [PATCH 2/4] drm/xe/rtp: Add GT WAs rule checking

[Gustavo Sousa]

Violet Monti <violet.monti@intel.com> writes:

> It is currently possible for a RTP rule, and subsequently a workaround,
> to expect contexts that may not be present when the workaround is
> applied. For example, the workarounds in the engine_was[] in drm/xe/xe_wa.c
> expect an engine entity to be active. Conversely, the gt_was[] is not
> depending on an engine entity to implement its workarounds. This kunit
> test addition checks the gt_was[] workaround list for any workarounds
> with specifically an engine_class rule. If a workaround does have an

I think "an engine_class rule" can be a bit vague. I would spell out
ENGINE_CLASS() or XE_RTP_ENGINE_CLASS().

> engine_class rule, the workaround is then checked for the
> "FOREACH_ENGINE" flag, which ensures the workaround is not implemented
> in an improper context.
>
> The result of this test is an expectation failure if a workaround has an
> improper engine_class rule, and aims to prevent future issues of
> gt_was being applied without proper contexts.
>
> Signed-off-by: Violet Monti <violet.monti@intel.com>
> ---
>  drivers/gpu/drm/xe/tests/Makefile             |  1 +
>  drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c | 76 +++++++++++++++++++
>  drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h | 24 ++++++
>  drivers/gpu/drm/xe/xe_wa.c                    |  2 +-
>  drivers/gpu/drm/xe/xe_wa.h                    |  5 ++
>  5 files changed, 107 insertions(+), 1 deletion(-)
>  create mode 100644 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
>  create mode 100644 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
>
> diff --git a/drivers/gpu/drm/xe/tests/Makefile b/drivers/gpu/drm/xe/tests/Makefile
> index 0e3408f4952c..f7aa47f11a36 100644
> --- a/drivers/gpu/drm/xe/tests/Makefile
> +++ b/drivers/gpu/drm/xe/tests/Makefile
> @@ -9,5 +9,6 @@ obj-$(CONFIG_DRM_XE_KUNIT_TEST) += xe_test.o
>  xe_test-y = xe_test_mod.o \
>  	xe_args_test.o \
>  	xe_pci_test.o \
> +	xe_rtp_tables_test.o \
>  	xe_rtp_test.o \
>  	xe_wa_test.o
> diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
> new file mode 100644
> index 000000000000..100cac379b08
> --- /dev/null
> +++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
> @@ -0,0 +1,76 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright © 2026 Intel Corporation
> + */
> +
> +#include <drm/drm_kunit_helpers.h>
> +
> +#include "xe_kunit_helpers.h"
> +#include "xe_pci_test.h"
> +#include "xe_rtp.h"
> +#include "xe_rtp_tables_test.h"
> +#include "xe_wa.h"
> +
> +static void xe_rtp_table_gt_test(struct kunit *test)
> +{
> +	const struct xe_rtp_entry_sr *param = test->param_value;

I think it makes sense to call the variable "entry" here, like done in
other places for instances of xe_rtp_entry_sr.

> +
> +	for (int i = 0; i < param->n_rules; i++) {
> +		if (param->rules[i].match_type == XE_RTP_MATCH_ENGINE_CLASS)

We would need to check XE_RTP_MATCH_NOT_ENGINE_CLASS as well.

> +			KUNIT_EXPECT_EQ_MSG(test, param->flags,
> +					    XE_RTP_ENTRY_FLAG_FOREACH_ENGINE,

If the entry has other flags set along with
XE_RTP_ENTRY_FLAG_FOREACH_ENGINE, this check would fail.

> +					    "GT WA %s has an invalid engine class rule setup",
> +					    param->name);

I think it would be simpler to replace this with something like

  KUNIT_EXPECT_TRUE(param->rules[i].match_type != XE_RTP_MATCH_ENGINE_CLASS ||
                    param->flags & XE_RTP_ENTRY_FLAG_FOREACH_ENGINE)

And another one like that for XE_RTP_MATCH_NOT_ENGINE_CLASS.

Since we are using entries as parameters of the test, the RTP entry name
will be displayed in the kunit output, so I think we can skip the
explanatory string.

> +	}
> +}
> +
> +static int xe_rtp_table_test_init(struct kunit *test)
> +{
> +	struct xe_device *xe;
> +	struct device *dev;
> +	int ret;
> +
> +	dev = drm_kunit_helper_alloc_device(test);
> +	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
> +
> +	xe = xe_kunit_helper_alloc_xe_device(test, dev);
> +	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, xe);
> +
> +	/* Initialize an empty device */
> +	test->priv = NULL;
> +
> +	ret = xe_pci_fake_device_init(xe);
> +	KUNIT_ASSERT_EQ(test, ret, 0);
> +	xe->drm.dev = dev;
> +	test->priv = xe;
> +
> +	return 0;
> +}
> +
> +static void xe_rtp_table_test_exit(struct kunit *test)
> +{
> +	struct xe_device *xe = test->priv;
> +
> +	drm_kunit_helper_free_device(test, xe->drm.dev);
> +}
> +
> +static void rtp_table_gt_test_desc(const struct xe_rtp_entry_sr *t, char *desc)
> +{
> +	strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
> +}
> +
> +RTP_KUNIT_ARRAY_PARAM(rtp_table_gt, gt_was, rtp_table_gt_test_desc);
> +
> +static struct kunit_case xe_rtp_table_tests[] = {
> +	KUNIT_CASE_PARAM(xe_rtp_table_gt_test, rtp_table_gt_gen_params),
> +	{}
> +};
> +
> +static struct kunit_suite xe_rtp_tables_test_suite = {
> +	.name = "xe_rtp_tables_test",
> +	.init = xe_rtp_table_test_init,
> +	.exit = xe_rtp_table_test_exit,

We do not need fake device initialization for the current test being
done here.  We can simply drop those functions and the .init and .exit
initializations here.

> +	.test_cases = xe_rtp_table_tests,
> +};
> +
> +kunit_test_suite(xe_rtp_tables_test_suite);
> diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
> new file mode 100644
> index 000000000000..3e91dd08f854
> --- /dev/null
> +++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
> @@ -0,0 +1,24 @@
> +/* SPDX-License-Identifier: GPL-2.0 AND MIT */
> +/*
> + * Copyright © 2026 Intel Corporation
> + */
> +
> +// The "gen_params" function functionality does not work to dynamically collect the size
> +// of the WA array, even with the new n_entries pointer. This addition builds on that framework
> +// to allow dynamic sizing
> +#define RTP_KUNIT_ARRAY_PARAM(name, array, get_desc)						\

The only user of this macro is xe_rtp_tables_test.c, I don't think we
need to expose it via a header.

I also think RTP_TABLE_PARAM() would be a good name for the macro.

> +	static const void *name##_gen_params(struct kunit *test,				\
> +					     const void *prev, char *desc)			\
> +	{											\
> +		typeof((array.entries)[0]) *__next = prev ?					\
> +			((typeof(__next))prev) + 1 : (array.entries);				\
> +		if (!prev)									\
> +			kunit_register_params_array(test, array.entries, array.n_entries, NULL);\

Do we really need to call kunit_register_params_array()?  Looking at the
implementation of kunit, it appears kunit_register_params_array() is
meant to be used together with kunit_array_gen_params() as the parameter
generator.  Here we are using our own custom generator.

By the way, I wonder why kunit itself is doing that for
KUNIT_ARRAY_PARAM() and KUNIT_ARRAY_PARAM_DESC().  Commit b820b9077b7f
("kunit: Enable direct registration of parameter arrays to a KUnit
test") is the one that added kunit_register_params_array() and says the
following:

    "The arrays passed to KUNIT_ARRAY_PARAM(,DESC) will also be registered to
    the parameterized test context for consistency as well as for higher
    availability of the parameter count that will be used for outputting a KTAP
    test plan for a parameterized test."

, however, the registered data is only used if the generator is
kunit_array_gen_params() anyway, so the registration in those macros
seems useless.

Bottom line: I think we can simply drop this call.

> +		if (__next - array.entries < array.n_entries) {					\
> +			void (*__get_desc)(typeof(__next), char *) = get_desc;			\
> +			if (__get_desc)								\
> +				__get_desc(__next, desc);					\

Since we are writing this macro specifically for RTP entries, I don't
think we need a "get description" function: we can use __next->name
directly here.

Also, for the description, I think we could also include the name of the
variable, for completeness.  Today we are only adding gt_was, but in the
future we could add others.  Using the variable name in the parameter
name here should make it easy to correctly spot the offending RTP entry
in a expectation failure.

Hence, here is what I would suggest for such a macro (tested locally):

    #define RTP_TABLE_PARAM(array)								\
    	static const void *array##_gen_params(struct kunit *test,				\
    					     const void *prev, char *desc)			\
    	{											\
    		typeof((array.entries)[0]) *__next = prev ?					\
    			((typeof(__next))prev) + 1 : (array.entries);				\
    		if (__next - array.entries < array.n_entries) {					\
    			scnprintf(desc, KUNIT_PARAM_DESC_SIZE, #array "/%s", __next->name);	\
    			return __next;								\
    		}										\
    		return NULL;									\
    	}
    


--
Gustavo Sousa

> +			return __next;								\
> +		}										\
> +		return NULL;									\
> +	}
> diff --git a/drivers/gpu/drm/xe/xe_wa.c b/drivers/gpu/drm/xe/xe_wa.c
> index 39c507edb8ce..285072fe0a47 100644
> --- a/drivers/gpu/drm/xe/xe_wa.c
> +++ b/drivers/gpu/drm/xe/xe_wa.c
> @@ -130,7 +130,7 @@
>  __diag_push();
>  __diag_ignore_all("-Woverride-init", "Allow field overrides in table");
>  
> -static const struct xe_rtp_table_sr gt_was = XE_RTP_TABLE_SR(
> +VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was = XE_RTP_TABLE_SR(
>  	/* Workarounds applying over a range of IPs */
>  
>  	{ XE_RTP_NAME("14011060649"),
> diff --git a/drivers/gpu/drm/xe/xe_wa.h b/drivers/gpu/drm/xe/xe_wa.h
> index a5f7d33c1b32..17dff615e507 100644
> --- a/drivers/gpu/drm/xe/xe_wa.h
> +++ b/drivers/gpu/drm/xe/xe_wa.h
> @@ -6,6 +6,7 @@
>  #ifndef _XE_WA_H_
>  #define _XE_WA_H_
>  
> +#include <kunit/visibility.h>
>  #include "xe_assert.h"
>  
>  struct drm_printer;
> @@ -24,6 +25,10 @@ void xe_wa_apply_tile_workarounds(struct xe_tile *tile);
>  void xe_wa_device_dump(struct xe_device *xe, struct drm_printer *p);
>  int xe_wa_gt_dump(struct xe_gt *gt, struct drm_printer *p);
>  
> +#if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST)
> +extern VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was;
> +#endif
> +
>  /**
>   * XE_GT_WA - Out-of-band GT workarounds, to be queried and called as needed.
>   * @gt__: gt instance
> -- 
> 2.43.0

Re: [PATCH 2/4] drm/xe/rtp: Add GT WAs rule checking

[Gustavo Sousa]

Adding some things I forgot in my previous reply...

Gustavo Sousa <gustavo.sousa@intel.com> writes:

> Violet Monti <violet.monti@intel.com> writes:
>

I think the commit subject is a bit vague. We could try to be more
specific with something like:

  drm/xe/rtp: Ensure gt_was doesn't check for engine types

>> It is currently possible for a RTP rule, and subsequently a workaround,
>> to expect contexts that may not be present when the workaround is
>> applied. For example, the workarounds in the engine_was[] in drm/xe/xe_wa.c
>> expect an engine entity to be active. Conversely, the gt_was[] is not
>> depending on an engine entity to implement its workarounds. This kunit
>> test addition checks the gt_was[] workaround list for any workarounds
>> with specifically an engine_class rule. If a workaround does have an
>
> I think "an engine_class rule" can be a bit vague. I would spell out
> ENGINE_CLASS() or XE_RTP_ENGINE_CLASS().
>
>> engine_class rule, the workaround is then checked for the
>> "FOREACH_ENGINE" flag, which ensures the workaround is not implemented
>> in an improper context.
>>
>> The result of this test is an expectation failure if a workaround has an
>> improper engine_class rule, and aims to prevent future issues of
>> gt_was being applied without proper contexts.
>>
>> Signed-off-by: Violet Monti <violet.monti@intel.com>
>> ---
>>  drivers/gpu/drm/xe/tests/Makefile             |  1 +
>>  drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c | 76 +++++++++++++++++++
>>  drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h | 24 ++++++
>>  drivers/gpu/drm/xe/xe_wa.c                    |  2 +-
>>  drivers/gpu/drm/xe/xe_wa.h                    |  5 ++
>>  5 files changed, 107 insertions(+), 1 deletion(-)
>>  create mode 100644 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
>>  create mode 100644 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
>>
>> diff --git a/drivers/gpu/drm/xe/tests/Makefile b/drivers/gpu/drm/xe/tests/Makefile
>> index 0e3408f4952c..f7aa47f11a36 100644
>> --- a/drivers/gpu/drm/xe/tests/Makefile
>> +++ b/drivers/gpu/drm/xe/tests/Makefile
>> @@ -9,5 +9,6 @@ obj-$(CONFIG_DRM_XE_KUNIT_TEST) += xe_test.o
>>  xe_test-y = xe_test_mod.o \
>>  	xe_args_test.o \
>>  	xe_pci_test.o \
>> +	xe_rtp_tables_test.o \
>>  	xe_rtp_test.o \
>>  	xe_wa_test.o
>> diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
>> new file mode 100644
>> index 000000000000..100cac379b08
>> --- /dev/null
>> +++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
>> @@ -0,0 +1,76 @@
>> +// SPDX-License-Identifier: GPL-2.0
>> +/*
>> + * Copyright © 2026 Intel Corporation
>> + */
>> +
>> +#include <drm/drm_kunit_helpers.h>
>> +
>> +#include "xe_kunit_helpers.h"
>> +#include "xe_pci_test.h"
>> +#include "xe_rtp.h"
>> +#include "xe_rtp_tables_test.h"
>> +#include "xe_wa.h"
>> +
>> +static void xe_rtp_table_gt_test(struct kunit *test)
>> +{
>> +	const struct xe_rtp_entry_sr *param = test->param_value;
>
> I think it makes sense to call the variable "entry" here, like done in
> other places for instances of xe_rtp_entry_sr.
>
>> +
>> +	for (int i = 0; i < param->n_rules; i++) {
>> +		if (param->rules[i].match_type == XE_RTP_MATCH_ENGINE_CLASS)
>
> We would need to check XE_RTP_MATCH_NOT_ENGINE_CLASS as well.
>
>> +			KUNIT_EXPECT_EQ_MSG(test, param->flags,
>> +					    XE_RTP_ENTRY_FLAG_FOREACH_ENGINE,
>
> If the entry has other flags set along with
> XE_RTP_ENTRY_FLAG_FOREACH_ENGINE, this check would fail.
>
>> +					    "GT WA %s has an invalid engine class rule setup",
>> +					    param->name);
>
> I think it would be simpler to replace this with something like
>
>   KUNIT_EXPECT_TRUE(param->rules[i].match_type != XE_RTP_MATCH_ENGINE_CLASS ||
>                     param->flags & XE_RTP_ENTRY_FLAG_FOREACH_ENGINE)
>
> And another one like that for XE_RTP_MATCH_NOT_ENGINE_CLASS.
>
> Since we are using entries as parameters of the test, the RTP entry name
> will be displayed in the kunit output, so I think we can skip the
> explanatory string.
>
>> +	}
>> +}
>> +
>> +static int xe_rtp_table_test_init(struct kunit *test)
>> +{
>> +	struct xe_device *xe;
>> +	struct device *dev;
>> +	int ret;
>> +
>> +	dev = drm_kunit_helper_alloc_device(test);
>> +	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
>> +
>> +	xe = xe_kunit_helper_alloc_xe_device(test, dev);
>> +	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, xe);
>> +
>> +	/* Initialize an empty device */
>> +	test->priv = NULL;
>> +
>> +	ret = xe_pci_fake_device_init(xe);
>> +	KUNIT_ASSERT_EQ(test, ret, 0);
>> +	xe->drm.dev = dev;
>> +	test->priv = xe;
>> +
>> +	return 0;
>> +}
>> +
>> +static void xe_rtp_table_test_exit(struct kunit *test)
>> +{
>> +	struct xe_device *xe = test->priv;
>> +
>> +	drm_kunit_helper_free_device(test, xe->drm.dev);
>> +}
>> +
>> +static void rtp_table_gt_test_desc(const struct xe_rtp_entry_sr *t, char *desc)
>> +{
>> +	strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
>> +}
>> +
>> +RTP_KUNIT_ARRAY_PARAM(rtp_table_gt, gt_was, rtp_table_gt_test_desc);
>> +
>> +static struct kunit_case xe_rtp_table_tests[] = {
>> +	KUNIT_CASE_PARAM(xe_rtp_table_gt_test, rtp_table_gt_gen_params),
>> +	{}
>> +};
>> +
>> +static struct kunit_suite xe_rtp_tables_test_suite = {
>> +	.name = "xe_rtp_tables_test",
>> +	.init = xe_rtp_table_test_init,
>> +	.exit = xe_rtp_table_test_exit,
>
> We do not need fake device initialization for the current test being
> done here.  We can simply drop those functions and the .init and .exit
> initializations here.
>
>> +	.test_cases = xe_rtp_table_tests,
>> +};
>> +
>> +kunit_test_suite(xe_rtp_tables_test_suite);
>> diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
>> new file mode 100644
>> index 000000000000..3e91dd08f854
>> --- /dev/null
>> +++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
>> @@ -0,0 +1,24 @@
>> +/* SPDX-License-Identifier: GPL-2.0 AND MIT */
>> +/*
>> + * Copyright © 2026 Intel Corporation
>> + */
>> +
>> +// The "gen_params" function functionality does not work to dynamically collect the size
>> +// of the WA array, even with the new n_entries pointer. This addition builds on that framework
>> +// to allow dynamic sizing
>> +#define RTP_KUNIT_ARRAY_PARAM(name, array, get_desc)						\
>
> The only user of this macro is xe_rtp_tables_test.c, I don't think we
> need to expose it via a header.
>
> I also think RTP_TABLE_PARAM() would be a good name for the macro.
>
>> +	static const void *name##_gen_params(struct kunit *test,				\
>> +					     const void *prev, char *desc)			\
>> +	{											\
>> +		typeof((array.entries)[0]) *__next = prev ?					\
>> +			((typeof(__next))prev) + 1 : (array.entries);				\
>> +		if (!prev)									\
>> +			kunit_register_params_array(test, array.entries, array.n_entries, NULL);\
>
> Do we really need to call kunit_register_params_array()?  Looking at the
> implementation of kunit, it appears kunit_register_params_array() is
> meant to be used together with kunit_array_gen_params() as the parameter
> generator.  Here we are using our own custom generator.
>
> By the way, I wonder why kunit itself is doing that for
> KUNIT_ARRAY_PARAM() and KUNIT_ARRAY_PARAM_DESC().  Commit b820b9077b7f
> ("kunit: Enable direct registration of parameter arrays to a KUnit
> test") is the one that added kunit_register_params_array() and says the
> following:
>
>     "The arrays passed to KUNIT_ARRAY_PARAM(,DESC) will also be registered to
>     the parameterized test context for consistency as well as for higher
>     availability of the parameter count that will be used for outputting a KTAP
>     test plan for a parameterized test."
>
> , however, the registered data is only used if the generator is
> kunit_array_gen_params() anyway, so the registration in those macros
> seems useless.
>
> Bottom line: I think we can simply drop this call.
>
>> +		if (__next - array.entries < array.n_entries) {					\
>> +			void (*__get_desc)(typeof(__next), char *) = get_desc;			\
>> +			if (__get_desc)								\
>> +				__get_desc(__next, desc);					\
>
> Since we are writing this macro specifically for RTP entries, I don't
> think we need a "get description" function: we can use __next->name
> directly here.
>
> Also, for the description, I think we could also include the name of the
> variable, for completeness.  Today we are only adding gt_was, but in the
> future we could add others.  Using the variable name in the parameter
> name here should make it easy to correctly spot the offending RTP entry
> in a expectation failure.
>
> Hence, here is what I would suggest for such a macro (tested locally):
>
>     #define RTP_TABLE_PARAM(array)								\

Maybe we should use "table" for the parameter here, since we are
expecting xe_rtp_table or xe_rtp_table_sr instances?

--
Gustavo Sousa

>     	static const void *array##_gen_params(struct kunit *test,				\
>     					     const void *prev, char *desc)			\
>     	{											\
>     		typeof((array.entries)[0]) *__next = prev ?					\
>     			((typeof(__next))prev) + 1 : (array.entries);				\
>     		if (__next - array.entries < array.n_entries) {					\
>     			scnprintf(desc, KUNIT_PARAM_DESC_SIZE, #array "/%s", __next->name);	\
>     			return __next;								\
>     		}										\
>     		return NULL;									\
>     	}
>     
>
>
> --
> Gustavo Sousa
>
>> +			return __next;								\
>> +		}										\
>> +		return NULL;									\
>> +	}
>> diff --git a/drivers/gpu/drm/xe/xe_wa.c b/drivers/gpu/drm/xe/xe_wa.c
>> index 39c507edb8ce..285072fe0a47 100644
>> --- a/drivers/gpu/drm/xe/xe_wa.c
>> +++ b/drivers/gpu/drm/xe/xe_wa.c
>> @@ -130,7 +130,7 @@
>>  __diag_push();
>>  __diag_ignore_all("-Woverride-init", "Allow field overrides in table");
>>  
>> -static const struct xe_rtp_table_sr gt_was = XE_RTP_TABLE_SR(
>> +VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was = XE_RTP_TABLE_SR(
>>  	/* Workarounds applying over a range of IPs */
>>  
>>  	{ XE_RTP_NAME("14011060649"),
>> diff --git a/drivers/gpu/drm/xe/xe_wa.h b/drivers/gpu/drm/xe/xe_wa.h
>> index a5f7d33c1b32..17dff615e507 100644
>> --- a/drivers/gpu/drm/xe/xe_wa.h
>> +++ b/drivers/gpu/drm/xe/xe_wa.h
>> @@ -6,6 +6,7 @@
>>  #ifndef _XE_WA_H_
>>  #define _XE_WA_H_
>>  
>> +#include <kunit/visibility.h>
>>  #include "xe_assert.h"
>>  
>>  struct drm_printer;
>> @@ -24,6 +25,10 @@ void xe_wa_apply_tile_workarounds(struct xe_tile *tile);
>>  void xe_wa_device_dump(struct xe_device *xe, struct drm_printer *p);
>>  int xe_wa_gt_dump(struct xe_gt *gt, struct drm_printer *p);
>>  
>> +#if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST)
>> +extern VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was;
>> +#endif
>> +
>>  /**
>>   * XE_GT_WA - Out-of-band GT workarounds, to be queried and called as needed.
>>   * @gt__: gt instance
>> -- 
>> 2.43.0

Re: [PATCH 3/4] drm/xe/rtp: Add OOB WAs rule checking

[Gustavo Sousa]

Same comments from previous patch about commit title and body applies
here.

Violet Monti <violet.monti@intel.com> writes:

> This commit builds on the implementation of the GT WA testing, increasing
> the scope of testing to include the OOB workaround list. The added test
> checks for workarounds with an engine_class rule, and raises an expectation
> failure if any are found. Unlike the GT workarounds, there are no flags
> within this workaround list, so all engine_class rules will fail.
>
> This test prevents future implementation of rules that would apply an
> engine_class rule without an active engine in context, preventing rule
> errors or mishaps.
>
> Signed-off-by: Violet Monti <violet.monti@intel.com>
> ---
>  drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c | 20 +++++++++++++++++++
>  drivers/gpu/drm/xe/xe_wa.c                    |  2 +-
>  drivers/gpu/drm/xe/xe_wa.h                    |  1 +
>  3 files changed, 22 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
> index 100cac379b08..eae3262775bb 100644
> --- a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
> +++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
> @@ -24,6 +24,18 @@ static void xe_rtp_table_gt_test(struct kunit *test)
>  	}
>  }
>  
> +static void xe_rtp_table_oob_test(struct kunit *test)
> +{
> +	const struct xe_rtp_entry *param = test->param_value;
> +
> +	for (int i = 0; i < param->n_rules; i++) {
> +		KUNIT_EXPECT_NE_MSG(test, param->rules[i].match_type,
> +				    XE_RTP_MATCH_ENGINE_CLASS,
> +				    "OOB_WA %s has an engine class rule",
> +				    param->name);

Like with the previous patch, I think we could simplify by using
something like

  KUNIT_EXPECT_NE(test, param->rules[i].match_type,
                  XE_RTP_MATCH_ENGINE_CLASS)

> +	}
> +}
> +
>  static int xe_rtp_table_test_init(struct kunit *test)
>  {
>  	struct xe_device *xe;
> @@ -61,8 +73,16 @@ static void rtp_table_gt_test_desc(const struct xe_rtp_entry_sr *t, char *desc)
>  
>  RTP_KUNIT_ARRAY_PARAM(rtp_table_gt, gt_was, rtp_table_gt_test_desc);
>  
> +static void rtp_table_oob_test_desc(const struct xe_rtp_entry *t, char *desc)
> +{
> +	strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
> +}
> +
> +RTP_KUNIT_ARRAY_PARAM(rtp_table_oob, oob_was, rtp_table_oob_test_desc);
> +
>  static struct kunit_case xe_rtp_table_tests[] = {
>  	KUNIT_CASE_PARAM(xe_rtp_table_gt_test, rtp_table_gt_gen_params),
> +	KUNIT_CASE_PARAM(xe_rtp_table_oob_test, rtp_table_oob_gen_params),

Yeah.  It is unfortunate that we need 2 different functions here.  I think
in the future we could try to have a single way of expressing RTP entries
instead of having two different struct types (xe_rtp_entry vs
xe_rtp_entry_sr).  That would allow us to unify code specific for
processing rules in those entries.

--
Gustavo Sousa

>  	{}
>  };
>  
> diff --git a/drivers/gpu/drm/xe/xe_wa.c b/drivers/gpu/drm/xe/xe_wa.c
> index 285072fe0a47..5744bd3f8be9 100644
> --- a/drivers/gpu/drm/xe/xe_wa.c
> +++ b/drivers/gpu/drm/xe/xe_wa.c
> @@ -802,7 +802,7 @@ static const struct xe_rtp_entry oob_was_entries[] = {
>  
>  static_assert(ARRAY_SIZE(oob_was_entries)  == _XE_WA_OOB_COUNT);
>  
> -static __maybe_unused const struct xe_rtp_table oob_was = {
> +VISIBLE_IF_KUNIT __maybe_unused const struct xe_rtp_table oob_was = {
>  	.entries = oob_was_entries,
>  	.n_entries = ARRAY_SIZE(oob_was_entries),
>  };
> diff --git a/drivers/gpu/drm/xe/xe_wa.h b/drivers/gpu/drm/xe/xe_wa.h
> index 17dff615e507..7ac6d365b65f 100644
> --- a/drivers/gpu/drm/xe/xe_wa.h
> +++ b/drivers/gpu/drm/xe/xe_wa.h
> @@ -27,6 +27,7 @@ int xe_wa_gt_dump(struct xe_gt *gt, struct drm_printer *p);
>  
>  #if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST)
>  extern VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was;
> +extern VISIBLE_IF_KUNIT __maybe_unused const struct xe_rtp_table oob_was;
>  #endif
>  
>  /**
> -- 
> 2.43.0

Re: [PATCH 2/4] drm/xe/rtp: Add GT WAs rule checking

[Violet Monti]

On Mon, May 18, 2026 at 05:44:30PM -0300, Gustavo Sousa wrote:
> 
> Adding some things I forgot in my previous reply...
> 
> Gustavo Sousa <gustavo.sousa@intel.com> writes:
> 
> > Violet Monti <violet.monti@intel.com> writes:
> >
> 
> I think the commit subject is a bit vague. We could try to be more
> specific with something like:
> 
>   drm/xe/rtp: Ensure gt_was doesn't check for engine types
> 

Agreed. Thoughts on:
    
    drm/xe/rtp: Ensure gt_was doesn't evaluate rules with engine types

My understanding is that the gt_was takes the RTP rule list and
evaluates the rules so the workarounds can be applied.

> >> It is currently possible for a RTP rule, and subsequently a workaround,
> >> to expect contexts that may not be present when the workaround is
> >> applied. For example, the workarounds in the engine_was[] in drm/xe/xe_wa.c
> >> expect an engine entity to be active. Conversely, the gt_was[] is not
> >> depending on an engine entity to implement its workarounds. This kunit
> >> test addition checks the gt_was[] workaround list for any workarounds
> >> with specifically an engine_class rule. If a workaround does have an
> >
> > I think "an engine_class rule" can be a bit vague. I would spell out
> > ENGINE_CLASS() or XE_RTP_ENGINE_CLASS().
> >

Alright. For specificity, I will update this to XE_RTP_ENGINE_CLASS() in
V2

> >> engine_class rule, the workaround is then checked for the
> >> "FOREACH_ENGINE" flag, which ensures the workaround is not implemented
> >> in an improper context.
> >>
> >> The result of this test is an expectation failure if a workaround has an
> >> improper engine_class rule, and aims to prevent future issues of
> >> gt_was being applied without proper contexts.
> >>
> >> Signed-off-by: Violet Monti <violet.monti@intel.com>
> >> ---
> >>  drivers/gpu/drm/xe/tests/Makefile             |  1 +
> >>  drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c | 76 +++++++++++++++++++
> >>  drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h | 24 ++++++
> >>  drivers/gpu/drm/xe/xe_wa.c                    |  2 +-
> >>  drivers/gpu/drm/xe/xe_wa.h                    |  5 ++
> >>  5 files changed, 107 insertions(+), 1 deletion(-)
> >>  create mode 100644 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
> >>  create mode 100644 drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
> >>
> >> diff --git a/drivers/gpu/drm/xe/tests/Makefile b/drivers/gpu/drm/xe/tests/Makefile
> >> index 0e3408f4952c..f7aa47f11a36 100644
> >> --- a/drivers/gpu/drm/xe/tests/Makefile
> >> +++ b/drivers/gpu/drm/xe/tests/Makefile
> >> @@ -9,5 +9,6 @@ obj-$(CONFIG_DRM_XE_KUNIT_TEST) += xe_test.o
> >>  xe_test-y = xe_test_mod.o \
> >>  	xe_args_test.o \
> >>  	xe_pci_test.o \
> >> +	xe_rtp_tables_test.o \
> >>  	xe_rtp_test.o \
> >>  	xe_wa_test.o
> >> diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
> >> new file mode 100644
> >> index 000000000000..100cac379b08
> >> --- /dev/null
> >> +++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
> >> @@ -0,0 +1,76 @@
> >> +// SPDX-License-Identifier: GPL-2.0
> >> +/*
> >> + * Copyright © 2026 Intel Corporation
> >> + */
> >> +
> >> +#include <drm/drm_kunit_helpers.h>
> >> +
> >> +#include "xe_kunit_helpers.h"
> >> +#include "xe_pci_test.h"
> >> +#include "xe_rtp.h"
> >> +#include "xe_rtp_tables_test.h"
> >> +#include "xe_wa.h"
> >> +
> >> +static void xe_rtp_table_gt_test(struct kunit *test)
> >> +{
> >> +	const struct xe_rtp_entry_sr *param = test->param_value;
> >
> > I think it makes sense to call the variable "entry" here, like done in
> > other places for instances of xe_rtp_entry_sr.
> >

Will add in V2.

> >> +
> >> +	for (int i = 0; i < param->n_rules; i++) {
> >> +		if (param->rules[i].match_type == XE_RTP_MATCH_ENGINE_CLASS)
> >
> > We would need to check XE_RTP_MATCH_NOT_ENGINE_CLASS as well.
> >

Thank you for confirming that, will add as well.

> >> +			KUNIT_EXPECT_EQ_MSG(test, param->flags,
> >> +					    XE_RTP_ENTRY_FLAG_FOREACH_ENGINE,
> >
> > If the entry has other flags set along with
> > XE_RTP_ENTRY_FLAG_FOREACH_ENGINE, this check would fail.
> >
> >> +					    "GT WA %s has an invalid engine class rule setup",
> >> +					    param->name);
> >
> > I think it would be simpler to replace this with something like
> >
> >   KUNIT_EXPECT_TRUE(param->rules[i].match_type != XE_RTP_MATCH_ENGINE_CLASS ||
> >                     param->flags & XE_RTP_ENTRY_FLAG_FOREACH_ENGINE)
> >
> > And another one like that for XE_RTP_MATCH_NOT_ENGINE_CLASS.
> >
> > Since we are using entries as parameters of the test, the RTP entry name
> > will be displayed in the kunit output, so I think we can skip the
> > explanatory string.
> >

Should there be an explanation somewhere within the file as a comment?
Such as a comment above this test explaining that MATCH_ENGINE_CLASS and
MATCH_NOT_ENGINE_CLASS are not allowed in this context?

> >> +	}
> >> +}
> >> +
> >> +static int xe_rtp_table_test_init(struct kunit *test)
> >> +{
> >> +	struct xe_device *xe;
> >> +	struct device *dev;
> >> +	int ret;
> >> +
> >> +	dev = drm_kunit_helper_alloc_device(test);
> >> +	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
> >> +
> >> +	xe = xe_kunit_helper_alloc_xe_device(test, dev);
> >> +	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, xe);
> >> +
> >> +	/* Initialize an empty device */
> >> +	test->priv = NULL;
> >> +
> >> +	ret = xe_pci_fake_device_init(xe);
> >> +	KUNIT_ASSERT_EQ(test, ret, 0);
> >> +	xe->drm.dev = dev;
> >> +	test->priv = xe;
> >> +
> >> +	return 0;
> >> +}
> >> +
> >> +static void xe_rtp_table_test_exit(struct kunit *test)
> >> +{
> >> +	struct xe_device *xe = test->priv;
> >> +
> >> +	drm_kunit_helper_free_device(test, xe->drm.dev);
> >> +}
> >> +
> >> +static void rtp_table_gt_test_desc(const struct xe_rtp_entry_sr *t, char *desc)
> >> +{
> >> +	strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
> >> +}
> >> +
> >> +RTP_KUNIT_ARRAY_PARAM(rtp_table_gt, gt_was, rtp_table_gt_test_desc);
> >> +
> >> +static struct kunit_case xe_rtp_table_tests[] = {
> >> +	KUNIT_CASE_PARAM(xe_rtp_table_gt_test, rtp_table_gt_gen_params),
> >> +	{}
> >> +};
> >> +
> >> +static struct kunit_suite xe_rtp_tables_test_suite = {
> >> +	.name = "xe_rtp_tables_test",
> >> +	.init = xe_rtp_table_test_init,
> >> +	.exit = xe_rtp_table_test_exit,
> >
> > We do not need fake device initialization for the current test being
> > done here.  We can simply drop those functions and the .init and .exit
> > initializations here.
> >

Gotcha. That is a remnant from my initial testing. Will remove in V2

> >> +	.test_cases = xe_rtp_table_tests,
> >> +};
> >> +
> >> +kunit_test_suite(xe_rtp_tables_test_suite);
> >> diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
> >> new file mode 100644
> >> index 000000000000..3e91dd08f854
> >> --- /dev/null
> >> +++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.h
> >> @@ -0,0 +1,24 @@
> >> +/* SPDX-License-Identifier: GPL-2.0 AND MIT */
> >> +/*
> >> + * Copyright © 2026 Intel Corporation
> >> + */
> >> +
> >> +// The "gen_params" function functionality does not work to dynamically collect the size
> >> +// of the WA array, even with the new n_entries pointer. This addition builds on that framework
> >> +// to allow dynamic sizing
> >> +#define RTP_KUNIT_ARRAY_PARAM(name, array, get_desc)						\
> >
> > The only user of this macro is xe_rtp_tables_test.c, I don't think we
> > need to expose it via a header.
> >
> > I also think RTP_TABLE_PARAM() would be a good name for the macro.
> >
> >> +	static const void *name##_gen_params(struct kunit *test,				\
> >> +					     const void *prev, char *desc)			\
> >> +	{											\
> >> +		typeof((array.entries)[0]) *__next = prev ?					\
> >> +			((typeof(__next))prev) + 1 : (array.entries);				\
> >> +		if (!prev)									\
> >> +			kunit_register_params_array(test, array.entries, array.n_entries, NULL);\
> >
> > Do we really need to call kunit_register_params_array()?  Looking at the
> > implementation of kunit, it appears kunit_register_params_array() is
> > meant to be used together with kunit_array_gen_params() as the parameter
> > generator.  Here we are using our own custom generator.
> >
> > By the way, I wonder why kunit itself is doing that for
> > KUNIT_ARRAY_PARAM() and KUNIT_ARRAY_PARAM_DESC().  Commit b820b9077b7f
> > ("kunit: Enable direct registration of parameter arrays to a KUnit
> > test") is the one that added kunit_register_params_array() and says the
> > following:
> >
> >     "The arrays passed to KUNIT_ARRAY_PARAM(,DESC) will also be registered to
> >     the parameterized test context for consistency as well as for higher
> >     availability of the parameter count that will be used for outputting a KTAP
> >     test plan for a parameterized test."
> >
> > , however, the registered data is only used if the generator is
> > kunit_array_gen_params() anyway, so the registration in those macros
> > seems useless.
> >
> > Bottom line: I think we can simply drop this call.
> >
> >> +		if (__next - array.entries < array.n_entries) {					\
> >> +			void (*__get_desc)(typeof(__next), char *) = get_desc;			\
> >> +			if (__get_desc)								\
> >> +				__get_desc(__next, desc);					\
> >
> > Since we are writing this macro specifically for RTP entries, I don't
> > think we need a "get description" function: we can use __next->name
> > directly here.
> >
> > Also, for the description, I think we could also include the name of the
> > variable, for completeness.  Today we are only adding gt_was, but in the
> > future we could add others.  Using the variable name in the parameter
> > name here should make it easy to correctly spot the offending RTP entry
> > in a expectation failure.
> >
> > Hence, here is what I would suggest for such a macro (tested locally):
> >
> >     #define RTP_TABLE_PARAM(array)								\
> 
> Maybe we should use "table" for the parameter here, since we are
> expecting xe_rtp_table or xe_rtp_table_sr instances?
> 
> --
> Gustavo Sousa
> 
> >     	static const void *array##_gen_params(struct kunit *test,				\
> >     					     const void *prev, char *desc)			\
> >     	{											\
> >     		typeof((array.entries)[0]) *__next = prev ?					\
> >     			((typeof(__next))prev) + 1 : (array.entries);				\
> >     		if (__next - array.entries < array.n_entries) {					\
> >     			scnprintf(desc, KUNIT_PARAM_DESC_SIZE, #array "/%s", __next->name);	\
> >     			return __next;								\
> >     		}										\
> >     		return NULL;									\
> >     	}
> >     

I will work on implementing this. I used the existing macro to match the
style of the KUNIT_ARRAY_PARAM() macro used in other test files, but
those did not work with the ARRAY_SIZE() macro due to context issues. 

I do like a lot of these changes, though, so I will work on adding this
into V2.

> >
> >
> > --
> > Gustavo Sousa
> >
> >> +			return __next;								\
> >> +		}										\
> >> +		return NULL;									\
> >> +	}
> >> diff --git a/drivers/gpu/drm/xe/xe_wa.c b/drivers/gpu/drm/xe/xe_wa.c
> >> index 39c507edb8ce..285072fe0a47 100644
> >> --- a/drivers/gpu/drm/xe/xe_wa.c
> >> +++ b/drivers/gpu/drm/xe/xe_wa.c
> >> @@ -130,7 +130,7 @@
> >>  __diag_push();
> >>  __diag_ignore_all("-Woverride-init", "Allow field overrides in table");
> >>  
> >> -static const struct xe_rtp_table_sr gt_was = XE_RTP_TABLE_SR(
> >> +VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was = XE_RTP_TABLE_SR(
> >>  	/* Workarounds applying over a range of IPs */
> >>  
> >>  	{ XE_RTP_NAME("14011060649"),
> >> diff --git a/drivers/gpu/drm/xe/xe_wa.h b/drivers/gpu/drm/xe/xe_wa.h
> >> index a5f7d33c1b32..17dff615e507 100644
> >> --- a/drivers/gpu/drm/xe/xe_wa.h
> >> +++ b/drivers/gpu/drm/xe/xe_wa.h
> >> @@ -6,6 +6,7 @@
> >>  #ifndef _XE_WA_H_
> >>  #define _XE_WA_H_
> >>  
> >> +#include <kunit/visibility.h>
> >>  #include "xe_assert.h"
> >>  
> >>  struct drm_printer;
> >> @@ -24,6 +25,10 @@ void xe_wa_apply_tile_workarounds(struct xe_tile *tile);
> >>  void xe_wa_device_dump(struct xe_device *xe, struct drm_printer *p);
> >>  int xe_wa_gt_dump(struct xe_gt *gt, struct drm_printer *p);
> >>  
> >> +#if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST)
> >> +extern VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was;
> >> +#endif
> >> +
> >>  /**
> >>   * XE_GT_WA - Out-of-band GT workarounds, to be queried and called as needed.
> >>   * @gt__: gt instance
> >> -- 
> >> 2.43.0

-- 
--
Violet Monti

Re: [PATCH 3/4] drm/xe/rtp: Add OOB WAs rule checking

[Violet Monti]

On Mon, May 18, 2026 at 05:54:26PM -0300, Gustavo Sousa wrote:
> 
> Same comments from previous patch about commit title and body applies
> here.
>

    drm/xe/rtp: Ensure oob_was doesn't evaluate rules with engine types

> Violet Monti <violet.monti@intel.com> writes:
> 
> > This commit builds on the implementation of the GT WA testing, increasing
> > the scope of testing to include the OOB workaround list. The added test
> > checks for workarounds with an engine_class rule, and raises an expectation
> > failure if any are found. Unlike the GT workarounds, there are no flags
> > within this workaround list, so all engine_class rules will fail.
> >
> > This test prevents future implementation of rules that would apply an
> > engine_class rule without an active engine in context, preventing rule
> > errors or mishaps.
> >
> > Signed-off-by: Violet Monti <violet.monti@intel.com>
> > ---
> >  drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c | 20 +++++++++++++++++++
> >  drivers/gpu/drm/xe/xe_wa.c                    |  2 +-
> >  drivers/gpu/drm/xe/xe_wa.h                    |  1 +
> >  3 files changed, 22 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
> > index 100cac379b08..eae3262775bb 100644
> > --- a/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
> > +++ b/drivers/gpu/drm/xe/tests/xe_rtp_tables_test.c
> > @@ -24,6 +24,18 @@ static void xe_rtp_table_gt_test(struct kunit *test)
> >  	}
> >  }
> >  
> > +static void xe_rtp_table_oob_test(struct kunit *test)
> > +{
> > +	const struct xe_rtp_entry *param = test->param_value;
> > +
> > +	for (int i = 0; i < param->n_rules; i++) {
> > +		KUNIT_EXPECT_NE_MSG(test, param->rules[i].match_type,
> > +				    XE_RTP_MATCH_ENGINE_CLASS,
> > +				    "OOB_WA %s has an engine class rule",
> > +				    param->name);
> 
> Like with the previous patch, I think we could simplify by using
> something like
> 
>   KUNIT_EXPECT_NE(test, param->rules[i].match_type,
>                   XE_RTP_MATCH_ENGINE_CLASS)
> 

Agreed. Will add into V2

> > +	}
> > +}
> > +
> >  static int xe_rtp_table_test_init(struct kunit *test)
> >  {
> >  	struct xe_device *xe;
> > @@ -61,8 +73,16 @@ static void rtp_table_gt_test_desc(const struct xe_rtp_entry_sr *t, char *desc)
> >  
> >  RTP_KUNIT_ARRAY_PARAM(rtp_table_gt, gt_was, rtp_table_gt_test_desc);
> >  
> > +static void rtp_table_oob_test_desc(const struct xe_rtp_entry *t, char *desc)
> > +{
> > +	strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
> > +}
> > +
> > +RTP_KUNIT_ARRAY_PARAM(rtp_table_oob, oob_was, rtp_table_oob_test_desc);
> > +
> >  static struct kunit_case xe_rtp_table_tests[] = {
> >  	KUNIT_CASE_PARAM(xe_rtp_table_gt_test, rtp_table_gt_gen_params),
> > +	KUNIT_CASE_PARAM(xe_rtp_table_oob_test, rtp_table_oob_gen_params),
> 
> Yeah.  It is unfortunate that we need 2 different functions here.  I think
> in the future we could try to have a single way of expressing RTP entries
> instead of having two different struct types (xe_rtp_entry vs
> xe_rtp_entry_sr).  That would allow us to unify code specific for
> processing rules in those entries.
>

I definitely agree with unifying the code. This series was difficult to
implement initially due to the separate setups for xe_rtp_entry and
xe_rtp_entry_sr. 

> --
> Gustavo Sousa
> 
> >  	{}
> >  };
> >  
> > diff --git a/drivers/gpu/drm/xe/xe_wa.c b/drivers/gpu/drm/xe/xe_wa.c
> > index 285072fe0a47..5744bd3f8be9 100644
> > --- a/drivers/gpu/drm/xe/xe_wa.c
> > +++ b/drivers/gpu/drm/xe/xe_wa.c
> > @@ -802,7 +802,7 @@ static const struct xe_rtp_entry oob_was_entries[] = {
> >  
> >  static_assert(ARRAY_SIZE(oob_was_entries)  == _XE_WA_OOB_COUNT);
> >  
> > -static __maybe_unused const struct xe_rtp_table oob_was = {
> > +VISIBLE_IF_KUNIT __maybe_unused const struct xe_rtp_table oob_was = {
> >  	.entries = oob_was_entries,
> >  	.n_entries = ARRAY_SIZE(oob_was_entries),
> >  };
> > diff --git a/drivers/gpu/drm/xe/xe_wa.h b/drivers/gpu/drm/xe/xe_wa.h
> > index 17dff615e507..7ac6d365b65f 100644
> > --- a/drivers/gpu/drm/xe/xe_wa.h
> > +++ b/drivers/gpu/drm/xe/xe_wa.h
> > @@ -27,6 +27,7 @@ int xe_wa_gt_dump(struct xe_gt *gt, struct drm_printer *p);
> >  
> >  #if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST)
> >  extern VISIBLE_IF_KUNIT const struct xe_rtp_table_sr gt_was;
> > +extern VISIBLE_IF_KUNIT __maybe_unused const struct xe_rtp_table oob_was;
> >  #endif
> >  
> >  /**
> > -- 
> > 2.43.0

-- 
--
Violet Monti