// SPDX-License-Identifier: GPL-2.0+
/*
 * Texas Instruments' K3 System Controller Driver
 *
 * Copyright (C) 2017-2018 Texas Instruments Incorporated - http://www.ti.com/
 *      Lokesh Vutla <lokeshvutla@ti.com>
 */

#include <common.h>
#include <dm.h>
#include <remoteproc.h>
#include <errno.h>
#include <mailbox.h>
#include <linux/soc/ti/k3-sec-proxy.h>

#define K3_MSG_R5_TO_M3_M3FW                    0x8105
#define K3_MSG_M3_TO_R5_CERT_RESULT             0x8805
#define K3_MSG_M3_TO_R5_BOOT_NOTIFICATION       0x000A

#define K3_FLAGS_MSG_CERT_AUTH_PASS             0x555555
#define K3_FLAGS_MSG_CERT_AUTH_FAIL             0xffffff

/**
 * struct k3_sysctrler_msg_hdr - Generic Header for Messages and responses.
 * @cmd_id:     Message ID. One of K3_MSG_*
 * @host_id:    Host ID of the message
 * @seq_ne:     Message identifier indicating a transfer sequence.
 * @flags:      Flags for the message.
 */
struct k3_sysctrler_msg_hdr {
        u16 cmd_id;
        u8 host_id;
        u8 seq_nr;
        u32 flags;
} __packed;

/**
 * struct k3_sysctrler_load_msg - Message format for Firmware loading
 * @hdr:                Generic message hdr
 * @buffer_address:     Address at which firmware is located.
 * @buffer_size:        Size of the firmware.
 */
struct k3_sysctrler_load_msg {
        struct k3_sysctrler_msg_hdr hdr;
        u32 buffer_address;
        u32 buffer_size;
} __packed;

/**
 * struct k3_sysctrler_boot_notification_msg - Message format for boot
 *                                             notification
 * @checksum:           Checksum for the entire message
 * @reserved:           Reserved for future use.
 * @hdr:                Generic message hdr
 */
struct k3_sysctrler_boot_notification_msg {
        u16 checksum;
        u16 reserved;
        struct k3_sysctrler_msg_hdr hdr;
} __packed;

/**
 * struct k3_sysctrler_desc - Description of SoC integration.
 * @host_id:    Host identifier representing the compute entity
 * @max_rx_timeout_ms:  Timeout for communication with SoC (in Milliseconds)
 * @max_msg_size: Maximum size of data per message that can be handled.
 */
struct k3_sysctrler_desc {
        u8 host_id;
        int max_rx_timeout_us;
        int max_msg_size;
};

/**
 * struct k3_sysctrler_privdata - Structure representing System Controller data.
 * @chan_tx:    Transmit mailbox channel
 * @chan_rx:    Receive mailbox channel
 * @desc:       SoC description for this instance
 * @seq_nr:     Counter for number of messages sent.
 */
struct k3_sysctrler_privdata {
        struct mbox_chan chan_tx;
        struct mbox_chan chan_rx;
        struct k3_sysctrler_desc *desc;
        u32 seq_nr;
};

static inline
void k3_sysctrler_load_msg_setup(struct k3_sysctrler_load_msg *fw,
                                 struct k3_sysctrler_privdata *priv,
                                 ulong addr, ulong size)
{
        fw->hdr.cmd_id = K3_MSG_R5_TO_M3_M3FW;
        fw->hdr.host_id = priv->desc->host_id;
        fw->hdr.seq_nr = priv->seq_nr++;
        fw->hdr.flags = 0x0;
        fw->buffer_address = addr;
        fw->buffer_size = size;
}

static int k3_sysctrler_load_response(u32 *buf)
{
        struct k3_sysctrler_load_msg *fw;

        fw = (struct k3_sysctrler_load_msg *)buf;

        /* Check for proper response ID */
        if (fw->hdr.cmd_id != K3_MSG_M3_TO_R5_CERT_RESULT) {
                dev_err(dev, "%s: Command expected 0x%x, but received 0x%x\n",
                        __func__, K3_MSG_M3_TO_R5_CERT_RESULT, fw->hdr.cmd_id);
                return -EINVAL;
        }

        /* Check for certificate authentication result */
        if (fw->hdr.flags == K3_FLAGS_MSG_CERT_AUTH_FAIL) {
                dev_err(dev, "%s: Firmware certificate authentication failed\n",
                        __func__);
                return -EINVAL;
        } else if (fw->hdr.flags != K3_FLAGS_MSG_CERT_AUTH_PASS) {
                dev_err(dev, "%s: Firmware Load response Invalid %d\n",
                        __func__, fw->hdr.flags);
                return -EINVAL;
        }

        debug("%s: Firmware authentication passed\n", __func__);

        return 0;
}

static int k3_sysctrler_boot_notification_response(u32 *buf)
{
        struct k3_sysctrler_boot_notification_msg *boot;

        boot = (struct k3_sysctrler_boot_notification_msg *)buf;

        /* ToDo: Verify checksum */

        /* Check for proper response ID */
        if (boot->hdr.cmd_id != K3_MSG_M3_TO_R5_BOOT_NOTIFICATION) {
                dev_err(dev, "%s: Command expected 0x%x, but received 0x%x\n",
                        __func__, K3_MSG_M3_TO_R5_BOOT_NOTIFICATION,
                        boot->hdr.cmd_id);
                return -EINVAL;
        }

        debug("%s: Boot notification received\n", __func__);

        return 0;
}

/**
 * k3_sysctrler_load() - Loadup the K3 remote processor
 * @dev:        corresponding K3 remote processor device
 * @addr:       Address in memory where image binary is stored
 * @size:       Size in bytes of the image binary
 *
 * Return: 0 if all goes good, else appropriate error message.
 */
static int k3_sysctrler_load(struct udevice *dev, ulong addr, ulong size)
{
        struct k3_sysctrler_privdata *priv = dev_get_priv(dev);
        struct k3_sysctrler_load_msg firmware;
        struct k3_sec_proxy_msg msg;
        int ret;

        debug("%s: Loading binary from 0x%08lX, size 0x%08lX\n",
              __func__, addr, size);

        memset(&firmware, 0, sizeof(firmware));
        memset(&msg, 0, sizeof(msg));

        /* Setup the message */
        k3_sysctrler_load_msg_setup(&firmware, priv, addr, size);
        msg.len = sizeof(firmware);
        msg.buf = (u32 *)&firmware;

        /* Send the message */
        ret = mbox_send(&priv->chan_tx, &msg);
        if (ret) {
                dev_err(dev, "%s: Firmware Loading failed. ret = %d\n",
                        __func__, ret);
                return ret;
        }

        /* Receive the response */
        ret = mbox_recv(&priv->chan_rx, &msg, priv->desc->max_rx_timeout_us);
        if (ret) {
                dev_err(dev, "%s: Firmware Load response failed. ret = %d\n",
                        __func__, ret);
                return ret;
        }

        /* Process the response */
        ret = k3_sysctrler_load_response(msg.buf);
        if (ret)
                return ret;

        debug("%s: Firmware Loaded successfully on dev %s\n",
              __func__, dev->name);

        return 0;
}

/**
 * k3_sysctrler_start() - Start the remote processor
 *              Note that while technically the K3 system controller starts up
 *              automatically after its firmware got loaded we still want to
 *              utilize the rproc start operation for other startup-related
 *              tasks.
 * @dev:        device to operate upon
 *
 * Return: 0 if all went ok, else return appropriate error
 */
static int k3_sysctrler_start(struct udevice *dev)
{
        struct k3_sysctrler_privdata *priv = dev_get_priv(dev);
        struct k3_sec_proxy_msg msg;
        int ret;

        debug("%s(dev=%p)\n", __func__, dev);

        /* Receive the boot notification. Note that it is sent only once. */
        ret = mbox_recv(&priv->chan_rx, &msg, priv->desc->max_rx_timeout_us);
        if (ret) {
                dev_err(dev, "%s: Boot Notification response failed. ret = %d\n",
                        __func__, ret);
                return ret;
        }

        /* Process the response */
        ret = k3_sysctrler_boot_notification_response(msg.buf);
        if (ret)
                return ret;

        debug("%s: Boot notification received successfully on dev %s\n",
              __func__, dev->name);

        return 0;
}

static const struct dm_rproc_ops k3_sysctrler_ops = {
        .load = k3_sysctrler_load,
        .start = k3_sysctrler_start,
};

/**
 * k3_of_to_priv() - generate private data from device tree
 * @dev:        corresponding k3 remote processor device
 * @priv:       pointer to driver specific private data
 *
 * Return: 0 if all goes good, else appropriate error message.
 */
static int k3_of_to_priv(struct udevice *dev,
                         struct k3_sysctrler_privdata *priv)
{
        int ret;

        ret = mbox_get_by_name(dev, "tx", &priv->chan_tx);
        if (ret) {
                dev_err(dev, "%s: Acquiring Tx channel failed. ret = %d\n",
                        __func__, ret);
                return ret;
        }

        ret = mbox_get_by_name(dev, "rx", &priv->chan_rx);
        if (ret) {
                dev_err(dev, "%s: Acquiring Rx channel failed. ret = %d\n",
                        __func__, ret);
                return ret;
        }

        return 0;
}

/**
 * k3_sysctrler_probe() - Basic probe
 * @dev:        corresponding k3 remote processor device
 *
 * Return: 0 if all goes good, else appropriate error message.
 */
static int k3_sysctrler_probe(struct udevice *dev)
{
        struct k3_sysctrler_privdata *priv;
        int ret;

        debug("%s(dev=%p)\n", __func__, dev);

        priv = dev_get_priv(dev);

        ret = k3_of_to_priv(dev, priv);
        if (ret) {
                dev_err(dev, "%s: Probe failed with error %d\n", __func__, ret);
                return ret;
        }

        priv->desc = (void *)dev_get_driver_data(dev);
        priv->seq_nr = 0;

        return 0;
}

static const struct k3_sysctrler_desc k3_sysctrler_am654_desc = {
        .host_id = 4,                           /* HOST_ID_R5_1 */
        .max_rx_timeout_us = 800000,
        .max_msg_size = 60,
};

static const struct udevice_id k3_sysctrler_ids[] = {
        {
                .compatible = "ti,am654-system-controller",
                .data = (ulong)&k3_sysctrler_am654_desc,
        },
        {}
};

U_BOOT_DRIVER(k3_sysctrler) = {
        .name = "k3_system_controller",
        .of_match = k3_sysctrler_ids,
        .id = UCLASS_REMOTEPROC,
        .ops = &k3_sysctrler_ops,
        .probe = k3_sysctrler_probe,
        .priv_auto_alloc_size = sizeof(struct k3_sysctrler_privdata),
};