// SPDX-License-Identifier: GPL-2.0
//
// Copyright (c) 2017-2019 Samuel Holland <samuel@sholland.org>

#include <linux/bitops.h>
#include <linux/clk.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/mailbox_controller.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/platform_device.h>
#include <linux/reset.h>
#include <linux/spinlock.h>

#define NUM_CHANS               8

#define CTRL_REG(n)             (0x0000 + 0x4 * ((n) / 4))
#define CTRL_RX(n)              BIT(0 + 8 * ((n) % 4))
#define CTRL_TX(n)              BIT(4 + 8 * ((n) % 4))

#define REMOTE_IRQ_EN_REG       0x0040
#define REMOTE_IRQ_STAT_REG     0x0050
#define LOCAL_IRQ_EN_REG        0x0060
#define LOCAL_IRQ_STAT_REG      0x0070

#define RX_IRQ(n)               BIT(0 + 2 * (n))
#define RX_IRQ_MASK             0x5555
#define TX_IRQ(n)               BIT(1 + 2 * (n))
#define TX_IRQ_MASK             0xaaaa

#define FIFO_STAT_REG(n)        (0x0100 + 0x4 * (n))
#define FIFO_STAT_MASK          GENMASK(0, 0)

#define MSG_STAT_REG(n)         (0x0140 + 0x4 * (n))
#define MSG_STAT_MASK           GENMASK(2, 0)

#define MSG_DATA_REG(n)         (0x0180 + 0x4 * (n))

#define mbox_dbg(mbox, ...)     dev_dbg((mbox)->controller.dev, __VA_ARGS__)

struct sun6i_msgbox {
        struct mbox_controller controller;
        struct clk *clk;
        spinlock_t lock;
        void __iomem *regs;
};

static bool sun6i_msgbox_last_tx_done(struct mbox_chan *chan);
static bool sun6i_msgbox_peek_data(struct mbox_chan *chan);

static inline int channel_number(struct mbox_chan *chan)
{
        return chan - chan->mbox->chans;
}

static inline struct sun6i_msgbox *to_sun6i_msgbox(struct mbox_chan *chan)
{
        return chan->con_priv;
}

static irqreturn_t sun6i_msgbox_irq(int irq, void *dev_id)
{
        struct sun6i_msgbox *mbox = dev_id;
        uint32_t status;
        int n;

        /* Only examine channels that are currently enabled. */
        status = readl(mbox->regs + LOCAL_IRQ_EN_REG) &
                 readl(mbox->regs + LOCAL_IRQ_STAT_REG);

        if (!(status & RX_IRQ_MASK))
                return IRQ_NONE;

        for (n = 0; n < NUM_CHANS; ++n) {
                struct mbox_chan *chan = &mbox->controller.chans[n];

                if (!(status & RX_IRQ(n)))
                        continue;

                while (sun6i_msgbox_peek_data(chan)) {
                        uint32_t msg = readl(mbox->regs + MSG_DATA_REG(n));

                        mbox_dbg(mbox, "Channel %d received 0x%08x\n", n, msg);
                        mbox_chan_received_data(chan, &msg);
                }

                /* The IRQ can be cleared only once the FIFO is empty. */
                writel(RX_IRQ(n), mbox->regs + LOCAL_IRQ_STAT_REG);
        }

        return IRQ_HANDLED;
}

static int sun6i_msgbox_send_data(struct mbox_chan *chan, void *data)
{
        struct sun6i_msgbox *mbox = to_sun6i_msgbox(chan);
        int n = channel_number(chan);
        uint32_t msg = *(uint32_t *)data;

        /* Using a channel backwards gets the hardware into a bad state. */
        if (WARN_ON_ONCE(!(readl(mbox->regs + CTRL_REG(n)) & CTRL_TX(n))))
                return 0;

        writel(msg, mbox->regs + MSG_DATA_REG(n));
        mbox_dbg(mbox, "Channel %d sent 0x%08x\n", n, msg);

        return 0;
}

static int sun6i_msgbox_startup(struct mbox_chan *chan)
{
        struct sun6i_msgbox *mbox = to_sun6i_msgbox(chan);
        int n = channel_number(chan);

        /* The coprocessor is responsible for setting channel directions. */
        if (readl(mbox->regs + CTRL_REG(n)) & CTRL_RX(n)) {
                /* Flush the receive FIFO. */
                while (sun6i_msgbox_peek_data(chan))
                        readl(mbox->regs + MSG_DATA_REG(n));
                writel(RX_IRQ(n), mbox->regs + LOCAL_IRQ_STAT_REG);

                /* Enable the receive IRQ. */
                spin_lock(&mbox->lock);
                writel(readl(mbox->regs + LOCAL_IRQ_EN_REG) | RX_IRQ(n),
                       mbox->regs + LOCAL_IRQ_EN_REG);
                spin_unlock(&mbox->lock);
        }

        mbox_dbg(mbox, "Channel %d startup complete\n", n);

        return 0;
}

static void sun6i_msgbox_shutdown(struct mbox_chan *chan)
{
        struct sun6i_msgbox *mbox = to_sun6i_msgbox(chan);
        int n = channel_number(chan);

        if (readl(mbox->regs + CTRL_REG(n)) & CTRL_RX(n)) {
                /* Disable the receive IRQ. */
                spin_lock(&mbox->lock);
                writel(readl(mbox->regs + LOCAL_IRQ_EN_REG) & ~RX_IRQ(n),
                       mbox->regs + LOCAL_IRQ_EN_REG);
                spin_unlock(&mbox->lock);

                /* Attempt to flush the FIFO until the IRQ is cleared. */
                do {
                        while (sun6i_msgbox_peek_data(chan))
                                readl(mbox->regs + MSG_DATA_REG(n));
                        writel(RX_IRQ(n), mbox->regs + LOCAL_IRQ_STAT_REG);
                } while (readl(mbox->regs + LOCAL_IRQ_STAT_REG) & RX_IRQ(n));
        }

        mbox_dbg(mbox, "Channel %d shutdown complete\n", n);
}

static bool sun6i_msgbox_last_tx_done(struct mbox_chan *chan)
{
        struct sun6i_msgbox *mbox = to_sun6i_msgbox(chan);
        int n = channel_number(chan);

        /*
         * The hardware allows snooping on the remote user's IRQ statuses.
         * We consider a message to be acknowledged only once the receive IRQ
         * for that channel is cleared. Since the receive IRQ for a channel
         * cannot be cleared until the FIFO for that channel is empty, this
         * ensures that the message has actually been read. It also gives the
         * recipient an opportunity to perform minimal processing before
         * acknowledging the message.
         */
        return !(readl(mbox->regs + REMOTE_IRQ_STAT_REG) & RX_IRQ(n));
}

static bool sun6i_msgbox_peek_data(struct mbox_chan *chan)
{
        struct sun6i_msgbox *mbox = to_sun6i_msgbox(chan);
        int n = channel_number(chan);

        return readl(mbox->regs + MSG_STAT_REG(n)) & MSG_STAT_MASK;
}

static const struct mbox_chan_ops sun6i_msgbox_chan_ops = {
        .send_data    = sun6i_msgbox_send_data,
        .startup      = sun6i_msgbox_startup,
        .shutdown     = sun6i_msgbox_shutdown,
        .last_tx_done = sun6i_msgbox_last_tx_done,
        .peek_data    = sun6i_msgbox_peek_data,
};

static int sun6i_msgbox_probe(struct platform_device *pdev)
{
        struct device *dev = &pdev->dev;
        struct mbox_chan *chans;
        struct reset_control *reset;
        struct sun6i_msgbox *mbox;
        int i, ret;

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

        chans = devm_kcalloc(dev, NUM_CHANS, sizeof(*chans), GFP_KERNEL);
        if (!chans)
                return -ENOMEM;

        for (i = 0; i < NUM_CHANS; ++i)
                chans[i].con_priv = mbox;

        mbox->clk = devm_clk_get(dev, NULL);
        if (IS_ERR(mbox->clk)) {
                ret = PTR_ERR(mbox->clk);
                dev_err(dev, "Failed to get clock: %d\n", ret);
                return ret;
        }

        ret = clk_prepare_enable(mbox->clk);
        if (ret) {
                dev_err(dev, "Failed to enable clock: %d\n", ret);
                return ret;
        }

        reset = devm_reset_control_get_exclusive(dev, NULL);
        if (IS_ERR(reset)) {
                ret = PTR_ERR(reset);
                dev_err(dev, "Failed to get reset control: %d\n", ret);
                goto err_disable_unprepare;
        }

        /*
         * NOTE: We rely on platform firmware to preconfigure the channel
         * directions, and we share this hardware block with other firmware
         * that runs concurrently with Linux (e.g. a trusted monitor).
         *
         * Therefore, we do *not* assert the reset line if probing fails or
         * when removing the device.
         */
        ret = reset_control_deassert(reset);
        if (ret) {
                dev_err(dev, "Failed to deassert reset: %d\n", ret);
                goto err_disable_unprepare;
        }

        mbox->regs = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(mbox->regs)) {
                ret = PTR_ERR(mbox->regs);
                dev_err(dev, "Failed to map MMIO resource: %d\n", ret);
                goto err_disable_unprepare;
        }

        /* Disable all IRQs for this end of the msgbox. */
        writel(0, mbox->regs + LOCAL_IRQ_EN_REG);

        ret = devm_request_irq(dev, irq_of_parse_and_map(dev->of_node, 0),
                               sun6i_msgbox_irq, 0, dev_name(dev), mbox);
        if (ret) {
                dev_err(dev, "Failed to register IRQ handler: %d\n", ret);
                goto err_disable_unprepare;
        }

        mbox->controller.dev           = dev;
        mbox->controller.ops           = &sun6i_msgbox_chan_ops;
        mbox->controller.chans         = chans;
        mbox->controller.num_chans     = NUM_CHANS;
        mbox->controller.txdone_irq    = false;
        mbox->controller.txdone_poll   = true;
        mbox->controller.txpoll_period = 5;

        spin_lock_init(&mbox->lock);
        platform_set_drvdata(pdev, mbox);

        ret = mbox_controller_register(&mbox->controller);
        if (ret) {
                dev_err(dev, "Failed to register controller: %d\n", ret);
                goto err_disable_unprepare;
        }

        return 0;

err_disable_unprepare:
        clk_disable_unprepare(mbox->clk);

        return ret;
}

static void sun6i_msgbox_remove(struct platform_device *pdev)
{
        struct sun6i_msgbox *mbox = platform_get_drvdata(pdev);

        mbox_controller_unregister(&mbox->controller);
        /* See the comment in sun6i_msgbox_probe about the reset line. */
        clk_disable_unprepare(mbox->clk);
}

static const struct of_device_id sun6i_msgbox_of_match[] = {
        { .compatible = "allwinner,sun6i-a31-msgbox", },
        {},
};
MODULE_DEVICE_TABLE(of, sun6i_msgbox_of_match);

static struct platform_driver sun6i_msgbox_driver = {
        .driver = {
                .name = "sun6i-msgbox",
                .of_match_table = sun6i_msgbox_of_match,
        },
        .probe = sun6i_msgbox_probe,
        .remove = sun6i_msgbox_remove,
};
module_platform_driver(sun6i_msgbox_driver);

MODULE_AUTHOR("Samuel Holland <samuel@sholland.org>");
MODULE_DESCRIPTION("Allwinner sun6i/sun8i/sun9i/sun50i Message Box");
MODULE_LICENSE("GPL v2");