// SPDX-License-Identifier: GPL-2.0
/*
 * BOOTROM Greybus driver.
 *
 * Copyright 2016 Google Inc.
 * Copyright 2016 Linaro Ltd.
 */

#include <linux/firmware.h>
#include <linux/jiffies.h>
#include <linux/mutex.h>
#include <linux/workqueue.h>

#include "greybus.h"
#include "firmware.h"

/* Timeout, in jiffies, within which the next request must be received */
#define NEXT_REQ_TIMEOUT_MS     1000

/*
 * FIXME: Reduce this timeout once svc core handles parallel processing of
 * events from the SVC, which are handled sequentially today.
 */
#define MODE_SWITCH_TIMEOUT_MS  10000

enum next_request_type {
        NEXT_REQ_FIRMWARE_SIZE,
        NEXT_REQ_GET_FIRMWARE,
        NEXT_REQ_READY_TO_BOOT,
        NEXT_REQ_MODE_SWITCH,
};

struct gb_bootrom {
        struct gb_connection    *connection;
        const struct firmware   *fw;
        u8                      protocol_major;
        u8                      protocol_minor;
        enum next_request_type  next_request;
        struct delayed_work     dwork;
        struct mutex            mutex; /* Protects bootrom->fw */
};

static void free_firmware(struct gb_bootrom *bootrom)
{
        if (!bootrom->fw)
                return;

        release_firmware(bootrom->fw);
        bootrom->fw = NULL;
}

static void gb_bootrom_timedout(struct work_struct *work)
{
        struct delayed_work *dwork = to_delayed_work(work);
        struct gb_bootrom *bootrom = container_of(dwork,
                                                  struct gb_bootrom, dwork);
        struct device *dev = &bootrom->connection->bundle->dev;
        const char *reason;

        switch (bootrom->next_request) {
        case NEXT_REQ_FIRMWARE_SIZE:
                reason = "Firmware Size Request";
                break;
        case NEXT_REQ_GET_FIRMWARE:
                reason = "Get Firmware Request";
                break;
        case NEXT_REQ_READY_TO_BOOT:
                reason = "Ready to Boot Request";
                break;
        case NEXT_REQ_MODE_SWITCH:
                reason = "Interface Mode Switch";
                break;
        default:
                reason = NULL;
                dev_err(dev, "Invalid next-request: %u", bootrom->next_request);
                break;
        }

        dev_err(dev, "Timed out waiting for %s from the Module\n", reason);

        mutex_lock(&bootrom->mutex);
        free_firmware(bootrom);
        mutex_unlock(&bootrom->mutex);

        /* TODO: Power-off Module ? */
}

static void gb_bootrom_set_timeout(struct gb_bootrom *bootrom,
                        enum next_request_type next, unsigned long timeout)
{
        bootrom->next_request = next;
        schedule_delayed_work(&bootrom->dwork, msecs_to_jiffies(timeout));
}

static void gb_bootrom_cancel_timeout(struct gb_bootrom *bootrom)
{
        cancel_delayed_work_sync(&bootrom->dwork);
}

/*
 * The es2 chip doesn't have VID/PID programmed into the hardware and we need to
 * hack that up to distinguish different modules and their firmware blobs.
 *
 * This fetches VID/PID (over bootrom protocol) for es2 chip only, when VID/PID
 * already sent during hotplug are 0.
 *
 * Otherwise, we keep intf->vendor_id/product_id same as what's passed
 * during hotplug.
 */
static void bootrom_es2_fixup_vid_pid(struct gb_bootrom *bootrom)
{
        struct gb_bootrom_get_vid_pid_response response;
        struct gb_connection *connection = bootrom->connection;
        struct gb_interface *intf = connection->bundle->intf;
        int ret;

        if (!(intf->quirks & GB_INTERFACE_QUIRK_NO_GMP_IDS))
                return;

        ret = gb_operation_sync(connection, GB_BOOTROM_TYPE_GET_VID_PID,
                                NULL, 0, &response, sizeof(response));
        if (ret) {
                dev_err(&connection->bundle->dev,
                        "Bootrom get vid/pid operation failed (%d)\n", ret);
                return;
        }

        /*
         * NOTE: This is hacked, so that the same values of VID/PID can be used
         * by next firmware level as well. The uevent for bootrom will still
         * have VID/PID as 0, though after this point the sysfs files will start
         * showing the updated values. But yeah, that's a bit racy as the same
         * sysfs files would be showing 0 before this point.
         */
        intf->vendor_id = le32_to_cpu(response.vendor_id);
        intf->product_id = le32_to_cpu(response.product_id);

        dev_dbg(&connection->bundle->dev, "Bootrom got vid (0x%x)/pid (0x%x)\n",
                intf->vendor_id, intf->product_id);
}

/* This returns path of the firmware blob on the disk */
static int find_firmware(struct gb_bootrom *bootrom, u8 stage)
{
        struct gb_connection *connection = bootrom->connection;
        struct gb_interface *intf = connection->bundle->intf;
        char firmware_name[49];
        int rc;

        /* Already have a firmware, free it */
        free_firmware(bootrom);

        /* Bootrom protocol is only supported for loading Stage 2 firmware */
        if (stage != 2) {
                dev_err(&connection->bundle->dev, "Invalid boot stage: %u\n",
                        stage);
                return -EINVAL;
        }

        /*
         * Create firmware name
         *
         * XXX Name it properly..
         */
        snprintf(firmware_name, sizeof(firmware_name),
                 FW_NAME_PREFIX "%08x_%08x_%08x_%08x_s2l.tftf",
                 intf->ddbl1_manufacturer_id, intf->ddbl1_product_id,
                 intf->vendor_id, intf->product_id);

        // FIXME:
        // Turn to dev_dbg later after everyone has valid bootloaders with good
        // ids, but leave this as dev_info for now to make it easier to track
        // down "empty" vid/pid modules.
        dev_info(&connection->bundle->dev, "Firmware file '%s' requested\n",
                 firmware_name);

        rc = request_firmware(&bootrom->fw, firmware_name,
                &connection->bundle->dev);
        if (rc) {
                dev_err(&connection->bundle->dev,
                        "failed to find %s firmware (%d)\n", firmware_name, rc);
        }

        return rc;
}

static int gb_bootrom_firmware_size_request(struct gb_operation *op)
{
        struct gb_bootrom *bootrom = gb_connection_get_data(op->connection);
        struct gb_bootrom_firmware_size_request *size_request =
                op->request->payload;
        struct gb_bootrom_firmware_size_response *size_response;
        struct device *dev = &op->connection->bundle->dev;
        int ret;

        /* Disable timeouts */
        gb_bootrom_cancel_timeout(bootrom);

        if (op->request->payload_size != sizeof(*size_request)) {
                dev_err(dev, "%s: illegal size of firmware size request (%zu != %zu)\n",
                        __func__, op->request->payload_size,
                        sizeof(*size_request));
                ret = -EINVAL;
                goto queue_work;
        }

        mutex_lock(&bootrom->mutex);

        ret = find_firmware(bootrom, size_request->stage);
        if (ret)
                goto unlock;

        if (!gb_operation_response_alloc(op, sizeof(*size_response),
                                         GFP_KERNEL)) {
                dev_err(dev, "%s: error allocating response\n", __func__);
                free_firmware(bootrom);
                ret = -ENOMEM;
                goto unlock;
        }

        size_response = op->response->payload;
        size_response->size = cpu_to_le32(bootrom->fw->size);

        dev_dbg(dev, "%s: firmware size %d bytes\n",
                __func__, size_response->size);

unlock:
        mutex_unlock(&bootrom->mutex);

queue_work:
        if (!ret) {
                /* Refresh timeout */
                gb_bootrom_set_timeout(bootrom, NEXT_REQ_GET_FIRMWARE,
                                       NEXT_REQ_TIMEOUT_MS);
        }

        return ret;
}

static int gb_bootrom_get_firmware(struct gb_operation *op)
{
        struct gb_bootrom *bootrom = gb_connection_get_data(op->connection);
        const struct firmware *fw;
        struct gb_bootrom_get_firmware_request *firmware_request;
        struct gb_bootrom_get_firmware_response *firmware_response;
        struct device *dev = &op->connection->bundle->dev;
        unsigned int offset, size;
        enum next_request_type next_request;
        int ret = 0;

        /* Disable timeouts */
        gb_bootrom_cancel_timeout(bootrom);

        if (op->request->payload_size != sizeof(*firmware_request)) {
                dev_err(dev, "%s: Illegal size of get firmware request (%zu %zu)\n",
                        __func__, op->request->payload_size,
                        sizeof(*firmware_request));
                ret = -EINVAL;
                goto queue_work;
        }

        mutex_lock(&bootrom->mutex);

        fw = bootrom->fw;
        if (!fw) {
                dev_err(dev, "%s: firmware not available\n", __func__);
                ret = -EINVAL;
                goto unlock;
        }

        firmware_request = op->request->payload;
        offset = le32_to_cpu(firmware_request->offset);
        size = le32_to_cpu(firmware_request->size);

        if (offset >= fw->size || size > fw->size - offset) {
                dev_warn(dev, "bad firmware request (offs = %u, size = %u)\n",
                                offset, size);
                ret = -EINVAL;
                goto unlock;
        }

        if (!gb_operation_response_alloc(op, sizeof(*firmware_response) + size,
                                         GFP_KERNEL)) {
                dev_err(dev, "%s: error allocating response\n", __func__);
                ret = -ENOMEM;
                goto unlock;
        }

        firmware_response = op->response->payload;
        memcpy(firmware_response->data, fw->data + offset, size);

        dev_dbg(dev, "responding with firmware (offs = %u, size = %u)\n",
                offset, size);

unlock:
        mutex_unlock(&bootrom->mutex);

queue_work:
        /* Refresh timeout */
        if (!ret && (offset + size == fw->size))
                next_request = NEXT_REQ_READY_TO_BOOT;
        else
                next_request = NEXT_REQ_GET_FIRMWARE;

        gb_bootrom_set_timeout(bootrom, next_request, NEXT_REQ_TIMEOUT_MS);

        return ret;
}

static int gb_bootrom_ready_to_boot(struct gb_operation *op)
{
        struct gb_connection *connection = op->connection;
        struct gb_bootrom *bootrom = gb_connection_get_data(connection);
        struct gb_bootrom_ready_to_boot_request *rtb_request;
        struct device *dev = &connection->bundle->dev;
        u8 status;
        int ret = 0;

        /* Disable timeouts */
        gb_bootrom_cancel_timeout(bootrom);

        if (op->request->payload_size != sizeof(*rtb_request)) {
                dev_err(dev, "%s: Illegal size of ready to boot request (%zu %zu)\n",
                        __func__, op->request->payload_size,
                        sizeof(*rtb_request));
                ret = -EINVAL;
                goto queue_work;
        }

        rtb_request = op->request->payload;
        status = rtb_request->status;

        /* Return error if the blob was invalid */
        if (status == GB_BOOTROM_BOOT_STATUS_INVALID) {
                ret = -EINVAL;
                goto queue_work;
        }

        /*
         * XXX Should we return error for insecure firmware?
         */
        dev_dbg(dev, "ready to boot: 0x%x, 0\n", status);

queue_work:
        /*
         * Refresh timeout, the Interface shall load the new personality and
         * send a new hotplug request, which shall get rid of the bootrom
         * connection. As that can take some time, increase the timeout a bit.
         */
        gb_bootrom_set_timeout(bootrom, NEXT_REQ_MODE_SWITCH,
                               MODE_SWITCH_TIMEOUT_MS);

        return ret;
}

static int gb_bootrom_request_handler(struct gb_operation *op)
{
        u8 type = op->type;

        switch (type) {
        case GB_BOOTROM_TYPE_FIRMWARE_SIZE:
                return gb_bootrom_firmware_size_request(op);
        case GB_BOOTROM_TYPE_GET_FIRMWARE:
                return gb_bootrom_get_firmware(op);
        case GB_BOOTROM_TYPE_READY_TO_BOOT:
                return gb_bootrom_ready_to_boot(op);
        default:
                dev_err(&op->connection->bundle->dev,
                        "unsupported request: %u\n", type);
                return -EINVAL;
        }
}

static int gb_bootrom_get_version(struct gb_bootrom *bootrom)
{
        struct gb_bundle *bundle = bootrom->connection->bundle;
        struct gb_bootrom_version_request request;
        struct gb_bootrom_version_response response;
        int ret;

        request.major = GB_BOOTROM_VERSION_MAJOR;
        request.minor = GB_BOOTROM_VERSION_MINOR;

        ret = gb_operation_sync(bootrom->connection,
                                GB_BOOTROM_TYPE_VERSION,
                                &request, sizeof(request), &response,
                                sizeof(response));
        if (ret) {
                dev_err(&bundle->dev,
                                "failed to get protocol version: %d\n",
                                ret);
                return ret;
        }

        if (response.major > request.major) {
                dev_err(&bundle->dev,
                                "unsupported major protocol version (%u > %u)\n",
                                response.major, request.major);
                return -ENOTSUPP;
        }

        bootrom->protocol_major = response.major;
        bootrom->protocol_minor = response.minor;

        dev_dbg(&bundle->dev, "%s - %u.%u\n", __func__, response.major,
                        response.minor);

        return 0;
}

static int gb_bootrom_probe(struct gb_bundle *bundle,
                                        const struct greybus_bundle_id *id)
{
        struct greybus_descriptor_cport *cport_desc;
        struct gb_connection *connection;
        struct gb_bootrom *bootrom;
        int ret;

        if (bundle->num_cports != 1)
                return -ENODEV;

        cport_desc = &bundle->cport_desc[0];
        if (cport_desc->protocol_id != GREYBUS_PROTOCOL_BOOTROM)
                return -ENODEV;

        bootrom = kzalloc(sizeof(*bootrom), GFP_KERNEL);
        if (!bootrom)
                return -ENOMEM;

        connection = gb_connection_create(bundle,
                                                le16_to_cpu(cport_desc->id),
                                                gb_bootrom_request_handler);
        if (IS_ERR(connection)) {
                ret = PTR_ERR(connection);
                goto err_free_bootrom;
        }

        gb_connection_set_data(connection, bootrom);

        bootrom->connection = connection;

        mutex_init(&bootrom->mutex);
        INIT_DELAYED_WORK(&bootrom->dwork, gb_bootrom_timedout);
        greybus_set_drvdata(bundle, bootrom);

        ret = gb_connection_enable_tx(connection);
        if (ret)
                goto err_connection_destroy;

        ret = gb_bootrom_get_version(bootrom);
        if (ret)
                goto err_connection_disable;

        bootrom_es2_fixup_vid_pid(bootrom);

        ret = gb_connection_enable(connection);
        if (ret)
                goto err_connection_disable;

        /* Refresh timeout */
        gb_bootrom_set_timeout(bootrom, NEXT_REQ_FIRMWARE_SIZE,
                               NEXT_REQ_TIMEOUT_MS);

        /* Tell bootrom we're ready. */
        ret = gb_operation_sync(connection, GB_BOOTROM_TYPE_AP_READY, NULL, 0,
                                NULL, 0);
        if (ret) {
                dev_err(&connection->bundle->dev,
                                "failed to send AP READY: %d\n", ret);
                goto err_cancel_timeout;
        }

        dev_dbg(&bundle->dev, "AP_READY sent\n");

        return 0;

err_cancel_timeout:
        gb_bootrom_cancel_timeout(bootrom);
err_connection_disable:
        gb_connection_disable(connection);
err_connection_destroy:
        gb_connection_destroy(connection);
err_free_bootrom:
        kfree(bootrom);

        return ret;
}

static void gb_bootrom_disconnect(struct gb_bundle *bundle)
{
        struct gb_bootrom *bootrom = greybus_get_drvdata(bundle);

        dev_dbg(&bundle->dev, "%s\n", __func__);

        gb_connection_disable(bootrom->connection);

        /* Disable timeouts */
        gb_bootrom_cancel_timeout(bootrom);

        /*
         * Release firmware:
         *
         * As the connection and the delayed work are already disabled, we don't
         * need to lock access to bootrom->fw here.
         */
        free_firmware(bootrom);

        gb_connection_destroy(bootrom->connection);
        kfree(bootrom);
}

static const struct greybus_bundle_id gb_bootrom_id_table[] = {
        { GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_BOOTROM) },
        { }
};

static struct greybus_driver gb_bootrom_driver = {
        .name           = "bootrom",
        .probe          = gb_bootrom_probe,
        .disconnect     = gb_bootrom_disconnect,
        .id_table       = gb_bootrom_id_table,
};

module_greybus_driver(gb_bootrom_driver);

MODULE_LICENSE("GPL v2");