// SPDX-License-Identifier: GPL-2.0+
/*
 * Test cases for API provided by resource.c and ioport.h
 */

#include <kunit/test.h>
#include <linux/ioport.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/sizes.h>
#include <linux/mm.h>

#define R0_START        0x0000
#define R0_END          0xffff
#define R1_START        0x1234
#define R1_END          0x2345
#define R2_START        0x4567
#define R2_END          0x5678
#define R3_START        0x6789
#define R3_END          0x789a
#define R4_START        0x2000
#define R4_END          0x7000

static struct resource r0 = { .start = R0_START, .end = R0_END };
static struct resource r1 = { .start = R1_START, .end = R1_END };
static struct resource r2 = { .start = R2_START, .end = R2_END };
static struct resource r3 = { .start = R3_START, .end = R3_END };
static struct resource r4 = { .start = R4_START, .end = R4_END };

struct result {
        struct resource *r1;
        struct resource *r2;
        struct resource r;
        bool ret;
};

static struct result results_for_union[] = {
        {
                .r1 = &r1, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
        }, {
                .r1 = &r2, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
        }, {
                .r1 = &r3, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
        }, {
                .r1 = &r4, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
        }, {
                .r1 = &r2, .r2 = &r1, .ret = false,
        }, {
                .r1 = &r3, .r2 = &r1, .ret = false,
        }, {
                .r1 = &r4, .r2 = &r1, .r.start = R1_START, .r.end = R4_END, .ret = true,
        }, {
                .r1 = &r2, .r2 = &r3, .ret = false,
        }, {
                .r1 = &r2, .r2 = &r4, .r.start = R4_START, .r.end = R4_END, .ret = true,
        }, {
                .r1 = &r3, .r2 = &r4, .r.start = R4_START, .r.end = R3_END, .ret = true,
        },
};

static struct result results_for_intersection[] = {
        {
                .r1 = &r1, .r2 = &r0, .r.start = R1_START, .r.end = R1_END, .ret = true,
        }, {
                .r1 = &r2, .r2 = &r0, .r.start = R2_START, .r.end = R2_END, .ret = true,
        }, {
                .r1 = &r3, .r2 = &r0, .r.start = R3_START, .r.end = R3_END, .ret = true,
        }, {
                .r1 = &r4, .r2 = &r0, .r.start = R4_START, .r.end = R4_END, .ret = true,
        }, {
                .r1 = &r2, .r2 = &r1, .ret = false,
        }, {
                .r1 = &r3, .r2 = &r1, .ret = false,
        }, {
                .r1 = &r4, .r2 = &r1, .r.start = R4_START, .r.end = R1_END, .ret = true,
        }, {
                .r1 = &r2, .r2 = &r3, .ret = false,
        }, {
                .r1 = &r2, .r2 = &r4, .r.start = R2_START, .r.end = R2_END, .ret = true,
        }, {
                .r1 = &r3, .r2 = &r4, .r.start = R3_START, .r.end = R4_END, .ret = true,
        },
};

static void resource_do_test(struct kunit *test, bool ret, struct resource *r,
                             bool exp_ret, struct resource *exp_r,
                             struct resource *r1, struct resource *r2)
{
        KUNIT_EXPECT_EQ_MSG(test, ret, exp_ret, "Resources %pR %pR", r1, r2);
        KUNIT_EXPECT_EQ_MSG(test, r->start, exp_r->start, "Start elements are not equal");
        KUNIT_EXPECT_EQ_MSG(test, r->end, exp_r->end, "End elements are not equal");
}

static void resource_do_union_test(struct kunit *test, struct result *r)
{
        struct resource result;
        bool ret;

        memset(&result, 0, sizeof(result));
        ret = resource_union(r->r1, r->r2, &result);
        resource_do_test(test, ret, &result, r->ret, &r->r, r->r1, r->r2);

        memset(&result, 0, sizeof(result));
        ret = resource_union(r->r2, r->r1, &result);
        resource_do_test(test, ret, &result, r->ret, &r->r, r->r2, r->r1);
}

static void resource_test_union(struct kunit *test)
{
        struct result *r = results_for_union;
        unsigned int i = 0;

        do {
                resource_do_union_test(test, &r[i]);
        } while (++i < ARRAY_SIZE(results_for_union));
}

static void resource_do_intersection_test(struct kunit *test, struct result *r)
{
        struct resource result;
        bool ret;

        memset(&result, 0, sizeof(result));
        ret = resource_intersection(r->r1, r->r2, &result);
        resource_do_test(test, ret, &result, r->ret, &r->r, r->r1, r->r2);

        memset(&result, 0, sizeof(result));
        ret = resource_intersection(r->r2, r->r1, &result);
        resource_do_test(test, ret, &result, r->ret, &r->r, r->r2, r->r1);
}

static void resource_test_intersection(struct kunit *test)
{
        struct result *r = results_for_intersection;
        unsigned int i = 0;

        do {
                resource_do_intersection_test(test, &r[i]);
        } while (++i < ARRAY_SIZE(results_for_intersection));
}

/*
 * The test resource tree for region_intersects() test:
 *
 * BASE-BASE+1M-1 : Test System RAM 0
 *                # hole 0 (BASE+1M-BASE+2M)
 * BASE+2M-BASE+3M-1 : Test CXL Window 0
 * BASE+3M-BASE+4M-1 : Test System RAM 1
 * BASE+4M-BASE+7M-1 : Test CXL Window 1
 *   BASE+4M-BASE+5M-1 : Test System RAM 2
 *     BASE+4M+128K-BASE+4M+256K-1: Test Code
 *   BASE+5M-BASE+6M-1 : Test System RAM 3
 */
#define RES_TEST_RAM0_OFFSET    0
#define RES_TEST_RAM0_SIZE      SZ_1M
#define RES_TEST_HOLE0_OFFSET   (RES_TEST_RAM0_OFFSET + RES_TEST_RAM0_SIZE)
#define RES_TEST_HOLE0_SIZE     SZ_1M
#define RES_TEST_WIN0_OFFSET    (RES_TEST_HOLE0_OFFSET + RES_TEST_HOLE0_SIZE)
#define RES_TEST_WIN0_SIZE      SZ_1M
#define RES_TEST_RAM1_OFFSET    (RES_TEST_WIN0_OFFSET + RES_TEST_WIN0_SIZE)
#define RES_TEST_RAM1_SIZE      SZ_1M
#define RES_TEST_WIN1_OFFSET    (RES_TEST_RAM1_OFFSET + RES_TEST_RAM1_SIZE)
#define RES_TEST_WIN1_SIZE      (SZ_1M * 3)
#define RES_TEST_RAM2_OFFSET    RES_TEST_WIN1_OFFSET
#define RES_TEST_RAM2_SIZE      SZ_1M
#define RES_TEST_CODE_OFFSET    (RES_TEST_RAM2_OFFSET + SZ_128K)
#define RES_TEST_CODE_SIZE      SZ_128K
#define RES_TEST_RAM3_OFFSET    (RES_TEST_RAM2_OFFSET + RES_TEST_RAM2_SIZE)
#define RES_TEST_RAM3_SIZE      SZ_1M
#define RES_TEST_TOTAL_SIZE     ((RES_TEST_WIN1_OFFSET + RES_TEST_WIN1_SIZE))

KUNIT_DEFINE_ACTION_WRAPPER(kfree_wrapper, kfree, const void *);

static void remove_free_resource(void *ctx)
{
        struct resource *res = (struct resource *)ctx;

        remove_resource(res);
        kfree(res);
}

static void resource_test_add_action_or_abort(
        struct kunit *test, void (*action)(void *), void *ctx)
{
        KUNIT_ASSERT_EQ_MSG(test, 0,
                            kunit_add_action_or_reset(test, action, ctx),
                            "Fail to add action");
}

static void resource_test_request_region(struct kunit *test, struct resource *parent,
                                         resource_size_t start, resource_size_t size,
                                         const char *name, unsigned long flags)
{
        struct resource *res;

        res = __request_region(parent, start, size, name, flags);
        KUNIT_ASSERT_NOT_NULL(test, res);
        resource_test_add_action_or_abort(test, remove_free_resource, res);
}

static void resource_test_insert_resource(struct kunit *test, struct resource *parent,
                                          resource_size_t start, resource_size_t size,
                                          const char *name, unsigned long flags)
{
        struct resource *res;

        res = kzalloc_obj(*res);
        KUNIT_ASSERT_NOT_NULL(test, res);

        res->name = name;
        res->start = start;
        res->end = start + size - 1;
        res->flags = flags;
        if (insert_resource(parent, res)) {
                resource_test_add_action_or_abort(test, kfree_wrapper, res);
                KUNIT_FAIL_AND_ABORT(test, "Fail to insert resource %pR\n", res);
        }

        resource_test_add_action_or_abort(test, remove_free_resource, res);
}

static void resource_test_region_intersects(struct kunit *test)
{
        unsigned long flags =  IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
        struct resource *parent;
        resource_size_t start;

        /* Find an iomem_resource hole to hold test resources */
        parent = alloc_free_mem_region(&iomem_resource, RES_TEST_TOTAL_SIZE, SZ_1M,
                                       "test resources");
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
        start = parent->start;
        resource_test_add_action_or_abort(test, remove_free_resource, parent);

        resource_test_request_region(test, parent, start + RES_TEST_RAM0_OFFSET,
                                     RES_TEST_RAM0_SIZE, "Test System RAM 0", flags);
        resource_test_insert_resource(test, parent, start + RES_TEST_WIN0_OFFSET,
                                      RES_TEST_WIN0_SIZE, "Test CXL Window 0",
                                      IORESOURCE_MEM);
        resource_test_request_region(test, parent, start + RES_TEST_RAM1_OFFSET,
                                     RES_TEST_RAM1_SIZE, "Test System RAM 1", flags);
        resource_test_insert_resource(test, parent, start + RES_TEST_WIN1_OFFSET,
                                      RES_TEST_WIN1_SIZE, "Test CXL Window 1",
                                      IORESOURCE_MEM);
        resource_test_request_region(test, parent, start + RES_TEST_RAM2_OFFSET,
                                     RES_TEST_RAM2_SIZE, "Test System RAM 2", flags);
        resource_test_insert_resource(test, parent, start + RES_TEST_CODE_OFFSET,
                                      RES_TEST_CODE_SIZE, "Test Code", flags);
        resource_test_request_region(test, parent, start + RES_TEST_RAM3_OFFSET,
                                     RES_TEST_RAM3_SIZE, "Test System RAM 3", flags);
        kunit_release_action(test, remove_free_resource, parent);

        KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
                        region_intersects(start + RES_TEST_RAM0_OFFSET, PAGE_SIZE,
                                          IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
        KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
                        region_intersects(start + RES_TEST_RAM0_OFFSET +
                                          RES_TEST_RAM0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
                                          IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
        KUNIT_EXPECT_EQ(test, REGION_DISJOINT,
                        region_intersects(start + RES_TEST_HOLE0_OFFSET, PAGE_SIZE,
                                          IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
        KUNIT_EXPECT_EQ(test, REGION_DISJOINT,
                        region_intersects(start + RES_TEST_HOLE0_OFFSET +
                                          RES_TEST_HOLE0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
                                          IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
        KUNIT_EXPECT_EQ(test, REGION_MIXED,
                        region_intersects(start + RES_TEST_WIN0_OFFSET +
                                          RES_TEST_WIN0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
                                          IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
        KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
                        region_intersects(start + RES_TEST_RAM1_OFFSET +
                                          RES_TEST_RAM1_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
                                          IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
        KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
                        region_intersects(start + RES_TEST_RAM2_OFFSET +
                                          RES_TEST_RAM2_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
                                          IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
        KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
                        region_intersects(start + RES_TEST_CODE_OFFSET, PAGE_SIZE,
                                          IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
        KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
                        region_intersects(start + RES_TEST_RAM2_OFFSET,
                                          RES_TEST_RAM2_SIZE + PAGE_SIZE,
                                          IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
        KUNIT_EXPECT_EQ(test, REGION_MIXED,
                        region_intersects(start + RES_TEST_RAM3_OFFSET,
                                          RES_TEST_RAM3_SIZE + PAGE_SIZE,
                                          IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
}

static struct kunit_case resource_test_cases[] = {
        KUNIT_CASE(resource_test_union),
        KUNIT_CASE(resource_test_intersection),
        KUNIT_CASE(resource_test_region_intersects),
        {}
};

static struct kunit_suite resource_test_suite = {
        .name = "resource",
        .test_cases = resource_test_cases,
};
kunit_test_suite(resource_test_suite);

MODULE_DESCRIPTION("I/O Port & Memory Resource manager unit tests");
MODULE_LICENSE("GPL");