// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2019, The Linux Foundation. All rights reserved.
 */

#include <linux/dma-mapping.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/mhi.h>
#include <linux/mutex.h>
#include <dsp/voice_mhi.h>
#include <dsp/msm_audio_ion.h>
#include <dsp/audio_notifier.h>
#include <dsp/q6core.h>
#include <dsp/audio_notifier.h>
#include <ipc/apr.h>
#include "adsp_err.h"

#define VSS_IPKTEXG_CMD_SET_MAILBOX_MEMORY_CONFIG	0x0001333B

#define VOICE_MHI_STATE_SET(a, b) ((a) |= (1UL<<(b)))
#define VOICE_MHI_STATE_RESET(a, b) ((a) &= ~(1UL<<(b)))
#define VOICE_MHI_STATE_CHECK(a, b) (1UL & (a >> b))

#define CMD_STATUS_SUCCESS 0
#define CMD_STATUS_FAIL 1
#define TIMEOUT_MS 500
#define PORT_NUM 0x01
#define PORT_MASK 0x03
#define CONVERT_PORT_APR(x, y) (x << 8 | y)

enum voice_states {
	VOICE_MHI_INIT = 0,
	VOICE_MHI_PROBED = VOICE_MHI_INIT,
	VOICE_MHI_ADSP_UP,
	VOICE_MHI_SDX_UP,
	VOICE_MHI_INCALL
};

struct voice_mhi_addr {
	dma_addr_t base;
	uint32_t size;
};

struct voice_mhi_dev_info {
	struct platform_device *pdev;
	struct voice_mhi_addr phys_addr;
	struct voice_mhi_addr iova_pcie;
	struct voice_mhi_addr iova_adsp;
};

struct voice_mhi {
	struct voice_mhi_dev_info dev_info;
	struct mhi_device *mhi_dev;
	uint32_t vote_count;
	struct mutex mutex;
	enum voice_states voice_mhi_state;
	bool vote_enable;
	bool pcie_enabled;
	void *apr_mvm_handle;
	struct work_struct voice_mhi_work_pcie;
	struct work_struct voice_mhi_work_adsp;
	wait_queue_head_t voice_mhi_wait;
	u32 mvm_state;
	u32 async_err;
};

struct vss_ipktexg_cmd_set_mailbox_memory_config_t {
	struct apr_hdr hdr;
	uint64_t mailbox_mem_address_adsp;
	/*
	 * IOVA of mailbox memory for ADSP access
	 */
	uint64_t mailbox_mem_address_pcie;
	/*
	 * IOVA of mailbox memory for PCIe access
	 */
	uint32_t mem_size;
	/*
	 * Size of mailbox memory allocated
	 */
} __packed;

static struct voice_mhi voice_mhi_lcl;

static int voice_mhi_pcie_up_callback(struct mhi_device *,
					const struct mhi_device_id *);
static void voice_mhi_pcie_down_callback(struct mhi_device *);
static void voice_mhi_pcie_status_callback(struct mhi_device *, enum MHI_CB);
static int32_t voice_mhi_apr_callback(struct apr_client_data *data, void *priv);
static int voice_mhi_notifier_service_cb(struct notifier_block *nb,
					 unsigned long opcode, void *ptr);
static int voice_mhi_apr_register(void);

static struct notifier_block voice_mhi_service_nb = {
	.notifier_call  = voice_mhi_notifier_service_cb,
	.priority = -INT_MAX,
};

static const struct mhi_device_id voice_mhi_match_table[] = {
	{ .chan = "AUDIO_VOICE_0", .driver_data = 0 },
	{},
};

static struct mhi_driver voice_mhi_driver = {
	.id_table = voice_mhi_match_table,
	.probe = voice_mhi_pcie_up_callback,
	.remove = voice_mhi_pcie_down_callback,
	.status_cb = voice_mhi_pcie_status_callback,
	.driver = {
		.name = "voice_mhi_audio",
		.owner = THIS_MODULE,
	},
};

static int voice_mhi_notifier_service_cb(struct notifier_block *nb,
					 unsigned long opcode, void *ptr)
{
	pr_debug("%s: opcode 0x%lx\n", __func__, opcode);

	switch (opcode) {
	case AUDIO_NOTIFIER_SERVICE_DOWN:
		if (voice_mhi_lcl.apr_mvm_handle) {
			apr_reset(voice_mhi_lcl.apr_mvm_handle);
			voice_mhi_lcl.apr_mvm_handle = NULL;
			VOICE_MHI_STATE_RESET(voice_mhi_lcl.voice_mhi_state,
					VOICE_MHI_ADSP_UP);
		}
		break;
	case AUDIO_NOTIFIER_SERVICE_UP:
		if (!VOICE_MHI_STATE_CHECK(voice_mhi_lcl.voice_mhi_state,
				VOICE_MHI_ADSP_UP)) {
			VOICE_MHI_STATE_SET(voice_mhi_lcl.voice_mhi_state,
					VOICE_MHI_ADSP_UP);
			schedule_work(&voice_mhi_lcl.voice_mhi_work_adsp);
		}
		break;
	default:
		break;
	}

	return NOTIFY_OK;

}

static int32_t voice_mhi_apr_callback(struct apr_client_data *data, void *priv)
{
	uint32_t *ptr1;

	if (data == NULL) {
		pr_err("%s: data is NULL\n", __func__);
		return -EINVAL;
	}

	pr_debug("%s: Payload Length = %d, opcode=%x\n", __func__,
		data->payload_size, data->opcode);

	switch (data->opcode) {
	case APR_BASIC_RSP_RESULT:
		if (data->payload_size < 2 * sizeof(uint32_t)) {
			pr_err("%s: APR_BASIC_RSP_RESULT payload less than expected\n",
					__func__);
			return 0;
		}
		ptr1 = data->payload;
		switch (ptr1[0]) {
		case VSS_IPKTEXG_CMD_SET_MAILBOX_MEMORY_CONFIG:
			pr_debug("%s: cmd VSS_IPKTEXG_CMD_SET_MAILBOX_MEMORY_CONFIG\n",
					 __func__);
			voice_mhi_lcl.mvm_state = CMD_STATUS_SUCCESS;
			voice_mhi_lcl.async_err = ptr1[1];
			wake_up(&voice_mhi_lcl.voice_mhi_wait);
			break;
		default:
			pr_err("%s: Invalid cmd response 0x%x 0x%x\n", __func__,
				ptr1[0], ptr1[1]);
			break;
		}
		break;
	case APR_RSP_ACCEPTED:
		if (data->payload_size < sizeof(uint32_t)) {
			pr_err("%s: APR_RSP_ACCEPTED payload less than expected\n",
					__func__);
			return 0;
		}
		ptr1 = data->payload;
		if (ptr1[0])
			pr_debug("%s: APR_RSP_ACCEPTED for 0x%x:\n",
				 __func__, ptr1[0]);
		break;
	case RESET_EVENTS:
		/* Should we handle here or audio notifier down? */
		if (voice_mhi_lcl.apr_mvm_handle) {
			apr_reset(voice_mhi_lcl.apr_mvm_handle);
			voice_mhi_lcl.apr_mvm_handle = NULL;
			VOICE_MHI_STATE_RESET(voice_mhi_lcl.voice_mhi_state,
					VOICE_MHI_ADSP_UP);
		}
		break;
	default:
		pr_err("%s: Invalid opcode %d\n", __func__,
				data->opcode);
		break;

	}
	return 0;
}

/**
 * voice_mhi_start -
 *        Start vote for MHI/PCIe clock
 *
 * Returns 0 on success or error on failure
 */
int voice_mhi_start(void)
{
	int ret = 0;

	mutex_lock(&voice_mhi_lcl.mutex);
	if (voice_mhi_lcl.pcie_enabled) {
		if (!voice_mhi_lcl.mhi_dev) {
			pr_err("%s: NULL device found\n", __func__);
			ret = -EINVAL;
			goto done;
		}
		if (voice_mhi_lcl.vote_count == 0) {
			ret = mhi_device_get_sync(voice_mhi_lcl.mhi_dev,
					MHI_VOTE_DEVICE);
			if (ret) {
				pr_err("%s: mhi_device_get_sync failed\n",
					   __func__);
				ret = -EINVAL;
				goto done;
			}
			pr_debug("%s: mhi_device_get_sync success\n", __func__);
		} else {
			/* For DSDA, no additional voting is needed */
			pr_debug("%s: mhi is already voted\n", __func__);
		}
		voice_mhi_lcl.vote_count++;
	} else {
		/* PCIe not supported - return success*/
		goto done;
	}
done:
	mutex_unlock(&voice_mhi_lcl.mutex);

	return ret;
}
EXPORT_SYMBOL(voice_mhi_start);

/**
 * voice_mhi_end -
 *        End vote for MHI/PCIe clock
 *
 * Returns 0 on success or error on failure
 */
int voice_mhi_end(void)
{
	mutex_lock(&voice_mhi_lcl.mutex);
	if (voice_mhi_lcl.pcie_enabled) {
		if (!voice_mhi_lcl.mhi_dev || voice_mhi_lcl.vote_count == 0) {
			pr_err("%s: NULL device found\n", __func__);
			mutex_unlock(&voice_mhi_lcl.mutex);
			return -EINVAL;
		}

		if (voice_mhi_lcl.vote_count == 1)
			mhi_device_put(voice_mhi_lcl.mhi_dev, MHI_VOTE_DEVICE);
		voice_mhi_lcl.vote_count--;
	}
	mutex_unlock(&voice_mhi_lcl.mutex);

	return 0;
}
EXPORT_SYMBOL(voice_mhi_end);

static int voice_mhi_set_mailbox_memory_config(void)
{
	struct vss_ipktexg_cmd_set_mailbox_memory_config_t mb_memory_config;
	int ret = 0;
	void *apr_mvm;

	if (!voice_mhi_lcl.apr_mvm_handle) {
		pr_err("%s: APR handle is NULL\n", __func__);
		return -EINVAL;
	}

	memset(&mb_memory_config, 0, sizeof(mb_memory_config));
	mb_memory_config.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
						APR_HDR_LEN(APR_HDR_SIZE),
						APR_PKT_VER);
	mb_memory_config.hdr.pkt_size = APR_PKT_SIZE(APR_HDR_SIZE,
				sizeof(mb_memory_config) - APR_HDR_SIZE);
	pr_debug("%s: pkt size = %d\n", __func__,
			 mb_memory_config.hdr.pkt_size);

	mutex_lock(&voice_mhi_lcl.mutex);
	apr_mvm = voice_mhi_lcl.apr_mvm_handle;

	/*
	 * Handle can be NULL as it is not tied to any session
	 */
	mb_memory_config.hdr.src_port = CONVERT_PORT_APR(PORT_NUM, PORT_MASK);
	mb_memory_config.hdr.dest_port = 0;
	mb_memory_config.hdr.token = 0;
	mb_memory_config.hdr.opcode = VSS_IPKTEXG_CMD_SET_MAILBOX_MEMORY_CONFIG;
	mb_memory_config.mailbox_mem_address_pcie =
			voice_mhi_lcl.dev_info.iova_pcie.base;
	mb_memory_config.mailbox_mem_address_adsp =
			voice_mhi_lcl.dev_info.iova_adsp.base;
	mb_memory_config.mem_size = voice_mhi_lcl.dev_info.iova_adsp.size;
	voice_mhi_lcl.mvm_state = CMD_STATUS_FAIL;
	voice_mhi_lcl.async_err = 0;

	ret = apr_send_pkt(apr_mvm, (uint32_t *) &mb_memory_config);
	if (ret < 0) {
		pr_err("%s: Set mailbox memory config failed ret = %d\n",
				__func__, ret);
		goto unlock;
	}

	ret = wait_event_timeout(voice_mhi_lcl.voice_mhi_wait,
				 (voice_mhi_lcl.mvm_state ==
				 CMD_STATUS_SUCCESS),
				 msecs_to_jiffies(TIMEOUT_MS));
	if (!ret) {
		pr_err("%s: wait_event timeout\n", __func__);
		ret = -ETIME;
		goto unlock;
	}
	if (voice_mhi_lcl.async_err > 0) {
		pr_err("%s: DSP returned error[%d]\n",
				__func__, voice_mhi_lcl.async_err);
		ret = voice_mhi_lcl.async_err;
		goto unlock;
	}
	ret = 0;
unlock:
	mutex_unlock(&voice_mhi_lcl.mutex);
	return ret;
}

static void voice_mhi_map_pcie_and_send(struct work_struct *work)
{
	dma_addr_t iova, phys_addr;
	uint32_t mem_size;
	struct device *md;

	mutex_lock(&voice_mhi_lcl.mutex);
	if (voice_mhi_lcl.mhi_dev) {
		md = &voice_mhi_lcl.mhi_dev->dev;
	} else {
		pr_err("%s: MHI device handle is NULL\n", __func__);
		goto err;
	}

	phys_addr = voice_mhi_lcl.dev_info.phys_addr.base;
	mem_size = voice_mhi_lcl.dev_info.iova_pcie.size;
	if (md) {
		iova = dma_map_resource(md->parent, phys_addr, mem_size,
					DMA_BIDIRECTIONAL, 0);
		if (dma_mapping_error(md->parent, iova)) {
			pr_err("%s: dma_mapping_error\n", __func__);
			goto err;
		}
		pr_debug("%s: dma_mapping_success iova:0x%lx\n",
				 __func__, (unsigned long)iova);
		voice_mhi_lcl.dev_info.iova_pcie.base = iova;

		if (q6core_is_adsp_ready()) {
			if (VOICE_MHI_STATE_CHECK(voice_mhi_lcl.voice_mhi_state,
					VOICE_MHI_SDX_UP)) {
				mutex_unlock(&voice_mhi_lcl.mutex);
				voice_mhi_set_mailbox_memory_config();
				return;
			}
		}
	}

err:
	mutex_unlock(&voice_mhi_lcl.mutex);
}

static void voice_mhi_register_apr_and_send(struct work_struct *work)
{
	int ret = 0;

	ret = voice_mhi_apr_register();
	if (ret) {
		pr_err("%s: APR registration failed %d\n", __func__, ret);
		return;
	}
	mutex_lock(&voice_mhi_lcl.mutex);
	if (q6core_is_adsp_ready()) {
		if (VOICE_MHI_STATE_CHECK(voice_mhi_lcl.voice_mhi_state,
				VOICE_MHI_SDX_UP)) {
			mutex_unlock(&voice_mhi_lcl.mutex);
			voice_mhi_set_mailbox_memory_config();
			return;
		}
	}
	mutex_unlock(&voice_mhi_lcl.mutex);
}

static int voice_mhi_pcie_up_callback(struct mhi_device *voice_mhi_dev,
				const struct mhi_device_id *id)
{

	if ((!voice_mhi_dev) || (id != &voice_mhi_match_table[0])) {
		pr_err("%s: Invalid device or table received\n", __func__);
		return -EINVAL;
	}
	pr_debug("%s: MHI PCIe UP callback\n", __func__);
	mutex_lock(&voice_mhi_lcl.mutex);
	voice_mhi_lcl.mhi_dev = voice_mhi_dev;
	VOICE_MHI_STATE_SET(voice_mhi_lcl.voice_mhi_state, VOICE_MHI_SDX_UP);
	mutex_unlock(&voice_mhi_lcl.mutex);
	schedule_work(&voice_mhi_lcl.voice_mhi_work_pcie);
	return 0;
}

static void voice_mhi_pcie_down_callback(struct mhi_device *voice_mhi_dev)
{
	dma_addr_t iova;
	struct device *md = NULL;

	mutex_lock(&voice_mhi_lcl.mutex);

	if (voice_mhi_lcl.mhi_dev)
		md = &voice_mhi_lcl.mhi_dev->dev;

	VOICE_MHI_STATE_RESET(voice_mhi_lcl.voice_mhi_state, VOICE_MHI_SDX_UP);
	iova = voice_mhi_lcl.dev_info.iova_pcie.base;

	if (md)
		dma_unmap_resource(md->parent, iova, PAGE_SIZE,
				   DMA_BIDIRECTIONAL, 0);

	voice_mhi_lcl.mhi_dev = NULL;
	voice_mhi_lcl.vote_count = 0;
	mutex_unlock(&voice_mhi_lcl.mutex);
}

static void voice_mhi_pcie_status_callback(struct mhi_device *voice_mhi_dev,
					enum MHI_CB mhi_cb)
{

}

static int voice_mhi_apr_register(void)
{
	int ret = 0;

	mutex_lock(&voice_mhi_lcl.mutex);
	voice_mhi_lcl.apr_mvm_handle = apr_register("ADSP", "MVM",
						(apr_fn)voice_mhi_apr_callback,
						CONVERT_PORT_APR(PORT_NUM,
							PORT_MASK),
						&voice_mhi_lcl);
	if (voice_mhi_lcl.apr_mvm_handle == NULL) {
		pr_err("%s: error in APR register\n", __func__);
		ret = -ENODEV;
	}
	mutex_unlock(&voice_mhi_lcl.mutex);

	return ret;
}

static int voice_mhi_probe(struct platform_device *pdev)
{
	int ret = 0;
	struct device_node *node;
	uint32_t mem_size = 0;
	void *ptr;
	dma_addr_t phys_addr, iova;
	const __be32 *cell;

	pr_debug("%s:\n", __func__);

	INIT_WORK(&voice_mhi_lcl.voice_mhi_work_pcie,
				voice_mhi_map_pcie_and_send);
	INIT_WORK(&voice_mhi_lcl.voice_mhi_work_adsp,
				voice_mhi_register_apr_and_send);
	init_waitqueue_head(&voice_mhi_lcl.voice_mhi_wait);

	node = of_parse_phandle(pdev->dev.of_node, "memory-region", 0);
	if (node) {
		cell = of_get_property(node, "size", NULL);
		if (cell)
			mem_size = of_read_number(cell, 2);
		else {
			pr_err("%s: cell not found\n", __func__);
			ret = -EINVAL;
			goto done;
		}
	} else {
		pr_err("%s: Node read failed\n", __func__);
		ret = -EINVAL;
		goto done;
	}

	pr_debug("%s: mem_size = %d\n", __func__, mem_size);

	if (mem_size) {
		ptr = dma_alloc_attrs(&pdev->dev, mem_size, &phys_addr,
					GFP_KERNEL, DMA_ATTR_NO_KERNEL_MAPPING);
		if (IS_ERR_OR_NULL(ptr)) {
			pr_err("%s: Memory alloc failed\n", __func__);
			ret = -ENOMEM;
			goto done;
		} else {
			pr_debug("%s: Memory alloc success phys_addr:0x%lx\n",
					 __func__, (unsigned long)phys_addr);
		}

		ret = msm_audio_ion_dma_map(&phys_addr, &iova, mem_size,
					DMA_BIDIRECTIONAL);
		if (ret) {
			pr_err("%s: dma mapping failed %d\n", __func__, ret);
			goto err_free;
		}
		pr_debug("%s: dma_mapping_success iova:0x%lx\n",
				 __func__, (unsigned long)iova);

		voice_mhi_lcl.dev_info.phys_addr.base = phys_addr;
		voice_mhi_lcl.dev_info.iova_adsp.base = iova;
		voice_mhi_lcl.dev_info.iova_adsp.size = mem_size;
		voice_mhi_lcl.dev_info.iova_pcie.size = mem_size;
		VOICE_MHI_STATE_SET(voice_mhi_lcl.voice_mhi_state,
				VOICE_MHI_ADSP_UP);

		ret = voice_mhi_apr_register();
		/* If fails register during audio notifier UP event */
		if (ret)
			pr_err("%s: APR register failed %d\n", __func__, ret);
		ret = mhi_driver_register(&voice_mhi_driver);
		if (ret) {
			pr_err("%s: mhi register failed %d\n", __func__, ret);
			goto done;
		}

		ret = audio_notifier_register("voice_mhi",
				AUDIO_NOTIFIER_ADSP_DOMAIN,
				&voice_mhi_service_nb);
		if (ret < 0)
			pr_err("%s: Audio notifier register failed ret = %d\n",
				__func__, ret);

		mutex_lock(&voice_mhi_lcl.mutex);
		voice_mhi_lcl.dev_info.pdev = pdev;
		voice_mhi_lcl.pcie_enabled = true;
		VOICE_MHI_STATE_SET(voice_mhi_lcl.voice_mhi_state,
				VOICE_MHI_PROBED);
		mutex_unlock(&voice_mhi_lcl.mutex);
	} else {
		pr_err("%s: Memory size can't be zero\n", __func__);
		ret = -ENOMEM;
		goto done;
	}

done:
	return ret;
err_free:
	dma_free_attrs(&pdev->dev, mem_size, ptr, phys_addr,
						   DMA_ATTR_NO_KERNEL_MAPPING);
	return ret;

}

static int voice_mhi_remove(struct platform_device *pdev)
{
	if (voice_mhi_lcl.apr_mvm_handle)
			apr_reset(voice_mhi_lcl.apr_mvm_handle);
	mhi_driver_unregister(&voice_mhi_driver);
	memset(&voice_mhi_lcl, 0, sizeof(voice_mhi_lcl));
	return 0;
}
static const struct of_device_id voice_mhi_of_match[]  = {
	{ .compatible = "qcom,voice-mhi-audio", },
	{},
};
static struct platform_driver voice_mhi_platform_driver = {
	.probe = voice_mhi_probe,
	.remove = voice_mhi_remove,
	.driver = {
		.name = "voice_mhi_audio",
		.owner = THIS_MODULE,
		.of_match_table = voice_mhi_of_match,
		.suppress_bind_attrs = true,
	}
};

int __init voice_mhi_init(void)
{
	int ret = 0;

	memset(&voice_mhi_lcl, 0, sizeof(voice_mhi_lcl));
	mutex_init(&voice_mhi_lcl.mutex);

	/* Add remaining init here */
	voice_mhi_lcl.pcie_enabled = false;
	voice_mhi_lcl.voice_mhi_state = VOICE_MHI_INIT;
	voice_mhi_lcl.vote_count = 0;
	voice_mhi_lcl.apr_mvm_handle = NULL;
	ret = platform_driver_register(&voice_mhi_platform_driver);

	return ret;
}

void __exit voice_mhi_exit(void)
{
	mutex_destroy(&voice_mhi_lcl.mutex);
	platform_driver_unregister(&voice_mhi_platform_driver);
}

MODULE_DESCRIPTION("Voice MHI module");
MODULE_LICENSE("GPL v2");