drm/xe/rtp: Drop rule matching cases from rtp_to_sr_cases and rtp_cases

The kunit test cases for the RTP framework are currently separated into
three groups:

(1) rtp_rules_cases:
    Those to verify rule matching logic.

(2) rtp_to_sr_cases:
    Those to verify generation of save/restore tables from RTP tables.

(3) rtp_cases
    Those to verify processing of RTP tables without save/restore action
    associated, which are used for OOB workarounds.

Today we have some cases in (2) and (3) that are actually meant to
verify rule matching logic.  Now that we have (1), let's cleanup (2)
and (3) so that they become focused on their main objectives.

Reviewed-by: Matt Roper <matthew.d.roper@intel.com>
Link: https://patch.msgid.link/20260522-rtp-rule-parser-v3-2-0c51039899f4@intel.com
Signed-off-by: Gustavo Sousa <gustavo.sousa@intel.com>

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
index c98d85a156529041ec8f44685df35b145ed8191f..b3eab1337b0c1b0c9115e7f4537459aa2fe94c3f 100644 (file)
--- a/drivers/gpu/drm/xe/tests/xe_rtp_test.c
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
@@ -257,80 +257,6 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
                        {}
                },
        },
-       {
-               .name = "match-or",
-               .expected_reg = REGULAR_REG1,
-               .expected_set_bits = REG_BIT(0) | REG_BIT(1) | REG_BIT(2),
-               .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[]) {
-                       { XE_RTP_NAME("first"),
-                         XE_RTP_RULES(FUNC(match_yes), OR, FUNC(match_no)),
-                         XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
-                       },
-                       { XE_RTP_NAME("middle"),
-                         XE_RTP_RULES(FUNC(match_no), FUNC(match_no), OR,
-                                      FUNC(match_yes), OR,
-                                      FUNC(match_no)),
-                         XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(1)))
-                       },
-                       { XE_RTP_NAME("last"),
-                         XE_RTP_RULES(FUNC(match_no), OR, FUNC(match_yes)),
-                         XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(2)))
-                       },
-                       { XE_RTP_NAME("no-match"),
-                         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[]) {
-                       { XE_RTP_NAME("leading-or"),
-                         XE_RTP_RULES(OR, FUNC(match_yes)),
-                         XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
-                       },
-                       { XE_RTP_NAME("trailing-or"),
-                         /*
-                          * First condition is match_no, otherwise the failure
-                          * wouldn't really trigger as RTP stops processing as
-                          * soon as it has a matching set of rules
-                          */
-                         XE_RTP_RULES(FUNC(match_no), OR),
-                         XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(1)))
-                       },
-                       { XE_RTP_NAME("no-or-or-yes"),
-                         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",
-               .expected_reg = REGULAR_REG1,
-               .expected_set_bits = REG_BIT(0),
-               .expected_clr_bits = REG_BIT(0),
-               .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[]) {
-                       { XE_RTP_NAME("basic-1"),
-                         XE_RTP_RULES(FUNC(match_yes)),
-                         XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
-                       },
-                       { XE_RTP_NAME("basic-2"),
-                         XE_RTP_RULES(FUNC(match_yes), FUNC(match_no)),
-                         XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(1)))
-                       },
-                       {}
-               },
-       },
        {
                .name = "two-regs-two-entries",
                .expected_reg = REGULAR_REG1,
@@ -591,33 +517,15 @@ static const struct rtp_test_case rtp_cases[] = {
                },
        },
        {
-               .name = "inactive-1st_or_active-inactive",
+               .name = "inactive-active-inactive",
                .expected_active = BIT(1),
                .entries = (const struct xe_rtp_entry[]) {
                        { XE_RTP_NAME("r1"),
                          XE_RTP_RULES(FUNC(match_no)),
                        },
-                       { XE_RTP_NAME("r2_or_conditions"),
-                         XE_RTP_RULES(FUNC(match_yes), OR,
-                                      FUNC(match_no), OR,
-                                      FUNC(match_no)) },
-                       { 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[]) {
-                       { XE_RTP_NAME("r1"),
-                         XE_RTP_RULES(FUNC(match_no)),
+                       { XE_RTP_NAME("r2"),
+                         XE_RTP_RULES(FUNC(match_yes)),
                        },
-                       { XE_RTP_NAME("r2_or_conditions"),
-                         XE_RTP_RULES(FUNC(match_no), OR,
-                                      FUNC(match_yes), OR,
-                                      FUNC(match_no)) },
                        { XE_RTP_NAME("r3"),
                          XE_RTP_RULES(FUNC(match_no)),
                        },
@@ -625,33 +533,15 @@ static const struct rtp_test_case rtp_cases[] = {
                },
        },
        {
-               .name = "inactive-last_or_active-inactive",
-               .expected_active = BIT(1),
+               .name = "inactive-inactive-inactive",
+               .expected_active = 0,
                .entries = (const struct xe_rtp_entry[]) {
                        { XE_RTP_NAME("r1"),
                          XE_RTP_RULES(FUNC(match_no)),
                        },
-                       { XE_RTP_NAME("r2_or_conditions"),
-                         XE_RTP_RULES(FUNC(match_no), OR,
-                                      FUNC(match_no), OR,
-                                      FUNC(match_yes)) },
-                       { 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[]) {
-                       { XE_RTP_NAME("r1"),
+                       { XE_RTP_NAME("r2"),
                          XE_RTP_RULES(FUNC(match_no)),
                        },
-                       { XE_RTP_NAME("r2_or_conditions"),
-                         XE_RTP_RULES(FUNC(match_no), OR,
-                                      FUNC(match_no), OR,
-                                      FUNC(match_no)) },
                        { XE_RTP_NAME("r3"),
                          XE_RTP_RULES(FUNC(match_no)),
                        },