drm/xe/rtp: Write kunit test cases specific for rule matching

The kunit test cases for the RTP framework are currently separated into
those that validate xe_rtp_process_to_sr() and those that validate
xe_rtp_process().  In both of them, we also have mixed stuff to validate
rule matching functionality, which should rather be done in a separate
test case group.

Let's create such a group, specific for validating rule matching, and
also add an initial set of cases.  In an upcoming change, we will do a
cleanup of the other groups by migrating those cases intended for rule
matching to this new group.

v2:
  - s/no-yes-or-no-yes/no-yes-or-yes-no/ (Matt)
  - Drop leftover include of <kunit/test.h>.

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

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp.c b/drivers/gpu/drm/xe/tests/xe_rtp.c
new file mode 100644 (file)
index 0000000..b3a8b75
--- /dev/null
+++ b/drivers/gpu/drm/xe/tests/xe_rtp.c
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-2.0 AND MIT
+/*
+ * Copyright © 2026 Intel Corporation
+ */
+
+#include "tests/xe_rtp_test.h"
+
+#include <kunit/visibility.h>
+
+/**
+ * xe_rtp_rule_matches - Check if a set of RTP rule set match against the
+ *                      device/GT/hwe
+ * @xe: The xe device
+ * @gt: The GT struct (may be NULL)
+ * @hwe: The hw_engine  (may be NULL)
+ * @rules: The array of rules to match against
+ * @n_rules: Number of items in @rules
+ * @err: Pointer (may be NULL) to set error number.
+ *
+ * This parses the set of rules and check if they match against the passed
+ * parameters.
+ *
+ * If passed, @err is updated with a non-zero negative error number or zero if
+ * no errors were found during the parsing/evaluation of rules.
+ *
+ * Returns true if there is a match and false if there is no match or if an
+ * error was found.
+ */
+bool xe_rtp_rule_matches(const struct xe_device *xe,
+                        struct xe_gt *gt,
+                        struct xe_hw_engine *hwe,
+                        const struct xe_rtp_rule *rules,
+                        unsigned int n_rules,
+                        int *err)
+{
+       return rule_matches_with_err(xe, gt, hwe, rules, n_rules, err);
+}
+EXPORT_SYMBOL_IF_KUNIT(xe_rtp_rule_matches);

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
index 5d78f2283df935857c1e70e5ff86b7985e7a959d..c98d85a156529041ec8f44685df35b145ed8191f 100644 (file)
--- a/drivers/gpu/drm/xe/tests/xe_rtp_test.c
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
@@ -21,6 +21,7 @@
 #include "xe_pci_test.h"
 #include "xe_reg_sr.h"
 #include "xe_rtp.h"
+#include "xe_rtp_test.h"
 
 #define REGULAR_REG1           XE_REG(1)
 #define REGULAR_REG2           XE_REG(2)
@@ -37,6 +38,14 @@
 #undef XE_REG_MCR
 #define XE_REG_MCR(...)     XE_REG(__VA_ARGS__, .mcr = 1)
 
+struct rtp_rules_test_case {
+       const char *name;
+       bool expected_match;
+       int expected_err;
+       const struct xe_rtp_rule *rules;
+       u8 n_rules;
+};
+
 struct rtp_to_sr_test_case {
        const char *name;
        struct xe_reg expected_reg;
@@ -83,6 +92,130 @@ static bool match_no(const struct xe_device *xe, const struct xe_gt *gt,
        return false;
 }
 
+static const struct rtp_rules_test_case rtp_rules_cases[] = {
+       /*
+        * Single rules.
+        *
+        * TODO: Include other types of rules as well: GRAPHICS_VERSION(),
+        * MEDIA_VERSION(), etc.
+        */
+       {
+               .name = "no",
+               .expected_match = false,
+               XE_RTP_RULES(FUNC(match_no)),
+       },
+       {
+               .name = "yes",
+               .expected_match = true,
+               XE_RTP_RULES(FUNC(match_yes)),
+       },
+
+       /* Conjunctions with 2 operands. */
+       {
+               .name = "no-and-no",
+               .expected_match = false,
+               XE_RTP_RULES(FUNC(match_no), FUNC(match_no)),
+       },
+       {
+               .name = "no-and-yes",
+               .expected_match = false,
+               XE_RTP_RULES(FUNC(match_no), FUNC(match_yes)),
+       },
+       {
+               .name = "yes-and-no",
+               .expected_match = false,
+               XE_RTP_RULES(FUNC(match_yes), FUNC(match_no)),
+       },
+       {
+               .name = "yes-and-yes",
+               .expected_match = true,
+               XE_RTP_RULES(FUNC(match_yes), FUNC(match_yes)),
+       },
+
+       /* Disjunctions with 2 operands. */
+       {
+               .name = "no-or-no",
+               .expected_match = false,
+               XE_RTP_RULES(FUNC(match_no), OR, FUNC(match_no)),
+       },
+       {
+               .name = "no-or-yes",
+               .expected_match = true,
+               XE_RTP_RULES(FUNC(match_no), OR, FUNC(match_yes)),
+       },
+       {
+               .name = "yes-or-no",
+               .expected_match = true,
+               XE_RTP_RULES(FUNC(match_yes), OR, FUNC(match_no)),
+       },
+       {
+               .name = "yes-or-yes",
+               .expected_match = true,
+               XE_RTP_RULES(FUNC(match_yes), OR, FUNC(match_yes)),
+       },
+
+       /* Conjunction and disjunctions. */
+       {
+               .name = "no-yes-or-yes-no",
+               .expected_match = false,
+               XE_RTP_RULES(FUNC(match_no), FUNC(match_yes), OR,
+                            FUNC(match_yes), FUNC(match_no)),
+       },
+       {
+               .name = "no-yes-or-yes-yes",
+               .expected_match = true,
+               XE_RTP_RULES(FUNC(match_no), FUNC(match_yes), OR,
+                            FUNC(match_yes), FUNC(match_yes)),
+       },
+       {
+               .name = "yes-yes-or-no-yes",
+               .expected_match = true,
+               XE_RTP_RULES(FUNC(match_yes), FUNC(match_yes), OR,
+                            FUNC(match_no), FUNC(match_yes)),
+       },
+       {
+               .name = "yes-yes-or-yes-yes",
+               .expected_match = true,
+               XE_RTP_RULES(FUNC(match_yes), FUNC(match_yes), OR,
+                            FUNC(match_yes), FUNC(match_yes)),
+       },
+       {
+               .name = "no-no-or-yes-or-no",
+               .expected_match = true,
+               XE_RTP_RULES(FUNC(match_no), FUNC(match_no), OR,
+                            FUNC(match_yes), OR,
+                            FUNC(match_no)),
+       },
+
+       /* Syntax errors. */
+       {
+               .name = "or",
+               .expected_match = false,
+               .expected_err = -EINVAL,
+               XE_RTP_RULES(OR),
+       },
+       {
+               .name = "or-anything",
+               .expected_match = false,
+               .expected_err = -EINVAL,
+               XE_RTP_RULES(OR, FUNC(match_yes)),
+       },
+};
+
+static void xe_rtp_rules_tests(struct kunit *test)
+{
+       const struct rtp_rules_test_case *param = test->param_value;
+       struct xe_device *xe = test->priv;
+       struct xe_gt *gt = xe_device_get_root_tile(xe)->primary_gt;
+       int err;
+       bool match;
+
+       match = xe_rtp_rule_matches(xe, gt, NULL, param->rules, param->n_rules, &err);
+
+       KUNIT_EXPECT_EQ(test, match, param->expected_match);
+       KUNIT_EXPECT_EQ(test, err, param->expected_err);
+}
+
 static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
        {
                .name = "coalesce-same-reg",
@@ -544,6 +677,13 @@ static void xe_rtp_process_tests(struct kunit *test)
        KUNIT_EXPECT_EQ(test, active, param->expected_active);
 }
 
+static void rtp_rules_desc(const struct rtp_rules_test_case *t, char *desc)
+{
+       strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
+}
+
+KUNIT_ARRAY_PARAM(rtp_rules, rtp_rules_cases, rtp_rules_desc);
+
 static void rtp_to_sr_desc(const struct rtp_to_sr_test_case *t, char *desc)
 {
        strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
@@ -591,6 +731,7 @@ static void xe_rtp_test_exit(struct kunit *test)
 }
 
 static struct kunit_case xe_rtp_tests[] = {
+       KUNIT_CASE_PARAM(xe_rtp_rules_tests, rtp_rules_gen_params),
        KUNIT_CASE_PARAM(xe_rtp_process_to_sr_tests, rtp_to_sr_gen_params),
        KUNIT_CASE_PARAM(xe_rtp_process_tests, rtp_gen_params),
        {}

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_test.h b/drivers/gpu/drm/xe/tests/xe_rtp_test.h
new file mode 100644 (file)
index 0000000..26becc1
--- /dev/null
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_test.h
@@ -0,0 +1,23 @@
+/* SPDX-License-Identifier: GPL-2.0 AND MIT */
+/*
+ * Copyright © 2026 Intel Corporation
+ */
+
+#ifndef _XE_RTP_TEST_H_
+#define _XE_RTP_TEST_H_
+
+#include <linux/types.h>
+
+struct xe_device;
+struct xe_gt;
+struct xe_hw_engine;
+struct xe_rtp_rule;
+
+bool xe_rtp_rule_matches(const struct xe_device *xe,
+                        struct xe_gt *gt,
+                        struct xe_hw_engine *hwe,
+                        const struct xe_rtp_rule *rules,
+                        unsigned int n_rules,
+                        int *err);
+
+#endif

diff --git a/drivers/gpu/drm/xe/xe_rtp.c b/drivers/gpu/drm/xe/xe_rtp.c
index 1a4dcbbbc1764aafab07e41474e3cb3a0285fed2..0e1adf07e4e78d5aae4aa749048532a7ce27cae5 100644 (file)
--- a/drivers/gpu/drm/xe/xe_rtp.c
+++ b/drivers/gpu/drm/xe/xe_rtp.c
@@ -30,16 +30,20 @@ static bool has_samedia(const struct xe_device *xe)
        return xe->info.media_verx100 >= 1300;
 }
 
-static bool rule_matches(const struct xe_device *xe,
-                        struct xe_gt *gt,
-                        struct xe_hw_engine *hwe,
-                        const struct xe_rtp_rule *rules,
-                        unsigned int n_rules)
+static bool rule_matches_with_err(const struct xe_device *xe,
+                                 struct xe_gt *gt,
+                                 struct xe_hw_engine *hwe,
+                                 const struct xe_rtp_rule *rules,
+                                 unsigned int n_rules,
+                                 int *err)
 {
        const struct xe_rtp_rule *r;
        unsigned int i, rcount = 0;
        bool match;
 
+       if (err)
+               *err = 0;
+
        for (r = rules, i = 0; i < n_rules; r = &rules[++i]) {
                switch (r->match_type) {
                case XE_RTP_MATCH_OR:
@@ -58,21 +62,21 @@ static bool rule_matches(const struct xe_device *xe,
                        break;
                case XE_RTP_MATCH_PLATFORM_STEP:
                        if (drm_WARN_ON(&xe->drm, xe->info.step.platform == STEP_NONE))
-                               return false;
+                               goto error;
 
                        match = xe->info.step.platform >= r->step_start &&
                                xe->info.step.platform < r->step_end;
                        break;
                case XE_RTP_MATCH_GRAPHICS_VERSION:
                        if (drm_WARN_ON(&xe->drm, !gt))
-                               return false;
+                               goto error;
 
                        match = xe->info.graphics_verx100 == r->ver_start &&
                                (!has_samedia(xe) || !xe_gt_is_media_type(gt));
                        break;
                case XE_RTP_MATCH_GRAPHICS_VERSION_RANGE:
                        if (drm_WARN_ON(&xe->drm, !gt))
-                               return false;
+                               goto error;
 
                        match = xe->info.graphics_verx100 >= r->ver_start &&
                                xe->info.graphics_verx100 <= r->ver_end &&
@@ -80,13 +84,13 @@ static bool rule_matches(const struct xe_device *xe,
                        break;
                case XE_RTP_MATCH_GRAPHICS_VERSION_ANY_GT:
                        if (drm_WARN_ON(&xe->drm, !gt))
-                               return false;
+                               goto error;
 
                        match = xe->info.graphics_verx100 == r->ver_start;
                        break;
                case XE_RTP_MATCH_GRAPHICS_STEP:
                        if (drm_WARN_ON(&xe->drm, !gt))
-                               return false;
+                               goto error;
 
                        match = xe->info.step.graphics >= r->step_start &&
                                xe->info.step.graphics < r->step_end &&
@@ -94,14 +98,14 @@ static bool rule_matches(const struct xe_device *xe,
                        break;
                case XE_RTP_MATCH_MEDIA_VERSION:
                        if (drm_WARN_ON(&xe->drm, !gt))
-                               return false;
+                               goto error;
 
                        match = xe->info.media_verx100 == r->ver_start &&
                                (!has_samedia(xe) || xe_gt_is_media_type(gt));
                        break;
                case XE_RTP_MATCH_MEDIA_VERSION_RANGE:
                        if (drm_WARN_ON(&xe->drm, !gt))
-                               return false;
+                               goto error;
 
                        match = xe->info.media_verx100 >= r->ver_start &&
                                xe->info.media_verx100 <= r->ver_end &&
@@ -109,7 +113,7 @@ static bool rule_matches(const struct xe_device *xe,
                        break;
                case XE_RTP_MATCH_MEDIA_STEP:
                        if (drm_WARN_ON(&xe->drm, !gt))
-                               return false;
+                               goto error;
 
                        match = xe->info.step.media >= r->step_start &&
                                xe->info.step.media < r->step_end &&
@@ -117,7 +121,7 @@ static bool rule_matches(const struct xe_device *xe,
                        break;
                case XE_RTP_MATCH_MEDIA_VERSION_ANY_GT:
                        if (drm_WARN_ON(&xe->drm, !gt))
-                               return false;
+                               goto error;
 
                        match = xe->info.media_verx100 == r->ver_start;
                        break;
@@ -129,13 +133,13 @@ static bool rule_matches(const struct xe_device *xe,
                        break;
                case XE_RTP_MATCH_ENGINE_CLASS:
                        if (drm_WARN_ON(&xe->drm, !hwe))
-                               return false;
+                               goto error;
 
                        match = hwe->class == r->engine_class;
                        break;
                case XE_RTP_MATCH_NOT_ENGINE_CLASS:
                        if (drm_WARN_ON(&xe->drm, !hwe))
-                               return false;
+                               goto error;
 
                        match = hwe->class != r->engine_class;
                        break;
@@ -167,9 +171,24 @@ static bool rule_matches(const struct xe_device *xe,
 
 done:
        if (drm_WARN_ON(&xe->drm, !rcount))
-               return false;
+               goto error;
 
        return true;
+
+error:
+       if (err)
+               *err = -EINVAL;
+
+       return false;
+}
+
+static bool rule_matches(const struct xe_device *xe,
+                        struct xe_gt *gt,
+                        struct xe_hw_engine *hwe,
+                        const struct xe_rtp_rule *rules,
+                        unsigned int n_rules)
+{
+       return rule_matches_with_err(xe, gt, hwe, rules, n_rules, NULL);
 }
 
 static void rtp_add_sr_entry(const struct xe_rtp_action *action,
@@ -412,3 +431,7 @@ bool xe_rtp_match_has_msix(const struct xe_device *xe,
 {
        return xe_device_has_msix(xe);
 }
+
+#if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST)
+#include "tests/xe_rtp.c"
+#endif