// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2013-2020 TRUSTONIC LIMITED
 * All Rights Reserved.
 *
 * 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/cdev.h>
#include <linux/device.h>
#include <linux/export.h>
#include <linux/fs.h>
#include <linux/mm_types.h>	/* struct vm_area_struct */
#include <linux/uaccess.h>

#include "public/mc_user.h"

#include "main.h"
#include "admin.h"	/* tee_object* */
#include "mmu.h"	/* tee_mmu* */
#include "client.h"
#include "mcp.h"	/* mcp_get_version */
#include "protocol.h"
#include "user.h"

/*
 * Get client object from file pointer
 */
static inline struct tee_client *get_client(struct file *file)
{
	return (struct tee_client *)file->private_data;
}

/*
 * Callback for system open()
 * A set of internal client data are created and initialized.
 *
 * @inode
 * @file
 * Returns 0 if OK or -ENOMEM if no allocation was possible.
 */
static int user_open(struct inode *inode, struct file *file)
{
	struct tee_client *client;

	/* Create client */
	mc_dev_devel("from %s (%d)", current->comm, current->pid);
	client = client_create(false, protocol_vm_id());
	if (!client)
		return -ENOMEM;

	/* Store client in user file */
	file->private_data = client;
	return 0;
}

/*
 * Callback for system close()
 * The client object is freed.
 * @inode
 * @file
 * Returns 0
 */
static int user_release(struct inode *inode, struct file *file)
{
	struct tee_client *client = get_client(file);

	/* Close client */
	mc_dev_devel("from %s (%d)", current->comm, current->pid);
	if (!client)
		return -EPROTO;

	/* Detach client from user file */
	file->private_data = NULL;

	/* Destroy client, including remaining sessions */
	client_close(client);
	return 0;
}

/*
 * Check r/w access to referenced memory
 */
static inline int ioctl_check_pointer(unsigned int cmd, int __user *uarg)
{
	int err = 0;

	if (_IOC_DIR(cmd) & _IOC_READ)
#if KERNEL_VERSION(5, 0, 0) > LINUX_VERSION_CODE
		err = !access_ok(VERIFY_WRITE, uarg, _IOC_SIZE(cmd));
#else
		err = !access_ok(uarg, _IOC_SIZE(cmd));
#endif
	else if (_IOC_DIR(cmd) & _IOC_WRITE)
#if KERNEL_VERSION(5, 0, 0) > LINUX_VERSION_CODE
		err = !access_ok(VERIFY_READ, uarg, _IOC_SIZE(cmd));
#else
		err = !access_ok(uarg, _IOC_SIZE(cmd));
#endif

	if (err)
		return -EFAULT;

	return 0;
}

/*
 * Callback for system ioctl()
 * Implement most of ClientLib API functions
 * @file	pointer to file
 * @cmd		command
 * @arg		arguments
 *
 * Returns 0 for OK and an errno in case of error
 */
static long user_ioctl(struct file *file, unsigned int id, unsigned long arg)
{
	struct tee_client *client = get_client(file);
	int __user *uarg = (int __user *)arg;
	int ret = -EINVAL;

	mc_dev_devel("%u from %s", _IOC_NR(id), current->comm);

	if (!client)
		return -EPROTO;

	if (ioctl_check_pointer(id, uarg))
		return -EFAULT;

	switch (id) {
	case MC_IO_HAS_SESSIONS:
		/* Freeze the client */
		if (client_has_sessions(client))
			ret = -ENOTEMPTY;
		else
			ret = 0;
		break;

	case MC_IO_OPEN_SESSION: {
		struct mc_ioctl_open_session session;

		if (copy_from_user(&session, uarg, sizeof(session))) {
			ret = -EFAULT;
			break;
		}

		ret = client_mc_open_session(client, &session.uuid,
					     session.tci, session.tci_len,
					     &session.sid);
		if (ret)
			break;

		if (copy_to_user(uarg, &session, sizeof(session))) {
			ret = -EFAULT;
			client_remove_session(client, session.sid);
			break;
		}
		break;
	}
	case MC_IO_OPEN_TRUSTLET: {
		struct mc_ioctl_open_trustlet trustlet;

		if (copy_from_user(&trustlet, uarg, sizeof(trustlet))) {
			ret = -EFAULT;
			break;
		}

		ret = client_mc_open_trustlet(client,
					      trustlet.tl, trustlet.tl_len,
					      trustlet.tci, trustlet.tci_len,
					      &trustlet.sid);
		if (ret)
			break;

		if (copy_to_user(uarg, &trustlet, sizeof(trustlet))) {
			ret = -EFAULT;
			client_remove_session(client, trustlet.sid);
			break;
		}
		break;
	}
	case MC_IO_CLOSE_SESSION: {
		u32 sid = (u32)arg;

		ret = client_remove_session(client, sid);
		break;
	}
	case MC_IO_NOTIFY: {
		u32 sid = (u32)arg;

		ret = client_notify_session(client, sid);
		break;
	}
	case MC_IO_WAIT: {
		struct mc_ioctl_wait wait;

		if (copy_from_user(&wait, uarg, sizeof(wait))) {
			ret = -EFAULT;
			break;
		}
		ret = client_waitnotif_session(client, wait.sid, wait.timeout);
		break;
	}
	case MC_IO_MAP: {
		struct mc_ioctl_map map;

		if (copy_from_user(&map, uarg, sizeof(map))) {
			ret = -EFAULT;
			break;
		}

		ret = client_mc_map(client, map.sid, NULL, &map.buf);
		if (ret)
			break;

		/* Fill in return struct */
		if (copy_to_user(uarg, &map, sizeof(map))) {
			ret = -EFAULT;
			break;
		}
		break;
	}
	case MC_IO_UNMAP: {
		struct mc_ioctl_map map;

		if (copy_from_user(&map, uarg, sizeof(map))) {
			ret = -EFAULT;
			break;
		}

		ret = client_mc_unmap(client, map.sid, &map.buf);
		break;
	}
	case MC_IO_ERR: {
		struct mc_ioctl_geterr __user *uerr =
			(struct mc_ioctl_geterr __user *)uarg;
		u32 sid;
		s32 exit_code;

		if (get_user(sid, &uerr->sid)) {
			ret = -EFAULT;
			break;
		}

		ret = client_get_session_exitcode(client, sid, &exit_code);
		if (ret)
			break;

		/* Fill in return struct */
		if (put_user(exit_code, &uerr->value)) {
			ret = -EFAULT;
			break;
		}

		break;
	}
	case MC_IO_VERSION: {
		struct mc_version_info version_info;

		ret = mcp_get_version(&version_info);
		if (ret)
			break;

		if (copy_to_user(uarg, &version_info, sizeof(version_info)))
			ret = -EFAULT;

		break;
	}
	case MC_IO_GP_INITIALIZE_CONTEXT: {
		struct mc_ioctl_gp_initialize_context context;

		if (copy_from_user(&context, uarg, sizeof(context))) {
			ret = -EFAULT;
			break;
		}

		ret = client_gp_initialize_context(client, &context.ret);

		if (copy_to_user(uarg, &context, sizeof(context))) {
			ret = -EFAULT;
			break;
		}
		break;
	}
	case MC_IO_GP_REGISTER_SHARED_MEM: {
		struct mc_ioctl_gp_register_shared_mem shared_mem;

		if (copy_from_user(&shared_mem, uarg, sizeof(shared_mem))) {
			ret = -EFAULT;
			break;
		}

		ret = client_gp_register_shared_mem(client, NULL, NULL,
						    &shared_mem.memref,
						    &shared_mem.ret);

		if (copy_to_user(uarg, &shared_mem, sizeof(shared_mem))) {
			ret = -EFAULT;
			break;
		}
		break;
	}
	case MC_IO_GP_RELEASE_SHARED_MEM: {
		struct mc_ioctl_gp_release_shared_mem shared_mem;

		if (copy_from_user(&shared_mem, uarg, sizeof(shared_mem))) {
			ret = -EFAULT;
			break;
		}

		ret = client_gp_release_shared_mem(client, &shared_mem.memref);
		break;
	}
	case MC_IO_GP_OPEN_SESSION: {
		struct mc_ioctl_gp_open_session session;
		struct tee_object *obj = NULL;
		struct tee_mmu *ta_mmu = NULL;

		if (copy_from_user(&session, uarg, sizeof(session))) {
			ret = -EFAULT;
			break;
		}

		/* Create object from user-space binary */
		if (session.ta_len) {
			obj = tee_object_read(session.ta, session.ta_len);
			if (IS_ERR(obj)) {
				ret = PTR_ERR(obj);
				break;
			}

			{
				struct mc_ioctl_buffer buf = {
					.va = (uintptr_t)obj->data,
					.len = obj->length,
					.flags = MC_IO_MAP_INPUT,
				};

				ta_mmu = tee_mmu_create(NULL, &buf);
				if (IS_ERR(ta_mmu)) {
					ret = PTR_ERR(ta_mmu);
					goto err_mmu;
				}
			}
		}

		ret = client_gp_open_session(client, &session.uuid, ta_mmu,
					     &session.operation,
					     &session.identity,
					     &session.ret, &session.session_id);
		if (ta_mmu)
			tee_mmu_put(ta_mmu);
err_mmu:
		if (obj)
			tee_object_free(obj);

		if (copy_to_user(uarg, &session, sizeof(session))) {
			ret = -EFAULT;
			break;
		}

		break;
	}
	case MC_IO_GP_CLOSE_SESSION: {
		struct mc_ioctl_gp_close_session session;

		if (copy_from_user(&session, uarg, sizeof(session))) {
			ret = -EFAULT;
			break;
		}

		ret = client_gp_close_session(client, session.session_id);
		break;
	}
	case MC_IO_GP_INVOKE_COMMAND: {
		struct mc_ioctl_gp_invoke_command command;

		if (copy_from_user(&command, uarg, sizeof(command))) {
			ret = -EFAULT;
			break;
		}

		ret = client_gp_invoke_command(client, command.session_id,
					       command.command_id,
					       &command.operation,
					       &command.ret);

		if (copy_to_user(uarg, &command, sizeof(command))) {
			ret = -EFAULT;
			break;
		}
		break;
	}
	case MC_IO_GP_REQUEST_CANCELLATION: {
		struct mc_ioctl_gp_request_cancellation cancel;

		if (copy_from_user(&cancel, uarg, sizeof(cancel))) {
			ret = -EFAULT;
			break;
		}

		client_gp_request_cancellation(client,
					       cancel.operation.started);
		ret = 0;
		break;
	}
	default:
		ret = -ENOIOCTLCMD;
		mc_dev_err(ret, "unsupported command no %d", id);
	}

	return ret;
}

static const struct file_operations mc_user_fops = {
	.owner = THIS_MODULE,
	.open = user_open,
	.release = user_release,
	.unlocked_ioctl = user_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = user_ioctl,
#endif
};

int mc_user_init(struct cdev *cdev)
{
	cdev_init(cdev, &mc_user_fops);
	return 0;
}