// SPDX-License-Identifier: GPL-2.0
/*
 * Nuvoton NCT6694 GPIO controller driver based on USB interface.
 *
 * Copyright (C) 2025 Nuvoton Technology Corp.
 */

#include <linux/bits.h>
#include <linux/gpio/driver.h>
#include <linux/idr.h>
#include <linux/interrupt.h>
#include <linux/mfd/nct6694.h>
#include <linux/module.h>
#include <linux/platform_device.h>

/*
 * USB command module type for NCT6694 GPIO controller.
 * This defines the module type used for communication with the NCT6694
 * GPIO controller over the USB interface.
 */
#define NCT6694_GPIO_MOD        0xFF

#define NCT6694_GPIO_VER        0x90
#define NCT6694_GPIO_VALID      0x110
#define NCT6694_GPI_DATA        0x120
#define NCT6694_GPO_DIR         0x170
#define NCT6694_GPO_TYPE        0x180
#define NCT6694_GPO_DATA        0x190

#define NCT6694_GPI_STS         0x130
#define NCT6694_GPI_CLR         0x140
#define NCT6694_GPI_FALLING     0x150
#define NCT6694_GPI_RISING      0x160

#define NCT6694_NR_GPIO         8

struct nct6694_gpio_data {
        struct nct6694 *nct6694;
        struct gpio_chip gpio;
        struct mutex lock;
        /* Protect irq operation */
        struct mutex irq_lock;

        unsigned char reg_val;
        unsigned char irq_trig_falling;
        unsigned char irq_trig_rising;

        /* Current gpio group */
        unsigned char group;
        int irq;
};

static int nct6694_get_direction(struct gpio_chip *gpio, unsigned int offset)
{
        struct nct6694_gpio_data *data = gpiochip_get_data(gpio);
        const struct nct6694_cmd_header cmd_hd = {
                .mod = NCT6694_GPIO_MOD,
                .offset = cpu_to_le16(NCT6694_GPO_DIR + data->group),
                .len = cpu_to_le16(sizeof(data->reg_val))
        };
        int ret;

        guard(mutex)(&data->lock);

        ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->reg_val);
        if (ret < 0)
                return ret;

        return !(BIT(offset) & data->reg_val);
}

static int nct6694_direction_input(struct gpio_chip *gpio, unsigned int offset)
{
        struct nct6694_gpio_data *data = gpiochip_get_data(gpio);
        const struct nct6694_cmd_header cmd_hd = {
                .mod = NCT6694_GPIO_MOD,
                .offset = cpu_to_le16(NCT6694_GPO_DIR + data->group),
                .len = cpu_to_le16(sizeof(data->reg_val))
        };
        int ret;

        guard(mutex)(&data->lock);

        ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->reg_val);
        if (ret < 0)
                return ret;

        data->reg_val &= ~BIT(offset);

        return nct6694_write_msg(data->nct6694, &cmd_hd, &data->reg_val);
}

static int nct6694_direction_output(struct gpio_chip *gpio,
                                    unsigned int offset, int val)
{
        struct nct6694_gpio_data *data = gpiochip_get_data(gpio);
        struct nct6694_cmd_header cmd_hd = {
                .mod = NCT6694_GPIO_MOD,
                .offset = cpu_to_le16(NCT6694_GPO_DIR + data->group),
                .len = cpu_to_le16(sizeof(data->reg_val))
        };
        int ret;

        guard(mutex)(&data->lock);

        /* Set direction to output */
        ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->reg_val);
        if (ret < 0)
                return ret;

        data->reg_val |= BIT(offset);
        ret = nct6694_write_msg(data->nct6694, &cmd_hd, &data->reg_val);
        if (ret < 0)
                return ret;

        /* Then set output level */
        cmd_hd.offset = cpu_to_le16(NCT6694_GPO_DATA + data->group);
        ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->reg_val);
        if (ret < 0)
                return ret;

        if (val)
                data->reg_val |= BIT(offset);
        else
                data->reg_val &= ~BIT(offset);

        return nct6694_write_msg(data->nct6694, &cmd_hd, &data->reg_val);
}

static int nct6694_get_value(struct gpio_chip *gpio, unsigned int offset)
{
        struct nct6694_gpio_data *data = gpiochip_get_data(gpio);
        struct nct6694_cmd_header cmd_hd = {
                .mod = NCT6694_GPIO_MOD,
                .offset = cpu_to_le16(NCT6694_GPO_DIR + data->group),
                .len = cpu_to_le16(sizeof(data->reg_val))
        };
        int ret;

        guard(mutex)(&data->lock);

        ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->reg_val);
        if (ret < 0)
                return ret;

        if (BIT(offset) & data->reg_val) {
                cmd_hd.offset = cpu_to_le16(NCT6694_GPO_DATA + data->group);
                ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->reg_val);
                if (ret < 0)
                        return ret;

                return !!(BIT(offset) & data->reg_val);
        }

        cmd_hd.offset = cpu_to_le16(NCT6694_GPI_DATA + data->group);
        ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->reg_val);
        if (ret < 0)
                return ret;

        return !!(BIT(offset) & data->reg_val);
}

static int nct6694_set_value(struct gpio_chip *gpio, unsigned int offset,
                             int val)
{
        struct nct6694_gpio_data *data = gpiochip_get_data(gpio);
        const struct nct6694_cmd_header cmd_hd = {
                .mod = NCT6694_GPIO_MOD,
                .offset = cpu_to_le16(NCT6694_GPO_DATA + data->group),
                .len = cpu_to_le16(sizeof(data->reg_val))
        };
        int ret;

        guard(mutex)(&data->lock);

        ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->reg_val);
        if (ret < 0)
                return ret;

        if (val)
                data->reg_val |= BIT(offset);
        else
                data->reg_val &= ~BIT(offset);

        return nct6694_write_msg(data->nct6694, &cmd_hd, &data->reg_val);
}

static int nct6694_set_config(struct gpio_chip *gpio, unsigned int offset,
                              unsigned long config)
{
        struct nct6694_gpio_data *data = gpiochip_get_data(gpio);
        const struct nct6694_cmd_header cmd_hd = {
                .mod = NCT6694_GPIO_MOD,
                .offset = cpu_to_le16(NCT6694_GPO_TYPE + data->group),
                .len = cpu_to_le16(sizeof(data->reg_val))
        };
        int ret;

        guard(mutex)(&data->lock);

        ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->reg_val);
        if (ret < 0)
                return ret;

        switch (pinconf_to_config_param(config)) {
        case PIN_CONFIG_DRIVE_OPEN_DRAIN:
                data->reg_val |= BIT(offset);
                break;
        case PIN_CONFIG_DRIVE_PUSH_PULL:
                data->reg_val &= ~BIT(offset);
                break;
        default:
                return -ENOTSUPP;
        }

        return nct6694_write_msg(data->nct6694, &cmd_hd, &data->reg_val);
}

static int nct6694_init_valid_mask(struct gpio_chip *gpio,
                                   unsigned long *valid_mask,
                                   unsigned int ngpios)
{
        struct nct6694_gpio_data *data = gpiochip_get_data(gpio);
        const struct nct6694_cmd_header cmd_hd = {
                .mod = NCT6694_GPIO_MOD,
                .offset = cpu_to_le16(NCT6694_GPIO_VALID + data->group),
                .len = cpu_to_le16(sizeof(data->reg_val))
        };
        int ret;

        guard(mutex)(&data->lock);

        ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->reg_val);
        if (ret < 0)
                return ret;

        *valid_mask = data->reg_val;

        return ret;
}

static irqreturn_t nct6694_irq_handler(int irq, void *priv)
{
        struct nct6694_gpio_data *data = priv;
        struct nct6694_cmd_header cmd_hd = {
                .mod = NCT6694_GPIO_MOD,
                .offset = cpu_to_le16(NCT6694_GPI_STS + data->group),
                .len = cpu_to_le16(sizeof(data->reg_val))
        };
        unsigned char status;
        int ret;

        guard(mutex)(&data->lock);

        ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->reg_val);
        if (ret)
                return IRQ_NONE;

        status = data->reg_val;

        while (status) {
                int bit = __ffs(status);

                data->reg_val = BIT(bit);
                handle_nested_irq(irq_find_mapping(data->gpio.irq.domain, bit));
                status &= ~BIT(bit);
                cmd_hd.offset = cpu_to_le16(NCT6694_GPI_CLR + data->group);
                nct6694_write_msg(data->nct6694, &cmd_hd, &data->reg_val);
        }

        return IRQ_HANDLED;
}

static int nct6694_get_irq_trig(struct nct6694_gpio_data *data)
{
        struct nct6694_cmd_header cmd_hd = {
                .mod = NCT6694_GPIO_MOD,
                .offset = cpu_to_le16(NCT6694_GPI_FALLING + data->group),
                .len = cpu_to_le16(sizeof(data->reg_val))
        };
        int ret;

        guard(mutex)(&data->lock);

        ret = nct6694_read_msg(data->nct6694, &cmd_hd, &data->irq_trig_falling);
        if (ret)
                return ret;

        cmd_hd.offset = cpu_to_le16(NCT6694_GPI_RISING + data->group);
        return nct6694_read_msg(data->nct6694, &cmd_hd, &data->irq_trig_rising);
}

static void nct6694_irq_mask(struct irq_data *d)
{
        struct gpio_chip *gpio = irq_data_get_irq_chip_data(d);
        irq_hw_number_t hwirq = irqd_to_hwirq(d);

        gpiochip_disable_irq(gpio, hwirq);
}

static void nct6694_irq_unmask(struct irq_data *d)
{
        struct gpio_chip *gpio = irq_data_get_irq_chip_data(d);
        irq_hw_number_t hwirq = irqd_to_hwirq(d);

        gpiochip_enable_irq(gpio, hwirq);
}

static int nct6694_irq_set_type(struct irq_data *d, unsigned int type)
{
        struct gpio_chip *gpio = irq_data_get_irq_chip_data(d);
        struct nct6694_gpio_data *data = gpiochip_get_data(gpio);
        irq_hw_number_t hwirq = irqd_to_hwirq(d);

        guard(mutex)(&data->lock);

        switch (type) {
        case IRQ_TYPE_EDGE_RISING:
                data->irq_trig_rising |= BIT(hwirq);
                break;

        case IRQ_TYPE_EDGE_FALLING:
                data->irq_trig_falling |= BIT(hwirq);
                break;

        case IRQ_TYPE_EDGE_BOTH:
                data->irq_trig_rising |= BIT(hwirq);
                data->irq_trig_falling |= BIT(hwirq);
                break;

        default:
                return -ENOTSUPP;
        }

        return 0;
}

static void nct6694_irq_bus_lock(struct irq_data *d)
{
        struct gpio_chip *gpio = irq_data_get_irq_chip_data(d);
        struct nct6694_gpio_data *data = gpiochip_get_data(gpio);

        mutex_lock(&data->irq_lock);
}

static void nct6694_irq_bus_sync_unlock(struct irq_data *d)
{
        struct gpio_chip *gpio = irq_data_get_irq_chip_data(d);
        struct nct6694_gpio_data *data = gpiochip_get_data(gpio);
        struct nct6694_cmd_header cmd_hd = {
                .mod = NCT6694_GPIO_MOD,
                .offset = cpu_to_le16(NCT6694_GPI_FALLING + data->group),
                .len = cpu_to_le16(sizeof(data->reg_val))
        };

        scoped_guard(mutex, &data->lock) {
                nct6694_write_msg(data->nct6694, &cmd_hd, &data->irq_trig_falling);

                cmd_hd.offset = cpu_to_le16(NCT6694_GPI_RISING + data->group);
                nct6694_write_msg(data->nct6694, &cmd_hd, &data->irq_trig_rising);
        }

        mutex_unlock(&data->irq_lock);
}

static const struct irq_chip nct6694_irq_chip = {
        .name                   = "gpio-nct6694",
        .irq_mask               = nct6694_irq_mask,
        .irq_unmask             = nct6694_irq_unmask,
        .irq_set_type           = nct6694_irq_set_type,
        .irq_bus_lock           = nct6694_irq_bus_lock,
        .irq_bus_sync_unlock    = nct6694_irq_bus_sync_unlock,
        .flags                  = IRQCHIP_IMMUTABLE,
        GPIOCHIP_IRQ_RESOURCE_HELPERS,
};

static void nct6694_irq_dispose_mapping(void *d)
{
        struct nct6694_gpio_data *data = d;

        irq_dispose_mapping(data->irq);
}

static void nct6694_gpio_ida_free(void *d)
{
        struct nct6694_gpio_data *data = d;
        struct nct6694 *nct6694 = data->nct6694;

        ida_free(&nct6694->gpio_ida, data->group);
}

static int nct6694_gpio_probe(struct platform_device *pdev)
{
        struct device *dev = &pdev->dev;
        struct nct6694 *nct6694 = dev_get_drvdata(dev->parent);
        struct nct6694_gpio_data *data;
        struct gpio_irq_chip *girq;
        int ret, i;
        char **names;

        data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;

        data->nct6694 = nct6694;

        ret = ida_alloc(&nct6694->gpio_ida, GFP_KERNEL);
        if (ret < 0)
                return ret;
        data->group = ret;

        ret = devm_add_action_or_reset(dev, nct6694_gpio_ida_free, data);
        if (ret)
                return ret;

        names = devm_kcalloc(dev, NCT6694_NR_GPIO, sizeof(char *),
                             GFP_KERNEL);
        if (!names)
                return -ENOMEM;

        for (i = 0; i < NCT6694_NR_GPIO; i++) {
                names[i] = devm_kasprintf(dev, GFP_KERNEL, "GPIO%X%d",
                                          data->group, i);
                if (!names[i])
                        return -ENOMEM;
        }

        data->irq = irq_create_mapping(nct6694->domain,
                                       NCT6694_IRQ_GPIO0 + data->group);
        if (!data->irq)
                return -EINVAL;

        ret = devm_add_action_or_reset(dev, nct6694_irq_dispose_mapping, data);
        if (ret)
                return ret;

        data->gpio.names                = (const char * const*)names;
        data->gpio.label                = pdev->name;
        data->gpio.direction_input      = nct6694_direction_input;
        data->gpio.get                  = nct6694_get_value;
        data->gpio.direction_output     = nct6694_direction_output;
        data->gpio.set                  = nct6694_set_value;
        data->gpio.get_direction        = nct6694_get_direction;
        data->gpio.set_config           = nct6694_set_config;
        data->gpio.init_valid_mask      = nct6694_init_valid_mask;
        data->gpio.base                 = -1;
        data->gpio.can_sleep            = false;
        data->gpio.owner                = THIS_MODULE;
        data->gpio.ngpio                = NCT6694_NR_GPIO;

        platform_set_drvdata(pdev, data);

        ret = devm_mutex_init(dev, &data->lock);
        if (ret)
                return ret;

        ret = devm_mutex_init(dev, &data->irq_lock);
        if (ret)
                return ret;

        ret = nct6694_get_irq_trig(data);
        if (ret) {
                dev_err_probe(dev, ret, "Failed to get irq trigger type\n");
                return ret;
        }

        girq = &data->gpio.irq;
        gpio_irq_chip_set_chip(girq, &nct6694_irq_chip);
        girq->parent_handler = NULL;
        girq->num_parents = 0;
        girq->parents = NULL;
        girq->default_type = IRQ_TYPE_NONE;
        girq->handler = handle_level_irq;
        girq->threaded = true;

        ret = devm_request_threaded_irq(dev, data->irq, NULL, nct6694_irq_handler,
                                        IRQF_ONESHOT | IRQF_SHARED,
                                        "gpio-nct6694", data);
        if (ret) {
                dev_err_probe(dev, ret, "Failed to request irq\n");
                return ret;
        }

        return devm_gpiochip_add_data(dev, &data->gpio, data);
}

static struct platform_driver nct6694_gpio_driver = {
        .driver = {
                .name   = "nct6694-gpio",
        },
        .probe          = nct6694_gpio_probe,
};

module_platform_driver(nct6694_gpio_driver);

MODULE_DESCRIPTION("USB-GPIO controller driver for NCT6694");
MODULE_AUTHOR("Ming Yu <tmyu0@nuvoton.com>");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:nct6694-gpio");