// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2023 Intel Corporation. All rights reserved.
 * Intel Visual Sensing Controller ACE Linux driver
 */

/*
 * To set ownership of camera sensor, there is specific command, which
 * is sent via MEI protocol. That's a two-step scheme where the firmware
 * first acks receipt of the command and later responses the command was
 * executed. The command sending function uses "completion" as the
 * synchronization mechanism. The notification for command is received
 * via a mei callback which wakes up the caller. There can be only one
 * outstanding command at a time.
 *
 * The power line of camera sensor is directly connected to IVSC instead
 * of host, when camera sensor ownership is switched to host, sensor is
 * already powered up by firmware.
 */

#include <linux/acpi.h>
#include <linux/completion.h>
#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/mei_cl_bus.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>
#include <linux/uuid.h>
#include <linux/workqueue.h>

/* indicating driver message */
#define ACE_DRV_MSG             1
/* indicating set command */
#define ACE_CMD_SET             4
/* command timeout determined experimentally */
#define ACE_CMD_TIMEOUT         (5 * HZ)
/* indicating the first command block */
#define ACE_CMD_INIT_BLOCK      1
/* indicating the last command block */
#define ACE_CMD_FINAL_BLOCK     1
/* size of camera status notification content */
#define ACE_CAMERA_STATUS_SIZE  5

/* UUID used to get firmware id */
#define ACE_GET_FW_ID_UUID UUID_LE(0x6167DCFB, 0x72F1, 0x4584, 0xBF, \
                                   0xE3, 0x84, 0x17, 0x71, 0xAA, 0x79, 0x0B)

/* UUID used to get csi device */
#define MEI_CSI_UUID UUID_LE(0x92335FCF, 0x3203, 0x4472, \
                             0xAF, 0x93, 0x7b, 0x44, 0x53, 0xAC, 0x29, 0xDA)

/* identify firmware event type */
enum ace_event_type {
        /* firmware ready */
        ACE_FW_READY = 0x8,

        /* command response */
        ACE_CMD_RESPONSE = 0x10,
};

/* identify camera sensor ownership */
enum ace_camera_owner {
        ACE_CAMERA_IVSC,
        ACE_CAMERA_HOST,
};

/* identify the command id supported by firmware IPC */
enum ace_cmd_id {
        /* used to switch camera sensor to host */
        ACE_SWITCH_CAMERA_TO_HOST = 0x13,

        /* used to switch camera sensor to IVSC */
        ACE_SWITCH_CAMERA_TO_IVSC = 0x14,

        /* used to get firmware id */
        ACE_GET_FW_ID = 0x1A,
};

/* ACE command header structure */
struct ace_cmd_hdr {
        u32 firmware_id : 16;
        u32 instance_id : 8;
        u32 type : 5;
        u32 rsp : 1;
        u32 msg_tgt : 1;
        u32 _hw_rsvd_1 : 1;
        u32 param_size : 20;
        u32 cmd_id : 8;
        u32 final_block : 1;
        u32 init_block : 1;
        u32 _hw_rsvd_2 : 2;
} __packed;

/* ACE command parameter structure */
union ace_cmd_param {
        uuid_le uuid;
        u32 param;
};

/* ACE command structure */
struct ace_cmd {
        struct ace_cmd_hdr hdr;
        union ace_cmd_param param;
} __packed;

/* ACE notification header */
union ace_notif_hdr {
        struct _confirm {
                u32 status : 24;
                u32 type : 5;
                u32 rsp : 1;
                u32 msg_tgt : 1;
                u32 _hw_rsvd_1 : 1;
                u32 param_size : 20;
                u32 cmd_id : 8;
                u32 final_block : 1;
                u32 init_block : 1;
                u32 _hw_rsvd_2 : 2;
        } __packed ack;

        struct _event {
                u32 rsvd1 : 16;
                u32 event_type : 8;
                u32 type : 5;
                u32 ack : 1;
                u32 msg_tgt : 1;
                u32 _hw_rsvd_1 : 1;
                u32 rsvd2 : 30;
                u32 _hw_rsvd_2 : 2;
        } __packed event;

        struct _response {
                u32 event_id : 16;
                u32 notif_type : 8;
                u32 type : 5;
                u32 rsp : 1;
                u32 msg_tgt : 1;
                u32 _hw_rsvd_1 : 1;
                u32 event_data_size : 16;
                u32 request_target : 1;
                u32 request_type : 5;
                u32 cmd_id : 8;
                u32 _hw_rsvd_2 : 2;
        } __packed response;
};

/* ACE notification content */
union ace_notif_cont {
        u16 firmware_id;
        u8 state_notif;
        u8 camera_status[ACE_CAMERA_STATUS_SIZE];
};

/* ACE notification structure */
struct ace_notif {
        union ace_notif_hdr hdr;
        union ace_notif_cont cont;
} __packed;

struct mei_ace {
        struct mei_cl_device *cldev;

        /* command ack */
        struct ace_notif cmd_ack;
        /* command response */
        struct ace_notif cmd_response;
        /* used to wait for command ack and response */
        struct completion cmd_completion;
        /* lock used to prevent multiple call to send command */
        struct mutex lock;

        /* used to construct command */
        u16 firmware_id;

        struct device *csi_dev;

        /* runtime PM link from ace to csi */
        struct device_link *csi_link;

        struct work_struct work;
};

static inline void init_cmd_hdr(struct ace_cmd_hdr *hdr)
{
        memset(hdr, 0, sizeof(struct ace_cmd_hdr));

        hdr->type = ACE_CMD_SET;
        hdr->msg_tgt = ACE_DRV_MSG;
        hdr->init_block = ACE_CMD_INIT_BLOCK;
        hdr->final_block = ACE_CMD_FINAL_BLOCK;
}

static int construct_command(struct mei_ace *ace, struct ace_cmd *cmd,
                             enum ace_cmd_id cmd_id)
{
        union ace_cmd_param *param = &cmd->param;
        struct ace_cmd_hdr *hdr = &cmd->hdr;

        init_cmd_hdr(hdr);

        hdr->cmd_id = cmd_id;
        switch (cmd_id) {
        case ACE_GET_FW_ID:
                param->uuid = ACE_GET_FW_ID_UUID;
                hdr->param_size = sizeof(param->uuid);
                break;
        case ACE_SWITCH_CAMERA_TO_IVSC:
                param->param = 0;
                hdr->firmware_id = ace->firmware_id;
                hdr->param_size = sizeof(param->param);
                break;
        case ACE_SWITCH_CAMERA_TO_HOST:
                hdr->firmware_id = ace->firmware_id;
                break;
        default:
                return -EINVAL;
        }

        return hdr->param_size + sizeof(cmd->hdr);
}

/* send command to firmware */
static int mei_ace_send(struct mei_ace *ace, struct ace_cmd *cmd,
                        size_t len, bool only_ack)
{
        union ace_notif_hdr *resp_hdr = &ace->cmd_response.hdr;
        union ace_notif_hdr *ack_hdr = &ace->cmd_ack.hdr;
        struct ace_cmd_hdr *cmd_hdr = &cmd->hdr;
        int ret;

        mutex_lock(&ace->lock);

        reinit_completion(&ace->cmd_completion);

        ret = mei_cldev_send(ace->cldev, (u8 *)cmd, len);
        if (ret < 0)
                goto out;

        ret = wait_for_completion_killable_timeout(&ace->cmd_completion,
                                                   ACE_CMD_TIMEOUT);
        if (ret < 0) {
                goto out;
        } else if (!ret) {
                ret = -ETIMEDOUT;
                goto out;
        }

        if (ack_hdr->ack.cmd_id != cmd_hdr->cmd_id) {
                ret = -EINVAL;
                goto out;
        }

        /* command ack status */
        ret = ack_hdr->ack.status;
        if (ret) {
                ret = -EIO;
                goto out;
        }

        if (only_ack)
                goto out;

        ret = wait_for_completion_killable_timeout(&ace->cmd_completion,
                                                   ACE_CMD_TIMEOUT);
        if (ret < 0) {
                goto out;
        } else if (!ret) {
                ret = -ETIMEDOUT;
                goto out;
        } else {
                ret = 0;
        }

        if (resp_hdr->response.cmd_id != cmd_hdr->cmd_id)
                ret = -EINVAL;

out:
        mutex_unlock(&ace->lock);

        return ret;
}

static int ace_set_camera_owner(struct mei_ace *ace,
                                enum ace_camera_owner owner)
{
        enum ace_cmd_id cmd_id;
        struct ace_cmd cmd;
        int cmd_size;
        int ret;

        if (owner == ACE_CAMERA_IVSC)
                cmd_id = ACE_SWITCH_CAMERA_TO_IVSC;
        else
                cmd_id = ACE_SWITCH_CAMERA_TO_HOST;

        cmd_size = construct_command(ace, &cmd, cmd_id);
        if (cmd_size >= 0)
                ret = mei_ace_send(ace, &cmd, cmd_size, false);
        else
                ret = cmd_size;

        return ret;
}

/* the first command downloaded to firmware */
static inline int ace_get_firmware_id(struct mei_ace *ace)
{
        struct ace_cmd cmd;
        int cmd_size;
        int ret;

        cmd_size = construct_command(ace, &cmd, ACE_GET_FW_ID);
        if (cmd_size >= 0)
                ret = mei_ace_send(ace, &cmd, cmd_size, true);
        else
                ret = cmd_size;

        return ret;
}

static void handle_command_response(struct mei_ace *ace,
                                    struct ace_notif *resp, int len)
{
        union ace_notif_hdr *hdr = &resp->hdr;

        switch (hdr->response.cmd_id) {
        case ACE_SWITCH_CAMERA_TO_IVSC:
        case ACE_SWITCH_CAMERA_TO_HOST:
                memcpy(&ace->cmd_response, resp, len);
                complete(&ace->cmd_completion);
                break;
        case ACE_GET_FW_ID:
                break;
        default:
                break;
        }
}

static void handle_command_ack(struct mei_ace *ace,
                               struct ace_notif *ack, int len)
{
        union ace_notif_hdr *hdr = &ack->hdr;

        switch (hdr->ack.cmd_id) {
        case ACE_GET_FW_ID:
                ace->firmware_id = ack->cont.firmware_id;
                fallthrough;
        case ACE_SWITCH_CAMERA_TO_IVSC:
        case ACE_SWITCH_CAMERA_TO_HOST:
                memcpy(&ace->cmd_ack, ack, len);
                complete(&ace->cmd_completion);
                break;
        default:
                break;
        }
}

/* callback for receive */
static void mei_ace_rx(struct mei_cl_device *cldev)
{
        struct mei_ace *ace = mei_cldev_get_drvdata(cldev);
        struct ace_notif event;
        union ace_notif_hdr *hdr = &event.hdr;
        int ret;

        ret = mei_cldev_recv(cldev, (u8 *)&event, sizeof(event));
        if (ret < 0) {
                dev_err(&cldev->dev, "recv error: %d\n", ret);
                return;
        }

        if (hdr->event.ack) {
                handle_command_ack(ace, &event, ret);
                return;
        }

        switch (hdr->event.event_type) {
        case ACE_CMD_RESPONSE:
                handle_command_response(ace, &event, ret);
                break;
        case ACE_FW_READY:
                /*
                 * firmware ready notification sent to driver
                 * after HECI client connected with firmware.
                 */
                dev_dbg(&cldev->dev, "firmware ready\n");
                break;
        default:
                break;
        }
}

static int mei_ace_setup_dev_link(struct mei_ace *ace)
{
        struct device *dev = &ace->cldev->dev;
        uuid_le uuid = MEI_CSI_UUID;
        struct device *csi_dev;
        char name[64];
        int ret;

        snprintf(name, sizeof(name), "%s-%pUl", dev_name(dev->parent), &uuid);

        csi_dev = device_find_child_by_name(dev->parent, name);
        if (!csi_dev) {
                ret = -EPROBE_DEFER;
                goto err;
        } else if (!dev_fwnode(csi_dev)) {
                ret = -EPROBE_DEFER;
                goto err_put;
        }

        /* setup link between mei_ace and mei_csi */
        ace->csi_link = device_link_add(csi_dev, dev, DL_FLAG_PM_RUNTIME |
                                        DL_FLAG_RPM_ACTIVE | DL_FLAG_STATELESS);
        put_device(csi_dev);
        if (!ace->csi_link) {
                ret = -EINVAL;
                dev_err(dev, "failed to link to %s\n", dev_name(csi_dev));
                goto err;
        }

        ace->csi_dev = csi_dev;

        return 0;

err_put:
        put_device(csi_dev);

err:
        return ret;
}

/* switch camera to host before probe sensor device */
static void mei_ace_post_probe_work(struct work_struct *work)
{
        struct acpi_device *adev;
        struct mei_ace *ace;
        struct device *dev;
        int ret;

        ace = container_of(work, struct mei_ace, work);
        dev = &ace->cldev->dev;

        ret = ace_set_camera_owner(ace, ACE_CAMERA_HOST);
        if (ret) {
                dev_err(dev, "switch camera to host failed: %d\n", ret);
                return;
        }

        adev = ACPI_COMPANION(dev->parent);
        if (!adev)
                return;

        acpi_dev_clear_dependencies(adev);
}

static int mei_ace_probe(struct mei_cl_device *cldev,
                         const struct mei_cl_device_id *id)
{
        struct device *dev = &cldev->dev;
        struct mei_ace *ace;
        int ret;

        ace = devm_kzalloc(dev, sizeof(struct mei_ace), GFP_KERNEL);
        if (!ace)
                return -ENOMEM;

        ace->cldev = cldev;
        mutex_init(&ace->lock);
        init_completion(&ace->cmd_completion);
        INIT_WORK(&ace->work, mei_ace_post_probe_work);

        mei_cldev_set_drvdata(cldev, ace);

        ret = mei_cldev_enable(cldev);
        if (ret < 0) {
                dev_err(dev, "mei_cldev_enable failed: %d\n", ret);
                goto destroy_mutex;
        }

        ret = mei_cldev_register_rx_cb(cldev, mei_ace_rx);
        if (ret) {
                dev_err(dev, "event cb registration failed: %d\n", ret);
                goto err_disable;
        }

        ret = ace_get_firmware_id(ace);
        if (ret) {
                dev_err(dev, "get firmware id failed: %d\n", ret);
                goto err_disable;
        }

        pm_runtime_set_active(dev);
        pm_runtime_enable(dev);

        ret = mei_ace_setup_dev_link(ace);
        if (ret)
                goto disable_pm;

        schedule_work(&ace->work);

        return 0;

disable_pm:
        pm_runtime_disable(dev);
        pm_runtime_set_suspended(dev);

err_disable:
        mei_cldev_disable(cldev);

destroy_mutex:
        mutex_destroy(&ace->lock);

        return ret;
}

static void mei_ace_remove(struct mei_cl_device *cldev)
{
        struct mei_ace *ace = mei_cldev_get_drvdata(cldev);

        cancel_work_sync(&ace->work);

        device_link_del(ace->csi_link);

        pm_runtime_disable(&cldev->dev);
        pm_runtime_set_suspended(&cldev->dev);

        ace_set_camera_owner(ace, ACE_CAMERA_IVSC);

        mei_cldev_disable(cldev);

        mutex_destroy(&ace->lock);
}

static int __maybe_unused mei_ace_runtime_suspend(struct device *dev)
{
        struct mei_ace *ace = dev_get_drvdata(dev);

        return ace_set_camera_owner(ace, ACE_CAMERA_IVSC);
}

static int __maybe_unused mei_ace_runtime_resume(struct device *dev)
{
        struct mei_ace *ace = dev_get_drvdata(dev);

        return ace_set_camera_owner(ace, ACE_CAMERA_HOST);
}

static const struct dev_pm_ops mei_ace_pm_ops = {
        SET_RUNTIME_PM_OPS(mei_ace_runtime_suspend,
                           mei_ace_runtime_resume, NULL)
};

#define MEI_ACE_UUID UUID_LE(0x5DB76CF6, 0x0A68, 0x4ED6, \
                             0x9B, 0x78, 0x03, 0x61, 0x63, 0x5E, 0x24, 0x47)

static const struct mei_cl_device_id mei_ace_tbl[] = {
        { .uuid = MEI_ACE_UUID, .version = MEI_CL_VERSION_ANY },
        { /* sentinel */ }
};
MODULE_DEVICE_TABLE(mei, mei_ace_tbl);

static struct mei_cl_driver mei_ace_driver = {
        .id_table = mei_ace_tbl,
        .name = KBUILD_MODNAME,

        .probe = mei_ace_probe,
        .remove = mei_ace_remove,

        .driver = {
                .pm = &mei_ace_pm_ops,
        },
};

module_mei_cl_driver(mei_ace_driver);

MODULE_AUTHOR("Wentong Wu");
MODULE_AUTHOR("Zhifeng Wang <zhifeng.wang@intel.com>");
MODULE_DESCRIPTION("Device driver for IVSC ACE");
MODULE_LICENSE("GPL");