drm/xe/tests: Add KUnit tests for new VRAM fair provisioning

Add basic test cases to check outcome of the fair VRAM provisioning
for regular and admin-only PF mode.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Reviewed-by: Piotr Piórkowski <piotr.piorkowski@intel.com>
Link: https://patch.msgid.link/20260218205553.3561-7-michal.wajdeczko@intel.com

diff --git a/drivers/gpu/drm/xe/tests/xe_gt_sriov_pf_config_kunit.c b/drivers/gpu/drm/xe/tests/xe_gt_sriov_pf_config_kunit.c
index 3889dc3e49ca61241f9afe2ce842b070971d534c..305dbd4e5d1a70b19a0ec658a804e231762607ed 100644 (file)
--- a/drivers/gpu/drm/xe/tests/xe_gt_sriov_pf_config_kunit.c
+++ b/drivers/gpu/drm/xe/tests/xe_gt_sriov_pf_config_kunit.c
@@ -11,6 +11,7 @@
 #include "xe_pci_test.h"
 
 #define TEST_MAX_VFS   63
+#define TEST_VRAM      0x37a800000ull
 
 static void pf_set_admin_mode(struct xe_device *xe, bool enable)
 {
@@ -19,6 +20,17 @@ static void pf_set_admin_mode(struct xe_device *xe, bool enable)
        KUNIT_EXPECT_EQ(kunit_get_current_test(), enable, xe_sriov_pf_admin_only(xe));
 }
 
+static void pf_set_usable_vram(struct xe_device *xe, u64 usable)
+{
+       struct xe_tile *tile = xe_device_get_root_tile(xe);
+       struct kunit *test = kunit_get_current_test();
+
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tile);
+       xe->mem.vram->usable_size = usable;
+       tile->mem.vram->usable_size = usable;
+       KUNIT_ASSERT_EQ(test, usable, xe_vram_region_usable_size(tile->mem.vram));
+}
+
 static const void *num_vfs_gen_param(struct kunit *test, const void *prev, char *desc)
 {
        unsigned long next = 1 + (unsigned long)prev;
@@ -34,9 +46,11 @@ static int pf_gt_config_test_init(struct kunit *test)
 {
        struct xe_pci_fake_data fake = {
                .sriov_mode = XE_SRIOV_MODE_PF,
-               .platform = XE_TIGERLAKE, /* any random platform with SR-IOV */
+               .platform = XE_BATTLEMAGE, /* any random DGFX platform with SR-IOV */
                .subplatform = XE_SUBPLATFORM_NONE,
+               .graphics_verx100 = 2001,
        };
+       struct xe_vram_region *vram;
        struct xe_device *xe;
        struct xe_gt *gt;
 
@@ -50,6 +64,19 @@ static int pf_gt_config_test_init(struct kunit *test)
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, gt);
        test->priv = gt;
 
+       /* pretend it has some VRAM */
+       KUNIT_ASSERT_TRUE(test, IS_DGFX(xe));
+       vram = kunit_kzalloc(test, sizeof(*vram), GFP_KERNEL);
+       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vram);
+       vram->usable_size = TEST_VRAM;
+       xe->mem.vram = vram;
+       xe->tiles[0].mem.vram = vram;
+
+       /* pretend we have a valid LMTT */
+       KUNIT_ASSERT_TRUE(test, xe_device_has_lmtt(xe));
+       KUNIT_ASSERT_GE(test, GRAPHICS_VERx100(xe), 1260);
+       xe->tiles[0].sriov.pf.lmtt.ops = &lmtt_ml_ops;
+
        /* pretend it can support up to 63 VFs */
        xe->sriov.pf.device_total_vfs = TEST_MAX_VFS;
        xe->sriov.pf.driver_max_vfs = TEST_MAX_VFS;
@@ -189,13 +216,80 @@ static void fair_ggtt(struct kunit *test)
                KUNIT_ASSERT_EQ(test, SZ_2G, pf_profile_fair_ggtt(gt, num_vfs));
 }
 
+static const u64 vram_sizes[] = {
+       SZ_4G - SZ_512M,
+       SZ_8G + SZ_4G - SZ_512M,
+       SZ_16G - SZ_512M,
+       SZ_32G - SZ_512M,
+       SZ_64G - SZ_512M,
+       TEST_VRAM,
+};
+
+static void u64_param_get_desc(const u64 *p, char *desc)
+{
+       string_get_size(*p, 1, STRING_UNITS_2, desc, KUNIT_PARAM_DESC_SIZE);
+}
+
+KUNIT_ARRAY_PARAM(vram_size, vram_sizes, u64_param_get_desc);
+
+static void fair_vram_1vf(struct kunit *test)
+{
+       const u64 usable = *(const u64 *)test->param_value;
+       struct xe_gt *gt = test->priv;
+       struct xe_device *xe = gt_to_xe(gt);
+
+       pf_set_admin_mode(xe, false);
+       pf_set_usable_vram(xe, usable);
+
+       KUNIT_EXPECT_NE(test, 0, pf_profile_fair_lmem(gt, 1));
+       KUNIT_EXPECT_GE(test, usable, pf_profile_fair_lmem(gt, 1));
+       KUNIT_EXPECT_TRUE(test, is_power_of_2(pf_profile_fair_lmem(gt, 1)));
+       KUNIT_EXPECT_GE(test, usable - pf_profile_fair_lmem(gt, 1), pf_profile_fair_lmem(gt, 1));
+}
+
+static void fair_vram_1vf_admin_only(struct kunit *test)
+{
+       const u64 usable = *(const u64 *)test->param_value;
+       struct xe_gt *gt = test->priv;
+       struct xe_device *xe = gt_to_xe(gt);
+
+       pf_set_admin_mode(xe, true);
+       pf_set_usable_vram(xe, usable);
+
+       KUNIT_EXPECT_NE(test, 0, pf_profile_fair_lmem(gt, 1));
+       KUNIT_EXPECT_GE(test, usable, pf_profile_fair_lmem(gt, 1));
+       KUNIT_EXPECT_LT(test, usable - pf_profile_fair_lmem(gt, 1), pf_profile_fair_lmem(gt, 1));
+       KUNIT_EXPECT_TRUE(test, IS_ALIGNED(pf_profile_fair_lmem(gt, 1), SZ_1G));
+}
+
+static void fair_vram(struct kunit *test)
+{
+       unsigned int num_vfs = (unsigned long)test->param_value;
+       struct xe_gt *gt = test->priv;
+       struct xe_device *xe = gt_to_xe(gt);
+       u64 alignment = pf_get_lmem_alignment(gt);
+       char size[10];
+
+       pf_set_admin_mode(xe, false);
+
+       string_get_size(pf_profile_fair_lmem(gt, num_vfs), 1, STRING_UNITS_2, size, sizeof(size));
+       kunit_info(test, "fair %s %llx\n", size, pf_profile_fair_lmem(gt, num_vfs));
+
+       KUNIT_EXPECT_TRUE(test, is_power_of_2(pf_profile_fair_lmem(gt, num_vfs)));
+       KUNIT_EXPECT_TRUE(test, IS_ALIGNED(pf_profile_fair_lmem(gt, num_vfs), alignment));
+       KUNIT_EXPECT_GE(test, TEST_VRAM, num_vfs * pf_profile_fair_lmem(gt, num_vfs));
+}
+
 static struct kunit_case pf_gt_config_test_cases[] = {
        KUNIT_CASE(fair_contexts_1vf),
        KUNIT_CASE(fair_doorbells_1vf),
        KUNIT_CASE(fair_ggtt_1vf),
+       KUNIT_CASE_PARAM(fair_vram_1vf, vram_size_gen_params),
+       KUNIT_CASE_PARAM(fair_vram_1vf_admin_only, vram_size_gen_params),
        KUNIT_CASE_PARAM(fair_contexts, num_vfs_gen_param),
        KUNIT_CASE_PARAM(fair_doorbells, num_vfs_gen_param),
        KUNIT_CASE_PARAM(fair_ggtt, num_vfs_gen_param),
+       KUNIT_CASE_PARAM(fair_vram, num_vfs_gen_param),
        {}
 };