/*
 * Copyright (c) 2014, STMicroelectronics International N.V.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/mutex.h>
#include <linux/miscdevice.h>
#include <linux/uaccess.h>
#include <linux/anon_inodes.h>
#include <linux/semaphore.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/device.h>

#include "tee_shm.h"
#include "tee_core.h"
#include "tee_supp_com.h"

#define TEE_RPC_BUFFER	0x00000001
#define TEE_RPC_VALUE	0x00000002

enum teec_rpc_result tee_supp_cmd(struct tee *tee,
				  uint32_t id, void *data, size_t datalen)
{
	struct tee_rpc *rpc = tee->rpc;
	enum teec_rpc_result res = TEEC_RPC_FAIL;
	size_t size;
	struct task_struct *task = current;

	dev_dbg(tee->dev, "> tgid:[%d] id:[0x%08x]\n", task->tgid, id);

	if (atomic_read(&rpc->used) == 0) {
		dev_err(tee->dev, "%s: ERROR Supplicant application NOT ready\n"
				, __func__);
		goto out;
	}

	switch (id) {
	case TEE_RPC_ICMD_ALLOCATE:
		{
			struct tee_rpc_alloc *alloc;
			struct tee_shm *shmint;

			alloc = (struct tee_rpc_alloc *)data;
			size = alloc->size;
			memset(alloc, 0, sizeof(struct tee_rpc_alloc));
			shmint = tee_shm_alloc_from_rpc(tee, size);
			if (IS_ERR_OR_NULL(shmint))
				break;

			alloc->size = size;
			alloc->data = (void *)(unsigned long)shmint->paddr;
			alloc->shm = shmint;
			res = TEEC_RPC_OK;

			break;
		}
	case TEE_RPC_ICMD_FREE:
		{
			struct tee_rpc_free *free;

			free = (struct tee_rpc_free *)data;
			tee_shm_free_from_rpc(free->shm);
			res = TEEC_RPC_OK;
			break;
		}
	case TEE_RPC_ICMD_INVOKE:
		{
			if (sizeof(rpc->commToUser) < datalen)
				break;

			/*
			 * Other threads blocks here until we've copied our
			 * answer from the supplicant
			 */
			mutex_lock(&rpc->thrd_mutex);

			mutex_lock(&rpc->outsync);
			memcpy(&rpc->commToUser, data, datalen);
			mutex_unlock(&rpc->outsync);

			dev_dbg(tee->dev,
				"Supplicant Cmd: %x. Give hand to supplicant\n",
				rpc->commToUser.cmd);

			up(&rpc->datatouser);

			down(&rpc->datafromuser);

			dev_dbg(tee->dev,
				"Supplicant Cmd: %x. Give hand to fw\n",
				rpc->commToUser.cmd);

			mutex_lock(&rpc->insync);
			memcpy(data, &rpc->commFromUser, datalen);
			mutex_unlock(&rpc->insync);

			mutex_unlock(&rpc->thrd_mutex);

			res = TEEC_RPC_OK;

			break;
		}
	default:
		/* not supported */
		break;
	}

out:
	dev_dbg(tee->dev, "< res: [%d]\n", res);

	return res;
}
EXPORT_SYMBOL(tee_supp_cmd);

ssize_t tee_supp_read(struct file *filp, char __user *buffer,
		  size_t length, loff_t *offset)
{
	struct tee_context *ctx = (struct tee_context *)(filp->private_data);
	struct tee *tee;
	struct tee_rpc *rpc;
	struct task_struct *task = current;
	int ret;

	BUG_ON(!ctx);
	tee = ctx->tee;
	BUG_ON(!tee);
	BUG_ON(!tee->dev);
	BUG_ON(!tee->rpc);

	dev_dbg(tee->dev, "> ctx %p\n", ctx);

	rpc = tee->rpc;

	if (atomic_read(&rpc->used) == 0) {
		dev_err(tee->dev, "%s: ERROR Supplicant application NOT ready\n"
				, __func__);
		ret = -EPERM;
		goto out;
	}

	if (down_interruptible(&rpc->datatouser))
		return -ERESTARTSYS;

	dev_dbg(tee->dev, "> tgid:[%d]\n", task->tgid);

	mutex_lock(&rpc->outsync);

	ret =
	    sizeof(rpc->commToUser) - sizeof(rpc->commToUser.cmds) +
	    sizeof(rpc->commToUser.cmds[0]) * rpc->commToUser.nbr_bf;
	if (length < ret) {
		ret = -EINVAL;
	} else {
		if (copy_to_user(buffer, &rpc->commToUser, ret)) {
			dev_err(tee->dev,
				"[%s] error, copy_to_user failed!\n", __func__);
			ret = -EINVAL;
		}
	}

	mutex_unlock(&rpc->outsync);

out:
	dev_dbg(tee->dev, "< [%d]\n", ret);
	return ret;
}

ssize_t tee_supp_write(struct file *filp, const char __user *buffer,
		   size_t length, loff_t *offset)
{
	struct tee_context *ctx = (struct tee_context *)(filp->private_data);
	struct tee *tee;
	struct tee_rpc *rpc;
	struct task_struct *task = current;
	int ret = 0;

	BUG_ON(!ctx);
	BUG_ON(!ctx->tee);
	BUG_ON(!ctx->tee->rpc);
	tee = ctx->tee;
	rpc = tee->rpc;
	dev_dbg(tee->dev, "> tgid:[%d]\n", task->tgid);

	if (atomic_read(&rpc->used) == 0) {
		dev_err(tee->dev, "%s: ERROR Supplicant application NOT ready\n"
				, __func__);
		goto out;
	}

	if (length > 0 && length < sizeof(rpc->commFromUser)) {
		uint32_t i;

		mutex_lock(&rpc->insync);

		if (copy_from_user(&rpc->commFromUser, buffer, length)) {
			dev_err(tee->dev,
				"%s: ERROR, tee_session copy_from_user failed\n",
				__func__);
			mutex_unlock(&rpc->insync);
			ret = -EINVAL;
			goto out;
		}

		/* Translate virtual address of caller into physical address */
		for (i = 0; i < rpc->commFromUser.nbr_bf; i++) {
			if (rpc->commFromUser.cmds[i].type == TEE_RPC_BUFFER
			    && rpc->commFromUser.cmds[i].buffer) {
				struct vm_area_struct *vma =
				    find_vma(current->mm,
					     (unsigned long)rpc->
					     commFromUser.cmds[i].buffer);
				if (vma != NULL) {
					struct tee_shm *shm =
					    vma->vm_private_data;
					BUG_ON(!shm);
					dev_dbg(tee->dev,
						"%d gid2pa(0x%p => %x)\n", i,
						rpc->commFromUser.cmds[i].
						buffer,
						(unsigned int)shm->paddr);
					rpc->commFromUser.cmds[i].buffer =
					    (void *)(unsigned long)shm->paddr;
				} else
					dev_dbg(tee->dev,
						" gid2pa(0x%p => NULL\n)",
						rpc->commFromUser.cmds[i].
						buffer);
			}
		}

		mutex_unlock(&rpc->insync);
		up(&rpc->datafromuser);
		ret = length;
	}

out:
	dev_dbg(tee->dev, "< [%d]\n", ret);
	return ret;
}

int tee_supp_init(struct tee *tee)
{
	struct tee_rpc *rpc =
	    devm_kzalloc(tee->dev, sizeof(struct tee_rpc), GFP_KERNEL);
	if (!rpc) {
		dev_err(tee->dev, "%s: can't allocate tee_rpc structure\n",
				__func__);
		return -ENOMEM;
	}

	sema_init(&rpc->datafromuser, 0);
	sema_init(&rpc->datatouser, 0);
	mutex_init(&rpc->thrd_mutex);
	mutex_init(&rpc->outsync);
	mutex_init(&rpc->insync);
	atomic_set(&rpc->used, 0);
	tee->rpc = rpc;
	return 0;
}

void tee_supp_deinit(struct tee *tee)
{
	devm_kfree(tee->dev, tee->rpc);
	tee->rpc = NULL;
}