2021-07-22 12:19:53

by Jens Wiklander

[permalink] [raw]
Subject: [PATCH v3 0/5] Add FF-A support in OP-TEE driver

Hi all,

This adds supports for the OP-TEE driver to communicate with secure world
using FF-A [1] as transport.

There is one change to the TEE subsystem with "tee: add sec_world_id to
struct tee_shm" to add support for holding globally unique handle assigned
by the FF-A. This is a field that I believe could useful for the AMDTEE
driver too.

For communication the OP-TEE message protocol is still used, but with a new
type of memory reference, struct optee_msg_param_fmem, to carry the
information needed by FF-A. The OP-TEE driver is refactored internally with
to sets of callbacks, one for the old SMC based communication and another
set with FF-A as transport. The functions relating to the SMC based ABI
are moved to smc_abi.c while the FF-A based ABI is added in a ffa_abi.c.

There is also a difference in how the drivers are instantiated. With the
SMC based transport we have a platform driver, module_platform_driver(),
today which we're keeping as is for this configuration. In a FF-A system we
have a FF-A driver, module_ffa_driver(), instead.

The OP-TEE driver can be compiled for both targets at the same time and
it's up to runtime configuration (device tree or ACPI) to decide how it's
initialized. Note that it's only the old SMC based driver instance that
need device tree or ACPI to initialize. The FF-A based driver relies on the
FF-A bus instead.

This can be tested QEMU
The repo for SPMC at S-EL1 retrieved by
repo init -u https://github.com/jenswi-linaro/manifest.git -m
qemu_v8.xml -b ffav4_spmc
repo sync
# Then checkout the branch optee_ffa_v3 from
# git://git.linaro.org/people/jens.wiklander/linux-tee.git
# in the linux directory

To build do:
cd build
make toolchains
make all

To boot:
make run-only

Test with xtest, perhaps only with the command "xtest 1004" in case you're
not interested in too many tests.

Thanks,
Jens

[1] https://developer.arm.com/documentation/den0077/latest

v2->v3:
- Rebased on 5.14-rc2 which now have the FF-A patches merged
- Fixed a couple bugs in optee_shm_register() and optee_shm_unregister()
which where introduced in "optee: refactor driver with internal callbacks"
in previous the version.
- Separated SMC ABI specifics into smc_abi.c to keep it separated from
the FF-A ABI functions as requested by Sumit.
- Added the FF-A specifics in ffa_abi.c
- Provided an implementation for optee_ffa_remove()

v1->v2:
- Rebased to the FF-A v7 patch
- Fixed a couple of reports from kernel test robot <[email protected]>

Jens Wiklander (5):
tee: add sec_world_id to struct tee_shm
optee: simplify optee_release()
optee: refactor driver with internal callbacks
optee: isolate smc abi
optee: add FF-A support

drivers/tee/optee/Makefile | 7 +-
drivers/tee/optee/call.c | 415 ++-------
drivers/tee/optee/core.c | 673 ++-------------
drivers/tee/optee/ffa_abi.c | 910 ++++++++++++++++++++
drivers/tee/optee/optee_ffa.h | 153 ++++
drivers/tee/optee/optee_msg.h | 27 +-
drivers/tee/optee/optee_private.h | 155 +++-
drivers/tee/optee/rpc.c | 270 +-----
drivers/tee/optee/shm_pool.c | 89 --
drivers/tee/optee/shm_pool.h | 14 -
drivers/tee/optee/smc_abi.c | 1301 +++++++++++++++++++++++++++++
include/linux/tee_drv.h | 7 +-
12 files changed, 2650 insertions(+), 1371 deletions(-)
create mode 100644 drivers/tee/optee/ffa_abi.c
create mode 100644 drivers/tee/optee/optee_ffa.h
delete mode 100644 drivers/tee/optee/shm_pool.c
delete mode 100644 drivers/tee/optee/shm_pool.h
create mode 100644 drivers/tee/optee/smc_abi.c

--
2.31.1


2021-07-22 12:20:20

by Jens Wiklander

[permalink] [raw]
Subject: [PATCH v3 5/5] optee: add FF-A support

Adds support for using FF-A [1] as transport to the OP-TEE driver.

Introduces struct optee_msg_param_fmem which carries all information
needed when OP-TEE is calling FFA_MEM_RETRIEVE_REQ to get the shared
memory reference mapped by the hypervisor in S-EL2. Register usage is
also updated to include the information needed.

The FF-A part of this driver is enabled if CONFIG_ARM_FFA_TRANSPORT is
enabled.

[1] https://developer.arm.com/documentation/den0077/latest
Signed-off-by: Jens Wiklander <[email protected]>
---
drivers/tee/optee/Makefile | 3 +-
drivers/tee/optee/call.c | 13 +-
drivers/tee/optee/ffa_abi.c | 910 ++++++++++++++++++++++++++++++
drivers/tee/optee/optee_ffa.h | 153 +++++
drivers/tee/optee/optee_msg.h | 27 +-
drivers/tee/optee/optee_private.h | 35 +-
6 files changed, 1129 insertions(+), 12 deletions(-)
create mode 100644 drivers/tee/optee/ffa_abi.c
create mode 100644 drivers/tee/optee/optee_ffa.h

diff --git a/drivers/tee/optee/Makefile b/drivers/tee/optee/Makefile
index e92f77462f40..dbfd83d3c4ae 100644
--- a/drivers/tee/optee/Makefile
+++ b/drivers/tee/optee/Makefile
@@ -7,7 +7,8 @@ optee-objs += supp.o
optee-objs += device.o

optee-smc-abi-y = smc_abi.o
-optee-objs += $(optee-ffa-abi-y)
+optee-ffa-abi-$(CONFIG_ARM_FFA_TRANSPORT) = ffa_abi.o
+optee-objs += $(optee-smc-abi-y) $(optee-ffa-abi-y)

# for tracing framework to find optee_trace.h
CFLAGS_smc_abi.o := -I$(src)
diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c
index 3f81c168ed3f..87d739091055 100644
--- a/drivers/tee/optee/call.c
+++ b/drivers/tee/optee/call.c
@@ -107,11 +107,20 @@ static struct optee_session *find_session(struct optee_context_data *ctxdata,
struct tee_shm *optee_get_msg_arg(struct tee_context *ctx, size_t num_params,
struct optee_msg_arg **msg_arg)
{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
+ size_t sz = OPTEE_MSG_GET_ARG_SIZE(num_params);
struct tee_shm *shm;
struct optee_msg_arg *ma;

- shm = tee_shm_alloc(ctx, OPTEE_MSG_GET_ARG_SIZE(num_params),
- TEE_SHM_MAPPED);
+ /*
+ * rpc_arg_count is set to the number of allocated parameters in
+ * the RPC argument struct if a second MSG arg struct is expected.
+ * The second arg struct will then be used for RPC.
+ */
+ if (optee->rpc_arg_count)
+ sz += OPTEE_MSG_GET_ARG_SIZE(optee->rpc_arg_count);
+
+ shm = tee_shm_alloc(ctx, sz, TEE_SHM_MAPPED);
if (IS_ERR(shm))
return shm;

diff --git a/drivers/tee/optee/ffa_abi.c b/drivers/tee/optee/ffa_abi.c
new file mode 100644
index 000000000000..7e553328b92b
--- /dev/null
+++ b/drivers/tee/optee/ffa_abi.c
@@ -0,0 +1,910 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2021, Linaro Limited
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/arm_ffa.h>
+#include <linux/errno.h>
+#include <linux/scatterlist.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/tee_drv.h>
+#include <linux/types.h>
+#include "optee_private.h"
+#include "optee_ffa.h"
+#include "optee_rpc_cmd.h"
+
+/*
+ * This file implement the FF-A ABI used when communicating with secure world
+ * OP-TEE OS via FF-A.
+ * This file is divided into the follow sections:
+ * 1. Maintain a hash table for lookup of a global FF-A memory handle
+ * 2. Convert between struct tee_param and struct optee_msg_param
+ * 3. Low level support functions to register shared memory in secure world
+ * 4. Dynamic shared memory pool based on alloc_pages()
+ * 5. Do a normal scheduled call into secure world
+ * 6. Driver initialization.
+ */
+
+/*
+ * 1. Maintain a hash table for lookup of a global FF-A memory handle
+ *
+ * FF-A assigns a global memory handle for each piece shared memory.
+ * This handle is then used when communicating with secure world.
+ *
+ * Main functions are optee_shm_add_ffa_handle() and optee_shm_rem_ffa_handle()
+ */
+struct shm_rhash {
+ struct tee_shm *shm;
+ u64 global_id;
+ struct rhash_head linkage;
+};
+
+static void rh_free_fn(void *ptr, void *arg)
+{
+ kfree(ptr);
+}
+
+static const struct rhashtable_params shm_rhash_params = {
+ .head_offset = offsetof(struct shm_rhash, linkage),
+ .key_len = sizeof(u64),
+ .key_offset = offsetof(struct shm_rhash, global_id),
+ .automatic_shrinking = true,
+};
+
+static struct tee_shm *optee_shm_from_ffa_handle(struct optee *optee,
+ u64 global_id)
+{
+ struct tee_shm *shm = NULL;
+ struct shm_rhash *r;
+
+ mutex_lock(&optee->ffa.mutex);
+ r = rhashtable_lookup_fast(&optee->ffa.global_ids, &global_id,
+ shm_rhash_params);
+ if (r)
+ shm = r->shm;
+ mutex_unlock(&optee->ffa.mutex);
+
+ return shm;
+}
+
+static int optee_shm_add_ffa_handle(struct optee *optee, struct tee_shm *shm,
+ u64 global_id)
+{
+ struct shm_rhash *r;
+ int rc;
+
+ r = kmalloc(sizeof(*r), GFP_KERNEL);
+ if (!r)
+ return -ENOMEM;
+ r->shm = shm;
+ r->global_id = global_id;
+
+ mutex_lock(&optee->ffa.mutex);
+ rc = rhashtable_lookup_insert_fast(&optee->ffa.global_ids, &r->linkage,
+ shm_rhash_params);
+ mutex_unlock(&optee->ffa.mutex);
+
+ if (rc)
+ kfree(r);
+
+ return rc;
+}
+
+static int optee_shm_rem_ffa_handle(struct optee *optee, u64 global_id)
+{
+ struct shm_rhash *r;
+ int rc = -ENOENT;
+
+ mutex_lock(&optee->ffa.mutex);
+ r = rhashtable_lookup_fast(&optee->ffa.global_ids, &global_id,
+ shm_rhash_params);
+ if (r)
+ rc = rhashtable_remove_fast(&optee->ffa.global_ids,
+ &r->linkage, shm_rhash_params);
+ mutex_unlock(&optee->ffa.mutex);
+
+ if (!rc)
+ kfree(r);
+
+ return rc;
+}
+
+/*
+ * 2. Convert between struct tee_param and struct optee_msg_param
+ *
+ * optee_ffa_from_msg_param() and optee_ffa_to_msg_param() are the main
+ * functions.
+ */
+
+static void from_msg_param_ffa_mem(struct optee *optee, struct tee_param *p,
+ u32 attr, const struct optee_msg_param *mp)
+{
+ struct tee_shm *shm = NULL;
+ u64 offs_high = 0;
+ u64 offs_low = 0;
+
+ p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
+ attr - OPTEE_MSG_ATTR_TYPE_FMEM_INPUT;
+ p->u.memref.size = mp->u.fmem.size;
+
+ if (mp->u.fmem.global_id != OPTEE_MSG_FMEM_INVALID_GLOBAL_ID)
+ shm = optee_shm_from_ffa_handle(optee, mp->u.fmem.global_id);
+ p->u.memref.shm = shm;
+
+ if (shm) {
+ offs_low = mp->u.fmem.offs_low;
+ offs_high = mp->u.fmem.offs_high;
+ }
+ p->u.memref.shm_offs = offs_low | offs_high << 32;
+}
+
+/**
+ * optee_ffa_from_msg_param() - convert from OPTEE_MSG parameters to
+ * struct tee_param
+ * @optee: main service struct
+ * @params: subsystem internal parameter representation
+ * @num_params: number of elements in the parameter arrays
+ * @msg_params: OPTEE_MSG parameters
+ *
+ * Returns 0 on success or <0 on failure
+ */
+static int optee_ffa_from_msg_param(struct optee *optee,
+ struct tee_param *params, size_t num_params,
+ const struct optee_msg_param *msg_params)
+{
+ size_t n;
+
+ 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_IOCTL_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:
+ optee_from_msg_param_value(p, attr, mp);
+ break;
+ case OPTEE_MSG_ATTR_TYPE_FMEM_INPUT:
+ case OPTEE_MSG_ATTR_TYPE_FMEM_OUTPUT:
+ case OPTEE_MSG_ATTR_TYPE_FMEM_INOUT:
+ from_msg_param_ffa_mem(optee, p, attr, mp);
+ break;
+ default:
+ return -EINVAL;
+ }
+ }
+
+ return 0;
+}
+
+static int to_msg_param_ffa_mem(struct optee_msg_param *mp,
+ const struct tee_param *p)
+{
+ struct tee_shm *shm = p->u.memref.shm;
+
+ mp->attr = OPTEE_MSG_ATTR_TYPE_FMEM_INPUT + p->attr -
+ TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
+
+ if (shm) {
+ u64 shm_offs = p->u.memref.shm_offs;
+
+ mp->u.fmem.internal_offs = shm->offset;
+
+ mp->u.fmem.offs_low = shm_offs;
+ mp->u.fmem.offs_high = shm_offs >> 32;
+ /* Check that the entire offset could be stored. */
+ if (mp->u.fmem.offs_high != shm_offs >> 32)
+ return -EINVAL;
+
+ mp->u.fmem.global_id = shm->sec_world_id;
+ } else {
+ memset(&mp->u, 0, sizeof(mp->u));
+ mp->u.fmem.global_id = OPTEE_MSG_FMEM_INVALID_GLOBAL_ID;
+ }
+ mp->u.fmem.size = p->u.memref.size;
+
+ return 0;
+}
+
+/**
+ * optee_ffa_to_msg_param() - convert from struct tee_params to OPTEE_MSG
+ * parameters
+ * @optee: main service struct
+ * @msg_params: OPTEE_MSG parameters
+ * @num_params: number of elements in the parameter arrays
+ * @params: subsystem itnernal parameter representation
+ * Returns 0 on success or <0 on failure
+ */
+static int optee_ffa_to_msg_param(struct optee *optee,
+ struct optee_msg_param *msg_params,
+ size_t num_params,
+ const struct tee_param *params)
+{
+ size_t 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_IOCTL_PARAM_ATTR_TYPE_NONE:
+ mp->attr = TEE_IOCTL_PARAM_ATTR_TYPE_NONE;
+ memset(&mp->u, 0, sizeof(mp->u));
+ break;
+ case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT:
+ case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
+ case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
+ optee_to_msg_param_value(mp, p);
+ break;
+ case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT:
+ case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
+ case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:
+ if (to_msg_param_ffa_mem(mp, p))
+ return -EINVAL;
+ break;
+ default:
+ return -EINVAL;
+ }
+ }
+
+ return 0;
+}
+
+/*
+ * 3. Low level support functions to register shared memory in secure world
+ *
+ * Functions to register and unregister shared memory both for normal
+ * clients and for tee-supplicant.
+ */
+
+static int optee_ffa_shm_register(struct tee_context *ctx, struct tee_shm *shm,
+ struct page **pages, size_t num_pages,
+ unsigned long start)
+{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
+ const struct ffa_dev_ops *ffa_ops = optee->ffa.ffa_ops;
+ struct ffa_device *ffa_dev = optee->ffa.ffa_dev;
+ struct ffa_mem_region_attributes mem_attr = {
+ .receiver = ffa_dev->vm_id,
+ .attrs = FFA_MEM_RW,
+ };
+ struct ffa_mem_ops_args args = {
+ .use_txbuf = true,
+ .attrs = &mem_attr,
+ .nattrs = 1,
+ };
+ struct sg_table sgt;
+ int rc;
+
+ rc = optee_check_mem_type(start, num_pages);
+ if (rc)
+ return rc;
+
+ rc = sg_alloc_table_from_pages(&sgt, pages, num_pages, 0,
+ num_pages * PAGE_SIZE, GFP_KERNEL);
+ if (rc)
+ return rc;
+ args.sg = sgt.sgl;
+ rc = ffa_ops->memory_share(ffa_dev, &args);
+ sg_free_table(&sgt);
+ if (rc)
+ return rc;
+
+ rc = optee_shm_add_ffa_handle(optee, shm, args.g_handle);
+ if (rc) {
+ ffa_ops->memory_reclaim(args.g_handle, 0);
+ return rc;
+ }
+
+ shm->sec_world_id = args.g_handle;
+
+ return 0;
+}
+
+static int optee_ffa_shm_unregister(struct tee_context *ctx,
+ struct tee_shm *shm)
+{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
+ const struct ffa_dev_ops *ffa_ops = optee->ffa.ffa_ops;
+ struct ffa_device *ffa_dev = optee->ffa.ffa_dev;
+ u64 global_handle = shm->sec_world_id;
+ struct ffa_send_direct_data data = {
+ .data0 = OPTEE_FFA_UNREGISTER_SHM,
+ .data1 = (u32)global_handle,
+ .data2 = (u32)(global_handle >> 32)
+ };
+ int rc;
+
+ optee_shm_rem_ffa_handle(optee, global_handle);
+ shm->sec_world_id = 0;
+
+ rc = ffa_ops->sync_send_receive(ffa_dev, &data);
+ if (rc)
+ pr_err("Unregister SHM id 0x%llx rc %d\n", global_handle, rc);
+
+ rc = ffa_ops->memory_reclaim(global_handle, 0);
+ if (rc)
+ pr_err("mem_reclain: 0x%llx %d", global_handle, rc);
+
+ return rc;
+}
+
+static int optee_ffa_shm_unregister_supp(struct tee_context *ctx,
+ struct tee_shm *shm)
+{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
+ const struct ffa_dev_ops *ffa_ops = optee->ffa.ffa_ops;
+ u64 global_handle = shm->sec_world_id;
+ int rc;
+
+ /*
+ * We're skipping the OPTEE_FFA_YIELDING_CALL_UNREGISTER_SHM call
+ * since this is OP-TEE freeing via RPC so it has already retired
+ * this ID.
+ */
+
+ optee_shm_rem_ffa_handle(optee, global_handle);
+ rc = ffa_ops->memory_reclaim(global_handle, 0);
+ if (rc)
+ pr_err("mem_reclain: 0x%llx %d", global_handle, rc);
+
+ shm->sec_world_id = 0;
+
+ return rc;
+}
+
+/*
+ * 4. Dynamic shared memory pool based on alloc_pages()
+ *
+ * Implements an OP-TEE specific shared memory pool.
+ * The main function is optee_ffa_shm_pool_alloc_pages().
+ */
+
+static int pool_ffa_op_alloc(struct tee_shm_pool_mgr *poolm,
+ struct tee_shm *shm, size_t size)
+{
+ return optee_pool_op_alloc_helper(poolm, shm, size,
+ optee_ffa_shm_register);
+}
+
+static void pool_ffa_op_free(struct tee_shm_pool_mgr *poolm,
+ struct tee_shm *shm)
+{
+ optee_ffa_shm_unregister(shm->ctx, shm);
+ free_pages((unsigned long)shm->kaddr, get_order(shm->size));
+ shm->kaddr = NULL;
+}
+
+static void pool_ffa_op_destroy_poolmgr(struct tee_shm_pool_mgr *poolm)
+{
+ kfree(poolm);
+}
+
+static const struct tee_shm_pool_mgr_ops pool_ffa_ops = {
+ .alloc = pool_ffa_op_alloc,
+ .free = pool_ffa_op_free,
+ .destroy_poolmgr = pool_ffa_op_destroy_poolmgr,
+};
+
+/**
+ * optee_ffa_shm_pool_alloc_pages() - create page-based allocator pool
+ *
+ * This pool is used with OP-TEE over FF-A. In this case command buffers
+ * and such are allocated from kernel's own memory.
+ */
+static struct tee_shm_pool_mgr *optee_ffa_shm_pool_alloc_pages(void)
+{
+ struct tee_shm_pool_mgr *mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
+
+ if (!mgr)
+ return ERR_PTR(-ENOMEM);
+
+ mgr->ops = &pool_ffa_ops;
+
+ return mgr;
+}
+
+/*
+ * 5. Do a normal scheduled call into secure world
+ *
+ * The function optee_ffa_do_call_with_arg() performs a normal scheduled
+ * call into secure world. During this call may normal world request help
+ * from normal world using RPCs, Remote Procedure Calls. This includes
+ * delivery of non-secure interrupts to for instance allow rescheduling of
+ * the current task.
+ */
+
+static void handle_ffa_rpc_func_cmd_shm_alloc(struct tee_context *ctx,
+ struct optee_msg_arg *arg)
+{
+ struct tee_shm *shm;
+
+ if (arg->num_params != 1 ||
+ arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) {
+ arg->ret = TEEC_ERROR_BAD_PARAMETERS;
+ return;
+ }
+
+ switch (arg->params[0].u.value.a) {
+ case OPTEE_RPC_SHM_TYPE_APPL:
+ shm = optee_rpc_cmd_alloc_suppl(ctx, arg->params[0].u.value.b);
+ break;
+ case OPTEE_RPC_SHM_TYPE_KERNEL:
+ shm = tee_shm_alloc(ctx, arg->params[0].u.value.b,
+ TEE_SHM_MAPPED);
+ break;
+ default:
+ arg->ret = TEEC_ERROR_BAD_PARAMETERS;
+ return;
+ }
+
+ if (IS_ERR(shm)) {
+ arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
+ return;
+ }
+
+ arg->params[0] = (struct optee_msg_param){
+ .attr = OPTEE_MSG_ATTR_TYPE_FMEM_OUTPUT,
+ .u.fmem.size = tee_shm_get_size(shm),
+ .u.fmem.global_id = shm->sec_world_id,
+ .u.fmem.internal_offs = shm->offset,
+ };
+
+ arg->ret = TEEC_SUCCESS;
+}
+
+static void handle_ffa_rpc_func_cmd_shm_free(struct tee_context *ctx,
+ struct optee *optee,
+ struct optee_msg_arg *arg)
+{
+ struct tee_shm *shm;
+
+ if (arg->num_params != 1 ||
+ arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT)
+ goto err_bad_param;
+
+ shm = optee_shm_from_ffa_handle(optee, arg->params[0].u.value.b);
+ if (!shm)
+ goto err_bad_param;
+ switch (arg->params[0].u.value.a) {
+ case OPTEE_RPC_SHM_TYPE_APPL:
+ optee_rpc_cmd_free_suppl(ctx, shm);
+ break;
+ case OPTEE_RPC_SHM_TYPE_KERNEL:
+ tee_shm_free(shm);
+ break;
+ default:
+ goto err_bad_param;
+ }
+ arg->ret = TEEC_SUCCESS;
+ return;
+
+err_bad_param:
+ arg->ret = TEEC_ERROR_BAD_PARAMETERS;
+}
+
+static void handle_ffa_rpc_func_cmd(struct tee_context *ctx,
+ struct optee_msg_arg *arg)
+{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
+
+ arg->ret_origin = TEEC_ORIGIN_COMMS;
+ switch (arg->cmd) {
+ case OPTEE_RPC_CMD_GET_TIME:
+ optee_rpc_func_cmd_get_time(arg);
+ break;
+ case OPTEE_RPC_CMD_WAIT_QUEUE:
+ optee_rpc_func_cmd_wq(optee, arg);
+ break;
+ case OPTEE_RPC_CMD_SUSPEND:
+ optee_rpc_func_cmd_wait(arg);
+ break;
+ case OPTEE_RPC_CMD_SHM_ALLOC:
+ handle_ffa_rpc_func_cmd_shm_alloc(ctx, arg);
+ break;
+ case OPTEE_RPC_CMD_SHM_FREE:
+ handle_ffa_rpc_func_cmd_shm_free(ctx, optee, arg);
+ break;
+ case OPTEE_RPC_CMD_I2C_TRANSFER:
+ optee_rpc_func_cmd_i2c_transfer(ctx, arg);
+ break;
+ default:
+ optee_rpc_supp_cmd(ctx, optee, arg);
+ }
+}
+
+static void optee_handle_ffa_rpc(struct tee_context *ctx, u32 cmd,
+ struct optee_msg_arg *arg)
+{
+ switch (cmd) {
+ case OPTEE_FFA_YIELDING_CALL_RETURN_RPC_CMD:
+ handle_ffa_rpc_func_cmd(ctx, arg);
+ break;
+ case OPTEE_FFA_YIELDING_CALL_RETURN_INTERRUPT:
+ /* Interrupt delivered by now */
+ break;
+ default:
+ pr_warn("Unknown RPC func 0x%x\n", cmd);
+ break;
+ }
+}
+
+static int optee_ffa_yielding_call(struct tee_context *ctx,
+ struct ffa_send_direct_data *data,
+ struct optee_msg_arg *rpc_arg)
+{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
+ const struct ffa_dev_ops *ffa_ops = optee->ffa.ffa_ops;
+ struct ffa_device *ffa_dev = optee->ffa.ffa_dev;
+ struct optee_call_waiter w;
+ u32 cmd = data->data0;
+ u32 w4 = data->data1;
+ u32 w5 = data->data2;
+ u32 w6 = data->data3;
+ int rc;
+
+ /* Initialize waiter */
+ optee_cq_wait_init(&optee->call_queue, &w);
+ while (true) {
+ rc = ffa_ops->sync_send_receive(ffa_dev, data);
+ if (rc)
+ goto done;
+
+ switch ((int)data->data0) {
+ case TEEC_SUCCESS:
+ break;
+ case TEEC_ERROR_BUSY:
+ if (cmd == OPTEE_FFA_YIELDING_CALL_RESUME) {
+ rc = -EIO;
+ goto done;
+ }
+
+ /*
+ * Out of threads in secure world, wait for a thread
+ * become available.
+ */
+ optee_cq_wait_for_completion(&optee->call_queue, &w);
+ data->data0 = cmd;
+ data->data1 = w4;
+ data->data2 = w5;
+ data->data3 = w6;
+ continue;
+ default:
+ rc = -EIO;
+ goto done;
+ }
+
+ if (data->data1 == OPTEE_FFA_YIELDING_CALL_RETURN_DONE)
+ goto done;
+
+ /*
+ * OP-TEE has returned with a RPC request.
+ *
+ * Note that data->data4 (passed in register w7) is already
+ * filled in by ffa_ops->sync_send_receive() returning
+ * above.
+ */
+ cond_resched();
+ optee_handle_ffa_rpc(ctx, data->data1, rpc_arg);
+ cmd = OPTEE_FFA_YIELDING_CALL_RESUME;
+ data->data0 = cmd;
+ data->data1 = 0;
+ data->data2 = 0;
+ data->data3 = 0;
+ }
+done:
+ /*
+ * We're done with our thread in secure world, if there's any
+ * thread waiters wake up one.
+ */
+ optee_cq_wait_final(&optee->call_queue, &w);
+
+ return rc;
+}
+
+/**
+ * optee_ffa_do_call_with_arg() - Do a FF-A call to enter OP-TEE in secure world
+ * @ctx: calling context
+ * @shm: shared memory holding the message to pass to secure world
+ *
+ * Does a FF-A call to OP-TEE in secure world and handles eventual resulting
+ * Remote Procedure Calls (RPC) from OP-TEE.
+ *
+ * Returns return code from FF-A, 0 is OK
+ */
+
+static int optee_ffa_do_call_with_arg(struct tee_context *ctx,
+ struct tee_shm *shm)
+{
+ struct ffa_send_direct_data data = {
+ .data0 = OPTEE_FFA_YIELDING_CALL_WITH_ARG,
+ .data1 = (u32)shm->sec_world_id,
+ .data2 = (u32)(shm->sec_world_id >> 32),
+ .data3 = shm->offset,
+ };
+ struct optee_msg_arg *arg = tee_shm_get_va(shm, 0);
+ unsigned int rpc_arg_offs = OPTEE_MSG_GET_ARG_SIZE(arg->num_params);
+ struct optee_msg_arg *rpc_arg = tee_shm_get_va(shm, rpc_arg_offs);
+
+ return optee_ffa_yielding_call(ctx, &data, rpc_arg);
+}
+
+/*
+ * 6. Driver initialization
+ *
+ * During driver inititialization is the OP-TEE Secure Partition is probed
+ * to find out which features it supports so the driver can be initialized
+ * with a matching configuration.
+ */
+
+static bool optee_ffa_api_is_compatbile(struct ffa_device *ffa_dev,
+ const struct ffa_dev_ops *ops)
+{
+ struct ffa_send_direct_data data = { OPTEE_FFA_GET_API_VERSION };
+ int rc;
+
+ ops->mode_32bit_set(ffa_dev);
+
+ rc = ops->sync_send_receive(ffa_dev, &data);
+ if (rc) {
+ pr_err("Unexpected error %d\n", rc);
+ return false;
+ }
+ if (data.data0 != OPTEE_FFA_VERSION_MAJOR ||
+ data.data1 < OPTEE_FFA_VERSION_MINOR) {
+ pr_err("Incompatible OP-TEE API version %lu.%lu",
+ data.data0, data.data1);
+ return false;
+ }
+
+ data = (struct ffa_send_direct_data){ OPTEE_FFA_GET_OS_VERSION };
+ rc = ops->sync_send_receive(ffa_dev, &data);
+ if (rc) {
+ pr_err("Unexpected error %d\n", rc);
+ return false;
+ }
+ if (data.data2)
+ pr_info("revision %lu.%lu (%08lx)",
+ data.data0, data.data1, data.data2);
+ else
+ pr_info("revision %lu.%lu", data.data0, data.data1);
+
+ return true;
+}
+
+static bool optee_ffa_exchange_caps(struct ffa_device *ffa_dev,
+ const struct ffa_dev_ops *ops,
+ unsigned int *rpc_arg_count)
+{
+ struct ffa_send_direct_data data = { OPTEE_FFA_EXCHANGE_CAPABILITIES };
+ int rc;
+
+ rc = ops->sync_send_receive(ffa_dev, &data);
+ if (rc) {
+ pr_err("Unexpected error %d", rc);
+ return false;
+ }
+ if (data.data0) {
+ pr_err("Unexpected exchange error %lu", data.data0);
+ return false;
+ }
+
+ *rpc_arg_count = (u8)data.data1;
+
+ return true;
+}
+
+static struct tee_shm_pool *optee_ffa_config_dyn_shm(void)
+{
+ struct tee_shm_pool_mgr *priv_mgr;
+ struct tee_shm_pool_mgr *dmabuf_mgr;
+ void *rc;
+
+ rc = optee_ffa_shm_pool_alloc_pages();
+ if (IS_ERR(rc))
+ return rc;
+ priv_mgr = rc;
+
+ rc = optee_ffa_shm_pool_alloc_pages();
+ if (IS_ERR(rc)) {
+ tee_shm_pool_mgr_destroy(priv_mgr);
+ return rc;
+ }
+ dmabuf_mgr = rc;
+
+ rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
+ if (IS_ERR(rc)) {
+ tee_shm_pool_mgr_destroy(priv_mgr);
+ tee_shm_pool_mgr_destroy(dmabuf_mgr);
+ }
+
+ return rc;
+}
+
+static void optee_ffa_get_version(struct tee_device *teedev,
+ struct tee_ioctl_version_data *vers)
+{
+ struct tee_ioctl_version_data v = {
+ .impl_id = TEE_IMPL_ID_OPTEE,
+ .impl_caps = TEE_OPTEE_CAP_TZ,
+ .gen_caps = TEE_GEN_CAP_GP | TEE_GEN_CAP_REG_MEM |
+ TEE_GEN_CAP_MEMREF_NULL,
+ };
+
+ *vers = v;
+}
+
+static int optee_ffa_open(struct tee_context *ctx)
+{
+ return optee_open(ctx, true);
+}
+
+static const struct tee_driver_ops optee_ffa_clnt_ops = {
+ .get_version = optee_ffa_get_version,
+ .open = optee_ffa_open,
+ .release = optee_release,
+ .open_session = optee_open_session,
+ .close_session = optee_close_session,
+ .invoke_func = optee_invoke_func,
+ .cancel_req = optee_cancel_req,
+ .shm_register = optee_ffa_shm_register,
+ .shm_unregister = optee_ffa_shm_unregister,
+};
+
+static const struct tee_desc optee_ffa_clnt_desc = {
+ .name = DRIVER_NAME "-ffa-clnt",
+ .ops = &optee_ffa_clnt_ops,
+ .owner = THIS_MODULE,
+};
+
+static const struct tee_driver_ops optee_ffa_supp_ops = {
+ .get_version = optee_ffa_get_version,
+ .open = optee_ffa_open,
+ .release = optee_release_supp,
+ .supp_recv = optee_supp_recv,
+ .supp_send = optee_supp_send,
+ .shm_register = optee_ffa_shm_register, /* same as for clnt ops */
+ .shm_unregister = optee_ffa_shm_unregister_supp,
+};
+
+static const struct tee_desc optee_ffa_supp_desc = {
+ .name = DRIVER_NAME "-ffa-supp",
+ .ops = &optee_ffa_supp_ops,
+ .owner = THIS_MODULE,
+ .flags = TEE_DESC_PRIVILEGED,
+};
+
+static const struct optee_ops optee_ffa_ops = {
+ .do_call_with_arg = optee_ffa_do_call_with_arg,
+ .to_msg_param = optee_ffa_to_msg_param,
+ .from_msg_param = optee_ffa_from_msg_param,
+};
+
+static void optee_ffa_remove(struct ffa_device *ffa_dev)
+{
+ struct optee *optee = ffa_dev->dev.driver_data;
+
+ optee_remove_common(optee);
+
+ mutex_destroy(&optee->ffa.mutex);
+ rhashtable_free_and_destroy(&optee->ffa.global_ids, rh_free_fn, NULL);
+
+ kfree(optee);
+}
+
+static int optee_ffa_probe(struct ffa_device *ffa_dev)
+{
+ const struct ffa_dev_ops *ffa_ops;
+ unsigned int rpc_arg_count;
+ struct tee_device *teedev;
+ struct optee *optee;
+ int rc;
+
+ ffa_ops = ffa_dev_ops_get(ffa_dev);
+ if (!ffa_ops) {
+ pr_warn("failed \"method\" init: ffa\n");
+ return -ENOENT;
+ }
+
+ if (!optee_ffa_api_is_compatbile(ffa_dev, ffa_ops))
+ return -EINVAL;
+
+ if (!optee_ffa_exchange_caps(ffa_dev, ffa_ops, &rpc_arg_count))
+ return -EINVAL;
+
+ optee = kzalloc(sizeof(*optee), GFP_KERNEL);
+ if (!optee) {
+ rc = -ENOMEM;
+ goto err;
+ }
+ optee->pool = optee_ffa_config_dyn_shm();
+ if (IS_ERR(optee->pool)) {
+ rc = PTR_ERR(optee->pool);
+ optee->pool = NULL;
+ goto err;
+ }
+
+ optee->ops = &optee_ffa_ops;
+ optee->ffa.ffa_dev = ffa_dev;
+ optee->ffa.ffa_ops = ffa_ops;
+ optee->rpc_arg_count = rpc_arg_count;
+
+ teedev = tee_device_alloc(&optee_ffa_clnt_desc, NULL, optee->pool,
+ optee);
+ if (IS_ERR(teedev)) {
+ rc = PTR_ERR(teedev);
+ goto err;
+ }
+ optee->teedev = teedev;
+
+ teedev = tee_device_alloc(&optee_ffa_supp_desc, NULL, optee->pool,
+ optee);
+ if (IS_ERR(teedev)) {
+ rc = PTR_ERR(teedev);
+ goto err;
+ }
+ optee->supp_teedev = teedev;
+
+ rc = tee_device_register(optee->teedev);
+ if (rc)
+ goto err;
+
+ rc = tee_device_register(optee->supp_teedev);
+ if (rc)
+ goto err;
+
+ rc = rhashtable_init(&optee->ffa.global_ids, &shm_rhash_params);
+ if (rc)
+ goto err;
+ mutex_init(&optee->ffa.mutex);
+ mutex_init(&optee->call_queue.mutex);
+ INIT_LIST_HEAD(&optee->call_queue.waiters);
+ optee_wait_queue_init(&optee->wait_queue);
+ optee_supp_init(&optee->supp);
+ ffa_dev_set_drvdata(ffa_dev, optee);
+
+ rc = optee_enumerate_devices(PTA_CMD_GET_DEVICES);
+ if (rc) {
+ optee_ffa_remove(ffa_dev);
+ return rc;
+ }
+
+ pr_info("initialized driver\n");
+ return 0;
+err:
+ /*
+ * tee_device_unregister() is safe to call even if the
+ * devices hasn't been registered with
+ * tee_device_register() yet.
+ */
+ tee_device_unregister(optee->supp_teedev);
+ tee_device_unregister(optee->teedev);
+ if (optee->pool)
+ tee_shm_pool_free(optee->pool);
+ kfree(optee);
+ return rc;
+}
+
+static const struct ffa_device_id optee_ffa_device_id[] = {
+ /* 486178e0-e7f8-11e3-bc5e0002a5d5c51b */
+ { UUID_INIT(0x486178e0, 0xe7f8, 0x11e3,
+ 0xbc, 0x5e, 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b) },
+ {}
+};
+
+static struct ffa_driver optee_ffa_driver = {
+ .name = "optee",
+ .probe = optee_ffa_probe,
+ .remove = optee_ffa_remove,
+ .id_table = optee_ffa_device_id,
+};
+module_ffa_driver(optee_ffa_driver);
diff --git a/drivers/tee/optee/optee_ffa.h b/drivers/tee/optee/optee_ffa.h
new file mode 100644
index 000000000000..ee3a03fc392c
--- /dev/null
+++ b/drivers/tee/optee/optee_ffa.h
@@ -0,0 +1,153 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+/*
+ * Copyright (c) 2019-2021, Linaro Limited
+ */
+
+/*
+ * This file is exported by OP-TEE and is kept in sync between secure world
+ * and normal world drivers. We're using ARM FF-A 1.0 specification.
+ */
+
+#ifndef __OPTEE_FFA_H
+#define __OPTEE_FFA_H
+
+#include <linux/arm_ffa.h>
+
+/*
+ * Normal world sends requests with FFA_MSG_SEND_DIRECT_REQ and
+ * responses are returned with FFA_MSG_SEND_DIRECT_RESP for normal
+ * messages.
+ *
+ * All requests with FFA_MSG_SEND_DIRECT_REQ and FFA_MSG_SEND_DIRECT_RESP
+ * are using the AArch32 SMC calling convention with register usage as
+ * defined in FF-A specification:
+ * w0: Function ID (0x8400006F or 0x84000070)
+ * w1: Source/Destination IDs
+ * w2: Reserved (MBZ)
+ * w3-w7: Implementation defined, free to be used below
+ */
+
+#define OPTEE_FFA_VERSION_MAJOR 1
+#define OPTEE_FFA_VERSION_MINOR 0
+
+#define OPTEE_FFA_BLOCKING_CALL(id) (id)
+#define OPTEE_FFA_YIELDING_CALL_BIT 31
+#define OPTEE_FFA_YIELDING_CALL(id) ((id) | BIT(OPTEE_FFA_YIELDING_CALL_BIT))
+
+/*
+ * Returns the API version implemented, currently follows the FF-A version.
+ * Call register usage:
+ * w3: Service ID, OPTEE_FFA_GET_API_VERSION
+ * w4-w7: Not used (MBZ)
+ *
+ * Return register usage:
+ * w3: OPTEE_FFA_VERSION_MAJOR
+ * w4: OPTEE_FFA_VERSION_MINOR
+ * w5-w7: Not used (MBZ)
+ */
+#define OPTEE_FFA_GET_API_VERSION OPTEE_FFA_BLOCKING_CALL(0)
+
+/*
+ * Returns the revision of OP-TEE.
+ *
+ * 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.
+ *
+ * Call register usage:
+ * w3: Service ID, OPTEE_FFA_GET_OS_VERSION
+ * w4-w7: Unused (MBZ)
+ *
+ * Return register usage:
+ * w3: CFG_OPTEE_REVISION_MAJOR
+ * w4: CFG_OPTEE_REVISION_MINOR
+ * w5: TEE_IMPL_GIT_SHA1 (or zero if not supported)
+ */
+#define OPTEE_FFA_GET_OS_VERSION OPTEE_FFA_BLOCKING_CALL(1)
+
+/*
+ * Exchange capabilities between normal world and secure world.
+ *
+ * Currently there are no defined capabilities. When features are added new
+ * capabilities may be added.
+ *
+ * Call register usage:
+ * w3: Service ID, OPTEE_FFA_EXCHANGE_CAPABILITIES
+ * w4-w7: Note used (MBZ)
+ *
+ * Return register usage:
+ * w3: Error code, 0 on success
+ * w4: Bit[7:0]: Number of parameters needed for RPC to be supplied
+ * as the second MSG arg struct for
+ * OPTEE_FFA_YIELDING_CALL_WITH_ARG.
+ * Bit[31:8]: Reserved (MBZ)
+ * w5-w7: Note used (MBZ)
+ */
+#define OPTEE_FFA_EXCHANGE_CAPABILITIES OPTEE_FFA_BLOCKING_CALL(2)
+
+/*
+ * Unregister shared memory
+ *
+ * Call register usage:
+ * w3: Service ID, OPTEE_FFA_YIELDING_CALL_UNREGISTER_SHM
+ * w4: Shared memory handle, lower bits
+ * w5: Shared memory handle, higher bits
+ * w6-w7: Not used (MBZ)
+ *
+ * Return register usage:
+ * w3: Error code, 0 on success
+ * w4-w7: Note used (MBZ)
+ */
+#define OPTEE_FFA_UNREGISTER_SHM OPTEE_FFA_BLOCKING_CALL(3)
+
+/*
+ * Call with struct optee_msg_arg as argument in the supplied shared memory
+ * with a zero internal offset and normal cached memory attributes.
+ * Register usage:
+ * w3: Service ID, OPTEE_FFA_YIELDING_CALL_WITH_ARG
+ * w4: Lower 32 bits of a 64-bit Shared memory handle
+ * w5: Upper 32 bits of a 64-bit Shared memory handle
+ * w6: Offset into shared memory pointing to a struct optee_msg_arg
+ * right after the parameters of this struct (at offset
+ * OPTEE_MSG_GET_ARG_SIZE(num_params) follows a struct optee_msg_arg
+ * for RPC, this struct has reserved space for the number of RPC
+ * parameters as returned by OPTEE_FFA_EXCHANGE_CAPABILITIES.
+ * w7: Not used (MBZ)
+ * Resume from RPC. Register usage:
+ * w3: Service ID, OPTEE_FFA_YIELDING_CALL_RESUME
+ * w4-w6: Not used (MBZ)
+ * w7: Resume info
+ *
+ * Normal return (yielding call is completed). Register usage:
+ * w3: Error code, 0 on success
+ * w4: OPTEE_FFA_YIELDING_CALL_RETURN_DONE
+ * w5-w7: Not used (MBZ)
+ *
+ * RPC interrupt return (RPC from secure world). Register usage:
+ * w3: Error code == 0
+ * w4: Any defined RPC code but OPTEE_FFA_YIELDING_CALL_RETURN_DONE
+ * w5-w6: Not used (MBZ)
+ * w7: Resume info
+ *
+ * Possible error codes in register w3:
+ * 0: Success
+ * FFA_DENIED: w4 isn't one of OPTEE_FFA_YIELDING_CALL_START
+ * OPTEE_FFA_YIELDING_CALL_RESUME
+ *
+ * Possible error codes for OPTEE_FFA_YIELDING_CALL_START,
+ * FFA_BUSY: Number of OP-TEE OS threads exceeded,
+ * try again later
+ * FFA_DENIED: RPC shared memory object not found
+ * FFA_INVALID_PARAMETER: Bad shared memory handle or offset into the memory
+ *
+ * Possible error codes for OPTEE_FFA_YIELDING_CALL_RESUME
+ * FFA_INVALID_PARAMETER: Bad resume info
+ */
+#define OPTEE_FFA_YIELDING_CALL_WITH_ARG OPTEE_FFA_YIELDING_CALL(0)
+#define OPTEE_FFA_YIELDING_CALL_RESUME OPTEE_FFA_YIELDING_CALL(1)
+
+#define OPTEE_FFA_YIELDING_CALL_RETURN_DONE 0
+#define OPTEE_FFA_YIELDING_CALL_RETURN_RPC_CMD 1
+#define OPTEE_FFA_YIELDING_CALL_RETURN_INTERRUPT 2
+
+#endif /*__OPTEE_FFA_H*/
diff --git a/drivers/tee/optee/optee_msg.h b/drivers/tee/optee/optee_msg.h
index e3d72d09c484..2422e185d400 100644
--- a/drivers/tee/optee/optee_msg.h
+++ b/drivers/tee/optee/optee_msg.h
@@ -28,6 +28,9 @@
#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_FMEM_INPUT OPTEE_MSG_ATTR_TYPE_RMEM_INPUT
+#define OPTEE_MSG_ATTR_TYPE_FMEM_OUTPUT OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT
+#define OPTEE_MSG_ATTR_TYPE_FMEM_INOUT OPTEE_MSG_ATTR_TYPE_RMEM_INOUT
#define OPTEE_MSG_ATTR_TYPE_TMEM_INPUT 0x9
#define OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT 0xa
#define OPTEE_MSG_ATTR_TYPE_TMEM_INOUT 0xb
@@ -96,6 +99,8 @@
*/
#define OPTEE_MSG_NONCONTIG_PAGE_SIZE 4096

+#define OPTEE_MSG_FMEM_INVALID_GLOBAL_ID 0xffffffffffffffff
+
/**
* struct optee_msg_param_tmem - temporary memory reference parameter
* @buf_ptr: Address of the buffer
@@ -127,6 +132,23 @@ struct optee_msg_param_rmem {
u64 shm_ref;
};

+/**
+ * struct optee_msg_param_fmem - ffa memory reference parameter
+ * @offs_lower: Lower bits of offset into shared memory reference
+ * @offs_upper: Upper bits of offset into shared memory reference
+ * @internal_offs: Internal offset into the first page of shared memory
+ * reference
+ * @size: Size of the buffer
+ * @global_id: Global identifier of Shared memory
+ */
+struct optee_msg_param_fmem {
+ u32 offs_low;
+ u16 offs_high;
+ u16 internal_offs;
+ u64 size;
+ u64 global_id;
+};
+
/**
* struct optee_msg_param_value - opaque value parameter
*
@@ -143,13 +165,15 @@ struct optee_msg_param_value {
* @attr: attributes
* @tmem: parameter by temporary memory reference
* @rmem: parameter by registered memory reference
+ * @fmem: parameter by ffa registered memory reference
* @value: parameter by opaque value
* @octets: parameter by octet string
*
* @attr & OPTEE_MSG_ATTR_TYPE_MASK indicates if tmem, rmem or value is used in
* the union. OPTEE_MSG_ATTR_TYPE_VALUE_* indicates value or octets,
* OPTEE_MSG_ATTR_TYPE_TMEM_* indicates @tmem and
- * OPTEE_MSG_ATTR_TYPE_RMEM_* indicates @rmem,
+ * OPTEE_MSG_ATTR_TYPE_RMEM_* or the alias PTEE_MSG_ATTR_TYPE_FMEM_* indicates
+ * @rmem or @fmem depending on the conduit.
* OPTEE_MSG_ATTR_TYPE_NONE indicates that none of the members are used.
*/
struct optee_msg_param {
@@ -157,6 +181,7 @@ struct optee_msg_param {
union {
struct optee_msg_param_tmem tmem;
struct optee_msg_param_rmem rmem;
+ struct optee_msg_param_fmem fmem;
struct optee_msg_param_value value;
u8 octets[24];
} u;
diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h
index 68d1331068e9..c4547c152ee6 100644
--- a/drivers/tee/optee/optee_private.h
+++ b/drivers/tee/optee/optee_private.h
@@ -7,6 +7,7 @@
#define OPTEE_PRIVATE_H

#include <linux/arm-smccc.h>
+#include <linux/rhashtable.h>
#include <linux/semaphore.h>
#include <linux/tee_drv.h>
#include <linux/types.h>
@@ -22,6 +23,7 @@
#define TEEC_ERROR_NOT_SUPPORTED 0xFFFF000A
#define TEEC_ERROR_COMMUNICATION 0xFFFF000E
#define TEEC_ERROR_OUT_OF_MEMORY 0xFFFF000C
+#define TEEC_ERROR_BUSY 0xFFFF000D
#define TEEC_ERROR_SHORT_BUFFER 0xFFFF0010

#define TEEC_ORIGIN_COMMS 0x00000002
@@ -73,19 +75,28 @@ struct optee_supp {
struct completion reqs_c;
};

-/**
- * struct optee_smc - SMC ABI specifics
- * @invoke_fn: function to issue smc or hvc
- * @memremaped_shm virtual address of memory in shared memory pool
- * @sec_caps: secure world capabilities defined by
- * OPTEE_SMC_SEC_CAP_* in optee_smc.h
- */
struct optee_smc {
optee_invoke_fn *invoke_fn;
void *memremaped_shm;
u32 sec_caps;
};

+/**
+ * struct optee_ffa_data - FFA communication struct
+ * @ffa_dev FFA device, contains the destination id, the id of
+ * OP-TEE in secure world
+ * @ffa_ops FFA operations
+ * @mutex Serializes access to @global_ids
+ * @global_ids FF-A shared memory global handle translation
+ */
+struct optee_ffa {
+ struct ffa_device *ffa_dev;
+ const struct ffa_dev_ops *ffa_ops;
+ /* Serializes access to @global_ids */
+ struct mutex mutex;
+ struct rhashtable global_ids;
+};
+
struct optee;

/**
@@ -116,11 +127,13 @@ struct optee_ops {
* world
* @teedev: client device
* @smc: specific to SMC ABI
+ * @ffa: specific to FF-A ABI
* @call_queue: queue of threads waiting to call @invoke_fn
* @wait_queue: queue of threads from secure world waiting for a
* secure world sync object
* @supp: supplicant synchronization struct for RPC to supplicant
* @pool: shared memory pool
+ * @rpc_arg_count: If > 0 number of RPC parameters to make room for
* @scan_bus_done flag if device registation was already done.
* @scan_bus_wq workqueue to scan optee bus and register optee drivers
* @scan_bus_work workq to scan optee bus and register optee drivers
@@ -129,11 +142,17 @@ struct optee {
struct tee_device *supp_teedev;
struct tee_device *teedev;
const struct optee_ops *ops;
- struct optee_smc smc;
+ union {
+ struct optee_smc smc;
+#ifdef CONFIG_ARM_FFA_TRANSPORT
+ struct optee_ffa ffa;
+#endif
+ };
struct optee_call_queue call_queue;
struct optee_wait_queue wait_queue;
struct optee_supp supp;
struct tee_shm_pool *pool;
+ unsigned int rpc_arg_count;
bool scan_bus_done;
struct workqueue_struct *scan_bus_wq;
struct work_struct scan_bus_work;
--
2.31.1

2021-07-22 12:20:29

by Jens Wiklander

[permalink] [raw]
Subject: [PATCH v3 1/5] tee: add sec_world_id to struct tee_shm

Adds sec_world_id to struct tee_shm which describes a shared memory
object. sec_world_id can be used by a driver to store an id assigned by
secure world.

Signed-off-by: Jens Wiklander <[email protected]>
---
include/linux/tee_drv.h | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/include/linux/tee_drv.h b/include/linux/tee_drv.h
index 54269e47ac9a..1a29f0e66e13 100644
--- a/include/linux/tee_drv.h
+++ b/include/linux/tee_drv.h
@@ -196,7 +196,11 @@ int tee_session_calc_client_uuid(uuid_t *uuid, u32 connection_method,
* @num_pages: number of locked pages
* @dmabuf: dmabuf used to for exporting to user space
* @flags: defined by TEE_SHM_* in tee_drv.h
- * @id: unique id of a shared memory object on this device
+ * @id: unique id of a shared memory object on this device, shared
+ * with user space
+ * @sec_world_id:
+ * secure world assigned id of this shared memory object, not
+ * used by all drivers
*
* This pool is only supposed to be accessed directly from the TEE
* subsystem and from drivers that implements their own shm pool manager.
@@ -212,6 +216,7 @@ struct tee_shm {
struct dma_buf *dmabuf;
u32 flags;
int id;
+ u64 sec_world_id;
};

/**
--
2.31.1

2021-07-22 12:20:30

by Jens Wiklander

[permalink] [raw]
Subject: [PATCH v3 3/5] optee: refactor driver with internal callbacks

The OP-TEE driver is refactored with three internal callbacks replacing
direct calls to optee_from_msg_param(), optee_to_msg_param() and
optee_do_call_with_arg().

These functions a central to communicating with OP-TEE in secure world
by using the SMC Calling Convention directly.

This refactoring makes room for using other primitives to communicate
with OP-TEE in secure world while being able to reuse as much as
possible from the present driver.

Signed-off-by: Jens Wiklander <[email protected]>
---
drivers/tee/optee/call.c | 86 +++++++++--------
drivers/tee/optee/core.c | 148 ++++++++++++++++++++----------
drivers/tee/optee/optee_private.h | 35 +++++--
drivers/tee/optee/rpc.c | 19 ++--
4 files changed, 182 insertions(+), 106 deletions(-)

diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c
index 9d8f5a95e42f..00ecd794e59a 100644
--- a/drivers/tee/optee/call.c
+++ b/drivers/tee/optee/call.c
@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
- * Copyright (c) 2015, Linaro Limited
+ * Copyright (c) 2015-2021, Linaro Limited
*/
#include <linux/arm-smccc.h>
#include <linux/device.h>
@@ -118,20 +118,25 @@ static struct optee_session *find_session(struct optee_context_data *ctxdata,
/**
* optee_do_call_with_arg() - Do an SMC to OP-TEE in secure world
* @ctx: calling context
- * @parg: physical address of message to pass to secure world
+ * @arg: shared memory holding the message to pass to secure world
*
* Does and SMC to OP-TEE in secure world and handles eventual resulting
* Remote Procedure Calls (RPC) from OP-TEE.
*
* Returns return code from secure world, 0 is OK
*/
-u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
+int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg)
{
struct optee *optee = tee_get_drvdata(ctx->teedev);
struct optee_call_waiter w;
struct optee_rpc_param param = { };
struct optee_call_ctx call_ctx = { };
- u32 ret;
+ phys_addr_t parg;
+ int rc;
+
+ rc = tee_shm_get_pa(arg, 0, &parg);
+ if (rc)
+ return rc;

param.a0 = OPTEE_SMC_CALL_WITH_ARG;
reg_pair_from_64(&param.a1, &param.a2, parg);
@@ -160,7 +165,7 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
param.a3 = res.a3;
optee_handle_rpc(ctx, &param, &call_ctx);
} else {
- ret = res.a0;
+ rc = res.a0;
break;
}
}
@@ -172,14 +177,12 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
*/
optee_cq_wait_final(&optee->call_queue, &w);

- return ret;
+ return rc;
}

static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,
- struct optee_msg_arg **msg_arg,
- phys_addr_t *msg_parg)
+ struct optee_msg_arg **msg_arg)
{
- int rc;
struct tee_shm *shm;
struct optee_msg_arg *ma;

@@ -190,22 +193,13 @@ static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,

ma = tee_shm_get_va(shm, 0);
if (IS_ERR(ma)) {
- rc = PTR_ERR(ma);
- goto out;
+ tee_shm_free(shm);
+ return (void *)ma;
}

- rc = tee_shm_get_pa(shm, 0, msg_parg);
- if (rc)
- goto out;
-
memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params));
ma->num_params = num_params;
*msg_arg = ma;
-out:
- if (rc) {
- tee_shm_free(shm);
- return ERR_PTR(rc);
- }

return shm;
}
@@ -214,16 +208,16 @@ int optee_open_session(struct tee_context *ctx,
struct tee_ioctl_open_session_arg *arg,
struct tee_param *param)
{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
struct optee_context_data *ctxdata = ctx->data;
int rc;
struct tee_shm *shm;
struct optee_msg_arg *msg_arg;
- phys_addr_t msg_parg;
struct optee_session *sess = NULL;
uuid_t client_uuid;

/* +2 for the meta parameters added below */
- shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg, &msg_parg);
+ shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg);
if (IS_ERR(shm))
return PTR_ERR(shm);

@@ -247,7 +241,8 @@ int optee_open_session(struct tee_context *ctx,
goto out;
export_uuid(msg_arg->params[1].u.octets, &client_uuid);

- rc = optee_to_msg_param(msg_arg->params + 2, arg->num_params, param);
+ rc = optee->ops->to_msg_param(optee, msg_arg->params + 2,
+ arg->num_params, param);
if (rc)
goto out;

@@ -257,7 +252,7 @@ int optee_open_session(struct tee_context *ctx,
goto out;
}

- if (optee_do_call_with_arg(ctx, msg_parg)) {
+ if (optee->ops->do_call_with_arg(ctx, shm)) {
msg_arg->ret = TEEC_ERROR_COMMUNICATION;
msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
}
@@ -272,7 +267,8 @@ int optee_open_session(struct tee_context *ctx,
kfree(sess);
}

- if (optee_from_msg_param(param, arg->num_params, msg_arg->params + 2)) {
+ if (optee->ops->from_msg_param(optee, param, arg->num_params,
+ msg_arg->params + 2)) {
arg->ret = TEEC_ERROR_COMMUNICATION;
arg->ret_origin = TEEC_ORIGIN_COMMS;
/* Close session again to avoid leakage */
@@ -291,16 +287,16 @@ int optee_open_session(struct tee_context *ctx,
int optee_close_session_helper(struct tee_context *ctx, u32 session)
{
struct tee_shm *shm;
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
struct optee_msg_arg *msg_arg;
- phys_addr_t msg_parg;

- shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
+ shm = get_msg_arg(ctx, 0, &msg_arg);
if (IS_ERR(shm))
return PTR_ERR(shm);

msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
msg_arg->session = session;
- optee_do_call_with_arg(ctx, msg_parg);
+ optee->ops->do_call_with_arg(ctx, shm);

tee_shm_free(shm);

@@ -328,10 +324,10 @@ int optee_close_session(struct tee_context *ctx, u32 session)
int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
struct tee_param *param)
{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
struct optee_context_data *ctxdata = ctx->data;
struct tee_shm *shm;
struct optee_msg_arg *msg_arg;
- phys_addr_t msg_parg;
struct optee_session *sess;
int rc;

@@ -342,7 +338,7 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
if (!sess)
return -EINVAL;

- shm = get_msg_arg(ctx, arg->num_params, &msg_arg, &msg_parg);
+ shm = get_msg_arg(ctx, arg->num_params, &msg_arg);
if (IS_ERR(shm))
return PTR_ERR(shm);
msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND;
@@ -350,16 +346,18 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
msg_arg->session = arg->session;
msg_arg->cancel_id = arg->cancel_id;

- rc = optee_to_msg_param(msg_arg->params, arg->num_params, param);
+ rc = optee->ops->to_msg_param(optee, msg_arg->params, arg->num_params,
+ param);
if (rc)
goto out;

- if (optee_do_call_with_arg(ctx, msg_parg)) {
+ if (optee->ops->do_call_with_arg(ctx, shm)) {
msg_arg->ret = TEEC_ERROR_COMMUNICATION;
msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
}

- if (optee_from_msg_param(param, arg->num_params, msg_arg->params)) {
+ if (optee->ops->from_msg_param(optee, param, arg->num_params,
+ msg_arg->params)) {
msg_arg->ret = TEEC_ERROR_COMMUNICATION;
msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
}
@@ -373,10 +371,10 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,

int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
struct optee_context_data *ctxdata = ctx->data;
struct tee_shm *shm;
struct optee_msg_arg *msg_arg;
- phys_addr_t msg_parg;
struct optee_session *sess;

/* Check that the session is valid */
@@ -386,14 +384,14 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
if (!sess)
return -EINVAL;

- shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
+ shm = get_msg_arg(ctx, 0, &msg_arg);
if (IS_ERR(shm))
return PTR_ERR(shm);

msg_arg->cmd = OPTEE_MSG_CMD_CANCEL;
msg_arg->session = session;
msg_arg->cancel_id = cancel_id;
- optee_do_call_with_arg(ctx, msg_parg);
+ optee->ops->do_call_with_arg(ctx, shm);

tee_shm_free(shm);
return 0;
@@ -592,10 +590,10 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
struct page **pages, size_t num_pages,
unsigned long start)
{
- struct tee_shm *shm_arg = NULL;
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
struct optee_msg_arg *msg_arg;
+ struct tee_shm *shm_arg;
u64 *pages_list;
- phys_addr_t msg_parg;
int rc;

if (!num_pages)
@@ -609,7 +607,7 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
if (!pages_list)
return -ENOMEM;

- shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
+ shm_arg = get_msg_arg(ctx, 1, &msg_arg);
if (IS_ERR(shm_arg)) {
rc = PTR_ERR(shm_arg);
goto out;
@@ -630,7 +628,7 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
msg_arg->params->u.tmem.buf_ptr = virt_to_phys(pages_list) |
(tee_shm_get_page_offset(shm) & (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));

- if (optee_do_call_with_arg(ctx, msg_parg) ||
+ if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
msg_arg->ret != TEEC_SUCCESS)
rc = -EINVAL;

@@ -642,12 +640,12 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,

int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
{
- struct tee_shm *shm_arg;
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
struct optee_msg_arg *msg_arg;
- phys_addr_t msg_parg;
+ struct tee_shm *shm_arg;
int rc = 0;

- shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
+ shm_arg = get_msg_arg(ctx, 1, &msg_arg);
if (IS_ERR(shm_arg))
return PTR_ERR(shm_arg);

@@ -656,7 +654,7 @@ int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
msg_arg->params[0].u.rmem.shm_ref = (unsigned long)shm;

- if (optee_do_call_with_arg(ctx, msg_parg) ||
+ if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
msg_arg->ret != TEEC_SUCCESS)
rc = -EINVAL;
tee_shm_free(shm_arg);
diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c
index 949223b214c3..f689f171a794 100644
--- a/drivers/tee/optee/core.c
+++ b/drivers/tee/optee/core.c
@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
- * Copyright (c) 2015, Linaro Limited
+ * Copyright (c) 2015-2021, Linaro Limited
*/

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
@@ -26,21 +26,87 @@

#define OPTEE_SHM_NUM_PRIV_PAGES CONFIG_OPTEE_SHM_NUM_PRIV_PAGES

+static void from_msg_param_value(struct tee_param *p, u32 attr,
+ const struct optee_msg_param *mp)
+{
+ p->attr = TEE_IOCTL_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;
+}
+
+static int from_msg_param_tmp_mem(struct tee_param *p, u32 attr,
+ const struct optee_msg_param *mp)
+{
+ struct tee_shm *shm;
+ phys_addr_t pa;
+ int rc;
+
+ p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
+ attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
+ p->u.memref.size = mp->u.tmem.size;
+ shm = (struct tee_shm *)(unsigned long)mp->u.tmem.shm_ref;
+ if (!shm) {
+ p->u.memref.shm_offs = 0;
+ p->u.memref.shm = NULL;
+ return 0;
+ }
+
+ rc = tee_shm_get_pa(shm, 0, &pa);
+ if (rc)
+ return rc;
+
+ p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
+ p->u.memref.shm = shm;
+
+ /* Check that the memref is covered by the shm object */
+ if (p->u.memref.size) {
+ size_t o = p->u.memref.shm_offs +
+ p->u.memref.size - 1;
+
+ rc = tee_shm_get_pa(shm, o, NULL);
+ if (rc)
+ return rc;
+ }
+
+ return 0;
+}
+
+static void from_msg_param_reg_mem(struct tee_param *p, u32 attr,
+ const struct optee_msg_param *mp)
+{
+ struct tee_shm *shm;
+
+ p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
+ attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
+ p->u.memref.size = mp->u.rmem.size;
+ shm = (struct tee_shm *)(unsigned long)mp->u.rmem.shm_ref;
+
+ if (shm) {
+ p->u.memref.shm_offs = mp->u.rmem.offs;
+ p->u.memref.shm = shm;
+ } else {
+ p->u.memref.shm_offs = 0;
+ p->u.memref.shm = NULL;
+ }
+}
+
/**
* optee_from_msg_param() - convert from OPTEE_MSG parameters to
* struct tee_param
+ * @optee: main service struct
* @params: subsystem internal parameter representation
* @num_params: number of elements in the parameter arrays
* @msg_params: OPTEE_MSG parameters
* Returns 0 on success or <0 on failure
*/
-int optee_from_msg_param(struct tee_param *params, size_t num_params,
- const struct optee_msg_param *msg_params)
+static int optee_from_msg_param(struct optee *optee, struct tee_param *params,
+ size_t num_params,
+ const struct optee_msg_param *msg_params)
{
int rc;
size_t n;
- struct tee_shm *shm;
- phys_addr_t pa;

for (n = 0; n < num_params; n++) {
struct tee_param *p = params + n;
@@ -55,48 +121,19 @@ int optee_from_msg_param(struct tee_param *params, size_t num_params,
case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT:
case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:
case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:
- p->attr = TEE_IOCTL_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;
+ from_msg_param_value(p, attr, mp);
break;
case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:
case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
- p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
- attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
- p->u.memref.size = mp->u.tmem.size;
- shm = (struct tee_shm *)(unsigned long)
- mp->u.tmem.shm_ref;
- if (!shm) {
- p->u.memref.shm_offs = 0;
- p->u.memref.shm = NULL;
- break;
- }
- rc = tee_shm_get_pa(shm, 0, &pa);
+ rc = from_msg_param_tmp_mem(p, attr, mp);
if (rc)
return rc;
- p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
- p->u.memref.shm = shm;
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_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
- attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
- p->u.memref.size = mp->u.rmem.size;
- shm = (struct tee_shm *)(unsigned long)
- 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;
-
+ from_msg_param_reg_mem(p, attr, mp);
break;

default:
@@ -106,6 +143,16 @@ int optee_from_msg_param(struct tee_param *params, size_t num_params,
return 0;
}

+static void to_msg_param_value(struct optee_msg_param *mp,
+ const struct tee_param *p)
+{
+ mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
+ TEE_IOCTL_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;
+}
+
static int to_msg_param_tmp_mem(struct optee_msg_param *mp,
const struct tee_param *p)
{
@@ -148,13 +195,15 @@ static int to_msg_param_reg_mem(struct optee_msg_param *mp,

/**
* optee_to_msg_param() - convert from struct tee_params to OPTEE_MSG parameters
+ * @optee: main service struct
* @msg_params: OPTEE_MSG parameters
* @num_params: number of elements in the parameter arrays
* @params: subsystem itnernal parameter representation
* Returns 0 on success or <0 on failure
*/
-int optee_to_msg_param(struct optee_msg_param *msg_params, size_t num_params,
- const struct tee_param *params)
+static int optee_to_msg_param(struct optee *optee,
+ struct optee_msg_param *msg_params,
+ size_t num_params, const struct tee_param *params)
{
int rc;
size_t n;
@@ -171,11 +220,7 @@ int optee_to_msg_param(struct optee_msg_param *msg_params, size_t num_params,
case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT:
case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
- mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
- TEE_IOCTL_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;
+ to_msg_param_value(mp, p);
break;
case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT:
case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
@@ -301,7 +346,7 @@ static void optee_release_supp(struct tee_context *ctx)
optee_supp_release(&optee->supp);
}

-static const struct tee_driver_ops optee_ops = {
+static const struct tee_driver_ops optee_clnt_ops = {
.get_version = optee_get_version,
.open = optee_open,
.release = optee_release,
@@ -313,9 +358,9 @@ static const struct tee_driver_ops optee_ops = {
.shm_unregister = optee_shm_unregister,
};

-static const struct tee_desc optee_desc = {
+static const struct tee_desc optee_clnt_desc = {
.name = DRIVER_NAME "-clnt",
- .ops = &optee_ops,
+ .ops = &optee_clnt_ops,
.owner = THIS_MODULE,
};

@@ -336,6 +381,12 @@ static const struct tee_desc optee_supp_desc = {
.flags = TEE_DESC_PRIVILEGED,
};

+static const struct optee_ops optee_ops = {
+ .do_call_with_arg = optee_do_call_with_arg,
+ .to_msg_param = optee_to_msg_param,
+ .from_msg_param = optee_from_msg_param,
+};
+
static bool optee_msg_api_uid_is_optee_api(optee_invoke_fn *invoke_fn)
{
struct arm_smccc_res res;
@@ -637,10 +688,11 @@ static int optee_probe(struct platform_device *pdev)
goto err;
}

+ optee->ops = &optee_ops;
optee->invoke_fn = invoke_fn;
optee->sec_caps = sec_caps;

- teedev = tee_device_alloc(&optee_desc, NULL, pool, optee);
+ teedev = tee_device_alloc(&optee_clnt_desc, NULL, pool, optee);
if (IS_ERR(teedev)) {
rc = PTR_ERR(teedev);
goto err;
diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h
index 2b63b796645e..c5741e96e967 100644
--- a/drivers/tee/optee/optee_private.h
+++ b/drivers/tee/optee/optee_private.h
@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
- * Copyright (c) 2015, Linaro Limited
+ * Copyright (c) 2015-2021, Linaro Limited
*/

#ifndef OPTEE_PRIVATE_H
@@ -66,9 +66,34 @@ struct optee_supp {
struct completion reqs_c;
};

+struct optee;
+
+/**
+ * struct optee_ops - OP-TEE driver internal operations
+ * @do_call_with_arg: enters OP-TEE in secure world
+ * @to_msg_param: converts from struct tee_param to OPTEE_MSG parameters
+ * @from_msg_param: converts from OPTEE_MSG parameters to struct tee_param
+ *
+ * These OPs are only supposed to be used internally in the OP-TEE driver
+ * as a way of abstracting the different methogs of entering OP-TEE in
+ * secure world.
+ */
+struct optee_ops {
+ int (*do_call_with_arg)(struct tee_context *ctx,
+ struct tee_shm *shm_arg);
+ int (*to_msg_param)(struct optee *optee,
+ struct optee_msg_param *msg_params,
+ size_t num_params, const struct tee_param *params);
+ int (*from_msg_param)(struct optee *optee, struct tee_param *params,
+ size_t num_params,
+ const struct optee_msg_param *msg_params);
+};
+
/**
* struct optee - main service struct
* @supp_teedev: supplicant device
+ * @ops: internal callbacks for different ways to reach secure
+ * world
* @teedev: client device
* @invoke_fn: function to issue smc or hvc
* @call_queue: queue of threads waiting to call @invoke_fn
@@ -86,6 +111,7 @@ struct optee_supp {
struct optee {
struct tee_device *supp_teedev;
struct tee_device *teedev;
+ const struct optee_ops *ops;
optee_invoke_fn *invoke_fn;
struct optee_call_queue call_queue;
struct optee_wait_queue wait_queue;
@@ -148,7 +174,7 @@ int optee_supp_recv(struct tee_context *ctx, u32 *func, u32 *num_params,
int optee_supp_send(struct tee_context *ctx, u32 ret, u32 num_params,
struct tee_param *param);

-u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg);
+int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg);
int optee_open_session(struct tee_context *ctx,
struct tee_ioctl_open_session_arg *arg,
struct tee_param *param);
@@ -171,11 +197,6 @@ int optee_shm_register_supp(struct tee_context *ctx, struct tee_shm *shm,
unsigned long start);
int optee_shm_unregister_supp(struct tee_context *ctx, struct tee_shm *shm);

-int optee_from_msg_param(struct tee_param *params, size_t num_params,
- const struct optee_msg_param *msg_params);
-int optee_to_msg_param(struct optee_msg_param *msg_params, size_t num_params,
- const struct tee_param *params);
-
u64 *optee_allocate_pages_list(size_t num_entries);
void optee_free_pages_list(void *array, size_t num_entries);
void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,
diff --git a/drivers/tee/optee/rpc.c b/drivers/tee/optee/rpc.c
index 1849180b0278..39562fb6841e 100644
--- a/drivers/tee/optee/rpc.c
+++ b/drivers/tee/optee/rpc.c
@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
- * Copyright (c) 2015-2016, Linaro Limited
+ * Copyright (c) 2015-2021, Linaro Limited
*/

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
@@ -55,6 +55,7 @@ static void handle_rpc_func_cmd_get_time(struct optee_msg_arg *arg)
static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
struct optee_msg_arg *arg)
{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
struct tee_param *params;
struct i2c_adapter *adapter;
struct i2c_msg msg = { };
@@ -79,7 +80,8 @@ static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
return;
}

- if (optee_from_msg_param(params, arg->num_params, arg->params))
+ if (optee->ops->from_msg_param(optee, params, arg->num_params,
+ arg->params))
goto bad;

for (i = 0; i < arg->num_params; i++) {
@@ -122,7 +124,8 @@ static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
arg->ret = TEEC_ERROR_COMMUNICATION;
} else {
params[3].u.value.a = msg.len;
- if (optee_to_msg_param(arg->params, arg->num_params, params))
+ if (optee->ops->to_msg_param(optee, arg->params,
+ arg->num_params, params))
arg->ret = TEEC_ERROR_BAD_PARAMETERS;
else
arg->ret = TEEC_SUCCESS;
@@ -234,7 +237,7 @@ static void handle_rpc_func_cmd_wait(struct optee_msg_arg *arg)
arg->ret = TEEC_ERROR_BAD_PARAMETERS;
}

-static void handle_rpc_supp_cmd(struct tee_context *ctx,
+static void handle_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
struct optee_msg_arg *arg)
{
struct tee_param *params;
@@ -248,14 +251,16 @@ static void handle_rpc_supp_cmd(struct tee_context *ctx,
return;
}

- if (optee_from_msg_param(params, arg->num_params, arg->params)) {
+ if (optee->ops->from_msg_param(optee, params, arg->num_params,
+ arg->params)) {
arg->ret = TEEC_ERROR_BAD_PARAMETERS;
goto out;
}

arg->ret = optee_supp_thrd_req(ctx, arg->cmd, arg->num_params, params);

- if (optee_to_msg_param(arg->params, arg->num_params, params))
+ if (optee->ops->to_msg_param(optee, arg->params, arg->num_params,
+ params))
arg->ret = TEEC_ERROR_BAD_PARAMETERS;
out:
kfree(params);
@@ -480,7 +485,7 @@ static void handle_rpc_func_cmd(struct tee_context *ctx, struct optee *optee,
handle_rpc_func_cmd_i2c_transfer(ctx, arg);
break;
default:
- handle_rpc_supp_cmd(ctx, arg);
+ handle_rpc_supp_cmd(ctx, optee, arg);
}
}

--
2.31.1

2021-07-22 12:21:41

by Jens Wiklander

[permalink] [raw]
Subject: [PATCH v3 4/5] optee: isolate smc abi

Isolate the ABI based on raw SMCs. Code specific to the raw SMC ABI is
moved into smc_abi.c. This makes room for other ABIs with a clear
separation.

This patch is not supposed to change the driver behavior, it's only a
matter of reorganizing the code.

Signed-off-by: Jens Wiklander <[email protected]>
---
drivers/tee/optee/Makefile | 6 +-
drivers/tee/optee/call.c | 339 +-------
drivers/tee/optee/core.c | 684 +--------------
drivers/tee/optee/optee_private.h | 104 ++-
drivers/tee/optee/rpc.c | 255 +-----
drivers/tee/optee/shm_pool.c | 89 --
drivers/tee/optee/shm_pool.h | 14 -
drivers/tee/optee/smc_abi.c | 1301 +++++++++++++++++++++++++++++
8 files changed, 1441 insertions(+), 1351 deletions(-)
delete mode 100644 drivers/tee/optee/shm_pool.c
delete mode 100644 drivers/tee/optee/shm_pool.h
create mode 100644 drivers/tee/optee/smc_abi.c

diff --git a/drivers/tee/optee/Makefile b/drivers/tee/optee/Makefile
index 3aa33ea9e6a6..e92f77462f40 100644
--- a/drivers/tee/optee/Makefile
+++ b/drivers/tee/optee/Makefile
@@ -4,8 +4,10 @@ optee-objs += core.o
optee-objs += call.o
optee-objs += rpc.o
optee-objs += supp.o
-optee-objs += shm_pool.o
optee-objs += device.o

+optee-smc-abi-y = smc_abi.o
+optee-objs += $(optee-ffa-abi-y)
+
# for tracing framework to find optee_trace.h
-CFLAGS_call.o := -I$(src)
+CFLAGS_smc_abi.o := -I$(src)
diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c
index 00ecd794e59a..3f81c168ed3f 100644
--- a/drivers/tee/optee/call.c
+++ b/drivers/tee/optee/call.c
@@ -2,28 +2,17 @@
/*
* Copyright (c) 2015-2021, Linaro Limited
*/
-#include <linux/arm-smccc.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/mm.h>
-#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/tee_drv.h>
#include <linux/types.h>
-#include <linux/uaccess.h>
#include "optee_private.h"
-#include "optee_smc.h"
-#define CREATE_TRACE_POINTS
-#include "optee_trace.h"

-struct optee_call_waiter {
- struct list_head list_node;
- struct completion c;
-};
-
-static void optee_cq_wait_init(struct optee_call_queue *cq,
- struct optee_call_waiter *w)
+void optee_cq_wait_init(struct optee_call_queue *cq,
+ struct optee_call_waiter *w)
{
/*
* We're preparing to make a call to secure world. In case we can't
@@ -47,8 +36,8 @@ static void optee_cq_wait_init(struct optee_call_queue *cq,
mutex_unlock(&cq->mutex);
}

-static void optee_cq_wait_for_completion(struct optee_call_queue *cq,
- struct optee_call_waiter *w)
+void optee_cq_wait_for_completion(struct optee_call_queue *cq,
+ struct optee_call_waiter *w)
{
wait_for_completion(&w->c);

@@ -74,8 +63,8 @@ static void optee_cq_complete_one(struct optee_call_queue *cq)
}
}

-static void optee_cq_wait_final(struct optee_call_queue *cq,
- struct optee_call_waiter *w)
+void optee_cq_wait_final(struct optee_call_queue *cq,
+ struct optee_call_waiter *w)
{
/*
* We're done with the call to secure world. The thread in secure
@@ -115,73 +104,8 @@ static struct optee_session *find_session(struct optee_context_data *ctxdata,
return NULL;
}

-/**
- * optee_do_call_with_arg() - Do an SMC to OP-TEE in secure world
- * @ctx: calling context
- * @arg: shared memory holding the message to pass to secure world
- *
- * Does and SMC to OP-TEE in secure world and handles eventual resulting
- * Remote Procedure Calls (RPC) from OP-TEE.
- *
- * Returns return code from secure world, 0 is OK
- */
-int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg)
-{
- struct optee *optee = tee_get_drvdata(ctx->teedev);
- struct optee_call_waiter w;
- struct optee_rpc_param param = { };
- struct optee_call_ctx call_ctx = { };
- phys_addr_t parg;
- int rc;
-
- rc = tee_shm_get_pa(arg, 0, &parg);
- if (rc)
- return rc;
-
- param.a0 = OPTEE_SMC_CALL_WITH_ARG;
- reg_pair_from_64(&param.a1, &param.a2, parg);
- /* Initialize waiter */
- optee_cq_wait_init(&optee->call_queue, &w);
- while (true) {
- struct arm_smccc_res res;
-
- trace_optee_invoke_fn_begin(&param);
- optee->invoke_fn(param.a0, param.a1, param.a2, param.a3,
- param.a4, param.a5, param.a6, param.a7,
- &res);
- trace_optee_invoke_fn_end(&param, &res);
-
- if (res.a0 == OPTEE_SMC_RETURN_ETHREAD_LIMIT) {
- /*
- * Out of threads in secure world, wait for a thread
- * become available.
- */
- optee_cq_wait_for_completion(&optee->call_queue, &w);
- } else if (OPTEE_SMC_RETURN_IS_RPC(res.a0)) {
- cond_resched();
- param.a0 = res.a0;
- param.a1 = res.a1;
- param.a2 = res.a2;
- param.a3 = res.a3;
- optee_handle_rpc(ctx, &param, &call_ctx);
- } else {
- rc = res.a0;
- break;
- }
- }
-
- optee_rpc_finalize_call(&call_ctx);
- /*
- * We're done with our thread in secure world, if there's any
- * thread waiters wake up one.
- */
- optee_cq_wait_final(&optee->call_queue, &w);
-
- return rc;
-}
-
-static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,
- struct optee_msg_arg **msg_arg)
+struct tee_shm *optee_get_msg_arg(struct tee_context *ctx, size_t num_params,
+ struct optee_msg_arg **msg_arg)
{
struct tee_shm *shm;
struct optee_msg_arg *ma;
@@ -217,7 +141,7 @@ int optee_open_session(struct tee_context *ctx,
uuid_t client_uuid;

/* +2 for the meta parameters added below */
- shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg);
+ shm = optee_get_msg_arg(ctx, arg->num_params + 2, &msg_arg);
if (IS_ERR(shm))
return PTR_ERR(shm);

@@ -290,7 +214,7 @@ int optee_close_session_helper(struct tee_context *ctx, u32 session)
struct optee *optee = tee_get_drvdata(ctx->teedev);
struct optee_msg_arg *msg_arg;

- shm = get_msg_arg(ctx, 0, &msg_arg);
+ shm = optee_get_msg_arg(ctx, 0, &msg_arg);
if (IS_ERR(shm))
return PTR_ERR(shm);

@@ -338,7 +262,7 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
if (!sess)
return -EINVAL;

- shm = get_msg_arg(ctx, arg->num_params, &msg_arg);
+ shm = optee_get_msg_arg(ctx, arg->num_params, &msg_arg);
if (IS_ERR(shm))
return PTR_ERR(shm);
msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND;
@@ -384,7 +308,7 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
if (!sess)
return -EINVAL;

- shm = get_msg_arg(ctx, 0, &msg_arg);
+ shm = optee_get_msg_arg(ctx, 0, &msg_arg);
if (IS_ERR(shm))
return PTR_ERR(shm);

@@ -397,152 +321,6 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
return 0;
}

-/**
- * optee_enable_shm_cache() - Enables caching of some shared memory allocation
- * in OP-TEE
- * @optee: main service struct
- */
-void optee_enable_shm_cache(struct optee *optee)
-{
- struct optee_call_waiter w;
-
- /* We need to retry until secure world isn't busy. */
- optee_cq_wait_init(&optee->call_queue, &w);
- while (true) {
- struct arm_smccc_res res;
-
- optee->invoke_fn(OPTEE_SMC_ENABLE_SHM_CACHE, 0, 0, 0, 0, 0, 0,
- 0, &res);
- if (res.a0 == OPTEE_SMC_RETURN_OK)
- break;
- optee_cq_wait_for_completion(&optee->call_queue, &w);
- }
- optee_cq_wait_final(&optee->call_queue, &w);
-}
-
-/**
- * optee_disable_shm_cache() - Disables caching of some shared memory allocation
- * in OP-TEE
- * @optee: main service struct
- */
-void optee_disable_shm_cache(struct optee *optee)
-{
- struct optee_call_waiter w;
-
- /* We need to retry until secure world isn't busy. */
- optee_cq_wait_init(&optee->call_queue, &w);
- while (true) {
- union {
- struct arm_smccc_res smccc;
- struct optee_smc_disable_shm_cache_result result;
- } res;
-
- optee->invoke_fn(OPTEE_SMC_DISABLE_SHM_CACHE, 0, 0, 0, 0, 0, 0,
- 0, &res.smccc);
- if (res.result.status == OPTEE_SMC_RETURN_ENOTAVAIL)
- break; /* All shm's freed */
- if (res.result.status == OPTEE_SMC_RETURN_OK) {
- struct tee_shm *shm;
-
- shm = reg_pair_to_ptr(res.result.shm_upper32,
- res.result.shm_lower32);
- tee_shm_free(shm);
- } else {
- optee_cq_wait_for_completion(&optee->call_queue, &w);
- }
- }
- optee_cq_wait_final(&optee->call_queue, &w);
-}
-
-#define PAGELIST_ENTRIES_PER_PAGE \
- ((OPTEE_MSG_NONCONTIG_PAGE_SIZE / sizeof(u64)) - 1)
-
-/**
- * optee_fill_pages_list() - write list of user pages to given shared
- * buffer.
- *
- * @dst: page-aligned buffer where list of pages will be stored
- * @pages: array of pages that represents shared buffer
- * @num_pages: number of entries in @pages
- * @page_offset: offset of user buffer from page start
- *
- * @dst should be big enough to hold list of user page addresses and
- * links to the next pages of buffer
- */
-void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,
- size_t page_offset)
-{
- int n = 0;
- phys_addr_t optee_page;
- /*
- * Refer to OPTEE_MSG_ATTR_NONCONTIG description in optee_msg.h
- * for details.
- */
- struct {
- u64 pages_list[PAGELIST_ENTRIES_PER_PAGE];
- u64 next_page_data;
- } *pages_data;
-
- /*
- * Currently OP-TEE uses 4k page size and it does not looks
- * like this will change in the future. On other hand, there are
- * no know ARM architectures with page size < 4k.
- * Thus the next built assert looks redundant. But the following
- * code heavily relies on this assumption, so it is better be
- * safe than sorry.
- */
- BUILD_BUG_ON(PAGE_SIZE < OPTEE_MSG_NONCONTIG_PAGE_SIZE);
-
- pages_data = (void *)dst;
- /*
- * If linux page is bigger than 4k, and user buffer offset is
- * larger than 4k/8k/12k/etc this will skip first 4k pages,
- * because they bear no value data for OP-TEE.
- */
- optee_page = page_to_phys(*pages) +
- round_down(page_offset, OPTEE_MSG_NONCONTIG_PAGE_SIZE);
-
- while (true) {
- pages_data->pages_list[n++] = optee_page;
-
- if (n == PAGELIST_ENTRIES_PER_PAGE) {
- pages_data->next_page_data =
- virt_to_phys(pages_data + 1);
- pages_data++;
- n = 0;
- }
-
- optee_page += OPTEE_MSG_NONCONTIG_PAGE_SIZE;
- if (!(optee_page & ~PAGE_MASK)) {
- if (!--num_pages)
- break;
- pages++;
- optee_page = page_to_phys(*pages);
- }
- }
-}
-
-/*
- * The final entry in each pagelist page is a pointer to the next
- * pagelist page.
- */
-static size_t get_pages_list_size(size_t num_entries)
-{
- int pages = DIV_ROUND_UP(num_entries, PAGELIST_ENTRIES_PER_PAGE);
-
- return pages * OPTEE_MSG_NONCONTIG_PAGE_SIZE;
-}
-
-u64 *optee_allocate_pages_list(size_t num_entries)
-{
- return alloc_pages_exact(get_pages_list_size(num_entries), GFP_KERNEL);
-}
-
-void optee_free_pages_list(void *list, size_t num_entries)
-{
- free_pages_exact(list, get_pages_list_size(num_entries));
-}
-
static bool is_normal_memory(pgprot_t p)
{
#if defined(CONFIG_ARM)
@@ -566,7 +344,7 @@ static int __check_mem_type(struct vm_area_struct *vma, unsigned long end)
return -EINVAL;
}

-static int check_mem_type(unsigned long start, size_t num_pages)
+int optee_check_mem_type(unsigned long start, size_t num_pages)
{
struct mm_struct *mm = current->mm;
int rc;
@@ -585,94 +363,3 @@ static int check_mem_type(unsigned long start, size_t num_pages)

return rc;
}
-
-int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
- struct page **pages, size_t num_pages,
- unsigned long start)
-{
- struct optee *optee = tee_get_drvdata(ctx->teedev);
- struct optee_msg_arg *msg_arg;
- struct tee_shm *shm_arg;
- u64 *pages_list;
- int rc;
-
- if (!num_pages)
- return -EINVAL;
-
- rc = check_mem_type(start, num_pages);
- if (rc)
- return rc;
-
- pages_list = optee_allocate_pages_list(num_pages);
- if (!pages_list)
- return -ENOMEM;
-
- shm_arg = get_msg_arg(ctx, 1, &msg_arg);
- if (IS_ERR(shm_arg)) {
- rc = PTR_ERR(shm_arg);
- goto out;
- }
-
- optee_fill_pages_list(pages_list, pages, num_pages,
- tee_shm_get_page_offset(shm));
-
- 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.shm_ref = (unsigned long)shm;
- msg_arg->params->u.tmem.size = tee_shm_get_size(shm);
- /*
- * In the least bits of msg_arg->params->u.tmem.buf_ptr we
- * store buffer offset from 4k page, as described in OP-TEE ABI.
- */
- msg_arg->params->u.tmem.buf_ptr = virt_to_phys(pages_list) |
- (tee_shm_get_page_offset(shm) & (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
-
- if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
- msg_arg->ret != TEEC_SUCCESS)
- rc = -EINVAL;
-
- tee_shm_free(shm_arg);
-out:
- optee_free_pages_list(pages_list, num_pages);
- return rc;
-}
-
-int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
-{
- struct optee *optee = tee_get_drvdata(ctx->teedev);
- struct optee_msg_arg *msg_arg;
- struct tee_shm *shm_arg;
- int rc = 0;
-
- shm_arg = get_msg_arg(ctx, 1, &msg_arg);
- if (IS_ERR(shm_arg))
- return PTR_ERR(shm_arg);
-
- 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 = (unsigned long)shm;
-
- if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
- msg_arg->ret != TEEC_SUCCESS)
- rc = -EINVAL;
- tee_shm_free(shm_arg);
- return rc;
-}
-
-int optee_shm_register_supp(struct tee_context *ctx, struct tee_shm *shm,
- struct page **pages, size_t num_pages,
- unsigned long start)
-{
- /*
- * We don't want to register supplicant memory in OP-TEE.
- * Instead information about it will be passed in RPC code.
- */
- return check_mem_type(start, num_pages);
-}
-
-int optee_shm_unregister_supp(struct tee_context *ctx, struct tee_shm *shm)
-{
- return 0;
-}
diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c
index f689f171a794..e0dcde043df2 100644
--- a/drivers/tee/optee/core.c
+++ b/drivers/tee/optee/core.c
@@ -1,259 +1,62 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2015-2021, Linaro Limited
+ * Copyright (c) 2016, EPAM Systems
*/

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

-#include <linux/arm-smccc.h>
#include <linux/errno.h>
#include <linux/io.h>
+#include <linux/mm.h>
#include <linux/module.h>
-#include <linux/of.h>
-#include <linux/of_platform.h>
-#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/tee_drv.h>
#include <linux/types.h>
-#include <linux/uaccess.h>
#include <linux/workqueue.h>
#include "optee_private.h"
-#include "optee_smc.h"
-#include "shm_pool.h"

-#define DRIVER_NAME "optee"
-
-#define OPTEE_SHM_NUM_PRIV_PAGES CONFIG_OPTEE_SHM_NUM_PRIV_PAGES
-
-static void from_msg_param_value(struct tee_param *p, u32 attr,
- const struct optee_msg_param *mp)
-{
- p->attr = TEE_IOCTL_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;
-}
-
-static int from_msg_param_tmp_mem(struct tee_param *p, u32 attr,
- const struct optee_msg_param *mp)
+int optee_pool_op_alloc_helper(struct tee_shm_pool_mgr *poolm,
+ struct tee_shm *shm, size_t size,
+ int (*shm_register)(struct tee_context *ctx,
+ struct tee_shm *shm,
+ struct page **pages,
+ size_t num_pages,
+ unsigned long start))
{
- struct tee_shm *shm;
- phys_addr_t pa;
- int rc;
-
- p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
- attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
- p->u.memref.size = mp->u.tmem.size;
- shm = (struct tee_shm *)(unsigned long)mp->u.tmem.shm_ref;
- if (!shm) {
- p->u.memref.shm_offs = 0;
- p->u.memref.shm = NULL;
- return 0;
- }
-
- rc = tee_shm_get_pa(shm, 0, &pa);
- if (rc)
- return rc;
-
- p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
- p->u.memref.shm = shm;
-
- /* Check that the memref is covered by the shm object */
- if (p->u.memref.size) {
- size_t o = p->u.memref.shm_offs +
- p->u.memref.size - 1;
-
- rc = tee_shm_get_pa(shm, o, NULL);
- if (rc)
- return rc;
- }
+ unsigned int order = get_order(size);
+ struct page *page;
+ int rc = 0;

- return 0;
-}
-
-static void from_msg_param_reg_mem(struct tee_param *p, u32 attr,
- const struct optee_msg_param *mp)
-{
- struct tee_shm *shm;
-
- p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
- attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
- p->u.memref.size = mp->u.rmem.size;
- shm = (struct tee_shm *)(unsigned long)mp->u.rmem.shm_ref;
-
- if (shm) {
- p->u.memref.shm_offs = mp->u.rmem.offs;
- p->u.memref.shm = shm;
- } else {
- p->u.memref.shm_offs = 0;
- p->u.memref.shm = NULL;
- }
-}
+ page = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
+ if (!page)
+ return -ENOMEM;

-/**
- * optee_from_msg_param() - convert from OPTEE_MSG parameters to
- * struct tee_param
- * @optee: main service struct
- * @params: subsystem internal parameter representation
- * @num_params: number of elements in the parameter arrays
- * @msg_params: OPTEE_MSG parameters
- * Returns 0 on success or <0 on failure
- */
-static int optee_from_msg_param(struct optee *optee, struct tee_param *params,
- size_t num_params,
- const struct optee_msg_param *msg_params)
-{
- int rc;
- size_t n;
+ shm->kaddr = page_address(page);
+ shm->paddr = page_to_phys(page);
+ shm->size = PAGE_SIZE << order;

- 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;
+ if (shm_register) {
+ unsigned int nr_pages = 1 << order, i;
+ struct page **pages;

- switch (attr) {
- case OPTEE_MSG_ATTR_TYPE_NONE:
- p->attr = TEE_IOCTL_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:
- from_msg_param_value(p, attr, mp);
- break;
- case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:
- case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
- case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
- rc = from_msg_param_tmp_mem(p, attr, mp);
- if (rc)
- return rc;
- break;
- case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:
- case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:
- case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:
- from_msg_param_reg_mem(p, attr, mp);
- break;
+ pages = kcalloc(nr_pages, sizeof(pages), GFP_KERNEL);
+ if (!pages)
+ return -ENOMEM;

- default:
- return -EINVAL;
+ for (i = 0; i < nr_pages; i++) {
+ pages[i] = page;
+ page++;
}
- }
- return 0;
-}
-
-static void to_msg_param_value(struct optee_msg_param *mp,
- const struct tee_param *p)
-{
- mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
- TEE_IOCTL_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;
-}

-static int to_msg_param_tmp_mem(struct optee_msg_param *mp,
- const struct tee_param *p)
-{
- int rc;
- phys_addr_t pa;
-
- mp->attr = OPTEE_MSG_ATTR_TYPE_TMEM_INPUT + p->attr -
- TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
-
- mp->u.tmem.shm_ref = (unsigned long)p->u.memref.shm;
- mp->u.tmem.size = p->u.memref.size;
-
- if (!p->u.memref.shm) {
- mp->u.tmem.buf_ptr = 0;
- return 0;
+ shm->flags |= TEE_SHM_REGISTER;
+ rc = shm_register(shm->ctx, shm, pages, nr_pages,
+ (unsigned long)shm->kaddr);
+ kfree(pages);
}

- rc = tee_shm_get_pa(p->u.memref.shm, p->u.memref.shm_offs, &pa);
- if (rc)
- return rc;
-
- mp->u.tmem.buf_ptr = pa;
- mp->attr |= OPTEE_MSG_ATTR_CACHE_PREDEFINED <<
- OPTEE_MSG_ATTR_CACHE_SHIFT;
-
- return 0;
-}
-
-static int to_msg_param_reg_mem(struct optee_msg_param *mp,
- const struct tee_param *p)
-{
- mp->attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT + p->attr -
- TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
-
- mp->u.rmem.shm_ref = (unsigned long)p->u.memref.shm;
- mp->u.rmem.size = p->u.memref.size;
- mp->u.rmem.offs = p->u.memref.shm_offs;
- return 0;
-}
-
-/**
- * optee_to_msg_param() - convert from struct tee_params to OPTEE_MSG parameters
- * @optee: main service struct
- * @msg_params: OPTEE_MSG parameters
- * @num_params: number of elements in the parameter arrays
- * @params: subsystem itnernal parameter representation
- * Returns 0 on success or <0 on failure
- */
-static int optee_to_msg_param(struct optee *optee,
- struct optee_msg_param *msg_params,
- size_t num_params, const struct tee_param *params)
-{
- int rc;
- size_t 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_IOCTL_PARAM_ATTR_TYPE_NONE:
- mp->attr = TEE_IOCTL_PARAM_ATTR_TYPE_NONE;
- memset(&mp->u, 0, sizeof(mp->u));
- break;
- case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT:
- case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
- case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
- to_msg_param_value(mp, p);
- break;
- case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT:
- case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
- case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:
- if (tee_shm_is_registered(p->u.memref.shm))
- rc = to_msg_param_reg_mem(mp, p);
- else
- rc = to_msg_param_tmp_mem(mp, p);
- if (rc)
- return rc;
- break;
- default:
- return -EINVAL;
- }
- }
- return 0;
-}
-
-static void optee_get_version(struct tee_device *teedev,
- struct tee_ioctl_version_data *vers)
-{
- struct tee_ioctl_version_data v = {
- .impl_id = TEE_IMPL_ID_OPTEE,
- .impl_caps = TEE_OPTEE_CAP_TZ,
- .gen_caps = TEE_GEN_CAP_GP,
- };
- struct optee *optee = tee_get_drvdata(teedev);
-
- if (optee->sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
- v.gen_caps |= TEE_GEN_CAP_REG_MEM;
- if (optee->sec_caps & OPTEE_SMC_SEC_CAP_MEMREF_NULL)
- v.gen_caps |= TEE_GEN_CAP_MEMREF_NULL;
- *vers = v;
+ return rc;
}

static void optee_bus_scan(struct work_struct *work)
@@ -261,7 +64,7 @@ static void optee_bus_scan(struct work_struct *work)
WARN_ON(optee_enumerate_devices(PTA_CMD_GET_DEVICES_SUPP));
}

-static int optee_open(struct tee_context *ctx)
+int optee_open(struct tee_context *ctx, bool cap_memref_null)
{
struct optee_context_data *ctxdata;
struct tee_device *teedev = ctx->teedev;
@@ -299,11 +102,7 @@ static int optee_open(struct tee_context *ctx)
mutex_init(&ctxdata->mutex);
INIT_LIST_HEAD(&ctxdata->sess_list);

- if (optee->sec_caps & OPTEE_SMC_SEC_CAP_MEMREF_NULL)
- ctx->cap_memref_null = true;
- else
- ctx->cap_memref_null = false;
-
+ ctx->cap_memref_null = cap_memref_null;
ctx->data = ctxdata;
return 0;
}
@@ -329,12 +128,12 @@ static void optee_release_helper(struct tee_context *ctx,
ctx->data = NULL;
}

-static void optee_release(struct tee_context *ctx)
+void optee_release(struct tee_context *ctx)
{
optee_release_helper(ctx, optee_close_session_helper);
}

-static void optee_release_supp(struct tee_context *ctx)
+void optee_release_supp(struct tee_context *ctx)
{
struct optee *optee = tee_get_drvdata(ctx->teedev);

@@ -346,277 +145,8 @@ static void optee_release_supp(struct tee_context *ctx)
optee_supp_release(&optee->supp);
}

-static const struct tee_driver_ops optee_clnt_ops = {
- .get_version = optee_get_version,
- .open = optee_open,
- .release = optee_release,
- .open_session = optee_open_session,
- .close_session = optee_close_session,
- .invoke_func = optee_invoke_func,
- .cancel_req = optee_cancel_req,
- .shm_register = optee_shm_register,
- .shm_unregister = optee_shm_unregister,
-};
-
-static const struct tee_desc optee_clnt_desc = {
- .name = DRIVER_NAME "-clnt",
- .ops = &optee_clnt_ops,
- .owner = THIS_MODULE,
-};
-
-static const struct tee_driver_ops optee_supp_ops = {
- .get_version = optee_get_version,
- .open = optee_open,
- .release = optee_release_supp,
- .supp_recv = optee_supp_recv,
- .supp_send = optee_supp_send,
- .shm_register = optee_shm_register_supp,
- .shm_unregister = optee_shm_unregister_supp,
-};
-
-static const struct tee_desc optee_supp_desc = {
- .name = DRIVER_NAME "-supp",
- .ops = &optee_supp_ops,
- .owner = THIS_MODULE,
- .flags = TEE_DESC_PRIVILEGED,
-};
-
-static const struct optee_ops optee_ops = {
- .do_call_with_arg = optee_do_call_with_arg,
- .to_msg_param = optee_to_msg_param,
- .from_msg_param = optee_from_msg_param,
-};
-
-static bool optee_msg_api_uid_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);
-
- if (res.a0 == OPTEE_MSG_UID_0 && res.a1 == OPTEE_MSG_UID_1 &&
- res.a2 == OPTEE_MSG_UID_2 && res.a3 == OPTEE_MSG_UID_3)
- return true;
- return false;
-}
-
-static void optee_msg_get_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)
- pr_info("revision %lu.%lu (%08lx)", res.result.major,
- res.result.minor, res.result.build_id);
- else
- pr_info("revision %lu.%lu", res.result.major, res.result.minor);
-}
-
-static bool optee_msg_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);
-
- if (res.result.major == OPTEE_MSG_REVISION_MAJOR &&
- (int)res.result.minor >= OPTEE_MSG_REVISION_MINOR)
- return true;
- return false;
-}
-
-static bool optee_msg_exchange_capabilities(optee_invoke_fn *invoke_fn,
- u32 *sec_caps)
-{
- union {
- struct arm_smccc_res smccc;
- struct optee_smc_exchange_capabilities_result result;
- } res;
- u32 a1 = 0;
-
- /*
- * TODO This isn't enough to tell if it's UP system (from kernel
- * point of view) or not, is_smp() returns the the information
- * needed, but can't be called directly from here.
- */
- if (!IS_ENABLED(CONFIG_SMP) || nr_cpu_ids == 1)
- a1 |= OPTEE_SMC_NSEC_CAP_UNIPROCESSOR;
-
- invoke_fn(OPTEE_SMC_EXCHANGE_CAPABILITIES, a1, 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;
-}
-
-static struct tee_shm_pool *optee_config_dyn_shm(void)
-{
- struct tee_shm_pool_mgr *priv_mgr;
- struct tee_shm_pool_mgr *dmabuf_mgr;
- void *rc;
-
- rc = optee_shm_pool_alloc_pages();
- if (IS_ERR(rc))
- return rc;
- priv_mgr = rc;
-
- rc = optee_shm_pool_alloc_pages();
- if (IS_ERR(rc)) {
- tee_shm_pool_mgr_destroy(priv_mgr);
- return rc;
- }
- dmabuf_mgr = rc;
-
- rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
- if (IS_ERR(rc)) {
- tee_shm_pool_mgr_destroy(priv_mgr);
- tee_shm_pool_mgr_destroy(dmabuf_mgr);
- }
-
- return rc;
-}
-
-static struct tee_shm_pool *
-optee_config_shm_memremap(optee_invoke_fn *invoke_fn, void **memremaped_shm)
+void optee_remove_common(struct optee *optee)
{
- union {
- struct arm_smccc_res smccc;
- struct optee_smc_get_shm_config_result result;
- } res;
- unsigned long vaddr;
- phys_addr_t paddr;
- size_t size;
- phys_addr_t begin;
- phys_addr_t end;
- void *va;
- struct tee_shm_pool_mgr *priv_mgr;
- struct tee_shm_pool_mgr *dmabuf_mgr;
- void *rc;
- const int sz = OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE;
-
- invoke_fn(OPTEE_SMC_GET_SHM_CONFIG, 0, 0, 0, 0, 0, 0, 0, &res.smccc);
- if (res.result.status != OPTEE_SMC_RETURN_OK) {
- pr_err("static shm service not available\n");
- return ERR_PTR(-ENOENT);
- }
-
- if (res.result.settings != OPTEE_SMC_SHM_CACHED) {
- pr_err("only normal cached shared memory supported\n");
- return ERR_PTR(-EINVAL);
- }
-
- begin = roundup(res.result.start, PAGE_SIZE);
- end = rounddown(res.result.start + res.result.size, PAGE_SIZE);
- paddr = begin;
- size = end - begin;
-
- if (size < 2 * OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE) {
- pr_err("too small shared memory area\n");
- return ERR_PTR(-EINVAL);
- }
-
- va = memremap(paddr, size, MEMREMAP_WB);
- if (!va) {
- pr_err("shared memory ioremap failed\n");
- return ERR_PTR(-EINVAL);
- }
- vaddr = (unsigned long)va;
-
- rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, sz,
- 3 /* 8 bytes aligned */);
- if (IS_ERR(rc))
- goto err_memunmap;
- priv_mgr = rc;
-
- vaddr += sz;
- paddr += sz;
- size -= sz;
-
- rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, size, PAGE_SHIFT);
- if (IS_ERR(rc))
- goto err_free_priv_mgr;
- dmabuf_mgr = rc;
-
- rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
- if (IS_ERR(rc))
- goto err_free_dmabuf_mgr;
-
- *memremaped_shm = va;
-
- return rc;
-
-err_free_dmabuf_mgr:
- tee_shm_pool_mgr_destroy(dmabuf_mgr);
-err_free_priv_mgr:
- tee_shm_pool_mgr_destroy(priv_mgr);
-err_memunmap:
- memunmap(va);
- return rc;
-}
-
-/* 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 device *dev)
-{
- const char *method;
-
- pr_info("probing for conduit method.\n");
-
- if (device_property_read_string(dev, "method", &method)) {
- pr_warn("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;
-
- pr_warn("invalid \"method\" property: %s\n", method);
- return ERR_PTR(-EINVAL);
-}
-
-static int optee_remove(struct platform_device *pdev)
-{
- struct optee *optee = platform_get_drvdata(pdev);
-
- /*
- * Ask OP-TEE to free all cached shared memory objects to decrease
- * reference counters and also avoid wild pointers in secure world
- * into the old shared memory range.
- */
- optee_disable_shm_cache(optee);
-
/*
* The two devices have to be unregistered before we can free the
* other resources.
@@ -625,151 +155,11 @@ static int optee_remove(struct platform_device *pdev)
tee_device_unregister(optee->teedev);

tee_shm_pool_free(optee->pool);
- if (optee->memremaped_shm)
- memunmap(optee->memremaped_shm);
optee_wait_queue_exit(&optee->wait_queue);
optee_supp_uninit(&optee->supp);
mutex_destroy(&optee->call_queue.mutex);
-
- kfree(optee);
-
- return 0;
-}
-
-static int optee_probe(struct platform_device *pdev)
-{
- optee_invoke_fn *invoke_fn;
- struct tee_shm_pool *pool = ERR_PTR(-EINVAL);
- struct optee *optee = NULL;
- void *memremaped_shm = NULL;
- struct tee_device *teedev;
- u32 sec_caps;
- int rc;
-
- invoke_fn = get_invoke_func(&pdev->dev);
- if (IS_ERR(invoke_fn))
- return PTR_ERR(invoke_fn);
-
- if (!optee_msg_api_uid_is_optee_api(invoke_fn)) {
- pr_warn("api uid mismatch\n");
- return -EINVAL;
- }
-
- optee_msg_get_os_revision(invoke_fn);
-
- if (!optee_msg_api_revision_is_compatible(invoke_fn)) {
- pr_warn("api revision mismatch\n");
- return -EINVAL;
- }
-
- if (!optee_msg_exchange_capabilities(invoke_fn, &sec_caps)) {
- pr_warn("capabilities mismatch\n");
- return -EINVAL;
- }
-
- /*
- * Try to use dynamic shared memory if possible
- */
- if (sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
- pool = optee_config_dyn_shm();
-
- /*
- * If dynamic shared memory is not available or failed - try static one
- */
- if (IS_ERR(pool) && (sec_caps & OPTEE_SMC_SEC_CAP_HAVE_RESERVED_SHM))
- pool = optee_config_shm_memremap(invoke_fn, &memremaped_shm);
-
- if (IS_ERR(pool))
- return PTR_ERR(pool);
-
- optee = kzalloc(sizeof(*optee), GFP_KERNEL);
- if (!optee) {
- rc = -ENOMEM;
- goto err;
- }
-
- optee->ops = &optee_ops;
- optee->invoke_fn = invoke_fn;
- optee->sec_caps = sec_caps;
-
- teedev = tee_device_alloc(&optee_clnt_desc, NULL, pool, optee);
- if (IS_ERR(teedev)) {
- rc = PTR_ERR(teedev);
- goto err;
- }
- optee->teedev = teedev;
-
- teedev = tee_device_alloc(&optee_supp_desc, NULL, pool, optee);
- if (IS_ERR(teedev)) {
- rc = PTR_ERR(teedev);
- goto err;
- }
- optee->supp_teedev = teedev;
-
- rc = tee_device_register(optee->teedev);
- if (rc)
- goto err;
-
- rc = tee_device_register(optee->supp_teedev);
- if (rc)
- goto err;
-
- mutex_init(&optee->call_queue.mutex);
- INIT_LIST_HEAD(&optee->call_queue.waiters);
- optee_wait_queue_init(&optee->wait_queue);
- optee_supp_init(&optee->supp);
- optee->memremaped_shm = memremaped_shm;
- optee->pool = pool;
-
- optee_enable_shm_cache(optee);
-
- if (optee->sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
- pr_info("dynamic shared memory is enabled\n");
-
- platform_set_drvdata(pdev, optee);
-
- rc = optee_enumerate_devices(PTA_CMD_GET_DEVICES);
- if (rc) {
- optee_remove(pdev);
- return rc;
- }
-
- pr_info("initialized driver\n");
- return 0;
-err:
- if (optee) {
- /*
- * tee_device_unregister() is safe to call even if the
- * devices hasn't been registered with
- * tee_device_register() yet.
- */
- tee_device_unregister(optee->supp_teedev);
- tee_device_unregister(optee->teedev);
- kfree(optee);
- }
- if (pool)
- tee_shm_pool_free(pool);
- if (memremaped_shm)
- memunmap(memremaped_shm);
- return rc;
}

-static const struct of_device_id optee_dt_match[] = {
- { .compatible = "linaro,optee-tz" },
- {},
-};
-MODULE_DEVICE_TABLE(of, optee_dt_match);
-
-static struct platform_driver optee_driver = {
- .probe = optee_probe,
- .remove = optee_remove,
- .driver = {
- .name = "optee",
- .of_match_table = optee_dt_match,
- },
-};
-module_platform_driver(optee_driver);
-
MODULE_AUTHOR("Linaro");
MODULE_DESCRIPTION("OP-TEE driver");
MODULE_VERSION("1.0");
diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h
index c5741e96e967..68d1331068e9 100644
--- a/drivers/tee/optee/optee_private.h
+++ b/drivers/tee/optee/optee_private.h
@@ -12,6 +12,8 @@
#include <linux/types.h>
#include "optee_msg.h"

+#define DRIVER_NAME "optee"
+
#define OPTEE_MAX_ARG_SIZE 1024

/* Some Global Platform error codes used in this driver */
@@ -29,6 +31,11 @@ typedef void (optee_invoke_fn)(unsigned long, unsigned long, unsigned long,
unsigned long, unsigned long,
struct arm_smccc_res *);

+struct optee_call_waiter {
+ struct list_head list_node;
+ struct completion c;
+};
+
struct optee_call_queue {
/* Serializes access to this struct */
struct mutex mutex;
@@ -66,6 +73,19 @@ struct optee_supp {
struct completion reqs_c;
};

+/**
+ * struct optee_smc - SMC ABI specifics
+ * @invoke_fn: function to issue smc or hvc
+ * @memremaped_shm virtual address of memory in shared memory pool
+ * @sec_caps: secure world capabilities defined by
+ * OPTEE_SMC_SEC_CAP_* in optee_smc.h
+ */
+struct optee_smc {
+ optee_invoke_fn *invoke_fn;
+ void *memremaped_shm;
+ u32 sec_caps;
+};
+
struct optee;

/**
@@ -95,15 +115,12 @@ struct optee_ops {
* @ops: internal callbacks for different ways to reach secure
* world
* @teedev: client device
- * @invoke_fn: function to issue smc or hvc
+ * @smc: specific to SMC ABI
* @call_queue: queue of threads waiting to call @invoke_fn
* @wait_queue: queue of threads from secure world waiting for a
* secure world sync object
* @supp: supplicant synchronization struct for RPC to supplicant
* @pool: shared memory pool
- * @memremaped_shm virtual address of memory in shared memory pool
- * @sec_caps: secure world capabilities defined by
- * OPTEE_SMC_SEC_CAP_* in optee_smc.h
* @scan_bus_done flag if device registation was already done.
* @scan_bus_wq workqueue to scan optee bus and register optee drivers
* @scan_bus_work workq to scan optee bus and register optee drivers
@@ -112,13 +129,11 @@ struct optee {
struct tee_device *supp_teedev;
struct tee_device *teedev;
const struct optee_ops *ops;
- optee_invoke_fn *invoke_fn;
+ struct optee_smc smc;
struct optee_call_queue call_queue;
struct optee_wait_queue wait_queue;
struct optee_supp supp;
struct tee_shm_pool *pool;
- void *memremaped_shm;
- u32 sec_caps;
bool scan_bus_done;
struct workqueue_struct *scan_bus_wq;
struct work_struct scan_bus_work;
@@ -153,10 +168,6 @@ struct optee_call_ctx {
size_t num_entries;
};

-void optee_handle_rpc(struct tee_context *ctx, struct optee_rpc_param *param,
- struct optee_call_ctx *call_ctx);
-void optee_rpc_finalize_call(struct optee_call_ctx *call_ctx);
-
void optee_wait_queue_init(struct optee_wait_queue *wq);
void optee_wait_queue_exit(struct optee_wait_queue *wq);

@@ -174,7 +185,6 @@ int optee_supp_recv(struct tee_context *ctx, u32 *func, u32 *num_params,
int optee_supp_send(struct tee_context *ctx, u32 ret, u32 num_params,
struct tee_param *param);

-int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg);
int optee_open_session(struct tee_context *ctx,
struct tee_ioctl_open_session_arg *arg,
struct tee_param *param);
@@ -184,27 +194,63 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
struct tee_param *param);
int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session);

-void optee_enable_shm_cache(struct optee *optee);
-void optee_disable_shm_cache(struct optee *optee);
+#define PTA_CMD_GET_DEVICES 0x0
+#define PTA_CMD_GET_DEVICES_SUPP 0x1
+int optee_enumerate_devices(u32 func);

-int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
- struct page **pages, size_t num_pages,
- unsigned long start);
-int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm);
+int optee_pool_op_alloc_helper(struct tee_shm_pool_mgr *poolm,
+ struct tee_shm *shm, size_t size,
+ int (*shm_register)(struct tee_context *ctx,
+ struct tee_shm *shm,
+ struct page **pages,
+ size_t num_pages,
+ unsigned long start));

-int optee_shm_register_supp(struct tee_context *ctx, struct tee_shm *shm,
- struct page **pages, size_t num_pages,
- unsigned long start);
-int optee_shm_unregister_supp(struct tee_context *ctx, struct tee_shm *shm);

-u64 *optee_allocate_pages_list(size_t num_entries);
-void optee_free_pages_list(void *array, size_t num_entries);
-void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,
- size_t page_offset);
+void optee_remove_common(struct optee *optee);
+int optee_open(struct tee_context *ctx, bool cap_memref_null);
+void optee_release(struct tee_context *ctx);
+void optee_release_supp(struct tee_context *ctx);

-#define PTA_CMD_GET_DEVICES 0x0
-#define PTA_CMD_GET_DEVICES_SUPP 0x1
-int optee_enumerate_devices(u32 func);
+static inline void optee_from_msg_param_value(struct tee_param *p, u32 attr,
+ const struct optee_msg_param *mp)
+{
+ p->attr = TEE_IOCTL_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;
+}
+
+static inline void optee_to_msg_param_value(struct optee_msg_param *mp,
+ const struct tee_param *p)
+{
+ mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
+ TEE_IOCTL_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;
+}
+
+void optee_cq_wait_init(struct optee_call_queue *cq,
+ struct optee_call_waiter *w);
+void optee_cq_wait_for_completion(struct optee_call_queue *cq,
+ struct optee_call_waiter *w);
+void optee_cq_wait_final(struct optee_call_queue *cq,
+ struct optee_call_waiter *w);
+int optee_check_mem_type(unsigned long start, size_t num_pages);
+struct tee_shm *optee_get_msg_arg(struct tee_context *ctx, size_t num_params,
+ struct optee_msg_arg **msg_arg);
+
+struct tee_shm *optee_rpc_cmd_alloc_suppl(struct tee_context *ctx, size_t sz);
+void optee_rpc_cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm);
+void optee_rpc_func_cmd_get_time(struct optee_msg_arg *arg);
+void optee_rpc_func_cmd_wq(struct optee *optee, struct optee_msg_arg *arg);
+void optee_rpc_func_cmd_wait(struct optee_msg_arg *arg);
+void optee_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
+ struct optee_msg_arg *arg);
+void optee_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
+ struct optee_msg_arg *arg);

/*
* Small helpers
diff --git a/drivers/tee/optee/rpc.c b/drivers/tee/optee/rpc.c
index 39562fb6841e..e99e353b3f29 100644
--- a/drivers/tee/optee/rpc.c
+++ b/drivers/tee/optee/rpc.c
@@ -6,12 +6,10 @@
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/delay.h>
-#include <linux/device.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/tee_drv.h>
#include "optee_private.h"
-#include "optee_smc.h"
#include "optee_rpc_cmd.h"

struct wq_entry {
@@ -31,7 +29,7 @@ void optee_wait_queue_exit(struct optee_wait_queue *priv)
mutex_destroy(&priv->mu);
}

-static void handle_rpc_func_cmd_get_time(struct optee_msg_arg *arg)
+void optee_rpc_func_cmd_get_time(struct optee_msg_arg *arg)
{
struct timespec64 ts;

@@ -52,8 +50,8 @@ static void handle_rpc_func_cmd_get_time(struct optee_msg_arg *arg)
}

#if IS_REACHABLE(CONFIG_I2C)
-static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
- struct optee_msg_arg *arg)
+void optee_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
+ struct optee_msg_arg *arg)
{
struct optee *optee = tee_get_drvdata(ctx->teedev);
struct tee_param *params;
@@ -139,8 +137,8 @@ static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
arg->ret = TEEC_ERROR_BAD_PARAMETERS;
}
#else
-static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
- struct optee_msg_arg *arg)
+void optee_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
+ struct optee_msg_arg *arg)
{
arg->ret = TEEC_ERROR_NOT_SUPPORTED;
}
@@ -188,8 +186,7 @@ static void wq_wakeup(struct optee_wait_queue *wq, u32 key)
complete(&w->c);
}

-static void handle_rpc_func_cmd_wq(struct optee *optee,
- struct optee_msg_arg *arg)
+void optee_rpc_func_cmd_wq(struct optee *optee, struct optee_msg_arg *arg)
{
if (arg->num_params != 1)
goto bad;
@@ -215,7 +212,7 @@ static void handle_rpc_func_cmd_wq(struct optee *optee,
arg->ret = TEEC_ERROR_BAD_PARAMETERS;
}

-static void handle_rpc_func_cmd_wait(struct optee_msg_arg *arg)
+void optee_rpc_func_cmd_wait(struct optee_msg_arg *arg)
{
u32 msec_to_wait;

@@ -237,8 +234,8 @@ static void handle_rpc_func_cmd_wait(struct optee_msg_arg *arg)
arg->ret = TEEC_ERROR_BAD_PARAMETERS;
}

-static void handle_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
- struct optee_msg_arg *arg)
+void optee_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
+ struct optee_msg_arg *arg)
{
struct tee_param *params;

@@ -266,7 +263,7 @@ static void handle_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
kfree(params);
}

-static struct tee_shm *cmd_alloc_suppl(struct tee_context *ctx, size_t sz)
+struct tee_shm *optee_rpc_cmd_alloc_suppl(struct tee_context *ctx, size_t sz)
{
u32 ret;
struct tee_param param;
@@ -289,103 +286,7 @@ static struct tee_shm *cmd_alloc_suppl(struct tee_context *ctx, size_t sz)
return shm;
}

-static void handle_rpc_func_cmd_shm_alloc(struct tee_context *ctx,
- struct optee_msg_arg *arg,
- struct optee_call_ctx *call_ctx)
-{
- phys_addr_t pa;
- struct tee_shm *shm;
- size_t sz;
- size_t n;
-
- arg->ret_origin = TEEC_ORIGIN_COMMS;
-
- if (!arg->num_params ||
- arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) {
- arg->ret = TEEC_ERROR_BAD_PARAMETERS;
- return;
- }
-
- for (n = 1; n < arg->num_params; n++) {
- if (arg->params[n].attr != OPTEE_MSG_ATTR_TYPE_NONE) {
- arg->ret = TEEC_ERROR_BAD_PARAMETERS;
- return;
- }
- }
-
- sz = arg->params[0].u.value.b;
- switch (arg->params[0].u.value.a) {
- case OPTEE_RPC_SHM_TYPE_APPL:
- shm = cmd_alloc_suppl(ctx, sz);
- break;
- case OPTEE_RPC_SHM_TYPE_KERNEL:
- shm = tee_shm_alloc(ctx, sz, TEE_SHM_MAPPED);
- break;
- default:
- arg->ret = TEEC_ERROR_BAD_PARAMETERS;
- return;
- }
-
- if (IS_ERR(shm)) {
- arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
- return;
- }
-
- if (tee_shm_get_pa(shm, 0, &pa)) {
- arg->ret = TEEC_ERROR_BAD_PARAMETERS;
- goto bad;
- }
-
- sz = tee_shm_get_size(shm);
-
- if (tee_shm_is_registered(shm)) {
- struct page **pages;
- u64 *pages_list;
- size_t page_num;
-
- pages = tee_shm_get_pages(shm, &page_num);
- if (!pages || !page_num) {
- arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
- goto bad;
- }
-
- pages_list = optee_allocate_pages_list(page_num);
- if (!pages_list) {
- arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
- goto bad;
- }
-
- call_ctx->pages_list = pages_list;
- call_ctx->num_entries = page_num;
-
- arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT |
- OPTEE_MSG_ATTR_NONCONTIG;
- /*
- * In the least bits of u.tmem.buf_ptr we store buffer offset
- * from 4k page, as described in OP-TEE ABI.
- */
- arg->params[0].u.tmem.buf_ptr = virt_to_phys(pages_list) |
- (tee_shm_get_page_offset(shm) &
- (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
- arg->params[0].u.tmem.size = tee_shm_get_size(shm);
- arg->params[0].u.tmem.shm_ref = (unsigned long)shm;
-
- optee_fill_pages_list(pages_list, pages, page_num,
- tee_shm_get_page_offset(shm));
- } else {
- arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT;
- arg->params[0].u.tmem.buf_ptr = pa;
- arg->params[0].u.tmem.size = sz;
- arg->params[0].u.tmem.shm_ref = (unsigned long)shm;
- }
-
- arg->ret = TEEC_SUCCESS;
- return;
-bad:
- tee_shm_free(shm);
-}
-
-static void cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm)
+void optee_rpc_cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm)
{
struct tee_param param;

@@ -409,137 +310,3 @@ static void cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm)

optee_supp_thrd_req(ctx, OPTEE_RPC_CMD_SHM_FREE, 1, &param);
}
-
-static void handle_rpc_func_cmd_shm_free(struct tee_context *ctx,
- struct optee_msg_arg *arg)
-{
- struct tee_shm *shm;
-
- arg->ret_origin = TEEC_ORIGIN_COMMS;
-
- if (arg->num_params != 1 ||
- arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) {
- arg->ret = TEEC_ERROR_BAD_PARAMETERS;
- return;
- }
-
- shm = (struct tee_shm *)(unsigned long)arg->params[0].u.value.b;
- switch (arg->params[0].u.value.a) {
- case OPTEE_RPC_SHM_TYPE_APPL:
- cmd_free_suppl(ctx, shm);
- break;
- case OPTEE_RPC_SHM_TYPE_KERNEL:
- tee_shm_free(shm);
- break;
- default:
- arg->ret = TEEC_ERROR_BAD_PARAMETERS;
- }
- arg->ret = TEEC_SUCCESS;
-}
-
-static void free_pages_list(struct optee_call_ctx *call_ctx)
-{
- if (call_ctx->pages_list) {
- optee_free_pages_list(call_ctx->pages_list,
- call_ctx->num_entries);
- call_ctx->pages_list = NULL;
- call_ctx->num_entries = 0;
- }
-}
-
-void optee_rpc_finalize_call(struct optee_call_ctx *call_ctx)
-{
- free_pages_list(call_ctx);
-}
-
-static void handle_rpc_func_cmd(struct tee_context *ctx, struct optee *optee,
- struct tee_shm *shm,
- struct optee_call_ctx *call_ctx)
-{
- struct optee_msg_arg *arg;
-
- arg = tee_shm_get_va(shm, 0);
- if (IS_ERR(arg)) {
- pr_err("%s: tee_shm_get_va %p failed\n", __func__, shm);
- return;
- }
-
- switch (arg->cmd) {
- case OPTEE_RPC_CMD_GET_TIME:
- handle_rpc_func_cmd_get_time(arg);
- break;
- case OPTEE_RPC_CMD_WAIT_QUEUE:
- handle_rpc_func_cmd_wq(optee, arg);
- break;
- case OPTEE_RPC_CMD_SUSPEND:
- handle_rpc_func_cmd_wait(arg);
- break;
- case OPTEE_RPC_CMD_SHM_ALLOC:
- free_pages_list(call_ctx);
- handle_rpc_func_cmd_shm_alloc(ctx, arg, call_ctx);
- break;
- case OPTEE_RPC_CMD_SHM_FREE:
- handle_rpc_func_cmd_shm_free(ctx, arg);
- break;
- case OPTEE_RPC_CMD_I2C_TRANSFER:
- handle_rpc_func_cmd_i2c_transfer(ctx, arg);
- break;
- default:
- handle_rpc_supp_cmd(ctx, optee, arg);
- }
-}
-
-/**
- * optee_handle_rpc() - handle RPC from secure world
- * @ctx: context doing the RPC
- * @param: value of registers for the RPC
- * @call_ctx: call context. Preserved during one OP-TEE invocation
- *
- * Result of RPC is written back into @param.
- */
-void optee_handle_rpc(struct tee_context *ctx, struct optee_rpc_param *param,
- struct optee_call_ctx *call_ctx)
-{
- struct tee_device *teedev = ctx->teedev;
- struct optee *optee = tee_get_drvdata(teedev);
- struct tee_shm *shm;
- phys_addr_t pa;
-
- switch (OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0)) {
- case OPTEE_SMC_RPC_FUNC_ALLOC:
- shm = tee_shm_alloc(ctx, param->a1, TEE_SHM_MAPPED);
- if (!IS_ERR(shm) && !tee_shm_get_pa(shm, 0, &pa)) {
- reg_pair_from_64(&param->a1, &param->a2, pa);
- reg_pair_from_64(&param->a4, &param->a5,
- (unsigned long)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:
- /*
- * A foreign interrupt was raised while secure world was
- * executing, since they are handled in Linux a dummy RPC is
- * performed to let Linux take the interrupt through the normal
- * vector.
- */
- break;
- case OPTEE_SMC_RPC_FUNC_CMD:
- shm = reg_pair_to_ptr(param->a1, param->a2);
- handle_rpc_func_cmd(ctx, optee, shm, call_ctx);
- break;
- default:
- pr_warn("Unknown RPC func 0x%x\n",
- (u32)OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0));
- break;
- }
-
- param->a0 = OPTEE_SMC_CALL_RETURN_FROM_RPC;
-}
diff --git a/drivers/tee/optee/shm_pool.c b/drivers/tee/optee/shm_pool.c
deleted file mode 100644
index d767eebf30bd..000000000000
--- a/drivers/tee/optee/shm_pool.c
+++ /dev/null
@@ -1,89 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * Copyright (c) 2015, Linaro Limited
- * Copyright (c) 2017, EPAM Systems
- */
-#include <linux/device.h>
-#include <linux/dma-buf.h>
-#include <linux/genalloc.h>
-#include <linux/slab.h>
-#include <linux/tee_drv.h>
-#include "optee_private.h"
-#include "optee_smc.h"
-#include "shm_pool.h"
-
-static int pool_op_alloc(struct tee_shm_pool_mgr *poolm,
- struct tee_shm *shm, size_t size)
-{
- unsigned int order = get_order(size);
- struct page *page;
- int rc = 0;
-
- page = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
- if (!page)
- return -ENOMEM;
-
- shm->kaddr = page_address(page);
- shm->paddr = page_to_phys(page);
- shm->size = PAGE_SIZE << order;
-
- if (shm->flags & TEE_SHM_DMA_BUF) {
- unsigned int nr_pages = 1 << order, i;
- struct page **pages;
-
- pages = kcalloc(nr_pages, sizeof(pages), GFP_KERNEL);
- if (!pages)
- return -ENOMEM;
-
- for (i = 0; i < nr_pages; i++) {
- pages[i] = page;
- page++;
- }
-
- shm->flags |= TEE_SHM_REGISTER;
- rc = optee_shm_register(shm->ctx, shm, pages, nr_pages,
- (unsigned long)shm->kaddr);
- kfree(pages);
- }
-
- return rc;
-}
-
-static void pool_op_free(struct tee_shm_pool_mgr *poolm,
- struct tee_shm *shm)
-{
- if (shm->flags & TEE_SHM_DMA_BUF)
- optee_shm_unregister(shm->ctx, shm);
-
- free_pages((unsigned long)shm->kaddr, get_order(shm->size));
- shm->kaddr = NULL;
-}
-
-static void pool_op_destroy_poolmgr(struct tee_shm_pool_mgr *poolm)
-{
- kfree(poolm);
-}
-
-static const struct tee_shm_pool_mgr_ops pool_ops = {
- .alloc = pool_op_alloc,
- .free = pool_op_free,
- .destroy_poolmgr = pool_op_destroy_poolmgr,
-};
-
-/**
- * optee_shm_pool_alloc_pages() - create page-based allocator pool
- *
- * This pool is used when OP-TEE supports dymanic SHM. In this case
- * command buffers and such are allocated from kernel's own memory.
- */
-struct tee_shm_pool_mgr *optee_shm_pool_alloc_pages(void)
-{
- struct tee_shm_pool_mgr *mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
-
- if (!mgr)
- return ERR_PTR(-ENOMEM);
-
- mgr->ops = &pool_ops;
-
- return mgr;
-}
diff --git a/drivers/tee/optee/shm_pool.h b/drivers/tee/optee/shm_pool.h
deleted file mode 100644
index 28109d991c4b..000000000000
--- a/drivers/tee/optee/shm_pool.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-only */
-/*
- * Copyright (c) 2015, Linaro Limited
- * Copyright (c) 2016, EPAM Systems
- */
-
-#ifndef SHM_POOL_H
-#define SHM_POOL_H
-
-#include <linux/tee_drv.h>
-
-struct tee_shm_pool_mgr *optee_shm_pool_alloc_pages(void);
-
-#endif
diff --git a/drivers/tee/optee/smc_abi.c b/drivers/tee/optee/smc_abi.c
new file mode 100644
index 000000000000..f87c62e33694
--- /dev/null
+++ b/drivers/tee/optee/smc_abi.c
@@ -0,0 +1,1301 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2015-2021, Linaro Limited
+ * Copyright (c) 2016, EPAM Systems
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/arm-smccc.h>
+#include <linux/errno.h>
+#include <linux/io.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/tee_drv.h>
+#include <linux/types.h>
+#include <linux/workqueue.h>
+#include "optee_private.h"
+#include "optee_smc.h"
+#include "optee_rpc_cmd.h"
+#define CREATE_TRACE_POINTS
+#include "optee_trace.h"
+
+/*
+ * This file implement the SMC ABI used when communicating with secure world
+ * OP-TEE OS via raw SMCs.
+ * This file is divided into the follow sections:
+ * 1. Convert between struct tee_param and struct optee_msg_param
+ * 2. Low level support functions to register shared memory in secure world
+ * 3. Dynamic shared memory pool based on alloc_pages()
+ * 4. Do a normal scheduled call into secure world
+ * 5. Driver initialization.
+ */
+
+#define OPTEE_SHM_NUM_PRIV_PAGES CONFIG_OPTEE_SHM_NUM_PRIV_PAGES
+
+/*
+ * 1. Convert between struct tee_param and struct optee_msg_param
+ *
+ * optee_from_msg_param() and optee_to_msg_param() are the main
+ * functions.
+ */
+
+static int from_msg_param_tmp_mem(struct tee_param *p, u32 attr,
+ const struct optee_msg_param *mp)
+{
+ struct tee_shm *shm;
+ phys_addr_t pa;
+ int rc;
+
+ p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
+ attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
+ p->u.memref.size = mp->u.tmem.size;
+ shm = (struct tee_shm *)(unsigned long)mp->u.tmem.shm_ref;
+ if (!shm) {
+ p->u.memref.shm_offs = 0;
+ p->u.memref.shm = NULL;
+ return 0;
+ }
+
+ rc = tee_shm_get_pa(shm, 0, &pa);
+ if (rc)
+ return rc;
+
+ p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
+ p->u.memref.shm = shm;
+
+ /* Check that the memref is covered by the shm object */
+ if (p->u.memref.size) {
+ size_t o = p->u.memref.shm_offs +
+ p->u.memref.size - 1;
+
+ rc = tee_shm_get_pa(shm, o, NULL);
+ if (rc)
+ return rc;
+ }
+
+ return 0;
+}
+
+static void from_msg_param_reg_mem(struct tee_param *p, u32 attr,
+ const struct optee_msg_param *mp)
+{
+ struct tee_shm *shm;
+
+ p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
+ attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
+ p->u.memref.size = mp->u.rmem.size;
+ shm = (struct tee_shm *)(unsigned long)mp->u.rmem.shm_ref;
+
+ if (shm) {
+ p->u.memref.shm_offs = mp->u.rmem.offs;
+ p->u.memref.shm = shm;
+ } else {
+ p->u.memref.shm_offs = 0;
+ p->u.memref.shm = NULL;
+ }
+}
+
+/**
+ * optee_from_msg_param() - convert from OPTEE_MSG parameters to
+ * struct tee_param
+ * @optee: main service struct
+ * @params: subsystem internal parameter representation
+ * @num_params: number of elements in the parameter arrays
+ * @msg_params: OPTEE_MSG parameters
+ * Returns 0 on success or <0 on failure
+ */
+static int optee_from_msg_param(struct optee *optee, struct tee_param *params,
+ size_t num_params,
+ const struct optee_msg_param *msg_params)
+{
+ int rc;
+ size_t n;
+
+ 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_IOCTL_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:
+ optee_from_msg_param_value(p, attr, mp);
+ break;
+ case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:
+ case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
+ case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
+ rc = from_msg_param_tmp_mem(p, attr, mp);
+ if (rc)
+ return rc;
+ break;
+ case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:
+ case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:
+ case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:
+ from_msg_param_reg_mem(p, attr, mp);
+ break;
+
+ default:
+ return -EINVAL;
+ }
+ }
+ return 0;
+}
+
+static int to_msg_param_tmp_mem(struct optee_msg_param *mp,
+ const struct tee_param *p)
+{
+ int rc;
+ phys_addr_t pa;
+
+ mp->attr = OPTEE_MSG_ATTR_TYPE_TMEM_INPUT + p->attr -
+ TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
+
+ mp->u.tmem.shm_ref = (unsigned long)p->u.memref.shm;
+ mp->u.tmem.size = p->u.memref.size;
+
+ if (!p->u.memref.shm) {
+ mp->u.tmem.buf_ptr = 0;
+ return 0;
+ }
+
+ rc = tee_shm_get_pa(p->u.memref.shm, p->u.memref.shm_offs, &pa);
+ if (rc)
+ return rc;
+
+ mp->u.tmem.buf_ptr = pa;
+ mp->attr |= OPTEE_MSG_ATTR_CACHE_PREDEFINED <<
+ OPTEE_MSG_ATTR_CACHE_SHIFT;
+
+ return 0;
+}
+
+static int to_msg_param_reg_mem(struct optee_msg_param *mp,
+ const struct tee_param *p)
+{
+ mp->attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT + p->attr -
+ TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
+
+ mp->u.rmem.shm_ref = (unsigned long)p->u.memref.shm;
+ mp->u.rmem.size = p->u.memref.size;
+ mp->u.rmem.offs = p->u.memref.shm_offs;
+ return 0;
+}
+
+/**
+ * optee_to_msg_param() - convert from struct tee_params to OPTEE_MSG parameters
+ * @optee: main service struct
+ * @msg_params: OPTEE_MSG parameters
+ * @num_params: number of elements in the parameter arrays
+ * @params: subsystem itnernal parameter representation
+ * Returns 0 on success or <0 on failure
+ */
+static int optee_to_msg_param(struct optee *optee,
+ struct optee_msg_param *msg_params,
+ size_t num_params, const struct tee_param *params)
+{
+ int rc;
+ size_t 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_IOCTL_PARAM_ATTR_TYPE_NONE:
+ mp->attr = TEE_IOCTL_PARAM_ATTR_TYPE_NONE;
+ memset(&mp->u, 0, sizeof(mp->u));
+ break;
+ case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT:
+ case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
+ case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
+ optee_to_msg_param_value(mp, p);
+ break;
+ case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT:
+ case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
+ case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:
+ if (tee_shm_is_registered(p->u.memref.shm))
+ rc = to_msg_param_reg_mem(mp, p);
+ else
+ rc = to_msg_param_tmp_mem(mp, p);
+ if (rc)
+ return rc;
+ break;
+ default:
+ return -EINVAL;
+ }
+ }
+ return 0;
+}
+
+/*
+ * 2. Low level support functions to register shared memory in secure world
+ *
+ * Functions to enable/disable shared memory caching in secure world, that
+ * is, lazy freeing of previously allocated shared memory. Freeing is
+ * performed when a request has been compled.
+ *
+ * Functions to register and unregister shared memory both for normal
+ * clients and for tee-supplicant.
+ */
+
+/**
+ * optee_enable_shm_cache() - Enables caching of some shared memory allocation
+ * in OP-TEE
+ * @optee: main service struct
+ */
+static void optee_enable_shm_cache(struct optee *optee)
+{
+ struct optee_call_waiter w;
+
+ /* We need to retry until secure world isn't busy. */
+ optee_cq_wait_init(&optee->call_queue, &w);
+ while (true) {
+ struct arm_smccc_res res;
+
+ optee->smc.invoke_fn(OPTEE_SMC_ENABLE_SHM_CACHE,
+ 0, 0, 0, 0, 0, 0, 0, &res);
+ if (res.a0 == OPTEE_SMC_RETURN_OK)
+ break;
+ optee_cq_wait_for_completion(&optee->call_queue, &w);
+ }
+ optee_cq_wait_final(&optee->call_queue, &w);
+}
+
+/**
+ * optee_disable_shm_cache() - Disables caching of some shared memory allocation
+ * in OP-TEE
+ * @optee: main service struct
+ */
+static void optee_disable_shm_cache(struct optee *optee)
+{
+ struct optee_call_waiter w;
+
+ /* We need to retry until secure world isn't busy. */
+ optee_cq_wait_init(&optee->call_queue, &w);
+ while (true) {
+ union {
+ struct arm_smccc_res smccc;
+ struct optee_smc_disable_shm_cache_result result;
+ } res;
+
+ optee->smc.invoke_fn(OPTEE_SMC_DISABLE_SHM_CACHE,
+ 0, 0, 0, 0, 0, 0, 0, &res.smccc);
+ if (res.result.status == OPTEE_SMC_RETURN_ENOTAVAIL)
+ break; /* All shm's freed */
+ if (res.result.status == OPTEE_SMC_RETURN_OK) {
+ struct tee_shm *shm;
+
+ shm = reg_pair_to_ptr(res.result.shm_upper32,
+ res.result.shm_lower32);
+ tee_shm_free(shm);
+ } else {
+ optee_cq_wait_for_completion(&optee->call_queue, &w);
+ }
+ }
+ optee_cq_wait_final(&optee->call_queue, &w);
+}
+
+#define PAGELIST_ENTRIES_PER_PAGE \
+ ((OPTEE_MSG_NONCONTIG_PAGE_SIZE / sizeof(u64)) - 1)
+
+/*
+ * The final entry in each pagelist page is a pointer to the next
+ * pagelist page.
+ */
+static size_t get_pages_list_size(size_t num_entries)
+{
+ int pages = DIV_ROUND_UP(num_entries, PAGELIST_ENTRIES_PER_PAGE);
+
+ return pages * OPTEE_MSG_NONCONTIG_PAGE_SIZE;
+}
+
+static u64 *optee_allocate_pages_list(size_t num_entries)
+{
+ return alloc_pages_exact(get_pages_list_size(num_entries), GFP_KERNEL);
+}
+
+static void optee_free_pages_list(void *list, size_t num_entries)
+{
+ free_pages_exact(list, get_pages_list_size(num_entries));
+}
+
+/**
+ * optee_fill_pages_list() - write list of user pages to given shared
+ * buffer.
+ *
+ * @dst: page-aligned buffer where list of pages will be stored
+ * @pages: array of pages that represents shared buffer
+ * @num_pages: number of entries in @pages
+ * @page_offset: offset of user buffer from page start
+ *
+ * @dst should be big enough to hold list of user page addresses and
+ * links to the next pages of buffer
+ */
+static void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,
+ size_t page_offset)
+{
+ int n = 0;
+ phys_addr_t optee_page;
+ /*
+ * Refer to OPTEE_MSG_ATTR_NONCONTIG description in optee_msg.h
+ * for details.
+ */
+ struct {
+ u64 pages_list[PAGELIST_ENTRIES_PER_PAGE];
+ u64 next_page_data;
+ } *pages_data;
+
+ /*
+ * Currently OP-TEE uses 4k page size and it does not looks
+ * like this will change in the future. On other hand, there are
+ * no know ARM architectures with page size < 4k.
+ * Thus the next built assert looks redundant. But the following
+ * code heavily relies on this assumption, so it is better be
+ * safe than sorry.
+ */
+ BUILD_BUG_ON(PAGE_SIZE < OPTEE_MSG_NONCONTIG_PAGE_SIZE);
+
+ pages_data = (void *)dst;
+ /*
+ * If linux page is bigger than 4k, and user buffer offset is
+ * larger than 4k/8k/12k/etc this will skip first 4k pages,
+ * because they bear no value data for OP-TEE.
+ */
+ optee_page = page_to_phys(*pages) +
+ round_down(page_offset, OPTEE_MSG_NONCONTIG_PAGE_SIZE);
+
+ while (true) {
+ pages_data->pages_list[n++] = optee_page;
+
+ if (n == PAGELIST_ENTRIES_PER_PAGE) {
+ pages_data->next_page_data =
+ virt_to_phys(pages_data + 1);
+ pages_data++;
+ n = 0;
+ }
+
+ optee_page += OPTEE_MSG_NONCONTIG_PAGE_SIZE;
+ if (!(optee_page & ~PAGE_MASK)) {
+ if (!--num_pages)
+ break;
+ pages++;
+ optee_page = page_to_phys(*pages);
+ }
+ }
+}
+
+static int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
+ struct page **pages, size_t num_pages,
+ unsigned long start)
+{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
+ struct optee_msg_arg *msg_arg;
+ struct tee_shm *shm_arg;
+ u64 *pages_list;
+ int rc;
+
+ if (!num_pages)
+ return -EINVAL;
+
+ rc = optee_check_mem_type(start, num_pages);
+ if (rc)
+ return rc;
+
+ pages_list = optee_allocate_pages_list(num_pages);
+ if (!pages_list)
+ return -ENOMEM;
+
+ shm_arg = optee_get_msg_arg(ctx, 1, &msg_arg);
+ if (IS_ERR(shm_arg)) {
+ rc = PTR_ERR(shm_arg);
+ goto out;
+ }
+
+ optee_fill_pages_list(pages_list, pages, num_pages,
+ tee_shm_get_page_offset(shm));
+
+ 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.shm_ref = (unsigned long)shm;
+ msg_arg->params->u.tmem.size = tee_shm_get_size(shm);
+ /*
+ * In the least bits of msg_arg->params->u.tmem.buf_ptr we
+ * store buffer offset from 4k page, as described in OP-TEE ABI.
+ */
+ msg_arg->params->u.tmem.buf_ptr = virt_to_phys(pages_list) |
+ (tee_shm_get_page_offset(shm) & (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
+
+ if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
+ msg_arg->ret != TEEC_SUCCESS)
+ rc = -EINVAL;
+
+ tee_shm_free(shm_arg);
+out:
+ optee_free_pages_list(pages_list, num_pages);
+ return rc;
+}
+
+static int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
+{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
+ struct optee_msg_arg *msg_arg;
+ struct tee_shm *shm_arg;
+ int rc = 0;
+
+ shm_arg = optee_get_msg_arg(ctx, 1, &msg_arg);
+ if (IS_ERR(shm_arg))
+ return PTR_ERR(shm_arg);
+
+ 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 = (unsigned long)shm;
+
+ if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
+ msg_arg->ret != TEEC_SUCCESS)
+ rc = -EINVAL;
+ tee_shm_free(shm_arg);
+ return rc;
+}
+
+static int optee_shm_register_supp(struct tee_context *ctx, struct tee_shm *shm,
+ struct page **pages, size_t num_pages,
+ unsigned long start)
+{
+ /*
+ * We don't want to register supplicant memory in OP-TEE.
+ * Instead information about it will be passed in RPC code.
+ */
+ return optee_check_mem_type(start, num_pages);
+}
+
+static int optee_shm_unregister_supp(struct tee_context *ctx,
+ struct tee_shm *shm)
+{
+ return 0;
+}
+
+/*
+ * 3. Dynamic shared memory pool based on alloc_pages()
+ *
+ * Implements an OP-TEE specific shared memory pool which is used
+ * when dynamic shared memory is supported by secure world.
+ *
+ * The main function is optee_shm_pool_alloc_pages().
+ */
+
+static int pool_op_alloc(struct tee_shm_pool_mgr *poolm,
+ struct tee_shm *shm, size_t size)
+{
+ if (!(shm->flags & TEE_SHM_DMA_BUF))
+ return optee_pool_op_alloc_helper(poolm, shm, size, NULL);
+
+ return optee_pool_op_alloc_helper(poolm, shm, size, optee_shm_register);
+}
+
+static void pool_op_free(struct tee_shm_pool_mgr *poolm,
+ struct tee_shm *shm)
+{
+ if (shm->flags & TEE_SHM_DMA_BUF)
+ optee_shm_unregister(shm->ctx, shm);
+
+ free_pages((unsigned long)shm->kaddr, get_order(shm->size));
+ shm->kaddr = NULL;
+}
+
+static void pool_op_destroy_poolmgr(struct tee_shm_pool_mgr *poolm)
+{
+ kfree(poolm);
+}
+
+static const struct tee_shm_pool_mgr_ops pool_ops = {
+ .alloc = pool_op_alloc,
+ .free = pool_op_free,
+ .destroy_poolmgr = pool_op_destroy_poolmgr,
+};
+
+/**
+ * optee_shm_pool_alloc_pages() - create page-based allocator pool
+ *
+ * This pool is used when OP-TEE supports dymanic SHM. In this case
+ * command buffers and such are allocated from kernel's own memory.
+ */
+static struct tee_shm_pool_mgr *optee_shm_pool_alloc_pages(void)
+{
+ struct tee_shm_pool_mgr *mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
+
+ if (!mgr)
+ return ERR_PTR(-ENOMEM);
+
+ mgr->ops = &pool_ops;
+
+ return mgr;
+}
+
+/*
+ * 4. Do a normal scheduled call into secure world
+ *
+ * The function optee_smc_do_call_with_arg() performs a normal scheduled
+ * call into secure world. During this call may normal world request help
+ * from normal world using RPCs, Remote Procedure Calls. This includes
+ * delivery of non-secure interrupts to for instance allow rescheduling of
+ * the current task.
+ */
+
+static void handle_rpc_func_cmd_shm_free(struct tee_context *ctx,
+ struct optee_msg_arg *arg)
+{
+ struct tee_shm *shm;
+
+ arg->ret_origin = TEEC_ORIGIN_COMMS;
+
+ if (arg->num_params != 1 ||
+ arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) {
+ arg->ret = TEEC_ERROR_BAD_PARAMETERS;
+ return;
+ }
+
+ shm = (struct tee_shm *)(unsigned long)arg->params[0].u.value.b;
+ switch (arg->params[0].u.value.a) {
+ case OPTEE_RPC_SHM_TYPE_APPL:
+ optee_rpc_cmd_free_suppl(ctx, shm);
+ break;
+ case OPTEE_RPC_SHM_TYPE_KERNEL:
+ tee_shm_free(shm);
+ break;
+ default:
+ arg->ret = TEEC_ERROR_BAD_PARAMETERS;
+ }
+ arg->ret = TEEC_SUCCESS;
+}
+
+static void handle_rpc_func_cmd_shm_alloc(struct tee_context *ctx,
+ struct optee_msg_arg *arg,
+ struct optee_call_ctx *call_ctx)
+{
+ phys_addr_t pa;
+ struct tee_shm *shm;
+ size_t sz;
+ size_t n;
+
+ arg->ret_origin = TEEC_ORIGIN_COMMS;
+
+ if (!arg->num_params ||
+ arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) {
+ arg->ret = TEEC_ERROR_BAD_PARAMETERS;
+ return;
+ }
+
+ for (n = 1; n < arg->num_params; n++) {
+ if (arg->params[n].attr != OPTEE_MSG_ATTR_TYPE_NONE) {
+ arg->ret = TEEC_ERROR_BAD_PARAMETERS;
+ return;
+ }
+ }
+
+ sz = arg->params[0].u.value.b;
+ switch (arg->params[0].u.value.a) {
+ case OPTEE_RPC_SHM_TYPE_APPL:
+ shm = optee_rpc_cmd_alloc_suppl(ctx, sz);
+ break;
+ case OPTEE_RPC_SHM_TYPE_KERNEL:
+ shm = tee_shm_alloc(ctx, sz, TEE_SHM_MAPPED);
+ break;
+ default:
+ arg->ret = TEEC_ERROR_BAD_PARAMETERS;
+ return;
+ }
+
+ if (IS_ERR(shm)) {
+ arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
+ return;
+ }
+
+ if (tee_shm_get_pa(shm, 0, &pa)) {
+ arg->ret = TEEC_ERROR_BAD_PARAMETERS;
+ goto bad;
+ }
+
+ sz = tee_shm_get_size(shm);
+
+ if (tee_shm_is_registered(shm)) {
+ struct page **pages;
+ u64 *pages_list;
+ size_t page_num;
+
+ pages = tee_shm_get_pages(shm, &page_num);
+ if (!pages || !page_num) {
+ arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
+ goto bad;
+ }
+
+ pages_list = optee_allocate_pages_list(page_num);
+ if (!pages_list) {
+ arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
+ goto bad;
+ }
+
+ call_ctx->pages_list = pages_list;
+ call_ctx->num_entries = page_num;
+
+ arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT |
+ OPTEE_MSG_ATTR_NONCONTIG;
+ /*
+ * In the least bits of u.tmem.buf_ptr we store buffer offset
+ * from 4k page, as described in OP-TEE ABI.
+ */
+ arg->params[0].u.tmem.buf_ptr = virt_to_phys(pages_list) |
+ (tee_shm_get_page_offset(shm) &
+ (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
+ arg->params[0].u.tmem.size = tee_shm_get_size(shm);
+ arg->params[0].u.tmem.shm_ref = (unsigned long)shm;
+
+ optee_fill_pages_list(pages_list, pages, page_num,
+ tee_shm_get_page_offset(shm));
+ } else {
+ arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT;
+ arg->params[0].u.tmem.buf_ptr = pa;
+ arg->params[0].u.tmem.size = sz;
+ arg->params[0].u.tmem.shm_ref = (unsigned long)shm;
+ }
+
+ arg->ret = TEEC_SUCCESS;
+ return;
+bad:
+ tee_shm_free(shm);
+}
+
+static void free_pages_list(struct optee_call_ctx *call_ctx)
+{
+ if (call_ctx->pages_list) {
+ optee_free_pages_list(call_ctx->pages_list,
+ call_ctx->num_entries);
+ call_ctx->pages_list = NULL;
+ call_ctx->num_entries = 0;
+ }
+}
+
+static void optee_rpc_finalize_call(struct optee_call_ctx *call_ctx)
+{
+ free_pages_list(call_ctx);
+}
+
+static void handle_rpc_func_cmd(struct tee_context *ctx, struct optee *optee,
+ struct tee_shm *shm,
+ struct optee_call_ctx *call_ctx)
+{
+ struct optee_msg_arg *arg;
+
+ arg = tee_shm_get_va(shm, 0);
+ if (IS_ERR(arg)) {
+ pr_err("%s: tee_shm_get_va %p failed\n", __func__, shm);
+ return;
+ }
+
+ switch (arg->cmd) {
+ case OPTEE_RPC_CMD_GET_TIME:
+ optee_rpc_func_cmd_get_time(arg);
+ break;
+ case OPTEE_RPC_CMD_WAIT_QUEUE:
+ optee_rpc_func_cmd_wq(optee, arg);
+ break;
+ case OPTEE_RPC_CMD_SUSPEND:
+ optee_rpc_func_cmd_wait(arg);
+ break;
+ case OPTEE_RPC_CMD_SHM_ALLOC:
+ free_pages_list(call_ctx);
+ handle_rpc_func_cmd_shm_alloc(ctx, arg, call_ctx);
+ break;
+ case OPTEE_RPC_CMD_SHM_FREE:
+ handle_rpc_func_cmd_shm_free(ctx, arg);
+ break;
+ case OPTEE_RPC_CMD_I2C_TRANSFER:
+ optee_rpc_func_cmd_i2c_transfer(ctx, arg);
+ break;
+ default:
+ optee_rpc_supp_cmd(ctx, optee, arg);
+ }
+}
+
+/**
+ * optee_handle_rpc() - handle RPC from secure world
+ * @ctx: context doing the RPC
+ * @param: value of registers for the RPC
+ * @call_ctx: call context. Preserved during one OP-TEE invocation
+ *
+ * Result of RPC is written back into @param.
+ */
+static void optee_handle_rpc(struct tee_context *ctx,
+ struct optee_rpc_param *param,
+ struct optee_call_ctx *call_ctx)
+{
+ struct tee_device *teedev = ctx->teedev;
+ struct optee *optee = tee_get_drvdata(teedev);
+ struct tee_shm *shm;
+ phys_addr_t pa;
+
+ switch (OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0)) {
+ case OPTEE_SMC_RPC_FUNC_ALLOC:
+ shm = tee_shm_alloc(ctx, param->a1, TEE_SHM_MAPPED);
+ if (!IS_ERR(shm) && !tee_shm_get_pa(shm, 0, &pa)) {
+ reg_pair_from_64(&param->a1, &param->a2, pa);
+ reg_pair_from_64(&param->a4, &param->a5,
+ (unsigned long)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:
+ /*
+ * A foreign interrupt was raised while secure world was
+ * executing, since they are handled in Linux a dummy RPC is
+ * performed to let Linux take the interrupt through the normal
+ * vector.
+ */
+ break;
+ case OPTEE_SMC_RPC_FUNC_CMD:
+ shm = reg_pair_to_ptr(param->a1, param->a2);
+ handle_rpc_func_cmd(ctx, optee, shm, call_ctx);
+ break;
+ default:
+ pr_warn("Unknown RPC func 0x%x\n",
+ (u32)OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0));
+ break;
+ }
+
+ param->a0 = OPTEE_SMC_CALL_RETURN_FROM_RPC;
+}
+
+/**
+ * optee_smc_do_call_with_arg() - Do an SMC to OP-TEE in secure world
+ * @ctx: calling context
+ * @arg: shared memory holding the message to pass to secure world
+ *
+ * Does and SMC to OP-TEE in secure world and handles eventual resulting
+ * Remote Procedure Calls (RPC) from OP-TEE.
+ *
+ * Returns return code from secure world, 0 is OK
+ */
+static int optee_smc_do_call_with_arg(struct tee_context *ctx,
+ struct tee_shm *arg)
+{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
+ struct optee_call_waiter w;
+ struct optee_rpc_param param = { };
+ struct optee_call_ctx call_ctx = { };
+ phys_addr_t parg;
+ int rc;
+
+ rc = tee_shm_get_pa(arg, 0, &parg);
+ if (rc)
+ return rc;
+
+ param.a0 = OPTEE_SMC_CALL_WITH_ARG;
+ reg_pair_from_64(&param.a1, &param.a2, parg);
+ /* Initialize waiter */
+ optee_cq_wait_init(&optee->call_queue, &w);
+ while (true) {
+ struct arm_smccc_res res;
+
+ trace_optee_invoke_fn_begin(&param);
+ optee->smc.invoke_fn(param.a0, param.a1, param.a2, param.a3,
+ param.a4, param.a5, param.a6, param.a7,
+ &res);
+ trace_optee_invoke_fn_end(&param, &res);
+
+ if (res.a0 == OPTEE_SMC_RETURN_ETHREAD_LIMIT) {
+ /*
+ * Out of threads in secure world, wait for a thread
+ * become available.
+ */
+ optee_cq_wait_for_completion(&optee->call_queue, &w);
+ } else if (OPTEE_SMC_RETURN_IS_RPC(res.a0)) {
+ cond_resched();
+ param.a0 = res.a0;
+ param.a1 = res.a1;
+ param.a2 = res.a2;
+ param.a3 = res.a3;
+ optee_handle_rpc(ctx, &param, &call_ctx);
+ } else {
+ rc = res.a0;
+ break;
+ }
+ }
+
+ optee_rpc_finalize_call(&call_ctx);
+ /*
+ * We're done with our thread in secure world, if there's any
+ * thread waiters wake up one.
+ */
+ optee_cq_wait_final(&optee->call_queue, &w);
+
+ return rc;
+}
+
+/*
+ * 5. Driver initialization
+ *
+ * During driver inititialization is secure world probed to find out which
+ * features it supports so the driver can be initialized with a matching
+ * configuration. This involves for instance support for dynamic shared
+ * memory instead of a static memory carvout.
+ */
+
+static void optee_get_version(struct tee_device *teedev,
+ struct tee_ioctl_version_data *vers)
+{
+ struct tee_ioctl_version_data v = {
+ .impl_id = TEE_IMPL_ID_OPTEE,
+ .impl_caps = TEE_OPTEE_CAP_TZ,
+ .gen_caps = TEE_GEN_CAP_GP,
+ };
+ struct optee *optee = tee_get_drvdata(teedev);
+
+ if (optee->smc.sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
+ v.gen_caps |= TEE_GEN_CAP_REG_MEM;
+ if (optee->smc.sec_caps & OPTEE_SMC_SEC_CAP_MEMREF_NULL)
+ v.gen_caps |= TEE_GEN_CAP_MEMREF_NULL;
+ *vers = v;
+}
+
+static int optee_smc_open(struct tee_context *ctx)
+{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);
+ u32 sec_caps = optee->smc.sec_caps;
+
+ return optee_open(ctx, sec_caps & OPTEE_SMC_SEC_CAP_MEMREF_NULL);
+}
+
+static const struct tee_driver_ops optee_clnt_ops = {
+ .get_version = optee_get_version,
+ .open = optee_smc_open,
+ .release = optee_release,
+ .open_session = optee_open_session,
+ .close_session = optee_close_session,
+ .invoke_func = optee_invoke_func,
+ .cancel_req = optee_cancel_req,
+ .shm_register = optee_shm_register,
+ .shm_unregister = optee_shm_unregister,
+};
+
+static const struct tee_desc optee_clnt_desc = {
+ .name = DRIVER_NAME "-clnt",
+ .ops = &optee_clnt_ops,
+ .owner = THIS_MODULE,
+};
+
+static const struct tee_driver_ops optee_supp_ops = {
+ .get_version = optee_get_version,
+ .open = optee_smc_open,
+ .release = optee_release_supp,
+ .supp_recv = optee_supp_recv,
+ .supp_send = optee_supp_send,
+ .shm_register = optee_shm_register_supp,
+ .shm_unregister = optee_shm_unregister_supp,
+};
+
+static const struct tee_desc optee_supp_desc = {
+ .name = DRIVER_NAME "-supp",
+ .ops = &optee_supp_ops,
+ .owner = THIS_MODULE,
+ .flags = TEE_DESC_PRIVILEGED,
+};
+
+static const struct optee_ops optee_ops = {
+ .do_call_with_arg = optee_smc_do_call_with_arg,
+ .to_msg_param = optee_to_msg_param,
+ .from_msg_param = optee_from_msg_param,
+};
+
+static bool optee_msg_api_uid_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);
+
+ if (res.a0 == OPTEE_MSG_UID_0 && res.a1 == OPTEE_MSG_UID_1 &&
+ res.a2 == OPTEE_MSG_UID_2 && res.a3 == OPTEE_MSG_UID_3)
+ return true;
+ return false;
+}
+
+static void optee_msg_get_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)
+ pr_info("revision %lu.%lu (%08lx)", res.result.major,
+ res.result.minor, res.result.build_id);
+ else
+ pr_info("revision %lu.%lu", res.result.major, res.result.minor);
+}
+
+static bool optee_msg_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);
+
+ if (res.result.major == OPTEE_MSG_REVISION_MAJOR &&
+ (int)res.result.minor >= OPTEE_MSG_REVISION_MINOR)
+ return true;
+ return false;
+}
+
+static bool optee_msg_exchange_capabilities(optee_invoke_fn *invoke_fn,
+ u32 *sec_caps)
+{
+ union {
+ struct arm_smccc_res smccc;
+ struct optee_smc_exchange_capabilities_result result;
+ } res;
+ u32 a1 = 0;
+
+ /*
+ * TODO This isn't enough to tell if it's UP system (from kernel
+ * point of view) or not, is_smp() returns the information
+ * needed, but can't be called directly from here.
+ */
+ if (!IS_ENABLED(CONFIG_SMP) || nr_cpu_ids == 1)
+ a1 |= OPTEE_SMC_NSEC_CAP_UNIPROCESSOR;
+
+ invoke_fn(OPTEE_SMC_EXCHANGE_CAPABILITIES, a1, 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;
+}
+
+static struct tee_shm_pool *optee_config_dyn_shm(void)
+{
+ struct tee_shm_pool_mgr *priv_mgr;
+ struct tee_shm_pool_mgr *dmabuf_mgr;
+ void *rc;
+
+ rc = optee_shm_pool_alloc_pages();
+ if (IS_ERR(rc))
+ return rc;
+ priv_mgr = rc;
+
+ rc = optee_shm_pool_alloc_pages();
+ if (IS_ERR(rc)) {
+ tee_shm_pool_mgr_destroy(priv_mgr);
+ return rc;
+ }
+ dmabuf_mgr = rc;
+
+ rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
+ if (IS_ERR(rc)) {
+ tee_shm_pool_mgr_destroy(priv_mgr);
+ tee_shm_pool_mgr_destroy(dmabuf_mgr);
+ }
+
+ return rc;
+}
+
+static struct tee_shm_pool *
+optee_config_shm_memremap(optee_invoke_fn *invoke_fn, void **memremaped_shm)
+{
+ union {
+ struct arm_smccc_res smccc;
+ struct optee_smc_get_shm_config_result result;
+ } res;
+ unsigned long vaddr;
+ phys_addr_t paddr;
+ size_t size;
+ phys_addr_t begin;
+ phys_addr_t end;
+ void *va;
+ struct tee_shm_pool_mgr *priv_mgr;
+ struct tee_shm_pool_mgr *dmabuf_mgr;
+ void *rc;
+ const int sz = OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE;
+
+ invoke_fn(OPTEE_SMC_GET_SHM_CONFIG, 0, 0, 0, 0, 0, 0, 0, &res.smccc);
+ if (res.result.status != OPTEE_SMC_RETURN_OK) {
+ pr_err("static shm service not available\n");
+ return ERR_PTR(-ENOENT);
+ }
+
+ if (res.result.settings != OPTEE_SMC_SHM_CACHED) {
+ pr_err("only normal cached shared memory supported\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ begin = roundup(res.result.start, PAGE_SIZE);
+ end = rounddown(res.result.start + res.result.size, PAGE_SIZE);
+ paddr = begin;
+ size = end - begin;
+
+ if (size < 2 * OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE) {
+ pr_err("too small shared memory area\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ va = memremap(paddr, size, MEMREMAP_WB);
+ if (!va) {
+ pr_err("shared memory ioremap failed\n");
+ return ERR_PTR(-EINVAL);
+ }
+ vaddr = (unsigned long)va;
+
+ rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, sz,
+ 3 /* 8 bytes aligned */);
+ if (IS_ERR(rc))
+ goto err_memunmap;
+ priv_mgr = rc;
+
+ vaddr += sz;
+ paddr += sz;
+ size -= sz;
+
+ rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, size, PAGE_SHIFT);
+ if (IS_ERR(rc))
+ goto err_free_priv_mgr;
+ dmabuf_mgr = rc;
+
+ rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
+ if (IS_ERR(rc))
+ goto err_free_dmabuf_mgr;
+
+ *memremaped_shm = va;
+
+ return rc;
+
+err_free_dmabuf_mgr:
+ tee_shm_pool_mgr_destroy(dmabuf_mgr);
+err_free_priv_mgr:
+ tee_shm_pool_mgr_destroy(priv_mgr);
+err_memunmap:
+ memunmap(va);
+ return rc;
+}
+
+/* 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 device *dev)
+{
+ const char *method;
+
+ pr_info("probing for conduit method.\n");
+
+ if (device_property_read_string(dev, "method", &method)) {
+ pr_warn("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;
+
+ pr_warn("invalid \"method\" property: %s\n", method);
+ return ERR_PTR(-EINVAL);
+}
+
+static int optee_smc_remove(struct platform_device *pdev)
+{
+ struct optee *optee = platform_get_drvdata(pdev);
+
+ /*
+ * Ask OP-TEE to free all cached shared memory objects to decrease
+ * reference counters and also avoid wild pointers in secure world
+ * into the old shared memory range.
+ */
+ optee_disable_shm_cache(optee);
+
+ optee_remove_common(optee);
+
+ if (optee->smc.memremaped_shm)
+ memunmap(optee->smc.memremaped_shm);
+
+ kfree(optee);
+
+ return 0;
+}
+
+static int optee_probe(struct platform_device *pdev)
+{
+ optee_invoke_fn *invoke_fn;
+ struct tee_shm_pool *pool = ERR_PTR(-EINVAL);
+ struct optee *optee = NULL;
+ void *memremaped_shm = NULL;
+ struct tee_device *teedev;
+ u32 sec_caps;
+ int rc;
+
+ invoke_fn = get_invoke_func(&pdev->dev);
+ if (IS_ERR(invoke_fn))
+ return PTR_ERR(invoke_fn);
+
+ if (!optee_msg_api_uid_is_optee_api(invoke_fn)) {
+ pr_warn("api uid mismatch\n");
+ return -EINVAL;
+ }
+
+ optee_msg_get_os_revision(invoke_fn);
+
+ if (!optee_msg_api_revision_is_compatible(invoke_fn)) {
+ pr_warn("api revision mismatch\n");
+ return -EINVAL;
+ }
+
+ if (!optee_msg_exchange_capabilities(invoke_fn, &sec_caps)) {
+ pr_warn("capabilities mismatch\n");
+ return -EINVAL;
+ }
+
+ /*
+ * Try to use dynamic shared memory if possible
+ */
+ if (sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
+ pool = optee_config_dyn_shm();
+
+ /*
+ * If dynamic shared memory is not available or failed - try static one
+ */
+ if (IS_ERR(pool) && (sec_caps & OPTEE_SMC_SEC_CAP_HAVE_RESERVED_SHM))
+ pool = optee_config_shm_memremap(invoke_fn, &memremaped_shm);
+
+ if (IS_ERR(pool))
+ return PTR_ERR(pool);
+
+ optee = kzalloc(sizeof(*optee), GFP_KERNEL);
+ if (!optee) {
+ rc = -ENOMEM;
+ goto err;
+ }
+
+ optee->ops = &optee_ops;
+ optee->smc.invoke_fn = invoke_fn;
+ optee->smc.sec_caps = sec_caps;
+
+ teedev = tee_device_alloc(&optee_clnt_desc, NULL, pool, optee);
+ if (IS_ERR(teedev)) {
+ rc = PTR_ERR(teedev);
+ goto err;
+ }
+ optee->teedev = teedev;
+
+ teedev = tee_device_alloc(&optee_supp_desc, NULL, pool, optee);
+ if (IS_ERR(teedev)) {
+ rc = PTR_ERR(teedev);
+ goto err;
+ }
+ optee->supp_teedev = teedev;
+
+ rc = tee_device_register(optee->teedev);
+ if (rc)
+ goto err;
+
+ rc = tee_device_register(optee->supp_teedev);
+ if (rc)
+ goto err;
+
+ mutex_init(&optee->call_queue.mutex);
+ INIT_LIST_HEAD(&optee->call_queue.waiters);
+ optee_wait_queue_init(&optee->wait_queue);
+ optee_supp_init(&optee->supp);
+ optee->smc.memremaped_shm = memremaped_shm;
+ optee->pool = pool;
+
+ optee_enable_shm_cache(optee);
+
+ if (optee->smc.sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
+ pr_info("dynamic shared memory is enabled\n");
+
+ platform_set_drvdata(pdev, optee);
+
+ rc = optee_enumerate_devices(PTA_CMD_GET_DEVICES);
+ if (rc) {
+ optee_smc_remove(pdev);
+ return rc;
+ }
+
+ pr_info("initialized driver\n");
+ return 0;
+err:
+ if (optee) {
+ /*
+ * tee_device_unregister() is safe to call even if the
+ * devices hasn't been registered with
+ * tee_device_register() yet.
+ */
+ tee_device_unregister(optee->supp_teedev);
+ tee_device_unregister(optee->teedev);
+ kfree(optee);
+ }
+ if (pool)
+ tee_shm_pool_free(pool);
+ if (memremaped_shm)
+ memunmap(memremaped_shm);
+ return rc;
+}
+
+static const struct of_device_id optee_dt_match[] = {
+ { .compatible = "linaro,optee-tz" },
+ {},
+};
+MODULE_DEVICE_TABLE(of, optee_dt_match);
+
+static struct platform_driver optee_driver = {
+ .probe = optee_probe,
+ .remove = optee_smc_remove,
+ .driver = {
+ .name = "optee",
+ .of_match_table = optee_dt_match,
+ },
+};
+module_platform_driver(optee_driver);
--
2.31.1

2021-07-22 12:21:58

by Jens Wiklander

[permalink] [raw]
Subject: [PATCH v3 2/5] optee: simplify optee_release()

Simplifies optee_release() with a new helper function,
optee_close_session_helper() which has been factored out from
optee_close_session().

A separate optee_release_supp() is added for the supplicant device.

Signed-off-by: Jens Wiklander <[email protected]>
---
drivers/tee/optee/call.c | 31 ++++++++++-------
drivers/tee/optee/core.c | 55 +++++++++++--------------------
drivers/tee/optee/optee_private.h | 1 +
3 files changed, 39 insertions(+), 48 deletions(-)

diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c
index 6e6eb836e9b6..9d8f5a95e42f 100644
--- a/drivers/tee/optee/call.c
+++ b/drivers/tee/optee/call.c
@@ -288,12 +288,28 @@ int optee_open_session(struct tee_context *ctx,
return rc;
}

-int optee_close_session(struct tee_context *ctx, u32 session)
+int optee_close_session_helper(struct tee_context *ctx, u32 session)
{
- struct optee_context_data *ctxdata = ctx->data;
struct tee_shm *shm;
struct optee_msg_arg *msg_arg;
phys_addr_t msg_parg;
+
+ shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
+ if (IS_ERR(shm))
+ return PTR_ERR(shm);
+
+ msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
+ msg_arg->session = session;
+ optee_do_call_with_arg(ctx, msg_parg);
+
+ tee_shm_free(shm);
+
+ return 0;
+}
+
+int optee_close_session(struct tee_context *ctx, u32 session)
+{
+ struct optee_context_data *ctxdata = ctx->data;
struct optee_session *sess;

/* Check that the session is valid and remove it from the list */
@@ -306,16 +322,7 @@ int optee_close_session(struct tee_context *ctx, u32 session)
return -EINVAL;
kfree(sess);

- shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
- if (IS_ERR(shm))
- return PTR_ERR(shm);
-
- msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
- msg_arg->session = session;
- optee_do_call_with_arg(ctx, msg_parg);
-
- tee_shm_free(shm);
- return 0;
+ return optee_close_session_helper(ctx, session);
}

int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c
index ddb8f9ecf307..949223b214c3 100644
--- a/drivers/tee/optee/core.c
+++ b/drivers/tee/optee/core.c
@@ -263,59 +263,42 @@ static int optee_open(struct tee_context *ctx)
return 0;
}

-static void optee_release(struct tee_context *ctx)
+static void optee_release_helper(struct tee_context *ctx,
+ int (*close_session)(struct tee_context *ctx,
+ u32 session))
{
struct optee_context_data *ctxdata = ctx->data;
- struct tee_device *teedev = ctx->teedev;
- struct optee *optee = tee_get_drvdata(teedev);
- struct tee_shm *shm;
- struct optee_msg_arg *arg = NULL;
- phys_addr_t parg;
struct optee_session *sess;
struct optee_session *sess_tmp;

if (!ctxdata)
return;

- shm = tee_shm_alloc(ctx, sizeof(struct optee_msg_arg), TEE_SHM_MAPPED);
- if (!IS_ERR(shm)) {
- arg = tee_shm_get_va(shm, 0);
- /*
- * If va2pa fails for some reason, we can't call into
- * secure world, only free the memory. Secure OS will leak
- * sessions and finally refuse more sessions, but we will
- * at least let normal world reclaim its memory.
- */
- if (!IS_ERR(arg))
- if (tee_shm_va2pa(shm, arg, &parg))
- arg = NULL; /* prevent usage of parg below */
- }
-
list_for_each_entry_safe(sess, sess_tmp, &ctxdata->sess_list,
list_node) {
list_del(&sess->list_node);
- if (!IS_ERR_OR_NULL(arg)) {
- memset(arg, 0, sizeof(*arg));
- arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
- arg->session = sess->session_id;
- optee_do_call_with_arg(ctx, parg);
- }
+ close_session(ctx, sess->session_id);
kfree(sess);
}
kfree(ctxdata);
+ ctx->data = NULL;
+}

- if (!IS_ERR(shm))
- tee_shm_free(shm);
+static void optee_release(struct tee_context *ctx)
+{
+ optee_release_helper(ctx, optee_close_session_helper);
+}

- ctx->data = NULL;
+static void optee_release_supp(struct tee_context *ctx)
+{
+ struct optee *optee = tee_get_drvdata(ctx->teedev);

- if (teedev == optee->supp_teedev) {
- if (optee->scan_bus_wq) {
- destroy_workqueue(optee->scan_bus_wq);
- optee->scan_bus_wq = NULL;
- }
- optee_supp_release(&optee->supp);
+ optee_release_helper(ctx, optee_close_session_helper);
+ if (optee->scan_bus_wq) {
+ destroy_workqueue(optee->scan_bus_wq);
+ optee->scan_bus_wq = NULL;
}
+ optee_supp_release(&optee->supp);
}

static const struct tee_driver_ops optee_ops = {
@@ -339,7 +322,7 @@ static const struct tee_desc optee_desc = {
static const struct tee_driver_ops optee_supp_ops = {
.get_version = optee_get_version,
.open = optee_open,
- .release = optee_release,
+ .release = optee_release_supp,
.supp_recv = optee_supp_recv,
.supp_send = optee_supp_send,
.shm_register = optee_shm_register_supp,
diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h
index e25b216a14ef..2b63b796645e 100644
--- a/drivers/tee/optee/optee_private.h
+++ b/drivers/tee/optee/optee_private.h
@@ -152,6 +152,7 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg);
int optee_open_session(struct tee_context *ctx,
struct tee_ioctl_open_session_arg *arg,
struct tee_param *param);
+int optee_close_session_helper(struct tee_context *ctx, u32 session);
int optee_close_session(struct tee_context *ctx, u32 session);
int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
struct tee_param *param);
--
2.31.1

2021-07-26 10:31:34

by Sumit Garg

[permalink] [raw]
Subject: Re: [PATCH v3 0/5] Add FF-A support in OP-TEE driver

Hi Jens,

On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
>
> Hi all,
>
> This adds supports for the OP-TEE driver to communicate with secure world
> using FF-A [1] as transport.
>
> There is one change to the TEE subsystem with "tee: add sec_world_id to
> struct tee_shm" to add support for holding globally unique handle assigned
> by the FF-A. This is a field that I believe could useful for the AMDTEE
> driver too.
>
> For communication the OP-TEE message protocol is still used, but with a new
> type of memory reference, struct optee_msg_param_fmem, to carry the
> information needed by FF-A. The OP-TEE driver is refactored internally with
> to sets of callbacks, one for the old SMC based communication and another
> set with FF-A as transport. The functions relating to the SMC based ABI
> are moved to smc_abi.c while the FF-A based ABI is added in a ffa_abi.c.
>
> There is also a difference in how the drivers are instantiated. With the
> SMC based transport we have a platform driver, module_platform_driver(),
> today which we're keeping as is for this configuration. In a FF-A system we
> have a FF-A driver, module_ffa_driver(), instead.
>
> The OP-TEE driver can be compiled for both targets at the same time and
> it's up to runtime configuration (device tree or ACPI) to decide how it's
> initialized. Note that it's only the old SMC based driver instance that
> need device tree or ACPI to initialize. The FF-A based driver relies on the
> FF-A bus instead.
>
> This can be tested QEMU
> The repo for SPMC at S-EL1 retrieved by
> repo init -u https://github.com/jenswi-linaro/manifest.git -m
> qemu_v8.xml -b ffav4_spmc
> repo sync
> # Then checkout the branch optee_ffa_v3 from
> # git://git.linaro.org/people/jens.wiklander/linux-tee.git
> # in the linux directory
>
> To build do:
> cd build
> make toolchains
> make all
>
> To boot:
> make run-only
>
> Test with xtest, perhaps only with the command "xtest 1004" in case you're
> not interested in too many tests.

Thanks Jens for sharing instructions to test this feature. So I tried
to reproduce using following repo versions:

linux-tee, branch: optee_ffa_v3
trusted-firmware-a, branch: ffav4_sel1_spmc
build, branch: ffav4_spmc

and rest of the repos synced to the latest version as per upstream
qemu_v8.xml [1] but I don't see OP-TEE driver being probed during boot
[2]. Am I missing something?

[1] https://github.com/OP-TEE/manifest/blob/master/qemu_v8.xml
[2]
Welcome to Buildroot, type root or test to login
buildroot login: root
# dmesg | grep optee
#

-Sumit

>
> Thanks,
> Jens
>
> [1] https://developer.arm.com/documentation/den0077/latest
>
> v2->v3:
> - Rebased on 5.14-rc2 which now have the FF-A patches merged
> - Fixed a couple bugs in optee_shm_register() and optee_shm_unregister()
> which where introduced in "optee: refactor driver with internal callbacks"
> in previous the version.
> - Separated SMC ABI specifics into smc_abi.c to keep it separated from
> the FF-A ABI functions as requested by Sumit.
> - Added the FF-A specifics in ffa_abi.c
> - Provided an implementation for optee_ffa_remove()
>
> v1->v2:
> - Rebased to the FF-A v7 patch
> - Fixed a couple of reports from kernel test robot <[email protected]>
>
> Jens Wiklander (5):
> tee: add sec_world_id to struct tee_shm
> optee: simplify optee_release()
> optee: refactor driver with internal callbacks
> optee: isolate smc abi
> optee: add FF-A support
>
> drivers/tee/optee/Makefile | 7 +-
> drivers/tee/optee/call.c | 415 ++-------
> drivers/tee/optee/core.c | 673 ++-------------
> drivers/tee/optee/ffa_abi.c | 910 ++++++++++++++++++++
> drivers/tee/optee/optee_ffa.h | 153 ++++
> drivers/tee/optee/optee_msg.h | 27 +-
> drivers/tee/optee/optee_private.h | 155 +++-
> drivers/tee/optee/rpc.c | 270 +-----
> drivers/tee/optee/shm_pool.c | 89 --
> drivers/tee/optee/shm_pool.h | 14 -
> drivers/tee/optee/smc_abi.c | 1301 +++++++++++++++++++++++++++++
> include/linux/tee_drv.h | 7 +-
> 12 files changed, 2650 insertions(+), 1371 deletions(-)
> create mode 100644 drivers/tee/optee/ffa_abi.c
> create mode 100644 drivers/tee/optee/optee_ffa.h
> delete mode 100644 drivers/tee/optee/shm_pool.c
> delete mode 100644 drivers/tee/optee/shm_pool.h
> create mode 100644 drivers/tee/optee/smc_abi.c
>
> --
> 2.31.1
>

2021-07-26 10:56:05

by Sudeep Holla

[permalink] [raw]
Subject: Re: [PATCH v3 0/5] Add FF-A support in OP-TEE driver

On Mon, Jul 26, 2021 at 03:59:36PM +0530, Sumit Garg wrote:
> Hi Jens,
>
> On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
> >
> > Hi all,
> >
> > This adds supports for the OP-TEE driver to communicate with secure world
> > using FF-A [1] as transport.
> >
> > There is one change to the TEE subsystem with "tee: add sec_world_id to
> > struct tee_shm" to add support for holding globally unique handle assigned
> > by the FF-A. This is a field that I believe could useful for the AMDTEE
> > driver too.
> >
> > For communication the OP-TEE message protocol is still used, but with a new
> > type of memory reference, struct optee_msg_param_fmem, to carry the
> > information needed by FF-A. The OP-TEE driver is refactored internally with
> > to sets of callbacks, one for the old SMC based communication and another
> > set with FF-A as transport. The functions relating to the SMC based ABI
> > are moved to smc_abi.c while the FF-A based ABI is added in a ffa_abi.c.
> >
> > There is also a difference in how the drivers are instantiated. With the
> > SMC based transport we have a platform driver, module_platform_driver(),
> > today which we're keeping as is for this configuration. In a FF-A system we
> > have a FF-A driver, module_ffa_driver(), instead.
> >
> > The OP-TEE driver can be compiled for both targets at the same time and
> > it's up to runtime configuration (device tree or ACPI) to decide how it's
> > initialized. Note that it's only the old SMC based driver instance that
> > need device tree or ACPI to initialize. The FF-A based driver relies on the
> > FF-A bus instead.
> >
> > This can be tested QEMU
> > The repo for SPMC at S-EL1 retrieved by
> > repo init -u https://github.com/jenswi-linaro/manifest.git -m
> > qemu_v8.xml -b ffav4_spmc
> > repo sync
> > # Then checkout the branch optee_ffa_v3 from
> > # git://git.linaro.org/people/jens.wiklander/linux-tee.git
> > # in the linux directory
> >
> > To build do:
> > cd build
> > make toolchains
> > make all
> >
> > To boot:
> > make run-only
> >
> > Test with xtest, perhaps only with the command "xtest 1004" in case you're
> > not interested in too many tests.
>
> Thanks Jens for sharing instructions to test this feature. So I tried
> to reproduce using following repo versions:
>
> linux-tee, branch: optee_ffa_v3
> trusted-firmware-a, branch: ffav4_sel1_spmc
> build, branch: ffav4_spmc
>
> and rest of the repos synced to the latest version as per upstream
> qemu_v8.xml [1] but I don't see OP-TEE driver being probed during boot
> [2]. Am I missing something?
>
> [1] https://github.com/OP-TEE/manifest/blob/master/qemu_v8.xml
> [2]
> Welcome to Buildroot, type root or test to login
> buildroot login: root
> # dmesg | grep optee
>

Do you see ARM FF-A driver initialised successfully ?
You must see "ARM FF-A Version 1.0 found" or something similar based on
the actual version supported.

If so, can you check if the partitions are correctly populated by
the driver using the discover API.

$ grep "" /sys/bus/arm_ffa/devices/*/uuid

If uuid reads zeros, then the devices are populated, just the matching
driver is not found(due to the workaround for v1.0 spec)

--
Regards,
Sudeep

2021-07-26 11:45:26

by Sumit Garg

[permalink] [raw]
Subject: Re: [PATCH v3 0/5] Add FF-A support in OP-TEE driver

On Mon, 26 Jul 2021 at 16:25, Sudeep Holla <[email protected]> wrote:
>
> On Mon, Jul 26, 2021 at 03:59:36PM +0530, Sumit Garg wrote:
> > Hi Jens,
> >
> > On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
> > >
> > > Hi all,
> > >
> > > This adds supports for the OP-TEE driver to communicate with secure world
> > > using FF-A [1] as transport.
> > >
> > > There is one change to the TEE subsystem with "tee: add sec_world_id to
> > > struct tee_shm" to add support for holding globally unique handle assigned
> > > by the FF-A. This is a field that I believe could useful for the AMDTEE
> > > driver too.
> > >
> > > For communication the OP-TEE message protocol is still used, but with a new
> > > type of memory reference, struct optee_msg_param_fmem, to carry the
> > > information needed by FF-A. The OP-TEE driver is refactored internally with
> > > to sets of callbacks, one for the old SMC based communication and another
> > > set with FF-A as transport. The functions relating to the SMC based ABI
> > > are moved to smc_abi.c while the FF-A based ABI is added in a ffa_abi.c.
> > >
> > > There is also a difference in how the drivers are instantiated. With the
> > > SMC based transport we have a platform driver, module_platform_driver(),
> > > today which we're keeping as is for this configuration. In a FF-A system we
> > > have a FF-A driver, module_ffa_driver(), instead.
> > >
> > > The OP-TEE driver can be compiled for both targets at the same time and
> > > it's up to runtime configuration (device tree or ACPI) to decide how it's
> > > initialized. Note that it's only the old SMC based driver instance that
> > > need device tree or ACPI to initialize. The FF-A based driver relies on the
> > > FF-A bus instead.
> > >
> > > This can be tested QEMU
> > > The repo for SPMC at S-EL1 retrieved by
> > > repo init -u https://github.com/jenswi-linaro/manifest.git -m
> > > qemu_v8.xml -b ffav4_spmc
> > > repo sync
> > > # Then checkout the branch optee_ffa_v3 from
> > > # git://git.linaro.org/people/jens.wiklander/linux-tee.git
> > > # in the linux directory
> > >
> > > To build do:
> > > cd build
> > > make toolchains
> > > make all
> > >
> > > To boot:
> > > make run-only
> > >
> > > Test with xtest, perhaps only with the command "xtest 1004" in case you're
> > > not interested in too many tests.
> >
> > Thanks Jens for sharing instructions to test this feature. So I tried
> > to reproduce using following repo versions:
> >
> > linux-tee, branch: optee_ffa_v3
> > trusted-firmware-a, branch: ffav4_sel1_spmc
> > build, branch: ffav4_spmc
> >
> > and rest of the repos synced to the latest version as per upstream
> > qemu_v8.xml [1] but I don't see OP-TEE driver being probed during boot
> > [2]. Am I missing something?
> >
> > [1] https://github.com/OP-TEE/manifest/blob/master/qemu_v8.xml
> > [2]
> > Welcome to Buildroot, type root or test to login
> > buildroot login: root
> > # dmesg | grep optee
> >
>
> Do you see ARM FF-A driver initialised successfully ?
> You must see "ARM FF-A Version 1.0 found" or something similar based on
> the actual version supported.
>
> If so, can you check if the partitions are correctly populated by
> the driver using the discover API.
>
> $ grep "" /sys/bus/arm_ffa/devices/*/uuid
>
> If uuid reads zeros, then the devices are populated, just the matching
> driver is not found(due to the workaround for v1.0 spec)
>

It turns out to be an issue with my build environment, I re-built from
scratch and I could see OP-TEE being probed successfully:

# dmesg | grep FF-A
[ 0.356382] ARM FF-A: Version 1.0 found
#
# cat /sys/bus/arm_ffa/devices/arm-ffa-8001/uuid
486178e0-e7f8-11e3-bc5e-0002a5d5c51b
#
# dmesg | grep optee
[ 4.991472] optee: revision 3.14 (49dbb9ef)
[ 5.010110] optee: initialized driver
#

Jens,

From xtest logs it looks like the pseudo TA interface isn't working for me:

* regression_1001 Core self tests
- 1001 - skip test, pseudo TA not found
regression_1001 OK

* regression_1002 PTA parameters
- 1002 - skip test, pseudo TA not found
regression_1002 OK

* regression_1003 Core internal read/write mutex
- 1003 - skip test, pseudo TA not found
regression_1003 OK

Similarly, pseudo TAs acting as TEE bus devices doesn't work as well
as I see following devices directory being empty:

# ls /sys/bus/tee/devices/
#

As otherwise with OP-TEE SMC ABI, we should have at least the default
pseudo TA [1] kernel device there.

So is pseudo TA functional with this new FF-A interface?

[1] https://github.com/OP-TEE/optee_os/blob/master/core/pta/tests/invoke.c#L445

-Sumit

> --
> Regards,
> Sudeep

2021-07-26 15:29:35

by Jens Wiklander

[permalink] [raw]
Subject: Re: [PATCH v3 0/5] Add FF-A support in OP-TEE driver

Hi Sumit,

On Mon, Jul 26, 2021 at 1:41 PM Sumit Garg <[email protected]> wrote:
>
> On Mon, 26 Jul 2021 at 16:25, Sudeep Holla <[email protected]> wrote:
> >
> > On Mon, Jul 26, 2021 at 03:59:36PM +0530, Sumit Garg wrote:
> > > Hi Jens,
> > >
> > > On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
> > > >
> > > > Hi all,
> > > >
> > > > This adds supports for the OP-TEE driver to communicate with secure world
> > > > using FF-A [1] as transport.
> > > >
> > > > There is one change to the TEE subsystem with "tee: add sec_world_id to
> > > > struct tee_shm" to add support for holding globally unique handle assigned
> > > > by the FF-A. This is a field that I believe could useful for the AMDTEE
> > > > driver too.
> > > >
> > > > For communication the OP-TEE message protocol is still used, but with a new
> > > > type of memory reference, struct optee_msg_param_fmem, to carry the
> > > > information needed by FF-A. The OP-TEE driver is refactored internally with
> > > > to sets of callbacks, one for the old SMC based communication and another
> > > > set with FF-A as transport. The functions relating to the SMC based ABI
> > > > are moved to smc_abi.c while the FF-A based ABI is added in a ffa_abi.c.
> > > >
> > > > There is also a difference in how the drivers are instantiated. With the
> > > > SMC based transport we have a platform driver, module_platform_driver(),
> > > > today which we're keeping as is for this configuration. In a FF-A system we
> > > > have a FF-A driver, module_ffa_driver(), instead.
> > > >
> > > > The OP-TEE driver can be compiled for both targets at the same time and
> > > > it's up to runtime configuration (device tree or ACPI) to decide how it's
> > > > initialized. Note that it's only the old SMC based driver instance that
> > > > need device tree or ACPI to initialize. The FF-A based driver relies on the
> > > > FF-A bus instead.
> > > >
> > > > This can be tested QEMU
> > > > The repo for SPMC at S-EL1 retrieved by
> > > > repo init -u https://github.com/jenswi-linaro/manifest.git -m
> > > > qemu_v8.xml -b ffav4_spmc
> > > > repo sync
> > > > # Then checkout the branch optee_ffa_v3 from
> > > > # git://git.linaro.org/people/jens.wiklander/linux-tee.git
> > > > # in the linux directory
> > > >
> > > > To build do:
> > > > cd build
> > > > make toolchains
> > > > make all
> > > >
> > > > To boot:
> > > > make run-only
> > > >
> > > > Test with xtest, perhaps only with the command "xtest 1004" in case you're
> > > > not interested in too many tests.
> > >
> > > Thanks Jens for sharing instructions to test this feature. So I tried
> > > to reproduce using following repo versions:
> > >
> > > linux-tee, branch: optee_ffa_v3
> > > trusted-firmware-a, branch: ffav4_sel1_spmc
> > > build, branch: ffav4_spmc
> > >
> > > and rest of the repos synced to the latest version as per upstream
> > > qemu_v8.xml [1] but I don't see OP-TEE driver being probed during boot
> > > [2]. Am I missing something?
> > >
> > > [1] https://github.com/OP-TEE/manifest/blob/master/qemu_v8.xml
> > > [2]
> > > Welcome to Buildroot, type root or test to login
> > > buildroot login: root
> > > # dmesg | grep optee
> > >
> >
> > Do you see ARM FF-A driver initialised successfully ?
> > You must see "ARM FF-A Version 1.0 found" or something similar based on
> > the actual version supported.
> >
> > If so, can you check if the partitions are correctly populated by
> > the driver using the discover API.
> >
> > $ grep "" /sys/bus/arm_ffa/devices/*/uuid
> >
> > If uuid reads zeros, then the devices are populated, just the matching
> > driver is not found(due to the workaround for v1.0 spec)
> >
>
> It turns out to be an issue with my build environment, I re-built from
> scratch and I could see OP-TEE being probed successfully:
>
> # dmesg | grep FF-A
> [ 0.356382] ARM FF-A: Version 1.0 found
> #
> # cat /sys/bus/arm_ffa/devices/arm-ffa-8001/uuid
> 486178e0-e7f8-11e3-bc5e-0002a5d5c51b
> #
> # dmesg | grep optee
> [ 4.991472] optee: revision 3.14 (49dbb9ef)
> [ 5.010110] optee: initialized driver
> #

That's good.

> From xtest logs it looks like the pseudo TA interface isn't working for me:
>
> * regression_1001 Core self tests
> - 1001 - skip test, pseudo TA not found
> regression_1001 OK
>
> * regression_1002 PTA parameters
> - 1002 - skip test, pseudo TA not found
> regression_1002 OK
>
> * regression_1003 Core internal read/write mutex
> - 1003 - skip test, pseudo TA not found
> regression_1003 OK

The test PTAs are disabled by default.

>
> Similarly, pseudo TAs acting as TEE bus devices doesn't work as well
> as I see following devices directory being empty:
>
> # ls /sys/bus/tee/devices/
> #
>
> As otherwise with OP-TEE SMC ABI, we should have at least the default
> pseudo TA [1] kernel device there.
>
> So is pseudo TA functional with this new FF-A interface?

Yes, everything is supposed to work.

Cheers,
Jens

2021-07-27 06:15:28

by Sumit Garg

[permalink] [raw]
Subject: Re: [PATCH v3 0/5] Add FF-A support in OP-TEE driver

On Mon, 26 Jul 2021 at 20:55, Jens Wiklander <[email protected]> wrote:
>
> Hi Sumit,
>
> On Mon, Jul 26, 2021 at 1:41 PM Sumit Garg <[email protected]> wrote:
> >
> > On Mon, 26 Jul 2021 at 16:25, Sudeep Holla <[email protected]> wrote:
> > >
> > > On Mon, Jul 26, 2021 at 03:59:36PM +0530, Sumit Garg wrote:
> > > > Hi Jens,
> > > >
> > > > On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
> > > > >
> > > > > Hi all,
> > > > >
> > > > > This adds supports for the OP-TEE driver to communicate with secure world
> > > > > using FF-A [1] as transport.
> > > > >
> > > > > There is one change to the TEE subsystem with "tee: add sec_world_id to
> > > > > struct tee_shm" to add support for holding globally unique handle assigned
> > > > > by the FF-A. This is a field that I believe could useful for the AMDTEE
> > > > > driver too.
> > > > >
> > > > > For communication the OP-TEE message protocol is still used, but with a new
> > > > > type of memory reference, struct optee_msg_param_fmem, to carry the
> > > > > information needed by FF-A. The OP-TEE driver is refactored internally with
> > > > > to sets of callbacks, one for the old SMC based communication and another
> > > > > set with FF-A as transport. The functions relating to the SMC based ABI
> > > > > are moved to smc_abi.c while the FF-A based ABI is added in a ffa_abi.c.
> > > > >
> > > > > There is also a difference in how the drivers are instantiated. With the
> > > > > SMC based transport we have a platform driver, module_platform_driver(),
> > > > > today which we're keeping as is for this configuration. In a FF-A system we
> > > > > have a FF-A driver, module_ffa_driver(), instead.
> > > > >
> > > > > The OP-TEE driver can be compiled for both targets at the same time and
> > > > > it's up to runtime configuration (device tree or ACPI) to decide how it's
> > > > > initialized. Note that it's only the old SMC based driver instance that
> > > > > need device tree or ACPI to initialize. The FF-A based driver relies on the
> > > > > FF-A bus instead.
> > > > >
> > > > > This can be tested QEMU
> > > > > The repo for SPMC at S-EL1 retrieved by
> > > > > repo init -u https://github.com/jenswi-linaro/manifest.git -m
> > > > > qemu_v8.xml -b ffav4_spmc
> > > > > repo sync
> > > > > # Then checkout the branch optee_ffa_v3 from
> > > > > # git://git.linaro.org/people/jens.wiklander/linux-tee.git
> > > > > # in the linux directory
> > > > >
> > > > > To build do:
> > > > > cd build
> > > > > make toolchains
> > > > > make all
> > > > >
> > > > > To boot:
> > > > > make run-only
> > > > >
> > > > > Test with xtest, perhaps only with the command "xtest 1004" in case you're
> > > > > not interested in too many tests.
> > > >
> > > > Thanks Jens for sharing instructions to test this feature. So I tried
> > > > to reproduce using following repo versions:
> > > >
> > > > linux-tee, branch: optee_ffa_v3
> > > > trusted-firmware-a, branch: ffav4_sel1_spmc
> > > > build, branch: ffav4_spmc
> > > >
> > > > and rest of the repos synced to the latest version as per upstream
> > > > qemu_v8.xml [1] but I don't see OP-TEE driver being probed during boot
> > > > [2]. Am I missing something?
> > > >
> > > > [1] https://github.com/OP-TEE/manifest/blob/master/qemu_v8.xml
> > > > [2]
> > > > Welcome to Buildroot, type root or test to login
> > > > buildroot login: root
> > > > # dmesg | grep optee
> > > >
> > >
> > > Do you see ARM FF-A driver initialised successfully ?
> > > You must see "ARM FF-A Version 1.0 found" or something similar based on
> > > the actual version supported.
> > >
> > > If so, can you check if the partitions are correctly populated by
> > > the driver using the discover API.
> > >
> > > $ grep "" /sys/bus/arm_ffa/devices/*/uuid
> > >
> > > If uuid reads zeros, then the devices are populated, just the matching
> > > driver is not found(due to the workaround for v1.0 spec)
> > >
> >
> > It turns out to be an issue with my build environment, I re-built from
> > scratch and I could see OP-TEE being probed successfully:
> >
> > # dmesg | grep FF-A
> > [ 0.356382] ARM FF-A: Version 1.0 found
> > #
> > # cat /sys/bus/arm_ffa/devices/arm-ffa-8001/uuid
> > 486178e0-e7f8-11e3-bc5e-0002a5d5c51b
> > #
> > # dmesg | grep optee
> > [ 4.991472] optee: revision 3.14 (49dbb9ef)
> > [ 5.010110] optee: initialized driver
> > #
>
> That's good.
>
> > From xtest logs it looks like the pseudo TA interface isn't working for me:
> >
> > * regression_1001 Core self tests
> > - 1001 - skip test, pseudo TA not found
> > regression_1001 OK
> >
> > * regression_1002 PTA parameters
> > - 1002 - skip test, pseudo TA not found
> > regression_1002 OK
> >
> > * regression_1003 Core internal read/write mutex
> > - 1003 - skip test, pseudo TA not found
> > regression_1003 OK
>
> The test PTAs are disabled by default.
>

Ah, I missed the CFG_ENABLE_EMBEDDED_TESTS option in OP-TEE. BTW, I
think it should be enabled for OP-TEE Qemu build as we mostly use it
as a test platform.

> >
> > Similarly, pseudo TAs acting as TEE bus devices doesn't work as well
> > as I see following devices directory being empty:
> >
> > # ls /sys/bus/tee/devices/
> > #
> >
> > As otherwise with OP-TEE SMC ABI, we should have at least the default
> > pseudo TA [1] kernel device there.
> >
> > So is pseudo TA functional with this new FF-A interface?
>
> Yes, everything is supposed to work.
>

So yes, xtest and TEE kernel bus framework works for me as well with
this new FF-A interface. FWIW:

Tested-by: Sumit Garg <[email protected]>

-Sumit

> Cheers,
> Jens

2021-07-28 06:42:08

by Jens Wiklander

[permalink] [raw]
Subject: Re: [PATCH v3 0/5] Add FF-A support in OP-TEE driver

On Tue, Jul 27, 2021 at 8:13 AM Sumit Garg <[email protected]> wrote:
>
> On Mon, 26 Jul 2021 at 20:55, Jens Wiklander <[email protected]> wrote:
> >
> > Hi Sumit,
> >
> > On Mon, Jul 26, 2021 at 1:41 PM Sumit Garg <[email protected]> wrote:
> > >
> > > On Mon, 26 Jul 2021 at 16:25, Sudeep Holla <[email protected]> wrote:
> > > >
> > > > On Mon, Jul 26, 2021 at 03:59:36PM +0530, Sumit Garg wrote:
> > > > > Hi Jens,
> > > > >
> > > > > On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
> > > > > >
> > > > > > Hi all,
> > > > > >
> > > > > > This adds supports for the OP-TEE driver to communicate with secure world
> > > > > > using FF-A [1] as transport.
> > > > > >
> > > > > > There is one change to the TEE subsystem with "tee: add sec_world_id to
> > > > > > struct tee_shm" to add support for holding globally unique handle assigned
> > > > > > by the FF-A. This is a field that I believe could useful for the AMDTEE
> > > > > > driver too.
> > > > > >
> > > > > > For communication the OP-TEE message protocol is still used, but with a new
> > > > > > type of memory reference, struct optee_msg_param_fmem, to carry the
> > > > > > information needed by FF-A. The OP-TEE driver is refactored internally with
> > > > > > to sets of callbacks, one for the old SMC based communication and another
> > > > > > set with FF-A as transport. The functions relating to the SMC based ABI
> > > > > > are moved to smc_abi.c while the FF-A based ABI is added in a ffa_abi.c.
> > > > > >
> > > > > > There is also a difference in how the drivers are instantiated. With the
> > > > > > SMC based transport we have a platform driver, module_platform_driver(),
> > > > > > today which we're keeping as is for this configuration. In a FF-A system we
> > > > > > have a FF-A driver, module_ffa_driver(), instead.
> > > > > >
> > > > > > The OP-TEE driver can be compiled for both targets at the same time and
> > > > > > it's up to runtime configuration (device tree or ACPI) to decide how it's
> > > > > > initialized. Note that it's only the old SMC based driver instance that
> > > > > > need device tree or ACPI to initialize. The FF-A based driver relies on the
> > > > > > FF-A bus instead.
> > > > > >
> > > > > > This can be tested QEMU
> > > > > > The repo for SPMC at S-EL1 retrieved by
> > > > > > repo init -u https://github.com/jenswi-linaro/manifest.git -m
> > > > > > qemu_v8.xml -b ffav4_spmc
> > > > > > repo sync
> > > > > > # Then checkout the branch optee_ffa_v3 from
> > > > > > # git://git.linaro.org/people/jens.wiklander/linux-tee.git
> > > > > > # in the linux directory
> > > > > >
> > > > > > To build do:
> > > > > > cd build
> > > > > > make toolchains
> > > > > > make all
> > > > > >
> > > > > > To boot:
> > > > > > make run-only
> > > > > >
> > > > > > Test with xtest, perhaps only with the command "xtest 1004" in case you're
> > > > > > not interested in too many tests.
> > > > >
> > > > > Thanks Jens for sharing instructions to test this feature. So I tried
> > > > > to reproduce using following repo versions:
> > > > >
> > > > > linux-tee, branch: optee_ffa_v3
> > > > > trusted-firmware-a, branch: ffav4_sel1_spmc
> > > > > build, branch: ffav4_spmc
> > > > >
> > > > > and rest of the repos synced to the latest version as per upstream
> > > > > qemu_v8.xml [1] but I don't see OP-TEE driver being probed during boot
> > > > > [2]. Am I missing something?
> > > > >
> > > > > [1] https://github.com/OP-TEE/manifest/blob/master/qemu_v8.xml
> > > > > [2]
> > > > > Welcome to Buildroot, type root or test to login
> > > > > buildroot login: root
> > > > > # dmesg | grep optee
> > > > >
> > > >
> > > > Do you see ARM FF-A driver initialised successfully ?
> > > > You must see "ARM FF-A Version 1.0 found" or something similar based on
> > > > the actual version supported.
> > > >
> > > > If so, can you check if the partitions are correctly populated by
> > > > the driver using the discover API.
> > > >
> > > > $ grep "" /sys/bus/arm_ffa/devices/*/uuid
> > > >
> > > > If uuid reads zeros, then the devices are populated, just the matching
> > > > driver is not found(due to the workaround for v1.0 spec)
> > > >
> > >
> > > It turns out to be an issue with my build environment, I re-built from
> > > scratch and I could see OP-TEE being probed successfully:
> > >
> > > # dmesg | grep FF-A
> > > [ 0.356382] ARM FF-A: Version 1.0 found
> > > #
> > > # cat /sys/bus/arm_ffa/devices/arm-ffa-8001/uuid
> > > 486178e0-e7f8-11e3-bc5e-0002a5d5c51b
> > > #
> > > # dmesg | grep optee
> > > [ 4.991472] optee: revision 3.14 (49dbb9ef)
> > > [ 5.010110] optee: initialized driver
> > > #
> >
> > That's good.
> >
> > > From xtest logs it looks like the pseudo TA interface isn't working for me:
> > >
> > > * regression_1001 Core self tests
> > > - 1001 - skip test, pseudo TA not found
> > > regression_1001 OK
> > >
> > > * regression_1002 PTA parameters
> > > - 1002 - skip test, pseudo TA not found
> > > regression_1002 OK
> > >
> > > * regression_1003 Core internal read/write mutex
> > > - 1003 - skip test, pseudo TA not found
> > > regression_1003 OK
> >
> > The test PTAs are disabled by default.
> >
>
> Ah, I missed the CFG_ENABLE_EMBEDDED_TESTS option in OP-TEE. BTW, I
> think it should be enabled for OP-TEE Qemu build as we mostly use it
> as a test platform.

That makes sense. Perhaps in the build git?

>
> > >
> > > Similarly, pseudo TAs acting as TEE bus devices doesn't work as well
> > > as I see following devices directory being empty:
> > >
> > > # ls /sys/bus/tee/devices/
> > > #
> > >
> > > As otherwise with OP-TEE SMC ABI, we should have at least the default
> > > pseudo TA [1] kernel device there.
> > >
> > > So is pseudo TA functional with this new FF-A interface?
> >
> > Yes, everything is supposed to work.
> >
>
> So yes, xtest and TEE kernel bus framework works for me as well with
> this new FF-A interface. FWIW:
>
> Tested-by: Sumit Garg <[email protected]>

Thanks for confirming.

Cheers,
Jens

2021-07-28 08:45:38

by Sumit Garg

[permalink] [raw]
Subject: Re: [PATCH v3 1/5] tee: add sec_world_id to struct tee_shm

On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
>
> Adds sec_world_id to struct tee_shm which describes a shared memory
> object. sec_world_id can be used by a driver to store an id assigned by
> secure world.
>
> Signed-off-by: Jens Wiklander <[email protected]>
> ---
> include/linux/tee_drv.h | 7 ++++++-
> 1 file changed, 6 insertions(+), 1 deletion(-)
>

Reviewed-by: Sumit Garg <[email protected]>

-Sumit

> diff --git a/include/linux/tee_drv.h b/include/linux/tee_drv.h
> index 54269e47ac9a..1a29f0e66e13 100644
> --- a/include/linux/tee_drv.h
> +++ b/include/linux/tee_drv.h
> @@ -196,7 +196,11 @@ int tee_session_calc_client_uuid(uuid_t *uuid, u32 connection_method,
> * @num_pages: number of locked pages
> * @dmabuf: dmabuf used to for exporting to user space
> * @flags: defined by TEE_SHM_* in tee_drv.h
> - * @id: unique id of a shared memory object on this device
> + * @id: unique id of a shared memory object on this device, shared
> + * with user space
> + * @sec_world_id:
> + * secure world assigned id of this shared memory object, not
> + * used by all drivers
> *
> * This pool is only supposed to be accessed directly from the TEE
> * subsystem and from drivers that implements their own shm pool manager.
> @@ -212,6 +216,7 @@ struct tee_shm {
> struct dma_buf *dmabuf;
> u32 flags;
> int id;
> + u64 sec_world_id;
> };
>
> /**
> --
> 2.31.1
>

2021-07-28 08:46:59

by Sumit Garg

[permalink] [raw]
Subject: Re: [PATCH v3 2/5] optee: simplify optee_release()

On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
>
> Simplifies optee_release() with a new helper function,
> optee_close_session_helper() which has been factored out from
> optee_close_session().
>

Simplification looks good to me.

> A separate optee_release_supp() is added for the supplicant device.
>

On similar terms, can we have separate optee_open_supp() for better
understanding?

-Sumit

> Signed-off-by: Jens Wiklander <[email protected]>
> ---
> drivers/tee/optee/call.c | 31 ++++++++++-------
> drivers/tee/optee/core.c | 55 +++++++++++--------------------
> drivers/tee/optee/optee_private.h | 1 +
> 3 files changed, 39 insertions(+), 48 deletions(-)
>
> diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c
> index 6e6eb836e9b6..9d8f5a95e42f 100644
> --- a/drivers/tee/optee/call.c
> +++ b/drivers/tee/optee/call.c
> @@ -288,12 +288,28 @@ int optee_open_session(struct tee_context *ctx,
> return rc;
> }
>
> -int optee_close_session(struct tee_context *ctx, u32 session)
> +int optee_close_session_helper(struct tee_context *ctx, u32 session)
> {
> - struct optee_context_data *ctxdata = ctx->data;
> struct tee_shm *shm;
> struct optee_msg_arg *msg_arg;
> phys_addr_t msg_parg;
> +
> + shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
> + if (IS_ERR(shm))
> + return PTR_ERR(shm);
> +
> + msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
> + msg_arg->session = session;
> + optee_do_call_with_arg(ctx, msg_parg);
> +
> + tee_shm_free(shm);
> +
> + return 0;
> +}
> +
> +int optee_close_session(struct tee_context *ctx, u32 session)
> +{
> + struct optee_context_data *ctxdata = ctx->data;
> struct optee_session *sess;
>
> /* Check that the session is valid and remove it from the list */
> @@ -306,16 +322,7 @@ int optee_close_session(struct tee_context *ctx, u32 session)
> return -EINVAL;
> kfree(sess);
>
> - shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
> - if (IS_ERR(shm))
> - return PTR_ERR(shm);
> -
> - msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
> - msg_arg->session = session;
> - optee_do_call_with_arg(ctx, msg_parg);
> -
> - tee_shm_free(shm);
> - return 0;
> + return optee_close_session_helper(ctx, session);
> }
>
> int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c
> index ddb8f9ecf307..949223b214c3 100644
> --- a/drivers/tee/optee/core.c
> +++ b/drivers/tee/optee/core.c
> @@ -263,59 +263,42 @@ static int optee_open(struct tee_context *ctx)
> return 0;
> }
>
> -static void optee_release(struct tee_context *ctx)
> +static void optee_release_helper(struct tee_context *ctx,
> + int (*close_session)(struct tee_context *ctx,
> + u32 session))
> {
> struct optee_context_data *ctxdata = ctx->data;
> - struct tee_device *teedev = ctx->teedev;
> - struct optee *optee = tee_get_drvdata(teedev);
> - struct tee_shm *shm;
> - struct optee_msg_arg *arg = NULL;
> - phys_addr_t parg;
> struct optee_session *sess;
> struct optee_session *sess_tmp;
>
> if (!ctxdata)
> return;
>
> - shm = tee_shm_alloc(ctx, sizeof(struct optee_msg_arg), TEE_SHM_MAPPED);
> - if (!IS_ERR(shm)) {
> - arg = tee_shm_get_va(shm, 0);
> - /*
> - * If va2pa fails for some reason, we can't call into
> - * secure world, only free the memory. Secure OS will leak
> - * sessions and finally refuse more sessions, but we will
> - * at least let normal world reclaim its memory.
> - */
> - if (!IS_ERR(arg))
> - if (tee_shm_va2pa(shm, arg, &parg))
> - arg = NULL; /* prevent usage of parg below */
> - }
> -
> list_for_each_entry_safe(sess, sess_tmp, &ctxdata->sess_list,
> list_node) {
> list_del(&sess->list_node);
> - if (!IS_ERR_OR_NULL(arg)) {
> - memset(arg, 0, sizeof(*arg));
> - arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
> - arg->session = sess->session_id;
> - optee_do_call_with_arg(ctx, parg);
> - }
> + close_session(ctx, sess->session_id);
> kfree(sess);
> }
> kfree(ctxdata);
> + ctx->data = NULL;
> +}
>
> - if (!IS_ERR(shm))
> - tee_shm_free(shm);
> +static void optee_release(struct tee_context *ctx)
> +{
> + optee_release_helper(ctx, optee_close_session_helper);
> +}
>
> - ctx->data = NULL;
> +static void optee_release_supp(struct tee_context *ctx)
> +{
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
>
> - if (teedev == optee->supp_teedev) {
> - if (optee->scan_bus_wq) {
> - destroy_workqueue(optee->scan_bus_wq);
> - optee->scan_bus_wq = NULL;
> - }
> - optee_supp_release(&optee->supp);
> + optee_release_helper(ctx, optee_close_session_helper);
> + if (optee->scan_bus_wq) {
> + destroy_workqueue(optee->scan_bus_wq);
> + optee->scan_bus_wq = NULL;
> }
> + optee_supp_release(&optee->supp);
> }
>
> static const struct tee_driver_ops optee_ops = {
> @@ -339,7 +322,7 @@ static const struct tee_desc optee_desc = {
> static const struct tee_driver_ops optee_supp_ops = {
> .get_version = optee_get_version,
> .open = optee_open,
> - .release = optee_release,
> + .release = optee_release_supp,
> .supp_recv = optee_supp_recv,
> .supp_send = optee_supp_send,
> .shm_register = optee_shm_register_supp,
> diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h
> index e25b216a14ef..2b63b796645e 100644
> --- a/drivers/tee/optee/optee_private.h
> +++ b/drivers/tee/optee/optee_private.h
> @@ -152,6 +152,7 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg);
> int optee_open_session(struct tee_context *ctx,
> struct tee_ioctl_open_session_arg *arg,
> struct tee_param *param);
> +int optee_close_session_helper(struct tee_context *ctx, u32 session);
> int optee_close_session(struct tee_context *ctx, u32 session);
> int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> struct tee_param *param);
> --
> 2.31.1
>

2021-07-28 10:00:40

by Sumit Garg

[permalink] [raw]
Subject: Re: [PATCH v3 3/5] optee: refactor driver with internal callbacks

On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
>
> The OP-TEE driver is refactored with three internal callbacks replacing
> direct calls to optee_from_msg_param(), optee_to_msg_param() and
> optee_do_call_with_arg().
>
> These functions a central to communicating with OP-TEE in secure world
> by using the SMC Calling Convention directly.
>
> This refactoring makes room for using other primitives to communicate
> with OP-TEE in secure world while being able to reuse as much as
> possible from the present driver.
>
> Signed-off-by: Jens Wiklander <[email protected]>
> ---
> drivers/tee/optee/call.c | 86 +++++++++--------
> drivers/tee/optee/core.c | 148 ++++++++++++++++++++----------
> drivers/tee/optee/optee_private.h | 35 +++++--
> drivers/tee/optee/rpc.c | 19 ++--
> 4 files changed, 182 insertions(+), 106 deletions(-)
>
> diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c
> index 9d8f5a95e42f..00ecd794e59a 100644
> --- a/drivers/tee/optee/call.c
> +++ b/drivers/tee/optee/call.c
> @@ -1,6 +1,6 @@
> // SPDX-License-Identifier: GPL-2.0-only
> /*
> - * Copyright (c) 2015, Linaro Limited
> + * Copyright (c) 2015-2021, Linaro Limited
> */
> #include <linux/arm-smccc.h>
> #include <linux/device.h>
> @@ -118,20 +118,25 @@ static struct optee_session *find_session(struct optee_context_data *ctxdata,
> /**
> * optee_do_call_with_arg() - Do an SMC to OP-TEE in secure world
> * @ctx: calling context
> - * @parg: physical address of message to pass to secure world
> + * @arg: shared memory holding the message to pass to secure world
> *
> * Does and SMC to OP-TEE in secure world and handles eventual resulting
> * Remote Procedure Calls (RPC) from OP-TEE.
> *
> * Returns return code from secure world, 0 is OK
> */
> -u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
> +int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg)
> {
> struct optee *optee = tee_get_drvdata(ctx->teedev);
> struct optee_call_waiter w;
> struct optee_rpc_param param = { };
> struct optee_call_ctx call_ctx = { };
> - u32 ret;
> + phys_addr_t parg;
> + int rc;
> +
> + rc = tee_shm_get_pa(arg, 0, &parg);
> + if (rc)
> + return rc;
>
> param.a0 = OPTEE_SMC_CALL_WITH_ARG;
> reg_pair_from_64(&param.a1, &param.a2, parg);
> @@ -160,7 +165,7 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
> param.a3 = res.a3;
> optee_handle_rpc(ctx, &param, &call_ctx);
> } else {
> - ret = res.a0;
> + rc = res.a0;
> break;
> }
> }
> @@ -172,14 +177,12 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
> */
> optee_cq_wait_final(&optee->call_queue, &w);
>
> - return ret;
> + return rc;
> }
>
> static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,
> - struct optee_msg_arg **msg_arg,
> - phys_addr_t *msg_parg)
> + struct optee_msg_arg **msg_arg)
> {
> - int rc;
> struct tee_shm *shm;
> struct optee_msg_arg *ma;
>
> @@ -190,22 +193,13 @@ static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,
>
> ma = tee_shm_get_va(shm, 0);
> if (IS_ERR(ma)) {
> - rc = PTR_ERR(ma);
> - goto out;
> + tee_shm_free(shm);
> + return (void *)ma;
> }
>
> - rc = tee_shm_get_pa(shm, 0, msg_parg);
> - if (rc)
> - goto out;
> -
> memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params));
> ma->num_params = num_params;
> *msg_arg = ma;
> -out:
> - if (rc) {
> - tee_shm_free(shm);
> - return ERR_PTR(rc);
> - }
>
> return shm;
> }
> @@ -214,16 +208,16 @@ int optee_open_session(struct tee_context *ctx,
> struct tee_ioctl_open_session_arg *arg,
> struct tee_param *param)
> {
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
> struct optee_context_data *ctxdata = ctx->data;
> int rc;
> struct tee_shm *shm;
> struct optee_msg_arg *msg_arg;
> - phys_addr_t msg_parg;
> struct optee_session *sess = NULL;
> uuid_t client_uuid;
>
> /* +2 for the meta parameters added below */
> - shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg, &msg_parg);
> + shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg);
> if (IS_ERR(shm))
> return PTR_ERR(shm);
>
> @@ -247,7 +241,8 @@ int optee_open_session(struct tee_context *ctx,
> goto out;
> export_uuid(msg_arg->params[1].u.octets, &client_uuid);
>
> - rc = optee_to_msg_param(msg_arg->params + 2, arg->num_params, param);
> + rc = optee->ops->to_msg_param(optee, msg_arg->params + 2,
> + arg->num_params, param);
> if (rc)
> goto out;
>
> @@ -257,7 +252,7 @@ int optee_open_session(struct tee_context *ctx,
> goto out;
> }
>
> - if (optee_do_call_with_arg(ctx, msg_parg)) {
> + if (optee->ops->do_call_with_arg(ctx, shm)) {
> msg_arg->ret = TEEC_ERROR_COMMUNICATION;
> msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
> }
> @@ -272,7 +267,8 @@ int optee_open_session(struct tee_context *ctx,
> kfree(sess);
> }
>
> - if (optee_from_msg_param(param, arg->num_params, msg_arg->params + 2)) {
> + if (optee->ops->from_msg_param(optee, param, arg->num_params,
> + msg_arg->params + 2)) {
> arg->ret = TEEC_ERROR_COMMUNICATION;
> arg->ret_origin = TEEC_ORIGIN_COMMS;
> /* Close session again to avoid leakage */
> @@ -291,16 +287,16 @@ int optee_open_session(struct tee_context *ctx,
> int optee_close_session_helper(struct tee_context *ctx, u32 session)
> {
> struct tee_shm *shm;
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
> struct optee_msg_arg *msg_arg;
> - phys_addr_t msg_parg;
>
> - shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
> + shm = get_msg_arg(ctx, 0, &msg_arg);
> if (IS_ERR(shm))
> return PTR_ERR(shm);
>
> msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
> msg_arg->session = session;
> - optee_do_call_with_arg(ctx, msg_parg);
> + optee->ops->do_call_with_arg(ctx, shm);
>
> tee_shm_free(shm);
>
> @@ -328,10 +324,10 @@ int optee_close_session(struct tee_context *ctx, u32 session)
> int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> struct tee_param *param)
> {
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
> struct optee_context_data *ctxdata = ctx->data;
> struct tee_shm *shm;
> struct optee_msg_arg *msg_arg;
> - phys_addr_t msg_parg;
> struct optee_session *sess;
> int rc;
>
> @@ -342,7 +338,7 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> if (!sess)
> return -EINVAL;
>
> - shm = get_msg_arg(ctx, arg->num_params, &msg_arg, &msg_parg);
> + shm = get_msg_arg(ctx, arg->num_params, &msg_arg);
> if (IS_ERR(shm))
> return PTR_ERR(shm);
> msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND;
> @@ -350,16 +346,18 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> msg_arg->session = arg->session;
> msg_arg->cancel_id = arg->cancel_id;
>
> - rc = optee_to_msg_param(msg_arg->params, arg->num_params, param);
> + rc = optee->ops->to_msg_param(optee, msg_arg->params, arg->num_params,
> + param);
> if (rc)
> goto out;
>
> - if (optee_do_call_with_arg(ctx, msg_parg)) {
> + if (optee->ops->do_call_with_arg(ctx, shm)) {
> msg_arg->ret = TEEC_ERROR_COMMUNICATION;
> msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
> }
>
> - if (optee_from_msg_param(param, arg->num_params, msg_arg->params)) {
> + if (optee->ops->from_msg_param(optee, param, arg->num_params,
> + msg_arg->params)) {
> msg_arg->ret = TEEC_ERROR_COMMUNICATION;
> msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
> }
> @@ -373,10 +371,10 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
>
> int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
> {
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
> struct optee_context_data *ctxdata = ctx->data;
> struct tee_shm *shm;
> struct optee_msg_arg *msg_arg;
> - phys_addr_t msg_parg;
> struct optee_session *sess;
>
> /* Check that the session is valid */
> @@ -386,14 +384,14 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
> if (!sess)
> return -EINVAL;
>
> - shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
> + shm = get_msg_arg(ctx, 0, &msg_arg);
> if (IS_ERR(shm))
> return PTR_ERR(shm);
>
> msg_arg->cmd = OPTEE_MSG_CMD_CANCEL;
> msg_arg->session = session;
> msg_arg->cancel_id = cancel_id;
> - optee_do_call_with_arg(ctx, msg_parg);
> + optee->ops->do_call_with_arg(ctx, shm);
>
> tee_shm_free(shm);
> return 0;
> @@ -592,10 +590,10 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> struct page **pages, size_t num_pages,
> unsigned long start)
> {
> - struct tee_shm *shm_arg = NULL;
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
> struct optee_msg_arg *msg_arg;
> + struct tee_shm *shm_arg;
> u64 *pages_list;
> - phys_addr_t msg_parg;
> int rc;
>
> if (!num_pages)
> @@ -609,7 +607,7 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> if (!pages_list)
> return -ENOMEM;
>
> - shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
> + shm_arg = get_msg_arg(ctx, 1, &msg_arg);
> if (IS_ERR(shm_arg)) {
> rc = PTR_ERR(shm_arg);
> goto out;
> @@ -630,7 +628,7 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> msg_arg->params->u.tmem.buf_ptr = virt_to_phys(pages_list) |
> (tee_shm_get_page_offset(shm) & (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
>
> - if (optee_do_call_with_arg(ctx, msg_parg) ||
> + if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> msg_arg->ret != TEEC_SUCCESS)
> rc = -EINVAL;
>
> @@ -642,12 +640,12 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
>
> int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
> {
> - struct tee_shm *shm_arg;
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
> struct optee_msg_arg *msg_arg;
> - phys_addr_t msg_parg;
> + struct tee_shm *shm_arg;
> int rc = 0;
>
> - shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
> + shm_arg = get_msg_arg(ctx, 1, &msg_arg);
> if (IS_ERR(shm_arg))
> return PTR_ERR(shm_arg);
>
> @@ -656,7 +654,7 @@ int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
> msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> msg_arg->params[0].u.rmem.shm_ref = (unsigned long)shm;
>
> - if (optee_do_call_with_arg(ctx, msg_parg) ||
> + if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> msg_arg->ret != TEEC_SUCCESS)
> rc = -EINVAL;
> tee_shm_free(shm_arg);
> diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c
> index 949223b214c3..f689f171a794 100644
> --- a/drivers/tee/optee/core.c
> +++ b/drivers/tee/optee/core.c
> @@ -1,6 +1,6 @@
> // SPDX-License-Identifier: GPL-2.0-only
> /*
> - * Copyright (c) 2015, Linaro Limited
> + * Copyright (c) 2015-2021, Linaro Limited
> */
>
> #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
> @@ -26,21 +26,87 @@
>
> #define OPTEE_SHM_NUM_PRIV_PAGES CONFIG_OPTEE_SHM_NUM_PRIV_PAGES
>
> +static void from_msg_param_value(struct tee_param *p, u32 attr,
> + const struct optee_msg_param *mp)
> +{
> + p->attr = TEE_IOCTL_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;
> +}
> +
> +static int from_msg_param_tmp_mem(struct tee_param *p, u32 attr,
> + const struct optee_msg_param *mp)
> +{
> + struct tee_shm *shm;
> + phys_addr_t pa;
> + int rc;
> +
> + p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> + attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
> + p->u.memref.size = mp->u.tmem.size;
> + shm = (struct tee_shm *)(unsigned long)mp->u.tmem.shm_ref;
> + if (!shm) {
> + p->u.memref.shm_offs = 0;
> + p->u.memref.shm = NULL;
> + return 0;
> + }
> +
> + rc = tee_shm_get_pa(shm, 0, &pa);
> + if (rc)
> + return rc;
> +
> + p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
> + p->u.memref.shm = shm;
> +
> + /* Check that the memref is covered by the shm object */
> + if (p->u.memref.size) {
> + size_t o = p->u.memref.shm_offs +
> + p->u.memref.size - 1;
> +
> + rc = tee_shm_get_pa(shm, o, NULL);
> + if (rc)
> + return rc;
> + }
> +
> + return 0;
> +}
> +
> +static void from_msg_param_reg_mem(struct tee_param *p, u32 attr,
> + const struct optee_msg_param *mp)
> +{
> + struct tee_shm *shm;
> +
> + p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> + attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> + p->u.memref.size = mp->u.rmem.size;
> + shm = (struct tee_shm *)(unsigned long)mp->u.rmem.shm_ref;
> +
> + if (shm) {
> + p->u.memref.shm_offs = mp->u.rmem.offs;
> + p->u.memref.shm = shm;
> + } else {
> + p->u.memref.shm_offs = 0;
> + p->u.memref.shm = NULL;
> + }
> +}
> +
> /**
> * optee_from_msg_param() - convert from OPTEE_MSG parameters to
> * struct tee_param
> + * @optee: main service struct

I don't see this new argument being used. Can you throw some light on
the use-case for this additional argument?

> * @params: subsystem internal parameter representation
> * @num_params: number of elements in the parameter arrays
> * @msg_params: OPTEE_MSG parameters
> * Returns 0 on success or <0 on failure
> */
> -int optee_from_msg_param(struct tee_param *params, size_t num_params,
> - const struct optee_msg_param *msg_params)
> +static int optee_from_msg_param(struct optee *optee, struct tee_param *params,
> + size_t num_params,
> + const struct optee_msg_param *msg_params)
> {
> int rc;
> size_t n;
> - struct tee_shm *shm;
> - phys_addr_t pa;
>
> for (n = 0; n < num_params; n++) {
> struct tee_param *p = params + n;
> @@ -55,48 +121,19 @@ int optee_from_msg_param(struct tee_param *params, size_t num_params,
> case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT:
> case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:
> case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:
> - p->attr = TEE_IOCTL_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;
> + from_msg_param_value(p, attr, mp);
> break;
> case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:
> case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
> case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
> - p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> - attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
> - p->u.memref.size = mp->u.tmem.size;
> - shm = (struct tee_shm *)(unsigned long)
> - mp->u.tmem.shm_ref;
> - if (!shm) {
> - p->u.memref.shm_offs = 0;
> - p->u.memref.shm = NULL;
> - break;
> - }
> - rc = tee_shm_get_pa(shm, 0, &pa);
> + rc = from_msg_param_tmp_mem(p, attr, mp);
> if (rc)
> return rc;
> - p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
> - p->u.memref.shm = shm;
> 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_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> - attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> - p->u.memref.size = mp->u.rmem.size;
> - shm = (struct tee_shm *)(unsigned long)
> - 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;
> -
> + from_msg_param_reg_mem(p, attr, mp);
> break;
>
> default:
> @@ -106,6 +143,16 @@ int optee_from_msg_param(struct tee_param *params, size_t num_params,
> return 0;
> }
>
> +static void to_msg_param_value(struct optee_msg_param *mp,
> + const struct tee_param *p)
> +{
> + mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
> + TEE_IOCTL_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;
> +}
> +
> static int to_msg_param_tmp_mem(struct optee_msg_param *mp,
> const struct tee_param *p)
> {
> @@ -148,13 +195,15 @@ static int to_msg_param_reg_mem(struct optee_msg_param *mp,
>
> /**
> * optee_to_msg_param() - convert from struct tee_params to OPTEE_MSG parameters
> + * @optee: main service struct

Same here.

-Sumit

> * @msg_params: OPTEE_MSG parameters
> * @num_params: number of elements in the parameter arrays
> * @params: subsystem itnernal parameter representation
> * Returns 0 on success or <0 on failure
> */
> -int optee_to_msg_param(struct optee_msg_param *msg_params, size_t num_params,
> - const struct tee_param *params)
> +static int optee_to_msg_param(struct optee *optee,
> + struct optee_msg_param *msg_params,
> + size_t num_params, const struct tee_param *params)
> {
> int rc;
> size_t n;
> @@ -171,11 +220,7 @@ int optee_to_msg_param(struct optee_msg_param *msg_params, size_t num_params,
> case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT:
> case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
> case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
> - mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
> - TEE_IOCTL_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;
> + to_msg_param_value(mp, p);
> break;
> case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT:
> case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
> @@ -301,7 +346,7 @@ static void optee_release_supp(struct tee_context *ctx)
> optee_supp_release(&optee->supp);
> }
>
> -static const struct tee_driver_ops optee_ops = {
> +static const struct tee_driver_ops optee_clnt_ops = {
> .get_version = optee_get_version,
> .open = optee_open,
> .release = optee_release,
> @@ -313,9 +358,9 @@ static const struct tee_driver_ops optee_ops = {
> .shm_unregister = optee_shm_unregister,
> };
>
> -static const struct tee_desc optee_desc = {
> +static const struct tee_desc optee_clnt_desc = {
> .name = DRIVER_NAME "-clnt",
> - .ops = &optee_ops,
> + .ops = &optee_clnt_ops,
> .owner = THIS_MODULE,
> };
>
> @@ -336,6 +381,12 @@ static const struct tee_desc optee_supp_desc = {
> .flags = TEE_DESC_PRIVILEGED,
> };
>
> +static const struct optee_ops optee_ops = {
> + .do_call_with_arg = optee_do_call_with_arg,
> + .to_msg_param = optee_to_msg_param,
> + .from_msg_param = optee_from_msg_param,
> +};
> +
> static bool optee_msg_api_uid_is_optee_api(optee_invoke_fn *invoke_fn)
> {
> struct arm_smccc_res res;
> @@ -637,10 +688,11 @@ static int optee_probe(struct platform_device *pdev)
> goto err;
> }
>
> + optee->ops = &optee_ops;
> optee->invoke_fn = invoke_fn;
> optee->sec_caps = sec_caps;
>
> - teedev = tee_device_alloc(&optee_desc, NULL, pool, optee);
> + teedev = tee_device_alloc(&optee_clnt_desc, NULL, pool, optee);
> if (IS_ERR(teedev)) {
> rc = PTR_ERR(teedev);
> goto err;
> diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h
> index 2b63b796645e..c5741e96e967 100644
> --- a/drivers/tee/optee/optee_private.h
> +++ b/drivers/tee/optee/optee_private.h
> @@ -1,6 +1,6 @@
> /* SPDX-License-Identifier: GPL-2.0-only */
> /*
> - * Copyright (c) 2015, Linaro Limited
> + * Copyright (c) 2015-2021, Linaro Limited
> */
>
> #ifndef OPTEE_PRIVATE_H
> @@ -66,9 +66,34 @@ struct optee_supp {
> struct completion reqs_c;
> };
>
> +struct optee;
> +
> +/**
> + * struct optee_ops - OP-TEE driver internal operations
> + * @do_call_with_arg: enters OP-TEE in secure world
> + * @to_msg_param: converts from struct tee_param to OPTEE_MSG parameters
> + * @from_msg_param: converts from OPTEE_MSG parameters to struct tee_param
> + *
> + * These OPs are only supposed to be used internally in the OP-TEE driver
> + * as a way of abstracting the different methogs of entering OP-TEE in
> + * secure world.
> + */
> +struct optee_ops {
> + int (*do_call_with_arg)(struct tee_context *ctx,
> + struct tee_shm *shm_arg);
> + int (*to_msg_param)(struct optee *optee,
> + struct optee_msg_param *msg_params,
> + size_t num_params, const struct tee_param *params);
> + int (*from_msg_param)(struct optee *optee, struct tee_param *params,
> + size_t num_params,
> + const struct optee_msg_param *msg_params);
> +};
> +
> /**
> * struct optee - main service struct
> * @supp_teedev: supplicant device
> + * @ops: internal callbacks for different ways to reach secure
> + * world
> * @teedev: client device
> * @invoke_fn: function to issue smc or hvc
> * @call_queue: queue of threads waiting to call @invoke_fn
> @@ -86,6 +111,7 @@ struct optee_supp {
> struct optee {
> struct tee_device *supp_teedev;
> struct tee_device *teedev;
> + const struct optee_ops *ops;
> optee_invoke_fn *invoke_fn;
> struct optee_call_queue call_queue;
> struct optee_wait_queue wait_queue;
> @@ -148,7 +174,7 @@ int optee_supp_recv(struct tee_context *ctx, u32 *func, u32 *num_params,
> int optee_supp_send(struct tee_context *ctx, u32 ret, u32 num_params,
> struct tee_param *param);
>
> -u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg);
> +int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg);
> int optee_open_session(struct tee_context *ctx,
> struct tee_ioctl_open_session_arg *arg,
> struct tee_param *param);
> @@ -171,11 +197,6 @@ int optee_shm_register_supp(struct tee_context *ctx, struct tee_shm *shm,
> unsigned long start);
> int optee_shm_unregister_supp(struct tee_context *ctx, struct tee_shm *shm);
>
> -int optee_from_msg_param(struct tee_param *params, size_t num_params,
> - const struct optee_msg_param *msg_params);
> -int optee_to_msg_param(struct optee_msg_param *msg_params, size_t num_params,
> - const struct tee_param *params);
> -
> u64 *optee_allocate_pages_list(size_t num_entries);
> void optee_free_pages_list(void *array, size_t num_entries);
> void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,
> diff --git a/drivers/tee/optee/rpc.c b/drivers/tee/optee/rpc.c
> index 1849180b0278..39562fb6841e 100644
> --- a/drivers/tee/optee/rpc.c
> +++ b/drivers/tee/optee/rpc.c
> @@ -1,6 +1,6 @@
> // SPDX-License-Identifier: GPL-2.0-only
> /*
> - * Copyright (c) 2015-2016, Linaro Limited
> + * Copyright (c) 2015-2021, Linaro Limited
> */
>
> #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
> @@ -55,6 +55,7 @@ static void handle_rpc_func_cmd_get_time(struct optee_msg_arg *arg)
> static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> struct optee_msg_arg *arg)
> {
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
> struct tee_param *params;
> struct i2c_adapter *adapter;
> struct i2c_msg msg = { };
> @@ -79,7 +80,8 @@ static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> return;
> }
>
> - if (optee_from_msg_param(params, arg->num_params, arg->params))
> + if (optee->ops->from_msg_param(optee, params, arg->num_params,
> + arg->params))
> goto bad;
>
> for (i = 0; i < arg->num_params; i++) {
> @@ -122,7 +124,8 @@ static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> arg->ret = TEEC_ERROR_COMMUNICATION;
> } else {
> params[3].u.value.a = msg.len;
> - if (optee_to_msg_param(arg->params, arg->num_params, params))
> + if (optee->ops->to_msg_param(optee, arg->params,
> + arg->num_params, params))
> arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> else
> arg->ret = TEEC_SUCCESS;
> @@ -234,7 +237,7 @@ static void handle_rpc_func_cmd_wait(struct optee_msg_arg *arg)
> arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> }
>
> -static void handle_rpc_supp_cmd(struct tee_context *ctx,
> +static void handle_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
> struct optee_msg_arg *arg)
> {
> struct tee_param *params;
> @@ -248,14 +251,16 @@ static void handle_rpc_supp_cmd(struct tee_context *ctx,
> return;
> }
>
> - if (optee_from_msg_param(params, arg->num_params, arg->params)) {
> + if (optee->ops->from_msg_param(optee, params, arg->num_params,
> + arg->params)) {
> arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> goto out;
> }
>
> arg->ret = optee_supp_thrd_req(ctx, arg->cmd, arg->num_params, params);
>
> - if (optee_to_msg_param(arg->params, arg->num_params, params))
> + if (optee->ops->to_msg_param(optee, arg->params, arg->num_params,
> + params))
> arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> out:
> kfree(params);
> @@ -480,7 +485,7 @@ static void handle_rpc_func_cmd(struct tee_context *ctx, struct optee *optee,
> handle_rpc_func_cmd_i2c_transfer(ctx, arg);
> break;
> default:
> - handle_rpc_supp_cmd(ctx, arg);
> + handle_rpc_supp_cmd(ctx, optee, arg);
> }
> }
>
> --
> 2.31.1
>

2021-07-28 10:12:05

by Sumit Garg

[permalink] [raw]
Subject: Re: [PATCH v3 4/5] optee: isolate smc abi

On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
>
> Isolate the ABI based on raw SMCs. Code specific to the raw SMC ABI is
> moved into smc_abi.c. This makes room for other ABIs with a clear
> separation.
>
> This patch is not supposed to change the driver behavior, it's only a
> matter of reorganizing the code.
>
> Signed-off-by: Jens Wiklander <[email protected]>
> ---
> drivers/tee/optee/Makefile | 6 +-
> drivers/tee/optee/call.c | 339 +-------
> drivers/tee/optee/core.c | 684 +--------------
> drivers/tee/optee/optee_private.h | 104 ++-
> drivers/tee/optee/rpc.c | 255 +-----
> drivers/tee/optee/shm_pool.c | 89 --
> drivers/tee/optee/shm_pool.h | 14 -
> drivers/tee/optee/smc_abi.c | 1301 +++++++++++++++++++++++++++++
> 8 files changed, 1441 insertions(+), 1351 deletions(-)
> delete mode 100644 drivers/tee/optee/shm_pool.c
> delete mode 100644 drivers/tee/optee/shm_pool.h
> create mode 100644 drivers/tee/optee/smc_abi.c
>
> diff --git a/drivers/tee/optee/Makefile b/drivers/tee/optee/Makefile
> index 3aa33ea9e6a6..e92f77462f40 100644
> --- a/drivers/tee/optee/Makefile
> +++ b/drivers/tee/optee/Makefile
> @@ -4,8 +4,10 @@ optee-objs += core.o
> optee-objs += call.o
> optee-objs += rpc.o
> optee-objs += supp.o
> -optee-objs += shm_pool.o
> optee-objs += device.o
>
> +optee-smc-abi-y = smc_abi.o
> +optee-objs += $(optee-ffa-abi-y)
> +
> # for tracing framework to find optee_trace.h
> -CFLAGS_call.o := -I$(src)
> +CFLAGS_smc_abi.o := -I$(src)
> diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c
> index 00ecd794e59a..3f81c168ed3f 100644
> --- a/drivers/tee/optee/call.c
> +++ b/drivers/tee/optee/call.c
> @@ -2,28 +2,17 @@
> /*
> * Copyright (c) 2015-2021, Linaro Limited
> */
> -#include <linux/arm-smccc.h>
> #include <linux/device.h>
> #include <linux/err.h>
> #include <linux/errno.h>
> #include <linux/mm.h>
> -#include <linux/sched.h>
> #include <linux/slab.h>
> #include <linux/tee_drv.h>
> #include <linux/types.h>
> -#include <linux/uaccess.h>
> #include "optee_private.h"
> -#include "optee_smc.h"
> -#define CREATE_TRACE_POINTS
> -#include "optee_trace.h"
>
> -struct optee_call_waiter {
> - struct list_head list_node;
> - struct completion c;
> -};
> -
> -static void optee_cq_wait_init(struct optee_call_queue *cq,
> - struct optee_call_waiter *w)
> +void optee_cq_wait_init(struct optee_call_queue *cq,
> + struct optee_call_waiter *w)
> {
> /*
> * We're preparing to make a call to secure world. In case we can't
> @@ -47,8 +36,8 @@ static void optee_cq_wait_init(struct optee_call_queue *cq,
> mutex_unlock(&cq->mutex);
> }
>
> -static void optee_cq_wait_for_completion(struct optee_call_queue *cq,
> - struct optee_call_waiter *w)
> +void optee_cq_wait_for_completion(struct optee_call_queue *cq,
> + struct optee_call_waiter *w)
> {
> wait_for_completion(&w->c);
>
> @@ -74,8 +63,8 @@ static void optee_cq_complete_one(struct optee_call_queue *cq)
> }
> }
>
> -static void optee_cq_wait_final(struct optee_call_queue *cq,
> - struct optee_call_waiter *w)
> +void optee_cq_wait_final(struct optee_call_queue *cq,
> + struct optee_call_waiter *w)
> {
> /*
> * We're done with the call to secure world. The thread in secure
> @@ -115,73 +104,8 @@ static struct optee_session *find_session(struct optee_context_data *ctxdata,
> return NULL;
> }
>
> -/**
> - * optee_do_call_with_arg() - Do an SMC to OP-TEE in secure world
> - * @ctx: calling context
> - * @arg: shared memory holding the message to pass to secure world
> - *
> - * Does and SMC to OP-TEE in secure world and handles eventual resulting
> - * Remote Procedure Calls (RPC) from OP-TEE.
> - *
> - * Returns return code from secure world, 0 is OK
> - */
> -int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg)
> -{
> - struct optee *optee = tee_get_drvdata(ctx->teedev);
> - struct optee_call_waiter w;
> - struct optee_rpc_param param = { };
> - struct optee_call_ctx call_ctx = { };
> - phys_addr_t parg;
> - int rc;
> -
> - rc = tee_shm_get_pa(arg, 0, &parg);
> - if (rc)
> - return rc;
> -
> - param.a0 = OPTEE_SMC_CALL_WITH_ARG;
> - reg_pair_from_64(&param.a1, &param.a2, parg);
> - /* Initialize waiter */
> - optee_cq_wait_init(&optee->call_queue, &w);
> - while (true) {
> - struct arm_smccc_res res;
> -
> - trace_optee_invoke_fn_begin(&param);
> - optee->invoke_fn(param.a0, param.a1, param.a2, param.a3,
> - param.a4, param.a5, param.a6, param.a7,
> - &res);
> - trace_optee_invoke_fn_end(&param, &res);
> -
> - if (res.a0 == OPTEE_SMC_RETURN_ETHREAD_LIMIT) {
> - /*
> - * Out of threads in secure world, wait for a thread
> - * become available.
> - */
> - optee_cq_wait_for_completion(&optee->call_queue, &w);
> - } else if (OPTEE_SMC_RETURN_IS_RPC(res.a0)) {
> - cond_resched();
> - param.a0 = res.a0;
> - param.a1 = res.a1;
> - param.a2 = res.a2;
> - param.a3 = res.a3;
> - optee_handle_rpc(ctx, &param, &call_ctx);
> - } else {
> - rc = res.a0;
> - break;
> - }
> - }
> -
> - optee_rpc_finalize_call(&call_ctx);
> - /*
> - * We're done with our thread in secure world, if there's any
> - * thread waiters wake up one.
> - */
> - optee_cq_wait_final(&optee->call_queue, &w);
> -
> - return rc;
> -}
> -
> -static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,
> - struct optee_msg_arg **msg_arg)
> +struct tee_shm *optee_get_msg_arg(struct tee_context *ctx, size_t num_params,
> + struct optee_msg_arg **msg_arg)
> {
> struct tee_shm *shm;
> struct optee_msg_arg *ma;
> @@ -217,7 +141,7 @@ int optee_open_session(struct tee_context *ctx,
> uuid_t client_uuid;
>
> /* +2 for the meta parameters added below */
> - shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg);
> + shm = optee_get_msg_arg(ctx, arg->num_params + 2, &msg_arg);
> if (IS_ERR(shm))
> return PTR_ERR(shm);
>
> @@ -290,7 +214,7 @@ int optee_close_session_helper(struct tee_context *ctx, u32 session)
> struct optee *optee = tee_get_drvdata(ctx->teedev);
> struct optee_msg_arg *msg_arg;
>
> - shm = get_msg_arg(ctx, 0, &msg_arg);
> + shm = optee_get_msg_arg(ctx, 0, &msg_arg);
> if (IS_ERR(shm))
> return PTR_ERR(shm);
>
> @@ -338,7 +262,7 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> if (!sess)
> return -EINVAL;
>
> - shm = get_msg_arg(ctx, arg->num_params, &msg_arg);
> + shm = optee_get_msg_arg(ctx, arg->num_params, &msg_arg);
> if (IS_ERR(shm))
> return PTR_ERR(shm);
> msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND;
> @@ -384,7 +308,7 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
> if (!sess)
> return -EINVAL;
>
> - shm = get_msg_arg(ctx, 0, &msg_arg);
> + shm = optee_get_msg_arg(ctx, 0, &msg_arg);
> if (IS_ERR(shm))
> return PTR_ERR(shm);
>
> @@ -397,152 +321,6 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
> return 0;
> }
>
> -/**
> - * optee_enable_shm_cache() - Enables caching of some shared memory allocation
> - * in OP-TEE
> - * @optee: main service struct
> - */
> -void optee_enable_shm_cache(struct optee *optee)
> -{
> - struct optee_call_waiter w;
> -
> - /* We need to retry until secure world isn't busy. */
> - optee_cq_wait_init(&optee->call_queue, &w);
> - while (true) {
> - struct arm_smccc_res res;
> -
> - optee->invoke_fn(OPTEE_SMC_ENABLE_SHM_CACHE, 0, 0, 0, 0, 0, 0,
> - 0, &res);
> - if (res.a0 == OPTEE_SMC_RETURN_OK)
> - break;
> - optee_cq_wait_for_completion(&optee->call_queue, &w);
> - }
> - optee_cq_wait_final(&optee->call_queue, &w);
> -}
> -
> -/**
> - * optee_disable_shm_cache() - Disables caching of some shared memory allocation
> - * in OP-TEE
> - * @optee: main service struct
> - */
> -void optee_disable_shm_cache(struct optee *optee)
> -{
> - struct optee_call_waiter w;
> -
> - /* We need to retry until secure world isn't busy. */
> - optee_cq_wait_init(&optee->call_queue, &w);
> - while (true) {
> - union {
> - struct arm_smccc_res smccc;
> - struct optee_smc_disable_shm_cache_result result;
> - } res;
> -
> - optee->invoke_fn(OPTEE_SMC_DISABLE_SHM_CACHE, 0, 0, 0, 0, 0, 0,
> - 0, &res.smccc);
> - if (res.result.status == OPTEE_SMC_RETURN_ENOTAVAIL)
> - break; /* All shm's freed */
> - if (res.result.status == OPTEE_SMC_RETURN_OK) {
> - struct tee_shm *shm;
> -
> - shm = reg_pair_to_ptr(res.result.shm_upper32,
> - res.result.shm_lower32);
> - tee_shm_free(shm);
> - } else {
> - optee_cq_wait_for_completion(&optee->call_queue, &w);
> - }
> - }
> - optee_cq_wait_final(&optee->call_queue, &w);
> -}
> -
> -#define PAGELIST_ENTRIES_PER_PAGE \
> - ((OPTEE_MSG_NONCONTIG_PAGE_SIZE / sizeof(u64)) - 1)
> -
> -/**
> - * optee_fill_pages_list() - write list of user pages to given shared
> - * buffer.
> - *
> - * @dst: page-aligned buffer where list of pages will be stored
> - * @pages: array of pages that represents shared buffer
> - * @num_pages: number of entries in @pages
> - * @page_offset: offset of user buffer from page start
> - *
> - * @dst should be big enough to hold list of user page addresses and
> - * links to the next pages of buffer
> - */
> -void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,
> - size_t page_offset)
> -{
> - int n = 0;
> - phys_addr_t optee_page;
> - /*
> - * Refer to OPTEE_MSG_ATTR_NONCONTIG description in optee_msg.h
> - * for details.
> - */
> - struct {
> - u64 pages_list[PAGELIST_ENTRIES_PER_PAGE];
> - u64 next_page_data;
> - } *pages_data;
> -
> - /*
> - * Currently OP-TEE uses 4k page size and it does not looks
> - * like this will change in the future. On other hand, there are
> - * no know ARM architectures with page size < 4k.
> - * Thus the next built assert looks redundant. But the following
> - * code heavily relies on this assumption, so it is better be
> - * safe than sorry.
> - */
> - BUILD_BUG_ON(PAGE_SIZE < OPTEE_MSG_NONCONTIG_PAGE_SIZE);
> -
> - pages_data = (void *)dst;
> - /*
> - * If linux page is bigger than 4k, and user buffer offset is
> - * larger than 4k/8k/12k/etc this will skip first 4k pages,
> - * because they bear no value data for OP-TEE.
> - */
> - optee_page = page_to_phys(*pages) +
> - round_down(page_offset, OPTEE_MSG_NONCONTIG_PAGE_SIZE);
> -
> - while (true) {
> - pages_data->pages_list[n++] = optee_page;
> -
> - if (n == PAGELIST_ENTRIES_PER_PAGE) {
> - pages_data->next_page_data =
> - virt_to_phys(pages_data + 1);
> - pages_data++;
> - n = 0;
> - }
> -
> - optee_page += OPTEE_MSG_NONCONTIG_PAGE_SIZE;
> - if (!(optee_page & ~PAGE_MASK)) {
> - if (!--num_pages)
> - break;
> - pages++;
> - optee_page = page_to_phys(*pages);
> - }
> - }
> -}
> -
> -/*
> - * The final entry in each pagelist page is a pointer to the next
> - * pagelist page.
> - */
> -static size_t get_pages_list_size(size_t num_entries)
> -{
> - int pages = DIV_ROUND_UP(num_entries, PAGELIST_ENTRIES_PER_PAGE);
> -
> - return pages * OPTEE_MSG_NONCONTIG_PAGE_SIZE;
> -}
> -
> -u64 *optee_allocate_pages_list(size_t num_entries)
> -{
> - return alloc_pages_exact(get_pages_list_size(num_entries), GFP_KERNEL);
> -}
> -
> -void optee_free_pages_list(void *list, size_t num_entries)
> -{
> - free_pages_exact(list, get_pages_list_size(num_entries));
> -}
> -
> static bool is_normal_memory(pgprot_t p)
> {
> #if defined(CONFIG_ARM)
> @@ -566,7 +344,7 @@ static int __check_mem_type(struct vm_area_struct *vma, unsigned long end)
> return -EINVAL;
> }
>
> -static int check_mem_type(unsigned long start, size_t num_pages)
> +int optee_check_mem_type(unsigned long start, size_t num_pages)
> {
> struct mm_struct *mm = current->mm;
> int rc;
> @@ -585,94 +363,3 @@ static int check_mem_type(unsigned long start, size_t num_pages)
>
> return rc;
> }
> -
> -int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> - struct page **pages, size_t num_pages,
> - unsigned long start)
> -{
> - struct optee *optee = tee_get_drvdata(ctx->teedev);
> - struct optee_msg_arg *msg_arg;
> - struct tee_shm *shm_arg;
> - u64 *pages_list;
> - int rc;
> -
> - if (!num_pages)
> - return -EINVAL;
> -
> - rc = check_mem_type(start, num_pages);
> - if (rc)
> - return rc;
> -
> - pages_list = optee_allocate_pages_list(num_pages);
> - if (!pages_list)
> - return -ENOMEM;
> -
> - shm_arg = get_msg_arg(ctx, 1, &msg_arg);
> - if (IS_ERR(shm_arg)) {
> - rc = PTR_ERR(shm_arg);
> - goto out;
> - }
> -
> - optee_fill_pages_list(pages_list, pages, num_pages,
> - tee_shm_get_page_offset(shm));
> -
> - 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.shm_ref = (unsigned long)shm;
> - msg_arg->params->u.tmem.size = tee_shm_get_size(shm);
> - /*
> - * In the least bits of msg_arg->params->u.tmem.buf_ptr we
> - * store buffer offset from 4k page, as described in OP-TEE ABI.
> - */
> - msg_arg->params->u.tmem.buf_ptr = virt_to_phys(pages_list) |
> - (tee_shm_get_page_offset(shm) & (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
> -
> - if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> - msg_arg->ret != TEEC_SUCCESS)
> - rc = -EINVAL;
> -
> - tee_shm_free(shm_arg);
> -out:
> - optee_free_pages_list(pages_list, num_pages);
> - return rc;
> -}
> -
> -int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
> -{
> - struct optee *optee = tee_get_drvdata(ctx->teedev);
> - struct optee_msg_arg *msg_arg;
> - struct tee_shm *shm_arg;
> - int rc = 0;
> -
> - shm_arg = get_msg_arg(ctx, 1, &msg_arg);
> - if (IS_ERR(shm_arg))
> - return PTR_ERR(shm_arg);
> -
> - 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 = (unsigned long)shm;
> -
> - if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> - msg_arg->ret != TEEC_SUCCESS)
> - rc = -EINVAL;
> - tee_shm_free(shm_arg);
> - return rc;
> -}
> -
> -int optee_shm_register_supp(struct tee_context *ctx, struct tee_shm *shm,
> - struct page **pages, size_t num_pages,
> - unsigned long start)
> -{
> - /*
> - * We don't want to register supplicant memory in OP-TEE.
> - * Instead information about it will be passed in RPC code.
> - */
> - return check_mem_type(start, num_pages);
> -}
> -
> -int optee_shm_unregister_supp(struct tee_context *ctx, struct tee_shm *shm)
> -{
> - return 0;
> -}
> diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c
> index f689f171a794..e0dcde043df2 100644
> --- a/drivers/tee/optee/core.c
> +++ b/drivers/tee/optee/core.c
> @@ -1,259 +1,62 @@
> // SPDX-License-Identifier: GPL-2.0-only
> /*
> * Copyright (c) 2015-2021, Linaro Limited
> + * Copyright (c) 2016, EPAM Systems
> */
>
> #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
>
> -#include <linux/arm-smccc.h>
> #include <linux/errno.h>
> #include <linux/io.h>
> +#include <linux/mm.h>
> #include <linux/module.h>
> -#include <linux/of.h>
> -#include <linux/of_platform.h>
> -#include <linux/platform_device.h>
> #include <linux/slab.h>
> #include <linux/string.h>
> #include <linux/tee_drv.h>
> #include <linux/types.h>
> -#include <linux/uaccess.h>
> #include <linux/workqueue.h>
> #include "optee_private.h"
> -#include "optee_smc.h"
> -#include "shm_pool.h"
>
> -#define DRIVER_NAME "optee"
> -
> -#define OPTEE_SHM_NUM_PRIV_PAGES CONFIG_OPTEE_SHM_NUM_PRIV_PAGES
> -
> -static void from_msg_param_value(struct tee_param *p, u32 attr,
> - const struct optee_msg_param *mp)
> -{
> - p->attr = TEE_IOCTL_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;
> -}
> -
> -static int from_msg_param_tmp_mem(struct tee_param *p, u32 attr,
> - const struct optee_msg_param *mp)
> +int optee_pool_op_alloc_helper(struct tee_shm_pool_mgr *poolm,
> + struct tee_shm *shm, size_t size,
> + int (*shm_register)(struct tee_context *ctx,
> + struct tee_shm *shm,
> + struct page **pages,
> + size_t num_pages,
> + unsigned long start))
> {
> - struct tee_shm *shm;
> - phys_addr_t pa;
> - int rc;
> -
> - p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> - attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
> - p->u.memref.size = mp->u.tmem.size;
> - shm = (struct tee_shm *)(unsigned long)mp->u.tmem.shm_ref;
> - if (!shm) {
> - p->u.memref.shm_offs = 0;
> - p->u.memref.shm = NULL;
> - return 0;
> - }
> -
> - rc = tee_shm_get_pa(shm, 0, &pa);
> - if (rc)
> - return rc;
> -
> - p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
> - p->u.memref.shm = shm;
> -
> - /* Check that the memref is covered by the shm object */
> - if (p->u.memref.size) {
> - size_t o = p->u.memref.shm_offs +
> - p->u.memref.size - 1;
> -
> - rc = tee_shm_get_pa(shm, o, NULL);
> - if (rc)
> - return rc;
> - }
> + unsigned int order = get_order(size);
> + struct page *page;
> + int rc = 0;
>
> - return 0;
> -}
> -
> -static void from_msg_param_reg_mem(struct tee_param *p, u32 attr,
> - const struct optee_msg_param *mp)
> -{
> - struct tee_shm *shm;
> -
> - p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> - attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> - p->u.memref.size = mp->u.rmem.size;
> - shm = (struct tee_shm *)(unsigned long)mp->u.rmem.shm_ref;
> -
> - if (shm) {
> - p->u.memref.shm_offs = mp->u.rmem.offs;
> - p->u.memref.shm = shm;
> - } else {
> - p->u.memref.shm_offs = 0;
> - p->u.memref.shm = NULL;
> - }
> -}
> + page = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
> + if (!page)
> + return -ENOMEM;
>
> -/**
> - * optee_from_msg_param() - convert from OPTEE_MSG parameters to
> - * struct tee_param
> - * @optee: main service struct
> - * @params: subsystem internal parameter representation
> - * @num_params: number of elements in the parameter arrays
> - * @msg_params: OPTEE_MSG parameters
> - * Returns 0 on success or <0 on failure
> - */
> -static int optee_from_msg_param(struct optee *optee, struct tee_param *params,
> - size_t num_params,
> - const struct optee_msg_param *msg_params)
> -{
> - int rc;
> - size_t n;
> + shm->kaddr = page_address(page);
> + shm->paddr = page_to_phys(page);
> + shm->size = PAGE_SIZE << order;
>
> - 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;
> + if (shm_register) {
> + unsigned int nr_pages = 1 << order, i;
> + struct page **pages;
>
> - switch (attr) {
> - case OPTEE_MSG_ATTR_TYPE_NONE:
> - p->attr = TEE_IOCTL_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:
> - from_msg_param_value(p, attr, mp);
> - break;
> - case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:
> - case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
> - case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
> - rc = from_msg_param_tmp_mem(p, attr, mp);
> - if (rc)
> - return rc;
> - break;
> - case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:
> - case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:
> - case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:
> - from_msg_param_reg_mem(p, attr, mp);
> - break;
> + pages = kcalloc(nr_pages, sizeof(pages), GFP_KERNEL);
> + if (!pages)
> + return -ENOMEM;
>
> - default:
> - return -EINVAL;
> + for (i = 0; i < nr_pages; i++) {
> + pages[i] = page;
> + page++;
> }
> - }
> - return 0;
> -}
> -
> -static void to_msg_param_value(struct optee_msg_param *mp,
> - const struct tee_param *p)
> -{
> - mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
> - TEE_IOCTL_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;
> -}
>
> -static int to_msg_param_tmp_mem(struct optee_msg_param *mp,
> - const struct tee_param *p)
> -{
> - int rc;
> - phys_addr_t pa;
> -
> - mp->attr = OPTEE_MSG_ATTR_TYPE_TMEM_INPUT + p->attr -
> - TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
> -
> - mp->u.tmem.shm_ref = (unsigned long)p->u.memref.shm;
> - mp->u.tmem.size = p->u.memref.size;
> -
> - if (!p->u.memref.shm) {
> - mp->u.tmem.buf_ptr = 0;
> - return 0;
> + shm->flags |= TEE_SHM_REGISTER;
> + rc = shm_register(shm->ctx, shm, pages, nr_pages,
> + (unsigned long)shm->kaddr);
> + kfree(pages);
> }
>
> - rc = tee_shm_get_pa(p->u.memref.shm, p->u.memref.shm_offs, &pa);
> - if (rc)
> - return rc;
> -
> - mp->u.tmem.buf_ptr = pa;
> - mp->attr |= OPTEE_MSG_ATTR_CACHE_PREDEFINED <<
> - OPTEE_MSG_ATTR_CACHE_SHIFT;
> -
> - return 0;
> -}
> -
> -static int to_msg_param_reg_mem(struct optee_msg_param *mp,
> - const struct tee_param *p)
> -{
> - mp->attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT + p->attr -
> - TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
> -
> - mp->u.rmem.shm_ref = (unsigned long)p->u.memref.shm;
> - mp->u.rmem.size = p->u.memref.size;
> - mp->u.rmem.offs = p->u.memref.shm_offs;
> - return 0;
> -}
> -
> -/**
> - * optee_to_msg_param() - convert from struct tee_params to OPTEE_MSG parameters
> - * @optee: main service struct
> - * @msg_params: OPTEE_MSG parameters
> - * @num_params: number of elements in the parameter arrays
> - * @params: subsystem itnernal parameter representation
> - * Returns 0 on success or <0 on failure
> - */
> -static int optee_to_msg_param(struct optee *optee,
> - struct optee_msg_param *msg_params,
> - size_t num_params, const struct tee_param *params)
> -{
> - int rc;
> - size_t 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_IOCTL_PARAM_ATTR_TYPE_NONE:
> - mp->attr = TEE_IOCTL_PARAM_ATTR_TYPE_NONE;
> - memset(&mp->u, 0, sizeof(mp->u));
> - break;
> - case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT:
> - case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
> - case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
> - to_msg_param_value(mp, p);
> - break;
> - case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT:
> - case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
> - case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:
> - if (tee_shm_is_registered(p->u.memref.shm))
> - rc = to_msg_param_reg_mem(mp, p);
> - else
> - rc = to_msg_param_tmp_mem(mp, p);
> - if (rc)
> - return rc;
> - break;
> - default:
> - return -EINVAL;
> - }
> - }
> - return 0;
> -}
> -
> -static void optee_get_version(struct tee_device *teedev,
> - struct tee_ioctl_version_data *vers)
> -{
> - struct tee_ioctl_version_data v = {
> - .impl_id = TEE_IMPL_ID_OPTEE,
> - .impl_caps = TEE_OPTEE_CAP_TZ,
> - .gen_caps = TEE_GEN_CAP_GP,
> - };
> - struct optee *optee = tee_get_drvdata(teedev);
> -
> - if (optee->sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
> - v.gen_caps |= TEE_GEN_CAP_REG_MEM;
> - if (optee->sec_caps & OPTEE_SMC_SEC_CAP_MEMREF_NULL)
> - v.gen_caps |= TEE_GEN_CAP_MEMREF_NULL;
> - *vers = v;
> + return rc;
> }
>
> static void optee_bus_scan(struct work_struct *work)
> @@ -261,7 +64,7 @@ static void optee_bus_scan(struct work_struct *work)
> WARN_ON(optee_enumerate_devices(PTA_CMD_GET_DEVICES_SUPP));
> }
>
> -static int optee_open(struct tee_context *ctx)
> +int optee_open(struct tee_context *ctx, bool cap_memref_null)
> {
> struct optee_context_data *ctxdata;
> struct tee_device *teedev = ctx->teedev;
> @@ -299,11 +102,7 @@ static int optee_open(struct tee_context *ctx)
> mutex_init(&ctxdata->mutex);
> INIT_LIST_HEAD(&ctxdata->sess_list);
>
> - if (optee->sec_caps & OPTEE_SMC_SEC_CAP_MEMREF_NULL)
> - ctx->cap_memref_null = true;
> - else
> - ctx->cap_memref_null = false;
> -
> + ctx->cap_memref_null = cap_memref_null;
> ctx->data = ctxdata;
> return 0;
> }
> @@ -329,12 +128,12 @@ static void optee_release_helper(struct tee_context *ctx,
> ctx->data = NULL;
> }
>
> -static void optee_release(struct tee_context *ctx)
> +void optee_release(struct tee_context *ctx)
> {
> optee_release_helper(ctx, optee_close_session_helper);
> }
>
> -static void optee_release_supp(struct tee_context *ctx)
> +void optee_release_supp(struct tee_context *ctx)
> {
> struct optee *optee = tee_get_drvdata(ctx->teedev);
>
> @@ -346,277 +145,8 @@ static void optee_release_supp(struct tee_context *ctx)
> optee_supp_release(&optee->supp);
> }
>
> -static const struct tee_driver_ops optee_clnt_ops = {
> - .get_version = optee_get_version,
> - .open = optee_open,
> - .release = optee_release,
> - .open_session = optee_open_session,
> - .close_session = optee_close_session,
> - .invoke_func = optee_invoke_func,
> - .cancel_req = optee_cancel_req,
> - .shm_register = optee_shm_register,
> - .shm_unregister = optee_shm_unregister,
> -};
> -
> -static const struct tee_desc optee_clnt_desc = {
> - .name = DRIVER_NAME "-clnt",
> - .ops = &optee_clnt_ops,
> - .owner = THIS_MODULE,
> -};
> -
> -static const struct tee_driver_ops optee_supp_ops = {
> - .get_version = optee_get_version,
> - .open = optee_open,
> - .release = optee_release_supp,
> - .supp_recv = optee_supp_recv,
> - .supp_send = optee_supp_send,
> - .shm_register = optee_shm_register_supp,
> - .shm_unregister = optee_shm_unregister_supp,
> -};
> -
> -static const struct tee_desc optee_supp_desc = {
> - .name = DRIVER_NAME "-supp",
> - .ops = &optee_supp_ops,
> - .owner = THIS_MODULE,
> - .flags = TEE_DESC_PRIVILEGED,
> -};
> -
> -static const struct optee_ops optee_ops = {
> - .do_call_with_arg = optee_do_call_with_arg,
> - .to_msg_param = optee_to_msg_param,
> - .from_msg_param = optee_from_msg_param,
> -};
> -
> -static bool optee_msg_api_uid_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);
> -
> - if (res.a0 == OPTEE_MSG_UID_0 && res.a1 == OPTEE_MSG_UID_1 &&
> - res.a2 == OPTEE_MSG_UID_2 && res.a3 == OPTEE_MSG_UID_3)
> - return true;
> - return false;
> -}
> -
> -static void optee_msg_get_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)
> - pr_info("revision %lu.%lu (%08lx)", res.result.major,
> - res.result.minor, res.result.build_id);
> - else
> - pr_info("revision %lu.%lu", res.result.major, res.result.minor);
> -}
> -
> -static bool optee_msg_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);
> -
> - if (res.result.major == OPTEE_MSG_REVISION_MAJOR &&
> - (int)res.result.minor >= OPTEE_MSG_REVISION_MINOR)
> - return true;
> - return false;
> -}
> -
> -static bool optee_msg_exchange_capabilities(optee_invoke_fn *invoke_fn,
> - u32 *sec_caps)
> -{
> - union {
> - struct arm_smccc_res smccc;
> - struct optee_smc_exchange_capabilities_result result;
> - } res;
> - u32 a1 = 0;
> -
> - /*
> - * TODO This isn't enough to tell if it's UP system (from kernel
> - * point of view) or not, is_smp() returns the the information
> - * needed, but can't be called directly from here.
> - */
> - if (!IS_ENABLED(CONFIG_SMP) || nr_cpu_ids == 1)
> - a1 |= OPTEE_SMC_NSEC_CAP_UNIPROCESSOR;
> -
> - invoke_fn(OPTEE_SMC_EXCHANGE_CAPABILITIES, a1, 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;
> -}
> -
> -static struct tee_shm_pool *optee_config_dyn_shm(void)
> -{
> - struct tee_shm_pool_mgr *priv_mgr;
> - struct tee_shm_pool_mgr *dmabuf_mgr;
> - void *rc;
> -
> - rc = optee_shm_pool_alloc_pages();
> - if (IS_ERR(rc))
> - return rc;
> - priv_mgr = rc;
> -
> - rc = optee_shm_pool_alloc_pages();
> - if (IS_ERR(rc)) {
> - tee_shm_pool_mgr_destroy(priv_mgr);
> - return rc;
> - }
> - dmabuf_mgr = rc;
> -
> - rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
> - if (IS_ERR(rc)) {
> - tee_shm_pool_mgr_destroy(priv_mgr);
> - tee_shm_pool_mgr_destroy(dmabuf_mgr);
> - }
> -
> - return rc;
> -}
> -
> -static struct tee_shm_pool *
> -optee_config_shm_memremap(optee_invoke_fn *invoke_fn, void **memremaped_shm)
> +void optee_remove_common(struct optee *optee)
> {
> - union {
> - struct arm_smccc_res smccc;
> - struct optee_smc_get_shm_config_result result;
> - } res;
> - unsigned long vaddr;
> - phys_addr_t paddr;
> - size_t size;
> - phys_addr_t begin;
> - phys_addr_t end;
> - void *va;
> - struct tee_shm_pool_mgr *priv_mgr;
> - struct tee_shm_pool_mgr *dmabuf_mgr;
> - void *rc;
> - const int sz = OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE;
> -
> - invoke_fn(OPTEE_SMC_GET_SHM_CONFIG, 0, 0, 0, 0, 0, 0, 0, &res.smccc);
> - if (res.result.status != OPTEE_SMC_RETURN_OK) {
> - pr_err("static shm service not available\n");
> - return ERR_PTR(-ENOENT);
> - }
> -
> - if (res.result.settings != OPTEE_SMC_SHM_CACHED) {
> - pr_err("only normal cached shared memory supported\n");
> - return ERR_PTR(-EINVAL);
> - }
> -
> - begin = roundup(res.result.start, PAGE_SIZE);
> - end = rounddown(res.result.start + res.result.size, PAGE_SIZE);
> - paddr = begin;
> - size = end - begin;
> -
> - if (size < 2 * OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE) {
> - pr_err("too small shared memory area\n");
> - return ERR_PTR(-EINVAL);
> - }
> -
> - va = memremap(paddr, size, MEMREMAP_WB);
> - if (!va) {
> - pr_err("shared memory ioremap failed\n");
> - return ERR_PTR(-EINVAL);
> - }
> - vaddr = (unsigned long)va;
> -
> - rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, sz,
> - 3 /* 8 bytes aligned */);
> - if (IS_ERR(rc))
> - goto err_memunmap;
> - priv_mgr = rc;
> -
> - vaddr += sz;
> - paddr += sz;
> - size -= sz;
> -
> - rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, size, PAGE_SHIFT);
> - if (IS_ERR(rc))
> - goto err_free_priv_mgr;
> - dmabuf_mgr = rc;
> -
> - rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
> - if (IS_ERR(rc))
> - goto err_free_dmabuf_mgr;
> -
> - *memremaped_shm = va;
> -
> - return rc;
> -
> -err_free_dmabuf_mgr:
> - tee_shm_pool_mgr_destroy(dmabuf_mgr);
> -err_free_priv_mgr:
> - tee_shm_pool_mgr_destroy(priv_mgr);
> -err_memunmap:
> - memunmap(va);
> - return rc;
> -}
> -
> -/* 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 device *dev)
> -{
> - const char *method;
> -
> - pr_info("probing for conduit method.\n");
> -
> - if (device_property_read_string(dev, "method", &method)) {
> - pr_warn("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;
> -
> - pr_warn("invalid \"method\" property: %s\n", method);
> - return ERR_PTR(-EINVAL);
> -}
> -
> -static int optee_remove(struct platform_device *pdev)
> -{
> - struct optee *optee = platform_get_drvdata(pdev);
> -
> - /*
> - * Ask OP-TEE to free all cached shared memory objects to decrease
> - * reference counters and also avoid wild pointers in secure world
> - * into the old shared memory range.
> - */
> - optee_disable_shm_cache(optee);
> -
> /*
> * The two devices have to be unregistered before we can free the
> * other resources.
> @@ -625,151 +155,11 @@ static int optee_remove(struct platform_device *pdev)
> tee_device_unregister(optee->teedev);
>
> tee_shm_pool_free(optee->pool);
> - if (optee->memremaped_shm)
> - memunmap(optee->memremaped_shm);
> optee_wait_queue_exit(&optee->wait_queue);
> optee_supp_uninit(&optee->supp);
> mutex_destroy(&optee->call_queue.mutex);
> -
> - kfree(optee);
> -
> - return 0;
> -}
> -
> -static int optee_probe(struct platform_device *pdev)
> -{
> - optee_invoke_fn *invoke_fn;
> - struct tee_shm_pool *pool = ERR_PTR(-EINVAL);
> - struct optee *optee = NULL;
> - void *memremaped_shm = NULL;
> - struct tee_device *teedev;
> - u32 sec_caps;
> - int rc;
> -
> - invoke_fn = get_invoke_func(&pdev->dev);
> - if (IS_ERR(invoke_fn))
> - return PTR_ERR(invoke_fn);
> -
> - if (!optee_msg_api_uid_is_optee_api(invoke_fn)) {
> - pr_warn("api uid mismatch\n");
> - return -EINVAL;
> - }
> -
> - optee_msg_get_os_revision(invoke_fn);
> -
> - if (!optee_msg_api_revision_is_compatible(invoke_fn)) {
> - pr_warn("api revision mismatch\n");
> - return -EINVAL;
> - }
> -
> - if (!optee_msg_exchange_capabilities(invoke_fn, &sec_caps)) {
> - pr_warn("capabilities mismatch\n");
> - return -EINVAL;
> - }
> -
> - /*
> - * Try to use dynamic shared memory if possible
> - */
> - if (sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
> - pool = optee_config_dyn_shm();
> -
> - /*
> - * If dynamic shared memory is not available or failed - try static one
> - */
> - if (IS_ERR(pool) && (sec_caps & OPTEE_SMC_SEC_CAP_HAVE_RESERVED_SHM))
> - pool = optee_config_shm_memremap(invoke_fn, &memremaped_shm);
> -
> - if (IS_ERR(pool))
> - return PTR_ERR(pool);
> -
> - optee = kzalloc(sizeof(*optee), GFP_KERNEL);
> - if (!optee) {
> - rc = -ENOMEM;
> - goto err;
> - }
> -
> - optee->ops = &optee_ops;
> - optee->invoke_fn = invoke_fn;
> - optee->sec_caps = sec_caps;
> -
> - teedev = tee_device_alloc(&optee_clnt_desc, NULL, pool, optee);
> - if (IS_ERR(teedev)) {
> - rc = PTR_ERR(teedev);
> - goto err;
> - }
> - optee->teedev = teedev;
> -
> - teedev = tee_device_alloc(&optee_supp_desc, NULL, pool, optee);
> - if (IS_ERR(teedev)) {
> - rc = PTR_ERR(teedev);
> - goto err;
> - }
> - optee->supp_teedev = teedev;
> -
> - rc = tee_device_register(optee->teedev);
> - if (rc)
> - goto err;
> -
> - rc = tee_device_register(optee->supp_teedev);
> - if (rc)
> - goto err;
> -
> - mutex_init(&optee->call_queue.mutex);
> - INIT_LIST_HEAD(&optee->call_queue.waiters);
> - optee_wait_queue_init(&optee->wait_queue);
> - optee_supp_init(&optee->supp);
> - optee->memremaped_shm = memremaped_shm;
> - optee->pool = pool;
> -
> - optee_enable_shm_cache(optee);
> -
> - if (optee->sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
> - pr_info("dynamic shared memory is enabled\n");
> -
> - platform_set_drvdata(pdev, optee);
> -
> - rc = optee_enumerate_devices(PTA_CMD_GET_DEVICES);
> - if (rc) {
> - optee_remove(pdev);
> - return rc;
> - }
> -
> - pr_info("initialized driver\n");
> - return 0;
> -err:
> - if (optee) {
> - /*
> - * tee_device_unregister() is safe to call even if the
> - * devices hasn't been registered with
> - * tee_device_register() yet.
> - */
> - tee_device_unregister(optee->supp_teedev);
> - tee_device_unregister(optee->teedev);
> - kfree(optee);
> - }
> - if (pool)
> - tee_shm_pool_free(pool);
> - if (memremaped_shm)
> - memunmap(memremaped_shm);
> - return rc;
> }
>
> -static const struct of_device_id optee_dt_match[] = {
> - { .compatible = "linaro,optee-tz" },
> - {},
> -};
> -MODULE_DEVICE_TABLE(of, optee_dt_match);
> -
> -static struct platform_driver optee_driver = {
> - .probe = optee_probe,
> - .remove = optee_remove,
> - .driver = {
> - .name = "optee",
> - .of_match_table = optee_dt_match,
> - },
> -};
> -module_platform_driver(optee_driver);
> -
> MODULE_AUTHOR("Linaro");
> MODULE_DESCRIPTION("OP-TEE driver");
> MODULE_VERSION("1.0");
> diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h
> index c5741e96e967..68d1331068e9 100644
> --- a/drivers/tee/optee/optee_private.h
> +++ b/drivers/tee/optee/optee_private.h
> @@ -12,6 +12,8 @@
> #include <linux/types.h>
> #include "optee_msg.h"
>
> +#define DRIVER_NAME "optee"
> +
> #define OPTEE_MAX_ARG_SIZE 1024
>
> /* Some Global Platform error codes used in this driver */
> @@ -29,6 +31,11 @@ typedef void (optee_invoke_fn)(unsigned long, unsigned long, unsigned long,
> unsigned long, unsigned long,
> struct arm_smccc_res *);
>
> +struct optee_call_waiter {
> + struct list_head list_node;
> + struct completion c;
> +};
> +
> struct optee_call_queue {
> /* Serializes access to this struct */
> struct mutex mutex;
> @@ -66,6 +73,19 @@ struct optee_supp {
> struct completion reqs_c;
> };
>
> +/**
> + * struct optee_smc - SMC ABI specifics
> + * @invoke_fn: function to issue smc or hvc
> + * @memremaped_shm virtual address of memory in shared memory pool
> + * @sec_caps: secure world capabilities defined by
> + * OPTEE_SMC_SEC_CAP_* in optee_smc.h
> + */
> +struct optee_smc {
> + optee_invoke_fn *invoke_fn;
> + void *memremaped_shm;
> + u32 sec_caps;
> +};
> +
> struct optee;
>
> /**
> @@ -95,15 +115,12 @@ struct optee_ops {
> * @ops: internal callbacks for different ways to reach secure
> * world
> * @teedev: client device
> - * @invoke_fn: function to issue smc or hvc
> + * @smc: specific to SMC ABI
> * @call_queue: queue of threads waiting to call @invoke_fn
> * @wait_queue: queue of threads from secure world waiting for a
> * secure world sync object
> * @supp: supplicant synchronization struct for RPC to supplicant
> * @pool: shared memory pool
> - * @memremaped_shm virtual address of memory in shared memory pool
> - * @sec_caps: secure world capabilities defined by
> - * OPTEE_SMC_SEC_CAP_* in optee_smc.h
> * @scan_bus_done flag if device registation was already done.
> * @scan_bus_wq workqueue to scan optee bus and register optee drivers
> * @scan_bus_work workq to scan optee bus and register optee drivers
> @@ -112,13 +129,11 @@ struct optee {
> struct tee_device *supp_teedev;
> struct tee_device *teedev;
> const struct optee_ops *ops;
> - optee_invoke_fn *invoke_fn;
> + struct optee_smc smc;
> struct optee_call_queue call_queue;
> struct optee_wait_queue wait_queue;
> struct optee_supp supp;
> struct tee_shm_pool *pool;
> - void *memremaped_shm;
> - u32 sec_caps;
> bool scan_bus_done;
> struct workqueue_struct *scan_bus_wq;
> struct work_struct scan_bus_work;
> @@ -153,10 +168,6 @@ struct optee_call_ctx {
> size_t num_entries;
> };
>
> -void optee_handle_rpc(struct tee_context *ctx, struct optee_rpc_param *param,
> - struct optee_call_ctx *call_ctx);
> -void optee_rpc_finalize_call(struct optee_call_ctx *call_ctx);
> -
> void optee_wait_queue_init(struct optee_wait_queue *wq);
> void optee_wait_queue_exit(struct optee_wait_queue *wq);
>
> @@ -174,7 +185,6 @@ int optee_supp_recv(struct tee_context *ctx, u32 *func, u32 *num_params,
> int optee_supp_send(struct tee_context *ctx, u32 ret, u32 num_params,
> struct tee_param *param);
>
> -int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg);
> int optee_open_session(struct tee_context *ctx,
> struct tee_ioctl_open_session_arg *arg,
> struct tee_param *param);
> @@ -184,27 +194,63 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> struct tee_param *param);
> int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session);
>
> -void optee_enable_shm_cache(struct optee *optee);
> -void optee_disable_shm_cache(struct optee *optee);
> +#define PTA_CMD_GET_DEVICES 0x0
> +#define PTA_CMD_GET_DEVICES_SUPP 0x1
> +int optee_enumerate_devices(u32 func);
>
> -int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> - struct page **pages, size_t num_pages,
> - unsigned long start);
> -int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm);
> +int optee_pool_op_alloc_helper(struct tee_shm_pool_mgr *poolm,
> + struct tee_shm *shm, size_t size,
> + int (*shm_register)(struct tee_context *ctx,
> + struct tee_shm *shm,
> + struct page **pages,
> + size_t num_pages,
> + unsigned long start));
>
> -int optee_shm_register_supp(struct tee_context *ctx, struct tee_shm *shm,
> - struct page **pages, size_t num_pages,
> - unsigned long start);
> -int optee_shm_unregister_supp(struct tee_context *ctx, struct tee_shm *shm);
>
> -u64 *optee_allocate_pages_list(size_t num_entries);
> -void optee_free_pages_list(void *array, size_t num_entries);
> -void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,
> - size_t page_offset);
> +void optee_remove_common(struct optee *optee);
> +int optee_open(struct tee_context *ctx, bool cap_memref_null);
> +void optee_release(struct tee_context *ctx);
> +void optee_release_supp(struct tee_context *ctx);
>
> -#define PTA_CMD_GET_DEVICES 0x0
> -#define PTA_CMD_GET_DEVICES_SUPP 0x1
> -int optee_enumerate_devices(u32 func);
> +static inline void optee_from_msg_param_value(struct tee_param *p, u32 attr,
> + const struct optee_msg_param *mp)
> +{
> + p->attr = TEE_IOCTL_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;
> +}
> +
> +static inline void optee_to_msg_param_value(struct optee_msg_param *mp,
> + const struct tee_param *p)
> +{
> + mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
> + TEE_IOCTL_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;
> +}
> +
> +void optee_cq_wait_init(struct optee_call_queue *cq,
> + struct optee_call_waiter *w);
> +void optee_cq_wait_for_completion(struct optee_call_queue *cq,
> + struct optee_call_waiter *w);
> +void optee_cq_wait_final(struct optee_call_queue *cq,
> + struct optee_call_waiter *w);
> +int optee_check_mem_type(unsigned long start, size_t num_pages);
> +struct tee_shm *optee_get_msg_arg(struct tee_context *ctx, size_t num_params,
> + struct optee_msg_arg **msg_arg);
> +
> +struct tee_shm *optee_rpc_cmd_alloc_suppl(struct tee_context *ctx, size_t sz);
> +void optee_rpc_cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm);
> +void optee_rpc_func_cmd_get_time(struct optee_msg_arg *arg);
> +void optee_rpc_func_cmd_wq(struct optee *optee, struct optee_msg_arg *arg);
> +void optee_rpc_func_cmd_wait(struct optee_msg_arg *arg);
> +void optee_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> + struct optee_msg_arg *arg);
> +void optee_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
> + struct optee_msg_arg *arg);
>
> /*
> * Small helpers
> diff --git a/drivers/tee/optee/rpc.c b/drivers/tee/optee/rpc.c
> index 39562fb6841e..e99e353b3f29 100644
> --- a/drivers/tee/optee/rpc.c
> +++ b/drivers/tee/optee/rpc.c
> @@ -6,12 +6,10 @@
> #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
>
> #include <linux/delay.h>
> -#include <linux/device.h>
> #include <linux/i2c.h>
> #include <linux/slab.h>
> #include <linux/tee_drv.h>
> #include "optee_private.h"
> -#include "optee_smc.h"
> #include "optee_rpc_cmd.h"
>
> struct wq_entry {
> @@ -31,7 +29,7 @@ void optee_wait_queue_exit(struct optee_wait_queue *priv)
> mutex_destroy(&priv->mu);
> }
>
> -static void handle_rpc_func_cmd_get_time(struct optee_msg_arg *arg)
> +void optee_rpc_func_cmd_get_time(struct optee_msg_arg *arg)
> {
> struct timespec64 ts;
>
> @@ -52,8 +50,8 @@ static void handle_rpc_func_cmd_get_time(struct optee_msg_arg *arg)
> }
>
> #if IS_REACHABLE(CONFIG_I2C)
> -static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> - struct optee_msg_arg *arg)
> +void optee_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> + struct optee_msg_arg *arg)
> {
> struct optee *optee = tee_get_drvdata(ctx->teedev);
> struct tee_param *params;
> @@ -139,8 +137,8 @@ static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> }
> #else
> -static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> - struct optee_msg_arg *arg)
> +void optee_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> + struct optee_msg_arg *arg)
> {
> arg->ret = TEEC_ERROR_NOT_SUPPORTED;
> }
> @@ -188,8 +186,7 @@ static void wq_wakeup(struct optee_wait_queue *wq, u32 key)
> complete(&w->c);
> }
>
> -static void handle_rpc_func_cmd_wq(struct optee *optee,
> - struct optee_msg_arg *arg)
> +void optee_rpc_func_cmd_wq(struct optee *optee, struct optee_msg_arg *arg)
> {
> if (arg->num_params != 1)
> goto bad;
> @@ -215,7 +212,7 @@ static void handle_rpc_func_cmd_wq(struct optee *optee,
> arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> }
>
> -static void handle_rpc_func_cmd_wait(struct optee_msg_arg *arg)
> +void optee_rpc_func_cmd_wait(struct optee_msg_arg *arg)
> {
> u32 msec_to_wait;
>
> @@ -237,8 +234,8 @@ static void handle_rpc_func_cmd_wait(struct optee_msg_arg *arg)
> arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> }
>
> -static void handle_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
> - struct optee_msg_arg *arg)
> +void optee_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
> + struct optee_msg_arg *arg)
> {
> struct tee_param *params;
>
> @@ -266,7 +263,7 @@ static void handle_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
> kfree(params);
> }
>
> -static struct tee_shm *cmd_alloc_suppl(struct tee_context *ctx, size_t sz)
> +struct tee_shm *optee_rpc_cmd_alloc_suppl(struct tee_context *ctx, size_t sz)
> {
> u32 ret;
> struct tee_param param;
> @@ -289,103 +286,7 @@ static struct tee_shm *cmd_alloc_suppl(struct tee_context *ctx, size_t sz)
> return shm;
> }
>
> -static void handle_rpc_func_cmd_shm_alloc(struct tee_context *ctx,
> - struct optee_msg_arg *arg,
> - struct optee_call_ctx *call_ctx)
> -{
> - phys_addr_t pa;
> - struct tee_shm *shm;
> - size_t sz;
> - size_t n;
> -
> - arg->ret_origin = TEEC_ORIGIN_COMMS;
> -
> - if (!arg->num_params ||
> - arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) {
> - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> - return;
> - }
> -
> - for (n = 1; n < arg->num_params; n++) {
> - if (arg->params[n].attr != OPTEE_MSG_ATTR_TYPE_NONE) {
> - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> - return;
> - }
> - }
> -
> - sz = arg->params[0].u.value.b;
> - switch (arg->params[0].u.value.a) {
> - case OPTEE_RPC_SHM_TYPE_APPL:
> - shm = cmd_alloc_suppl(ctx, sz);
> - break;
> - case OPTEE_RPC_SHM_TYPE_KERNEL:
> - shm = tee_shm_alloc(ctx, sz, TEE_SHM_MAPPED);
> - break;
> - default:
> - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> - return;
> - }
> -
> - if (IS_ERR(shm)) {
> - arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
> - return;
> - }
> -
> - if (tee_shm_get_pa(shm, 0, &pa)) {
> - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> - goto bad;
> - }
> -
> - sz = tee_shm_get_size(shm);
> -
> - if (tee_shm_is_registered(shm)) {
> - struct page **pages;
> - u64 *pages_list;
> - size_t page_num;
> -
> - pages = tee_shm_get_pages(shm, &page_num);
> - if (!pages || !page_num) {
> - arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
> - goto bad;
> - }
> -
> - pages_list = optee_allocate_pages_list(page_num);
> - if (!pages_list) {
> - arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
> - goto bad;
> - }
> -
> - call_ctx->pages_list = pages_list;
> - call_ctx->num_entries = page_num;
> -
> - arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT |
> - OPTEE_MSG_ATTR_NONCONTIG;
> - /*
> - * In the least bits of u.tmem.buf_ptr we store buffer offset
> - * from 4k page, as described in OP-TEE ABI.
> - */
> - arg->params[0].u.tmem.buf_ptr = virt_to_phys(pages_list) |
> - (tee_shm_get_page_offset(shm) &
> - (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
> - arg->params[0].u.tmem.size = tee_shm_get_size(shm);
> - arg->params[0].u.tmem.shm_ref = (unsigned long)shm;
> -
> - optee_fill_pages_list(pages_list, pages, page_num,
> - tee_shm_get_page_offset(shm));
> - } else {
> - arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT;
> - arg->params[0].u.tmem.buf_ptr = pa;
> - arg->params[0].u.tmem.size = sz;
> - arg->params[0].u.tmem.shm_ref = (unsigned long)shm;
> - }
> -
> - arg->ret = TEEC_SUCCESS;
> - return;
> -bad:
> - tee_shm_free(shm);
> -}
> -
> -static void cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm)
> +void optee_rpc_cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm)
> {
> struct tee_param param;
>
> @@ -409,137 +310,3 @@ static void cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm)
>
> optee_supp_thrd_req(ctx, OPTEE_RPC_CMD_SHM_FREE, 1, &param);
> }
> -
> -static void handle_rpc_func_cmd_shm_free(struct tee_context *ctx,
> - struct optee_msg_arg *arg)
> -{
> - struct tee_shm *shm;
> -
> - arg->ret_origin = TEEC_ORIGIN_COMMS;
> -
> - if (arg->num_params != 1 ||
> - arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) {
> - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> - return;
> - }
> -
> - shm = (struct tee_shm *)(unsigned long)arg->params[0].u.value.b;
> - switch (arg->params[0].u.value.a) {
> - case OPTEE_RPC_SHM_TYPE_APPL:
> - cmd_free_suppl(ctx, shm);
> - break;
> - case OPTEE_RPC_SHM_TYPE_KERNEL:
> - tee_shm_free(shm);
> - break;
> - default:
> - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> - }
> - arg->ret = TEEC_SUCCESS;
> -}
> -
> -static void free_pages_list(struct optee_call_ctx *call_ctx)
> -{
> - if (call_ctx->pages_list) {
> - optee_free_pages_list(call_ctx->pages_list,
> - call_ctx->num_entries);
> - call_ctx->pages_list = NULL;
> - call_ctx->num_entries = 0;
> - }
> -}
> -
> -void optee_rpc_finalize_call(struct optee_call_ctx *call_ctx)
> -{
> - free_pages_list(call_ctx);
> -}
> -
> -static void handle_rpc_func_cmd(struct tee_context *ctx, struct optee *optee,
> - struct tee_shm *shm,
> - struct optee_call_ctx *call_ctx)
> -{
> - struct optee_msg_arg *arg;
> -
> - arg = tee_shm_get_va(shm, 0);
> - if (IS_ERR(arg)) {
> - pr_err("%s: tee_shm_get_va %p failed\n", __func__, shm);
> - return;
> - }
> -
> - switch (arg->cmd) {
> - case OPTEE_RPC_CMD_GET_TIME:
> - handle_rpc_func_cmd_get_time(arg);
> - break;
> - case OPTEE_RPC_CMD_WAIT_QUEUE:
> - handle_rpc_func_cmd_wq(optee, arg);
> - break;
> - case OPTEE_RPC_CMD_SUSPEND:
> - handle_rpc_func_cmd_wait(arg);
> - break;
> - case OPTEE_RPC_CMD_SHM_ALLOC:
> - free_pages_list(call_ctx);
> - handle_rpc_func_cmd_shm_alloc(ctx, arg, call_ctx);
> - break;
> - case OPTEE_RPC_CMD_SHM_FREE:
> - handle_rpc_func_cmd_shm_free(ctx, arg);
> - break;
> - case OPTEE_RPC_CMD_I2C_TRANSFER:
> - handle_rpc_func_cmd_i2c_transfer(ctx, arg);
> - break;
> - default:
> - handle_rpc_supp_cmd(ctx, optee, arg);
> - }
> -}
> -
> -/**
> - * optee_handle_rpc() - handle RPC from secure world
> - * @ctx: context doing the RPC
> - * @param: value of registers for the RPC
> - * @call_ctx: call context. Preserved during one OP-TEE invocation
> - *
> - * Result of RPC is written back into @param.
> - */
> -void optee_handle_rpc(struct tee_context *ctx, struct optee_rpc_param *param,
> - struct optee_call_ctx *call_ctx)
> -{
> - struct tee_device *teedev = ctx->teedev;
> - struct optee *optee = tee_get_drvdata(teedev);
> - struct tee_shm *shm;
> - phys_addr_t pa;
> -
> - switch (OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0)) {
> - case OPTEE_SMC_RPC_FUNC_ALLOC:
> - shm = tee_shm_alloc(ctx, param->a1, TEE_SHM_MAPPED);
> - if (!IS_ERR(shm) && !tee_shm_get_pa(shm, 0, &pa)) {
> - reg_pair_from_64(&param->a1, &param->a2, pa);
> - reg_pair_from_64(&param->a4, &param->a5,
> - (unsigned long)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:
> - /*
> - * A foreign interrupt was raised while secure world was
> - * executing, since they are handled in Linux a dummy RPC is
> - * performed to let Linux take the interrupt through the normal
> - * vector.
> - */
> - break;
> - case OPTEE_SMC_RPC_FUNC_CMD:
> - shm = reg_pair_to_ptr(param->a1, param->a2);
> - handle_rpc_func_cmd(ctx, optee, shm, call_ctx);
> - break;
> - default:
> - pr_warn("Unknown RPC func 0x%x\n",
> - (u32)OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0));
> - break;
> - }
> -
> - param->a0 = OPTEE_SMC_CALL_RETURN_FROM_RPC;
> -}

Isn't it possible to keep this RPC handling as part of common code
only rather than ABI specific as otherwise for every new RPC command
handling support we need to maintain a sync for both SMC and FF-A ABI?
Given we should be able to create new ABI specific callbacks for this
as well eg. for managing shared memory etc.

-Sumit

> diff --git a/drivers/tee/optee/shm_pool.c b/drivers/tee/optee/shm_pool.c
> deleted file mode 100644
> index d767eebf30bd..000000000000
> --- a/drivers/tee/optee/shm_pool.c
> +++ /dev/null
> @@ -1,89 +0,0 @@
> -// SPDX-License-Identifier: GPL-2.0-only
> -/*
> - * Copyright (c) 2015, Linaro Limited
> - * Copyright (c) 2017, EPAM Systems
> - */
> -#include <linux/device.h>
> -#include <linux/dma-buf.h>
> -#include <linux/genalloc.h>
> -#include <linux/slab.h>
> -#include <linux/tee_drv.h>
> -#include "optee_private.h"
> -#include "optee_smc.h"
> -#include "shm_pool.h"
> -
> -static int pool_op_alloc(struct tee_shm_pool_mgr *poolm,
> - struct tee_shm *shm, size_t size)
> -{
> - unsigned int order = get_order(size);
> - struct page *page;
> - int rc = 0;
> -
> - page = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
> - if (!page)
> - return -ENOMEM;
> -
> - shm->kaddr = page_address(page);
> - shm->paddr = page_to_phys(page);
> - shm->size = PAGE_SIZE << order;
> -
> - if (shm->flags & TEE_SHM_DMA_BUF) {
> - unsigned int nr_pages = 1 << order, i;
> - struct page **pages;
> -
> - pages = kcalloc(nr_pages, sizeof(pages), GFP_KERNEL);
> - if (!pages)
> - return -ENOMEM;
> -
> - for (i = 0; i < nr_pages; i++) {
> - pages[i] = page;
> - page++;
> - }
> -
> - shm->flags |= TEE_SHM_REGISTER;
> - rc = optee_shm_register(shm->ctx, shm, pages, nr_pages,
> - (unsigned long)shm->kaddr);
> - kfree(pages);
> - }
> -
> - return rc;
> -}
> -
> -static void pool_op_free(struct tee_shm_pool_mgr *poolm,
> - struct tee_shm *shm)
> -{
> - if (shm->flags & TEE_SHM_DMA_BUF)
> - optee_shm_unregister(shm->ctx, shm);
> -
> - free_pages((unsigned long)shm->kaddr, get_order(shm->size));
> - shm->kaddr = NULL;
> -}
> -
> -static void pool_op_destroy_poolmgr(struct tee_shm_pool_mgr *poolm)
> -{
> - kfree(poolm);
> -}
> -
> -static const struct tee_shm_pool_mgr_ops pool_ops = {
> - .alloc = pool_op_alloc,
> - .free = pool_op_free,
> - .destroy_poolmgr = pool_op_destroy_poolmgr,
> -};
> -
> -/**
> - * optee_shm_pool_alloc_pages() - create page-based allocator pool
> - *
> - * This pool is used when OP-TEE supports dymanic SHM. In this case
> - * command buffers and such are allocated from kernel's own memory.
> - */
> -struct tee_shm_pool_mgr *optee_shm_pool_alloc_pages(void)
> -{
> - struct tee_shm_pool_mgr *mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
> -
> - if (!mgr)
> - return ERR_PTR(-ENOMEM);
> -
> - mgr->ops = &pool_ops;
> -
> - return mgr;
> -}
> diff --git a/drivers/tee/optee/shm_pool.h b/drivers/tee/optee/shm_pool.h
> deleted file mode 100644
> index 28109d991c4b..000000000000
> --- a/drivers/tee/optee/shm_pool.h
> +++ /dev/null
> @@ -1,14 +0,0 @@
> -/* SPDX-License-Identifier: GPL-2.0-only */
> -/*
> - * Copyright (c) 2015, Linaro Limited
> - * Copyright (c) 2016, EPAM Systems
> - */
> -
> -#ifndef SHM_POOL_H
> -#define SHM_POOL_H
> -
> -#include <linux/tee_drv.h>
> -
> -struct tee_shm_pool_mgr *optee_shm_pool_alloc_pages(void);
> -
> -#endif
> diff --git a/drivers/tee/optee/smc_abi.c b/drivers/tee/optee/smc_abi.c
> new file mode 100644
> index 000000000000..f87c62e33694
> --- /dev/null
> +++ b/drivers/tee/optee/smc_abi.c
> @@ -0,0 +1,1301 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (c) 2015-2021, Linaro Limited
> + * Copyright (c) 2016, EPAM Systems
> + */
> +
> +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
> +
> +#include <linux/arm-smccc.h>
> +#include <linux/errno.h>
> +#include <linux/io.h>
> +#include <linux/sched.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/of_platform.h>
> +#include <linux/platform_device.h>
> +#include <linux/slab.h>
> +#include <linux/string.h>
> +#include <linux/tee_drv.h>
> +#include <linux/types.h>
> +#include <linux/workqueue.h>
> +#include "optee_private.h"
> +#include "optee_smc.h"
> +#include "optee_rpc_cmd.h"
> +#define CREATE_TRACE_POINTS
> +#include "optee_trace.h"
> +
> +/*
> + * This file implement the SMC ABI used when communicating with secure world
> + * OP-TEE OS via raw SMCs.
> + * This file is divided into the follow sections:
> + * 1. Convert between struct tee_param and struct optee_msg_param
> + * 2. Low level support functions to register shared memory in secure world
> + * 3. Dynamic shared memory pool based on alloc_pages()
> + * 4. Do a normal scheduled call into secure world
> + * 5. Driver initialization.
> + */
> +
> +#define OPTEE_SHM_NUM_PRIV_PAGES CONFIG_OPTEE_SHM_NUM_PRIV_PAGES
> +
> +/*
> + * 1. Convert between struct tee_param and struct optee_msg_param
> + *
> + * optee_from_msg_param() and optee_to_msg_param() are the main
> + * functions.
> + */
> +
> +static int from_msg_param_tmp_mem(struct tee_param *p, u32 attr,
> + const struct optee_msg_param *mp)
> +{
> + struct tee_shm *shm;
> + phys_addr_t pa;
> + int rc;
> +
> + p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> + attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
> + p->u.memref.size = mp->u.tmem.size;
> + shm = (struct tee_shm *)(unsigned long)mp->u.tmem.shm_ref;
> + if (!shm) {
> + p->u.memref.shm_offs = 0;
> + p->u.memref.shm = NULL;
> + return 0;
> + }
> +
> + rc = tee_shm_get_pa(shm, 0, &pa);
> + if (rc)
> + return rc;
> +
> + p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
> + p->u.memref.shm = shm;
> +
> + /* Check that the memref is covered by the shm object */
> + if (p->u.memref.size) {
> + size_t o = p->u.memref.shm_offs +
> + p->u.memref.size - 1;
> +
> + rc = tee_shm_get_pa(shm, o, NULL);
> + if (rc)
> + return rc;
> + }
> +
> + return 0;
> +}
> +
> +static void from_msg_param_reg_mem(struct tee_param *p, u32 attr,
> + const struct optee_msg_param *mp)
> +{
> + struct tee_shm *shm;
> +
> + p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> + attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> + p->u.memref.size = mp->u.rmem.size;
> + shm = (struct tee_shm *)(unsigned long)mp->u.rmem.shm_ref;
> +
> + if (shm) {
> + p->u.memref.shm_offs = mp->u.rmem.offs;
> + p->u.memref.shm = shm;
> + } else {
> + p->u.memref.shm_offs = 0;
> + p->u.memref.shm = NULL;
> + }
> +}
> +
> +/**
> + * optee_from_msg_param() - convert from OPTEE_MSG parameters to
> + * struct tee_param
> + * @optee: main service struct
> + * @params: subsystem internal parameter representation
> + * @num_params: number of elements in the parameter arrays
> + * @msg_params: OPTEE_MSG parameters
> + * Returns 0 on success or <0 on failure
> + */
> +static int optee_from_msg_param(struct optee *optee, struct tee_param *params,
> + size_t num_params,
> + const struct optee_msg_param *msg_params)
> +{
> + int rc;
> + size_t n;
> +
> + 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_IOCTL_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:
> + optee_from_msg_param_value(p, attr, mp);
> + break;
> + case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:
> + case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
> + case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
> + rc = from_msg_param_tmp_mem(p, attr, mp);
> + if (rc)
> + return rc;
> + break;
> + case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:
> + case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:
> + case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:
> + from_msg_param_reg_mem(p, attr, mp);
> + break;
> +
> + default:
> + return -EINVAL;
> + }
> + }
> + return 0;
> +}
> +
> +static int to_msg_param_tmp_mem(struct optee_msg_param *mp,
> + const struct tee_param *p)
> +{
> + int rc;
> + phys_addr_t pa;
> +
> + mp->attr = OPTEE_MSG_ATTR_TYPE_TMEM_INPUT + p->attr -
> + TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
> +
> + mp->u.tmem.shm_ref = (unsigned long)p->u.memref.shm;
> + mp->u.tmem.size = p->u.memref.size;
> +
> + if (!p->u.memref.shm) {
> + mp->u.tmem.buf_ptr = 0;
> + return 0;
> + }
> +
> + rc = tee_shm_get_pa(p->u.memref.shm, p->u.memref.shm_offs, &pa);
> + if (rc)
> + return rc;
> +
> + mp->u.tmem.buf_ptr = pa;
> + mp->attr |= OPTEE_MSG_ATTR_CACHE_PREDEFINED <<
> + OPTEE_MSG_ATTR_CACHE_SHIFT;
> +
> + return 0;
> +}
> +
> +static int to_msg_param_reg_mem(struct optee_msg_param *mp,
> + const struct tee_param *p)
> +{
> + mp->attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT + p->attr -
> + TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
> +
> + mp->u.rmem.shm_ref = (unsigned long)p->u.memref.shm;
> + mp->u.rmem.size = p->u.memref.size;
> + mp->u.rmem.offs = p->u.memref.shm_offs;
> + return 0;
> +}
> +
> +/**
> + * optee_to_msg_param() - convert from struct tee_params to OPTEE_MSG parameters
> + * @optee: main service struct
> + * @msg_params: OPTEE_MSG parameters
> + * @num_params: number of elements in the parameter arrays
> + * @params: subsystem itnernal parameter representation
> + * Returns 0 on success or <0 on failure
> + */
> +static int optee_to_msg_param(struct optee *optee,
> + struct optee_msg_param *msg_params,
> + size_t num_params, const struct tee_param *params)
> +{
> + int rc;
> + size_t 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_IOCTL_PARAM_ATTR_TYPE_NONE:
> + mp->attr = TEE_IOCTL_PARAM_ATTR_TYPE_NONE;
> + memset(&mp->u, 0, sizeof(mp->u));
> + break;
> + case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT:
> + case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
> + case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
> + optee_to_msg_param_value(mp, p);
> + break;
> + case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT:
> + case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
> + case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:
> + if (tee_shm_is_registered(p->u.memref.shm))
> + rc = to_msg_param_reg_mem(mp, p);
> + else
> + rc = to_msg_param_tmp_mem(mp, p);
> + if (rc)
> + return rc;
> + break;
> + default:
> + return -EINVAL;
> + }
> + }
> + return 0;
> +}
> +
> +/*
> + * 2. Low level support functions to register shared memory in secure world
> + *
> + * Functions to enable/disable shared memory caching in secure world, that
> + * is, lazy freeing of previously allocated shared memory. Freeing is
> + * performed when a request has been compled.
> + *
> + * Functions to register and unregister shared memory both for normal
> + * clients and for tee-supplicant.
> + */
> +
> +/**
> + * optee_enable_shm_cache() - Enables caching of some shared memory allocation
> + * in OP-TEE
> + * @optee: main service struct
> + */
> +static void optee_enable_shm_cache(struct optee *optee)
> +{
> + struct optee_call_waiter w;
> +
> + /* We need to retry until secure world isn't busy. */
> + optee_cq_wait_init(&optee->call_queue, &w);
> + while (true) {
> + struct arm_smccc_res res;
> +
> + optee->smc.invoke_fn(OPTEE_SMC_ENABLE_SHM_CACHE,
> + 0, 0, 0, 0, 0, 0, 0, &res);
> + if (res.a0 == OPTEE_SMC_RETURN_OK)
> + break;
> + optee_cq_wait_for_completion(&optee->call_queue, &w);
> + }
> + optee_cq_wait_final(&optee->call_queue, &w);
> +}
> +
> +/**
> + * optee_disable_shm_cache() - Disables caching of some shared memory allocation
> + * in OP-TEE
> + * @optee: main service struct
> + */
> +static void optee_disable_shm_cache(struct optee *optee)
> +{
> + struct optee_call_waiter w;
> +
> + /* We need to retry until secure world isn't busy. */
> + optee_cq_wait_init(&optee->call_queue, &w);
> + while (true) {
> + union {
> + struct arm_smccc_res smccc;
> + struct optee_smc_disable_shm_cache_result result;
> + } res;
> +
> + optee->smc.invoke_fn(OPTEE_SMC_DISABLE_SHM_CACHE,
> + 0, 0, 0, 0, 0, 0, 0, &res.smccc);
> + if (res.result.status == OPTEE_SMC_RETURN_ENOTAVAIL)
> + break; /* All shm's freed */
> + if (res.result.status == OPTEE_SMC_RETURN_OK) {
> + struct tee_shm *shm;
> +
> + shm = reg_pair_to_ptr(res.result.shm_upper32,
> + res.result.shm_lower32);
> + tee_shm_free(shm);
> + } else {
> + optee_cq_wait_for_completion(&optee->call_queue, &w);
> + }
> + }
> + optee_cq_wait_final(&optee->call_queue, &w);
> +}
> +
> +#define PAGELIST_ENTRIES_PER_PAGE \
> + ((OPTEE_MSG_NONCONTIG_PAGE_SIZE / sizeof(u64)) - 1)
> +
> +/*
> + * The final entry in each pagelist page is a pointer to the next
> + * pagelist page.
> + */
> +static size_t get_pages_list_size(size_t num_entries)
> +{
> + int pages = DIV_ROUND_UP(num_entries, PAGELIST_ENTRIES_PER_PAGE);
> +
> + return pages * OPTEE_MSG_NONCONTIG_PAGE_SIZE;
> +}
> +
> +static u64 *optee_allocate_pages_list(size_t num_entries)
> +{
> + return alloc_pages_exact(get_pages_list_size(num_entries), GFP_KERNEL);
> +}
> +
> +static void optee_free_pages_list(void *list, size_t num_entries)
> +{
> + free_pages_exact(list, get_pages_list_size(num_entries));
> +}
> +
> +/**
> + * optee_fill_pages_list() - write list of user pages to given shared
> + * buffer.
> + *
> + * @dst: page-aligned buffer where list of pages will be stored
> + * @pages: array of pages that represents shared buffer
> + * @num_pages: number of entries in @pages
> + * @page_offset: offset of user buffer from page start
> + *
> + * @dst should be big enough to hold list of user page addresses and
> + * links to the next pages of buffer
> + */
> +static void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,
> + size_t page_offset)
> +{
> + int n = 0;
> + phys_addr_t optee_page;
> + /*
> + * Refer to OPTEE_MSG_ATTR_NONCONTIG description in optee_msg.h
> + * for details.
> + */
> + struct {
> + u64 pages_list[PAGELIST_ENTRIES_PER_PAGE];
> + u64 next_page_data;
> + } *pages_data;
> +
> + /*
> + * Currently OP-TEE uses 4k page size and it does not looks
> + * like this will change in the future. On other hand, there are
> + * no know ARM architectures with page size < 4k.
> + * Thus the next built assert looks redundant. But the following
> + * code heavily relies on this assumption, so it is better be
> + * safe than sorry.
> + */
> + BUILD_BUG_ON(PAGE_SIZE < OPTEE_MSG_NONCONTIG_PAGE_SIZE);
> +
> + pages_data = (void *)dst;
> + /*
> + * If linux page is bigger than 4k, and user buffer offset is
> + * larger than 4k/8k/12k/etc this will skip first 4k pages,
> + * because they bear no value data for OP-TEE.
> + */
> + optee_page = page_to_phys(*pages) +
> + round_down(page_offset, OPTEE_MSG_NONCONTIG_PAGE_SIZE);
> +
> + while (true) {
> + pages_data->pages_list[n++] = optee_page;
> +
> + if (n == PAGELIST_ENTRIES_PER_PAGE) {
> + pages_data->next_page_data =
> + virt_to_phys(pages_data + 1);
> + pages_data++;
> + n = 0;
> + }
> +
> + optee_page += OPTEE_MSG_NONCONTIG_PAGE_SIZE;
> + if (!(optee_page & ~PAGE_MASK)) {
> + if (!--num_pages)
> + break;
> + pages++;
> + optee_page = page_to_phys(*pages);
> + }
> + }
> +}
> +
> +static int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> + struct page **pages, size_t num_pages,
> + unsigned long start)
> +{
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
> + struct optee_msg_arg *msg_arg;
> + struct tee_shm *shm_arg;
> + u64 *pages_list;
> + int rc;
> +
> + if (!num_pages)
> + return -EINVAL;
> +
> + rc = optee_check_mem_type(start, num_pages);
> + if (rc)
> + return rc;
> +
> + pages_list = optee_allocate_pages_list(num_pages);
> + if (!pages_list)
> + return -ENOMEM;
> +
> + shm_arg = optee_get_msg_arg(ctx, 1, &msg_arg);
> + if (IS_ERR(shm_arg)) {
> + rc = PTR_ERR(shm_arg);
> + goto out;
> + }
> +
> + optee_fill_pages_list(pages_list, pages, num_pages,
> + tee_shm_get_page_offset(shm));
> +
> + 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.shm_ref = (unsigned long)shm;
> + msg_arg->params->u.tmem.size = tee_shm_get_size(shm);
> + /*
> + * In the least bits of msg_arg->params->u.tmem.buf_ptr we
> + * store buffer offset from 4k page, as described in OP-TEE ABI.
> + */
> + msg_arg->params->u.tmem.buf_ptr = virt_to_phys(pages_list) |
> + (tee_shm_get_page_offset(shm) & (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
> +
> + if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> + msg_arg->ret != TEEC_SUCCESS)
> + rc = -EINVAL;
> +
> + tee_shm_free(shm_arg);
> +out:
> + optee_free_pages_list(pages_list, num_pages);
> + return rc;
> +}
> +
> +static int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
> +{
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
> + struct optee_msg_arg *msg_arg;
> + struct tee_shm *shm_arg;
> + int rc = 0;
> +
> + shm_arg = optee_get_msg_arg(ctx, 1, &msg_arg);
> + if (IS_ERR(shm_arg))
> + return PTR_ERR(shm_arg);
> +
> + 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 = (unsigned long)shm;
> +
> + if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> + msg_arg->ret != TEEC_SUCCESS)
> + rc = -EINVAL;
> + tee_shm_free(shm_arg);
> + return rc;
> +}
> +
> +static int optee_shm_register_supp(struct tee_context *ctx, struct tee_shm *shm,
> + struct page **pages, size_t num_pages,
> + unsigned long start)
> +{
> + /*
> + * We don't want to register supplicant memory in OP-TEE.
> + * Instead information about it will be passed in RPC code.
> + */
> + return optee_check_mem_type(start, num_pages);
> +}
> +
> +static int optee_shm_unregister_supp(struct tee_context *ctx,
> + struct tee_shm *shm)
> +{
> + return 0;
> +}
> +
> +/*
> + * 3. Dynamic shared memory pool based on alloc_pages()
> + *
> + * Implements an OP-TEE specific shared memory pool which is used
> + * when dynamic shared memory is supported by secure world.
> + *
> + * The main function is optee_shm_pool_alloc_pages().
> + */
> +
> +static int pool_op_alloc(struct tee_shm_pool_mgr *poolm,
> + struct tee_shm *shm, size_t size)
> +{
> + if (!(shm->flags & TEE_SHM_DMA_BUF))
> + return optee_pool_op_alloc_helper(poolm, shm, size, NULL);
> +
> + return optee_pool_op_alloc_helper(poolm, shm, size, optee_shm_register);
> +}
> +
> +static void pool_op_free(struct tee_shm_pool_mgr *poolm,
> + struct tee_shm *shm)
> +{
> + if (shm->flags & TEE_SHM_DMA_BUF)
> + optee_shm_unregister(shm->ctx, shm);
> +
> + free_pages((unsigned long)shm->kaddr, get_order(shm->size));
> + shm->kaddr = NULL;
> +}
> +
> +static void pool_op_destroy_poolmgr(struct tee_shm_pool_mgr *poolm)
> +{
> + kfree(poolm);
> +}
> +
> +static const struct tee_shm_pool_mgr_ops pool_ops = {
> + .alloc = pool_op_alloc,
> + .free = pool_op_free,
> + .destroy_poolmgr = pool_op_destroy_poolmgr,
> +};
> +
> +/**
> + * optee_shm_pool_alloc_pages() - create page-based allocator pool
> + *
> + * This pool is used when OP-TEE supports dymanic SHM. In this case
> + * command buffers and such are allocated from kernel's own memory.
> + */
> +static struct tee_shm_pool_mgr *optee_shm_pool_alloc_pages(void)
> +{
> + struct tee_shm_pool_mgr *mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
> +
> + if (!mgr)
> + return ERR_PTR(-ENOMEM);
> +
> + mgr->ops = &pool_ops;
> +
> + return mgr;
> +}
> +
> +/*
> + * 4. Do a normal scheduled call into secure world
> + *
> + * The function optee_smc_do_call_with_arg() performs a normal scheduled
> + * call into secure world. During this call may normal world request help
> + * from normal world using RPCs, Remote Procedure Calls. This includes
> + * delivery of non-secure interrupts to for instance allow rescheduling of
> + * the current task.
> + */
> +
> +static void handle_rpc_func_cmd_shm_free(struct tee_context *ctx,
> + struct optee_msg_arg *arg)
> +{
> + struct tee_shm *shm;
> +
> + arg->ret_origin = TEEC_ORIGIN_COMMS;
> +
> + if (arg->num_params != 1 ||
> + arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) {
> + arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> + return;
> + }
> +
> + shm = (struct tee_shm *)(unsigned long)arg->params[0].u.value.b;
> + switch (arg->params[0].u.value.a) {
> + case OPTEE_RPC_SHM_TYPE_APPL:
> + optee_rpc_cmd_free_suppl(ctx, shm);
> + break;
> + case OPTEE_RPC_SHM_TYPE_KERNEL:
> + tee_shm_free(shm);
> + break;
> + default:
> + arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> + }
> + arg->ret = TEEC_SUCCESS;
> +}
> +
> +static void handle_rpc_func_cmd_shm_alloc(struct tee_context *ctx,
> + struct optee_msg_arg *arg,
> + struct optee_call_ctx *call_ctx)
> +{
> + phys_addr_t pa;
> + struct tee_shm *shm;
> + size_t sz;
> + size_t n;
> +
> + arg->ret_origin = TEEC_ORIGIN_COMMS;
> +
> + if (!arg->num_params ||
> + arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) {
> + arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> + return;
> + }
> +
> + for (n = 1; n < arg->num_params; n++) {
> + if (arg->params[n].attr != OPTEE_MSG_ATTR_TYPE_NONE) {
> + arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> + return;
> + }
> + }
> +
> + sz = arg->params[0].u.value.b;
> + switch (arg->params[0].u.value.a) {
> + case OPTEE_RPC_SHM_TYPE_APPL:
> + shm = optee_rpc_cmd_alloc_suppl(ctx, sz);
> + break;
> + case OPTEE_RPC_SHM_TYPE_KERNEL:
> + shm = tee_shm_alloc(ctx, sz, TEE_SHM_MAPPED);
> + break;
> + default:
> + arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> + return;
> + }
> +
> + if (IS_ERR(shm)) {
> + arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
> + return;
> + }
> +
> + if (tee_shm_get_pa(shm, 0, &pa)) {
> + arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> + goto bad;
> + }
> +
> + sz = tee_shm_get_size(shm);
> +
> + if (tee_shm_is_registered(shm)) {
> + struct page **pages;
> + u64 *pages_list;
> + size_t page_num;
> +
> + pages = tee_shm_get_pages(shm, &page_num);
> + if (!pages || !page_num) {
> + arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
> + goto bad;
> + }
> +
> + pages_list = optee_allocate_pages_list(page_num);
> + if (!pages_list) {
> + arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
> + goto bad;
> + }
> +
> + call_ctx->pages_list = pages_list;
> + call_ctx->num_entries = page_num;
> +
> + arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT |
> + OPTEE_MSG_ATTR_NONCONTIG;
> + /*
> + * In the least bits of u.tmem.buf_ptr we store buffer offset
> + * from 4k page, as described in OP-TEE ABI.
> + */
> + arg->params[0].u.tmem.buf_ptr = virt_to_phys(pages_list) |
> + (tee_shm_get_page_offset(shm) &
> + (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
> + arg->params[0].u.tmem.size = tee_shm_get_size(shm);
> + arg->params[0].u.tmem.shm_ref = (unsigned long)shm;
> +
> + optee_fill_pages_list(pages_list, pages, page_num,
> + tee_shm_get_page_offset(shm));
> + } else {
> + arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT;
> + arg->params[0].u.tmem.buf_ptr = pa;
> + arg->params[0].u.tmem.size = sz;
> + arg->params[0].u.tmem.shm_ref = (unsigned long)shm;
> + }
> +
> + arg->ret = TEEC_SUCCESS;
> + return;
> +bad:
> + tee_shm_free(shm);
> +}
> +
> +static void free_pages_list(struct optee_call_ctx *call_ctx)
> +{
> + if (call_ctx->pages_list) {
> + optee_free_pages_list(call_ctx->pages_list,
> + call_ctx->num_entries);
> + call_ctx->pages_list = NULL;
> + call_ctx->num_entries = 0;
> + }
> +}
> +
> +static void optee_rpc_finalize_call(struct optee_call_ctx *call_ctx)
> +{
> + free_pages_list(call_ctx);
> +}
> +
> +static void handle_rpc_func_cmd(struct tee_context *ctx, struct optee *optee,
> + struct tee_shm *shm,
> + struct optee_call_ctx *call_ctx)
> +{
> + struct optee_msg_arg *arg;
> +
> + arg = tee_shm_get_va(shm, 0);
> + if (IS_ERR(arg)) {
> + pr_err("%s: tee_shm_get_va %p failed\n", __func__, shm);
> + return;
> + }
> +
> + switch (arg->cmd) {
> + case OPTEE_RPC_CMD_GET_TIME:
> + optee_rpc_func_cmd_get_time(arg);
> + break;
> + case OPTEE_RPC_CMD_WAIT_QUEUE:
> + optee_rpc_func_cmd_wq(optee, arg);
> + break;
> + case OPTEE_RPC_CMD_SUSPEND:
> + optee_rpc_func_cmd_wait(arg);
> + break;
> + case OPTEE_RPC_CMD_SHM_ALLOC:
> + free_pages_list(call_ctx);
> + handle_rpc_func_cmd_shm_alloc(ctx, arg, call_ctx);
> + break;
> + case OPTEE_RPC_CMD_SHM_FREE:
> + handle_rpc_func_cmd_shm_free(ctx, arg);
> + break;
> + case OPTEE_RPC_CMD_I2C_TRANSFER:
> + optee_rpc_func_cmd_i2c_transfer(ctx, arg);
> + break;
> + default:
> + optee_rpc_supp_cmd(ctx, optee, arg);
> + }
> +}
> +
> +/**
> + * optee_handle_rpc() - handle RPC from secure world
> + * @ctx: context doing the RPC
> + * @param: value of registers for the RPC
> + * @call_ctx: call context. Preserved during one OP-TEE invocation
> + *
> + * Result of RPC is written back into @param.
> + */
> +static void optee_handle_rpc(struct tee_context *ctx,
> + struct optee_rpc_param *param,
> + struct optee_call_ctx *call_ctx)
> +{
> + struct tee_device *teedev = ctx->teedev;
> + struct optee *optee = tee_get_drvdata(teedev);
> + struct tee_shm *shm;
> + phys_addr_t pa;
> +
> + switch (OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0)) {
> + case OPTEE_SMC_RPC_FUNC_ALLOC:
> + shm = tee_shm_alloc(ctx, param->a1, TEE_SHM_MAPPED);
> + if (!IS_ERR(shm) && !tee_shm_get_pa(shm, 0, &pa)) {
> + reg_pair_from_64(&param->a1, &param->a2, pa);
> + reg_pair_from_64(&param->a4, &param->a5,
> + (unsigned long)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:
> + /*
> + * A foreign interrupt was raised while secure world was
> + * executing, since they are handled in Linux a dummy RPC is
> + * performed to let Linux take the interrupt through the normal
> + * vector.
> + */
> + break;
> + case OPTEE_SMC_RPC_FUNC_CMD:
> + shm = reg_pair_to_ptr(param->a1, param->a2);
> + handle_rpc_func_cmd(ctx, optee, shm, call_ctx);
> + break;
> + default:
> + pr_warn("Unknown RPC func 0x%x\n",
> + (u32)OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0));
> + break;
> + }
> +
> + param->a0 = OPTEE_SMC_CALL_RETURN_FROM_RPC;
> +}
> +
> +/**
> + * optee_smc_do_call_with_arg() - Do an SMC to OP-TEE in secure world
> + * @ctx: calling context
> + * @arg: shared memory holding the message to pass to secure world
> + *
> + * Does and SMC to OP-TEE in secure world and handles eventual resulting
> + * Remote Procedure Calls (RPC) from OP-TEE.
> + *
> + * Returns return code from secure world, 0 is OK
> + */
> +static int optee_smc_do_call_with_arg(struct tee_context *ctx,
> + struct tee_shm *arg)
> +{
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
> + struct optee_call_waiter w;
> + struct optee_rpc_param param = { };
> + struct optee_call_ctx call_ctx = { };
> + phys_addr_t parg;
> + int rc;
> +
> + rc = tee_shm_get_pa(arg, 0, &parg);
> + if (rc)
> + return rc;
> +
> + param.a0 = OPTEE_SMC_CALL_WITH_ARG;
> + reg_pair_from_64(&param.a1, &param.a2, parg);
> + /* Initialize waiter */
> + optee_cq_wait_init(&optee->call_queue, &w);
> + while (true) {
> + struct arm_smccc_res res;
> +
> + trace_optee_invoke_fn_begin(&param);
> + optee->smc.invoke_fn(param.a0, param.a1, param.a2, param.a3,
> + param.a4, param.a5, param.a6, param.a7,
> + &res);
> + trace_optee_invoke_fn_end(&param, &res);
> +
> + if (res.a0 == OPTEE_SMC_RETURN_ETHREAD_LIMIT) {
> + /*
> + * Out of threads in secure world, wait for a thread
> + * become available.
> + */
> + optee_cq_wait_for_completion(&optee->call_queue, &w);
> + } else if (OPTEE_SMC_RETURN_IS_RPC(res.a0)) {
> + cond_resched();
> + param.a0 = res.a0;
> + param.a1 = res.a1;
> + param.a2 = res.a2;
> + param.a3 = res.a3;
> + optee_handle_rpc(ctx, &param, &call_ctx);
> + } else {
> + rc = res.a0;
> + break;
> + }
> + }
> +
> + optee_rpc_finalize_call(&call_ctx);
> + /*
> + * We're done with our thread in secure world, if there's any
> + * thread waiters wake up one.
> + */
> + optee_cq_wait_final(&optee->call_queue, &w);
> +
> + return rc;
> +}
> +
> +/*
> + * 5. Driver initialization
> + *
> + * During driver inititialization is secure world probed to find out which
> + * features it supports so the driver can be initialized with a matching
> + * configuration. This involves for instance support for dynamic shared
> + * memory instead of a static memory carvout.
> + */
> +
> +static void optee_get_version(struct tee_device *teedev,
> + struct tee_ioctl_version_data *vers)
> +{
> + struct tee_ioctl_version_data v = {
> + .impl_id = TEE_IMPL_ID_OPTEE,
> + .impl_caps = TEE_OPTEE_CAP_TZ,
> + .gen_caps = TEE_GEN_CAP_GP,
> + };
> + struct optee *optee = tee_get_drvdata(teedev);
> +
> + if (optee->smc.sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
> + v.gen_caps |= TEE_GEN_CAP_REG_MEM;
> + if (optee->smc.sec_caps & OPTEE_SMC_SEC_CAP_MEMREF_NULL)
> + v.gen_caps |= TEE_GEN_CAP_MEMREF_NULL;
> + *vers = v;
> +}
> +
> +static int optee_smc_open(struct tee_context *ctx)
> +{
> + struct optee *optee = tee_get_drvdata(ctx->teedev);
> + u32 sec_caps = optee->smc.sec_caps;
> +
> + return optee_open(ctx, sec_caps & OPTEE_SMC_SEC_CAP_MEMREF_NULL);
> +}
> +
> +static const struct tee_driver_ops optee_clnt_ops = {
> + .get_version = optee_get_version,
> + .open = optee_smc_open,
> + .release = optee_release,
> + .open_session = optee_open_session,
> + .close_session = optee_close_session,
> + .invoke_func = optee_invoke_func,
> + .cancel_req = optee_cancel_req,
> + .shm_register = optee_shm_register,
> + .shm_unregister = optee_shm_unregister,
> +};
> +
> +static const struct tee_desc optee_clnt_desc = {
> + .name = DRIVER_NAME "-clnt",
> + .ops = &optee_clnt_ops,
> + .owner = THIS_MODULE,
> +};
> +
> +static const struct tee_driver_ops optee_supp_ops = {
> + .get_version = optee_get_version,
> + .open = optee_smc_open,
> + .release = optee_release_supp,
> + .supp_recv = optee_supp_recv,
> + .supp_send = optee_supp_send,
> + .shm_register = optee_shm_register_supp,
> + .shm_unregister = optee_shm_unregister_supp,
> +};
> +
> +static const struct tee_desc optee_supp_desc = {
> + .name = DRIVER_NAME "-supp",
> + .ops = &optee_supp_ops,
> + .owner = THIS_MODULE,
> + .flags = TEE_DESC_PRIVILEGED,
> +};
> +
> +static const struct optee_ops optee_ops = {
> + .do_call_with_arg = optee_smc_do_call_with_arg,
> + .to_msg_param = optee_to_msg_param,
> + .from_msg_param = optee_from_msg_param,
> +};
> +
> +static bool optee_msg_api_uid_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);
> +
> + if (res.a0 == OPTEE_MSG_UID_0 && res.a1 == OPTEE_MSG_UID_1 &&
> + res.a2 == OPTEE_MSG_UID_2 && res.a3 == OPTEE_MSG_UID_3)
> + return true;
> + return false;
> +}
> +
> +static void optee_msg_get_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)
> + pr_info("revision %lu.%lu (%08lx)", res.result.major,
> + res.result.minor, res.result.build_id);
> + else
> + pr_info("revision %lu.%lu", res.result.major, res.result.minor);
> +}
> +
> +static bool optee_msg_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);
> +
> + if (res.result.major == OPTEE_MSG_REVISION_MAJOR &&
> + (int)res.result.minor >= OPTEE_MSG_REVISION_MINOR)
> + return true;
> + return false;
> +}
> +
> +static bool optee_msg_exchange_capabilities(optee_invoke_fn *invoke_fn,
> + u32 *sec_caps)
> +{
> + union {
> + struct arm_smccc_res smccc;
> + struct optee_smc_exchange_capabilities_result result;
> + } res;
> + u32 a1 = 0;
> +
> + /*
> + * TODO This isn't enough to tell if it's UP system (from kernel
> + * point of view) or not, is_smp() returns the information
> + * needed, but can't be called directly from here.
> + */
> + if (!IS_ENABLED(CONFIG_SMP) || nr_cpu_ids == 1)
> + a1 |= OPTEE_SMC_NSEC_CAP_UNIPROCESSOR;
> +
> + invoke_fn(OPTEE_SMC_EXCHANGE_CAPABILITIES, a1, 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;
> +}
> +
> +static struct tee_shm_pool *optee_config_dyn_shm(void)
> +{
> + struct tee_shm_pool_mgr *priv_mgr;
> + struct tee_shm_pool_mgr *dmabuf_mgr;
> + void *rc;
> +
> + rc = optee_shm_pool_alloc_pages();
> + if (IS_ERR(rc))
> + return rc;
> + priv_mgr = rc;
> +
> + rc = optee_shm_pool_alloc_pages();
> + if (IS_ERR(rc)) {
> + tee_shm_pool_mgr_destroy(priv_mgr);
> + return rc;
> + }
> + dmabuf_mgr = rc;
> +
> + rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
> + if (IS_ERR(rc)) {
> + tee_shm_pool_mgr_destroy(priv_mgr);
> + tee_shm_pool_mgr_destroy(dmabuf_mgr);
> + }
> +
> + return rc;
> +}
> +
> +static struct tee_shm_pool *
> +optee_config_shm_memremap(optee_invoke_fn *invoke_fn, void **memremaped_shm)
> +{
> + union {
> + struct arm_smccc_res smccc;
> + struct optee_smc_get_shm_config_result result;
> + } res;
> + unsigned long vaddr;
> + phys_addr_t paddr;
> + size_t size;
> + phys_addr_t begin;
> + phys_addr_t end;
> + void *va;
> + struct tee_shm_pool_mgr *priv_mgr;
> + struct tee_shm_pool_mgr *dmabuf_mgr;
> + void *rc;
> + const int sz = OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE;
> +
> + invoke_fn(OPTEE_SMC_GET_SHM_CONFIG, 0, 0, 0, 0, 0, 0, 0, &res.smccc);
> + if (res.result.status != OPTEE_SMC_RETURN_OK) {
> + pr_err("static shm service not available\n");
> + return ERR_PTR(-ENOENT);
> + }
> +
> + if (res.result.settings != OPTEE_SMC_SHM_CACHED) {
> + pr_err("only normal cached shared memory supported\n");
> + return ERR_PTR(-EINVAL);
> + }
> +
> + begin = roundup(res.result.start, PAGE_SIZE);
> + end = rounddown(res.result.start + res.result.size, PAGE_SIZE);
> + paddr = begin;
> + size = end - begin;
> +
> + if (size < 2 * OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE) {
> + pr_err("too small shared memory area\n");
> + return ERR_PTR(-EINVAL);
> + }
> +
> + va = memremap(paddr, size, MEMREMAP_WB);
> + if (!va) {
> + pr_err("shared memory ioremap failed\n");
> + return ERR_PTR(-EINVAL);
> + }
> + vaddr = (unsigned long)va;
> +
> + rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, sz,
> + 3 /* 8 bytes aligned */);
> + if (IS_ERR(rc))
> + goto err_memunmap;
> + priv_mgr = rc;
> +
> + vaddr += sz;
> + paddr += sz;
> + size -= sz;
> +
> + rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, size, PAGE_SHIFT);
> + if (IS_ERR(rc))
> + goto err_free_priv_mgr;
> + dmabuf_mgr = rc;
> +
> + rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
> + if (IS_ERR(rc))
> + goto err_free_dmabuf_mgr;
> +
> + *memremaped_shm = va;
> +
> + return rc;
> +
> +err_free_dmabuf_mgr:
> + tee_shm_pool_mgr_destroy(dmabuf_mgr);
> +err_free_priv_mgr:
> + tee_shm_pool_mgr_destroy(priv_mgr);
> +err_memunmap:
> + memunmap(va);
> + return rc;
> +}
> +
> +/* 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 device *dev)
> +{
> + const char *method;
> +
> + pr_info("probing for conduit method.\n");
> +
> + if (device_property_read_string(dev, "method", &method)) {
> + pr_warn("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;
> +
> + pr_warn("invalid \"method\" property: %s\n", method);
> + return ERR_PTR(-EINVAL);
> +}
> +
> +static int optee_smc_remove(struct platform_device *pdev)
> +{
> + struct optee *optee = platform_get_drvdata(pdev);
> +
> + /*
> + * Ask OP-TEE to free all cached shared memory objects to decrease
> + * reference counters and also avoid wild pointers in secure world
> + * into the old shared memory range.
> + */
> + optee_disable_shm_cache(optee);
> +
> + optee_remove_common(optee);
> +
> + if (optee->smc.memremaped_shm)
> + memunmap(optee->smc.memremaped_shm);
> +
> + kfree(optee);
> +
> + return 0;
> +}
> +
> +static int optee_probe(struct platform_device *pdev)
> +{
> + optee_invoke_fn *invoke_fn;
> + struct tee_shm_pool *pool = ERR_PTR(-EINVAL);
> + struct optee *optee = NULL;
> + void *memremaped_shm = NULL;
> + struct tee_device *teedev;
> + u32 sec_caps;
> + int rc;
> +
> + invoke_fn = get_invoke_func(&pdev->dev);
> + if (IS_ERR(invoke_fn))
> + return PTR_ERR(invoke_fn);
> +
> + if (!optee_msg_api_uid_is_optee_api(invoke_fn)) {
> + pr_warn("api uid mismatch\n");
> + return -EINVAL;
> + }
> +
> + optee_msg_get_os_revision(invoke_fn);
> +
> + if (!optee_msg_api_revision_is_compatible(invoke_fn)) {
> + pr_warn("api revision mismatch\n");
> + return -EINVAL;
> + }
> +
> + if (!optee_msg_exchange_capabilities(invoke_fn, &sec_caps)) {
> + pr_warn("capabilities mismatch\n");
> + return -EINVAL;
> + }
> +
> + /*
> + * Try to use dynamic shared memory if possible
> + */
> + if (sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
> + pool = optee_config_dyn_shm();
> +
> + /*
> + * If dynamic shared memory is not available or failed - try static one
> + */
> + if (IS_ERR(pool) && (sec_caps & OPTEE_SMC_SEC_CAP_HAVE_RESERVED_SHM))
> + pool = optee_config_shm_memremap(invoke_fn, &memremaped_shm);
> +
> + if (IS_ERR(pool))
> + return PTR_ERR(pool);
> +
> + optee = kzalloc(sizeof(*optee), GFP_KERNEL);
> + if (!optee) {
> + rc = -ENOMEM;
> + goto err;
> + }
> +
> + optee->ops = &optee_ops;
> + optee->smc.invoke_fn = invoke_fn;
> + optee->smc.sec_caps = sec_caps;
> +
> + teedev = tee_device_alloc(&optee_clnt_desc, NULL, pool, optee);
> + if (IS_ERR(teedev)) {
> + rc = PTR_ERR(teedev);
> + goto err;
> + }
> + optee->teedev = teedev;
> +
> + teedev = tee_device_alloc(&optee_supp_desc, NULL, pool, optee);
> + if (IS_ERR(teedev)) {
> + rc = PTR_ERR(teedev);
> + goto err;
> + }
> + optee->supp_teedev = teedev;
> +
> + rc = tee_device_register(optee->teedev);
> + if (rc)
> + goto err;
> +
> + rc = tee_device_register(optee->supp_teedev);
> + if (rc)
> + goto err;
> +
> + mutex_init(&optee->call_queue.mutex);
> + INIT_LIST_HEAD(&optee->call_queue.waiters);
> + optee_wait_queue_init(&optee->wait_queue);
> + optee_supp_init(&optee->supp);
> + optee->smc.memremaped_shm = memremaped_shm;
> + optee->pool = pool;
> +
> + optee_enable_shm_cache(optee);
> +
> + if (optee->smc.sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
> + pr_info("dynamic shared memory is enabled\n");
> +
> + platform_set_drvdata(pdev, optee);
> +
> + rc = optee_enumerate_devices(PTA_CMD_GET_DEVICES);
> + if (rc) {
> + optee_smc_remove(pdev);
> + return rc;
> + }
> +
> + pr_info("initialized driver\n");
> + return 0;
> +err:
> + if (optee) {
> + /*
> + * tee_device_unregister() is safe to call even if the
> + * devices hasn't been registered with
> + * tee_device_register() yet.
> + */
> + tee_device_unregister(optee->supp_teedev);
> + tee_device_unregister(optee->teedev);
> + kfree(optee);
> + }
> + if (pool)
> + tee_shm_pool_free(pool);
> + if (memremaped_shm)
> + memunmap(memremaped_shm);
> + return rc;
> +}
> +
> +static const struct of_device_id optee_dt_match[] = {
> + { .compatible = "linaro,optee-tz" },
> + {},
> +};
> +MODULE_DEVICE_TABLE(of, optee_dt_match);
> +
> +static struct platform_driver optee_driver = {
> + .probe = optee_probe,
> + .remove = optee_smc_remove,
> + .driver = {
> + .name = "optee",
> + .of_match_table = optee_dt_match,
> + },
> +};
> +module_platform_driver(optee_driver);
> --
> 2.31.1
>

2021-07-28 10:26:49

by Sumit Garg

[permalink] [raw]
Subject: Re: [PATCH v3 0/5] Add FF-A support in OP-TEE driver

On Wed, 28 Jul 2021 at 12:11, Jens Wiklander <[email protected]> wrote:
>
> On Tue, Jul 27, 2021 at 8:13 AM Sumit Garg <[email protected]> wrote:
> >
> > On Mon, 26 Jul 2021 at 20:55, Jens Wiklander <[email protected]> wrote:
> > >
> > > Hi Sumit,
> > >
> > > On Mon, Jul 26, 2021 at 1:41 PM Sumit Garg <[email protected]> wrote:
> > > >
> > > > On Mon, 26 Jul 2021 at 16:25, Sudeep Holla <[email protected]> wrote:
> > > > >
> > > > > On Mon, Jul 26, 2021 at 03:59:36PM +0530, Sumit Garg wrote:
> > > > > > Hi Jens,
> > > > > >
> > > > > > On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
> > > > > > >
> > > > > > > Hi all,
> > > > > > >
> > > > > > > This adds supports for the OP-TEE driver to communicate with secure world
> > > > > > > using FF-A [1] as transport.
> > > > > > >
> > > > > > > There is one change to the TEE subsystem with "tee: add sec_world_id to
> > > > > > > struct tee_shm" to add support for holding globally unique handle assigned
> > > > > > > by the FF-A. This is a field that I believe could useful for the AMDTEE
> > > > > > > driver too.
> > > > > > >
> > > > > > > For communication the OP-TEE message protocol is still used, but with a new
> > > > > > > type of memory reference, struct optee_msg_param_fmem, to carry the
> > > > > > > information needed by FF-A. The OP-TEE driver is refactored internally with
> > > > > > > to sets of callbacks, one for the old SMC based communication and another
> > > > > > > set with FF-A as transport. The functions relating to the SMC based ABI
> > > > > > > are moved to smc_abi.c while the FF-A based ABI is added in a ffa_abi.c.
> > > > > > >
> > > > > > > There is also a difference in how the drivers are instantiated. With the
> > > > > > > SMC based transport we have a platform driver, module_platform_driver(),
> > > > > > > today which we're keeping as is for this configuration. In a FF-A system we
> > > > > > > have a FF-A driver, module_ffa_driver(), instead.
> > > > > > >
> > > > > > > The OP-TEE driver can be compiled for both targets at the same time and
> > > > > > > it's up to runtime configuration (device tree or ACPI) to decide how it's
> > > > > > > initialized. Note that it's only the old SMC based driver instance that
> > > > > > > need device tree or ACPI to initialize. The FF-A based driver relies on the
> > > > > > > FF-A bus instead.
> > > > > > >
> > > > > > > This can be tested QEMU
> > > > > > > The repo for SPMC at S-EL1 retrieved by
> > > > > > > repo init -u https://github.com/jenswi-linaro/manifest.git -m
> > > > > > > qemu_v8.xml -b ffav4_spmc
> > > > > > > repo sync
> > > > > > > # Then checkout the branch optee_ffa_v3 from
> > > > > > > # git://git.linaro.org/people/jens.wiklander/linux-tee.git
> > > > > > > # in the linux directory
> > > > > > >
> > > > > > > To build do:
> > > > > > > cd build
> > > > > > > make toolchains
> > > > > > > make all
> > > > > > >
> > > > > > > To boot:
> > > > > > > make run-only
> > > > > > >
> > > > > > > Test with xtest, perhaps only with the command "xtest 1004" in case you're
> > > > > > > not interested in too many tests.
> > > > > >
> > > > > > Thanks Jens for sharing instructions to test this feature. So I tried
> > > > > > to reproduce using following repo versions:
> > > > > >
> > > > > > linux-tee, branch: optee_ffa_v3
> > > > > > trusted-firmware-a, branch: ffav4_sel1_spmc
> > > > > > build, branch: ffav4_spmc
> > > > > >
> > > > > > and rest of the repos synced to the latest version as per upstream
> > > > > > qemu_v8.xml [1] but I don't see OP-TEE driver being probed during boot
> > > > > > [2]. Am I missing something?
> > > > > >
> > > > > > [1] https://github.com/OP-TEE/manifest/blob/master/qemu_v8.xml
> > > > > > [2]
> > > > > > Welcome to Buildroot, type root or test to login
> > > > > > buildroot login: root
> > > > > > # dmesg | grep optee
> > > > > >
> > > > >
> > > > > Do you see ARM FF-A driver initialised successfully ?
> > > > > You must see "ARM FF-A Version 1.0 found" or something similar based on
> > > > > the actual version supported.
> > > > >
> > > > > If so, can you check if the partitions are correctly populated by
> > > > > the driver using the discover API.
> > > > >
> > > > > $ grep "" /sys/bus/arm_ffa/devices/*/uuid
> > > > >
> > > > > If uuid reads zeros, then the devices are populated, just the matching
> > > > > driver is not found(due to the workaround for v1.0 spec)
> > > > >
> > > >
> > > > It turns out to be an issue with my build environment, I re-built from
> > > > scratch and I could see OP-TEE being probed successfully:
> > > >
> > > > # dmesg | grep FF-A
> > > > [ 0.356382] ARM FF-A: Version 1.0 found
> > > > #
> > > > # cat /sys/bus/arm_ffa/devices/arm-ffa-8001/uuid
> > > > 486178e0-e7f8-11e3-bc5e-0002a5d5c51b
> > > > #
> > > > # dmesg | grep optee
> > > > [ 4.991472] optee: revision 3.14 (49dbb9ef)
> > > > [ 5.010110] optee: initialized driver
> > > > #
> > >
> > > That's good.
> > >
> > > > From xtest logs it looks like the pseudo TA interface isn't working for me:
> > > >
> > > > * regression_1001 Core self tests
> > > > - 1001 - skip test, pseudo TA not found
> > > > regression_1001 OK
> > > >
> > > > * regression_1002 PTA parameters
> > > > - 1002 - skip test, pseudo TA not found
> > > > regression_1002 OK
> > > >
> > > > * regression_1003 Core internal read/write mutex
> > > > - 1003 - skip test, pseudo TA not found
> > > > regression_1003 OK
> > >
> > > The test PTAs are disabled by default.
> > >
> >
> > Ah, I missed the CFG_ENABLE_EMBEDDED_TESTS option in OP-TEE. BTW, I
> > think it should be enabled for OP-TEE Qemu build as we mostly use it
> > as a test platform.
>
> That makes sense. Perhaps in the build git?
>

Yeah, build git sounds appropriate location.

-Sumit

> >
> > > >
> > > > Similarly, pseudo TAs acting as TEE bus devices doesn't work as well
> > > > as I see following devices directory being empty:
> > > >
> > > > # ls /sys/bus/tee/devices/
> > > > #
> > > >
> > > > As otherwise with OP-TEE SMC ABI, we should have at least the default
> > > > pseudo TA [1] kernel device there.
> > > >
> > > > So is pseudo TA functional with this new FF-A interface?
> > >
> > > Yes, everything is supposed to work.
> > >
> >
> > So yes, xtest and TEE kernel bus framework works for me as well with
> > this new FF-A interface. FWIW:
> >
> > Tested-by: Sumit Garg <[email protected]>
>
> Thanks for confirming.
>
> Cheers,
> Jens

2021-07-29 06:45:50

by Jens Wiklander

[permalink] [raw]
Subject: Re: [PATCH v3 2/5] optee: simplify optee_release()

On Wed, Jul 28, 2021 at 02:15:47PM +0530, Sumit Garg wrote:
> On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
> >
> > Simplifies optee_release() with a new helper function,
> > optee_close_session_helper() which has been factored out from
> > optee_close_session().
> >
>
> Simplification looks good to me.
>
> > A separate optee_release_supp() is added for the supplicant device.
> >
>
> On similar terms, can we have separate optee_open_supp() for better
> understanding?

I'm not so keen on that. It wouldn't be much of a simplification since
we'd end up adding quite a few functions. optee_smc_open_supp(),
optee_ffa_open_supp(), optee_open_common(), and finally
optee_open_supp().

Thanks,
Jens

2021-07-29 06:58:07

by Jens Wiklander

[permalink] [raw]
Subject: Re: [PATCH v3 3/5] optee: refactor driver with internal callbacks

On Wed, Jul 28, 2021 at 03:29:33PM +0530, Sumit Garg wrote:
> On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
> >
> > The OP-TEE driver is refactored with three internal callbacks replacing
> > direct calls to optee_from_msg_param(), optee_to_msg_param() and
> > optee_do_call_with_arg().
> >
> > These functions a central to communicating with OP-TEE in secure world
> > by using the SMC Calling Convention directly.
> >
> > This refactoring makes room for using other primitives to communicate
> > with OP-TEE in secure world while being able to reuse as much as
> > possible from the present driver.
> >
> > Signed-off-by: Jens Wiklander <[email protected]>
> > ---
> > drivers/tee/optee/call.c | 86 +++++++++--------
> > drivers/tee/optee/core.c | 148 ++++++++++++++++++++----------
> > drivers/tee/optee/optee_private.h | 35 +++++--
> > drivers/tee/optee/rpc.c | 19 ++--
> > 4 files changed, 182 insertions(+), 106 deletions(-)
> >
> > diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c
> > index 9d8f5a95e42f..00ecd794e59a 100644
> > --- a/drivers/tee/optee/call.c
> > +++ b/drivers/tee/optee/call.c
> > @@ -1,6 +1,6 @@
> > // SPDX-License-Identifier: GPL-2.0-only
> > /*
> > - * Copyright (c) 2015, Linaro Limited
> > + * Copyright (c) 2015-2021, Linaro Limited
> > */
> > #include <linux/arm-smccc.h>
> > #include <linux/device.h>
> > @@ -118,20 +118,25 @@ static struct optee_session *find_session(struct optee_context_data *ctxdata,
> > /**
> > * optee_do_call_with_arg() - Do an SMC to OP-TEE in secure world
> > * @ctx: calling context
> > - * @parg: physical address of message to pass to secure world
> > + * @arg: shared memory holding the message to pass to secure world
> > *
> > * Does and SMC to OP-TEE in secure world and handles eventual resulting
> > * Remote Procedure Calls (RPC) from OP-TEE.
> > *
> > * Returns return code from secure world, 0 is OK
> > */
> > -u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
> > +int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg)
> > {
> > struct optee *optee = tee_get_drvdata(ctx->teedev);
> > struct optee_call_waiter w;
> > struct optee_rpc_param param = { };
> > struct optee_call_ctx call_ctx = { };
> > - u32 ret;
> > + phys_addr_t parg;
> > + int rc;
> > +
> > + rc = tee_shm_get_pa(arg, 0, &parg);
> > + if (rc)
> > + return rc;
> >
> > param.a0 = OPTEE_SMC_CALL_WITH_ARG;
> > reg_pair_from_64(&param.a1, &param.a2, parg);
> > @@ -160,7 +165,7 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
> > param.a3 = res.a3;
> > optee_handle_rpc(ctx, &param, &call_ctx);
> > } else {
> > - ret = res.a0;
> > + rc = res.a0;
> > break;
> > }
> > }
> > @@ -172,14 +177,12 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
> > */
> > optee_cq_wait_final(&optee->call_queue, &w);
> >
> > - return ret;
> > + return rc;
> > }
> >
> > static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,
> > - struct optee_msg_arg **msg_arg,
> > - phys_addr_t *msg_parg)
> > + struct optee_msg_arg **msg_arg)
> > {
> > - int rc;
> > struct tee_shm *shm;
> > struct optee_msg_arg *ma;
> >
> > @@ -190,22 +193,13 @@ static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,
> >
> > ma = tee_shm_get_va(shm, 0);
> > if (IS_ERR(ma)) {
> > - rc = PTR_ERR(ma);
> > - goto out;
> > + tee_shm_free(shm);
> > + return (void *)ma;
> > }
> >
> > - rc = tee_shm_get_pa(shm, 0, msg_parg);
> > - if (rc)
> > - goto out;
> > -
> > memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params));
> > ma->num_params = num_params;
> > *msg_arg = ma;
> > -out:
> > - if (rc) {
> > - tee_shm_free(shm);
> > - return ERR_PTR(rc);
> > - }
> >
> > return shm;
> > }
> > @@ -214,16 +208,16 @@ int optee_open_session(struct tee_context *ctx,
> > struct tee_ioctl_open_session_arg *arg,
> > struct tee_param *param)
> > {
> > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > struct optee_context_data *ctxdata = ctx->data;
> > int rc;
> > struct tee_shm *shm;
> > struct optee_msg_arg *msg_arg;
> > - phys_addr_t msg_parg;
> > struct optee_session *sess = NULL;
> > uuid_t client_uuid;
> >
> > /* +2 for the meta parameters added below */
> > - shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg, &msg_parg);
> > + shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg);
> > if (IS_ERR(shm))
> > return PTR_ERR(shm);
> >
> > @@ -247,7 +241,8 @@ int optee_open_session(struct tee_context *ctx,
> > goto out;
> > export_uuid(msg_arg->params[1].u.octets, &client_uuid);
> >
> > - rc = optee_to_msg_param(msg_arg->params + 2, arg->num_params, param);
> > + rc = optee->ops->to_msg_param(optee, msg_arg->params + 2,
> > + arg->num_params, param);
> > if (rc)
> > goto out;
> >
> > @@ -257,7 +252,7 @@ int optee_open_session(struct tee_context *ctx,
> > goto out;
> > }
> >
> > - if (optee_do_call_with_arg(ctx, msg_parg)) {
> > + if (optee->ops->do_call_with_arg(ctx, shm)) {
> > msg_arg->ret = TEEC_ERROR_COMMUNICATION;
> > msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
> > }
> > @@ -272,7 +267,8 @@ int optee_open_session(struct tee_context *ctx,
> > kfree(sess);
> > }
> >
> > - if (optee_from_msg_param(param, arg->num_params, msg_arg->params + 2)) {
> > + if (optee->ops->from_msg_param(optee, param, arg->num_params,
> > + msg_arg->params + 2)) {
> > arg->ret = TEEC_ERROR_COMMUNICATION;
> > arg->ret_origin = TEEC_ORIGIN_COMMS;
> > /* Close session again to avoid leakage */
> > @@ -291,16 +287,16 @@ int optee_open_session(struct tee_context *ctx,
> > int optee_close_session_helper(struct tee_context *ctx, u32 session)
> > {
> > struct tee_shm *shm;
> > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > struct optee_msg_arg *msg_arg;
> > - phys_addr_t msg_parg;
> >
> > - shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
> > + shm = get_msg_arg(ctx, 0, &msg_arg);
> > if (IS_ERR(shm))
> > return PTR_ERR(shm);
> >
> > msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
> > msg_arg->session = session;
> > - optee_do_call_with_arg(ctx, msg_parg);
> > + optee->ops->do_call_with_arg(ctx, shm);
> >
> > tee_shm_free(shm);
> >
> > @@ -328,10 +324,10 @@ int optee_close_session(struct tee_context *ctx, u32 session)
> > int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> > struct tee_param *param)
> > {
> > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > struct optee_context_data *ctxdata = ctx->data;
> > struct tee_shm *shm;
> > struct optee_msg_arg *msg_arg;
> > - phys_addr_t msg_parg;
> > struct optee_session *sess;
> > int rc;
> >
> > @@ -342,7 +338,7 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> > if (!sess)
> > return -EINVAL;
> >
> > - shm = get_msg_arg(ctx, arg->num_params, &msg_arg, &msg_parg);
> > + shm = get_msg_arg(ctx, arg->num_params, &msg_arg);
> > if (IS_ERR(shm))
> > return PTR_ERR(shm);
> > msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND;
> > @@ -350,16 +346,18 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> > msg_arg->session = arg->session;
> > msg_arg->cancel_id = arg->cancel_id;
> >
> > - rc = optee_to_msg_param(msg_arg->params, arg->num_params, param);
> > + rc = optee->ops->to_msg_param(optee, msg_arg->params, arg->num_params,
> > + param);
> > if (rc)
> > goto out;
> >
> > - if (optee_do_call_with_arg(ctx, msg_parg)) {
> > + if (optee->ops->do_call_with_arg(ctx, shm)) {
> > msg_arg->ret = TEEC_ERROR_COMMUNICATION;
> > msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
> > }
> >
> > - if (optee_from_msg_param(param, arg->num_params, msg_arg->params)) {
> > + if (optee->ops->from_msg_param(optee, param, arg->num_params,
> > + msg_arg->params)) {
> > msg_arg->ret = TEEC_ERROR_COMMUNICATION;
> > msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
> > }
> > @@ -373,10 +371,10 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> >
> > int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
> > {
> > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > struct optee_context_data *ctxdata = ctx->data;
> > struct tee_shm *shm;
> > struct optee_msg_arg *msg_arg;
> > - phys_addr_t msg_parg;
> > struct optee_session *sess;
> >
> > /* Check that the session is valid */
> > @@ -386,14 +384,14 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
> > if (!sess)
> > return -EINVAL;
> >
> > - shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
> > + shm = get_msg_arg(ctx, 0, &msg_arg);
> > if (IS_ERR(shm))
> > return PTR_ERR(shm);
> >
> > msg_arg->cmd = OPTEE_MSG_CMD_CANCEL;
> > msg_arg->session = session;
> > msg_arg->cancel_id = cancel_id;
> > - optee_do_call_with_arg(ctx, msg_parg);
> > + optee->ops->do_call_with_arg(ctx, shm);
> >
> > tee_shm_free(shm);
> > return 0;
> > @@ -592,10 +590,10 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> > struct page **pages, size_t num_pages,
> > unsigned long start)
> > {
> > - struct tee_shm *shm_arg = NULL;
> > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > struct optee_msg_arg *msg_arg;
> > + struct tee_shm *shm_arg;
> > u64 *pages_list;
> > - phys_addr_t msg_parg;
> > int rc;
> >
> > if (!num_pages)
> > @@ -609,7 +607,7 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> > if (!pages_list)
> > return -ENOMEM;
> >
> > - shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
> > + shm_arg = get_msg_arg(ctx, 1, &msg_arg);
> > if (IS_ERR(shm_arg)) {
> > rc = PTR_ERR(shm_arg);
> > goto out;
> > @@ -630,7 +628,7 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> > msg_arg->params->u.tmem.buf_ptr = virt_to_phys(pages_list) |
> > (tee_shm_get_page_offset(shm) & (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
> >
> > - if (optee_do_call_with_arg(ctx, msg_parg) ||
> > + if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> > msg_arg->ret != TEEC_SUCCESS)
> > rc = -EINVAL;
> >
> > @@ -642,12 +640,12 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> >
> > int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
> > {
> > - struct tee_shm *shm_arg;
> > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > struct optee_msg_arg *msg_arg;
> > - phys_addr_t msg_parg;
> > + struct tee_shm *shm_arg;
> > int rc = 0;
> >
> > - shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
> > + shm_arg = get_msg_arg(ctx, 1, &msg_arg);
> > if (IS_ERR(shm_arg))
> > return PTR_ERR(shm_arg);
> >
> > @@ -656,7 +654,7 @@ int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
> > msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> > msg_arg->params[0].u.rmem.shm_ref = (unsigned long)shm;
> >
> > - if (optee_do_call_with_arg(ctx, msg_parg) ||
> > + if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> > msg_arg->ret != TEEC_SUCCESS)
> > rc = -EINVAL;
> > tee_shm_free(shm_arg);
> > diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c
> > index 949223b214c3..f689f171a794 100644
> > --- a/drivers/tee/optee/core.c
> > +++ b/drivers/tee/optee/core.c
> > @@ -1,6 +1,6 @@
> > // SPDX-License-Identifier: GPL-2.0-only
> > /*
> > - * Copyright (c) 2015, Linaro Limited
> > + * Copyright (c) 2015-2021, Linaro Limited
> > */
> >
> > #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
> > @@ -26,21 +26,87 @@
> >
> > #define OPTEE_SHM_NUM_PRIV_PAGES CONFIG_OPTEE_SHM_NUM_PRIV_PAGES
> >
> > +static void from_msg_param_value(struct tee_param *p, u32 attr,
> > + const struct optee_msg_param *mp)
> > +{
> > + p->attr = TEE_IOCTL_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;
> > +}
> > +
> > +static int from_msg_param_tmp_mem(struct tee_param *p, u32 attr,
> > + const struct optee_msg_param *mp)
> > +{
> > + struct tee_shm *shm;
> > + phys_addr_t pa;
> > + int rc;
> > +
> > + p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> > + attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
> > + p->u.memref.size = mp->u.tmem.size;
> > + shm = (struct tee_shm *)(unsigned long)mp->u.tmem.shm_ref;
> > + if (!shm) {
> > + p->u.memref.shm_offs = 0;
> > + p->u.memref.shm = NULL;
> > + return 0;
> > + }
> > +
> > + rc = tee_shm_get_pa(shm, 0, &pa);
> > + if (rc)
> > + return rc;
> > +
> > + p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
> > + p->u.memref.shm = shm;
> > +
> > + /* Check that the memref is covered by the shm object */
> > + if (p->u.memref.size) {
> > + size_t o = p->u.memref.shm_offs +
> > + p->u.memref.size - 1;
> > +
> > + rc = tee_shm_get_pa(shm, o, NULL);
> > + if (rc)
> > + return rc;
> > + }
> > +
> > + return 0;
> > +}
> > +
> > +static void from_msg_param_reg_mem(struct tee_param *p, u32 attr,
> > + const struct optee_msg_param *mp)
> > +{
> > + struct tee_shm *shm;
> > +
> > + p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> > + attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> > + p->u.memref.size = mp->u.rmem.size;
> > + shm = (struct tee_shm *)(unsigned long)mp->u.rmem.shm_ref;
> > +
> > + if (shm) {
> > + p->u.memref.shm_offs = mp->u.rmem.offs;
> > + p->u.memref.shm = shm;
> > + } else {
> > + p->u.memref.shm_offs = 0;
> > + p->u.memref.shm = NULL;
> > + }
> > +}
> > +
> > /**
> > * optee_from_msg_param() - convert from OPTEE_MSG parameters to
> > * struct tee_param
> > + * @optee: main service struct
>
> I don't see this new argument being used. Can you throw some light on
> the use-case for this additional argument?

This function is registered as a callback and the counter part in the
FF-A ABI (optee_ffa_from_msg_param()) will need this parameter. So it's
needed to have the same signature.

>
> > * @params: subsystem internal parameter representation
> > * @num_params: number of elements in the parameter arrays
> > * @msg_params: OPTEE_MSG parameters
> > * Returns 0 on success or <0 on failure
> > */
> > -int optee_from_msg_param(struct tee_param *params, size_t num_params,
> > - const struct optee_msg_param *msg_params)
> > +static int optee_from_msg_param(struct optee *optee, struct tee_param *params,
> > + size_t num_params,
> > + const struct optee_msg_param *msg_params)
> > {
> > int rc;
> > size_t n;
> > - struct tee_shm *shm;
> > - phys_addr_t pa;
> >
> > for (n = 0; n < num_params; n++) {
> > struct tee_param *p = params + n;
> > @@ -55,48 +121,19 @@ int optee_from_msg_param(struct tee_param *params, size_t num_params,
> > case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT:
> > case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:
> > case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:
> > - p->attr = TEE_IOCTL_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;
> > + from_msg_param_value(p, attr, mp);
> > break;
> > case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:
> > case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
> > case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
> > - p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> > - attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
> > - p->u.memref.size = mp->u.tmem.size;
> > - shm = (struct tee_shm *)(unsigned long)
> > - mp->u.tmem.shm_ref;
> > - if (!shm) {
> > - p->u.memref.shm_offs = 0;
> > - p->u.memref.shm = NULL;
> > - break;
> > - }
> > - rc = tee_shm_get_pa(shm, 0, &pa);
> > + rc = from_msg_param_tmp_mem(p, attr, mp);
> > if (rc)
> > return rc;
> > - p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
> > - p->u.memref.shm = shm;
> > 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_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> > - attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> > - p->u.memref.size = mp->u.rmem.size;
> > - shm = (struct tee_shm *)(unsigned long)
> > - 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;
> > -
> > + from_msg_param_reg_mem(p, attr, mp);
> > break;
> >
> > default:
> > @@ -106,6 +143,16 @@ int optee_from_msg_param(struct tee_param *params, size_t num_params,
> > return 0;
> > }
> >
> > +static void to_msg_param_value(struct optee_msg_param *mp,
> > + const struct tee_param *p)
> > +{
> > + mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
> > + TEE_IOCTL_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;
> > +}
> > +
> > static int to_msg_param_tmp_mem(struct optee_msg_param *mp,
> > const struct tee_param *p)
> > {
> > @@ -148,13 +195,15 @@ static int to_msg_param_reg_mem(struct optee_msg_param *mp,
> >
> > /**
> > * optee_to_msg_param() - convert from struct tee_params to OPTEE_MSG parameters
> > + * @optee: main service struct
>
> Same here.

This function is also registered as a callback. Here it's questionable
though, but I added it to let optee->ops->to_msg_param() and
optee->ops->from_msg_param() have better symmetry.

Thanks,
Jens

2021-07-29 07:11:51

by Jens Wiklander

[permalink] [raw]
Subject: Re: [PATCH v3 4/5] optee: isolate smc abi

On Wed, Jul 28, 2021 at 03:40:05PM +0530, Sumit Garg wrote:
> On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
> >
> > Isolate the ABI based on raw SMCs. Code specific to the raw SMC ABI is
> > moved into smc_abi.c. This makes room for other ABIs with a clear
> > separation.
> >
> > This patch is not supposed to change the driver behavior, it's only a
> > matter of reorganizing the code.
> >
> > Signed-off-by: Jens Wiklander <[email protected]>
> > ---
> > drivers/tee/optee/Makefile | 6 +-
> > drivers/tee/optee/call.c | 339 +-------
> > drivers/tee/optee/core.c | 684 +--------------
> > drivers/tee/optee/optee_private.h | 104 ++-
> > drivers/tee/optee/rpc.c | 255 +-----
> > drivers/tee/optee/shm_pool.c | 89 --
> > drivers/tee/optee/shm_pool.h | 14 -
> > drivers/tee/optee/smc_abi.c | 1301 +++++++++++++++++++++++++++++
> > 8 files changed, 1441 insertions(+), 1351 deletions(-)
> > delete mode 100644 drivers/tee/optee/shm_pool.c
> > delete mode 100644 drivers/tee/optee/shm_pool.h
> > create mode 100644 drivers/tee/optee/smc_abi.c
> >
> > diff --git a/drivers/tee/optee/Makefile b/drivers/tee/optee/Makefile
> > index 3aa33ea9e6a6..e92f77462f40 100644
> > --- a/drivers/tee/optee/Makefile
> > +++ b/drivers/tee/optee/Makefile
> > @@ -4,8 +4,10 @@ optee-objs += core.o
> > optee-objs += call.o
> > optee-objs += rpc.o
> > optee-objs += supp.o
> > -optee-objs += shm_pool.o
> > optee-objs += device.o
> >
> > +optee-smc-abi-y = smc_abi.o
> > +optee-objs += $(optee-ffa-abi-y)
> > +
> > # for tracing framework to find optee_trace.h
> > -CFLAGS_call.o := -I$(src)
> > +CFLAGS_smc_abi.o := -I$(src)
> > diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c
> > index 00ecd794e59a..3f81c168ed3f 100644
> > --- a/drivers/tee/optee/call.c
> > +++ b/drivers/tee/optee/call.c
> > @@ -2,28 +2,17 @@
> > /*
> > * Copyright (c) 2015-2021, Linaro Limited
> > */
> > -#include <linux/arm-smccc.h>
> > #include <linux/device.h>
> > #include <linux/err.h>
> > #include <linux/errno.h>
> > #include <linux/mm.h>
> > -#include <linux/sched.h>
> > #include <linux/slab.h>
> > #include <linux/tee_drv.h>
> > #include <linux/types.h>
> > -#include <linux/uaccess.h>
> > #include "optee_private.h"
> > -#include "optee_smc.h"
> > -#define CREATE_TRACE_POINTS
> > -#include "optee_trace.h"
> >
> > -struct optee_call_waiter {
> > - struct list_head list_node;
> > - struct completion c;
> > -};
> > -
> > -static void optee_cq_wait_init(struct optee_call_queue *cq,
> > - struct optee_call_waiter *w)
> > +void optee_cq_wait_init(struct optee_call_queue *cq,
> > + struct optee_call_waiter *w)
> > {
> > /*
> > * We're preparing to make a call to secure world. In case we can't
> > @@ -47,8 +36,8 @@ static void optee_cq_wait_init(struct optee_call_queue *cq,
> > mutex_unlock(&cq->mutex);
> > }
> >
> > -static void optee_cq_wait_for_completion(struct optee_call_queue *cq,
> > - struct optee_call_waiter *w)
> > +void optee_cq_wait_for_completion(struct optee_call_queue *cq,
> > + struct optee_call_waiter *w)
> > {
> > wait_for_completion(&w->c);
> >
> > @@ -74,8 +63,8 @@ static void optee_cq_complete_one(struct optee_call_queue *cq)
> > }
> > }
> >
> > -static void optee_cq_wait_final(struct optee_call_queue *cq,
> > - struct optee_call_waiter *w)
> > +void optee_cq_wait_final(struct optee_call_queue *cq,
> > + struct optee_call_waiter *w)
> > {
> > /*
> > * We're done with the call to secure world. The thread in secure
> > @@ -115,73 +104,8 @@ static struct optee_session *find_session(struct optee_context_data *ctxdata,
> > return NULL;
> > }
> >
> > -/**
> > - * optee_do_call_with_arg() - Do an SMC to OP-TEE in secure world
> > - * @ctx: calling context
> > - * @arg: shared memory holding the message to pass to secure world
> > - *
> > - * Does and SMC to OP-TEE in secure world and handles eventual resulting
> > - * Remote Procedure Calls (RPC) from OP-TEE.
> > - *
> > - * Returns return code from secure world, 0 is OK
> > - */
> > -int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg)
> > -{
> > - struct optee *optee = tee_get_drvdata(ctx->teedev);
> > - struct optee_call_waiter w;
> > - struct optee_rpc_param param = { };
> > - struct optee_call_ctx call_ctx = { };
> > - phys_addr_t parg;
> > - int rc;
> > -
> > - rc = tee_shm_get_pa(arg, 0, &parg);
> > - if (rc)
> > - return rc;
> > -
> > - param.a0 = OPTEE_SMC_CALL_WITH_ARG;
> > - reg_pair_from_64(&param.a1, &param.a2, parg);
> > - /* Initialize waiter */
> > - optee_cq_wait_init(&optee->call_queue, &w);
> > - while (true) {
> > - struct arm_smccc_res res;
> > -
> > - trace_optee_invoke_fn_begin(&param);
> > - optee->invoke_fn(param.a0, param.a1, param.a2, param.a3,
> > - param.a4, param.a5, param.a6, param.a7,
> > - &res);
> > - trace_optee_invoke_fn_end(&param, &res);
> > -
> > - if (res.a0 == OPTEE_SMC_RETURN_ETHREAD_LIMIT) {
> > - /*
> > - * Out of threads in secure world, wait for a thread
> > - * become available.
> > - */
> > - optee_cq_wait_for_completion(&optee->call_queue, &w);
> > - } else if (OPTEE_SMC_RETURN_IS_RPC(res.a0)) {
> > - cond_resched();
> > - param.a0 = res.a0;
> > - param.a1 = res.a1;
> > - param.a2 = res.a2;
> > - param.a3 = res.a3;
> > - optee_handle_rpc(ctx, &param, &call_ctx);
> > - } else {
> > - rc = res.a0;
> > - break;
> > - }
> > - }
> > -
> > - optee_rpc_finalize_call(&call_ctx);
> > - /*
> > - * We're done with our thread in secure world, if there's any
> > - * thread waiters wake up one.
> > - */
> > - optee_cq_wait_final(&optee->call_queue, &w);
> > -
> > - return rc;
> > -}
> > -
> > -static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,
> > - struct optee_msg_arg **msg_arg)
> > +struct tee_shm *optee_get_msg_arg(struct tee_context *ctx, size_t num_params,
> > + struct optee_msg_arg **msg_arg)
> > {
> > struct tee_shm *shm;
> > struct optee_msg_arg *ma;
> > @@ -217,7 +141,7 @@ int optee_open_session(struct tee_context *ctx,
> > uuid_t client_uuid;
> >
> > /* +2 for the meta parameters added below */
> > - shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg);
> > + shm = optee_get_msg_arg(ctx, arg->num_params + 2, &msg_arg);
> > if (IS_ERR(shm))
> > return PTR_ERR(shm);
> >
> > @@ -290,7 +214,7 @@ int optee_close_session_helper(struct tee_context *ctx, u32 session)
> > struct optee *optee = tee_get_drvdata(ctx->teedev);
> > struct optee_msg_arg *msg_arg;
> >
> > - shm = get_msg_arg(ctx, 0, &msg_arg);
> > + shm = optee_get_msg_arg(ctx, 0, &msg_arg);
> > if (IS_ERR(shm))
> > return PTR_ERR(shm);
> >
> > @@ -338,7 +262,7 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> > if (!sess)
> > return -EINVAL;
> >
> > - shm = get_msg_arg(ctx, arg->num_params, &msg_arg);
> > + shm = optee_get_msg_arg(ctx, arg->num_params, &msg_arg);
> > if (IS_ERR(shm))
> > return PTR_ERR(shm);
> > msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND;
> > @@ -384,7 +308,7 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
> > if (!sess)
> > return -EINVAL;
> >
> > - shm = get_msg_arg(ctx, 0, &msg_arg);
> > + shm = optee_get_msg_arg(ctx, 0, &msg_arg);
> > if (IS_ERR(shm))
> > return PTR_ERR(shm);
> >
> > @@ -397,152 +321,6 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
> > return 0;
> > }
> >
> > -/**
> > - * optee_enable_shm_cache() - Enables caching of some shared memory allocation
> > - * in OP-TEE
> > - * @optee: main service struct
> > - */
> > -void optee_enable_shm_cache(struct optee *optee)
> > -{
> > - struct optee_call_waiter w;
> > -
> > - /* We need to retry until secure world isn't busy. */
> > - optee_cq_wait_init(&optee->call_queue, &w);
> > - while (true) {
> > - struct arm_smccc_res res;
> > -
> > - optee->invoke_fn(OPTEE_SMC_ENABLE_SHM_CACHE, 0, 0, 0, 0, 0, 0,
> > - 0, &res);
> > - if (res.a0 == OPTEE_SMC_RETURN_OK)
> > - break;
> > - optee_cq_wait_for_completion(&optee->call_queue, &w);
> > - }
> > - optee_cq_wait_final(&optee->call_queue, &w);
> > -}
> > -
> > -/**
> > - * optee_disable_shm_cache() - Disables caching of some shared memory allocation
> > - * in OP-TEE
> > - * @optee: main service struct
> > - */
> > -void optee_disable_shm_cache(struct optee *optee)
> > -{
> > - struct optee_call_waiter w;
> > -
> > - /* We need to retry until secure world isn't busy. */
> > - optee_cq_wait_init(&optee->call_queue, &w);
> > - while (true) {
> > - union {
> > - struct arm_smccc_res smccc;
> > - struct optee_smc_disable_shm_cache_result result;
> > - } res;
> > -
> > - optee->invoke_fn(OPTEE_SMC_DISABLE_SHM_CACHE, 0, 0, 0, 0, 0, 0,
> > - 0, &res.smccc);
> > - if (res.result.status == OPTEE_SMC_RETURN_ENOTAVAIL)
> > - break; /* All shm's freed */
> > - if (res.result.status == OPTEE_SMC_RETURN_OK) {
> > - struct tee_shm *shm;
> > -
> > - shm = reg_pair_to_ptr(res.result.shm_upper32,
> > - res.result.shm_lower32);
> > - tee_shm_free(shm);
> > - } else {
> > - optee_cq_wait_for_completion(&optee->call_queue, &w);
> > - }
> > - }
> > - optee_cq_wait_final(&optee->call_queue, &w);
> > -}
> > -
> > -#define PAGELIST_ENTRIES_PER_PAGE \
> > - ((OPTEE_MSG_NONCONTIG_PAGE_SIZE / sizeof(u64)) - 1)
> > -
> > -/**
> > - * optee_fill_pages_list() - write list of user pages to given shared
> > - * buffer.
> > - *
> > - * @dst: page-aligned buffer where list of pages will be stored
> > - * @pages: array of pages that represents shared buffer
> > - * @num_pages: number of entries in @pages
> > - * @page_offset: offset of user buffer from page start
> > - *
> > - * @dst should be big enough to hold list of user page addresses and
> > - * links to the next pages of buffer
> > - */
> > -void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,
> > - size_t page_offset)
> > -{
> > - int n = 0;
> > - phys_addr_t optee_page;
> > - /*
> > - * Refer to OPTEE_MSG_ATTR_NONCONTIG description in optee_msg.h
> > - * for details.
> > - */
> > - struct {
> > - u64 pages_list[PAGELIST_ENTRIES_PER_PAGE];
> > - u64 next_page_data;
> > - } *pages_data;
> > -
> > - /*
> > - * Currently OP-TEE uses 4k page size and it does not looks
> > - * like this will change in the future. On other hand, there are
> > - * no know ARM architectures with page size < 4k.
> > - * Thus the next built assert looks redundant. But the following
> > - * code heavily relies on this assumption, so it is better be
> > - * safe than sorry.
> > - */
> > - BUILD_BUG_ON(PAGE_SIZE < OPTEE_MSG_NONCONTIG_PAGE_SIZE);
> > -
> > - pages_data = (void *)dst;
> > - /*
> > - * If linux page is bigger than 4k, and user buffer offset is
> > - * larger than 4k/8k/12k/etc this will skip first 4k pages,
> > - * because they bear no value data for OP-TEE.
> > - */
> > - optee_page = page_to_phys(*pages) +
> > - round_down(page_offset, OPTEE_MSG_NONCONTIG_PAGE_SIZE);
> > -
> > - while (true) {
> > - pages_data->pages_list[n++] = optee_page;
> > -
> > - if (n == PAGELIST_ENTRIES_PER_PAGE) {
> > - pages_data->next_page_data =
> > - virt_to_phys(pages_data + 1);
> > - pages_data++;
> > - n = 0;
> > - }
> > -
> > - optee_page += OPTEE_MSG_NONCONTIG_PAGE_SIZE;
> > - if (!(optee_page & ~PAGE_MASK)) {
> > - if (!--num_pages)
> > - break;
> > - pages++;
> > - optee_page = page_to_phys(*pages);
> > - }
> > - }
> > -}
> > -
> > -/*
> > - * The final entry in each pagelist page is a pointer to the next
> > - * pagelist page.
> > - */
> > -static size_t get_pages_list_size(size_t num_entries)
> > -{
> > - int pages = DIV_ROUND_UP(num_entries, PAGELIST_ENTRIES_PER_PAGE);
> > -
> > - return pages * OPTEE_MSG_NONCONTIG_PAGE_SIZE;
> > -}
> > -
> > -u64 *optee_allocate_pages_list(size_t num_entries)
> > -{
> > - return alloc_pages_exact(get_pages_list_size(num_entries), GFP_KERNEL);
> > -}
> > -
> > -void optee_free_pages_list(void *list, size_t num_entries)
> > -{
> > - free_pages_exact(list, get_pages_list_size(num_entries));
> > -}
> > -
> > static bool is_normal_memory(pgprot_t p)
> > {
> > #if defined(CONFIG_ARM)
> > @@ -566,7 +344,7 @@ static int __check_mem_type(struct vm_area_struct *vma, unsigned long end)
> > return -EINVAL;
> > }
> >
> > -static int check_mem_type(unsigned long start, size_t num_pages)
> > +int optee_check_mem_type(unsigned long start, size_t num_pages)
> > {
> > struct mm_struct *mm = current->mm;
> > int rc;
> > @@ -585,94 +363,3 @@ static int check_mem_type(unsigned long start, size_t num_pages)
> >
> > return rc;
> > }
> > -
> > -int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> > - struct page **pages, size_t num_pages,
> > - unsigned long start)
> > -{
> > - struct optee *optee = tee_get_drvdata(ctx->teedev);
> > - struct optee_msg_arg *msg_arg;
> > - struct tee_shm *shm_arg;
> > - u64 *pages_list;
> > - int rc;
> > -
> > - if (!num_pages)
> > - return -EINVAL;
> > -
> > - rc = check_mem_type(start, num_pages);
> > - if (rc)
> > - return rc;
> > -
> > - pages_list = optee_allocate_pages_list(num_pages);
> > - if (!pages_list)
> > - return -ENOMEM;
> > -
> > - shm_arg = get_msg_arg(ctx, 1, &msg_arg);
> > - if (IS_ERR(shm_arg)) {
> > - rc = PTR_ERR(shm_arg);
> > - goto out;
> > - }
> > -
> > - optee_fill_pages_list(pages_list, pages, num_pages,
> > - tee_shm_get_page_offset(shm));
> > -
> > - 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.shm_ref = (unsigned long)shm;
> > - msg_arg->params->u.tmem.size = tee_shm_get_size(shm);
> > - /*
> > - * In the least bits of msg_arg->params->u.tmem.buf_ptr we
> > - * store buffer offset from 4k page, as described in OP-TEE ABI.
> > - */
> > - msg_arg->params->u.tmem.buf_ptr = virt_to_phys(pages_list) |
> > - (tee_shm_get_page_offset(shm) & (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
> > -
> > - if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> > - msg_arg->ret != TEEC_SUCCESS)
> > - rc = -EINVAL;
> > -
> > - tee_shm_free(shm_arg);
> > -out:
> > - optee_free_pages_list(pages_list, num_pages);
> > - return rc;
> > -}
> > -
> > -int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
> > -{
> > - struct optee *optee = tee_get_drvdata(ctx->teedev);
> > - struct optee_msg_arg *msg_arg;
> > - struct tee_shm *shm_arg;
> > - int rc = 0;
> > -
> > - shm_arg = get_msg_arg(ctx, 1, &msg_arg);
> > - if (IS_ERR(shm_arg))
> > - return PTR_ERR(shm_arg);
> > -
> > - 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 = (unsigned long)shm;
> > -
> > - if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> > - msg_arg->ret != TEEC_SUCCESS)
> > - rc = -EINVAL;
> > - tee_shm_free(shm_arg);
> > - return rc;
> > -}
> > -
> > -int optee_shm_register_supp(struct tee_context *ctx, struct tee_shm *shm,
> > - struct page **pages, size_t num_pages,
> > - unsigned long start)
> > -{
> > - /*
> > - * We don't want to register supplicant memory in OP-TEE.
> > - * Instead information about it will be passed in RPC code.
> > - */
> > - return check_mem_type(start, num_pages);
> > -}
> > -
> > -int optee_shm_unregister_supp(struct tee_context *ctx, struct tee_shm *shm)
> > -{
> > - return 0;
> > -}
> > diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c
> > index f689f171a794..e0dcde043df2 100644
> > --- a/drivers/tee/optee/core.c
> > +++ b/drivers/tee/optee/core.c
> > @@ -1,259 +1,62 @@
> > // SPDX-License-Identifier: GPL-2.0-only
> > /*
> > * Copyright (c) 2015-2021, Linaro Limited
> > + * Copyright (c) 2016, EPAM Systems
> > */
> >
> > #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
> >
> > -#include <linux/arm-smccc.h>
> > #include <linux/errno.h>
> > #include <linux/io.h>
> > +#include <linux/mm.h>
> > #include <linux/module.h>
> > -#include <linux/of.h>
> > -#include <linux/of_platform.h>
> > -#include <linux/platform_device.h>
> > #include <linux/slab.h>
> > #include <linux/string.h>
> > #include <linux/tee_drv.h>
> > #include <linux/types.h>
> > -#include <linux/uaccess.h>
> > #include <linux/workqueue.h>
> > #include "optee_private.h"
> > -#include "optee_smc.h"
> > -#include "shm_pool.h"
> >
> > -#define DRIVER_NAME "optee"
> > -
> > -#define OPTEE_SHM_NUM_PRIV_PAGES CONFIG_OPTEE_SHM_NUM_PRIV_PAGES
> > -
> > -static void from_msg_param_value(struct tee_param *p, u32 attr,
> > - const struct optee_msg_param *mp)
> > -{
> > - p->attr = TEE_IOCTL_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;
> > -}
> > -
> > -static int from_msg_param_tmp_mem(struct tee_param *p, u32 attr,
> > - const struct optee_msg_param *mp)
> > +int optee_pool_op_alloc_helper(struct tee_shm_pool_mgr *poolm,
> > + struct tee_shm *shm, size_t size,
> > + int (*shm_register)(struct tee_context *ctx,
> > + struct tee_shm *shm,
> > + struct page **pages,
> > + size_t num_pages,
> > + unsigned long start))
> > {
> > - struct tee_shm *shm;
> > - phys_addr_t pa;
> > - int rc;
> > -
> > - p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> > - attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
> > - p->u.memref.size = mp->u.tmem.size;
> > - shm = (struct tee_shm *)(unsigned long)mp->u.tmem.shm_ref;
> > - if (!shm) {
> > - p->u.memref.shm_offs = 0;
> > - p->u.memref.shm = NULL;
> > - return 0;
> > - }
> > -
> > - rc = tee_shm_get_pa(shm, 0, &pa);
> > - if (rc)
> > - return rc;
> > -
> > - p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
> > - p->u.memref.shm = shm;
> > -
> > - /* Check that the memref is covered by the shm object */
> > - if (p->u.memref.size) {
> > - size_t o = p->u.memref.shm_offs +
> > - p->u.memref.size - 1;
> > -
> > - rc = tee_shm_get_pa(shm, o, NULL);
> > - if (rc)
> > - return rc;
> > - }
> > + unsigned int order = get_order(size);
> > + struct page *page;
> > + int rc = 0;
> >
> > - return 0;
> > -}
> > -
> > -static void from_msg_param_reg_mem(struct tee_param *p, u32 attr,
> > - const struct optee_msg_param *mp)
> > -{
> > - struct tee_shm *shm;
> > -
> > - p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> > - attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> > - p->u.memref.size = mp->u.rmem.size;
> > - shm = (struct tee_shm *)(unsigned long)mp->u.rmem.shm_ref;
> > -
> > - if (shm) {
> > - p->u.memref.shm_offs = mp->u.rmem.offs;
> > - p->u.memref.shm = shm;
> > - } else {
> > - p->u.memref.shm_offs = 0;
> > - p->u.memref.shm = NULL;
> > - }
> > -}
> > + page = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
> > + if (!page)
> > + return -ENOMEM;
> >
> > -/**
> > - * optee_from_msg_param() - convert from OPTEE_MSG parameters to
> > - * struct tee_param
> > - * @optee: main service struct
> > - * @params: subsystem internal parameter representation
> > - * @num_params: number of elements in the parameter arrays
> > - * @msg_params: OPTEE_MSG parameters
> > - * Returns 0 on success or <0 on failure
> > - */
> > -static int optee_from_msg_param(struct optee *optee, struct tee_param *params,
> > - size_t num_params,
> > - const struct optee_msg_param *msg_params)
> > -{
> > - int rc;
> > - size_t n;
> > + shm->kaddr = page_address(page);
> > + shm->paddr = page_to_phys(page);
> > + shm->size = PAGE_SIZE << order;
> >
> > - 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;
> > + if (shm_register) {
> > + unsigned int nr_pages = 1 << order, i;
> > + struct page **pages;
> >
> > - switch (attr) {
> > - case OPTEE_MSG_ATTR_TYPE_NONE:
> > - p->attr = TEE_IOCTL_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:
> > - from_msg_param_value(p, attr, mp);
> > - break;
> > - case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:
> > - case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
> > - case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
> > - rc = from_msg_param_tmp_mem(p, attr, mp);
> > - if (rc)
> > - return rc;
> > - break;
> > - case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:
> > - case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:
> > - case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:
> > - from_msg_param_reg_mem(p, attr, mp);
> > - break;
> > + pages = kcalloc(nr_pages, sizeof(pages), GFP_KERNEL);
> > + if (!pages)
> > + return -ENOMEM;
> >
> > - default:
> > - return -EINVAL;
> > + for (i = 0; i < nr_pages; i++) {
> > + pages[i] = page;
> > + page++;
> > }
> > - }
> > - return 0;
> > -}
> > -
> > -static void to_msg_param_value(struct optee_msg_param *mp,
> > - const struct tee_param *p)
> > -{
> > - mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
> > - TEE_IOCTL_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;
> > -}
> >
> > -static int to_msg_param_tmp_mem(struct optee_msg_param *mp,
> > - const struct tee_param *p)
> > -{
> > - int rc;
> > - phys_addr_t pa;
> > -
> > - mp->attr = OPTEE_MSG_ATTR_TYPE_TMEM_INPUT + p->attr -
> > - TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
> > -
> > - mp->u.tmem.shm_ref = (unsigned long)p->u.memref.shm;
> > - mp->u.tmem.size = p->u.memref.size;
> > -
> > - if (!p->u.memref.shm) {
> > - mp->u.tmem.buf_ptr = 0;
> > - return 0;
> > + shm->flags |= TEE_SHM_REGISTER;
> > + rc = shm_register(shm->ctx, shm, pages, nr_pages,
> > + (unsigned long)shm->kaddr);
> > + kfree(pages);
> > }
> >
> > - rc = tee_shm_get_pa(p->u.memref.shm, p->u.memref.shm_offs, &pa);
> > - if (rc)
> > - return rc;
> > -
> > - mp->u.tmem.buf_ptr = pa;
> > - mp->attr |= OPTEE_MSG_ATTR_CACHE_PREDEFINED <<
> > - OPTEE_MSG_ATTR_CACHE_SHIFT;
> > -
> > - return 0;
> > -}
> > -
> > -static int to_msg_param_reg_mem(struct optee_msg_param *mp,
> > - const struct tee_param *p)
> > -{
> > - mp->attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT + p->attr -
> > - TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
> > -
> > - mp->u.rmem.shm_ref = (unsigned long)p->u.memref.shm;
> > - mp->u.rmem.size = p->u.memref.size;
> > - mp->u.rmem.offs = p->u.memref.shm_offs;
> > - return 0;
> > -}
> > -
> > -/**
> > - * optee_to_msg_param() - convert from struct tee_params to OPTEE_MSG parameters
> > - * @optee: main service struct
> > - * @msg_params: OPTEE_MSG parameters
> > - * @num_params: number of elements in the parameter arrays
> > - * @params: subsystem itnernal parameter representation
> > - * Returns 0 on success or <0 on failure
> > - */
> > -static int optee_to_msg_param(struct optee *optee,
> > - struct optee_msg_param *msg_params,
> > - size_t num_params, const struct tee_param *params)
> > -{
> > - int rc;
> > - size_t 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_IOCTL_PARAM_ATTR_TYPE_NONE:
> > - mp->attr = TEE_IOCTL_PARAM_ATTR_TYPE_NONE;
> > - memset(&mp->u, 0, sizeof(mp->u));
> > - break;
> > - case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT:
> > - case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
> > - case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
> > - to_msg_param_value(mp, p);
> > - break;
> > - case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT:
> > - case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
> > - case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:
> > - if (tee_shm_is_registered(p->u.memref.shm))
> > - rc = to_msg_param_reg_mem(mp, p);
> > - else
> > - rc = to_msg_param_tmp_mem(mp, p);
> > - if (rc)
> > - return rc;
> > - break;
> > - default:
> > - return -EINVAL;
> > - }
> > - }
> > - return 0;
> > -}
> > -
> > -static void optee_get_version(struct tee_device *teedev,
> > - struct tee_ioctl_version_data *vers)
> > -{
> > - struct tee_ioctl_version_data v = {
> > - .impl_id = TEE_IMPL_ID_OPTEE,
> > - .impl_caps = TEE_OPTEE_CAP_TZ,
> > - .gen_caps = TEE_GEN_CAP_GP,
> > - };
> > - struct optee *optee = tee_get_drvdata(teedev);
> > -
> > - if (optee->sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
> > - v.gen_caps |= TEE_GEN_CAP_REG_MEM;
> > - if (optee->sec_caps & OPTEE_SMC_SEC_CAP_MEMREF_NULL)
> > - v.gen_caps |= TEE_GEN_CAP_MEMREF_NULL;
> > - *vers = v;
> > + return rc;
> > }
> >
> > static void optee_bus_scan(struct work_struct *work)
> > @@ -261,7 +64,7 @@ static void optee_bus_scan(struct work_struct *work)
> > WARN_ON(optee_enumerate_devices(PTA_CMD_GET_DEVICES_SUPP));
> > }
> >
> > -static int optee_open(struct tee_context *ctx)
> > +int optee_open(struct tee_context *ctx, bool cap_memref_null)
> > {
> > struct optee_context_data *ctxdata;
> > struct tee_device *teedev = ctx->teedev;
> > @@ -299,11 +102,7 @@ static int optee_open(struct tee_context *ctx)
> > mutex_init(&ctxdata->mutex);
> > INIT_LIST_HEAD(&ctxdata->sess_list);
> >
> > - if (optee->sec_caps & OPTEE_SMC_SEC_CAP_MEMREF_NULL)
> > - ctx->cap_memref_null = true;
> > - else
> > - ctx->cap_memref_null = false;
> > -
> > + ctx->cap_memref_null = cap_memref_null;
> > ctx->data = ctxdata;
> > return 0;
> > }
> > @@ -329,12 +128,12 @@ static void optee_release_helper(struct tee_context *ctx,
> > ctx->data = NULL;
> > }
> >
> > -static void optee_release(struct tee_context *ctx)
> > +void optee_release(struct tee_context *ctx)
> > {
> > optee_release_helper(ctx, optee_close_session_helper);
> > }
> >
> > -static void optee_release_supp(struct tee_context *ctx)
> > +void optee_release_supp(struct tee_context *ctx)
> > {
> > struct optee *optee = tee_get_drvdata(ctx->teedev);
> >
> > @@ -346,277 +145,8 @@ static void optee_release_supp(struct tee_context *ctx)
> > optee_supp_release(&optee->supp);
> > }
> >
> > -static const struct tee_driver_ops optee_clnt_ops = {
> > - .get_version = optee_get_version,
> > - .open = optee_open,
> > - .release = optee_release,
> > - .open_session = optee_open_session,
> > - .close_session = optee_close_session,
> > - .invoke_func = optee_invoke_func,
> > - .cancel_req = optee_cancel_req,
> > - .shm_register = optee_shm_register,
> > - .shm_unregister = optee_shm_unregister,
> > -};
> > -
> > -static const struct tee_desc optee_clnt_desc = {
> > - .name = DRIVER_NAME "-clnt",
> > - .ops = &optee_clnt_ops,
> > - .owner = THIS_MODULE,
> > -};
> > -
> > -static const struct tee_driver_ops optee_supp_ops = {
> > - .get_version = optee_get_version,
> > - .open = optee_open,
> > - .release = optee_release_supp,
> > - .supp_recv = optee_supp_recv,
> > - .supp_send = optee_supp_send,
> > - .shm_register = optee_shm_register_supp,
> > - .shm_unregister = optee_shm_unregister_supp,
> > -};
> > -
> > -static const struct tee_desc optee_supp_desc = {
> > - .name = DRIVER_NAME "-supp",
> > - .ops = &optee_supp_ops,
> > - .owner = THIS_MODULE,
> > - .flags = TEE_DESC_PRIVILEGED,
> > -};
> > -
> > -static const struct optee_ops optee_ops = {
> > - .do_call_with_arg = optee_do_call_with_arg,
> > - .to_msg_param = optee_to_msg_param,
> > - .from_msg_param = optee_from_msg_param,
> > -};
> > -
> > -static bool optee_msg_api_uid_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);
> > -
> > - if (res.a0 == OPTEE_MSG_UID_0 && res.a1 == OPTEE_MSG_UID_1 &&
> > - res.a2 == OPTEE_MSG_UID_2 && res.a3 == OPTEE_MSG_UID_3)
> > - return true;
> > - return false;
> > -}
> > -
> > -static void optee_msg_get_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)
> > - pr_info("revision %lu.%lu (%08lx)", res.result.major,
> > - res.result.minor, res.result.build_id);
> > - else
> > - pr_info("revision %lu.%lu", res.result.major, res.result.minor);
> > -}
> > -
> > -static bool optee_msg_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);
> > -
> > - if (res.result.major == OPTEE_MSG_REVISION_MAJOR &&
> > - (int)res.result.minor >= OPTEE_MSG_REVISION_MINOR)
> > - return true;
> > - return false;
> > -}
> > -
> > -static bool optee_msg_exchange_capabilities(optee_invoke_fn *invoke_fn,
> > - u32 *sec_caps)
> > -{
> > - union {
> > - struct arm_smccc_res smccc;
> > - struct optee_smc_exchange_capabilities_result result;
> > - } res;
> > - u32 a1 = 0;
> > -
> > - /*
> > - * TODO This isn't enough to tell if it's UP system (from kernel
> > - * point of view) or not, is_smp() returns the the information
> > - * needed, but can't be called directly from here.
> > - */
> > - if (!IS_ENABLED(CONFIG_SMP) || nr_cpu_ids == 1)
> > - a1 |= OPTEE_SMC_NSEC_CAP_UNIPROCESSOR;
> > -
> > - invoke_fn(OPTEE_SMC_EXCHANGE_CAPABILITIES, a1, 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;
> > -}
> > -
> > -static struct tee_shm_pool *optee_config_dyn_shm(void)
> > -{
> > - struct tee_shm_pool_mgr *priv_mgr;
> > - struct tee_shm_pool_mgr *dmabuf_mgr;
> > - void *rc;
> > -
> > - rc = optee_shm_pool_alloc_pages();
> > - if (IS_ERR(rc))
> > - return rc;
> > - priv_mgr = rc;
> > -
> > - rc = optee_shm_pool_alloc_pages();
> > - if (IS_ERR(rc)) {
> > - tee_shm_pool_mgr_destroy(priv_mgr);
> > - return rc;
> > - }
> > - dmabuf_mgr = rc;
> > -
> > - rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
> > - if (IS_ERR(rc)) {
> > - tee_shm_pool_mgr_destroy(priv_mgr);
> > - tee_shm_pool_mgr_destroy(dmabuf_mgr);
> > - }
> > -
> > - return rc;
> > -}
> > -
> > -static struct tee_shm_pool *
> > -optee_config_shm_memremap(optee_invoke_fn *invoke_fn, void **memremaped_shm)
> > +void optee_remove_common(struct optee *optee)
> > {
> > - union {
> > - struct arm_smccc_res smccc;
> > - struct optee_smc_get_shm_config_result result;
> > - } res;
> > - unsigned long vaddr;
> > - phys_addr_t paddr;
> > - size_t size;
> > - phys_addr_t begin;
> > - phys_addr_t end;
> > - void *va;
> > - struct tee_shm_pool_mgr *priv_mgr;
> > - struct tee_shm_pool_mgr *dmabuf_mgr;
> > - void *rc;
> > - const int sz = OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE;
> > -
> > - invoke_fn(OPTEE_SMC_GET_SHM_CONFIG, 0, 0, 0, 0, 0, 0, 0, &res.smccc);
> > - if (res.result.status != OPTEE_SMC_RETURN_OK) {
> > - pr_err("static shm service not available\n");
> > - return ERR_PTR(-ENOENT);
> > - }
> > -
> > - if (res.result.settings != OPTEE_SMC_SHM_CACHED) {
> > - pr_err("only normal cached shared memory supported\n");
> > - return ERR_PTR(-EINVAL);
> > - }
> > -
> > - begin = roundup(res.result.start, PAGE_SIZE);
> > - end = rounddown(res.result.start + res.result.size, PAGE_SIZE);
> > - paddr = begin;
> > - size = end - begin;
> > -
> > - if (size < 2 * OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE) {
> > - pr_err("too small shared memory area\n");
> > - return ERR_PTR(-EINVAL);
> > - }
> > -
> > - va = memremap(paddr, size, MEMREMAP_WB);
> > - if (!va) {
> > - pr_err("shared memory ioremap failed\n");
> > - return ERR_PTR(-EINVAL);
> > - }
> > - vaddr = (unsigned long)va;
> > -
> > - rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, sz,
> > - 3 /* 8 bytes aligned */);
> > - if (IS_ERR(rc))
> > - goto err_memunmap;
> > - priv_mgr = rc;
> > -
> > - vaddr += sz;
> > - paddr += sz;
> > - size -= sz;
> > -
> > - rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, size, PAGE_SHIFT);
> > - if (IS_ERR(rc))
> > - goto err_free_priv_mgr;
> > - dmabuf_mgr = rc;
> > -
> > - rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr);
> > - if (IS_ERR(rc))
> > - goto err_free_dmabuf_mgr;
> > -
> > - *memremaped_shm = va;
> > -
> > - return rc;
> > -
> > -err_free_dmabuf_mgr:
> > - tee_shm_pool_mgr_destroy(dmabuf_mgr);
> > -err_free_priv_mgr:
> > - tee_shm_pool_mgr_destroy(priv_mgr);
> > -err_memunmap:
> > - memunmap(va);
> > - return rc;
> > -}
> > -
> > -/* 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 device *dev)
> > -{
> > - const char *method;
> > -
> > - pr_info("probing for conduit method.\n");
> > -
> > - if (device_property_read_string(dev, "method", &method)) {
> > - pr_warn("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;
> > -
> > - pr_warn("invalid \"method\" property: %s\n", method);
> > - return ERR_PTR(-EINVAL);
> > -}
> > -
> > -static int optee_remove(struct platform_device *pdev)
> > -{
> > - struct optee *optee = platform_get_drvdata(pdev);
> > -
> > - /*
> > - * Ask OP-TEE to free all cached shared memory objects to decrease
> > - * reference counters and also avoid wild pointers in secure world
> > - * into the old shared memory range.
> > - */
> > - optee_disable_shm_cache(optee);
> > -
> > /*
> > * The two devices have to be unregistered before we can free the
> > * other resources.
> > @@ -625,151 +155,11 @@ static int optee_remove(struct platform_device *pdev)
> > tee_device_unregister(optee->teedev);
> >
> > tee_shm_pool_free(optee->pool);
> > - if (optee->memremaped_shm)
> > - memunmap(optee->memremaped_shm);
> > optee_wait_queue_exit(&optee->wait_queue);
> > optee_supp_uninit(&optee->supp);
> > mutex_destroy(&optee->call_queue.mutex);
> > -
> > - kfree(optee);
> > -
> > - return 0;
> > -}
> > -
> > -static int optee_probe(struct platform_device *pdev)
> > -{
> > - optee_invoke_fn *invoke_fn;
> > - struct tee_shm_pool *pool = ERR_PTR(-EINVAL);
> > - struct optee *optee = NULL;
> > - void *memremaped_shm = NULL;
> > - struct tee_device *teedev;
> > - u32 sec_caps;
> > - int rc;
> > -
> > - invoke_fn = get_invoke_func(&pdev->dev);
> > - if (IS_ERR(invoke_fn))
> > - return PTR_ERR(invoke_fn);
> > -
> > - if (!optee_msg_api_uid_is_optee_api(invoke_fn)) {
> > - pr_warn("api uid mismatch\n");
> > - return -EINVAL;
> > - }
> > -
> > - optee_msg_get_os_revision(invoke_fn);
> > -
> > - if (!optee_msg_api_revision_is_compatible(invoke_fn)) {
> > - pr_warn("api revision mismatch\n");
> > - return -EINVAL;
> > - }
> > -
> > - if (!optee_msg_exchange_capabilities(invoke_fn, &sec_caps)) {
> > - pr_warn("capabilities mismatch\n");
> > - return -EINVAL;
> > - }
> > -
> > - /*
> > - * Try to use dynamic shared memory if possible
> > - */
> > - if (sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
> > - pool = optee_config_dyn_shm();
> > -
> > - /*
> > - * If dynamic shared memory is not available or failed - try static one
> > - */
> > - if (IS_ERR(pool) && (sec_caps & OPTEE_SMC_SEC_CAP_HAVE_RESERVED_SHM))
> > - pool = optee_config_shm_memremap(invoke_fn, &memremaped_shm);
> > -
> > - if (IS_ERR(pool))
> > - return PTR_ERR(pool);
> > -
> > - optee = kzalloc(sizeof(*optee), GFP_KERNEL);
> > - if (!optee) {
> > - rc = -ENOMEM;
> > - goto err;
> > - }
> > -
> > - optee->ops = &optee_ops;
> > - optee->invoke_fn = invoke_fn;
> > - optee->sec_caps = sec_caps;
> > -
> > - teedev = tee_device_alloc(&optee_clnt_desc, NULL, pool, optee);
> > - if (IS_ERR(teedev)) {
> > - rc = PTR_ERR(teedev);
> > - goto err;
> > - }
> > - optee->teedev = teedev;
> > -
> > - teedev = tee_device_alloc(&optee_supp_desc, NULL, pool, optee);
> > - if (IS_ERR(teedev)) {
> > - rc = PTR_ERR(teedev);
> > - goto err;
> > - }
> > - optee->supp_teedev = teedev;
> > -
> > - rc = tee_device_register(optee->teedev);
> > - if (rc)
> > - goto err;
> > -
> > - rc = tee_device_register(optee->supp_teedev);
> > - if (rc)
> > - goto err;
> > -
> > - mutex_init(&optee->call_queue.mutex);
> > - INIT_LIST_HEAD(&optee->call_queue.waiters);
> > - optee_wait_queue_init(&optee->wait_queue);
> > - optee_supp_init(&optee->supp);
> > - optee->memremaped_shm = memremaped_shm;
> > - optee->pool = pool;
> > -
> > - optee_enable_shm_cache(optee);
> > -
> > - if (optee->sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)
> > - pr_info("dynamic shared memory is enabled\n");
> > -
> > - platform_set_drvdata(pdev, optee);
> > -
> > - rc = optee_enumerate_devices(PTA_CMD_GET_DEVICES);
> > - if (rc) {
> > - optee_remove(pdev);
> > - return rc;
> > - }
> > -
> > - pr_info("initialized driver\n");
> > - return 0;
> > -err:
> > - if (optee) {
> > - /*
> > - * tee_device_unregister() is safe to call even if the
> > - * devices hasn't been registered with
> > - * tee_device_register() yet.
> > - */
> > - tee_device_unregister(optee->supp_teedev);
> > - tee_device_unregister(optee->teedev);
> > - kfree(optee);
> > - }
> > - if (pool)
> > - tee_shm_pool_free(pool);
> > - if (memremaped_shm)
> > - memunmap(memremaped_shm);
> > - return rc;
> > }
> >
> > -static const struct of_device_id optee_dt_match[] = {
> > - { .compatible = "linaro,optee-tz" },
> > - {},
> > -};
> > -MODULE_DEVICE_TABLE(of, optee_dt_match);
> > -
> > -static struct platform_driver optee_driver = {
> > - .probe = optee_probe,
> > - .remove = optee_remove,
> > - .driver = {
> > - .name = "optee",
> > - .of_match_table = optee_dt_match,
> > - },
> > -};
> > -module_platform_driver(optee_driver);
> > -
> > MODULE_AUTHOR("Linaro");
> > MODULE_DESCRIPTION("OP-TEE driver");
> > MODULE_VERSION("1.0");
> > diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h
> > index c5741e96e967..68d1331068e9 100644
> > --- a/drivers/tee/optee/optee_private.h
> > +++ b/drivers/tee/optee/optee_private.h
> > @@ -12,6 +12,8 @@
> > #include <linux/types.h>
> > #include "optee_msg.h"
> >
> > +#define DRIVER_NAME "optee"
> > +
> > #define OPTEE_MAX_ARG_SIZE 1024
> >
> > /* Some Global Platform error codes used in this driver */
> > @@ -29,6 +31,11 @@ typedef void (optee_invoke_fn)(unsigned long, unsigned long, unsigned long,
> > unsigned long, unsigned long,
> > struct arm_smccc_res *);
> >
> > +struct optee_call_waiter {
> > + struct list_head list_node;
> > + struct completion c;
> > +};
> > +
> > struct optee_call_queue {
> > /* Serializes access to this struct */
> > struct mutex mutex;
> > @@ -66,6 +73,19 @@ struct optee_supp {
> > struct completion reqs_c;
> > };
> >
> > +/**
> > + * struct optee_smc - SMC ABI specifics
> > + * @invoke_fn: function to issue smc or hvc
> > + * @memremaped_shm virtual address of memory in shared memory pool
> > + * @sec_caps: secure world capabilities defined by
> > + * OPTEE_SMC_SEC_CAP_* in optee_smc.h
> > + */
> > +struct optee_smc {
> > + optee_invoke_fn *invoke_fn;
> > + void *memremaped_shm;
> > + u32 sec_caps;
> > +};
> > +
> > struct optee;
> >
> > /**
> > @@ -95,15 +115,12 @@ struct optee_ops {
> > * @ops: internal callbacks for different ways to reach secure
> > * world
> > * @teedev: client device
> > - * @invoke_fn: function to issue smc or hvc
> > + * @smc: specific to SMC ABI
> > * @call_queue: queue of threads waiting to call @invoke_fn
> > * @wait_queue: queue of threads from secure world waiting for a
> > * secure world sync object
> > * @supp: supplicant synchronization struct for RPC to supplicant
> > * @pool: shared memory pool
> > - * @memremaped_shm virtual address of memory in shared memory pool
> > - * @sec_caps: secure world capabilities defined by
> > - * OPTEE_SMC_SEC_CAP_* in optee_smc.h
> > * @scan_bus_done flag if device registation was already done.
> > * @scan_bus_wq workqueue to scan optee bus and register optee drivers
> > * @scan_bus_work workq to scan optee bus and register optee drivers
> > @@ -112,13 +129,11 @@ struct optee {
> > struct tee_device *supp_teedev;
> > struct tee_device *teedev;
> > const struct optee_ops *ops;
> > - optee_invoke_fn *invoke_fn;
> > + struct optee_smc smc;
> > struct optee_call_queue call_queue;
> > struct optee_wait_queue wait_queue;
> > struct optee_supp supp;
> > struct tee_shm_pool *pool;
> > - void *memremaped_shm;
> > - u32 sec_caps;
> > bool scan_bus_done;
> > struct workqueue_struct *scan_bus_wq;
> > struct work_struct scan_bus_work;
> > @@ -153,10 +168,6 @@ struct optee_call_ctx {
> > size_t num_entries;
> > };
> >
> > -void optee_handle_rpc(struct tee_context *ctx, struct optee_rpc_param *param,
> > - struct optee_call_ctx *call_ctx);
> > -void optee_rpc_finalize_call(struct optee_call_ctx *call_ctx);
> > -
> > void optee_wait_queue_init(struct optee_wait_queue *wq);
> > void optee_wait_queue_exit(struct optee_wait_queue *wq);
> >
> > @@ -174,7 +185,6 @@ int optee_supp_recv(struct tee_context *ctx, u32 *func, u32 *num_params,
> > int optee_supp_send(struct tee_context *ctx, u32 ret, u32 num_params,
> > struct tee_param *param);
> >
> > -int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg);
> > int optee_open_session(struct tee_context *ctx,
> > struct tee_ioctl_open_session_arg *arg,
> > struct tee_param *param);
> > @@ -184,27 +194,63 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> > struct tee_param *param);
> > int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session);
> >
> > -void optee_enable_shm_cache(struct optee *optee);
> > -void optee_disable_shm_cache(struct optee *optee);
> > +#define PTA_CMD_GET_DEVICES 0x0
> > +#define PTA_CMD_GET_DEVICES_SUPP 0x1
> > +int optee_enumerate_devices(u32 func);
> >
> > -int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> > - struct page **pages, size_t num_pages,
> > - unsigned long start);
> > -int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm);
> > +int optee_pool_op_alloc_helper(struct tee_shm_pool_mgr *poolm,
> > + struct tee_shm *shm, size_t size,
> > + int (*shm_register)(struct tee_context *ctx,
> > + struct tee_shm *shm,
> > + struct page **pages,
> > + size_t num_pages,
> > + unsigned long start));
> >
> > -int optee_shm_register_supp(struct tee_context *ctx, struct tee_shm *shm,
> > - struct page **pages, size_t num_pages,
> > - unsigned long start);
> > -int optee_shm_unregister_supp(struct tee_context *ctx, struct tee_shm *shm);
> >
> > -u64 *optee_allocate_pages_list(size_t num_entries);
> > -void optee_free_pages_list(void *array, size_t num_entries);
> > -void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,
> > - size_t page_offset);
> > +void optee_remove_common(struct optee *optee);
> > +int optee_open(struct tee_context *ctx, bool cap_memref_null);
> > +void optee_release(struct tee_context *ctx);
> > +void optee_release_supp(struct tee_context *ctx);
> >
> > -#define PTA_CMD_GET_DEVICES 0x0
> > -#define PTA_CMD_GET_DEVICES_SUPP 0x1
> > -int optee_enumerate_devices(u32 func);
> > +static inline void optee_from_msg_param_value(struct tee_param *p, u32 attr,
> > + const struct optee_msg_param *mp)
> > +{
> > + p->attr = TEE_IOCTL_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;
> > +}
> > +
> > +static inline void optee_to_msg_param_value(struct optee_msg_param *mp,
> > + const struct tee_param *p)
> > +{
> > + mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
> > + TEE_IOCTL_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;
> > +}
> > +
> > +void optee_cq_wait_init(struct optee_call_queue *cq,
> > + struct optee_call_waiter *w);
> > +void optee_cq_wait_for_completion(struct optee_call_queue *cq,
> > + struct optee_call_waiter *w);
> > +void optee_cq_wait_final(struct optee_call_queue *cq,
> > + struct optee_call_waiter *w);
> > +int optee_check_mem_type(unsigned long start, size_t num_pages);
> > +struct tee_shm *optee_get_msg_arg(struct tee_context *ctx, size_t num_params,
> > + struct optee_msg_arg **msg_arg);
> > +
> > +struct tee_shm *optee_rpc_cmd_alloc_suppl(struct tee_context *ctx, size_t sz);
> > +void optee_rpc_cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm);
> > +void optee_rpc_func_cmd_get_time(struct optee_msg_arg *arg);
> > +void optee_rpc_func_cmd_wq(struct optee *optee, struct optee_msg_arg *arg);
> > +void optee_rpc_func_cmd_wait(struct optee_msg_arg *arg);
> > +void optee_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> > + struct optee_msg_arg *arg);
> > +void optee_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
> > + struct optee_msg_arg *arg);
> >
> > /*
> > * Small helpers
> > diff --git a/drivers/tee/optee/rpc.c b/drivers/tee/optee/rpc.c
> > index 39562fb6841e..e99e353b3f29 100644
> > --- a/drivers/tee/optee/rpc.c
> > +++ b/drivers/tee/optee/rpc.c
> > @@ -6,12 +6,10 @@
> > #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
> >
> > #include <linux/delay.h>
> > -#include <linux/device.h>
> > #include <linux/i2c.h>
> > #include <linux/slab.h>
> > #include <linux/tee_drv.h>
> > #include "optee_private.h"
> > -#include "optee_smc.h"
> > #include "optee_rpc_cmd.h"
> >
> > struct wq_entry {
> > @@ -31,7 +29,7 @@ void optee_wait_queue_exit(struct optee_wait_queue *priv)
> > mutex_destroy(&priv->mu);
> > }
> >
> > -static void handle_rpc_func_cmd_get_time(struct optee_msg_arg *arg)
> > +void optee_rpc_func_cmd_get_time(struct optee_msg_arg *arg)
> > {
> > struct timespec64 ts;
> >
> > @@ -52,8 +50,8 @@ static void handle_rpc_func_cmd_get_time(struct optee_msg_arg *arg)
> > }
> >
> > #if IS_REACHABLE(CONFIG_I2C)
> > -static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> > - struct optee_msg_arg *arg)
> > +void optee_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> > + struct optee_msg_arg *arg)
> > {
> > struct optee *optee = tee_get_drvdata(ctx->teedev);
> > struct tee_param *params;
> > @@ -139,8 +137,8 @@ static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> > arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> > }
> > #else
> > -static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> > - struct optee_msg_arg *arg)
> > +void optee_rpc_func_cmd_i2c_transfer(struct tee_context *ctx,
> > + struct optee_msg_arg *arg)
> > {
> > arg->ret = TEEC_ERROR_NOT_SUPPORTED;
> > }
> > @@ -188,8 +186,7 @@ static void wq_wakeup(struct optee_wait_queue *wq, u32 key)
> > complete(&w->c);
> > }
> >
> > -static void handle_rpc_func_cmd_wq(struct optee *optee,
> > - struct optee_msg_arg *arg)
> > +void optee_rpc_func_cmd_wq(struct optee *optee, struct optee_msg_arg *arg)
> > {
> > if (arg->num_params != 1)
> > goto bad;
> > @@ -215,7 +212,7 @@ static void handle_rpc_func_cmd_wq(struct optee *optee,
> > arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> > }
> >
> > -static void handle_rpc_func_cmd_wait(struct optee_msg_arg *arg)
> > +void optee_rpc_func_cmd_wait(struct optee_msg_arg *arg)
> > {
> > u32 msec_to_wait;
> >
> > @@ -237,8 +234,8 @@ static void handle_rpc_func_cmd_wait(struct optee_msg_arg *arg)
> > arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> > }
> >
> > -static void handle_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
> > - struct optee_msg_arg *arg)
> > +void optee_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
> > + struct optee_msg_arg *arg)
> > {
> > struct tee_param *params;
> >
> > @@ -266,7 +263,7 @@ static void handle_rpc_supp_cmd(struct tee_context *ctx, struct optee *optee,
> > kfree(params);
> > }
> >
> > -static struct tee_shm *cmd_alloc_suppl(struct tee_context *ctx, size_t sz)
> > +struct tee_shm *optee_rpc_cmd_alloc_suppl(struct tee_context *ctx, size_t sz)
> > {
> > u32 ret;
> > struct tee_param param;
> > @@ -289,103 +286,7 @@ static struct tee_shm *cmd_alloc_suppl(struct tee_context *ctx, size_t sz)
> > return shm;
> > }
> >
> > -static void handle_rpc_func_cmd_shm_alloc(struct tee_context *ctx,
> > - struct optee_msg_arg *arg,
> > - struct optee_call_ctx *call_ctx)
> > -{
> > - phys_addr_t pa;
> > - struct tee_shm *shm;
> > - size_t sz;
> > - size_t n;
> > -
> > - arg->ret_origin = TEEC_ORIGIN_COMMS;
> > -
> > - if (!arg->num_params ||
> > - arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) {
> > - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> > - return;
> > - }
> > -
> > - for (n = 1; n < arg->num_params; n++) {
> > - if (arg->params[n].attr != OPTEE_MSG_ATTR_TYPE_NONE) {
> > - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> > - return;
> > - }
> > - }
> > -
> > - sz = arg->params[0].u.value.b;
> > - switch (arg->params[0].u.value.a) {
> > - case OPTEE_RPC_SHM_TYPE_APPL:
> > - shm = cmd_alloc_suppl(ctx, sz);
> > - break;
> > - case OPTEE_RPC_SHM_TYPE_KERNEL:
> > - shm = tee_shm_alloc(ctx, sz, TEE_SHM_MAPPED);
> > - break;
> > - default:
> > - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> > - return;
> > - }
> > -
> > - if (IS_ERR(shm)) {
> > - arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
> > - return;
> > - }
> > -
> > - if (tee_shm_get_pa(shm, 0, &pa)) {
> > - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> > - goto bad;
> > - }
> > -
> > - sz = tee_shm_get_size(shm);
> > -
> > - if (tee_shm_is_registered(shm)) {
> > - struct page **pages;
> > - u64 *pages_list;
> > - size_t page_num;
> > -
> > - pages = tee_shm_get_pages(shm, &page_num);
> > - if (!pages || !page_num) {
> > - arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
> > - goto bad;
> > - }
> > -
> > - pages_list = optee_allocate_pages_list(page_num);
> > - if (!pages_list) {
> > - arg->ret = TEEC_ERROR_OUT_OF_MEMORY;
> > - goto bad;
> > - }
> > -
> > - call_ctx->pages_list = pages_list;
> > - call_ctx->num_entries = page_num;
> > -
> > - arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT |
> > - OPTEE_MSG_ATTR_NONCONTIG;
> > - /*
> > - * In the least bits of u.tmem.buf_ptr we store buffer offset
> > - * from 4k page, as described in OP-TEE ABI.
> > - */
> > - arg->params[0].u.tmem.buf_ptr = virt_to_phys(pages_list) |
> > - (tee_shm_get_page_offset(shm) &
> > - (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
> > - arg->params[0].u.tmem.size = tee_shm_get_size(shm);
> > - arg->params[0].u.tmem.shm_ref = (unsigned long)shm;
> > -
> > - optee_fill_pages_list(pages_list, pages, page_num,
> > - tee_shm_get_page_offset(shm));
> > - } else {
> > - arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT;
> > - arg->params[0].u.tmem.buf_ptr = pa;
> > - arg->params[0].u.tmem.size = sz;
> > - arg->params[0].u.tmem.shm_ref = (unsigned long)shm;
> > - }
> > -
> > - arg->ret = TEEC_SUCCESS;
> > - return;
> > -bad:
> > - tee_shm_free(shm);
> > -}
> > -
> > -static void cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm)
> > +void optee_rpc_cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm)
> > {
> > struct tee_param param;
> >
> > @@ -409,137 +310,3 @@ static void cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm)
> >
> > optee_supp_thrd_req(ctx, OPTEE_RPC_CMD_SHM_FREE, 1, &param);
> > }
> > -
> > -static void handle_rpc_func_cmd_shm_free(struct tee_context *ctx,
> > - struct optee_msg_arg *arg)
> > -{
> > - struct tee_shm *shm;
> > -
> > - arg->ret_origin = TEEC_ORIGIN_COMMS;
> > -
> > - if (arg->num_params != 1 ||
> > - arg->params[0].attr != OPTEE_MSG_ATTR_TYPE_VALUE_INPUT) {
> > - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> > - return;
> > - }
> > -
> > - shm = (struct tee_shm *)(unsigned long)arg->params[0].u.value.b;
> > - switch (arg->params[0].u.value.a) {
> > - case OPTEE_RPC_SHM_TYPE_APPL:
> > - cmd_free_suppl(ctx, shm);
> > - break;
> > - case OPTEE_RPC_SHM_TYPE_KERNEL:
> > - tee_shm_free(shm);
> > - break;
> > - default:
> > - arg->ret = TEEC_ERROR_BAD_PARAMETERS;
> > - }
> > - arg->ret = TEEC_SUCCESS;
> > -}
> > -
> > -static void free_pages_list(struct optee_call_ctx *call_ctx)
> > -{
> > - if (call_ctx->pages_list) {
> > - optee_free_pages_list(call_ctx->pages_list,
> > - call_ctx->num_entries);
> > - call_ctx->pages_list = NULL;
> > - call_ctx->num_entries = 0;
> > - }
> > -}
> > -
> > -void optee_rpc_finalize_call(struct optee_call_ctx *call_ctx)
> > -{
> > - free_pages_list(call_ctx);
> > -}
> > -
> > -static void handle_rpc_func_cmd(struct tee_context *ctx, struct optee *optee,
> > - struct tee_shm *shm,
> > - struct optee_call_ctx *call_ctx)
> > -{
> > - struct optee_msg_arg *arg;
> > -
> > - arg = tee_shm_get_va(shm, 0);
> > - if (IS_ERR(arg)) {
> > - pr_err("%s: tee_shm_get_va %p failed\n", __func__, shm);
> > - return;
> > - }
> > -
> > - switch (arg->cmd) {
> > - case OPTEE_RPC_CMD_GET_TIME:
> > - handle_rpc_func_cmd_get_time(arg);
> > - break;
> > - case OPTEE_RPC_CMD_WAIT_QUEUE:
> > - handle_rpc_func_cmd_wq(optee, arg);
> > - break;
> > - case OPTEE_RPC_CMD_SUSPEND:
> > - handle_rpc_func_cmd_wait(arg);
> > - break;
> > - case OPTEE_RPC_CMD_SHM_ALLOC:
> > - free_pages_list(call_ctx);
> > - handle_rpc_func_cmd_shm_alloc(ctx, arg, call_ctx);
> > - break;
> > - case OPTEE_RPC_CMD_SHM_FREE:
> > - handle_rpc_func_cmd_shm_free(ctx, arg);
> > - break;
> > - case OPTEE_RPC_CMD_I2C_TRANSFER:
> > - handle_rpc_func_cmd_i2c_transfer(ctx, arg);
> > - break;
> > - default:
> > - handle_rpc_supp_cmd(ctx, optee, arg);
> > - }
> > -}
> > -
> > -/**
> > - * optee_handle_rpc() - handle RPC from secure world
> > - * @ctx: context doing the RPC
> > - * @param: value of registers for the RPC
> > - * @call_ctx: call context. Preserved during one OP-TEE invocation
> > - *
> > - * Result of RPC is written back into @param.
> > - */
> > -void optee_handle_rpc(struct tee_context *ctx, struct optee_rpc_param *param,
> > - struct optee_call_ctx *call_ctx)
> > -{
> > - struct tee_device *teedev = ctx->teedev;
> > - struct optee *optee = tee_get_drvdata(teedev);
> > - struct tee_shm *shm;
> > - phys_addr_t pa;
> > -
> > - switch (OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0)) {
> > - case OPTEE_SMC_RPC_FUNC_ALLOC:
> > - shm = tee_shm_alloc(ctx, param->a1, TEE_SHM_MAPPED);
> > - if (!IS_ERR(shm) && !tee_shm_get_pa(shm, 0, &pa)) {
> > - reg_pair_from_64(&param->a1, &param->a2, pa);
> > - reg_pair_from_64(&param->a4, &param->a5,
> > - (unsigned long)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:
> > - /*
> > - * A foreign interrupt was raised while secure world was
> > - * executing, since they are handled in Linux a dummy RPC is
> > - * performed to let Linux take the interrupt through the normal
> > - * vector.
> > - */
> > - break;
> > - case OPTEE_SMC_RPC_FUNC_CMD:
> > - shm = reg_pair_to_ptr(param->a1, param->a2);
> > - handle_rpc_func_cmd(ctx, optee, shm, call_ctx);
> > - break;
> > - default:
> > - pr_warn("Unknown RPC func 0x%x\n",
> > - (u32)OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0));
> > - break;
> > - }
> > -
> > - param->a0 = OPTEE_SMC_CALL_RETURN_FROM_RPC;
> > -}
>
> Isn't it possible to keep this RPC handling as part of common code
> only rather than ABI specific as otherwise for every new RPC command
> handling support we need to maintain a sync for both SMC and FF-A ABI?
> Given we should be able to create new ABI specific callbacks for this
> as well eg. for managing shared memory etc.

Good point, the two functions handle_rpc_func_cmd() and
handle_ffa_rpc_func_cmd() are almost identical. If those could be
replaced with a comon function this problem would be taken care of.

What happens in optee_handle_rpc() before the call to
handle_rpc_func_cmd() is another thing though. That processing is purely
SMC ABI specific with no common code at all.

I'll fix this for the v4 patch set.

Thanks,
Jens

2021-07-29 07:14:22

by Sumit Garg

[permalink] [raw]
Subject: Re: [PATCH v3 2/5] optee: simplify optee_release()

On Thu, 29 Jul 2021 at 12:14, Jens Wiklander <[email protected]> wrote:
>
> On Wed, Jul 28, 2021 at 02:15:47PM +0530, Sumit Garg wrote:
> > On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
> > >
> > > Simplifies optee_release() with a new helper function,
> > > optee_close_session_helper() which has been factored out from
> > > optee_close_session().
> > >
> >
> > Simplification looks good to me.
> >
> > > A separate optee_release_supp() is added for the supplicant device.
> > >
> >
> > On similar terms, can we have separate optee_open_supp() for better
> > understanding?
>
> I'm not so keen on that. It wouldn't be much of a simplification since
> we'd end up adding quite a few functions. optee_smc_open_supp(),
> optee_ffa_open_supp(), optee_open_common(), and finally
> optee_open_supp().
>

Fair enough, FWIW:

Reviewed-by: Sumit Garg <[email protected]>

-Sumit

> Thanks,
> Jens

2021-07-29 07:16:23

by Sumit Garg

[permalink] [raw]
Subject: Re: [PATCH v3 3/5] optee: refactor driver with internal callbacks

On Thu, 29 Jul 2021 at 12:26, Jens Wiklander <[email protected]> wrote:
>
> On Wed, Jul 28, 2021 at 03:29:33PM +0530, Sumit Garg wrote:
> > On Thu, 22 Jul 2021 at 17:48, Jens Wiklander <[email protected]> wrote:
> > >
> > > The OP-TEE driver is refactored with three internal callbacks replacing
> > > direct calls to optee_from_msg_param(), optee_to_msg_param() and
> > > optee_do_call_with_arg().
> > >
> > > These functions a central to communicating with OP-TEE in secure world
> > > by using the SMC Calling Convention directly.
> > >
> > > This refactoring makes room for using other primitives to communicate
> > > with OP-TEE in secure world while being able to reuse as much as
> > > possible from the present driver.
> > >
> > > Signed-off-by: Jens Wiklander <[email protected]>
> > > ---
> > > drivers/tee/optee/call.c | 86 +++++++++--------
> > > drivers/tee/optee/core.c | 148 ++++++++++++++++++++----------
> > > drivers/tee/optee/optee_private.h | 35 +++++--
> > > drivers/tee/optee/rpc.c | 19 ++--
> > > 4 files changed, 182 insertions(+), 106 deletions(-)
> > >
> > > diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c
> > > index 9d8f5a95e42f..00ecd794e59a 100644
> > > --- a/drivers/tee/optee/call.c
> > > +++ b/drivers/tee/optee/call.c
> > > @@ -1,6 +1,6 @@
> > > // SPDX-License-Identifier: GPL-2.0-only
> > > /*
> > > - * Copyright (c) 2015, Linaro Limited
> > > + * Copyright (c) 2015-2021, Linaro Limited
> > > */
> > > #include <linux/arm-smccc.h>
> > > #include <linux/device.h>
> > > @@ -118,20 +118,25 @@ static struct optee_session *find_session(struct optee_context_data *ctxdata,
> > > /**
> > > * optee_do_call_with_arg() - Do an SMC to OP-TEE in secure world
> > > * @ctx: calling context
> > > - * @parg: physical address of message to pass to secure world
> > > + * @arg: shared memory holding the message to pass to secure world
> > > *
> > > * Does and SMC to OP-TEE in secure world and handles eventual resulting
> > > * Remote Procedure Calls (RPC) from OP-TEE.
> > > *
> > > * Returns return code from secure world, 0 is OK
> > > */
> > > -u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
> > > +int optee_do_call_with_arg(struct tee_context *ctx, struct tee_shm *arg)
> > > {
> > > struct optee *optee = tee_get_drvdata(ctx->teedev);
> > > struct optee_call_waiter w;
> > > struct optee_rpc_param param = { };
> > > struct optee_call_ctx call_ctx = { };
> > > - u32 ret;
> > > + phys_addr_t parg;
> > > + int rc;
> > > +
> > > + rc = tee_shm_get_pa(arg, 0, &parg);
> > > + if (rc)
> > > + return rc;
> > >
> > > param.a0 = OPTEE_SMC_CALL_WITH_ARG;
> > > reg_pair_from_64(&param.a1, &param.a2, parg);
> > > @@ -160,7 +165,7 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
> > > param.a3 = res.a3;
> > > optee_handle_rpc(ctx, &param, &call_ctx);
> > > } else {
> > > - ret = res.a0;
> > > + rc = res.a0;
> > > break;
> > > }
> > > }
> > > @@ -172,14 +177,12 @@ u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
> > > */
> > > optee_cq_wait_final(&optee->call_queue, &w);
> > >
> > > - return ret;
> > > + return rc;
> > > }
> > >
> > > static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,
> > > - struct optee_msg_arg **msg_arg,
> > > - phys_addr_t *msg_parg)
> > > + struct optee_msg_arg **msg_arg)
> > > {
> > > - int rc;
> > > struct tee_shm *shm;
> > > struct optee_msg_arg *ma;
> > >
> > > @@ -190,22 +193,13 @@ static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,
> > >
> > > ma = tee_shm_get_va(shm, 0);
> > > if (IS_ERR(ma)) {
> > > - rc = PTR_ERR(ma);
> > > - goto out;
> > > + tee_shm_free(shm);
> > > + return (void *)ma;
> > > }
> > >
> > > - rc = tee_shm_get_pa(shm, 0, msg_parg);
> > > - if (rc)
> > > - goto out;
> > > -
> > > memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params));
> > > ma->num_params = num_params;
> > > *msg_arg = ma;
> > > -out:
> > > - if (rc) {
> > > - tee_shm_free(shm);
> > > - return ERR_PTR(rc);
> > > - }
> > >
> > > return shm;
> > > }
> > > @@ -214,16 +208,16 @@ int optee_open_session(struct tee_context *ctx,
> > > struct tee_ioctl_open_session_arg *arg,
> > > struct tee_param *param)
> > > {
> > > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > > struct optee_context_data *ctxdata = ctx->data;
> > > int rc;
> > > struct tee_shm *shm;
> > > struct optee_msg_arg *msg_arg;
> > > - phys_addr_t msg_parg;
> > > struct optee_session *sess = NULL;
> > > uuid_t client_uuid;
> > >
> > > /* +2 for the meta parameters added below */
> > > - shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg, &msg_parg);
> > > + shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg);
> > > if (IS_ERR(shm))
> > > return PTR_ERR(shm);
> > >
> > > @@ -247,7 +241,8 @@ int optee_open_session(struct tee_context *ctx,
> > > goto out;
> > > export_uuid(msg_arg->params[1].u.octets, &client_uuid);
> > >
> > > - rc = optee_to_msg_param(msg_arg->params + 2, arg->num_params, param);
> > > + rc = optee->ops->to_msg_param(optee, msg_arg->params + 2,
> > > + arg->num_params, param);
> > > if (rc)
> > > goto out;
> > >
> > > @@ -257,7 +252,7 @@ int optee_open_session(struct tee_context *ctx,
> > > goto out;
> > > }
> > >
> > > - if (optee_do_call_with_arg(ctx, msg_parg)) {
> > > + if (optee->ops->do_call_with_arg(ctx, shm)) {
> > > msg_arg->ret = TEEC_ERROR_COMMUNICATION;
> > > msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
> > > }
> > > @@ -272,7 +267,8 @@ int optee_open_session(struct tee_context *ctx,
> > > kfree(sess);
> > > }
> > >
> > > - if (optee_from_msg_param(param, arg->num_params, msg_arg->params + 2)) {
> > > + if (optee->ops->from_msg_param(optee, param, arg->num_params,
> > > + msg_arg->params + 2)) {
> > > arg->ret = TEEC_ERROR_COMMUNICATION;
> > > arg->ret_origin = TEEC_ORIGIN_COMMS;
> > > /* Close session again to avoid leakage */
> > > @@ -291,16 +287,16 @@ int optee_open_session(struct tee_context *ctx,
> > > int optee_close_session_helper(struct tee_context *ctx, u32 session)
> > > {
> > > struct tee_shm *shm;
> > > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > > struct optee_msg_arg *msg_arg;
> > > - phys_addr_t msg_parg;
> > >
> > > - shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
> > > + shm = get_msg_arg(ctx, 0, &msg_arg);
> > > if (IS_ERR(shm))
> > > return PTR_ERR(shm);
> > >
> > > msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
> > > msg_arg->session = session;
> > > - optee_do_call_with_arg(ctx, msg_parg);
> > > + optee->ops->do_call_with_arg(ctx, shm);
> > >
> > > tee_shm_free(shm);
> > >
> > > @@ -328,10 +324,10 @@ int optee_close_session(struct tee_context *ctx, u32 session)
> > > int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> > > struct tee_param *param)
> > > {
> > > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > > struct optee_context_data *ctxdata = ctx->data;
> > > struct tee_shm *shm;
> > > struct optee_msg_arg *msg_arg;
> > > - phys_addr_t msg_parg;
> > > struct optee_session *sess;
> > > int rc;
> > >
> > > @@ -342,7 +338,7 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> > > if (!sess)
> > > return -EINVAL;
> > >
> > > - shm = get_msg_arg(ctx, arg->num_params, &msg_arg, &msg_parg);
> > > + shm = get_msg_arg(ctx, arg->num_params, &msg_arg);
> > > if (IS_ERR(shm))
> > > return PTR_ERR(shm);
> > > msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND;
> > > @@ -350,16 +346,18 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> > > msg_arg->session = arg->session;
> > > msg_arg->cancel_id = arg->cancel_id;
> > >
> > > - rc = optee_to_msg_param(msg_arg->params, arg->num_params, param);
> > > + rc = optee->ops->to_msg_param(optee, msg_arg->params, arg->num_params,
> > > + param);
> > > if (rc)
> > > goto out;
> > >
> > > - if (optee_do_call_with_arg(ctx, msg_parg)) {
> > > + if (optee->ops->do_call_with_arg(ctx, shm)) {
> > > msg_arg->ret = TEEC_ERROR_COMMUNICATION;
> > > msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
> > > }
> > >
> > > - if (optee_from_msg_param(param, arg->num_params, msg_arg->params)) {
> > > + if (optee->ops->from_msg_param(optee, param, arg->num_params,
> > > + msg_arg->params)) {
> > > msg_arg->ret = TEEC_ERROR_COMMUNICATION;
> > > msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
> > > }
> > > @@ -373,10 +371,10 @@ int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
> > >
> > > int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
> > > {
> > > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > > struct optee_context_data *ctxdata = ctx->data;
> > > struct tee_shm *shm;
> > > struct optee_msg_arg *msg_arg;
> > > - phys_addr_t msg_parg;
> > > struct optee_session *sess;
> > >
> > > /* Check that the session is valid */
> > > @@ -386,14 +384,14 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
> > > if (!sess)
> > > return -EINVAL;
> > >
> > > - shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
> > > + shm = get_msg_arg(ctx, 0, &msg_arg);
> > > if (IS_ERR(shm))
> > > return PTR_ERR(shm);
> > >
> > > msg_arg->cmd = OPTEE_MSG_CMD_CANCEL;
> > > msg_arg->session = session;
> > > msg_arg->cancel_id = cancel_id;
> > > - optee_do_call_with_arg(ctx, msg_parg);
> > > + optee->ops->do_call_with_arg(ctx, shm);
> > >
> > > tee_shm_free(shm);
> > > return 0;
> > > @@ -592,10 +590,10 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> > > struct page **pages, size_t num_pages,
> > > unsigned long start)
> > > {
> > > - struct tee_shm *shm_arg = NULL;
> > > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > > struct optee_msg_arg *msg_arg;
> > > + struct tee_shm *shm_arg;
> > > u64 *pages_list;
> > > - phys_addr_t msg_parg;
> > > int rc;
> > >
> > > if (!num_pages)
> > > @@ -609,7 +607,7 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> > > if (!pages_list)
> > > return -ENOMEM;
> > >
> > > - shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
> > > + shm_arg = get_msg_arg(ctx, 1, &msg_arg);
> > > if (IS_ERR(shm_arg)) {
> > > rc = PTR_ERR(shm_arg);
> > > goto out;
> > > @@ -630,7 +628,7 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> > > msg_arg->params->u.tmem.buf_ptr = virt_to_phys(pages_list) |
> > > (tee_shm_get_page_offset(shm) & (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
> > >
> > > - if (optee_do_call_with_arg(ctx, msg_parg) ||
> > > + if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> > > msg_arg->ret != TEEC_SUCCESS)
> > > rc = -EINVAL;
> > >
> > > @@ -642,12 +640,12 @@ int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
> > >
> > > int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
> > > {
> > > - struct tee_shm *shm_arg;
> > > + struct optee *optee = tee_get_drvdata(ctx->teedev);
> > > struct optee_msg_arg *msg_arg;
> > > - phys_addr_t msg_parg;
> > > + struct tee_shm *shm_arg;
> > > int rc = 0;
> > >
> > > - shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
> > > + shm_arg = get_msg_arg(ctx, 1, &msg_arg);
> > > if (IS_ERR(shm_arg))
> > > return PTR_ERR(shm_arg);
> > >
> > > @@ -656,7 +654,7 @@ int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
> > > msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> > > msg_arg->params[0].u.rmem.shm_ref = (unsigned long)shm;
> > >
> > > - if (optee_do_call_with_arg(ctx, msg_parg) ||
> > > + if (optee->ops->do_call_with_arg(ctx, shm_arg) ||
> > > msg_arg->ret != TEEC_SUCCESS)
> > > rc = -EINVAL;
> > > tee_shm_free(shm_arg);
> > > diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c
> > > index 949223b214c3..f689f171a794 100644
> > > --- a/drivers/tee/optee/core.c
> > > +++ b/drivers/tee/optee/core.c
> > > @@ -1,6 +1,6 @@
> > > // SPDX-License-Identifier: GPL-2.0-only
> > > /*
> > > - * Copyright (c) 2015, Linaro Limited
> > > + * Copyright (c) 2015-2021, Linaro Limited
> > > */
> > >
> > > #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
> > > @@ -26,21 +26,87 @@
> > >
> > > #define OPTEE_SHM_NUM_PRIV_PAGES CONFIG_OPTEE_SHM_NUM_PRIV_PAGES
> > >
> > > +static void from_msg_param_value(struct tee_param *p, u32 attr,
> > > + const struct optee_msg_param *mp)
> > > +{
> > > + p->attr = TEE_IOCTL_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;
> > > +}
> > > +
> > > +static int from_msg_param_tmp_mem(struct tee_param *p, u32 attr,
> > > + const struct optee_msg_param *mp)
> > > +{
> > > + struct tee_shm *shm;
> > > + phys_addr_t pa;
> > > + int rc;
> > > +
> > > + p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> > > + attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
> > > + p->u.memref.size = mp->u.tmem.size;
> > > + shm = (struct tee_shm *)(unsigned long)mp->u.tmem.shm_ref;
> > > + if (!shm) {
> > > + p->u.memref.shm_offs = 0;
> > > + p->u.memref.shm = NULL;
> > > + return 0;
> > > + }
> > > +
> > > + rc = tee_shm_get_pa(shm, 0, &pa);
> > > + if (rc)
> > > + return rc;
> > > +
> > > + p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
> > > + p->u.memref.shm = shm;
> > > +
> > > + /* Check that the memref is covered by the shm object */
> > > + if (p->u.memref.size) {
> > > + size_t o = p->u.memref.shm_offs +
> > > + p->u.memref.size - 1;
> > > +
> > > + rc = tee_shm_get_pa(shm, o, NULL);
> > > + if (rc)
> > > + return rc;
> > > + }
> > > +
> > > + return 0;
> > > +}
> > > +
> > > +static void from_msg_param_reg_mem(struct tee_param *p, u32 attr,
> > > + const struct optee_msg_param *mp)
> > > +{
> > > + struct tee_shm *shm;
> > > +
> > > + p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> > > + attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> > > + p->u.memref.size = mp->u.rmem.size;
> > > + shm = (struct tee_shm *)(unsigned long)mp->u.rmem.shm_ref;
> > > +
> > > + if (shm) {
> > > + p->u.memref.shm_offs = mp->u.rmem.offs;
> > > + p->u.memref.shm = shm;
> > > + } else {
> > > + p->u.memref.shm_offs = 0;
> > > + p->u.memref.shm = NULL;
> > > + }
> > > +}
> > > +
> > > /**
> > > * optee_from_msg_param() - convert from OPTEE_MSG parameters to
> > > * struct tee_param
> > > + * @optee: main service struct
> >
> > I don't see this new argument being used. Can you throw some light on
> > the use-case for this additional argument?
>
> This function is registered as a callback and the counter part in the
> FF-A ABI (optee_ffa_from_msg_param()) will need this parameter. So it's
> needed to have the same signature.
>

Okay, I see its usage.

> >
> > > * @params: subsystem internal parameter representation
> > > * @num_params: number of elements in the parameter arrays
> > > * @msg_params: OPTEE_MSG parameters
> > > * Returns 0 on success or <0 on failure
> > > */
> > > -int optee_from_msg_param(struct tee_param *params, size_t num_params,
> > > - const struct optee_msg_param *msg_params)
> > > +static int optee_from_msg_param(struct optee *optee, struct tee_param *params,
> > > + size_t num_params,
> > > + const struct optee_msg_param *msg_params)
> > > {
> > > int rc;
> > > size_t n;
> > > - struct tee_shm *shm;
> > > - phys_addr_t pa;
> > >
> > > for (n = 0; n < num_params; n++) {
> > > struct tee_param *p = params + n;
> > > @@ -55,48 +121,19 @@ int optee_from_msg_param(struct tee_param *params, size_t num_params,
> > > case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT:
> > > case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:
> > > case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:
> > > - p->attr = TEE_IOCTL_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;
> > > + from_msg_param_value(p, attr, mp);
> > > break;
> > > case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT:
> > > case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT:
> > > case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT:
> > > - p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> > > - attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT;
> > > - p->u.memref.size = mp->u.tmem.size;
> > > - shm = (struct tee_shm *)(unsigned long)
> > > - mp->u.tmem.shm_ref;
> > > - if (!shm) {
> > > - p->u.memref.shm_offs = 0;
> > > - p->u.memref.shm = NULL;
> > > - break;
> > > - }
> > > - rc = tee_shm_get_pa(shm, 0, &pa);
> > > + rc = from_msg_param_tmp_mem(p, attr, mp);
> > > if (rc)
> > > return rc;
> > > - p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa;
> > > - p->u.memref.shm = shm;
> > > 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_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT +
> > > - attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
> > > - p->u.memref.size = mp->u.rmem.size;
> > > - shm = (struct tee_shm *)(unsigned long)
> > > - 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;
> > > -
> > > + from_msg_param_reg_mem(p, attr, mp);
> > > break;
> > >
> > > default:
> > > @@ -106,6 +143,16 @@ int optee_from_msg_param(struct tee_param *params, size_t num_params,
> > > return 0;
> > > }
> > >
> > > +static void to_msg_param_value(struct optee_msg_param *mp,
> > > + const struct tee_param *p)
> > > +{
> > > + mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
> > > + TEE_IOCTL_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;
> > > +}
> > > +
> > > static int to_msg_param_tmp_mem(struct optee_msg_param *mp,
> > > const struct tee_param *p)
> > > {
> > > @@ -148,13 +195,15 @@ static int to_msg_param_reg_mem(struct optee_msg_param *mp,
> > >
> > > /**
> > > * optee_to_msg_param() - convert from struct tee_params to OPTEE_MSG parameters
> > > + * @optee: main service struct
> >
> > Same here.
>
> This function is also registered as a callback. Here it's questionable
> though, but I added it to let optee->ops->to_msg_param() and
> optee->ops->from_msg_param() have better symmetry.
>

I am fine with that. FWIW:

Reviewed-by: Sumit Garg <[email protected]>

-Sumit

> Thanks,
> Jens