// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright © 2023 Intel Corporation
 */

#include <linux/string.h>
#include <linux/xarray.h>

#include <drm/drm_drv.h>
#include <drm/drm_kunit_helpers.h>

#include <kunit/static_stub.h>
#include <kunit/test.h>

#include "regs/xe_gt_regs.h"
#include "regs/xe_reg_defs.h"
#include "xe_device.h"
#include "xe_device_types.h"
#include "xe_gt_mcr.h"
#include "xe_kunit_helpers.h"
#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)
#define REGULAR_REG3            XE_REG(3)
#define REGULAR_REG4            XE_REG(4)
#define BAD_REGULAR_REG5        XE_REG(5)
#define MCR_REG1                XE_REG_MCR(1)
#define MCR_REG2                XE_REG_MCR(2)
#define MCR_REG3                XE_REG_MCR(3)
#define BAD_MCR_REG4            XE_REG_MCR(4)
#define MCR_REG5                XE_REG_MCR(5)
#define MASKED_REG1             XE_REG(1, XE_REG_OPTION_MASKED)

#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;
        u32 expected_set_bits;
        u32 expected_clr_bits;
        unsigned long expected_count_sr_entries;
        unsigned int expected_sr_errors;
        unsigned long expected_active;
        const struct xe_rtp_table_sr table;
};

struct rtp_test_case {
        const char *name;
        unsigned long expected_active;
        const struct xe_rtp_table table;
};

static bool fake_xe_gt_mcr_check_reg(struct xe_gt *gt, struct xe_reg reg)
{
        /*
         * All supported platforms in this imaginary setup will always have REG4
         * as a non-MCR register and REG5 as MCR, meaning that BAD_MCR_REG4 and
         * BAD_REGULAR_REG5 represent programming errors to be captured by our
         * tests.
         */
        if (reg.raw == BAD_REGULAR_REG5.raw)
                return true;

        if (reg.raw == BAD_MCR_REG4.raw)
                return false;

        return reg.mcr;
}

static bool match_yes(const struct xe_device *xe, const struct xe_gt *gt,
                      const struct xe_hw_engine *hwe)
{
        return true;
}

static bool match_no(const struct xe_device *xe, const struct xe_gt *gt,
                     const struct xe_hw_engine *hwe)
{
        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-yes",
                .expected_match = true,
                .expected_err = -EINVAL,
                XE_RTP_RULES(OR, FUNC(match_yes)),
        },
        {
                .name = "or-no",
                .expected_match = false,
                .expected_err = -EINVAL,
                XE_RTP_RULES(OR, FUNC(match_no)),
        },
        {
                .name = "yes-or",
                .expected_match = true,
                .expected_err = -EINVAL,
                XE_RTP_RULES(FUNC(match_yes), OR),
        },
        {
                .name = "no-or",
                .expected_match = false,
                .expected_err = -EINVAL,
                XE_RTP_RULES(FUNC(match_no), OR),
        },
        {
                .name = "no-or-or-yes",
                .expected_match = true,
                .expected_err = -EINVAL,
                XE_RTP_RULES(FUNC(match_no), OR, OR, FUNC(match_yes)),
        },
        {
                .name = "yes-or-or-no",
                .expected_match = true,
                .expected_err = -EINVAL,
                XE_RTP_RULES(FUNC(match_yes), OR, OR, FUNC(match_no)),
        },
        {
                .name = "no-or-or-no",
                .expected_match = false,
                .expected_err = -EINVAL,
                XE_RTP_RULES(FUNC(match_no), OR, OR, FUNC(match_no)),
        },

        /* No match because hwe is NULL. */
        {
                .name = "missing-context-engine-class",
                .expected_match = false,
                XE_RTP_RULES(ENGINE_CLASS(RENDER)),
        },

        /*
         * Missing context (hwe==NULL) does not cause parsing to stop, hence we
         * expect a match.
         */
        {
                .name = "missing-context-engine-class-or-yes",
                .expected_match = true,
                XE_RTP_RULES(ENGINE_CLASS(RENDER), OR, FUNC(match_yes)),
        },

        /*
         * Missing context (hwe==NULL) does not cause parsing to stop, hence we
         * expect a syntax error.
         */
        {
                .name = "missing-context-engine-class-or-or-yes",
                .expected_match = true,
                .expected_err = -EINVAL,
                XE_RTP_RULES(ENGINE_CLASS(RENDER), OR, 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",
                .expected_reg = REGULAR_REG1,
                .expected_set_bits = REG_BIT(0) | REG_BIT(1),
                .expected_clr_bits = REG_BIT(0) | REG_BIT(1),
                .expected_active = BIT(0) | BIT(1),
                .expected_count_sr_entries = 1,
                /* Different bits on the same register: create a single entry */
                .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)))
                        },
                        { XE_RTP_NAME("basic-2"),
                          XE_RTP_RULES(FUNC(match_yes)),
                          XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(1)))
                        },
                ),
        },
        {
                .name = "no-match-no-add",
                .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 since rules don't match */
                .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)))
                        },
                        { XE_RTP_NAME("basic-2"),
                          XE_RTP_RULES(FUNC(match_no)),
                          XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(1)))
                        },
                ),
        },
        {
                .name = "two-regs-two-entries",
                .expected_reg = REGULAR_REG1,
                .expected_set_bits = REG_BIT(0),
                .expected_clr_bits = REG_BIT(0),
                .expected_active = BIT(0) | BIT(1),
                .expected_count_sr_entries = 2,
                /* Same bits on different registers are not coalesced */
                .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)))
                        },
                        { XE_RTP_NAME("basic-2"),
                          XE_RTP_RULES(FUNC(match_yes)),
                          XE_RTP_ACTIONS(SET(REGULAR_REG2, REG_BIT(0)))
                        },
                ),
        },
        {
                .name = "clr-one-set-other",
                .expected_reg = REGULAR_REG1,
                .expected_set_bits = REG_BIT(0),
                .expected_clr_bits = REG_BIT(1) | REG_BIT(0),
                .expected_active = BIT(0) | BIT(1),
                .expected_count_sr_entries = 1,
                /* Check clr vs set actions on different bits */
                .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)))
                        },
                        { XE_RTP_NAME("basic-2"),
                          XE_RTP_RULES(FUNC(match_yes)),
                          XE_RTP_ACTIONS(CLR(REGULAR_REG1, REG_BIT(1)))
                        },
                ),
        },
        {
#define TEMP_MASK       REG_GENMASK(10, 8)
#define TEMP_FIELD      REG_FIELD_PREP(TEMP_MASK, 2)
                .name = "set-field",
                .expected_reg = REGULAR_REG1,
                .expected_set_bits = TEMP_FIELD,
                .expected_clr_bits = TEMP_MASK,
                .expected_active = BIT(0),
                .expected_count_sr_entries = 1,
                /* Check FIELD_SET works */
                .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
        },
        {
                .name = "conflict-duplicate",
                .expected_reg = REGULAR_REG1,
                .expected_set_bits = REG_BIT(0),
                .expected_clr_bits = REG_BIT(0),
                .expected_active = BIT(0) | BIT(1),
                .expected_count_sr_entries = 1,
                .expected_sr_errors = 1,
                .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)))
                        },
                        /* drop: setting same values twice */
                        { XE_RTP_NAME("basic-2"),
                          XE_RTP_RULES(FUNC(match_yes)),
                          XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
                        },
                ),
        },
        {
                .name = "conflict-not-disjoint",
                .expected_reg = REGULAR_REG1,
                .expected_set_bits = REG_BIT(0),
                .expected_clr_bits = REG_BIT(0),
                .expected_active = BIT(0) | BIT(1),
                .expected_count_sr_entries = 1,
                .expected_sr_errors = 1,
                .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)))
                        },
                        /* drop: bits are not disjoint with previous entries */
                        { XE_RTP_NAME("basic-2"),
                          XE_RTP_RULES(FUNC(match_yes)),
                          XE_RTP_ACTIONS(CLR(REGULAR_REG1, REG_GENMASK(1, 0)))
                        },
                ),
        },
        {
                .name = "conflict-reg-type",
                .expected_reg = REGULAR_REG1,
                .expected_set_bits = REG_BIT(0),
                .expected_clr_bits = REG_BIT(0),
                .expected_active = BIT(0) | BIT(1) | BIT(2),
                .expected_count_sr_entries = 1,
                .expected_sr_errors = 2,
                .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)))
                        },
                        /* drop: regular vs MCR */
                        { XE_RTP_NAME("basic-2"),
                          XE_RTP_RULES(FUNC(match_yes)),
                          XE_RTP_ACTIONS(SET(MCR_REG1, REG_BIT(1)))
                        },
                        /* drop: regular vs masked */
                        { XE_RTP_NAME("basic-3"),
                          XE_RTP_RULES(FUNC(match_yes)),
                          XE_RTP_ACTIONS(SET(MASKED_REG1, REG_BIT(0)))
                        },
                ),
        },
        {
                .name = "bad-mcr-reg-forced-to-regular",
                .expected_reg = REGULAR_REG4,
                .expected_set_bits = REG_BIT(0),
                .expected_clr_bits = REG_BIT(0),
                .expected_active = BIT(0),
                .expected_count_sr_entries = 1,
                .expected_sr_errors = 1,
                .table = XE_RTP_TABLE_SR(
                        { XE_RTP_NAME("bad-mcr-regular-reg"),
                          XE_RTP_RULES(FUNC(match_yes)),
                          XE_RTP_ACTIONS(SET(BAD_MCR_REG4, REG_BIT(0)))
                        },
                ),
        },
        {
                .name = "bad-regular-reg-forced-to-mcr",
                .expected_reg = MCR_REG5,
                .expected_set_bits = REG_BIT(0),
                .expected_clr_bits = REG_BIT(0),
                .expected_active = BIT(0),
                .expected_count_sr_entries = 1,
                .expected_sr_errors = 1,
                .table = XE_RTP_TABLE_SR(
                        { XE_RTP_NAME("bad-regular-reg"),
                          XE_RTP_RULES(FUNC(match_yes)),
                          XE_RTP_ACTIONS(SET(BAD_REGULAR_REG5, REG_BIT(0)))
                        },
                ),
        },
};

static void xe_rtp_process_to_sr_tests(struct kunit *test)
{
        const struct rtp_to_sr_test_case *param = test->param_value;
        struct xe_device *xe = test->priv;
        struct xe_gt *gt = xe_device_get_root_tile(xe)->primary_gt;
        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, active = 0;

        xe_reg_sr_init(reg_sr, "xe_rtp_to_sr_tests", xe);

        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)
                        sr_entry = sre;

                count_sr_entries++;
        }

        KUNIT_EXPECT_EQ(test, active, param->expected_active);

        KUNIT_EXPECT_EQ(test, count_sr_entries, param->expected_count_sr_entries);
        if (count_sr_entries) {
                KUNIT_EXPECT_EQ(test, sr_entry->clr_bits, param->expected_clr_bits);
                KUNIT_EXPECT_EQ(test, sr_entry->set_bits, param->expected_set_bits);
                KUNIT_EXPECT_EQ(test, sr_entry->reg.raw, param->expected_reg.raw);
        } else {
                KUNIT_EXPECT_NULL(test, sr_entry);
        }

        KUNIT_EXPECT_EQ(test, reg_sr->errors, param->expected_sr_errors);
}

/*
 * Entries below follow the logic used with xe_wa_oob.rules:
 * 1) Entries with empty name are OR'ed: all entries marked active since the
 *    last entry with a name
 * 2) There are no action associated with rules
 */
static const struct rtp_test_case rtp_cases[] = {
        {
                .name = "active1",
                .expected_active = BIT(0),
                .table = XE_RTP_TABLE(
                        { XE_RTP_NAME("r1"),
                          XE_RTP_RULES(FUNC(match_yes)),
                        },
                ),
        },
        {
                .name = "active2",
                .expected_active = BIT(0) | BIT(1),
                .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),
                .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),
                .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-active-inactive",
                .expected_active = BIT(1),
                .table = XE_RTP_TABLE(
                        { XE_RTP_NAME("r1"),
                          XE_RTP_RULES(FUNC(match_no)),
                        },
                        { XE_RTP_NAME("r2"),
                          XE_RTP_RULES(FUNC(match_yes)),
                        },
                        { XE_RTP_NAME("r3"),
                          XE_RTP_RULES(FUNC(match_no)),
                        },
                ),
        },
        {
                .name = "inactive-inactive-inactive",
                .expected_active = 0,
                .table = XE_RTP_TABLE(
                        { XE_RTP_NAME("r1"),
                          XE_RTP_RULES(FUNC(match_no)),
                        },
                        { XE_RTP_NAME("r2"),
                          XE_RTP_RULES(FUNC(match_no)),
                        },
                        { XE_RTP_NAME("r3"),
                          XE_RTP_RULES(FUNC(match_no)),
                        },
                ),
        },
};

static void xe_rtp_process_tests(struct kunit *test)
{
        const struct rtp_test_case *param = test->param_value;
        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 active = 0;

        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);
}

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);
}

KUNIT_ARRAY_PARAM(rtp_to_sr, rtp_to_sr_cases, rtp_to_sr_desc);

static void rtp_desc(const struct rtp_test_case *t, char *desc)
{
        strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
}

KUNIT_ARRAY_PARAM(rtp, rtp_cases, rtp_desc);

static int xe_rtp_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;

        kunit_activate_static_stub(test, xe_gt_mcr_check_reg, fake_xe_gt_mcr_check_reg);

        return 0;
}

static void xe_rtp_test_exit(struct kunit *test)
{
        struct xe_device *xe = test->priv;

        drm_kunit_helper_free_device(test, xe->drm.dev);
}

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),
        {}
};

static struct kunit_suite xe_rtp_test_suite = {
        .name = "xe_rtp",
        .init = xe_rtp_test_init,
        .exit = xe_rtp_test_exit,
        .test_cases = xe_rtp_tests,
};

kunit_test_suite(xe_rtp_test_suite);