From mboxrd@z Thu Jan 1 00:00:00 1970 From: Igor Opaniuk Date: Thu, 16 Aug 2018 15:17:41 +0300 Subject: [U-Boot] [PATCH 06/10] tee: add OP-TEE driver In-Reply-To: <20180813155347.13844-7-jens.wiklander@linaro.org> References: <20180813155347.13844-1-jens.wiklander@linaro.org> <20180813155347.13844-7-jens.wiklander@linaro.org> Message-ID: List-Id: MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: u-boot@lists.denx.de Tested-by: Igor Opaniuk On 13 August 2018 at 18:53, Jens Wiklander wrote: > Adds a OP-TEE driver. > > * Targets ARM and ARM64 > * Supports using any u-boot memory as shared memory > * Probes OP-TEE version using SMCs > * Uses OPTEE message protocol version 2 to communicate with secure world > > Signed-off-by: Jens Wiklander > --- > drivers/tee/Kconfig | 10 + > drivers/tee/Makefile | 1 + > drivers/tee/optee/Kconfig | 7 + > drivers/tee/optee/Makefile | 4 + > drivers/tee/optee/core.c | 614 +++++++++++++++++++++++ > drivers/tee/optee/optee_msg.h | 423 ++++++++++++++++ > drivers/tee/optee/optee_msg_supplicant.h | 234 +++++++++ > drivers/tee/optee/optee_private.h | 12 + > drivers/tee/optee/optee_smc.h | 444 ++++++++++++++++ > drivers/tee/optee/supplicant.c | 89 ++++ > 10 files changed, 1838 insertions(+) > create mode 100644 drivers/tee/optee/Kconfig > create mode 100644 drivers/tee/optee/Makefile > create mode 100644 drivers/tee/optee/core.c > create mode 100644 drivers/tee/optee/optee_msg.h > create mode 100644 drivers/tee/optee/optee_msg_supplicant.h > create mode 100644 drivers/tee/optee/optee_private.h > create mode 100644 drivers/tee/optee/optee_smc.h > create mode 100644 drivers/tee/optee/supplicant.c > > diff --git a/drivers/tee/Kconfig b/drivers/tee/Kconfig > index 817ab331b0f8..3e7fe6ddcc5d 100644 > --- a/drivers/tee/Kconfig > +++ b/drivers/tee/Kconfig > @@ -6,3 +6,13 @@ config TEE > help > This implements a generic interface towards a Trusted Execution > Environment (TEE). > + > +if TEE > + > +menu "TEE drivers" > + > +source "drivers/tee/optee/Kconfig" > + > +endmenu > + > +endif > diff --git a/drivers/tee/Makefile b/drivers/tee/Makefile > index b6d8e16e6211..19633b60f235 100644 > --- a/drivers/tee/Makefile > +++ b/drivers/tee/Makefile > @@ -1,3 +1,4 @@ > # SPDX-License-Identifier: GPL-2.0+ > > obj-y += tee-uclass.o > +obj-$(CONFIG_OPTEE) += optee/ > diff --git a/drivers/tee/optee/Kconfig b/drivers/tee/optee/Kconfig > new file mode 100644 > index 000000000000..8f7ebe161111 > --- /dev/null > +++ b/drivers/tee/optee/Kconfig > @@ -0,0 +1,7 @@ > +# OP-TEE Trusted Execution Environment Configuration > +config OPTEE > + bool "OP-TEE" > + depends on ARM_SMCCC > + help > + This implements the OP-TEE Trusted Execution Environment (TEE) > + driver. > diff --git a/drivers/tee/optee/Makefile b/drivers/tee/optee/Makefile > new file mode 100644 > index 000000000000..6148feb474a5 > --- /dev/null > +++ b/drivers/tee/optee/Makefile > @@ -0,0 +1,4 @@ > +# SPDX-License-Identifier: GPL-2.0+ > + > +obj-y += core.o > +obj-y += supplicant.o > diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c > new file mode 100644 > index 000000000000..a810f3b965de > --- /dev/null > +++ b/drivers/tee/optee/core.c > @@ -0,0 +1,614 @@ > +// SPDX-License-Identifier: GPL-2.0+ > +/* > + * Copyright (c) 2018 Linaro Limited > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "optee_smc.h" > +#include "optee_msg.h" > +#include "optee_private.h" > + > +#define PAGELIST_ENTRIES_PER_PAGE \ > + ((OPTEE_MSG_NONCONTIG_PAGE_SIZE / sizeof(u64)) - 1) > + > +typedef void (optee_invoke_fn)(unsigned long, unsigned long, unsigned long, > + unsigned long, unsigned long, unsigned long, > + unsigned long, unsigned long, > + struct arm_smccc_res *); > + > +struct optee_pdata { > + optee_invoke_fn *invoke_fn; > +}; > + > +struct rpc_param { > + u32 a0; > + u32 a1; > + u32 a2; > + u32 a3; > + u32 a4; > + u32 a5; > + u32 a6; > + u32 a7; > +}; > + > +static void *reg_pair_to_ptr(u32 reg0, u32 reg1) > +{ > + return (void *)(ulong)(((u64)reg0 << 32) | reg1); > +} > + > +static void reg_pair_from_64(u32 *reg0, u32 *reg1, u64 val) > +{ > + *reg0 = val >> 32; > + *reg1 = val; > +} > + > +void *optee_alloc_and_init_page_list(void *buf, ulong len, u64 *phys_buf_ptr) > +{ > + const unsigned int page_size = OPTEE_MSG_NONCONTIG_PAGE_SIZE; > + const phys_addr_t page_mask = page_size - 1; > + u8 *buf_base; > + unsigned int page_offset; > + unsigned int num_pages; > + unsigned int list_size; > + unsigned int n; > + void *page_list; > + struct { > + u64 pages_list[PAGELIST_ENTRIES_PER_PAGE]; > + u64 next_page_data; > + } *pages_data; > + > + page_offset = (ulong)buf & page_mask; > + num_pages = roundup(page_offset + len, page_size) / page_size; > + list_size = DIV_ROUND_UP(num_pages, PAGELIST_ENTRIES_PER_PAGE) * > + page_size; > + page_list = memalign(page_size, list_size); > + if (!page_list) > + return NULL; > + > + pages_data = page_list; > + buf_base = (u8 *)(rounddown((ulong)buf, page_size)); > + n = 0; > + while (num_pages) { > + pages_data->pages_list[n] = virt_to_phys(buf_base); > + n++; > + buf_base += page_size; > + num_pages--; > + > + if (n == PAGELIST_ENTRIES_PER_PAGE) { > + pages_data->next_page_data = > + virt_to_phys(pages_data + 1); > + pages_data++; > + n = 0; > + } > + } > + > + *phys_buf_ptr = virt_to_phys(page_list) | page_offset; > + return page_list; > +} > + > +static void optee_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 struct tee_shm *get_msg_arg(struct udevice *dev, ulong num_params, > + struct optee_msg_arg **msg_arg) > +{ > + struct tee_shm *shm; > + struct optee_msg_arg *ma; > + > + shm = __tee_shm_add(dev, OPTEE_MSG_NONCONTIG_PAGE_SIZE, NULL, > + OPTEE_MSG_GET_ARG_SIZE(num_params), TEE_SHM_ALLOC); > + if (!shm) > + return NULL; > + > + ma = shm->addr; > + memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params)); > + ma->num_params = num_params; > + *msg_arg = ma; > + > + return shm; > +} > + > +int to_msg_param(struct optee_msg_param *msg_params, ulong num_params, > + const struct tee_param *params) > +{ > + ulong n; > + > + for (n = 0; n < num_params; n++) { > + const struct tee_param *p = params + n; > + struct optee_msg_param *mp = msg_params + n; > + > + switch (p->attr) { > + case TEE_PARAM_ATTR_TYPE_NONE: > + mp->attr = OPTEE_MSG_ATTR_TYPE_NONE; > + memset(&mp->u, 0, sizeof(mp->u)); > + break; > + case TEE_PARAM_ATTR_TYPE_VALUE_INPUT: > + case TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT: > + case TEE_PARAM_ATTR_TYPE_VALUE_INOUT: > + mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr - > + TEE_PARAM_ATTR_TYPE_VALUE_INPUT; > + mp->u.value.a = p->u.value.a; > + mp->u.value.b = p->u.value.b; > + mp->u.value.c = p->u.value.c; > + break; > + case TEE_PARAM_ATTR_TYPE_MEMREF_INPUT: > + case TEE_PARAM_ATTR_TYPE_MEMREF_OUTPUT: > + case TEE_PARAM_ATTR_TYPE_MEMREF_INOUT: > + mp->attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT + p->attr - > + TEE_PARAM_ATTR_TYPE_MEMREF_INPUT; > + mp->u.rmem.shm_ref = (ulong)p->u.memref.shm; > + mp->u.rmem.size = p->u.memref.size; > + mp->u.rmem.offs = p->u.memref.shm_offs; > + break; > + default: > + return -EINVAL; > + } > + } > + return 0; > +} > + > +static int from_msg_param(struct tee_param *params, ulong num_params, > + const struct optee_msg_param *msg_params) > +{ > + ulong n; > + struct tee_shm *shm; > + > + for (n = 0; n < num_params; n++) { > + struct tee_param *p = params + n; > + const struct optee_msg_param *mp = msg_params + n; > + u32 attr = mp->attr & OPTEE_MSG_ATTR_TYPE_MASK; > + > + switch (attr) { > + case OPTEE_MSG_ATTR_TYPE_NONE: > + p->attr = TEE_PARAM_ATTR_TYPE_NONE; > + memset(&p->u, 0, sizeof(p->u)); > + break; > + case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT: > + case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT: > + case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT: > + p->attr = TEE_PARAM_ATTR_TYPE_VALUE_INPUT + attr - > + OPTEE_MSG_ATTR_TYPE_VALUE_INPUT; > + p->u.value.a = mp->u.value.a; > + p->u.value.b = mp->u.value.b; > + p->u.value.c = mp->u.value.c; > + break; > + case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT: > + case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT: > + case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT: > + p->attr = TEE_PARAM_ATTR_TYPE_MEMREF_INPUT + attr - > + OPTEE_MSG_ATTR_TYPE_RMEM_INPUT; > + p->u.memref.size = mp->u.rmem.size; > + shm = (struct tee_shm *)(ulong)mp->u.rmem.shm_ref; > + > + if (!shm) { > + p->u.memref.shm_offs = 0; > + p->u.memref.shm = NULL; > + break; > + } > + p->u.memref.shm_offs = mp->u.rmem.offs; > + p->u.memref.shm = shm; > + break; > + default: > + return -EINVAL; > + } > + } > + return 0; > +} > + > +static void handle_rpc(struct udevice *dev, struct rpc_param *param, > + void *page_list) > +{ > + struct tee_shm *shm; > + > + switch (OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0)) { > + case OPTEE_SMC_RPC_FUNC_ALLOC: > + shm = __tee_shm_add(dev, OPTEE_MSG_NONCONTIG_PAGE_SIZE, NULL, > + param->a1, > + TEE_SHM_ALLOC | TEE_SHM_REGISTER); > + if (shm) { > + reg_pair_from_64(¶m->a1, ¶m->a2, > + virt_to_phys(shm->addr)); > + /* "cookie" */ > + reg_pair_from_64(¶m->a4, ¶m->a5, (ulong)shm); > + } else { > + param->a1 = 0; > + param->a2 = 0; > + param->a4 = 0; > + param->a5 = 0; > + } > + break; > + case OPTEE_SMC_RPC_FUNC_FREE: > + shm = reg_pair_to_ptr(param->a1, param->a2); > + tee_shm_free(shm); > + break; > + case OPTEE_SMC_RPC_FUNC_FOREIGN_INTR: > + break; > + case OPTEE_SMC_RPC_FUNC_CMD: > + shm = reg_pair_to_ptr(param->a1, param->a2); > + optee_suppl_cmd(dev, shm, page_list); > + break; > + default: > + break; > + } > + > + param->a0 = OPTEE_SMC_CALL_RETURN_FROM_RPC; > +} > + > +static u32 call_err_to_res(u32 call_err) > +{ > + switch (call_err) { > + case OPTEE_SMC_RETURN_OK: > + return TEE_SUCCESS; > + default: > + return TEE_ERROR_BAD_PARAMETERS; > + } > +} > + > +static u32 do_call_with_arg(struct udevice *dev, struct optee_msg_arg *arg) > +{ > + struct optee_pdata *pdata = dev_get_platdata(dev); > + struct rpc_param param = { .a0 = OPTEE_SMC_CALL_WITH_ARG }; > + void *page_list = NULL; > + > + reg_pair_from_64(¶m.a1, ¶m.a2, virt_to_phys(arg)); > + while (true) { > + struct arm_smccc_res res; > + > + pdata->invoke_fn(param.a0, param.a1, param.a2, param.a3, > + param.a4, param.a5, param.a6, param.a7, &res); > + > + free(page_list); > + page_list = NULL; > + > + if (OPTEE_SMC_RETURN_IS_RPC(res.a0)) { > + param.a0 = res.a0; > + param.a1 = res.a1; > + param.a2 = res.a2; > + param.a3 = res.a3; > + handle_rpc(dev, ¶m, &page_list); > + } else { > + return call_err_to_res(res.a0); > + } > + } > +} > + > +int optee_close_session(struct udevice *dev, u32 session) > +{ > + struct tee_shm *shm; > + struct optee_msg_arg *msg_arg; > + > + shm = get_msg_arg(dev, 0, &msg_arg); > + if (!shm) > + return -ENOMEM; > + > + msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION; > + msg_arg->session = session; > + do_call_with_arg(dev, msg_arg); > + > + tee_shm_free(shm); > + return 0; > +} > + > +static int optee_open_session(struct udevice *dev, > + struct tee_open_session_arg *arg, > + ulong num_params, struct tee_param *params) > +{ > + int rc; > + struct tee_shm *shm; > + struct optee_msg_arg *msg_arg; > + > + shm = get_msg_arg(dev, num_params + 2, &msg_arg); > + if (!shm) > + return -ENOMEM; > + > + msg_arg->cmd = OPTEE_MSG_CMD_OPEN_SESSION; > + /* > + * Initialize and add the meta parameters needed when opening a > + * session. > + */ > + msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT | > + OPTEE_MSG_ATTR_META; > + msg_arg->params[1].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT | > + OPTEE_MSG_ATTR_META; > + memcpy(&msg_arg->params[0].u.value, arg->uuid, sizeof(arg->uuid)); > + memcpy(&msg_arg->params[1].u.value, arg->uuid, sizeof(arg->clnt_uuid)); > + msg_arg->params[1].u.value.c = arg->clnt_login; > + > + rc = to_msg_param(msg_arg->params + 2, num_params, params); > + if (rc) > + goto out; > + > + arg->ret = do_call_with_arg(dev, msg_arg); > + if (arg->ret) { > + arg->ret_origin = TEE_ORIGIN_COMMS; > + goto out; > + } > + > + if (from_msg_param(params, num_params, msg_arg->params + 2)) { > + arg->ret = TEE_ERROR_COMMUNICATION; > + arg->ret_origin = TEE_ORIGIN_COMMS; > + /* Close session again to avoid leakage */ > + optee_close_session(dev, msg_arg->session); > + goto out; > + } > + > + arg->session = msg_arg->session; > + arg->ret = msg_arg->ret; > + arg->ret_origin = msg_arg->ret_origin; > +out: > + tee_shm_free(shm); > + > + return rc; > +} > + > +int optee_invoke_func(struct udevice *dev, struct tee_invoke_arg *arg, > + ulong num_params, struct tee_param *params) > +{ > + struct tee_shm *shm; > + struct optee_msg_arg *msg_arg; > + int rc; > + > + shm = get_msg_arg(dev, num_params, &msg_arg); > + if (!shm) > + return -ENOMEM; > + msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND; > + msg_arg->func = arg->func; > + msg_arg->session = arg->session; > + > + rc = to_msg_param(msg_arg->params, num_params, params); > + if (rc) > + goto out; > + > + arg->ret = do_call_with_arg(dev, msg_arg); > + if (arg->ret) { > + arg->ret_origin = TEE_ORIGIN_COMMS; > + goto out; > + } > + > + if (from_msg_param(params, num_params, msg_arg->params)) { > + arg->ret = TEE_ERROR_COMMUNICATION; > + arg->ret_origin = TEE_ORIGIN_COMMS; > + goto out; > + } > + > + arg->ret = msg_arg->ret; > + arg->ret_origin = msg_arg->ret_origin; > +out: > + tee_shm_free(shm); > + return rc; > +} > + > +int optee_shm_register(struct udevice *dev, struct tee_shm *shm) > +{ > + struct tee_shm *shm_arg; > + struct optee_msg_arg *msg_arg; > + void *pl; > + u64 ph_ptr; > + int rc = 0; > + > + shm_arg = get_msg_arg(dev, 1, &msg_arg); > + if (!shm_arg) > + return -ENOMEM; > + > + pl = optee_alloc_and_init_page_list(shm->addr, shm->size, &ph_ptr); > + if (!pl) { > + rc = -ENOMEM; > + goto out; > + } > + > + msg_arg->cmd = OPTEE_MSG_CMD_REGISTER_SHM; > + msg_arg->params->attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT | > + OPTEE_MSG_ATTR_NONCONTIG; > + msg_arg->params->u.tmem.buf_ptr = ph_ptr; > + msg_arg->params->u.tmem.shm_ref = (ulong)shm; > + msg_arg->params->u.tmem.size = shm->size; > + > + if (do_call_with_arg(dev, msg_arg) || msg_arg->ret) > + rc = -EINVAL; > + > + free(pl); > +out: > + tee_shm_free(shm_arg); > + return rc; > +} > + > +int optee_shm_unregister(struct udevice *dev, struct tee_shm *shm) > +{ > + struct tee_shm *shm_arg; > + struct optee_msg_arg *msg_arg; > + int rc = 0; > + > + shm_arg = get_msg_arg(dev, 1, &msg_arg); > + if (!shm_arg) > + return -ENOMEM; > + > + msg_arg->cmd = OPTEE_MSG_CMD_UNREGISTER_SHM; > + msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT; > + msg_arg->params[0].u.rmem.shm_ref = (ulong)shm; > + > + if (do_call_with_arg(dev, msg_arg) || msg_arg->ret) > + rc = -EINVAL; > + tee_shm_free(shm_arg); > + return rc; > +} > + > +static const struct tee_driver_ops optee_ops = { > + .get_version = optee_get_version, > + .open_session = optee_open_session, > + .close_session = optee_close_session, > + .invoke_func = optee_invoke_func, > + .shm_register = optee_shm_register, > + .shm_unregister = optee_shm_unregister, > +}; > + > +static bool is_optee_api(optee_invoke_fn *invoke_fn) > +{ > + struct arm_smccc_res res; > + > + invoke_fn(OPTEE_SMC_CALLS_UID, 0, 0, 0, 0, 0, 0, 0, &res); > + > + return res.a0 == OPTEE_MSG_UID_0 && res.a1 == OPTEE_MSG_UID_1 && > + res.a2 == OPTEE_MSG_UID_2 && res.a3 == OPTEE_MSG_UID_3; > +} > + > +static void print_os_revision(optee_invoke_fn *invoke_fn) > +{ > + union { > + struct arm_smccc_res smccc; > + struct optee_smc_call_get_os_revision_result result; > + } res = { > + .result = { > + .build_id = 0 > + } > + }; > + > + invoke_fn(OPTEE_SMC_CALL_GET_OS_REVISION, 0, 0, 0, 0, 0, 0, 0, > + &res.smccc); > + > + if (res.result.build_id) > + debug("OP-TEE revision %lu.%lu (%08lx)\n", res.result.major, > + res.result.minor, res.result.build_id); > + else > + debug("OP-TEE revision %lu.%lu\n", res.result.major, > + res.result.minor); > +} > + > +static bool api_revision_is_compatible(optee_invoke_fn *invoke_fn) > +{ > + union { > + struct arm_smccc_res smccc; > + struct optee_smc_calls_revision_result result; > + } res; > + > + invoke_fn(OPTEE_SMC_CALLS_REVISION, 0, 0, 0, 0, 0, 0, 0, &res.smccc); > + > + return res.result.major == OPTEE_MSG_REVISION_MAJOR && > + (int)res.result.minor >= OPTEE_MSG_REVISION_MINOR; > +} > + > +static bool exchange_capabilities(optee_invoke_fn *invoke_fn, u32 *sec_caps) > +{ > + union { > + struct arm_smccc_res smccc; > + struct optee_smc_exchange_capabilities_result result; > + } res; > + > + invoke_fn(OPTEE_SMC_EXCHANGE_CAPABILITIES, > + OPTEE_SMC_NSEC_CAP_UNIPROCESSOR, 0, 0, 0, 0, 0, 0, > + &res.smccc); > + > + if (res.result.status != OPTEE_SMC_RETURN_OK) > + return false; > + > + *sec_caps = res.result.capabilities; > + return true; > +} > + > +/* Simple wrapper functions to be able to use a function pointer */ > +static void optee_smccc_smc(unsigned long a0, unsigned long a1, > + unsigned long a2, unsigned long a3, > + unsigned long a4, unsigned long a5, > + unsigned long a6, unsigned long a7, > + struct arm_smccc_res *res) > +{ > + arm_smccc_smc(a0, a1, a2, a3, a4, a5, a6, a7, res); > +} > + > +static void optee_smccc_hvc(unsigned long a0, unsigned long a1, > + unsigned long a2, unsigned long a3, > + unsigned long a4, unsigned long a5, > + unsigned long a6, unsigned long a7, > + struct arm_smccc_res *res) > +{ > + arm_smccc_hvc(a0, a1, a2, a3, a4, a5, a6, a7, res); > +} > + > +static optee_invoke_fn *get_invoke_func(struct udevice *dev) > +{ > + const char *method; > + > + debug("optee: looking for conduit method in DT.\n"); > + method = ofnode_get_property(dev->node, "method", NULL); > + if (!method) { > + debug("optee: missing \"method\" property\n"); > + return ERR_PTR(-ENXIO); > + } > + > + if (!strcmp("hvc", method)) > + return optee_smccc_hvc; > + else if (!strcmp("smc", method)) > + return optee_smccc_smc; > + > + debug("optee: invalid \"method\" property: %s\n", method); > + return ERR_PTR(-EINVAL); > +} > + > +static int optee_ofdata_to_platdata(struct udevice *dev) > +{ > + struct optee_pdata *pdata = dev_get_platdata(dev); > + > + pdata->invoke_fn = get_invoke_func(dev); > + if (IS_ERR(pdata->invoke_fn)) > + return PTR_ERR(pdata->invoke_fn); > + > + return 0; > +} > + > +static int optee_probe(struct udevice *dev) > +{ > + struct optee_pdata *pdata = dev_get_platdata(dev); > + u32 sec_caps; > + > + if (!is_optee_api(pdata->invoke_fn)) { > + debug("%s: OP-TEE api uid mismatch\n", __func__); > + return -ENOENT; > + } > + > + print_os_revision(pdata->invoke_fn); > + > + if (!api_revision_is_compatible(pdata->invoke_fn)) { > + debug("%s: OP-TEE api revision mismatch\n", __func__); > + return -ENOENT; > + } > + > + /* > + * OP-TEE can use both shared memory via predefined pool or as > + * dynamic shared memory provided by normal world. To keep things > + * simple we're only using dynamic shared memory in this driver. > + */ > + if (!exchange_capabilities(pdata->invoke_fn, &sec_caps) || > + !(sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)) { > + debug("%s: OP-TEE capabilities mismatch\n", __func__); > + return -ENOENT; > + } > + > + return 0; > +} > + > +static const struct udevice_id optee_match[] = { > + { .compatible = "linaro,optee-tz" }, > + {}, > +}; > + > +U_BOOT_DRIVER(optee) = { > + .name = "optee", > + .id = UCLASS_TEE, > + .of_match = optee_match, > + .ofdata_to_platdata = optee_ofdata_to_platdata, > + .probe = optee_probe, > + .ops = &optee_ops, > + .platdata_auto_alloc_size = sizeof(struct optee_pdata), > +}; > diff --git a/drivers/tee/optee/optee_msg.h b/drivers/tee/optee/optee_msg.h > new file mode 100644 > index 000000000000..ebc16aa8cc31 > --- /dev/null > +++ b/drivers/tee/optee/optee_msg.h > @@ -0,0 +1,423 @@ > +/* SPDX-License-Identifier: BSD-2-Clause */ > +/* > + * Copyright (c) 2015-2018, Linaro Limited > + */ > + > +#ifndef _OPTEE_MSG_H > +#define _OPTEE_MSG_H > + > +#include > +#include > + > +/* > + * This file defines the OP-TEE message protocol used to communicate > + * with an instance of OP-TEE running in secure world. > + * > + * This file is divided into three sections. > + * 1. Formatting of messages. > + * 2. Requests from normal world > + * 3. Requests from secure world, Remote Procedure Call (RPC), handled by > + * tee-supplicant. > + */ > + > +/***************************************************************************** > + * Part 1 - formatting of messages > + *****************************************************************************/ > + > +#define OPTEE_MSG_ATTR_TYPE_NONE 0x0 > +#define OPTEE_MSG_ATTR_TYPE_VALUE_INPUT 0x1 > +#define OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT 0x2 > +#define OPTEE_MSG_ATTR_TYPE_VALUE_INOUT 0x3 > +#define OPTEE_MSG_ATTR_TYPE_RMEM_INPUT 0x5 > +#define OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT 0x6 > +#define OPTEE_MSG_ATTR_TYPE_RMEM_INOUT 0x7 > +#define OPTEE_MSG_ATTR_TYPE_TMEM_INPUT 0x9 > +#define OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT 0xa > +#define OPTEE_MSG_ATTR_TYPE_TMEM_INOUT 0xb > + > +#define OPTEE_MSG_ATTR_TYPE_MASK GENMASK(7, 0) > + > +/* > + * Meta parameter to be absorbed by the Secure OS and not passed > + * to the Trusted Application. > + * > + * Currently only used with OPTEE_MSG_CMD_OPEN_SESSION. > + */ > +#define OPTEE_MSG_ATTR_META BIT(8) > + > +/* > + * Pointer to a list of pages used to register user-defined SHM buffer. > + * Used with OPTEE_MSG_ATTR_TYPE_TMEM_*. > + * buf_ptr should point to the beginning of the buffer. Buffer will contain > + * list of page addresses. OP-TEE core can reconstruct contiguous buffer from > + * that page addresses list. Page addresses are stored as 64 bit values. > + * Last entry on a page should point to the next page of buffer. > + * Every entry in buffer should point to a 4k page beginning (12 least > + * significant bits must be equal to zero). > + * > + * 12 least significant bints of optee_msg_param.u.tmem.buf_ptr should hold page > + * offset of the user buffer. > + * > + * So, entries should be placed like members of this structure: > + * > + * struct page_data { > + * uint64_t pages_array[OPTEE_MSG_NONCONTIG_PAGE_SIZE/sizeof(uint64_t) - 1]; > + * uint64_t next_page_data; > + * }; > + * > + * Structure is designed to exactly fit into the page size > + * OPTEE_MSG_NONCONTIG_PAGE_SIZE which is a standard 4KB page. > + * > + * The size of 4KB is chosen because this is the smallest page size for ARM > + * architectures. If REE uses larger pages, it should divide them to 4KB ones. > + */ > +#define OPTEE_MSG_ATTR_NONCONTIG BIT(9) > + > +/* > + * Memory attributes for caching passed with temp memrefs. The actual value > + * used is defined outside the message protocol with the exception of > + * OPTEE_MSG_ATTR_CACHE_PREDEFINED which means the attributes already > + * defined for the memory range should be used. If optee_smc.h is used as > + * bearer of this protocol OPTEE_SMC_SHM_* is used for values. > + */ > +#define OPTEE_MSG_ATTR_CACHE_SHIFT 16 > +#define OPTEE_MSG_ATTR_CACHE_MASK GENMASK(2, 0) > +#define OPTEE_MSG_ATTR_CACHE_PREDEFINED 0 > + > +/* > + * Same values as TEE_LOGIN_* from TEE Internal API > + */ > +#define OPTEE_MSG_LOGIN_PUBLIC 0x00000000 > +#define OPTEE_MSG_LOGIN_USER 0x00000001 > +#define OPTEE_MSG_LOGIN_GROUP 0x00000002 > +#define OPTEE_MSG_LOGIN_APPLICATION 0x00000004 > +#define OPTEE_MSG_LOGIN_APPLICATION_USER 0x00000005 > +#define OPTEE_MSG_LOGIN_APPLICATION_GROUP 0x00000006 > + > +/* > + * Page size used in non-contiguous buffer entries > + */ > +#define OPTEE_MSG_NONCONTIG_PAGE_SIZE 4096 > + > +/** > + * struct optee_msg_param_tmem - temporary memory reference parameter > + * @buf_ptr: Address of the buffer > + * @size: Size of the buffer > + * @shm_ref: Temporary shared memory reference, pointer to a struct tee_shm > + * > + * Secure and normal world communicates pointers as physical address > + * instead of the virtual address. This is because secure and normal world > + * have completely independent memory mapping. Normal world can even have a > + * hypervisor which need to translate the guest physical address (AKA IPA > + * in ARM documentation) to a real physical address before passing the > + * structure to secure world. > + */ > +struct optee_msg_param_tmem { > + u64 buf_ptr; > + u64 size; > + u64 shm_ref; > +}; > + > +/** > + * struct optee_msg_param_rmem - registered memory reference parameter > + * @offs: Offset into shared memory reference > + * @size: Size of the buffer > + * @shm_ref: Shared memory reference, pointer to a struct tee_shm > + */ > +struct optee_msg_param_rmem { > + u64 offs; > + u64 size; > + u64 shm_ref; > +}; > + > +/** > + * struct optee_msg_param_value - opaque value parameter > + * > + * Value parameters are passed unchecked between normal and secure world. > + */ > +struct optee_msg_param_value { > + u64 a; > + u64 b; > + u64 c; > +}; > + > +/** > + * struct optee_msg_param - parameter used together with struct optee_msg_arg > + * @attr: attributes > + * @tmem: parameter by temporary memory reference > + * @rmem: parameter by registered memory reference > + * @value: parameter by opaque value > + * > + * @attr & OPTEE_MSG_ATTR_TYPE_MASK indicates if tmem, rmem or value is used in > + * the union. OPTEE_MSG_ATTR_TYPE_VALUE_* indicates value, > + * OPTEE_MSG_ATTR_TYPE_TMEM_* indicates @tmem and > + * OPTEE_MSG_ATTR_TYPE_RMEM_* indicates @rmem, > + * OPTEE_MSG_ATTR_TYPE_NONE indicates that none of the members are used. > + */ > +struct optee_msg_param { > + u64 attr; > + union { > + struct optee_msg_param_tmem tmem; > + struct optee_msg_param_rmem rmem; > + struct optee_msg_param_value value; > + } u; > +}; > + > +/** > + * struct optee_msg_arg - call argument > + * @cmd: Command, one of OPTEE_MSG_CMD_* or OPTEE_MSG_RPC_CMD_* > + * @func: Trusted Application function, specific to the Trusted Application, > + * used if cmd == OPTEE_MSG_CMD_INVOKE_COMMAND > + * @session: In parameter for all OPTEE_MSG_CMD_* except > + * OPTEE_MSG_CMD_OPEN_SESSION where it's an output parameter instead > + * @cancel_id: Cancellation id, a unique value to identify this request > + * @ret: return value > + * @ret_origin: origin of the return value > + * @num_params: number of parameters supplied to the OS Command > + * @params: the parameters supplied to the OS Command > + * > + * All normal calls to Trusted OS uses this struct. If cmd requires further > + * information than what these field holds it can be passed as a parameter > + * tagged as meta (setting the OPTEE_MSG_ATTR_META bit in corresponding > + * attrs field). All parameters tagged as meta has to come first. > + * > + * Temp memref parameters can be fragmented if supported by the Trusted OS > + * (when optee_smc.h is bearer of this protocol this is indicated with > + * OPTEE_SMC_SEC_CAP_UNREGISTERED_SHM). If a logical memref parameter is > + * fragmented then has all but the last fragment the > + * OPTEE_MSG_ATTR_FRAGMENT bit set in attrs. Even if a memref is fragmented > + * it will still be presented as a single logical memref to the Trusted > + * Application. > + */ > +struct optee_msg_arg { > + u32 cmd; > + u32 func; > + u32 session; > + u32 cancel_id; > + u32 pad; > + u32 ret; > + u32 ret_origin; > + u32 num_params; > + > + /* num_params tells the actual number of element in params */ > + struct optee_msg_param params[0]; > +}; > + > +/** > + * OPTEE_MSG_GET_ARG_SIZE - return size of struct optee_msg_arg > + * > + * @num_params: Number of parameters embedded in the struct optee_msg_arg > + * > + * Returns the size of the struct optee_msg_arg together with the number > + * of embedded parameters. > + */ > +#define OPTEE_MSG_GET_ARG_SIZE(num_params) \ > + (sizeof(struct optee_msg_arg) + \ > + sizeof(struct optee_msg_param) * (num_params)) > + > +/***************************************************************************** > + * Part 2 - requests from normal world > + *****************************************************************************/ > + > +/* > + * Return the following UID if using API specified in this file without > + * further extensions: > + * 384fb3e0-e7f8-11e3-af63-0002a5d5c51b. > + * Represented in 4 32-bit words in OPTEE_MSG_UID_0, OPTEE_MSG_UID_1, > + * OPTEE_MSG_UID_2, OPTEE_MSG_UID_3. > + */ > +#define OPTEE_MSG_UID_0 0x384fb3e0 > +#define OPTEE_MSG_UID_1 0xe7f811e3 > +#define OPTEE_MSG_UID_2 0xaf630002 > +#define OPTEE_MSG_UID_3 0xa5d5c51b > +#define OPTEE_MSG_FUNCID_CALLS_UID 0xFF01 > + > +/* > + * Returns 2.0 if using API specified in this file without further > + * extensions. Represented in 2 32-bit words in OPTEE_MSG_REVISION_MAJOR > + * and OPTEE_MSG_REVISION_MINOR > + */ > +#define OPTEE_MSG_REVISION_MAJOR 2 > +#define OPTEE_MSG_REVISION_MINOR 0 > +#define OPTEE_MSG_FUNCID_CALLS_REVISION 0xFF03 > + > +/* > + * Get UUID of Trusted OS. > + * > + * Used by non-secure world to figure out which Trusted OS is installed. > + * Note that returned UUID is the UUID of the Trusted OS, not of the API. > + * > + * Returns UUID in 4 32-bit words in the same way as > + * OPTEE_MSG_FUNCID_CALLS_UID described above. > + */ > +#define OPTEE_MSG_OS_OPTEE_UUID_0 0x486178e0 > +#define OPTEE_MSG_OS_OPTEE_UUID_1 0xe7f811e3 > +#define OPTEE_MSG_OS_OPTEE_UUID_2 0xbc5e0002 > +#define OPTEE_MSG_OS_OPTEE_UUID_3 0xa5d5c51b > +#define OPTEE_MSG_FUNCID_GET_OS_UUID 0x0000 > + > +/* > + * Get revision of Trusted OS. > + * > + * Used by non-secure world to figure out which version of the Trusted OS > + * is installed. Note that the returned revision is the revision of the > + * Trusted OS, not of the API. > + * > + * Returns revision in 2 32-bit words in the same way as > + * OPTEE_MSG_CALLS_REVISION described above. > + */ > +#define OPTEE_MSG_FUNCID_GET_OS_REVISION 0x0001 > + > +/* > + * Do a secure call with struct optee_msg_arg as argument > + * The OPTEE_MSG_CMD_* below defines what goes in struct optee_msg_arg::cmd > + * > + * OPTEE_MSG_CMD_OPEN_SESSION opens a session to a Trusted Application. > + * The first two parameters are tagged as meta, holding two value > + * parameters to pass the following information: > + * param[0].u.value.a-b uuid of Trusted Application > + * param[1].u.value.a-b uuid of Client > + * param[1].u.value.c Login class of client OPTEE_MSG_LOGIN_* > + * > + * OPTEE_MSG_CMD_INVOKE_COMMAND invokes a command a previously opened > + * session to a Trusted Application. struct optee_msg_arg::func is Trusted > + * Application function, specific to the Trusted Application. > + * > + * OPTEE_MSG_CMD_CLOSE_SESSION closes a previously opened session to > + * Trusted Application. > + * > + * OPTEE_MSG_CMD_CANCEL cancels a currently invoked command. > + * > + * OPTEE_MSG_CMD_REGISTER_SHM registers a shared memory reference. The > + * information is passed as: > + * [in] param[0].attr OPTEE_MSG_ATTR_TYPE_TMEM_INPUT > + * [| OPTEE_MSG_ATTR_FRAGMENT] > + * [in] param[0].u.tmem.buf_ptr physical address (of first fragment) > + * [in] param[0].u.tmem.size size (of first fragment) > + * [in] param[0].u.tmem.shm_ref holds shared memory reference > + * ... > + * The shared memory can optionally be fragmented, temp memrefs can follow > + * each other with all but the last with the OPTEE_MSG_ATTR_FRAGMENT bit set. > + * > + * OPTEE_MSG_CMD_UNREGISTER_SHM unregisteres a previously registered shared > + * memory reference. The information is passed as: > + * [in] param[0].attr OPTEE_MSG_ATTR_TYPE_RMEM_INPUT > + * [in] param[0].u.rmem.shm_ref holds shared memory reference > + * [in] param[0].u.rmem.offs 0 > + * [in] param[0].u.rmem.size 0 > + */ > +#define OPTEE_MSG_CMD_OPEN_SESSION 0 > +#define OPTEE_MSG_CMD_INVOKE_COMMAND 1 > +#define OPTEE_MSG_CMD_CLOSE_SESSION 2 > +#define OPTEE_MSG_CMD_CANCEL 3 > +#define OPTEE_MSG_CMD_REGISTER_SHM 4 > +#define OPTEE_MSG_CMD_UNREGISTER_SHM 5 > +#define OPTEE_MSG_FUNCID_CALL_WITH_ARG 0x0004 > + > +/***************************************************************************** > + * Part 3 - Requests from secure world, RPC > + *****************************************************************************/ > + > +/* > + * All RPC is done with a struct optee_msg_arg as bearer of information, > + * struct optee_msg_arg::arg holds values defined by OPTEE_MSG_RPC_CMD_* below > + * > + * RPC communication with tee-supplicant is reversed compared to normal > + * client communication desribed above. The supplicant receives requests > + * and sends responses. > + */ > + > +/* > + * Load a TA into memory, defined in tee-supplicant > + */ > +#define OPTEE_MSG_RPC_CMD_LOAD_TA 0 > + > +/* > + * Reserved > + */ > +#define OPTEE_MSG_RPC_CMD_RPMB 1 > + > +/* > + * File system access, defined in tee-supplicant > + */ > +#define OPTEE_MSG_RPC_CMD_FS 2 > + > +/* > + * Get time > + * > + * Returns number of seconds and nano seconds since the Epoch, > + * 1970-01-01 00:00:00 +0000 (UTC). > + * > + * [out] param[0].u.value.a Number of seconds > + * [out] param[0].u.value.b Number of nano seconds. > + */ > +#define OPTEE_MSG_RPC_CMD_GET_TIME 3 > + > +/* > + * Wait queue primitive, helper for secure world to implement a wait queue. > + * > + * If secure world need to wait for a secure world mutex it issues a sleep > + * request instead of spinning in secure world. Conversely is a wakeup > + * request issued when a secure world mutex with a thread waiting thread is > + * unlocked. > + * > + * Waiting on a key > + * [in] param[0].u.value.a OPTEE_MSG_RPC_WAIT_QUEUE_SLEEP > + * [in] param[0].u.value.b wait key > + * > + * Waking up a key > + * [in] param[0].u.value.a OPTEE_MSG_RPC_WAIT_QUEUE_WAKEUP > + * [in] param[0].u.value.b wakeup key > + */ > +#define OPTEE_MSG_RPC_CMD_WAIT_QUEUE 4 > +#define OPTEE_MSG_RPC_WAIT_QUEUE_SLEEP 0 > +#define OPTEE_MSG_RPC_WAIT_QUEUE_WAKEUP 1 > + > +/* > + * Suspend execution > + * > + * [in] param[0].value .a number of milliseconds to suspend > + */ > +#define OPTEE_MSG_RPC_CMD_SUSPEND 5 > + > +/* > + * Allocate a piece of shared memory > + * > + * Shared memory can optionally be fragmented, to support that additional > + * spare param entries are allocated to make room for eventual fragments. > + * The spare param entries has .attr = OPTEE_MSG_ATTR_TYPE_NONE when > + * unused. All returned temp memrefs except the last should have the > + * OPTEE_MSG_ATTR_FRAGMENT bit set in the attr field. > + * > + * [in] param[0].u.value.a type of memory one of > + * OPTEE_MSG_RPC_SHM_TYPE_* below > + * [in] param[0].u.value.b requested size > + * [in] param[0].u.value.c required alignment > + * > + * [out] param[0].u.tmem.buf_ptr physical address (of first fragment) > + * [out] param[0].u.tmem.size size (of first fragment) > + * [out] param[0].u.tmem.shm_ref shared memory reference > + * ... > + * [out] param[n].u.tmem.buf_ptr physical address > + * [out] param[n].u.tmem.size size > + * [out] param[n].u.tmem.shm_ref shared memory reference (same value > + * as in param[n-1].u.tmem.shm_ref) > + */ > +#define OPTEE_MSG_RPC_CMD_SHM_ALLOC 6 > +/* Memory that can be shared with a non-secure user space application */ > +#define OPTEE_MSG_RPC_SHM_TYPE_APPL 0 > +/* Memory only shared with non-secure kernel */ > +#define OPTEE_MSG_RPC_SHM_TYPE_KERNEL 1 > + > +/* > + * Free shared memory previously allocated with OPTEE_MSG_RPC_CMD_SHM_ALLOC > + * > + * [in] param[0].u.value.a type of memory one of > + * OPTEE_MSG_RPC_SHM_TYPE_* above > + * [in] param[0].u.value.b value of shared memory reference > + * returned in param[0].u.tmem.shm_ref > + * above > + */ > +#define OPTEE_MSG_RPC_CMD_SHM_FREE 7 > + > +#endif /* _OPTEE_MSG_H */ > diff --git a/drivers/tee/optee/optee_msg_supplicant.h b/drivers/tee/optee/optee_msg_supplicant.h > new file mode 100644 > index 000000000000..65ca6c0574b9 > --- /dev/null > +++ b/drivers/tee/optee/optee_msg_supplicant.h > @@ -0,0 +1,234 @@ > +/* SPDX-License-Identifier: BSD-2-Clause */ > +/* > + * Copyright (c) 2016-2018, Linaro Limited > + */ > + > +#ifndef __OPTEE_MSG_SUPPLICANT_H > +#define __OPTEE_MSG_SUPPLICANT_H > + > +/* > + * Load a TA into memory > + */ > +#define OPTEE_MSG_RPC_CMD_LOAD_TA 0 > + > +/* > + * Replay Protected Memory Block access > + */ > +#define OPTEE_MSG_RPC_CMD_RPMB 1 > + > +/* > + * File system access > + */ > +#define OPTEE_MSG_RPC_CMD_FS 2 > + > +/* > + * Define protocol for messages with .cmd == OPTEE_MSG_RPC_CMD_FS and first > + * parameter has the attribute OPTEE_MSG_ATTR_TYPE_VALUE_INPUT. > + */ > + > +/* > + * Open a file > + * > + * [in] param[0].u.value.a OPTEE_MRF_OPEN > + * [in] param[1].u.tmem a string holding the file name > + * [out] param[2].u.value.a file descriptor of open file > + */ > +#define OPTEE_MRF_OPEN 0 > + > +/* > + * Create a file > + * > + * [in] param[0].u.value.a OPTEE_MRF_CREATE > + * [in] param[1].u.tmem a string holding the file name > + * [out] param[2].u.value.a file descriptor of open file > + */ > +#define OPTEE_MRF_CREATE 1 > + > +/* > + * Close a file > + * > + * [in] param[0].u.value.a OPTEE_MRF_CLOSE > + * [in] param[0].u.value.b file descriptor of open file. > + */ > +#define OPTEE_MRF_CLOSE 2 > + > +/* > + * Read from a file > + * > + * [in] param[0].u.value.a OPTEE_MRF_READ > + * [in] param[0].u.value.b file descriptor of open file > + * [in] param[0].u.value.c offset into file > + * [out] param[1].u.tmem buffer to hold returned data > + */ > +#define OPTEE_MRF_READ 3 > + > +/* > + * Write to a file > + * > + * [in] param[0].u.value.a OPTEE_MRF_WRITE > + * [in] param[0].u.value.b file descriptor of open file > + * [in] param[0].u.value.c offset into file > + * [in] param[1].u.tmem buffer holding data to be written > + */ > +#define OPTEE_MRF_WRITE 4 > + > +/* > + * Truncate a file > + * > + * [in] param[0].u.value.a OPTEE_MRF_TRUNCATE > + * [in] param[0].u.value.b file descriptor of open file > + * [in] param[0].u.value.c length of file. > + */ > +#define OPTEE_MRF_TRUNCATE 5 > + > +/* > + * Remove a file > + * > + * [in] param[0].u.value.a OPTEE_MRF_REMOVE > + * [in] param[1].u.tmem a string holding the file name > + */ > +#define OPTEE_MRF_REMOVE 6 > + > +/* > + * Rename a file > + * > + * [in] param[0].u.value.a OPTEE_MRF_RENAME > + * [in] param[0].u.value.b true if existing target should be removed > + * [in] param[1].u.tmem a string holding the old file name > + * [in] param[2].u.tmem a string holding the new file name > + */ > +#define OPTEE_MRF_RENAME 7 > + > +/* > + * Opens a directory for file listing > + * > + * [in] param[0].u.value.a OPTEE_MRF_OPENDIR > + * [in] param[1].u.tmem a string holding the name of the directory > + * [out] param[2].u.value.a handle to open directory > + */ > +#define OPTEE_MRF_OPENDIR 8 > + > +/* > + * Closes a directory handle > + * > + * [in] param[0].u.value.a OPTEE_MRF_CLOSEDIR > + * [in] param[0].u.value.b handle to open directory > + */ > +#define OPTEE_MRF_CLOSEDIR 9 > + > +/* > + * Read next file name of directory > + * > + * > + * [in] param[0].u.value.a OPTEE_MRF_READDIR > + * [in] param[0].u.value.b handle to open directory > + * [out] param[1].u.tmem a string holding the file name > + */ > +#define OPTEE_MRF_READDIR 10 > + > +/* > + * End of definitions for messages with .cmd == OPTEE_MSG_RPC_CMD_FS > + */ > + > +/* > + * Command Ids 3, 4 and 5 of OPTEE_MSG_RPC_CMD_xxx macros are reserved for use > + * by the kernel driver. > + */ > + > +/* > + * Shared memory allocation > + */ > +#define OPTEE_MSG_RPC_CMD_SHM_ALLOC 6 > +#define OPTEE_MSG_RPC_CMD_SHM_FREE 7 > + > +/* > + * Was OPTEE_MSG_RPC_CMD_SQL_FS, which isn't supported any longer > + */ > +#define OPTEE_MSG_RPC_CMD_SQL_FS_RESERVED 8 > + > +/* > + * GPROF support management commands > + */ > +#define OPTEE_MSG_RPC_CMD_GPROF 9 > + > +/* > + * Socket commands > + */ > +#define OPTEE_MSG_RPC_CMD_SOCKET 10 > + > +/* > + * Define protocol for messages with .cmd == OPTEE_MSG_RPC_CMD_SOCKET > + */ > + > +#define OPTEE_MRC_SOCKET_TIMEOUT_NONBLOCKING 0 > +#define OPTEE_MRC_SOCKET_TIMEOUT_BLOCKING 0xffffffff > + > +/* > + * Open socket > + * > + * [in] param[0].u.value.a OPTEE_MRC_SOCKET_OPEN > + * [in] param[0].u.value.b TA instance id > + * [in] param[1].u.value.a server port number > + * [in] param[1].u.value.b protocol, TEE_ISOCKET_PROTOCOLID_* > + * [in] param[1].u.value.c ip version TEE_IP_VERSION_* from tee_ipsocket.h > + * [in] param[2].u.tmem server address > + * [out] param[3].u.value.a socket handle (32-bit) > + */ > +#define OPTEE_MRC_SOCKET_OPEN 0 > + > +/* > + * Close socket > + * > + * [in] param[0].u.value.a OPTEE_MRC_SOCKET_CLOSE > + * [in] param[0].u.value.b TA instance id > + * [in] param[0].u.value.c socket handle > + */ > +#define OPTEE_MRC_SOCKET_CLOSE 1 > + > +/* > + * Close all sockets > + * > + * [in] param[0].u.value.a OPTEE_MRC_SOCKET_CLOSE_ALL > + * [in] param[0].u.value.b TA instance id > + */ > +#define OPTEE_MRC_SOCKET_CLOSE_ALL 2 > + > +/* > + * Send data on socket > + * > + * [in] param[0].u.value.a OPTEE_MRC_SOCKET_SEND > + * [in] param[0].u.value.b TA instance id > + * [in] param[0].u.value.c socket handle > + * [in] param[1].u.tmem buffer to transmit > + * [in] param[2].u.value.a timeout ms or OPTEE_MRC_SOCKET_TIMEOUT_* > + * [out] param[2].u.value.b number of transmitted bytes > + */ > +#define OPTEE_MRC_SOCKET_SEND 3 > + > +/* > + * Receive data on socket > + * > + * [in] param[0].u.value.a OPTEE_MRC_SOCKET_RECV > + * [in] param[0].u.value.b TA instance id > + * [in] param[0].u.value.c socket handle > + * [out] param[1].u.tmem buffer to receive > + * [in] param[2].u.value.a timeout ms or OPTEE_MRC_SOCKET_TIMEOUT_* > + */ > +#define OPTEE_MRC_SOCKET_RECV 4 > + > +/* > + * Perform IOCTL on socket > + * > + * [in] param[0].u.value.a OPTEE_MRC_SOCKET_IOCTL > + * [in] param[0].u.value.b TA instance id > + * [in] param[0].u.value.c socket handle > + * [in/out] param[1].u.tmem buffer > + * [in] param[2].u.value.a ioctl command > + */ > +#define OPTEE_MRC_SOCKET_IOCTL 5 > + > +/* > + * End of definitions for messages with .cmd == OPTEE_MSG_RPC_CMD_SOCKET > + */ > + > +#endif /*__OPTEE_MSG_SUPPLICANT_H*/ > diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h > new file mode 100644 > index 000000000000..daa470f812a9 > --- /dev/null > +++ b/drivers/tee/optee/optee_private.h > @@ -0,0 +1,12 @@ > +/* SPDX-License-Identifier: GPL-2.0+ */ > +/* > + * Copyright (c) 2018 Linaro Limited > + */ > + > +#ifndef __OPTEE_PRIVATE_H > +#define __OPTEE_PRIVATE_H > + > +void *optee_alloc_and_init_page_list(void *buf, ulong len, u64 *phys_buf_ptr); > +void optee_suppl_cmd(struct udevice *dev, void *shm, void **page_list); > + > +#endif /*__OPTEE_PRIVATE_H*/ > diff --git a/drivers/tee/optee/optee_smc.h b/drivers/tee/optee/optee_smc.h > new file mode 100644 > index 000000000000..81069ae6f8ac > --- /dev/null > +++ b/drivers/tee/optee/optee_smc.h > @@ -0,0 +1,444 @@ > +/* SPDX-License-Identifier: BSD-2-Clause */ > +/* > + * Copyright (c) 2015-2018, Linaro Limited > + */ > + > +#ifndef OPTEE_SMC_H > +#define OPTEE_SMC_H > + > +#include > +#include > + > +#define OPTEE_SMC_STD_CALL_VAL(func_num) \ > + ARM_SMCCC_CALL_VAL(ARM_SMCCC_STD_CALL, ARM_SMCCC_SMC_32, \ > + ARM_SMCCC_OWNER_TRUSTED_OS, (func_num)) > +#define OPTEE_SMC_FAST_CALL_VAL(func_num) \ > + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, ARM_SMCCC_SMC_32, \ > + ARM_SMCCC_OWNER_TRUSTED_OS, (func_num)) > + > +/* > + * Function specified by SMC Calling convention. > + */ > +#define OPTEE_SMC_FUNCID_CALLS_COUNT 0xFF00 > +#define OPTEE_SMC_CALLS_COUNT \ > + ARM_SMCCC_CALL_VAL(OPTEE_SMC_FAST_CALL, SMCCC_SMC_32, \ > + SMCCC_OWNER_TRUSTED_OS_END, \ > + OPTEE_SMC_FUNCID_CALLS_COUNT) > + > +/* > + * Normal cached memory (write-back), shareable for SMP systems and not > + * shareable for UP systems. > + */ > +#define OPTEE_SMC_SHM_CACHED 1 > + > +/* > + * a0..a7 is used as register names in the descriptions below, on arm32 > + * that translates to r0..r7 and on arm64 to w0..w7. In both cases it's > + * 32-bit registers. > + */ > + > +/* > + * Function specified by SMC Calling convention > + * > + * Return one of the following UIDs if using API specified in this file > + * without further extentions: > + * 65cb6b93-af0c-4617-8ed6-644a8d1140f8 > + * see also OPTEE_SMC_UID_* in optee_msg.h > + */ > +#define OPTEE_SMC_FUNCID_CALLS_UID OPTEE_MSG_FUNCID_CALLS_UID > +#define OPTEE_SMC_CALLS_UID \ > + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, ARM_SMCCC_SMC_32, \ > + ARM_SMCCC_OWNER_TRUSTED_OS_END, \ > + OPTEE_SMC_FUNCID_CALLS_UID) > + > +/* > + * Function specified by SMC Calling convention > + * > + * Returns 2.0 if using API specified in this file without further extentions. > + * see also OPTEE_MSG_REVISION_* in optee_msg.h > + */ > +#define OPTEE_SMC_FUNCID_CALLS_REVISION OPTEE_MSG_FUNCID_CALLS_REVISION > +#define OPTEE_SMC_CALLS_REVISION \ > + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, ARM_SMCCC_SMC_32, \ > + ARM_SMCCC_OWNER_TRUSTED_OS_END, \ > + OPTEE_SMC_FUNCID_CALLS_REVISION) > + > +struct optee_smc_calls_revision_result { > + unsigned long major; > + unsigned long minor; > + unsigned long reserved0; > + unsigned long reserved1; > +}; > + > +/* > + * Get UUID of Trusted OS. > + * > + * Used by non-secure world to figure out which Trusted OS is installed. > + * Note that returned UUID is the UUID of the Trusted OS, not of the API. > + * > + * Returns UUID in a0-4 in the same way as OPTEE_SMC_CALLS_UID > + * described above. > + */ > +#define OPTEE_SMC_FUNCID_GET_OS_UUID OPTEE_MSG_FUNCID_GET_OS_UUID > +#define OPTEE_SMC_CALL_GET_OS_UUID \ > + OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_OS_UUID) > + > +/* > + * Get revision of Trusted OS. > + * > + * Used by non-secure world to figure out which version of the Trusted OS > + * is installed. Note that the returned revision is the revision of the > + * Trusted OS, not of the API. > + * > + * Returns revision in a0-1 in the same way as OPTEE_SMC_CALLS_REVISION > + * described above. May optionally return a 32-bit build identifier in a2, > + * with zero meaning unspecified. > + */ > +#define OPTEE_SMC_FUNCID_GET_OS_REVISION OPTEE_MSG_FUNCID_GET_OS_REVISION > +#define OPTEE_SMC_CALL_GET_OS_REVISION \ > + OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_OS_REVISION) > + > +struct optee_smc_call_get_os_revision_result { > + unsigned long major; > + unsigned long minor; > + unsigned long build_id; > + unsigned long reserved1; > +}; > + > +/* > + * Call with struct optee_msg_arg as argument > + * > + * Call register usage: > + * a0 SMC Function ID, OPTEE_SMC*CALL_WITH_ARG > + * a1 Upper 32bit of a 64bit physical pointer to a struct optee_msg_arg > + * a2 Lower 32bit of a 64bit physical pointer to a struct optee_msg_arg > + * a3 Cache settings, not used if physical pointer is in a predefined shared > + * memory area else per OPTEE_SMC_SHM_* > + * a4-6 Not used > + * a7 Hypervisor Client ID register > + * > + * Normal return register usage: > + * a0 Return value, OPTEE_SMC_RETURN_* > + * a1-3 Not used > + * a4-7 Preserved > + * > + * OPTEE_SMC_RETURN_ETHREAD_LIMIT return register usage: > + * a0 Return value, OPTEE_SMC_RETURN_ETHREAD_LIMIT > + * a1-3 Preserved > + * a4-7 Preserved > + * > + * RPC return register usage: > + * a0 Return value, OPTEE_SMC_RETURN_IS_RPC(val) > + * a1-2 RPC parameters > + * a3-7 Resume information, must be preserved > + * > + * Possible return values: > + * OPTEE_SMC_RETURN_UNKNOWN_FUNCTION Trusted OS does not recognize this > + * function. > + * OPTEE_SMC_RETURN_OK Call completed, result updated in > + * the previously supplied struct > + * optee_msg_arg. > + * OPTEE_SMC_RETURN_ETHREAD_LIMIT Number of Trusted OS threads exceeded, > + * try again later. > + * OPTEE_SMC_RETURN_EBADADDR Bad physcial pointer to struct > + * optee_msg_arg. > + * OPTEE_SMC_RETURN_EBADCMD Bad/unknown cmd in struct optee_msg_arg > + * OPTEE_SMC_RETURN_IS_RPC() Call suspended by RPC call to normal > + * world. > + */ > +#define OPTEE_SMC_FUNCID_CALL_WITH_ARG OPTEE_MSG_FUNCID_CALL_WITH_ARG > +#define OPTEE_SMC_CALL_WITH_ARG \ > + OPTEE_SMC_STD_CALL_VAL(OPTEE_SMC_FUNCID_CALL_WITH_ARG) > + > +/* > + * Get Shared Memory Config > + * > + * Returns the Secure/Non-secure shared memory config. > + * > + * Call register usage: > + * a0 SMC Function ID, OPTEE_SMC_GET_SHM_CONFIG > + * a1-6 Not used > + * a7 Hypervisor Client ID register > + * > + * Have config return register usage: > + * a0 OPTEE_SMC_RETURN_OK > + * a1 Physical address of start of SHM > + * a2 Size of of SHM > + * a3 Cache settings of memory, as defined by the > + * OPTEE_SMC_SHM_* values above > + * a4-7 Preserved > + * > + * Not available register usage: > + * a0 OPTEE_SMC_RETURN_ENOTAVAIL > + * a1-3 Not used > + * a4-7 Preserved > + */ > +#define OPTEE_SMC_FUNCID_GET_SHM_CONFIG 7 > +#define OPTEE_SMC_GET_SHM_CONFIG \ > + OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_SHM_CONFIG) > + > +struct optee_smc_get_shm_config_result { > + unsigned long status; > + unsigned long start; > + unsigned long size; > + unsigned long settings; > +}; > + > +/* > + * Exchanges capabilities between normal world and secure world > + * > + * Call register usage: > + * a0 SMC Function ID, OPTEE_SMC_EXCHANGE_CAPABILITIES > + * a1 bitfield of normal world capabilities OPTEE_SMC_NSEC_CAP_* > + * a2-6 Not used > + * a7 Hypervisor Client ID register > + * > + * Normal return register usage: > + * a0 OPTEE_SMC_RETURN_OK > + * a1 bitfield of secure world capabilities OPTEE_SMC_SEC_CAP_* > + * a2-7 Preserved > + * > + * Error return register usage: > + * a0 OPTEE_SMC_RETURN_ENOTAVAIL, can't use the capabilities from normal world > + * a1 bitfield of secure world capabilities OPTEE_SMC_SEC_CAP_* > + * a2-7 Preserved > + */ > +/* Normal world works as a uniprocessor system */ > +#define OPTEE_SMC_NSEC_CAP_UNIPROCESSOR BIT(0) > +/* Secure world has reserved shared memory for normal world to use */ > +#define OPTEE_SMC_SEC_CAP_HAVE_RESERVED_SHM BIT(0) > +/* Secure world can communicate via previously unregistered shared memory */ > +#define OPTEE_SMC_SEC_CAP_UNREGISTERED_SHM BIT(1) > + > +/* > + * Secure world supports commands "register/unregister shared memory", > + * secure world accepts command buffers located in any parts of non-secure RAM > + */ > +#define OPTEE_SMC_SEC_CAP_DYNAMIC_SHM BIT(2) > + > +#define OPTEE_SMC_FUNCID_EXCHANGE_CAPABILITIES 9 > +#define OPTEE_SMC_EXCHANGE_CAPABILITIES \ > + OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_EXCHANGE_CAPABILITIES) > + > +struct optee_smc_exchange_capabilities_result { > + unsigned long status; > + unsigned long capabilities; > + unsigned long reserved0; > + unsigned long reserved1; > +}; > + > +/* > + * Disable and empties cache of shared memory objects > + * > + * Secure world can cache frequently used shared memory objects, for > + * example objects used as RPC arguments. When secure world is idle this > + * function returns one shared memory reference to free. To disable the > + * cache and free all cached objects this function has to be called until > + * it returns OPTEE_SMC_RETURN_ENOTAVAIL. > + * > + * Call register usage: > + * a0 SMC Function ID, OPTEE_SMC_DISABLE_SHM_CACHE > + * a1-6 Not used > + * a7 Hypervisor Client ID register > + * > + * Normal return register usage: > + * a0 OPTEE_SMC_RETURN_OK > + * a1 Upper 32bit of a 64bit Shared memory cookie > + * a2 Lower 32bit of a 64bit Shared memory cookie > + * a3-7 Preserved > + * > + * Cache empty return register usage: > + * a0 OPTEE_SMC_RETURN_ENOTAVAIL > + * a1-7 Preserved > + * > + * Not idle return register usage: > + * a0 OPTEE_SMC_RETURN_EBUSY > + * a1-7 Preserved > + */ > +#define OPTEE_SMC_FUNCID_DISABLE_SHM_CACHE 10 > +#define OPTEE_SMC_DISABLE_SHM_CACHE \ > + OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_DISABLE_SHM_CACHE) > + > +struct optee_smc_disable_shm_cache_result { > + unsigned long status; > + unsigned long shm_upper32; > + unsigned long shm_lower32; > + unsigned long reserved0; > +}; > + > +/* > + * Enable cache of shared memory objects > + * > + * Secure world can cache frequently used shared memory objects, for > + * example objects used as RPC arguments. When secure world is idle this > + * function returns OPTEE_SMC_RETURN_OK and the cache is enabled. If > + * secure world isn't idle OPTEE_SMC_RETURN_EBUSY is returned. > + * > + * Call register usage: > + * a0 SMC Function ID, OPTEE_SMC_ENABLE_SHM_CACHE > + * a1-6 Not used > + * a7 Hypervisor Client ID register > + * > + * Normal return register usage: > + * a0 OPTEE_SMC_RETURN_OK > + * a1-7 Preserved > + * > + * Not idle return register usage: > + * a0 OPTEE_SMC_RETURN_EBUSY > + * a1-7 Preserved > + */ > +#define OPTEE_SMC_FUNCID_ENABLE_SHM_CACHE 11 > +#define OPTEE_SMC_ENABLE_SHM_CACHE \ > + OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_ENABLE_SHM_CACHE) > + > +/* > + * Resume from RPC (for example after processing a foreign interrupt) > + * > + * Call register usage: > + * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC > + * a1-3 Value of a1-3 when OPTEE_SMC_CALL_WITH_ARG returned > + * OPTEE_SMC_RETURN_RPC in a0 > + * > + * Return register usage is the same as for OPTEE_SMC_*CALL_WITH_ARG above. > + * > + * Possible return values > + * OPTEE_SMC_RETURN_UNKNOWN_FUNCTION Trusted OS does not recognize this > + * function. > + * OPTEE_SMC_RETURN_OK Original call completed, result > + * updated in the previously supplied. > + * struct optee_msg_arg > + * OPTEE_SMC_RETURN_RPC Call suspended by RPC call to normal > + * world. > + * OPTEE_SMC_RETURN_ERESUME Resume failed, the opaque resume > + * information was corrupt. > + */ > +#define OPTEE_SMC_FUNCID_RETURN_FROM_RPC 3 > +#define OPTEE_SMC_CALL_RETURN_FROM_RPC \ > + OPTEE_SMC_STD_CALL_VAL(OPTEE_SMC_FUNCID_RETURN_FROM_RPC) > + > +#define OPTEE_SMC_RETURN_RPC_PREFIX_MASK 0xFFFF0000 > +#define OPTEE_SMC_RETURN_RPC_PREFIX 0xFFFF0000 > +#define OPTEE_SMC_RETURN_RPC_FUNC_MASK 0x0000FFFF > + > +#define OPTEE_SMC_RETURN_GET_RPC_FUNC(ret) \ > + ((ret) & OPTEE_SMC_RETURN_RPC_FUNC_MASK) > + > +#define OPTEE_SMC_RPC_VAL(func) ((func) | OPTEE_SMC_RETURN_RPC_PREFIX) > + > +/* > + * Allocate memory for RPC parameter passing. The memory is used to hold a > + * struct optee_msg_arg. > + * > + * "Call" register usage: > + * a0 This value, OPTEE_SMC_RETURN_RPC_ALLOC > + * a1 Size in bytes of required argument memory > + * a2 Not used > + * a3 Resume information, must be preserved > + * a4-5 Not used > + * a6-7 Resume information, must be preserved > + * > + * "Return" register usage: > + * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC. > + * a1 Upper 32bits of 64bit physical pointer to allocated > + * memory, (a1 == 0 && a2 == 0) if size was 0 or if memory can't > + * be allocated. > + * a2 Lower 32bits of 64bit physical pointer to allocated > + * memory, (a1 == 0 && a2 == 0) if size was 0 or if memory can't > + * be allocated > + * a3 Preserved > + * a4 Upper 32bits of 64bit Shared memory cookie used when freeing > + * the memory or doing an RPC > + * a5 Lower 32bits of 64bit Shared memory cookie used when freeing > + * the memory or doing an RPC > + * a6-7 Preserved > + */ > +#define OPTEE_SMC_RPC_FUNC_ALLOC 0 > +#define OPTEE_SMC_RETURN_RPC_ALLOC \ > + OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_ALLOC) > + > +/* > + * Free memory previously allocated by OPTEE_SMC_RETURN_RPC_ALLOC > + * > + * "Call" register usage: > + * a0 This value, OPTEE_SMC_RETURN_RPC_FREE > + * a1 Upper 32bits of 64bit shared memory cookie belonging to this > + * argument memory > + * a2 Lower 32bits of 64bit shared memory cookie belonging to this > + * argument memory > + * a3-7 Resume information, must be preserved > + * > + * "Return" register usage: > + * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC. > + * a1-2 Not used > + * a3-7 Preserved > + */ > +#define OPTEE_SMC_RPC_FUNC_FREE 2 > +#define OPTEE_SMC_RETURN_RPC_FREE \ > + OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_FREE) > + > +/* > + * Deliver foreign interrupt to normal world. > + * > + * "Call" register usage: > + * a0 OPTEE_SMC_RETURN_RPC_FOREIGN_INTR > + * a1-7 Resume information, must be preserved > + * > + * "Return" register usage: > + * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC. > + * a1-7 Preserved > + */ > +#define OPTEE_SMC_RPC_FUNC_FOREIGN_INTR 4 > +#define OPTEE_SMC_RETURN_RPC_FOREIGN_INTR \ > + OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_FOREIGN_INTR) > + > +/* > + * Do an RPC request. The supplied struct optee_msg_arg tells which > + * request to do and the parameters for the request. The following fields > + * are used (the rest are unused): > + * - cmd the Request ID > + * - ret return value of the request, filled in by normal world > + * - num_params number of parameters for the request > + * - params the parameters > + * - param_attrs attributes of the parameters > + * > + * "Call" register usage: > + * a0 OPTEE_SMC_RETURN_RPC_CMD > + * a1 Upper 32bit of a 64bit Shared memory cookie holding a > + * struct optee_msg_arg, must be preserved, only the data should > + * be updated > + * a2 Lower 32bit of a 64bit Shared memory cookie holding a > + * struct optee_msg_arg, must be preserved, only the data should > + * be updated > + * a3-7 Resume information, must be preserved > + * > + * "Return" register usage: > + * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC. > + * a1-2 Not used > + * a3-7 Preserved > + */ > +#define OPTEE_SMC_RPC_FUNC_CMD 5 > +#define OPTEE_SMC_RETURN_RPC_CMD \ > + OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_CMD) > + > +/* Returned in a0 */ > +#define OPTEE_SMC_RETURN_UNKNOWN_FUNCTION 0xFFFFFFFF > + > +/* Returned in a0 only from Trusted OS functions */ > +#define OPTEE_SMC_RETURN_OK 0x0 > +#define OPTEE_SMC_RETURN_ETHREAD_LIMIT 0x1 > +#define OPTEE_SMC_RETURN_EBUSY 0x2 > +#define OPTEE_SMC_RETURN_ERESUME 0x3 > +#define OPTEE_SMC_RETURN_EBADADDR 0x4 > +#define OPTEE_SMC_RETURN_EBADCMD 0x5 > +#define OPTEE_SMC_RETURN_ENOMEM 0x6 > +#define OPTEE_SMC_RETURN_ENOTAVAIL 0x7 > +#define OPTEE_SMC_RETURN_IS_RPC(ret) __optee_smc_return_is_rpc((ret)) > + > +static inline bool __optee_smc_return_is_rpc(u32 ret) > +{ > + return ret != OPTEE_SMC_RETURN_UNKNOWN_FUNCTION && > + (ret & OPTEE_SMC_RETURN_RPC_PREFIX_MASK) == > + OPTEE_SMC_RETURN_RPC_PREFIX; > +} > + > +#endif /* OPTEE_SMC_H */ > diff --git a/drivers/tee/optee/supplicant.c b/drivers/tee/optee/supplicant.c > new file mode 100644 > index 000000000000..6965055bd1b5 > --- /dev/null > +++ b/drivers/tee/optee/supplicant.c > @@ -0,0 +1,89 @@ > +// SPDX-License-Identifier: BSD-2-Clause > +/* > + * Copyright (c) 2018, Linaro Limited > + */ > + > +#include > +#include > +#include > +#include > + > +#include "optee_msg.h" > +#include "optee_msg_supplicant.h" > +#include "optee_private.h" > +#include "optee_smc.h" > + > +static void cmd_shm_alloc(struct udevice *dev, struct optee_msg_arg *arg, > + void **page_list) > +{ > + struct tee_shm *shm; > + void *pl; > + u64 ph_ptr; > + > + arg->ret_origin = TEE_ORIGIN_COMMS; > + > + if (arg->num_params != 1 || > + arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) { > + arg->ret = TEE_ERROR_BAD_PARAMETERS; > + return; > + } > + > + shm = __tee_shm_add(dev, 0, NULL, arg->params[0].u.value.b, > + TEE_SHM_REGISTER | TEE_SHM_ALLOC); > + if (!shm) { > + arg->ret = TEE_ERROR_OUT_OF_MEMORY; > + return; > + } > + > + pl = optee_alloc_and_init_page_list(shm->addr, shm->size, &ph_ptr); > + if (!pl) { > + arg->ret = TEE_ERROR_OUT_OF_MEMORY; > + tee_shm_free(shm); > + return; > + } > + > + *page_list = pl; > + arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT | > + OPTEE_MSG_ATTR_NONCONTIG; > + arg->params[0].u.tmem.buf_ptr = ph_ptr; > + arg->params[0].u.tmem.size = shm->size; > + arg->params[0].u.tmem.shm_ref = (ulong)shm; > + arg->ret = TEE_SUCCESS; > +} > + > +static void cmd_shm_free(struct optee_msg_arg *arg) > +{ > + arg->ret_origin = TEE_ORIGIN_COMMS; > + > + if (arg->num_params != 1 || > + arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) { > + arg->ret = TEE_ERROR_BAD_PARAMETERS; > + return; > + } > + > + tee_shm_free((struct tee_shm *)(ulong)arg->params[0].u.value.b); > + arg->ret = TEE_SUCCESS; > +} > + > +void optee_suppl_cmd(struct udevice *dev, struct tee_shm *shm_arg, > + void **page_list) > +{ > + struct optee_msg_arg *arg = shm_arg->addr; > + > + switch (arg->cmd) { > + case OPTEE_MSG_RPC_CMD_SHM_ALLOC: > + cmd_shm_alloc(dev, arg, page_list); > + break; > + case OPTEE_MSG_RPC_CMD_SHM_FREE: > + cmd_shm_free(arg); > + break; > + case OPTEE_MSG_RPC_CMD_FS: > + debug("OPTEE_MSG_RPC_CMD_FS not implemented\n"); > + arg->ret = TEE_ERROR_NOT_IMPLEMENTED; > + break; > + default: > + arg->ret = TEE_ERROR_NOT_IMPLEMENTED; > + } > + > + arg->ret_origin = TEE_ORIGIN_COMMS; > +} > -- > 2.17.1 > -- Regards, Igor Opaniuk