// SPDX-License-Identifier: GPL-2.0-only
/*
 * OMAP Remote Processor driver
 *
 * Copyright (C) 2011 Texas Instruments, Inc.
 * Copyright (C) 2011 Google, Inc.
 *
 * Ohad Ben-Cohen <ohad@wizery.com>
 * Brian Swetland <swetland@google.com>
 * Fernando Guzman Lugo <fernando.lugo@ti.com>
 * Mark Grosen <mgrosen@ti.com>
 * Suman Anna <s-anna@ti.com>
 * Hari Kanigeri <h-kanigeri2@ti.com>
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/dma-mapping.h>
#include <linux/remoteproc.h>
#include <linux/mailbox_client.h>
#include <linux/omap-mailbox.h>

#include <linux/platform_data/remoteproc-omap.h>

#include "omap_remoteproc.h"
#include "remoteproc_internal.h"

/**
 * struct omap_rproc - omap remote processor state
 * @mbox: mailbox channel handle
 * @client: mailbox client to request the mailbox channel
 * @rproc: rproc handle
 */
struct omap_rproc {
        struct mbox_chan *mbox;
        struct mbox_client client;
        struct rproc *rproc;
};

/**
 * omap_rproc_mbox_callback() - inbound mailbox message handler
 * @client: mailbox client pointer used for requesting the mailbox channel
 * @data: mailbox payload
 *
 * This handler is invoked by omap's mailbox driver whenever a mailbox
 * message is received. Usually, the mailbox payload simply contains
 * the index of the virtqueue that is kicked by the remote processor,
 * and we let remoteproc core handle it.
 *
 * In addition to virtqueue indices, we also have some out-of-band values
 * that indicates different events. Those values are deliberately very
 * big so they don't coincide with virtqueue indices.
 */
static void omap_rproc_mbox_callback(struct mbox_client *client, void *data)
{
        struct omap_rproc *oproc = container_of(client, struct omap_rproc,
                                                client);
        struct device *dev = oproc->rproc->dev.parent;
        const char *name = oproc->rproc->name;
        u32 msg = (u32)data;

        dev_dbg(dev, "mbox msg: 0x%x\n", msg);

        switch (msg) {
        case RP_MBOX_CRASH:
                /* just log this for now. later, we'll also do recovery */
                dev_err(dev, "omap rproc %s crashed\n", name);
                break;
        case RP_MBOX_ECHO_REPLY:
                dev_info(dev, "received echo reply from %s\n", name);
                break;
        default:
                /* msg contains the index of the triggered vring */
                if (rproc_vq_interrupt(oproc->rproc, msg) == IRQ_NONE)
                        dev_dbg(dev, "no message was found in vqid %d\n", msg);
        }
}

/* kick a virtqueue */
static void omap_rproc_kick(struct rproc *rproc, int vqid)
{
        struct omap_rproc *oproc = rproc->priv;
        struct device *dev = rproc->dev.parent;
        int ret;

        /* send the index of the triggered virtqueue in the mailbox payload */
        ret = mbox_send_message(oproc->mbox, (void *)vqid);
        if (ret < 0)
                dev_err(dev, "failed to send mailbox message, status = %d\n",
                        ret);
}

/*
 * Power up the remote processor.
 *
 * This function will be invoked only after the firmware for this rproc
 * was loaded, parsed successfully, and all of its resource requirements
 * were met.
 */
static int omap_rproc_start(struct rproc *rproc)
{
        struct omap_rproc *oproc = rproc->priv;
        struct device *dev = rproc->dev.parent;
        struct platform_device *pdev = to_platform_device(dev);
        struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
        int ret;
        struct mbox_client *client = &oproc->client;

        if (pdata->set_bootaddr)
                pdata->set_bootaddr(rproc->bootaddr);

        client->dev = dev;
        client->tx_done = NULL;
        client->rx_callback = omap_rproc_mbox_callback;
        client->tx_block = false;
        client->knows_txdone = false;

        oproc->mbox = omap_mbox_request_channel(client, pdata->mbox_name);
        if (IS_ERR(oproc->mbox)) {
                ret = -EBUSY;
                dev_err(dev, "mbox_request_channel failed: %ld\n",
                        PTR_ERR(oproc->mbox));
                return ret;
        }

        /*
         * Ping the remote processor. this is only for sanity-sake;
         * there is no functional effect whatsoever.
         *
         * Note that the reply will _not_ arrive immediately: this message
         * will wait in the mailbox fifo until the remote processor is booted.
         */
        ret = mbox_send_message(oproc->mbox, (void *)RP_MBOX_ECHO_REQUEST);
        if (ret < 0) {
                dev_err(dev, "mbox_send_message failed: %d\n", ret);
                goto put_mbox;
        }

        ret = pdata->device_enable(pdev);
        if (ret) {
                dev_err(dev, "omap_device_enable failed: %d\n", ret);
                goto put_mbox;
        }

        return 0;

put_mbox:
        mbox_free_channel(oproc->mbox);
        return ret;
}

/* power off the remote processor */
static int omap_rproc_stop(struct rproc *rproc)
{
        struct device *dev = rproc->dev.parent;
        struct platform_device *pdev = to_platform_device(dev);
        struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
        struct omap_rproc *oproc = rproc->priv;
        int ret;

        ret = pdata->device_shutdown(pdev);
        if (ret)
                return ret;

        mbox_free_channel(oproc->mbox);

        return 0;
}

static const struct rproc_ops omap_rproc_ops = {
        .start          = omap_rproc_start,
        .stop           = omap_rproc_stop,
        .kick           = omap_rproc_kick,
};

static int omap_rproc_probe(struct platform_device *pdev)
{
        struct omap_rproc_pdata *pdata = pdev->dev.platform_data;
        struct omap_rproc *oproc;
        struct rproc *rproc;
        int ret;

        ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
        if (ret) {
                dev_err(&pdev->dev, "dma_set_coherent_mask: %d\n", ret);
                return ret;
        }

        rproc = rproc_alloc(&pdev->dev, pdata->name, &omap_rproc_ops,
                            pdata->firmware, sizeof(*oproc));
        if (!rproc)
                return -ENOMEM;

        oproc = rproc->priv;
        oproc->rproc = rproc;
        /* All existing OMAP IPU and DSP processors have an MMU */
        rproc->has_iommu = true;

        platform_set_drvdata(pdev, rproc);

        ret = rproc_add(rproc);
        if (ret)
                goto free_rproc;

        return 0;

free_rproc:
        rproc_free(rproc);
        return ret;
}

static int omap_rproc_remove(struct platform_device *pdev)
{
        struct rproc *rproc = platform_get_drvdata(pdev);

        rproc_del(rproc);
        rproc_free(rproc);

        return 0;
}

static struct platform_driver omap_rproc_driver = {
        .probe = omap_rproc_probe,
        .remove = omap_rproc_remove,
        .driver = {
                .name = "omap-rproc",
        },
};

module_platform_driver(omap_rproc_driver);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("OMAP Remote Processor control driver");