[J-u-boot.git] / drivers / tee / sandbox.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2018 Linaro Limited
 */

#include <dm.h>
#include <sandboxtee.h>
#include <tee.h>
#include <tee/optee_ta_avb.h>
#include <tee/optee_ta_rpc_test.h>
#include <tee/optee_ta_scp03.h>

#include "optee/optee_msg.h"
#include "optee/optee_private.h"

/*
 * The sandbox tee driver tries to emulate a generic Trusted Execution
 * Environment (TEE) with the Trusted Applications (TA) OPTEE_TA_AVB and
 * OPTEE_TA_RPC_TEST available.
 */

static const u32 pstorage_max = 16;
/**
 * struct ta_entry - TA entries
 * @uuid:		UUID of an emulated TA
 * @open_session	Called when a session is opened to the TA
 * @invoke_func		Called when a function in the TA is to be invoked
 *
 * This struct is used to register TAs in this sandbox emulation of a TEE.
 */
struct ta_entry {
	struct tee_optee_ta_uuid uuid;
	u32 (*open_session)(struct udevice *dev, uint num_params,
			    struct tee_param *params);
	u32 (*invoke_func)(struct udevice *dev,
			   u32 func, uint num_params,
			   struct tee_param *params);
};

static int get_msg_arg(struct udevice *dev, uint num_params,
		       struct tee_shm **shmp, struct optee_msg_arg **msg_arg)
{
	int rc;
	struct optee_msg_arg *ma;

	rc = __tee_shm_add(dev, OPTEE_MSG_NONCONTIG_PAGE_SIZE, NULL,
			   OPTEE_MSG_GET_ARG_SIZE(num_params), TEE_SHM_ALLOC,
			   shmp);
	if (rc)
		return rc;

	ma = (*shmp)->addr;
	memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params));
	ma->num_params = num_params;
	*msg_arg = ma;

	return 0;
}

void *optee_alloc_and_init_page_list(void *buf, ulong len,
				     u64 *phys_buf_ptr)
{
	/*
	 * An empty stub is added just to fix linking issues.
	 * This function isn't supposed to be called in sandbox
	 * setup, otherwise replace this with a proper
	 * implementation from optee/core.c
	 */
	return NULL;
}

#if defined(CONFIG_OPTEE_TA_SCP03) || defined(CONFIG_OPTEE_TA_AVB)
static u32 get_attr(uint n, uint num_params, struct tee_param *params)
{
	if (n >= num_params)
		return TEE_PARAM_ATTR_TYPE_NONE;

	return params[n].attr;
}

static u32 check_params(u8 p0, u8 p1, u8 p2, u8 p3, uint num_params,
			struct tee_param *params)
{
	u8 p[] = { p0, p1, p2, p3 };
	uint n;

	for (n = 0; n < ARRAY_SIZE(p); n++)
		if (p[n] != get_attr(n, num_params, params))
			goto bad_params;

	for (; n < num_params; n++)
		if (get_attr(n, num_params, params))
			goto bad_params;

	return TEE_SUCCESS;

bad_params:
	printf("Bad param attrs\n");

	return TEE_ERROR_BAD_PARAMETERS;
}
#endif

#ifdef CONFIG_OPTEE_TA_SCP03
static u32 pta_scp03_open_session(struct udevice *dev, uint num_params,
				  struct tee_param *params)
{
	/*
	 * We don't expect additional parameters when opening a session to
	 * this TA.
	 */
	return check_params(TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
			    TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
			    num_params, params);
}

static u32 pta_scp03_invoke_func(struct udevice *dev, u32 func, uint num_params,
				 struct tee_param *params)
{
	u32 res;
	static bool enabled;
	static bool provisioned;

	switch (func) {
	case PTA_CMD_ENABLE_SCP03:
		res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   num_params, params);
		if (res)
			return res;

		/* If SCP03 was not enabled, enable it */
		if (!enabled)
			enabled = true;

		/* If SCP03 was not provisioned, provision new keys */
		if (params[0].u.value.a && !provisioned)
			provisioned = true;

		/*
		 * Either way, we assume both operations succeeded and that
		 * the communication channel has now been established
		 */

		return TEE_SUCCESS;
	default:
		return TEE_ERROR_NOT_SUPPORTED;
	}
}
#endif

#ifdef CONFIG_OPTEE_TA_AVB
static u32 ta_avb_open_session(struct udevice *dev, uint num_params,
			       struct tee_param *params)
{
	/*
	 * We don't expect additional parameters when opening a session to
	 * this TA.
	 */
	return check_params(TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
			    TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
			    num_params, params);
}

static u32 ta_avb_invoke_func(struct udevice *dev, u32 func, uint num_params,
			      struct tee_param *params)
{
	struct sandbox_tee_state *state = dev_get_priv(dev);
	struct env_entry e, *ep;
	char *name;
	u32 res;
	uint slot;
	u64 val;
	char *value;
	u32 value_sz, tmp_sz;

	switch (func) {
	case TA_AVB_CMD_READ_ROLLBACK_INDEX:
		res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
				   TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   num_params, params);
		if (res)
			return res;

		slot = params[0].u.value.a;
		if (slot >= ARRAY_SIZE(state->ta_avb_rollback_indexes)) {
			printf("Rollback index slot out of bounds %u\n", slot);
			return TEE_ERROR_BAD_PARAMETERS;
		}

		val = state->ta_avb_rollback_indexes[slot];
		params[1].u.value.a = val >> 32;
		params[1].u.value.b = val;
		return TEE_SUCCESS;

	case TA_AVB_CMD_WRITE_ROLLBACK_INDEX:
		res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
				   TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   num_params, params);
		if (res)
			return res;

		slot = params[0].u.value.a;
		if (slot >= ARRAY_SIZE(state->ta_avb_rollback_indexes)) {
			printf("Rollback index slot out of bounds %u\n", slot);
			return TEE_ERROR_BAD_PARAMETERS;
		}

		val = (u64)params[1].u.value.a << 32 | params[1].u.value.b;
		if (val < state->ta_avb_rollback_indexes[slot])
			return TEE_ERROR_SECURITY;

		state->ta_avb_rollback_indexes[slot] = val;
		return TEE_SUCCESS;

	case TA_AVB_CMD_READ_LOCK_STATE:
		res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   num_params, params);
		if (res)
			return res;

		params[0].u.value.a = state->ta_avb_lock_state;
		return TEE_SUCCESS;

	case TA_AVB_CMD_WRITE_LOCK_STATE:
		res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   num_params, params);
		if (res)
			return res;

		if (state->ta_avb_lock_state != params[0].u.value.a) {
			state->ta_avb_lock_state = params[0].u.value.a;
			memset(state->ta_avb_rollback_indexes, 0,
			       sizeof(state->ta_avb_rollback_indexes));
		}

		return TEE_SUCCESS;
	case TA_AVB_CMD_READ_PERSIST_VALUE:
		res = check_params(TEE_PARAM_ATTR_TYPE_MEMREF_INPUT,
				   TEE_PARAM_ATTR_TYPE_MEMREF_INOUT,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   num_params, params);
		if (res)
			return res;

		name = params[0].u.memref.shm->addr;

		value = params[1].u.memref.shm->addr;
		value_sz = params[1].u.memref.size;

		e.key = name;
		e.data = NULL;
		hsearch_r(e, ENV_FIND, &ep, &state->pstorage_htab, 0);
		if (!ep)
			return TEE_ERROR_ITEM_NOT_FOUND;

		tmp_sz = strlen(ep->data) + 1;
		if (value_sz < tmp_sz)
			return TEE_ERROR_SHORT_BUFFER;

		memcpy(value, ep->data, tmp_sz);
		params[1].u.memref.size = tmp_sz;

		return TEE_SUCCESS;
	case TA_AVB_CMD_WRITE_PERSIST_VALUE:
		res = check_params(TEE_PARAM_ATTR_TYPE_MEMREF_INPUT,
				   TEE_PARAM_ATTR_TYPE_MEMREF_INPUT,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   TEE_PARAM_ATTR_TYPE_NONE,
				   num_params, params);
		if (res)
			return res;

		name = params[0].u.memref.shm->addr;

		value = params[1].u.memref.shm->addr;
		value_sz = params[1].u.memref.size;

		e.key = name;
		e.data = NULL;
		hsearch_r(e, ENV_FIND, &ep, &state->pstorage_htab, 0);
		if (ep)
			hdelete_r(e.key, &state->pstorage_htab, 0);

		e.key = name;
		e.data = value;
		hsearch_r(e, ENV_ENTER, &ep, &state->pstorage_htab, 0);
		if (!ep)
			return TEE_ERROR_OUT_OF_MEMORY;

		return TEE_SUCCESS;

	default:
		return TEE_ERROR_NOT_SUPPORTED;
	}
}
#endif /* OPTEE_TA_AVB */

#ifdef CONFIG_OPTEE_TA_RPC_TEST
static u32 ta_rpc_test_open_session(struct udevice *dev, uint num_params,
				    struct tee_param *params)
{
	/*
	 * We don't expect additional parameters when opening a session to
	 * this TA.
	 */
	return check_params(TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
			    TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
			    num_params, params);
}

static void fill_i2c_rpc_params(struct optee_msg_arg *msg_arg, u64 bus_num,
				u64 chip_addr, u64 xfer_flags, u64 op,
				struct tee_param_memref memref)
{
	msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;
	msg_arg->params[1].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;
	msg_arg->params[2].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INOUT;
	msg_arg->params[3].attr = OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT;

	/* trigger I2C services of TEE supplicant */
	msg_arg->cmd = OPTEE_MSG_RPC_CMD_I2C_TRANSFER;

	msg_arg->params[0].u.value.a = op;
	msg_arg->params[0].u.value.b = bus_num;
	msg_arg->params[0].u.value.c = chip_addr;
	msg_arg->params[1].u.value.a = xfer_flags;

	/* buffer to read/write data */
	msg_arg->params[2].u.rmem.shm_ref = (ulong)memref.shm;
	msg_arg->params[2].u.rmem.size = memref.size;
	msg_arg->params[2].u.rmem.offs = memref.shm_offs;

	msg_arg->num_params = 4;
}

static u32 ta_rpc_test_invoke_func(struct udevice *dev, u32 func,
				   uint num_params,
				   struct tee_param *params)
{
	struct tee_shm *shm;
	struct tee_param_memref memref_data;
	struct optee_msg_arg *msg_arg;
	int chip_addr, bus_num, op, xfer_flags;
	int res;

	res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
			   TEE_PARAM_ATTR_TYPE_MEMREF_INOUT,
			   TEE_PARAM_ATTR_TYPE_NONE,
			   TEE_PARAM_ATTR_TYPE_NONE,
			   num_params, params);
	if (res)
		return TEE_ERROR_BAD_PARAMETERS;

	bus_num = params[0].u.value.a;
	chip_addr = params[0].u.value.b;
	xfer_flags = params[0].u.value.c;
	memref_data = params[1].u.memref;

	switch (func) {
	case TA_RPC_TEST_CMD_I2C_READ:
		op = OPTEE_MSG_RPC_CMD_I2C_TRANSFER_RD;
		break;
	case TA_RPC_TEST_CMD_I2C_WRITE:
		op = OPTEE_MSG_RPC_CMD_I2C_TRANSFER_WR;
		break;
	default:
		return TEE_ERROR_NOT_SUPPORTED;
	}

	/*
	 * Fill params for an RPC call to tee supplicant
	 */
	res = get_msg_arg(dev, 4, &shm, &msg_arg);
	if (res)
		goto out;

	fill_i2c_rpc_params(msg_arg, bus_num, chip_addr, xfer_flags, op,
			    memref_data);

	/* Make an RPC call to tee supplicant */
	optee_suppl_cmd(dev, shm, 0);
	res = msg_arg->ret;
out:
	tee_shm_free(shm);

	return res;
}
#endif /* CONFIG_OPTEE_TA_RPC_TEST */

static const struct ta_entry ta_entries[] = {
#ifdef CONFIG_OPTEE_TA_AVB
	{ .uuid = TA_AVB_UUID,
	  .open_session = ta_avb_open_session,
	  .invoke_func = ta_avb_invoke_func,
	},
#endif
#ifdef CONFIG_OPTEE_TA_RPC_TEST
	{ .uuid = TA_RPC_TEST_UUID,
	  .open_session = ta_rpc_test_open_session,
	  .invoke_func = ta_rpc_test_invoke_func,
	},
#endif
#ifdef CONFIG_OPTEE_TA_SCP03
	{ .uuid = PTA_SCP03_UUID,
	  .open_session = pta_scp03_open_session,
	  .invoke_func = pta_scp03_invoke_func,
	},
#endif
};

static void sandbox_tee_get_version(struct udevice *dev,
				    struct tee_version_data *vers)
{
	struct tee_version_data v = {
		.gen_caps = TEE_GEN_CAP_GP | TEE_GEN_CAP_REG_MEM,
	};

	*vers = v;
}

static int sandbox_tee_close_session(struct udevice *dev, u32 session)
{
	struct sandbox_tee_state *state = dev_get_priv(dev);

	if (!state->ta || state->session != session)
		return -EINVAL;

	state->session = 0;
	state->ta = NULL;

	return 0;
}

static const struct ta_entry *find_ta_entry(u8 uuid[TEE_UUID_LEN])
{
	struct tee_optee_ta_uuid u;
	uint n;

	tee_optee_ta_uuid_from_octets(&u, uuid);

	for (n = 0; n < ARRAY_SIZE(ta_entries); n++)
		if (!memcmp(&u, &ta_entries[n].uuid, sizeof(u)))
			return ta_entries + n;

	return NULL;
}

static int sandbox_tee_open_session(struct udevice *dev,
				    struct tee_open_session_arg *arg,
				    uint num_params, struct tee_param *params)
{
	struct sandbox_tee_state *state = dev_get_priv(dev);
	const struct ta_entry *ta;

	if (state->ta) {
		printf("A session is already open\n");
		return -EBUSY;
	}

	ta = find_ta_entry(arg->uuid);
	if (!ta) {
		printf("Cannot find TA\n");
		arg->ret = TEE_ERROR_ITEM_NOT_FOUND;
		arg->ret_origin = TEE_ORIGIN_TEE;

		return 0;
	}

	arg->ret = ta->open_session(dev, num_params, params);
	arg->ret_origin = TEE_ORIGIN_TRUSTED_APP;

	if (!arg->ret) {
		state->ta = (void *)ta;
		state->session = 1;
		arg->session = state->session;
	} else {
		printf("Cannot open session, TA returns error\n");
	}

	return 0;
}

static int sandbox_tee_invoke_func(struct udevice *dev,
				   struct tee_invoke_arg *arg,
				   uint num_params, struct tee_param *params)
{
	struct sandbox_tee_state *state = dev_get_priv(dev);
	struct ta_entry *ta = state->ta;

	if (!arg->session) {
		printf("Missing session\n");
		return -EINVAL;
	}

	if (!ta) {
		printf("TA session not available\n");
		return -EINVAL;
	}

	if (arg->session != state->session) {
		printf("Session mismatch\n");
		return -EINVAL;
	}

	arg->ret = ta->invoke_func(dev, arg->func, num_params, params);
	arg->ret_origin = TEE_ORIGIN_TRUSTED_APP;

	return 0;
}

static int sandbox_tee_shm_register(struct udevice *dev, struct tee_shm *shm)
{
	struct sandbox_tee_state *state = dev_get_priv(dev);

	state->num_shms++;

	return 0;
}

static int sandbox_tee_shm_unregister(struct udevice *dev, struct tee_shm *shm)
{
	struct sandbox_tee_state *state = dev_get_priv(dev);

	state->num_shms--;

	return 0;
}

static int sandbox_tee_remove(struct udevice *dev)
{
	struct sandbox_tee_state *state = dev_get_priv(dev);

	hdestroy_r(&state->pstorage_htab);

	return 0;
}

static int sandbox_tee_probe(struct udevice *dev)
{
	struct sandbox_tee_state *state = dev_get_priv(dev);
	/*
	 * With this hastable we emulate persistent storage,
	 * which should contain persistent values
	 * between different sessions/command invocations.
	 */
	if (!hcreate_r(pstorage_max, &state->pstorage_htab))
		return TEE_ERROR_OUT_OF_MEMORY;

	return 0;
}

static const struct tee_driver_ops sandbox_tee_ops = {
	.get_version = sandbox_tee_get_version,
	.open_session = sandbox_tee_open_session,
	.close_session = sandbox_tee_close_session,
	.invoke_func = sandbox_tee_invoke_func,
	.shm_register = sandbox_tee_shm_register,
	.shm_unregister = sandbox_tee_shm_unregister,
};

static const struct udevice_id sandbox_tee_match[] = {
	{ .compatible = "sandbox,tee" },
	{},
};

U_BOOT_DRIVER(sandbox_tee) = {
	.name = "sandbox_tee",
	.id = UCLASS_TEE,
	.of_match = sandbox_tee_match,
	.ops = &sandbox_tee_ops,
	.priv_auto	= sizeof(struct sandbox_tee_state),
	.probe = sandbox_tee_probe,
	.remove = sandbox_tee_remove,
};
Commit	Line	Data
eadf26f1 JW	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (C) 2018 Linaro Limited
	4	*/
b905599b	5
eadf26f1 JW	6	#include <dm.h>
	7	#include <sandboxtee.h>
	8	#include <tee.h>
	9	#include <tee/optee_ta_avb.h>
592b98bb	10	#include <tee/optee_ta_rpc_test.h>
5a8783c8	11	#include <tee/optee_ta_scp03.h>
592b98bb IO	12
	13	#include "optee/optee_msg.h"
	14	#include "optee/optee_private.h"
eadf26f1 JW	15
eadf26f1 JW	16	/*
5e19fe8e	17	* The sandbox tee driver tries to emulate a generic Trusted Execution
592b98bb IO	18	* Environment (TEE) with the Trusted Applications (TA) OPTEE_TA_AVB and
592b98bb IO	19	* OPTEE_TA_RPC_TEST available.
eadf26f1 JW	20	*/
eadf26f1 JW	21
fc1fe01b	22	static const u32 pstorage_max = 16;
eadf26f1 JW	23	/**
	24	* struct ta_entry - TA entries
	25	* @uuid: UUID of an emulated TA
5e19fe8e	26	* @open_session Called when a session is opened to the TA
eadf26f1 JW	27	* @invoke_func Called when a function in the TA is to be invoked
	28	*
	29	* This struct is used to register TAs in this sandbox emulation of a TEE.
	30	*/
	31	struct ta_entry {
	32	struct tee_optee_ta_uuid uuid;
fc1fe01b IO	33	u32 (open_session)(struct udevice dev, uint num_params,
	34	struct tee_param *params);
	35	u32 (invoke_func)(struct udevice dev,
	36	u32 func, uint num_params,
	37	struct tee_param *params);
eadf26f1 JW	38	};
eadf26f1 JW	39
592b98bb IO	40	static int get_msg_arg(struct udevice *dev, uint num_params,
	41	struct tee_shm shmp, struct optee_msg_arg msg_arg)
	42	{
	43	int rc;
	44	struct optee_msg_arg *ma;
	45
	46	rc = __tee_shm_add(dev, OPTEE_MSG_NONCONTIG_PAGE_SIZE, NULL,
	47	OPTEE_MSG_GET_ARG_SIZE(num_params), TEE_SHM_ALLOC,
	48	shmp);
	49	if (rc)
	50	return rc;
	51
	52	ma = (*shmp)->addr;
	53	memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params));
	54	ma->num_params = num_params;
	55	*msg_arg = ma;
	56
	57	return 0;
	58	}
	59
	60	void optee_alloc_and_init_page_list(void buf, ulong len,
	61	u64 *phys_buf_ptr)
	62	{
	63	/*
	64	* An empty stub is added just to fix linking issues.
	65	* This function isn't supposed to be called in sandbox
	66	* setup, otherwise replace this with a proper
	67	* implementation from optee/core.c
	68	*/
	69	return NULL;
	70	}
	71
5a8783c8	72	#if defined(CONFIG_OPTEE_TA_SCP03) \|\| defined(CONFIG_OPTEE_TA_AVB)
eadf26f1 JW	73	static u32 get_attr(uint n, uint num_params, struct tee_param *params)
	74	{
	75	if (n >= num_params)
	76	return TEE_PARAM_ATTR_TYPE_NONE;
	77
	78	return params[n].attr;
	79	}
	80
	81	static u32 check_params(u8 p0, u8 p1, u8 p2, u8 p3, uint num_params,
	82	struct tee_param *params)
	83	{
5a8783c8	84	u8 p[] = { p0, p1, p2, p3 };
eadf26f1 JW	85	uint n;
	86
	87	for (n = 0; n < ARRAY_SIZE(p); n++)
	88	if (p[n] != get_attr(n, num_params, params))
	89	goto bad_params;
	90
	91	for (; n < num_params; n++)
	92	if (get_attr(n, num_params, params))
	93	goto bad_params;
	94
	95	return TEE_SUCCESS;
	96
	97	bad_params:
	98	printf("Bad param attrs\n");
	99
	100	return TEE_ERROR_BAD_PARAMETERS;
	101	}
5a8783c8 JRO	102	#endif
	103
	104	#ifdef CONFIG_OPTEE_TA_SCP03
	105	static u32 pta_scp03_open_session(struct udevice *dev, uint num_params,
	106	struct tee_param *params)
	107	{
	108	/*
	109	* We don't expect additional parameters when opening a session to
	110	* this TA.
	111	*/
	112	return check_params(TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
	113	TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
	114	num_params, params);
	115	}
	116
	117	static u32 pta_scp03_invoke_func(struct udevice *dev, u32 func, uint num_params,
	118	struct tee_param *params)
	119	{
	120	u32 res;
	121	static bool enabled;
7f1a4c9d	122	static bool provisioned;
5a8783c8 JRO	123
	124	switch (func) {
	125	case PTA_CMD_ENABLE_SCP03:
	126	res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
	127	TEE_PARAM_ATTR_TYPE_NONE,
	128	TEE_PARAM_ATTR_TYPE_NONE,
	129	TEE_PARAM_ATTR_TYPE_NONE,
	130	num_params, params);
	131	if (res)
	132	return res;
	133
7f1a4c9d JRO	134	/* If SCP03 was not enabled, enable it */
7f1a4c9d JRO	135	if (!enabled)
5a8783c8	136	enabled = true;
5a8783c8	137
7f1a4c9d JRO	138	/* If SCP03 was not provisioned, provision new keys */
	139	if (params[0].u.value.a && !provisioned)
	140	provisioned = true;
	141
	142	/*
5e19fe8e IO	143	* Either way, we assume both operations succeeded and that
5e19fe8e IO	144	* the communication channel has now been established
7f1a4c9d	145	*/
5a8783c8 JRO	146
	147	return TEE_SUCCESS;
	148	default:
	149	return TEE_ERROR_NOT_SUPPORTED;
	150	}
	151	}
	152	#endif
eadf26f1	153
592b98bb	154	#ifdef CONFIG_OPTEE_TA_AVB
fc1fe01b IO	155	static u32 ta_avb_open_session(struct udevice *dev, uint num_params,
fc1fe01b IO	156	struct tee_param *params)
eadf26f1 JW	157	{
	158	/*
	159	* We don't expect additional parameters when opening a session to
	160	* this TA.
	161	*/
	162	return check_params(TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
	163	TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
	164	num_params, params);
	165	}
	166
fc1fe01b	167	static u32 ta_avb_invoke_func(struct udevice *dev, u32 func, uint num_params,
eadf26f1 JW	168	struct tee_param *params)
eadf26f1 JW	169	{
fc1fe01b	170	struct sandbox_tee_state *state = dev_get_priv(dev);
dd2408ca	171	struct env_entry e, *ep;
fc1fe01b	172	char *name;
eadf26f1 JW	173	u32 res;
	174	uint slot;
	175	u64 val;
fc1fe01b	176	char *value;
8800cbe9	177	u32 value_sz, tmp_sz;
eadf26f1 JW	178
	179	switch (func) {
	180	case TA_AVB_CMD_READ_ROLLBACK_INDEX:
	181	res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
	182	TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT,
	183	TEE_PARAM_ATTR_TYPE_NONE,
	184	TEE_PARAM_ATTR_TYPE_NONE,
	185	num_params, params);
	186	if (res)
	187	return res;
	188
	189	slot = params[0].u.value.a;
fc1fe01b	190	if (slot >= ARRAY_SIZE(state->ta_avb_rollback_indexes)) {
eadf26f1 JW	191	printf("Rollback index slot out of bounds %u\n", slot);
	192	return TEE_ERROR_BAD_PARAMETERS;
	193	}
	194
fc1fe01b	195	val = state->ta_avb_rollback_indexes[slot];
eadf26f1 JW	196	params[1].u.value.a = val >> 32;
	197	params[1].u.value.b = val;
	198	return TEE_SUCCESS;
	199
	200	case TA_AVB_CMD_WRITE_ROLLBACK_INDEX:
	201	res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
	202	TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
	203	TEE_PARAM_ATTR_TYPE_NONE,
	204	TEE_PARAM_ATTR_TYPE_NONE,
	205	num_params, params);
	206	if (res)
	207	return res;
	208
	209	slot = params[0].u.value.a;
fc1fe01b	210	if (slot >= ARRAY_SIZE(state->ta_avb_rollback_indexes)) {
eadf26f1 JW	211	printf("Rollback index slot out of bounds %u\n", slot);
	212	return TEE_ERROR_BAD_PARAMETERS;
	213	}
	214
	215	val = (u64)params[1].u.value.a << 32 \| params[1].u.value.b;
fc1fe01b	216	if (val < state->ta_avb_rollback_indexes[slot])
eadf26f1 JW	217	return TEE_ERROR_SECURITY;
eadf26f1 JW	218
fc1fe01b	219	state->ta_avb_rollback_indexes[slot] = val;
eadf26f1 JW	220	return TEE_SUCCESS;
	221
	222	case TA_AVB_CMD_READ_LOCK_STATE:
	223	res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT,
	224	TEE_PARAM_ATTR_TYPE_NONE,
	225	TEE_PARAM_ATTR_TYPE_NONE,
	226	TEE_PARAM_ATTR_TYPE_NONE,
	227	num_params, params);
	228	if (res)
	229	return res;
	230
fc1fe01b	231	params[0].u.value.a = state->ta_avb_lock_state;
eadf26f1 JW	232	return TEE_SUCCESS;
	233
	234	case TA_AVB_CMD_WRITE_LOCK_STATE:
	235	res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
	236	TEE_PARAM_ATTR_TYPE_NONE,
	237	TEE_PARAM_ATTR_TYPE_NONE,
	238	TEE_PARAM_ATTR_TYPE_NONE,
	239	num_params, params);
	240	if (res)
	241	return res;
	242
fc1fe01b IO	243	if (state->ta_avb_lock_state != params[0].u.value.a) {
	244	state->ta_avb_lock_state = params[0].u.value.a;
	245	memset(state->ta_avb_rollback_indexes, 0,
	246	sizeof(state->ta_avb_rollback_indexes));
eadf26f1 JW	247	}
	248
	249	return TEE_SUCCESS;
fc1fe01b IO	250	case TA_AVB_CMD_READ_PERSIST_VALUE:
	251	res = check_params(TEE_PARAM_ATTR_TYPE_MEMREF_INPUT,
	252	TEE_PARAM_ATTR_TYPE_MEMREF_INOUT,
	253	TEE_PARAM_ATTR_TYPE_NONE,
	254	TEE_PARAM_ATTR_TYPE_NONE,
	255	num_params, params);
	256	if (res)
	257	return res;
	258
	259	name = params[0].u.memref.shm->addr;
	260
	261	value = params[1].u.memref.shm->addr;
	262	value_sz = params[1].u.memref.size;
	263
	264	e.key = name;
	265	e.data = NULL;
3f0d6807	266	hsearch_r(e, ENV_FIND, &ep, &state->pstorage_htab, 0);
fc1fe01b IO	267	if (!ep)
	268	return TEE_ERROR_ITEM_NOT_FOUND;
	269
8800cbe9 IO	270	tmp_sz = strlen(ep->data) + 1;
	271	if (value_sz < tmp_sz)
	272	return TEE_ERROR_SHORT_BUFFER;
	273
	274	memcpy(value, ep->data, tmp_sz);
	275	params[1].u.memref.size = tmp_sz;
fc1fe01b IO	276
	277	return TEE_SUCCESS;
	278	case TA_AVB_CMD_WRITE_PERSIST_VALUE:
	279	res = check_params(TEE_PARAM_ATTR_TYPE_MEMREF_INPUT,
	280	TEE_PARAM_ATTR_TYPE_MEMREF_INPUT,
	281	TEE_PARAM_ATTR_TYPE_NONE,
	282	TEE_PARAM_ATTR_TYPE_NONE,
	283	num_params, params);
	284	if (res)
	285	return res;
	286
	287	name = params[0].u.memref.shm->addr;
	288
	289	value = params[1].u.memref.shm->addr;
	290	value_sz = params[1].u.memref.size;
	291
	292	e.key = name;
	293	e.data = NULL;
3f0d6807	294	hsearch_r(e, ENV_FIND, &ep, &state->pstorage_htab, 0);
fc1fe01b IO	295	if (ep)
	296	hdelete_r(e.key, &state->pstorage_htab, 0);
	297
	298	e.key = name;
	299	e.data = value;
3f0d6807	300	hsearch_r(e, ENV_ENTER, &ep, &state->pstorage_htab, 0);
fc1fe01b IO	301	if (!ep)
	302	return TEE_ERROR_OUT_OF_MEMORY;
	303
	304	return TEE_SUCCESS;
eadf26f1 JW	305
	306	default:
	307	return TEE_ERROR_NOT_SUPPORTED;
	308	}
	309	}
592b98bb IO	310	#endif /* OPTEE_TA_AVB */
	311
	312	#ifdef CONFIG_OPTEE_TA_RPC_TEST
	313	static u32 ta_rpc_test_open_session(struct udevice *dev, uint num_params,
	314	struct tee_param *params)
	315	{
	316	/*
	317	* We don't expect additional parameters when opening a session to
	318	* this TA.
	319	*/
	320	return check_params(TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
	321	TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
	322	num_params, params);
	323	}
	324
	325	static void fill_i2c_rpc_params(struct optee_msg_arg *msg_arg, u64 bus_num,
	326	u64 chip_addr, u64 xfer_flags, u64 op,
	327	struct tee_param_memref memref)
	328	{
	329	msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;
	330	msg_arg->params[1].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;
	331	msg_arg->params[2].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INOUT;
	332	msg_arg->params[3].attr = OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT;
	333
	334	/* trigger I2C services of TEE supplicant */
	335	msg_arg->cmd = OPTEE_MSG_RPC_CMD_I2C_TRANSFER;
	336
	337	msg_arg->params[0].u.value.a = op;
	338	msg_arg->params[0].u.value.b = bus_num;
	339	msg_arg->params[0].u.value.c = chip_addr;
	340	msg_arg->params[1].u.value.a = xfer_flags;
	341
	342	/* buffer to read/write data */
	343	msg_arg->params[2].u.rmem.shm_ref = (ulong)memref.shm;
	344	msg_arg->params[2].u.rmem.size = memref.size;
	345	msg_arg->params[2].u.rmem.offs = memref.shm_offs;
	346
	347	msg_arg->num_params = 4;
	348	}
	349
	350	static u32 ta_rpc_test_invoke_func(struct udevice *dev, u32 func,
	351	uint num_params,
	352	struct tee_param *params)
	353	{
	354	struct tee_shm *shm;
	355	struct tee_param_memref memref_data;
	356	struct optee_msg_arg *msg_arg;
	357	int chip_addr, bus_num, op, xfer_flags;
	358	int res;
	359
	360	res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
	361	TEE_PARAM_ATTR_TYPE_MEMREF_INOUT,
	362	TEE_PARAM_ATTR_TYPE_NONE,
	363	TEE_PARAM_ATTR_TYPE_NONE,
	364	num_params, params);
	365	if (res)
	366	return TEE_ERROR_BAD_PARAMETERS;
	367
	368	bus_num = params[0].u.value.a;
	369	chip_addr = params[0].u.value.b;
	370	xfer_flags = params[0].u.value.c;
	371	memref_data = params[1].u.memref;
	372
	373	switch (func) {
374	case TA_RPC_TEST_CMD_I2C_READ:
375	op = OPTEE_MSG_RPC_CMD_I2C_TRANSFER_RD;
376	break;
377	case TA_RPC_TEST_CMD_I2C_WRITE:
378	op = OPTEE_MSG_RPC_CMD_I2C_TRANSFER_WR;
379	break;
380	default:
381	return TEE_ERROR_NOT_SUPPORTED;
382	}
383
384	/*
385	* Fill params for an RPC call to tee supplicant
386	*/
387	res = get_msg_arg(dev, 4, &shm, &msg_arg);
388	if (res)
389	goto out;
390
391	fill_i2c_rpc_params(msg_arg, bus_num, chip_addr, xfer_flags, op,
392	memref_data);
393
394	/* Make an RPC call to tee supplicant */
395	optee_suppl_cmd(dev, shm, 0);
396	res = msg_arg->ret;
397	out:
398	tee_shm_free(shm);
399
400	return res;
401	}
402	#endif /* CONFIG_OPTEE_TA_RPC_TEST */
eadf26f1 JW	403
	404	static const struct ta_entry ta_entries[] = {
	405	#ifdef CONFIG_OPTEE_TA_AVB
	406	{ .uuid = TA_AVB_UUID,
	407	.open_session = ta_avb_open_session,
	408	.invoke_func = ta_avb_invoke_func,
	409	},
	410	#endif
592b98bb IO	411	#ifdef CONFIG_OPTEE_TA_RPC_TEST
	412	{ .uuid = TA_RPC_TEST_UUID,
	413	.open_session = ta_rpc_test_open_session,
	414	.invoke_func = ta_rpc_test_invoke_func,
	415	},
	416	#endif
5a8783c8 JRO	417	#ifdef CONFIG_OPTEE_TA_SCP03
	418	{ .uuid = PTA_SCP03_UUID,
	419	.open_session = pta_scp03_open_session,
	420	.invoke_func = pta_scp03_invoke_func,
	421	},
	422	#endif
eadf26f1 JW	423	};
	424
	425	static void sandbox_tee_get_version(struct udevice *dev,
	426	struct tee_version_data *vers)
	427	{
	428	struct tee_version_data v = {
	429	.gen_caps = TEE_GEN_CAP_GP \| TEE_GEN_CAP_REG_MEM,
	430	};
	431
	432	*vers = v;
	433	}
	434
	435	static int sandbox_tee_close_session(struct udevice *dev, u32 session)
	436	{
	437	struct sandbox_tee_state *state = dev_get_priv(dev);
	438
	439	if (!state->ta \|\| state->session != session)
	440	return -EINVAL;
	441
	442	state->session = 0;
	443	state->ta = NULL;
	444
	445	return 0;
	446	}
	447
	448	static const struct ta_entry *find_ta_entry(u8 uuid[TEE_UUID_LEN])
	449	{
	450	struct tee_optee_ta_uuid u;
	451	uint n;
	452
	453	tee_optee_ta_uuid_from_octets(&u, uuid);
	454
	455	for (n = 0; n < ARRAY_SIZE(ta_entries); n++)
	456	if (!memcmp(&u, &ta_entries[n].uuid, sizeof(u)))
	457	return ta_entries + n;
	458
	459	return NULL;
	460	}
	461
	462	static int sandbox_tee_open_session(struct udevice *dev,
	463	struct tee_open_session_arg *arg,
	464	uint num_params, struct tee_param *params)
	465	{
	466	struct sandbox_tee_state *state = dev_get_priv(dev);
	467	const struct ta_entry *ta;
	468
	469	if (state->ta) {
	470	printf("A session is already open\n");
	471	return -EBUSY;
	472	}
	473
	474	ta = find_ta_entry(arg->uuid);
	475	if (!ta) {
	476	printf("Cannot find TA\n");
	477	arg->ret = TEE_ERROR_ITEM_NOT_FOUND;
	478	arg->ret_origin = TEE_ORIGIN_TEE;
	479
	480	return 0;
	481	}
	482
fc1fe01b	483	arg->ret = ta->open_session(dev, num_params, params);
eadf26f1 JW	484	arg->ret_origin = TEE_ORIGIN_TRUSTED_APP;
	485
	486	if (!arg->ret) {
	487	state->ta = (void *)ta;
	488	state->session = 1;
	489	arg->session = state->session;
	490	} else {
	491	printf("Cannot open session, TA returns error\n");
	492	}
	493
	494	return 0;
	495	}
	496
	497	static int sandbox_tee_invoke_func(struct udevice *dev,
	498	struct tee_invoke_arg *arg,
	499	uint num_params, struct tee_param *params)
	500	{
	501	struct sandbox_tee_state *state = dev_get_priv(dev);
	502	struct ta_entry *ta = state->ta;
	503
	504	if (!arg->session) {
	505	printf("Missing session\n");
	506	return -EINVAL;
	507	}
	508
	509	if (!ta) {
	510	printf("TA session not available\n");
	511	return -EINVAL;
	512	}
	513
	514	if (arg->session != state->session) {
	515	printf("Session mismatch\n");
	516	return -EINVAL;
	517	}
	518
fc1fe01b	519	arg->ret = ta->invoke_func(dev, arg->func, num_params, params);
eadf26f1 JW	520	arg->ret_origin = TEE_ORIGIN_TRUSTED_APP;
	521
	522	return 0;
	523	}
	524
	525	static int sandbox_tee_shm_register(struct udevice dev, struct tee_shm shm)
	526	{
	527	struct sandbox_tee_state *state = dev_get_priv(dev);
	528
	529	state->num_shms++;
	530
	531	return 0;
	532	}
	533
	534	static int sandbox_tee_shm_unregister(struct udevice dev, struct tee_shm shm)
	535	{
	536	struct sandbox_tee_state *state = dev_get_priv(dev);
	537
	538	state->num_shms--;
	539
	540	return 0;
	541	}
	542
fc1fe01b IO	543	static int sandbox_tee_remove(struct udevice *dev)
	544	{
	545	struct sandbox_tee_state *state = dev_get_priv(dev);
	546
	547	hdestroy_r(&state->pstorage_htab);
	548
	549	return 0;
	550	}
	551
	552	static int sandbox_tee_probe(struct udevice *dev)
	553	{
	554	struct sandbox_tee_state *state = dev_get_priv(dev);
	555	/*
	556	* With this hastable we emulate persistent storage,
	557	* which should contain persistent values
	558	* between different sessions/command invocations.
	559	*/
	560	if (!hcreate_r(pstorage_max, &state->pstorage_htab))
	561	return TEE_ERROR_OUT_OF_MEMORY;
	562
	563	return 0;
	564	}
	565
eadf26f1 JW	566	static const struct tee_driver_ops sandbox_tee_ops = {
	567	.get_version = sandbox_tee_get_version,
	568	.open_session = sandbox_tee_open_session,
	569	.close_session = sandbox_tee_close_session,
	570	.invoke_func = sandbox_tee_invoke_func,
	571	.shm_register = sandbox_tee_shm_register,
	572	.shm_unregister = sandbox_tee_shm_unregister,
	573	};
	574
	575	static const struct udevice_id sandbox_tee_match[] = {
	576	{ .compatible = "sandbox,tee" },
	577	{},
	578	};
	579
	580	U_BOOT_DRIVER(sandbox_tee) = {
	581	.name = "sandbox_tee",
	582	.id = UCLASS_TEE,
	583	.of_match = sandbox_tee_match,
	584	.ops = &sandbox_tee_ops,
41575d8e	585	.priv_auto = sizeof(struct sandbox_tee_state),
fc1fe01b IO	586	.probe = sandbox_tee_probe,
fc1fe01b IO	587	.remove = sandbox_tee_remove,
eadf26f1	588	};