// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2025, Qualcomm Innovation Center, Inc. All rights reserved.
 */

#define pr_fmt(fmt) "tlmm-test: " fmt

#include <kunit/test.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/slab.h>

/*
 * This TLMM test module serves the purpose of validating that the TLMM driver
 * (pinctrl-msm) delivers expected number of interrupts in response to changing
 * GPIO state.
 *
 * To achieve this without external equipment the test takes a module parameter
 * "gpio", which the tester is expected to specify an unused and non-connected
 * pin. The GPIO state is then driven by adjusting the bias of the pin, at
 * suitable times through the different test cases.
 *
 * Upon execution, the test initialization will find the TLMM node (subject to
 * tlmm_of_match[] allow listing) and create the necessary references
 * dynamically, rather then relying on e.g. Devicetree and phandles.
 */

#define MSM_PULL_MASK           GENMASK(2, 0)
#define MSM_PULL_DOWN           1
#define MSM_PULL_UP             3
#define TLMM_REG_SIZE           0x1000

static int tlmm_test_gpio = -1;
static char *tlmm_reg_name = "default_region";

module_param_named(gpio, tlmm_test_gpio, int, 0600);
module_param_named(name, tlmm_reg_name, charp, 0600);

static struct {
        void __iomem *base;
        void __iomem *reg;
        int irq;

        u32 low_val;
        u32 high_val;
} tlmm_suite;

/**
 * struct tlmm_test_priv - Per-test context
 * @intr_count:         number of times hard handler was hit with TLMM_TEST_COUNT op set
 * @thread_count:       number of times thread handler was hit with TLMM_TEST_COUNT op set
 * @intr_op:            operations to be performed by the hard IRQ handler
 * @intr_op_remain:     number of times the TLMM_TEST_THEN_* operations should be
 *                      performed by the hard IRQ handler
 * @thread_op:          operations to be performed by the threaded IRQ handler
 * @thread_op_remain:   number of times the TLMM_TEST_THEN_* operations should
 *                      be performed by the threaded IRQ handler
 */
struct tlmm_test_priv {
        atomic_t intr_count;
        atomic_t thread_count;

        unsigned int intr_op;
        atomic_t intr_op_remain;

        unsigned int thread_op;
        atomic_t thread_op_remain;
};

/* Operation masks for @intr_op and @thread_op */
#define TLMM_TEST_COUNT         BIT(0)
#define TLMM_TEST_OUTPUT_LOW    BIT(1)
#define TLMM_TEST_OUTPUT_HIGH   BIT(2)
#define TLMM_TEST_THEN_HIGH     BIT(3)
#define TLMM_TEST_THEN_LOW      BIT(4)
#define TLMM_TEST_WAKE_THREAD   BIT(5)

static void tlmm_output_low(void)
{
        writel(tlmm_suite.low_val, tlmm_suite.reg);
        readl(tlmm_suite.reg);
}

static void tlmm_output_high(void)
{
        writel(tlmm_suite.high_val, tlmm_suite.reg);
        readl(tlmm_suite.reg);
}

static irqreturn_t tlmm_test_intr_fn(int irq, void *dev_id)
{
        struct tlmm_test_priv *priv = dev_id;

        if (priv->intr_op & TLMM_TEST_COUNT)
                atomic_inc(&priv->intr_count);

        if (priv->intr_op & TLMM_TEST_OUTPUT_LOW)
                tlmm_output_low();
        if (priv->intr_op & TLMM_TEST_OUTPUT_HIGH)
                tlmm_output_high();

        if (atomic_dec_if_positive(&priv->intr_op_remain) > 0) {
                udelay(1);

                if (priv->intr_op & TLMM_TEST_THEN_LOW)
                        tlmm_output_low();
                if (priv->intr_op & TLMM_TEST_THEN_HIGH)
                        tlmm_output_high();
        }

        return priv->intr_op & TLMM_TEST_WAKE_THREAD ? IRQ_WAKE_THREAD : IRQ_HANDLED;
}

static irqreturn_t tlmm_test_intr_thread_fn(int irq, void *dev_id)
{
        struct tlmm_test_priv *priv = dev_id;

        if (priv->thread_op & TLMM_TEST_COUNT)
                atomic_inc(&priv->thread_count);

        if (priv->thread_op & TLMM_TEST_OUTPUT_LOW)
                tlmm_output_low();
        if (priv->thread_op & TLMM_TEST_OUTPUT_HIGH)
                tlmm_output_high();

        if (atomic_dec_if_positive(&priv->thread_op_remain) > 0) {
                udelay(1);
                if (priv->thread_op & TLMM_TEST_THEN_LOW)
                        tlmm_output_low();
                if (priv->thread_op & TLMM_TEST_THEN_HIGH)
                        tlmm_output_high();
        }

        return IRQ_HANDLED;
}

static void tlmm_test_request_hard_irq(struct kunit *test, unsigned long irqflags)
{
        struct tlmm_test_priv *priv = test->priv;
        int ret;

        ret = request_irq(tlmm_suite.irq, tlmm_test_intr_fn, irqflags, test->name, priv);
        KUNIT_EXPECT_EQ(test, ret, 0);
}

static void tlmm_test_request_threaded_irq(struct kunit *test, unsigned long irqflags)
{
        struct tlmm_test_priv *priv = test->priv;
        int ret;

        ret = request_threaded_irq(tlmm_suite.irq,
                                   tlmm_test_intr_fn, tlmm_test_intr_thread_fn,
                                   irqflags, test->name, priv);

        KUNIT_EXPECT_EQ(test, ret, 0);
}

static void tlmm_test_silent(struct kunit *test, unsigned long irqflags)
{
        struct tlmm_test_priv *priv = test->priv;

        priv->intr_op = TLMM_TEST_COUNT;

        /* GPIO line at non-triggering level */
        if (irqflags == IRQF_TRIGGER_LOW || irqflags == IRQF_TRIGGER_FALLING)
                tlmm_output_high();
        else
                tlmm_output_low();

        tlmm_test_request_hard_irq(test, irqflags);
        msleep(100);
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 0);
}

/*
 * Test that no RISING interrupts are triggered on a silent pin
 */
static void tlmm_test_silent_rising(struct kunit *test)
{
        tlmm_test_silent(test, IRQF_TRIGGER_RISING);
}

/*
 * Test that no FALLING interrupts are triggered on a silent pin
 */
static void tlmm_test_silent_falling(struct kunit *test)
{
        tlmm_test_silent(test, IRQF_TRIGGER_FALLING);
}

/*
 * Test that no LOW interrupts are triggered on a silent pin
 */
static void tlmm_test_silent_low(struct kunit *test)
{
        tlmm_test_silent(test, IRQF_TRIGGER_LOW);
}

/*
 * Test that no HIGH interrupts are triggered on a silent pin
 */
static void tlmm_test_silent_high(struct kunit *test)
{
        tlmm_test_silent(test, IRQF_TRIGGER_HIGH);
}

/*
 * Square wave with 10 high pulses, assert that we get 10 rising interrupts
 */
static void tlmm_test_rising(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;
        int i;

        priv->intr_op = TLMM_TEST_COUNT;

        tlmm_output_low();

        tlmm_test_request_hard_irq(test, IRQF_TRIGGER_RISING);
        for (i = 0; i < 10; i++) {
                tlmm_output_low();
                msleep(20);
                tlmm_output_high();
                msleep(20);
        }

        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
}

/*
 * Square wave with 10 low pulses, assert that we get 10 falling interrupts
 */
static void tlmm_test_falling(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;
        int i;

        priv->intr_op = TLMM_TEST_COUNT;

        tlmm_output_high();

        tlmm_test_request_hard_irq(test, IRQF_TRIGGER_FALLING);
        for (i = 0; i < 10; i++) {
                tlmm_output_high();
                msleep(20);
                tlmm_output_low();
                msleep(20);
        }
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
}

/*
 * Drive line low 10 times, handler drives it high to "clear the interrupt
 * source", assert we get 10 interrupts
 */
static void tlmm_test_low(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;
        int i;

        priv->intr_op = TLMM_TEST_COUNT | TLMM_TEST_OUTPUT_HIGH;
        atomic_set(&priv->intr_op_remain, 9);

        tlmm_output_high();

        tlmm_test_request_hard_irq(test, IRQF_TRIGGER_LOW);
        for (i = 0; i < 10; i++) {
                msleep(20);
                tlmm_output_low();
        }
        msleep(100);
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
}

/*
 * Drive line high 10 times, handler drives it low to "clear the interrupt
 * source", assert we get 10 interrupts
 */
static void tlmm_test_high(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;
        int i;

        priv->intr_op = TLMM_TEST_COUNT | TLMM_TEST_OUTPUT_LOW;
        atomic_set(&priv->intr_op_remain, 9);

        tlmm_output_low();

        tlmm_test_request_hard_irq(test, IRQF_TRIGGER_HIGH);
        for (i = 0; i < 10; i++) {
                msleep(20);
                tlmm_output_high();
        }
        msleep(100);
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
}

/*
 * Handler drives GPIO high to "clear the interrupt source", then low to
 * simulate a new interrupt, repeated 10 times, assert we get 10 interrupts
 */
static void tlmm_test_falling_in_handler(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;

        priv->intr_op = TLMM_TEST_COUNT | TLMM_TEST_OUTPUT_HIGH | TLMM_TEST_THEN_LOW;
        atomic_set(&priv->intr_op_remain, 10);

        tlmm_output_high();

        tlmm_test_request_hard_irq(test, IRQF_TRIGGER_FALLING);
        msleep(20);
        tlmm_output_low();
        msleep(100);
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
}

/*
 * Handler drives GPIO low to "clear the interrupt source", then high to
 * simulate a new interrupt, repeated 10 times, assert we get 10 interrupts
 */
static void tlmm_test_rising_in_handler(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;

        priv->intr_op = TLMM_TEST_COUNT | TLMM_TEST_OUTPUT_LOW | TLMM_TEST_THEN_HIGH;
        atomic_set(&priv->intr_op_remain, 10);

        tlmm_output_low();

        tlmm_test_request_hard_irq(test, IRQF_TRIGGER_RISING);
        msleep(20);
        tlmm_output_high();
        msleep(100);
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
}

/*
 * Square wave with 10 high pulses, assert that we get 10 rising hard and
 * 10 threaded interrupts
 */
static void tlmm_test_thread_rising(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;
        int i;

        priv->intr_op = TLMM_TEST_COUNT | TLMM_TEST_WAKE_THREAD;
        priv->thread_op = TLMM_TEST_COUNT;

        tlmm_output_low();

        tlmm_test_request_threaded_irq(test, IRQF_TRIGGER_RISING);
        for (i = 0; i < 10; i++) {
                tlmm_output_low();
                msleep(20);
                tlmm_output_high();
                msleep(20);
        }
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
        KUNIT_ASSERT_EQ(test, atomic_read(&priv->thread_count), 10);
}

/*
 * Square wave with 10 low pulses, assert that we get 10 falling interrupts
 */
static void tlmm_test_thread_falling(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;
        int i;

        priv->intr_op = TLMM_TEST_COUNT | TLMM_TEST_WAKE_THREAD;
        priv->thread_op = TLMM_TEST_COUNT;

        tlmm_output_high();

        tlmm_test_request_threaded_irq(test, IRQF_TRIGGER_FALLING);
        for (i = 0; i < 10; i++) {
                tlmm_output_high();
                msleep(20);
                tlmm_output_low();
                msleep(20);
        }
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
        KUNIT_ASSERT_EQ(test, atomic_read(&priv->thread_count), 10);
}

/*
 * Drive line high 10 times, threaded handler drives it low to "clear the
 * interrupt source", assert we get 10 interrupts
 */
static void tlmm_test_thread_high(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;
        int i;

        priv->intr_op = TLMM_TEST_COUNT | TLMM_TEST_WAKE_THREAD;
        priv->thread_op = TLMM_TEST_COUNT | TLMM_TEST_OUTPUT_LOW;

        tlmm_output_low();

        tlmm_test_request_threaded_irq(test, IRQF_TRIGGER_HIGH | IRQF_ONESHOT);
        for (i = 0; i < 10; i++) {
                tlmm_output_high();
                msleep(20);
        }
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
        KUNIT_ASSERT_EQ(test, atomic_read(&priv->thread_count), 10);
}

/*
 * Drive line low 10 times, threaded handler drives it high to "clear the
 * interrupt source", assert we get 10 interrupts
 */
static void tlmm_test_thread_low(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;
        int i;

        priv->intr_op = TLMM_TEST_COUNT | TLMM_TEST_WAKE_THREAD;
        priv->thread_op = TLMM_TEST_COUNT | TLMM_TEST_OUTPUT_HIGH;

        tlmm_output_high();

        tlmm_test_request_threaded_irq(test, IRQF_TRIGGER_LOW | IRQF_ONESHOT);
        for (i = 0; i < 10; i++) {
                tlmm_output_low();
                msleep(20);
        }
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
        KUNIT_ASSERT_EQ(test, atomic_read(&priv->thread_count), 10);
}

/*
 * Handler drives GPIO low to "clear the interrupt source", then high in the
 * threaded handler to simulate a new interrupt, repeated 10 times, assert we
 * get 10 interrupts
 */
static void tlmm_test_thread_rising_in_handler(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;

        priv->intr_op = TLMM_TEST_COUNT | TLMM_TEST_OUTPUT_LOW | TLMM_TEST_WAKE_THREAD;
        priv->thread_op = TLMM_TEST_COUNT | TLMM_TEST_THEN_HIGH;
        atomic_set(&priv->thread_op_remain, 10);

        tlmm_output_low();

        tlmm_test_request_threaded_irq(test, IRQF_TRIGGER_RISING);
        msleep(20);
        tlmm_output_high();
        msleep(100);
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
        KUNIT_ASSERT_EQ(test, atomic_read(&priv->thread_count), 10);
}

/*
 * Handler drives GPIO high to "clear the interrupt source", then low in the
 * threaded handler to simulate a new interrupt, repeated 10 times, assert we
 * get 10 interrupts
 */
static void tlmm_test_thread_falling_in_handler(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;

        priv->intr_op = TLMM_TEST_COUNT | TLMM_TEST_OUTPUT_HIGH | TLMM_TEST_WAKE_THREAD;
        priv->thread_op = TLMM_TEST_COUNT | TLMM_TEST_THEN_LOW;
        atomic_set(&priv->thread_op_remain, 10);

        tlmm_output_high();

        tlmm_test_request_threaded_irq(test, IRQF_TRIGGER_FALLING);
        msleep(20);
        tlmm_output_low();
        msleep(100);
        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 10);
        KUNIT_ASSERT_EQ(test, atomic_read(&priv->thread_count), 10);
}

/*
 * Validate that edge interrupts occurring while irq is disabled is delivered
 * once the interrupt is reenabled.
 */
static void tlmm_test_rising_while_disabled(struct kunit *test)
{
        struct tlmm_test_priv *priv = test->priv;
        unsigned int after_edge;
        unsigned int before_edge;

        priv->intr_op = TLMM_TEST_COUNT;
        atomic_set(&priv->thread_op_remain, 10);

        tlmm_output_low();

        tlmm_test_request_hard_irq(test, IRQF_TRIGGER_RISING);
        msleep(20);

        disable_irq(tlmm_suite.irq);
        before_edge = atomic_read(&priv->intr_count);

        tlmm_output_high();
        msleep(20);
        after_edge = atomic_read(&priv->intr_count);

        msleep(20);
        enable_irq(tlmm_suite.irq);
        msleep(20);

        free_irq(tlmm_suite.irq, priv);

        KUNIT_ASSERT_EQ(test, before_edge, 0);
        KUNIT_ASSERT_EQ(test, after_edge, 0);
        KUNIT_ASSERT_EQ(test, atomic_read(&priv->intr_count), 1);
}

static int tlmm_test_init(struct kunit *test)
{
        struct tlmm_test_priv *priv;

        priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);

        atomic_set(&priv->intr_count, 0);
        atomic_set(&priv->thread_count, 0);

        atomic_set(&priv->intr_op_remain, 0);
        atomic_set(&priv->thread_op_remain, 0);

        test->priv = priv;

        return 0;
}

/*
 * NOTE: When adding compatibles to this list, ensure that TLMM_REG_SIZE and
 * pull configuration values are supported and correct.
 */
static const struct of_device_id tlmm_of_match[] = {
        { .compatible = "qcom,sc8280xp-tlmm" },
        { .compatible = "qcom,x1e80100-tlmm" },
        {}
};

static int tlmm_reg_base(struct device_node *tlmm, struct resource *res)
{
        const char **reg_names;
        int count;
        int ret;
        int i;

        count = of_property_count_strings(tlmm, "reg-names");
        if (count <= 0) {
                pr_err("failed to find tlmm reg name\n");
                return count;
        }

        reg_names = kcalloc(count, sizeof(char *), GFP_KERNEL);
        if (!reg_names)
                return -ENOMEM;

        ret = of_property_read_string_array(tlmm, "reg-names", reg_names, count);
        if (ret != count) {
                kfree(reg_names);
                return -EINVAL;
        }

        if (!strcmp(tlmm_reg_name, "default_region")) {
                ret = of_address_to_resource(tlmm, 0, res);
        } else {
                for (i = 0; i < count; i++) {
                        if (!strcmp(reg_names[i], tlmm_reg_name)) {
                                ret = of_address_to_resource(tlmm, i, res);
                                break;
                        }
                }
                if (i == count)
                        ret = -EINVAL;
        }

        kfree(reg_names);

        return ret;
}

static int tlmm_test_init_suite(struct kunit_suite *suite)
{
        struct of_phandle_args args = {};
        struct resource res;
        int ret;
        u32 val;

        if (tlmm_test_gpio < 0) {
                pr_err("use the tlmm-test.gpio module parameter to specify which GPIO to use\n");
                return -EINVAL;
        }

        struct device_node *tlmm __free(device_node) = of_find_matching_node(NULL, tlmm_of_match);
        if (!tlmm) {
                pr_err("failed to find tlmm node\n");
                return -EINVAL;
        }

        ret = tlmm_reg_base(tlmm, &res);
        if (ret < 0)
                return ret;

        tlmm_suite.base = ioremap(res.start, resource_size(&res));
        if (!tlmm_suite.base)
                return -ENOMEM;

        args.np = tlmm;
        args.args_count = 2;
        args.args[0] = tlmm_test_gpio;
        args.args[1] = 0;

        tlmm_suite.irq = irq_create_of_mapping(&args);
        if (!tlmm_suite.irq) {
                pr_err("failed to map TLMM irq %d\n", args.args[0]);
                goto err_unmap;
        }

        tlmm_suite.reg = tlmm_suite.base + tlmm_test_gpio * TLMM_REG_SIZE;
        val = readl(tlmm_suite.reg) & ~MSM_PULL_MASK;
        tlmm_suite.low_val = val | MSM_PULL_DOWN;
        tlmm_suite.high_val = val | MSM_PULL_UP;

        return 0;

err_unmap:
        iounmap(tlmm_suite.base);
        tlmm_suite.base = NULL;
        return -EINVAL;
}

static void tlmm_test_exit_suite(struct kunit_suite *suite)
{
        irq_dispose_mapping(tlmm_suite.irq);
        iounmap(tlmm_suite.base);

        tlmm_suite.base = NULL;
        tlmm_suite.irq = -1;
}

static struct kunit_case tlmm_test_cases[] = {
        KUNIT_CASE(tlmm_test_silent_rising),
        KUNIT_CASE(tlmm_test_silent_falling),
        KUNIT_CASE(tlmm_test_silent_low),
        KUNIT_CASE(tlmm_test_silent_high),
        KUNIT_CASE(tlmm_test_rising),
        KUNIT_CASE(tlmm_test_falling),
        KUNIT_CASE(tlmm_test_high),
        KUNIT_CASE(tlmm_test_low),
        KUNIT_CASE(tlmm_test_rising_in_handler),
        KUNIT_CASE(tlmm_test_falling_in_handler),
        KUNIT_CASE(tlmm_test_thread_rising),
        KUNIT_CASE(tlmm_test_thread_falling),
        KUNIT_CASE(tlmm_test_thread_high),
        KUNIT_CASE(tlmm_test_thread_low),
        KUNIT_CASE(tlmm_test_thread_rising_in_handler),
        KUNIT_CASE(tlmm_test_thread_falling_in_handler),
        KUNIT_CASE(tlmm_test_rising_while_disabled),
        {}
};

static struct kunit_suite tlmm_test_suite = {
        .name = "tlmm-test",
        .init = tlmm_test_init,
        .suite_init = tlmm_test_init_suite,
        .suite_exit = tlmm_test_exit_suite,
        .test_cases = tlmm_test_cases,
};

kunit_test_suites(&tlmm_test_suite);

MODULE_DESCRIPTION("Qualcomm TLMM test");
MODULE_LICENSE("GPL");