[U-Boot,06/10] tee: add OP-TEE driver

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 <jens.wiklander@linaro.org>
---
 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

Tested-by: Igor Opaniuk <igor.opaniuk@linaro.org>

On 13 August 2018 at 18:53, Jens Wiklander <jens.wiklander@linaro.org> 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 <jens.wiklander@linaro.org>
> ---
>  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 <common.h>
> +#include <dm.h>
> +#include <linux/arm-smccc.h>
> +#include <linux/io.h>
> +#include <log.h>
> +#include <tee.h>
> +
> +#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(&param->a1, &param->a2,
> +                                        virt_to_phys(shm->addr));
> +                       /* "cookie" */
> +                       reg_pair_from_64(&param->a4, &param->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(&param.a1, &param.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, &param, &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 <linux/bitops.h>
> +#include <linux/types.h>
> +
> +/*
> + * 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 <linux/arm-smccc.h>
> +#include <linux/bitops.h>
> +
> +#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 <common.h>
> +#include <linux/types.h>
> +#include <log.h>
> +#include <tee.h>
> +
> +#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
>