// SPDX-License-Identifier: GPL-2.0
/*
 * Renesas RZ/V2H(P) Input Video Control Block driver
 *
 * Copyright (C) 2025 Ideas on Board Oy
 */

#include "rzv2h-ivc.h"

#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/reset.h>

void rzv2h_ivc_write(struct rzv2h_ivc *ivc, u32 addr, u32 val)
{
        writel(val, ivc->base + addr);
}

void rzv2h_ivc_update_bits(struct rzv2h_ivc *ivc, unsigned int addr,
                           u32 mask, u32 val)
{
        u32 orig, new;

        orig = readl(ivc->base + addr);

        new = orig & ~mask;
        new |= val & mask;

        if (new != orig)
                writel(new, ivc->base + addr);
}

static int rzv2h_ivc_get_hardware_resources(struct rzv2h_ivc *ivc,
                                            struct platform_device *pdev)
{
        static const char * const resource_names[RZV2H_IVC_NUM_HW_RESOURCES] = {
                "reg",
                "axi",
                "isp",
        };
        struct resource *res;
        int ret;

        ivc->base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
        if (IS_ERR(ivc->base))
                return dev_err_probe(ivc->dev, PTR_ERR(ivc->base),
                                     "failed to map IO memory\n");

        for (unsigned int i = 0; i < ARRAY_SIZE(resource_names); i++)
                ivc->clks[i].id = resource_names[i];

        ret = devm_clk_bulk_get(ivc->dev, ARRAY_SIZE(resource_names), ivc->clks);
        if (ret)
                return dev_err_probe(ivc->dev, ret, "failed to acquire clks\n");

        for (unsigned int i = 0; i < ARRAY_SIZE(resource_names); i++)
                ivc->resets[i].id = resource_names[i];

        ret = devm_reset_control_bulk_get_optional_shared(ivc->dev,
                                                ARRAY_SIZE(resource_names),
                                                ivc->resets);
        if (ret)
                return dev_err_probe(ivc->dev, ret, "failed to acquire resets\n");

        return 0;
}

static void rzv2h_ivc_global_config(struct rzv2h_ivc *ivc)
{
        /* Currently we only support single-exposure input */
        rzv2h_ivc_write(ivc, RZV2H_IVC_REG_AXIRX_PLNUM, RZV2H_IVC_ONE_EXPOSURE);

        /*
         * Datasheet says we should disable the interrupts before changing mode
         * to avoid spurious IFP interrupt.
         */
        rzv2h_ivc_write(ivc, RZV2H_IVC_REG_FM_INT_EN, 0x0);

        /*
         * RZ/V2H(P) documentation says software controlled single context mode
         * is not supported, and currently the driver does not support the
         * multi-context mode. That being so we just set single context sw-hw
         * mode.
         */
        rzv2h_ivc_write(ivc, RZV2H_IVC_REG_FM_CONTEXT,
                        RZV2H_IVC_SINGLE_CONTEXT_SW_HW_CFG);

        /*
         * We enable the frame end interrupt so that we know when we should send
         * follow-up frames.
         */
        rzv2h_ivc_write(ivc, RZV2H_IVC_REG_FM_INT_EN, RZV2H_IVC_VVAL_IFPE);
}

static irqreturn_t rzv2h_ivc_isr(int irq, void *context)
{
        struct device *dev = context;
        struct rzv2h_ivc *ivc = dev_get_drvdata(dev);

        guard(spinlock)(&ivc->spinlock);

        /* IRQ should never be triggered before vvalid_ifp has been reset to 2 */
        if (WARN_ON(!ivc->vvalid_ifp))
                return IRQ_HANDLED;

        /*
         * The first interrupt indicates that the buffer transfer has been
         * completed.
         */
        if (--ivc->vvalid_ifp) {
                rzv2h_ivc_buffer_done(ivc);
                return IRQ_HANDLED;
        }

        /*
         * The second interrupt indicates that the post-frame transfer VBLANK
         * has completed, we can now schedule a new frame transfer, if any.
         */
        queue_work(ivc->buffers.async_wq, &ivc->buffers.work);

        return IRQ_HANDLED;
}

static int rzv2h_ivc_runtime_resume(struct device *dev)
{
        struct rzv2h_ivc *ivc = dev_get_drvdata(dev);
        int ret;

        ret = clk_bulk_prepare_enable(ARRAY_SIZE(ivc->clks), ivc->clks);
        if (ret) {
                dev_err(ivc->dev, "failed to enable clocks\n");
                return ret;
        }

        ret = reset_control_bulk_deassert(ARRAY_SIZE(ivc->resets), ivc->resets);
        if (ret) {
                dev_err(ivc->dev, "failed to deassert resets\n");
                goto err_disable_clks;
        }

        rzv2h_ivc_global_config(ivc);

        ret = request_irq(ivc->irqnum, rzv2h_ivc_isr, 0, dev_driver_string(dev),
                          dev);
        if (ret) {
                dev_err(dev, "failed to request irq\n");
                goto err_assert_resets;
        }

        return 0;

err_assert_resets:
        reset_control_bulk_assert(ARRAY_SIZE(ivc->resets), ivc->resets);
err_disable_clks:
        clk_bulk_disable_unprepare(ARRAY_SIZE(ivc->clks), ivc->clks);

        return ret;
}

static int rzv2h_ivc_runtime_suspend(struct device *dev)
{
        struct rzv2h_ivc *ivc = dev_get_drvdata(dev);

        reset_control_bulk_assert(ARRAY_SIZE(ivc->resets), ivc->resets);
        clk_bulk_disable_unprepare(ARRAY_SIZE(ivc->clks), ivc->clks);
        free_irq(ivc->irqnum, dev);

        return 0;
}

static const struct dev_pm_ops rzv2h_ivc_pm_ops = {
        SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume)
        RUNTIME_PM_OPS(rzv2h_ivc_runtime_suspend, rzv2h_ivc_runtime_resume,
                       NULL)
};

static int rzv2h_ivc_probe(struct platform_device *pdev)
{
        struct device *dev = &pdev->dev;
        struct rzv2h_ivc *ivc;
        int ret;

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

        ivc->dev = dev;
        platform_set_drvdata(pdev, ivc);

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

        spin_lock_init(&ivc->spinlock);

        ret = rzv2h_ivc_get_hardware_resources(ivc, pdev);
        if (ret)
                return ret;

        pm_runtime_set_autosuspend_delay(dev, 2000);
        pm_runtime_use_autosuspend(dev);
        pm_runtime_enable(dev);

        ivc->irqnum = platform_get_irq(pdev, 0);
        if (ivc->irqnum < 0)
                return ivc->irqnum;

        ret = rzv2h_ivc_initialise_subdevice(ivc);
        if (ret)
                goto err_disable_pm_runtime;

        return 0;

err_disable_pm_runtime:
        pm_runtime_disable(dev);

        return ret;
}

static void rzv2h_ivc_remove(struct platform_device *pdev)
{
        struct rzv2h_ivc *ivc = platform_get_drvdata(pdev);

        rzv2h_deinit_video_dev_and_queue(ivc);
        rzv2h_ivc_deinit_subdevice(ivc);
}

static const struct of_device_id rzv2h_ivc_of_match[] = {
        { .compatible = "renesas,r9a09g057-ivc", },
        { /* Sentinel */ }
};
MODULE_DEVICE_TABLE(of, rzv2h_ivc_of_match);

static struct platform_driver rzv2h_ivc_driver = {
        .driver = {
                .name = "rzv2h-ivc",
                .of_match_table = rzv2h_ivc_of_match,
                .pm = &rzv2h_ivc_pm_ops,
        },
        .probe = rzv2h_ivc_probe,
        .remove = rzv2h_ivc_remove,
};

module_platform_driver(rzv2h_ivc_driver);

MODULE_AUTHOR("Daniel Scally <dan.scally@ideasonboard.com>");
MODULE_DESCRIPTION("Renesas RZ/V2H(P) Input Video Control Block driver");
MODULE_LICENSE("GPL");