// SPDX-License-Identifier: GPL-2.0
/*
 * Tenstorrent Atlantis PRCM Reset Driver
 *
 * Copyright (c) 2026 Tenstorrent
 */

#include <dt-bindings/clock/tenstorrent,atlantis-prcm-rcpu.h>
#include <linux/auxiliary_bus.h>
#include <linux/reset-controller.h>
#include <linux/regmap.h>

/* RCPU Reset Register Offsets */
#define RCPU_BLK_RST_REG 0x001c
#define LSIO_BLK_RST_REG 0x0020
#define HSIO_BLK_RST_REG 0x000c
#define PCIE_SUBS_RST_REG 0x0000
#define MM_RSTN_REG 0x0014

struct atlantis_reset_data {
        u8 bit;
        u16 reg;
        bool active_low;
};

struct atlantis_reset_controller_data {
        const struct atlantis_reset_data *reset_data;
        size_t count;
};

struct atlantis_reset_controller {
        struct reset_controller_dev rcdev;
        const struct atlantis_reset_controller_data *data;
        struct regmap *regmap;
};

static inline struct atlantis_reset_controller *
to_atlantis_reset_controller(struct reset_controller_dev *rcdev)
{
        return container_of(rcdev, struct atlantis_reset_controller, rcdev);
}

#define RESET_DATA(_reg, _bit, _active_low)                          \
        {                                                            \
                .bit = _bit, .reg = _reg, .active_low = _active_low, \
        }

static const struct atlantis_reset_data atlantis_rcpu_resets[] = {
        [RST_SMNDMA0]   = RESET_DATA(RCPU_BLK_RST_REG, 0, true),
        [RST_SMNDMA1]   = RESET_DATA(RCPU_BLK_RST_REG, 1, true),
        [RST_WDT0]      = RESET_DATA(RCPU_BLK_RST_REG, 2, true),
        [RST_WDT1]      = RESET_DATA(RCPU_BLK_RST_REG, 3, true),
        [RST_TMR]       = RESET_DATA(RCPU_BLK_RST_REG, 4, true),
        [RST_PVTC]      = RESET_DATA(RCPU_BLK_RST_REG, 12, true),
        [RST_PMU]       = RESET_DATA(RCPU_BLK_RST_REG, 13, true),
        [RST_MAILBOX]   = RESET_DATA(RCPU_BLK_RST_REG, 14, true),
        [RST_SPACC]     = RESET_DATA(RCPU_BLK_RST_REG, 26, true),
        [RST_OTP]       = RESET_DATA(RCPU_BLK_RST_REG, 28, true),
        [RST_TRNG]      = RESET_DATA(RCPU_BLK_RST_REG, 29, true),
        [RST_CRC]       = RESET_DATA(RCPU_BLK_RST_REG, 30, true),
        [RST_QSPI]      = RESET_DATA(LSIO_BLK_RST_REG, 0, true),
        [RST_I2C0]      = RESET_DATA(LSIO_BLK_RST_REG, 1, true),
        [RST_I2C1]      = RESET_DATA(LSIO_BLK_RST_REG, 2, true),
        [RST_I2C2]      = RESET_DATA(LSIO_BLK_RST_REG, 3, true),
        [RST_I2C3]      = RESET_DATA(LSIO_BLK_RST_REG, 4, true),
        [RST_I2C4]      = RESET_DATA(LSIO_BLK_RST_REG, 5, true),
        [RST_UART0]     = RESET_DATA(LSIO_BLK_RST_REG, 6, true),
        [RST_UART1]     = RESET_DATA(LSIO_BLK_RST_REG, 7, true),
        [RST_UART2]     = RESET_DATA(LSIO_BLK_RST_REG, 8, true),
        [RST_UART3]     = RESET_DATA(LSIO_BLK_RST_REG, 9, true),
        [RST_UART4]     = RESET_DATA(LSIO_BLK_RST_REG, 10, true),
        [RST_SPI0]      = RESET_DATA(LSIO_BLK_RST_REG, 11, true),
        [RST_SPI1]      = RESET_DATA(LSIO_BLK_RST_REG, 12, true),
        [RST_SPI2]      = RESET_DATA(LSIO_BLK_RST_REG, 13, true),
        [RST_SPI3]      = RESET_DATA(LSIO_BLK_RST_REG, 14, true),
        [RST_GPIO]      = RESET_DATA(LSIO_BLK_RST_REG, 15, true),
        [RST_CAN0]      = RESET_DATA(LSIO_BLK_RST_REG, 17, true),
        [RST_CAN1]      = RESET_DATA(LSIO_BLK_RST_REG, 18, true),
        [RST_I2S0]      = RESET_DATA(LSIO_BLK_RST_REG, 19, true),
        [RST_I2S1]      = RESET_DATA(LSIO_BLK_RST_REG, 20, true),

};

static const struct atlantis_reset_controller_data atlantis_rcpu_reset_data = {
        .reset_data = atlantis_rcpu_resets,
        .count = ARRAY_SIZE(atlantis_rcpu_resets),
};

static int atlantis_reset_update(struct reset_controller_dev *rcdev,
                                 unsigned long id, bool assert)
{
        unsigned int val;
        struct atlantis_reset_controller *rst =
                to_atlantis_reset_controller(rcdev);
        const struct atlantis_reset_data *data = &rst->data->reset_data[id];
        unsigned int mask = BIT(data->bit);
        struct regmap *regmap = rst->regmap;

        if (data->active_low ^ assert)
                val = mask;
        else
                val = 0;

        return regmap_update_bits(regmap, data->reg, mask, val);
}

static int atlantis_reset_assert(struct reset_controller_dev *rcdev,
                                 unsigned long id)
{
        return atlantis_reset_update(rcdev, id, true);
}

static int atlantis_reset_deassert(struct reset_controller_dev *rcdev,
                                   unsigned long id)
{
        return atlantis_reset_update(rcdev, id, false);
}

static const struct reset_control_ops atlantis_reset_control_ops = {
        .assert = atlantis_reset_assert,
        .deassert = atlantis_reset_deassert,
};

static int
atlantis_reset_controller_register(struct device *dev,
                                   struct atlantis_reset_controller *controller)
{
        struct reset_controller_dev *rcdev = &controller->rcdev;

        rcdev->ops = &atlantis_reset_control_ops;
        rcdev->owner = THIS_MODULE;
        rcdev->of_node = dev->of_node;
        rcdev->nr_resets = controller->data->count;

        return devm_reset_controller_register(dev, &controller->rcdev);
}
static int atlantis_reset_probe(struct auxiliary_device *adev,
                                const struct auxiliary_device_id *id)
{
        struct atlantis_reset_controller *controller;
        struct device *dev = &adev->dev;
        struct regmap *regmap;

        regmap = dev_get_regmap(dev->parent, NULL);
        if (!regmap)
                return -ENODEV;

        controller = devm_kzalloc(dev, sizeof(*controller), GFP_KERNEL);
        if (!controller)
                return -ENOMEM;
        controller->data =
                (const struct atlantis_reset_controller_data *)id->driver_data;
        controller->regmap = regmap;

        return atlantis_reset_controller_register(dev, controller);
}

static const struct auxiliary_device_id atlantis_reset_ids[] = {
        { .name = "atlantis_prcm.rcpu-reset",
          .driver_data = (kernel_ulong_t)&atlantis_rcpu_reset_data },
        {},
};
MODULE_DEVICE_TABLE(auxiliary, atlantis_reset_ids);

static struct auxiliary_driver atlantis_reset_driver = {
        .probe = atlantis_reset_probe,
        .id_table = atlantis_reset_ids,
};
module_auxiliary_driver(atlantis_reset_driver);

MODULE_AUTHOR("Anirudh Srinivasan <asrinivasan@oss.tenstorrent.com>");
MODULE_DESCRIPTION("Atlantis PRCM reset controller driver");
MODULE_LICENSE("GPL");