Re: [Tee-dev] [PATCH v6 preview 4/6] tee: generic TEE subsystem

On 10/23/2015 08:32 AM, Jens Wiklander wrote:

Initial patch for generic TEE subsystem. This subsystem provides:

• Registration/un-registration of TEE drivers.
• Shared memory between normal world and secure world.
• Ioctl interface for interaction with user space.

A TEE (Trusted Execution Environment) driver is a driver that interfaces with a trusted OS running in some secure environment, for example, TrustZone on ARM cpus, or a separate secure co-processor etc.

The TEE subsystem can serve a TEE driver for a Global Platform compliant TEE, but it's not limited to only Global Platform TEEs.

This patch builds on other similar implementations trying to solve the same problem:

• "optee_linuxdriver" by among others Jean-michel DELORMEjean-michel.delorme@st.com and Emmanuel MICHEL emmanuel.michel@st.com
• "Generic TrustZone Driver" by Javier González javier@javigon.com

Signed-off-by: Jens Wiklander jens.wiklander@linaro.org

Documentation/ioctl/ioctl-number.txt | 1 + MAINTAINERS | 7 + drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/tee/Kconfig | 8 + drivers/tee/Makefile | 3 + drivers/tee/tee.c | 869 +++++++++++++++++++++++++++++++++++ drivers/tee/tee_private.h | 80 ++++ drivers/tee/tee_shm.c | 324 +++++++++++++ drivers/tee/tee_shm_pool.c | 133 ++++++ include/linux/tee_drv.h | 300 ++++++++++++ include/uapi/linux/tee.h | 383 +++++++++++++++ 12 files changed, 2111 insertions(+) create mode 100644 drivers/tee/Kconfig create mode 100644 drivers/tee/Makefile create mode 100644 drivers/tee/tee.c create mode 100644 drivers/tee/tee_private.h create mode 100644 drivers/tee/tee_shm.c create mode 100644 drivers/tee/tee_shm_pool.c create mode 100644 include/linux/tee_drv.h create mode 100644 include/uapi/linux/tee.h

diff --git a/Documentation/ioctl/ioctl-number.txt b/Documentation/ioctl/ioctl-number.txt index df1b25e..8e4b7ac 100644 --- a/Documentation/ioctl/ioctl-number.txt +++ b/Documentation/ioctl/ioctl-number.txt @@ -303,6 +303,7 @@ Code Seq#(hex) Include File Comments 0xA3 80-8F Port ACL in development: mailto:tlewis@mindspring.com 0xA3 90-9F linux/dtlk.h +0xA4 00-1F uapi/linux/tee.h Generic TEE subsystem 0xAA 00-3F linux/uapi/linux/userfaultfd.h 0xAB 00-1F linux/nbd.h 0xAC 00-1F linux/raw.h diff --git a/MAINTAINERS b/MAINTAINERS index b8577ad9..d4020c5 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -9133,6 +9133,13 @@ S: Maintained F: include/linux/mmc/dw_mmc.h F: drivers/mmc/host/dw_mmc* +TEE SUBSYSTEM +M: Jens Wiklander jens.wiklander@linaro.org +S: Maintained +F: include/linux/tee_drv.h +F: include/uapi/linux/tee.h +F: drivers/tee/

THUNDERBOLT DRIVER M: Andreas Noever andreas.noever@gmail.com S: Maintained diff --git a/drivers/Kconfig b/drivers/Kconfig index 46b4a8e..fdd2e96 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -188,4 +188,6 @@ source "drivers/nvdimm/Kconfig" source "drivers/nvmem/Kconfig" +source "drivers/tee/Kconfig"

endmenu diff --git a/drivers/Makefile b/drivers/Makefile index b250b36..91c0411 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -167,3 +167,4 @@ obj-$(CONFIG_THUNDERBOLT) += thunderbolt/ obj-$(CONFIG_CORESIGHT) += hwtracing/coresight/ obj-$(CONFIG_ANDROID) += android/ obj-$(CONFIG_NVMEM) += nvmem/ +obj-$(CONFIG_TEE) += tee/ diff --git a/drivers/tee/Kconfig b/drivers/tee/Kconfig new file mode 100644 index 0000000..64a8cd7 --- /dev/null +++ b/drivers/tee/Kconfig @@ -0,0 +1,8 @@ +# Generic Trusted Execution Environment Configuration +config TEE

• bool "Trusted Execution Environment support"
• default n
• select DMA_SHARED_BUFFER
• help

•  This implements a generic interface towards a Trusted Execution
  

•  Environment (TEE).
  

diff --git a/drivers/tee/Makefile b/drivers/tee/Makefile new file mode 100644 index 0000000..60d2dab --- /dev/null +++ b/drivers/tee/Makefile @@ -0,0 +1,3 @@ +obj-y += tee.o +obj-y += tee_shm.o +obj-y += tee_shm_pool.o diff --git a/drivers/tee/tee.c b/drivers/tee/tee.c new file mode 100644 index 0000000..6397926 --- /dev/null +++ b/drivers/tee/tee.c @@ -0,0 +1,869 @@ +/*

• • Copyright (c) 2015, Linaro Limited
• • This software is licensed under the terms of the GNU General Public
• • License version 2, as published by the Free Software Foundation, and
• • may be copied, distributed, and modified under those terms.
• • This program is distributed in the hope that it will be useful,
• • but WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• • GNU General Public License for more details.
• */

+#include <linux/device.h> +#include <linux/cdev.h> +#include <linux/fs.h> +#include <linux/slab.h> +#include <linux/uaccess.h> +#include <linux/tee_drv.h> +#include "tee_private.h"

+#define TEE_NUM_DEVICES 32

+#define TEE_IOCTL_PARAM_SIZE(x) (sizeof(struct tee_param) * (x))

+/*

• • Unprivileged devices in the in the lower half range and privileged
• • devices in the upper half range.
• */

+static DECLARE_BITMAP(dev_mask, TEE_NUM_DEVICES); +static DEFINE_SPINLOCK(driver_lock);

+static struct class *tee_class; +static dev_t tee_devt;

+static int tee_open(struct inode *inode, struct file *filp) +{

• int rc;
• struct tee_device *teedev;
• struct tee_context *ctx;
• teedev = container_of(inode->i_cdev, struct tee_device, cdev);
• if (!tee_device_get(teedev))

• return -EINVAL;
  

• ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
• if (!ctx)

• return -ENOMEM;
  

• ctx->teedev = teedev;
• filp->private_data = ctx;
• rc = teedev->desc->ops->open(ctx);
• if (rc) {

• kfree(ctx);
  

• tee_device_put(teedev);
  

• }
• return rc;

+}

+static int tee_release(struct inode *inode, struct file *filp) +{

• struct tee_context *ctx = filp->private_data;
• struct tee_device *teedev = ctx->teedev;
• ctx->teedev->desc->ops->release(ctx);
• kfree(ctx);
• tee_device_put(teedev);
• return 0;

+}

+static int tee_ioctl_version(struct tee_context *ctx,

• struct tee_ioctl_version_data __user *uvers)
  

+{

• struct tee_ioctl_version_data vers;
• ctx->teedev->desc->ops->get_version(ctx->teedev, &vers);
• if (copy_to_user(uvers, &vers, sizeof(vers)))

• return -EFAULT;
  

• return 0;

+}

+static int tee_ioctl_shm_alloc(struct tee_context *ctx,

• struct tee_ioctl_shm_alloc_data __user *udata)
  

+{

• long ret;
• struct tee_ioctl_shm_alloc_data data;
• struct tee_shm *shm;
• if (copy_from_user(&data, udata, sizeof(data)))

• return -EFAULT;
  

• /* Currently no input flags are supported */
• if (data.flags)

• return -EINVAL;
  

• data.fd = -1;
• shm = tee_shm_alloc(ctx->teedev, data.size,

• 	    TEE_SHM_MAPPED | TEE_SHM_DMA_BUF);
  

• if (IS_ERR(shm))

• return PTR_ERR(shm);
  

• data.flags = shm->flags;
• data.size = shm->size;
• data.fd = tee_shm_get_fd(shm);
• if (data.fd < 0) {

• ret = data.fd;
  

• goto err;
  

• }
• if (copy_to_user(udata, &data, sizeof(data))) {

• ret = -EFAULT;
  

• goto err;
  

• }
• /*

• * When user space closes the file descriptor the shared memory
  

• * should be freed
  

• */
  

• tee_shm_put(shm);
• return 0;

+err:

• if (data.fd >= 0)

• tee_shm_put_fd(data.fd);
  

• tee_shm_free(shm);
• return ret;

+}

+static int params_from_user(struct tee_param *params, size_t num_params,

• struct tee_ioctl_param __user *uparams)
  

+{

• size_t n;
• for (n = 0; n < num_params; n++) {

• struct tee_shm *shm;
  

• struct tee_ioctl_param ip;
  

• if (copy_from_user(&ip, uparams + n, sizeof(ip)))
  

• 	return -EFAULT;
  

• /* All unused attribute bits has to be zero */
  

• if (ip.attr & ~TEE_IOCTL_PARAM_ATTR_TYPE_MASK)
  

• 	return -EINVAL;
  

• params[n].attr = ip.attr;
  

• switch (ip.attr) {
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_NONE:
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
  

• 	break;
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT:
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
  

• 	params[n].u.value.a = ip.u.value.a;
  

• 	params[n].u.value.b = ip.u.value.b;
  

• 	params[n].u.value.c = ip.u.value.c;
  

• 	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 we fail to get a pointer to a shared memory
  

• 	 * object (and increase the ref count) from a file
  

• 	 * descriptor we return an error. All pointers that
  

• 	 * has been added in params have an increased ref
  

• 	 * count. It's the callers responibility to do
  

• 	 * tee_shm_put() on all resolved pointers.
  

• 	 */
  

• 	shm = tee_shm_get_from_fd(ip.u.memref.shm_fd);
  

• 	if (IS_ERR(shm))
  

• 		return PTR_ERR(shm);
  

• 	params[n].u.memref.shm_offs = ip.u.memref.shm_offs;
  

• 	params[n].u.memref.size = ip.u.memref.size;
  

• 	params[n].u.memref.shm = shm;
  

• 	break;
  

• default:
  

• 	/* Unknown attribute */
  

• 	return -EINVAL;
  

• }
  

• }
• return 0;

+}

+static int params_to_user(struct tee_ioctl_param __user *uparams,

• size_t num_params, struct tee_param *params)
  

+{

• size_t n;
• for (n = 0; n < num_params; n++) {

• struct tee_ioctl_param __user *up = uparams + n;
  

• struct tee_param *p = params + n;
  

• switch (p->attr) {
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
  

• 	if (put_user(p->u.value.a, &up->u.value.a) ||
  

• 	    put_user(p->u.value.b, &up->u.value.b) ||
  

• 	    put_user(p->u.value.c, &up->u.value.c))
  

• 		return -EFAULT;
  

• 	break;
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:
  

• 	if (put_user((u64)p->u.memref.size, &up->u.memref.size))
  

• 		return -EFAULT;
  

• default:
  

• 	break;
  

• }
  

• }
• return 0;

+}

+static bool param_is_memref(struct tee_param *param) +{

• switch (param->attr & TEE_IOCTL_PARAM_ATTR_TYPE_MASK) {
• case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT:
• case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
• case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:

• return true;
  

• default:

• return false;
  

• }

+}

+static int tee_ioctl_open_session(struct tee_context *ctx,

• struct tee_ioctl_buf_data __user *ubuf)
  

+{

• int rc;
• size_t n;
• struct tee_ioctl_buf_data buf;
• struct tee_ioctl_open_session_arg __user *uarg;
• struct tee_ioctl_open_session_arg arg;
• struct tee_ioctl_param __user *uparams = NULL;
• struct tee_param *params = NULL;
• bool have_session = false;
• if (!ctx->teedev->desc->ops->open_session)

• return -EINVAL;
  

• if (copy_from_user(&buf, ubuf, sizeof(buf)))

• return -EFAULT;
  

• if (buf.buf_len > TEE_MAX_ARG_SIZE ||

•    buf.buf_len < sizeof(struct tee_ioctl_open_session_arg))
  

• return -EINVAL;
  

• uarg = (struct tee_ioctl_open_session_arg __user *)(unsigned long)

• buf.buf_ptr;
  

• rc = copy_from_user(&arg, uarg, sizeof(arg));
• if (rc)

• return rc;
  

• if (sizeof(arg) + TEE_IOCTL_PARAM_SIZE(arg.num_params) != buf.buf_len)

• return -EINVAL;
  

• if (arg.num_params) {

• params = kcalloc(arg.num_params, sizeof(struct tee_param),
  

• 		GFP_KERNEL);
  

• if (!params)
  

• 	return -ENOMEM;
  

• uparams = (struct tee_ioctl_param __user *)(uarg + 1);
  

• rc = params_from_user(params, arg.num_params, uparams);
  

• if (rc)
  

• 	goto out;
  

• }
• rc = ctx->teedev->desc->ops->open_session(ctx, &arg, params);
• if (rc)

• goto out;
  

• have_session = true;
• if (put_user(arg.session, &uarg->session) ||

•    put_user(arg.ret, &uarg->ret) ||
  

•    put_user(arg.ret_origin, &uarg->ret_origin)) {
  

• rc = -EFAULT;
  

• goto out;
  

• }
• rc = params_to_user(uparams, arg.num_params, params);

+out:

• /*

• * If we've succeeded to open the session but failed to communicate
  

• * it back to user space, close the session again to avoid leakage.
  

• */
  

• if (rc && have_session && ctx->teedev->desc->ops->close_session)

• ctx->teedev->desc->ops->close_session(ctx, arg.session);
  

• if (params) {

• /* Decrease ref count for all valid shared memory pointers */
  

• for (n = 0; n < arg.num_params; n++)
  

• 	if (param_is_memref(params + n) &&
  

• 	    params[n].u.memref.shm)
  

• 		tee_shm_put(params[n].u.memref.shm);
  

• kfree(params);
  

• }
• return rc;

+}

+static int tee_ioctl_invoke(struct tee_context *ctx,

• struct tee_ioctl_buf_data __user *ubuf)
  

+{

• int rc;
• size_t n;
• struct tee_ioctl_buf_data buf;
• struct tee_ioctl_invoke_arg __user *uarg;
• struct tee_ioctl_invoke_arg arg;
• struct tee_ioctl_param __user *uparams = NULL;
• struct tee_param *params = NULL;
• if (!ctx->teedev->desc->ops->invoke_func)

• return -EINVAL;
  

• rc = copy_from_user(&buf, ubuf, sizeof(buf));
• if (rc)

• return rc;
  

• if (buf.buf_len > TEE_MAX_ARG_SIZE ||

•    buf.buf_len < sizeof(struct tee_ioctl_invoke_arg))
  

• return -EINVAL;
  

• uarg = (struct tee_ioctl_invoke_arg __user *)(unsigned long)buf.buf_ptr;
• if (copy_from_user(&arg, uarg, sizeof(arg)))

• return -EFAULT;
  

• if (sizeof(arg) + TEE_IOCTL_PARAM_SIZE(arg.num_params) != buf.buf_len)

• return -EINVAL;
  

• if (arg.num_params) {

• params = kcalloc(arg.num_params, sizeof(struct tee_param),
  

• 		GFP_KERNEL);
  

• if (!params)
  

• 	return -ENOMEM;
  

• uparams = (struct tee_ioctl_param __user *)(uarg + 1);
  

• rc = params_from_user(params, arg.num_params, uparams);
  

• if (rc)
  

• 	goto out;
  

• }
• rc = ctx->teedev->desc->ops->invoke_func(ctx, &arg, params);
• if (rc)

• goto out;
  

• if (put_user(arg.ret, &uarg->ret) ||

•    put_user(arg.ret_origin, &uarg->ret_origin)) {
  

• rc = -EFAULT;
  

• goto out;
  

• }
• rc = params_to_user(uparams, arg.num_params, params);

+out:

• if (params) {

• /* Decrease ref count for all valid shared memory pointers */
  

• for (n = 0; n < arg.num_params; n++)
  

• 	if (param_is_memref(params + n) &&
  

• 	    params[n].u.memref.shm)
  

• 		tee_shm_put(params[n].u.memref.shm);
  

• kfree(params);
  

• }
• return rc;

+}

+static int tee_ioctl_cancel(struct tee_context *ctx,

• struct tee_ioctl_cancel_arg __user *uarg)
  

+{

• struct tee_ioctl_cancel_arg arg;
• if (!ctx->teedev->desc->ops->cancel_req)

• return -EINVAL;
  

• if (copy_from_user(&arg, uarg, sizeof(arg)))

• return -EFAULT;
  

• return ctx->teedev->desc->ops->cancel_req(ctx, arg.cancel_id,

• 				  arg.session);
  

+}

+static int tee_ioctl_close_session(struct tee_context *ctx,

• struct tee_ioctl_close_session_arg __user *uarg)
  

+{

• struct tee_ioctl_close_session_arg arg;
• if (!ctx->teedev->desc->ops->close_session)

• return -EINVAL;
  

• if (copy_from_user(&arg, uarg, sizeof(arg)))

• return -EFAULT;
  

• return ctx->teedev->desc->ops->close_session(ctx, arg.session);

+}

+static int params_to_supp(struct tee_ioctl_param __user *uparams,

• size_t num_params, struct tee_param *params)
  

+{

• int rc = 0;
• size_t n;
• int *fds = kmalloc_array(num_params, sizeof(int), GFP_KERNEL);
• if (!fds)

• return -ENOMEM;
  

• for (n = 0; n < num_params; n++)

• fds[n] = -1;
  

• for (n = 0; n < num_params; n++) {

• struct tee_ioctl_param ip;
  

• struct tee_param *p = params + n;
  

• ip.attr = p->attr & TEE_IOCTL_PARAM_ATTR_TYPE_MASK;
  

• switch (p->attr) {
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT:
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
  

• 	ip.u.value.a = p->u.value.a;
  

• 	ip.u.value.b = p->u.value.b;
  

• 	ip.u.value.c = p->u.value.c;
  

• 	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:
  

• 	ip.u.memref.size = p->u.memref.size;
  

• 	if (!p->u.memref.shm) {
  

• 		ip.u.memref.shm_offs = 0;
  

• 		ip.u.memref.shm_fd = -1;
  

• 		break;
  

• 	}
  

• 	ip.u.memref.shm_offs = p->u.memref.shm_offs;
  

• 	/*
  

• 	 * This tee_shm_get_fd() is supposed to be matched
  

• 	 * by a close(2) from tee-supplicant.
  

• 	 */
  

• 	fds[n] = tee_shm_get_fd(p->u.memref.shm);
  

• 	if (fds[n] < 0) {
  

• 		rc = fds[n];
  

• 		goto out;
  

• 	}
  

• 	ip.u.memref.shm_fd = fds[n];
  

• 	break;
  

• default:
  

• 	memset(&ip.u, 0, sizeof(ip.u));
  

• 	break;
  

• }
  

• if (copy_to_user(uparams + n, &ip, sizeof(ip))) {
  

• 	rc = -EFAULT;
  

• 	goto out;
  

• }
  

• }

+out:

• if (rc) {

• for (n = 0; n < num_params; n++)
  

• 	if (fds[n] >= 0)
  

• 		tee_shm_put_fd(fds[n]);
  

• }
• kfree(fds);
• return rc;

+}

+static int tee_ioctl_supp_recv(struct tee_context *ctx,

• struct tee_ioctl_buf_data __user *ubuf)
  

+{

• int rc;
• struct tee_ioctl_buf_data buf;
• struct tee_iocl_supp_recv_arg __user *uarg;
• struct tee_param *params;
• struct tee_ioctl_param __user *uparams;
• u32 num_params;
• u32 func;
• if (!ctx->teedev->desc->ops->supp_recv)

• return -EINVAL;
  

• if (copy_from_user(&buf, ubuf, sizeof(buf)))

• return -EFAULT;
  

• if (buf.buf_len > TEE_MAX_ARG_SIZE ||

•    buf.buf_len < sizeof(struct tee_iocl_supp_recv_arg))
  

• return -EINVAL;
  

• uarg = (struct tee_iocl_supp_recv_arg __user *)(unsigned long)

• buf.buf_ptr;
  

• if (get_user(num_params, &uarg->num_params))

• return -EFAULT;
  

• if (sizeof(*uarg) + TEE_IOCTL_PARAM_SIZE(num_params) != buf.buf_len)

• return -EINVAL;
  

• params = kcalloc(num_params, sizeof(struct tee_param), GFP_KERNEL);
• if (!params)

• return -ENOMEM;
  

• rc = ctx->teedev->desc->ops->supp_recv(ctx, &func, &num_params, params);
• if (rc)

• goto out;
  

• if (put_user(func, &uarg->func) ||

•    put_user(num_params, &uarg->num_params)) {
  

• rc = -EFAULT;
  

• goto out;
  

• }
• uparams = (struct tee_ioctl_param __user *)(uarg + 1);
• rc = params_to_supp(uparams, num_params, params);

+out:

• kfree(params);
• return rc;

+}

+static int params_from_supp(struct tee_param *params,

• size_t num_params, struct tee_ioctl_param __user *uparams)
  

+{

• size_t n;
• for (n = 0; n < num_params; n++) {

• struct tee_param *p = params + n;
  

• struct tee_ioctl_param ip;
  

• if (copy_from_user(&ip, uparams + n, sizeof(ip)))
  

• 	return -EFAULT;
  

• /* All unused attribute bits has to be zero */
  

• if (ip.attr & ~TEE_IOCTL_PARAM_ATTR_TYPE_MASK)
  

• 	return -EINVAL;
  

• p->attr = ip.attr;
  

• switch (ip.attr) {
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT:
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT:
  

• 	/* Only out and in/out values can be updated */
  

• 	p->u.value.a = ip.u.value.a;
  

• 	p->u.value.b = ip.u.value.b;
  

• 	p->u.value.c = ip.u.value.c;
  

• 	break;
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
  

• case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:
  

• 	/*
  

• 	 * Only the size of the memref can be updated.
  

• 	 * Since we don't have access to the original
  

• 	 * parameters here, only store the supplied size.
  

• 	 * The driver will copy the updated size into the
  

• 	 * original parameters.
  

• 	 */
  

• 	p->u.memref.shm = NULL;
  

• 	p->u.memref.shm_offs = 0;
  

• 	p->u.memref.size = ip.u.memref.size;
  

• 	break;
  

• default:
  

• 	memset(&p->u, 0, sizeof(p->u));
  

• 	break;
  

• }
  

• }
• return 0;

+}

+static int tee_ioctl_supp_send(struct tee_context *ctx,

• struct tee_ioctl_buf_data __user *ubuf)
  

+{

• long rc;
• struct tee_ioctl_buf_data buf;
• struct tee_iocl_supp_send_arg __user *uarg;
• struct tee_param *params;
• struct tee_ioctl_param __user *uparams;
• u32 num_params;
• u32 ret;
• /* Not valid for this driver */
• if (!ctx->teedev->desc->ops->supp_send)

• return -EINVAL;
  

• if (copy_from_user(&buf, ubuf, sizeof(buf)))

• return -EFAULT;
  

• if (buf.buf_len > TEE_MAX_ARG_SIZE ||

•    buf.buf_len < sizeof(struct tee_iocl_supp_send_arg))
  

• return -EINVAL;
  

• uarg = (struct tee_iocl_supp_send_arg __user *)(unsigned long)

• buf.buf_ptr;
  

• if (get_user(ret, &uarg->ret) ||

•    get_user(num_params, &uarg->num_params))
  

• return -EFAULT;
  

• if (sizeof(*uarg) + TEE_IOCTL_PARAM_SIZE(num_params) > buf.buf_len)

• return -EINVAL;
  

• params = kcalloc(num_params, sizeof(struct tee_param), GFP_KERNEL);
• if (!params)

• return -ENOMEM;
  

• uparams = (struct tee_ioctl_param __user *)(uarg + 1);
• rc = params_from_supp(params, num_params, uparams);
• if (rc)

• goto out;
  

• rc = ctx->teedev->desc->ops->supp_send(ctx, ret, num_params, params);

+out:

• kfree(params);
• return rc;

+}

+static long tee_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) +{

• struct tee_context *ctx = filp->private_data;
• void __user *uarg = (void __user *)arg;
• switch (cmd) {
• case TEE_IOC_VERSION:

• return tee_ioctl_version(ctx, uarg);
  

• case TEE_IOC_SHM_ALLOC:

• return tee_ioctl_shm_alloc(ctx, uarg);
  

• case TEE_IOC_OPEN_SESSION:

• return tee_ioctl_open_session(ctx, uarg);
  

• case TEE_IOC_INVOKE:

• return tee_ioctl_invoke(ctx, uarg);
  

• case TEE_IOC_CANCEL:

• return tee_ioctl_cancel(ctx, uarg);
  

• case TEE_IOC_CLOSE_SESSION:

• return tee_ioctl_close_session(ctx, uarg);
  

• case TEE_IOC_SUPPL_RECV:

• return tee_ioctl_supp_recv(ctx, uarg);
  

• case TEE_IOC_SUPPL_SEND:

• return tee_ioctl_supp_send(ctx, uarg);
  

• default:

• return -EINVAL;
  

• }

+}

+static const struct file_operations tee_fops = {

• .open = tee_open,
• .release = tee_release,
• .unlocked_ioctl = tee_ioctl,
• .compat_ioctl = tee_ioctl,

+};

+static void tee_release_device(struct device *dev) +{

• struct tee_device *teedev = container_of(dev, struct tee_device, dev);
• spin_lock(&driver_lock);
• clear_bit(teedev->id, dev_mask);
• spin_unlock(&driver_lock);
• mutex_destroy(&teedev->mutex);
• kfree(teedev);

+}

+struct tee_device *tee_device_alloc(const struct tee_desc *teedesc,

• 	struct device *dev, struct tee_shm_pool *pool,
  

• 	void *driver_data)
  

+{

• struct tee_device *teedev;
• void *ret;
• int rc;
• int offs = 0;
• if (!teedesc || !teedesc->name || !teedesc->ops ||

•    !teedesc->ops->get_version || !teedesc->ops->open ||
  

•    !teedesc->ops->release || !dev || !pool)
  

• return ERR_PTR(-EINVAL);
  

• teedev = kzalloc(sizeof(*teedev), GFP_KERNEL);
• if (!teedev) {

• ret = ERR_PTR(-ENOMEM);
  

• goto err;
  

• }
• if (teedesc->flags & TEE_DESC_PRIVILEGED)

• offs = TEE_NUM_DEVICES / 2;
  

• spin_lock(&driver_lock);
• teedev->id = find_next_zero_bit(dev_mask, TEE_NUM_DEVICES, offs);
• if (teedev->id < TEE_NUM_DEVICES)

• set_bit(teedev->id, dev_mask);
  

• spin_unlock(&driver_lock);
• if (teedev->id >= TEE_NUM_DEVICES) {

• ret = ERR_PTR(-ENOMEM);
  

• goto err;
  

• }
• snprintf(teedev->name, sizeof(teedev->name), "tee%s%d",

•  teedesc->flags & TEE_DESC_PRIVILEGED ? "priv" : "",
  

•  teedev->id - offs);
  

• teedev->dev.class = tee_class;
• teedev->dev.release = tee_release_device;
• teedev->dev.parent = dev;
• teedev->dev.devt = MKDEV(MAJOR(tee_devt), teedev->id);
• rc = dev_set_name(&teedev->dev, "%s", teedev->name);
• if (rc) {

• ret = ERR_PTR(rc);
  

• goto err;
  

• }
• cdev_init(&teedev->cdev, &tee_fops);
• teedev->cdev.owner = teedesc->owner;
• teedev->cdev.kobj.parent = &teedev->dev.kobj;
• dev_set_drvdata(&teedev->dev, driver_data);
• device_initialize(&teedev->dev);
• /* 1 as tee_device_unregister() does one final tee_device_put() */
• teedev->num_users = 1;
• init_completion(&teedev->c_no_users);
• mutex_init(&teedev->mutex);
• teedev->desc = teedesc;
• teedev->pool = pool;
• INIT_LIST_HEAD(&teedev->list_shm);
• return teedev;

+err:

• dev_err(dev, "could not register %s driver\n",

• teedesc->flags & TEE_DESC_PRIVILEGED ? "privileged" : "client");
  

• if (teedev && teedev->id < TEE_NUM_DEVICES) {

• spin_lock(&driver_lock);
  

• clear_bit(teedev->id, dev_mask);
  

• spin_unlock(&driver_lock);
  

• }
• kfree(teedev);
• return ret;

+} +EXPORT_SYMBOL_GPL(tee_device_alloc);

+static ssize_t version_show(struct device *dev, struct device_attribute *attr,

• 	char *buf)
  

+{

• struct tee_device *teedev = container_of(dev, struct tee_device, dev);
• struct tee_ioctl_version_data vers;
• teedev->desc->ops->get_version(teedev, &vers);
• return sprintf(buf, "%#x %#x %#x\n",

•        vers.impl_id, vers.impl_caps, vers.gen_caps);
  

+} +static DEVICE_ATTR_RO(version);

+static struct attribute *tee_dev_attrs[] = {

• &dev_attr_version.attr,
• NULL

+};

+static const struct attribute_group tee_dev_group = {

• .attrs = tee_dev_attrs,

+};

+int tee_device_register(struct tee_device *teedev) +{

• int rc;
• /*

• * If the teedev already is registered, don't do it again. It's
  

• * obviously an error to try to register twice, but if we return
  

• * an error we'll force the driver to remove the teedev.
  

• */
  

• if (teedev->flags & TEE_DEVICE_FLAG_REGISTERED) {

• dev_err(&teedev->dev, "attempt to register twice\n");
  

• return 0;
  

• }
• rc = cdev_add(&teedev->cdev, teedev->dev.devt, 1);
• if (rc) {

• dev_err(&teedev->dev,
  

• 	"unable to cdev_add() %s, major %d, minor %d, err=%d\n",
  

• 	teedev->name, MAJOR(teedev->dev.devt),
  

• 	MINOR(teedev->dev.devt), rc);
  

• return rc;
  

• }
• rc = device_add(&teedev->dev);
• if (rc) {

• dev_err(&teedev->dev,
  

• 	"unable to device_add() %s, major %d, minor %d, err=%d\n",
  

• 	teedev->name, MAJOR(teedev->dev.devt),
  

• 	MINOR(teedev->dev.devt), rc);
  

• goto err_device_add;
  

• }
• rc = sysfs_create_group(&teedev->dev.kobj, &tee_dev_group);
• if (rc) {

• dev_err(&teedev->dev,
  

• 	"failed to create sysfs attributes, err=%d\n", rc);
  

• goto err_sysfs_create_group;
  

• }
• teedev->flags |= TEE_DEVICE_FLAG_REGISTERED;
• return 0;

+err_sysfs_create_group:

• device_del(&teedev->dev);

+err_device_add:

• cdev_del(&teedev->cdev);
• return rc;

+} +EXPORT_SYMBOL_GPL(tee_device_register);

+void tee_device_put(struct tee_device *teedev) +{

• mutex_lock(&teedev->mutex);
• /* Shouldn't put in this state */
• if (!WARN_ON(!teedev->desc)) {

• teedev->num_users--;
  

• if (!teedev->num_users) {
  

• 	teedev->desc = NULL;
  

• 	complete(&teedev->c_no_users);
  

• }
  

• }
• mutex_unlock(&teedev->mutex);

+}

+bool tee_device_get(struct tee_device *teedev) +{

• mutex_lock(&teedev->mutex);
• if (!teedev->desc) {

• mutex_unlock(&teedev->mutex);
  

• return false;
  

• }
• teedev->num_users++;
• mutex_unlock(&teedev->mutex);
• return true;

+}

+void tee_device_unregister(struct tee_device *teedev) +{

• if (!teedev)

• return;
  

• if (teedev->flags & TEE_DEVICE_FLAG_REGISTERED) {

• sysfs_remove_group(&teedev->dev.kobj, &tee_dev_group);
  

• cdev_del(&teedev->cdev);
  

• device_del(&teedev->dev);
  

• }
• tee_device_put(teedev);
• wait_for_completion(&teedev->c_no_users);
• /*

• * No need to take a mutex any longer now since teedev->desc was
  

• * set to NULL before teedev->c_no_users was completed.
  

• */
  

• teedev->pool = NULL;
• put_device(&teedev->dev);

+} +EXPORT_SYMBOL_GPL(tee_device_unregister);

+void *tee_get_drvdata(struct tee_device *teedev) +{

• return dev_get_drvdata(&teedev->dev);

+} +EXPORT_SYMBOL_GPL(tee_get_drvdata);

+static int __init tee_init(void) +{

• int rc;
• tee_class = class_create(THIS_MODULE, "tee");
• if (IS_ERR(tee_class)) {

• pr_err("couldn't create class\n");
  

• return PTR_ERR(tee_class);
  

• }
• rc = alloc_chrdev_region(&tee_devt, 0, TEE_NUM_DEVICES, "tee");
• if (rc < 0) {

• pr_err("failed to allocate char dev region\n");
  

• class_destroy(tee_class);
  

• tee_class = NULL;
  

• }
• return rc;

+}

+subsys_initcall(tee_init); diff --git a/drivers/tee/tee_private.h b/drivers/tee/tee_private.h new file mode 100644 index 0000000..d32ac54 --- /dev/null +++ b/drivers/tee/tee_private.h @@ -0,0 +1,80 @@ +/*

• • Copyright (c) 2015, Linaro Limited
• • This software is licensed under the terms of the GNU General Public
• • License version 2, as published by the Free Software Foundation, and
• • may be copied, distributed, and modified under those terms.
• • This program is distributed in the hope that it will be useful,
• • but WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• • GNU General Public License for more details.
• */

+#ifndef TEE_PRIVATE_H +#define TEE_PRIVATE_H

+#include <linux/types.h> +#include <linux/device.h> +#include <linux/cdev.h> +#include <linux/completion.h> +#include <linux/mutex.h> +#include <linux/kref.h>

+struct tee_device;

+struct tee_shm {

• struct list_head list_node;
• struct tee_device *teedev;
• phys_addr_t paddr;
• void *kaddr;
• size_t size;
• struct dma_buf *dmabuf;
• u32 flags;

+};

+struct tee_shm_pool_mgr; +struct tee_shm_pool_mgr_ops {

• int (*alloc)(struct tee_shm_pool_mgr *poolmgr, struct tee_shm *shm,

•      size_t size);
  

• void (*free)(struct tee_shm_pool_mgr *poolmgr, struct tee_shm *shm);

+};

+struct tee_shm_pool_mgr {

• const struct tee_shm_pool_mgr_ops *ops;
• void *private_data;

+};

+struct tee_shm_pool {

• struct tee_shm_pool_mgr private_mgr;
• struct tee_shm_pool_mgr dma_buf_mgr;
• void (*destroy)(struct tee_shm_pool *pool);
• void *private_data;

+};

+#define TEE_DEVICE_FLAG_REGISTERED 0x1 +#define TEE_MAX_DEV_NAME_LEN 32

+struct tee_device {

• char name[TEE_MAX_DEV_NAME_LEN];
• const struct tee_desc *desc;
• int id;
• unsigned flags;
• struct device dev;
• struct cdev cdev;
• size_t num_users;
• struct completion c_no_users;
• struct mutex mutex;
• struct list_head list_shm;
• struct tee_shm_pool *pool;

+};

+int tee_shm_init(void);

+bool tee_device_get(struct tee_device *teedev); +void tee_device_put(struct tee_device *teedev);

+#endif /*TEE_PRIVATE_H*/ diff --git a/drivers/tee/tee_shm.c b/drivers/tee/tee_shm.c new file mode 100644 index 0000000..6732e77 --- /dev/null +++ b/drivers/tee/tee_shm.c @@ -0,0 +1,324 @@ +/*

• • Copyright (c) 2015, Linaro Limited
• • This software is licensed under the terms of the GNU General Public
• • License version 2, as published by the Free Software Foundation, and
• • may be copied, distributed, and modified under those terms.
• • This program is distributed in the hope that it will be useful,
• • but WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• • GNU General Public License for more details.
• */

+#include <linux/device.h> +#include <linux/fdtable.h> +#include <linux/sched.h> +#include <linux/dma-buf.h> +#include <linux/slab.h> +#include <linux/tee_drv.h> +#include "tee_private.h"

+static void tee_shm_release(struct tee_shm *shm) +{

• struct tee_device *teedev = shm->teedev;
• struct tee_shm_pool_mgr *poolm;
• mutex_lock(&teedev->mutex);
• list_del(&shm->list_node);
• mutex_unlock(&teedev->mutex);
• if (shm->flags & TEE_SHM_DMA_BUF)

• poolm = &teedev->pool->dma_buf_mgr;
  

• else

• poolm = &teedev->pool->private_mgr;
  

• poolm->ops->free(poolm, shm);
• kfree(shm);
• tee_device_put(teedev);

+}

+static struct sg_table *tee_shm_op_map_dma_buf(struct dma_buf_attachment

• 	*attach, enum dma_data_direction dir)
  

+{

• return NULL;

+}

+static void tee_shm_op_unmap_dma_buf(struct dma_buf_attachment *attach,

• 	struct sg_table *table, enum dma_data_direction dir)
  

+{ +}

+static void tee_shm_op_release(struct dma_buf *dmabuf) +{

• struct tee_shm *shm = dmabuf->priv;
• tee_shm_release(shm);

+}

+static void *tee_shm_op_kmap_atomic(struct dma_buf *dmabuf,

• 	unsigned long pgnum)
  

+{

• return NULL;

+}

+static void *tee_shm_op_kmap(struct dma_buf *dmabuf, unsigned long pgnum) +{

• return NULL;

+}

+static int tee_shm_op_mmap(struct dma_buf *dmabuf,

• 	struct vm_area_struct *vma)
  

+{

• struct tee_shm *shm = dmabuf->priv;
• size_t size = vma->vm_end - vma->vm_start;
• return remap_pfn_range(vma, vma->vm_start, shm->paddr >> PAGE_SHIFT,

• 	       size, vma->vm_page_prot);
  

+}

+static struct dma_buf_ops tee_shm_dma_buf_ops = {

• .map_dma_buf = tee_shm_op_map_dma_buf,
• .unmap_dma_buf = tee_shm_op_unmap_dma_buf,
• .release = tee_shm_op_release,
• .kmap_atomic = tee_shm_op_kmap_atomic,
• .kmap = tee_shm_op_kmap,
• .mmap = tee_shm_op_mmap,

+};

+struct tee_shm *tee_shm_alloc(struct tee_device *teedev, size_t size,

• 	u32 flags)
  

+{

• struct tee_shm_pool_mgr *poolm = NULL;
• struct tee_shm *shm;
• void *ret;
• int rc;
• if (!(flags & TEE_SHM_MAPPED)) {

• dev_err(teedev->dev.parent,
  

• 	"only mapped allocations supported\n");
  

• return ERR_PTR(-EINVAL);
  

• }
• if ((flags & ~(TEE_SHM_MAPPED|TEE_SHM_DMA_BUF))) {

• dev_err(teedev->dev.parent, "invalid shm flags 0x%x", flags);
  

• return ERR_PTR(-EINVAL);
  

• }
• if (!tee_device_get(teedev))

• return ERR_PTR(-EINVAL);
  

• if (!teedev->pool) {

• /* teedev has been detached from driver */
  

• ret = ERR_PTR(-EINVAL);
  

• goto err;
  

• }
• shm = kzalloc(sizeof(struct tee_shm), GFP_KERNEL);
• if (!shm) {

• ret = ERR_PTR(-ENOMEM);
  

• goto err;
  

• }
• shm->flags = flags;
• shm->teedev = teedev;
• if (flags & TEE_SHM_DMA_BUF)

• poolm = &teedev->pool->dma_buf_mgr;
  

• else

• poolm = &teedev->pool->private_mgr;
  

• rc = poolm->ops->alloc(poolm, shm, size);
• if (rc) {

• ret = ERR_PTR(rc);
  

• goto err;
  

• }
• mutex_lock(&teedev->mutex);
• list_add_tail(&shm->list_node, &teedev->list_shm);
• mutex_unlock(&teedev->mutex);
• if (flags & TEE_SHM_DMA_BUF) {

• DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
  

• exp_info.ops = &tee_shm_dma_buf_ops;
  

• exp_info.size = shm->size;
  

• exp_info.flags = O_RDWR;
  

• exp_info.priv = shm;
  

• shm->dmabuf = dma_buf_export(&exp_info);
  

• if (IS_ERR(shm->dmabuf)) {
  

• 	ret = ERR_CAST(shm->dmabuf);
  

• 	goto err;
  

• }
  

• }
• return shm;

+err:

• if (poolm && shm && shm->kaddr)

• poolm->ops->free(poolm, shm);
  

• kfree(shm);
• tee_device_put(teedev);
• return ret;

+} +EXPORT_SYMBOL_GPL(tee_shm_alloc);

+int tee_shm_get_fd(struct tee_shm *shm) +{

• u32 req_flags = TEE_SHM_MAPPED | TEE_SHM_DMA_BUF;
• int fd;
• if ((shm->flags & req_flags) != req_flags)

• return -EINVAL;
  

• fd = dma_buf_fd(shm->dmabuf, O_CLOEXEC);
• if (fd >= 0)

• get_dma_buf(shm->dmabuf);
  

• return fd;

+} +EXPORT_SYMBOL_GPL(tee_shm_get_fd);

+int tee_shm_put_fd(int fd) +{

• return __close_fd(current->files, fd);

+} +EXPORT_SYMBOL_GPL(tee_shm_put_fd);

+void tee_shm_free(struct tee_shm *shm) +{

• /*

• * dma_buf_put() decreases the dmabuf reference counter and will
  

• * call tee_shm_release() when the last reference is gone.
  

• *
  

• * In the case of driver private memory we call tee_shm_release
  

• * directly instead as it doesn't have a reference counter.
  

• */
  

• if (shm->flags & TEE_SHM_DMA_BUF)

• dma_buf_put(shm->dmabuf);
  

• else

• tee_shm_release(shm);
  

+} +EXPORT_SYMBOL_GPL(tee_shm_free);

+static bool cmp_key_va(struct tee_shm *shm, uintptr_t va) +{

• uintptr_t shm_va = (uintptr_t)shm->kaddr;
• return (va >= shm_va) && (va < (shm_va + shm->size));

+}

+static bool cmp_key_pa(struct tee_shm *shm, uintptr_t pa) +{

• return (pa >= shm->paddr) && (pa < (shm->paddr + shm->size));

+}

+static struct tee_shm *tee_shm_find_by_key(struct tee_device *teedev, u32 flags,

• 	bool (*cmp)(struct tee_shm *shm, uintptr_t key),
  

• 	uintptr_t key)
  

+{

• struct tee_shm *ret = NULL;
• struct tee_shm *shm;
• mutex_lock(&teedev->mutex);
• list_for_each_entry(shm, &teedev->list_shm, list_node) {

• if (cmp(shm, key)) {
  

• 	ret = shm;
  

• 	break;
  

• }
  

• }
• mutex_unlock(&teedev->mutex);
• return ret;

+}

+struct tee_shm *tee_shm_find_by_va(struct tee_device *teedev, u32 flags,

• 	void *va)
  

+{

• return tee_shm_find_by_key(teedev, flags, cmp_key_va, (uintptr_t)va);

+} +EXPORT_SYMBOL_GPL(tee_shm_find_by_va);

+struct tee_shm *tee_shm_find_by_pa(struct tee_device *teedev, u32 flags,

• 	phys_addr_t pa)
  

+{

• return tee_shm_find_by_key(teedev, flags, cmp_key_pa, pa);

+} +EXPORT_SYMBOL_GPL(tee_shm_find_by_pa);

+int tee_shm_va2pa(struct tee_shm *shm, void *va, phys_addr_t *pa) +{

• /* Check that we're in the range of the shm */
• if ((char *)va < (char *)shm->kaddr)

• return -EINVAL;
  

• if ((char *)va >= ((char *)shm->kaddr + shm->size))

• return -EINVAL;
  

• return tee_shm_get_pa(

• 	shm, (unsigned long)va - (unsigned long)shm->kaddr, pa);
  

+} +EXPORT_SYMBOL_GPL(tee_shm_va2pa);

+int tee_shm_pa2va(struct tee_shm *shm, phys_addr_t pa, void **va) +{

• /* Check that we're in the range of the shm */
• if (pa < shm->paddr)

• return -EINVAL;
  

• if (pa >= (shm->paddr + shm->size))

• return -EINVAL;
  

• if (va) {

• void *v = tee_shm_get_va(shm, pa - shm->paddr);
  

• if (IS_ERR(v))
  

• 	return PTR_ERR(v);
  

• *va = v;
  

• }
• return 0;

+} +EXPORT_SYMBOL_GPL(tee_shm_pa2va);

+void *tee_shm_get_va(struct tee_shm *shm, size_t offs) +{

• if (offs >= shm->size)

• return ERR_PTR(-EINVAL);
  

• return (char *)shm->kaddr + offs;

+} +EXPORT_SYMBOL_GPL(tee_shm_get_va);

+int tee_shm_get_pa(struct tee_shm *shm, size_t offs, phys_addr_t *pa) +{

• if (offs >= shm->size)

• return -EINVAL;
  

• if (pa)

• *pa = shm->paddr + offs;
  

• return 0;

+} +EXPORT_SYMBOL_GPL(tee_shm_get_pa);

+static bool is_shm_dma_buf(struct dma_buf *dmabuf) +{

• return dmabuf->ops == &tee_shm_dma_buf_ops;

+}

+struct tee_shm *tee_shm_get_from_fd(int fd) +{

• struct dma_buf *dmabuf = dma_buf_get(fd);
• if (IS_ERR(dmabuf))

• return ERR_CAST(dmabuf);
  

• if (!is_shm_dma_buf(dmabuf)) {

• dma_buf_put(dmabuf);
  

• return ERR_PTR(-EINVAL);
  

• }
• return dmabuf->priv;

+} +EXPORT_SYMBOL_GPL(tee_shm_get_from_fd);

+void tee_shm_put(struct tee_shm *shm) +{

• if (shm->flags & TEE_SHM_DMA_BUF)

• dma_buf_put(shm->dmabuf);
  

+} +EXPORT_SYMBOL_GPL(tee_shm_put); diff --git a/drivers/tee/tee_shm_pool.c b/drivers/tee/tee_shm_pool.c new file mode 100644 index 0000000..2ef22bc --- /dev/null +++ b/drivers/tee/tee_shm_pool.c @@ -0,0 +1,133 @@ +/*

• • Copyright (c) 2015, Linaro Limited
• • This software is licensed under the terms of the GNU General Public
• • License version 2, as published by the Free Software Foundation, and
• • may be copied, distributed, and modified under those terms.
• • This program is distributed in the hope that it will be useful,
• • but WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• • GNU General Public License for more details.
• */

+#include <linux/device.h> +#include <linux/dma-buf.h> +#include <linux/slab.h> +#include <linux/genalloc.h> +#include <linux/tee_drv.h> +#include "tee_private.h"

+static int pool_op_gen_alloc(struct tee_shm_pool_mgr *poolm,

• 	struct tee_shm *shm, size_t size)
  

+{

• unsigned long va;
• struct gen_pool *genpool = poolm->private_data;
• size_t s = roundup(size, 1 << genpool->min_alloc_order);
• va = gen_pool_alloc(genpool, s);
• if (!va)

• return -ENOMEM;
  

• shm->kaddr = (void *)va;
• shm->paddr = gen_pool_virt_to_phys(genpool, va);
• shm->size = s;
• return 0;

+}

+static void pool_op_gen_free(struct tee_shm_pool_mgr *poolm,

• 	struct tee_shm *shm)
  

+{

• gen_pool_free(poolm->private_data, (unsigned long)shm->kaddr,

•       shm->size);
  

• shm->kaddr = NULL;

+}

+static const struct tee_shm_pool_mgr_ops pool_ops_generic = {

• .alloc = pool_op_gen_alloc,
• .free = pool_op_gen_free,

+};

+static void pool_res_mem_destroy(struct tee_shm_pool *pool) +{

• gen_pool_destroy(pool->private_mgr.private_data);
• gen_pool_destroy(pool->dma_buf_mgr.private_data);

+}

+static int pool_res_mem_mgr_init(struct tee_shm_pool_mgr *mgr,

• 	struct tee_shm_pool_mem_info *info, int min_alloc_order)
  

+{

• size_t page_mask = PAGE_SIZE - 1;
• struct gen_pool *genpool = NULL;
• int rc;
• /*

• * Start and end must be page aligned
  

• */
  

• if ((info->vaddr & page_mask) || (info->paddr & page_mask) ||

•    (info->size & page_mask))
  

• return -EINVAL;
  

• genpool = gen_pool_create(min_alloc_order, -1);
• if (!genpool)

• return -ENOMEM;
  

• gen_pool_set_algo(genpool, gen_pool_best_fit, NULL);
• rc = gen_pool_add_virt(genpool, info->vaddr, info->paddr, info->size,

• 	       -1);
  

• if (rc) {

• gen_pool_destroy(genpool);
  

• return rc;
  

• }
• mgr->private_data = genpool;
• mgr->ops = &pool_ops_generic;
• return 0;

+}

+struct tee_shm_pool *tee_shm_pool_alloc_res_mem(struct device *dev,

• 	struct tee_shm_pool_mem_info *priv_info,
  

• 	struct tee_shm_pool_mem_info *dmabuf_info)
  

+{

• struct tee_shm_pool *pool = NULL;
• int ret;
• pool = kzalloc(sizeof(*pool), GFP_KERNEL);
• if (!pool) {

• ret = -ENOMEM;
  

• goto err;
  

• }
• /*

• * Create the pool for driver private shared memory
  

• */
  

• ret = pool_res_mem_mgr_init(&pool->private_mgr, priv_info,

• 		    3 /* 8 byte aligned */);
  

• if (ret)

• goto err;
  

• /*

• * Create the pool for dma_buf shared memory
  

• */
  

• ret = pool_res_mem_mgr_init(&pool->dma_buf_mgr, dmabuf_info,

• 		    PAGE_SHIFT);
  

• if (ret)

• goto err;
  

• pool->destroy = pool_res_mem_destroy;
• return pool;

+err:

• if (ret == -ENOMEM)

• dev_err(dev, "can't allocate memory for res_mem shared memory pool\n");
  

• if (pool && pool->private_mgr.private_data)

• gen_pool_destroy(pool->private_mgr.private_data);
  

• kfree(pool);
• return ERR_PTR(ret);

+} +EXPORT_SYMBOL_GPL(tee_shm_pool_alloc_res_mem);

+void tee_shm_pool_free(struct tee_shm_pool *pool) +{

• pool->destroy(pool);
• kfree(pool);

+} +EXPORT_SYMBOL_GPL(tee_shm_pool_free); diff --git a/include/linux/tee_drv.h b/include/linux/tee_drv.h new file mode 100644 index 0000000..bbfe8c2 --- /dev/null +++ b/include/linux/tee_drv.h @@ -0,0 +1,300 @@ +/*

• • Copyright (c) 2015, Linaro Limited
• • This software is licensed under the terms of the GNU General Public
• • License version 2, as published by the Free Software Foundation, and
• • may be copied, distributed, and modified under those terms.
• • This program is distributed in the hope that it will be useful,
• • but WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• • GNU General Public License for more details.
• */

+#ifndef __TEE_DRV_H +#define __TEE_DRV_H

+#include <linux/types.h> +#include <linux/list.h> +#include <linux/miscdevice.h> +#include <linux/tee.h>

+/*

• • The file describes the API provided by the generic TEE driver to the
• • specific TEE driver.
• */

+#define TEE_SHM_MAPPED 0x1 /* Memory mapped by the kernel */ +#define TEE_SHM_DMA_BUF 0x2 /* Memory with dma-buf handle */

+struct tee_device; +struct tee_shm; +struct tee_shm_pool;

+/**

• • struct tee_context - driver specific context on file pointer data
• • @teedev: pointer to this drivers struct tee_device
• • @data: driver specific context data, managed by the driver
• */

+struct tee_context {

• struct tee_device *teedev;
• void *data;

+};

+struct tee_param_memref {

• size_t shm_offs;
• size_t size;
• struct tee_shm *shm;

+};

+struct tee_param_value {

• u64 a;
• u64 b;
• u64 c;

+};

+struct tee_param {

• u64 attr;
• union {

• struct tee_param_memref memref;
  

• struct tee_param_value value;
  

• } u;

+};

+/**

• • struct tee_driver_ops - driver operations vtable
• • @get_version: returns version of driver
• • @open: called when the device file is opened
• • @release: release this open file
• */

+struct tee_driver_ops {

• void (*get_version)(struct tee_device *teedev,

• 	struct tee_ioctl_version_data *vers);
  

• int (*open)(struct tee_context *ctx);
• void (*release)(struct tee_context *ctx);
• int (*open_session)(struct tee_context *ctx,

• 	struct tee_ioctl_open_session_arg *arg,
  

• 	struct tee_param *param);
  

• int (*close_session)(struct tee_context *ctx, u32 session);
• int (*invoke_func)(struct tee_context *ctx,

• 	struct tee_ioctl_invoke_arg *arg,
  

• 	struct tee_param *param);
  

• int (*cancel_req)(struct tee_context *ctx, u32 cancel_id, u32 session);
• int (*supp_recv)(struct tee_context *ctx, u32 *func, u32 *num_params,

• 	struct tee_param *param);
  

• int (*supp_send)(struct tee_context *ctx, u32 ret, u32 num_params,

• 	struct tee_param *param);
  

+};

+/**

• • struct tee_desc - Describes the TEE driver to the subsystem
• • @name: name of driver
• • @ops: driver operations vtable
• • @owner: module providing the driver
• • @flags: Extra properties of driver, defined by TEE_DESC_* below
• */

+#define TEE_DESC_PRIVILEGED 0x1 +struct tee_desc {

• const char *name;
• const struct tee_driver_ops *ops;
• struct module *owner;
• u32 flags;

+};

+/**

• • tee_device_alloc() - Allocate a new struct tee_device instance
• • @teedesc: Descriptor for this driver
• • @dev: Parent device for this device
• • @pool: Shared memory pool, NULL if not used
• • @driver_data: Private driver data for this device
• • Allocates a new struct tee_device instance. The device is
• • removed by tee_device_unregister().
• • @returns a pointer to a 'struct tee_device' or an ERR_PTR on failure
• */

+struct tee_device *tee_device_alloc(const struct tee_desc *teedesc,

• 	struct device *dev, struct tee_shm_pool *pool,
  

• 	void *driver_data);
  

+/**

• • tee_device_register() - Registers a TEE device
• • @teedev: Device to register
• • tee_device_unregister() need to be called to remove the @teedev if
• • this function fails.
• • @returns < 0 on failure
• */

+int tee_device_register(struct tee_device *teedev);

+/**

• • tee_device_unregister() - Removes a TEE device
• • @teedev: Device to unregister
• • This function should be called to remove the @teedev even if
• • tee_device_register() hasn't been called yet. Does nothing if
• • @teedev is NULL.
• */

+void tee_device_unregister(struct tee_device *teedev);

+/**

• • struct tee_shm_pool_mem_info - holds information needed to create a shared memory pool
• • @vaddr: Virtual address of start of pool
• • @paddr: Physical address of start of pool
• • @size: Size in bytes of the pool
• */

+struct tee_shm_pool_mem_info {

• unsigned long vaddr;
• unsigned long paddr;
• size_t size;

+};

+/**

• • tee_shm_pool_alloc_res_mem() - Create a shared memory pool from reserved memory range
• • @dev: Device allocating the pool
• • @priv_info: Information for driver private shared memory pool
• • @dmabuf_info: Information for dma-buf shared memory pool
• • Start and end of pools will must be page aligned.
• • Allocation with the flag TEE_SHM_DMA_BUF set will use the range supplied
• • in @dmabuf, others will use the range provided by @priv.
• • @returns pointer to a 'struct tee_shm_pool' or an ERR_PTR on failure.
• */

+struct tee_shm_pool *tee_shm_pool_alloc_res_mem(struct device *dev,

• 	struct tee_shm_pool_mem_info *priv_info,
  

• 	struct tee_shm_pool_mem_info *dmabuf_info);
  

+/**

• • tee_shm_pool_free() - Free a shared memory pool
• • @pool: The shared memory pool to free
• • The must be no remaining shared memory allocated from this pool when
• • this function is called.
• */

+void tee_shm_pool_free(struct tee_shm_pool *pool);

+/**

• • tee_get_drvdata() - Return driver_data pointer
• • @returns the driver_data pointer supplied to tee_register().
• */

+void *tee_get_drvdata(struct tee_device *teedev);

+/**

• • tee_shm_alloc() - Allocate shared memory
• • @teedev: Driver that allocates the shared memory
• • @size: Requested size of shared memory
• • @flags: Flags setting properties for the requested shared memory.
• • Memory allocated as global shared memory is automatically freed when the
• • TEE file pointer is closed. The @flags field uses the bits defined by
• • TEE_SHM_* above. TEE_SHM_MAPPED must currently always be set. If
• • TEE_SHM_DMA_BUF global shared memory will be allocated and associated
• • with a dma-buf handle, else driver private memory.
• • @returns a pointer to 'struct tee_shm'
• */

+struct tee_shm *tee_shm_alloc(struct tee_device *teedev, size_t size,

• 	u32 flags);
  

+/**

• • tee_shm_free() - Free shared memory
• • @shm: Handle to shared memory to free
• */

+void tee_shm_free(struct tee_shm *shm);

+/**

• • tee_shm_find_by_va() - Find a shared memory handle by a virtual address
• • @teedev: The device that owns the shared memory
• • @flags: Select which type of shared memory to locate, if

• • TEE_SHM_DMA_BUF global shared memory else driver private
    

• • shared memory.
    

• • @va: Virtual address covered by the shared memory
• • @returns a Handle to shared memory
• */

+struct tee_shm *tee_shm_find_by_va(struct tee_device *teedev, u32 flags,

• 	void *va);
  

+/**

• • tee_shm_find_by_pa() - Find a shared memory handle by a physical address
• • @teedev: The device that owns the shared memory
• • @flags: Select which type of shared memory to locate, if

• • TEE_SHM_DMA_BUF global shared memory else driver private
    

• • shared memory.
    

• • @pa: Physical address covered by the shared memory
• • @returns a Handle to shared memory
• */

+struct tee_shm *tee_shm_find_by_pa(struct tee_device *teedev, u32 flags,

• 	phys_addr_t pa);
  

+/**

• • tee_shm_va2pa() - Get physical address of a virtual address
• • @shm: Shared memory handle
• • @va: Virtual address to tranlsate
• • @pa: Returned physical address
• • @returns 0 on success and < 0 on failure
• */

+int tee_shm_va2pa(struct tee_shm *shm, void *va, phys_addr_t *pa);

+/**

• • tee_shm_pa2va() - Get virtual address of a physical address
• • @shm: Shared memory handle
• • @pa: Physical address to tranlsate
• • @va: Returned virtual address
• • @returns 0 on success and < 0 on failure
• */

+int tee_shm_pa2va(struct tee_shm *shm, phys_addr_t pa, void **va);

+/**

• • tee_shm_get_va() - Get virtual address of a shared memory plus an offset
• • @shm: Shared memory handle
• • @offs: Offset from start of this shared memory
• • @returns virtual address of the shared memory + offs if offs is within
• • the bounds of this shared memory, else an ERR_PTR
• */

+void *tee_shm_get_va(struct tee_shm *shm, size_t offs);

+/**

• • tee_shm_get_pa() - Get physical address of a shared memory plus an offset
• • @shm: Shared memory handle
• • @offs: Offset from start of this shared memory
• • @pa: Physical address to return
• • @returns 0 if offs is within the bounds of this shared memory, else an
• • error code.
• */

+int tee_shm_get_pa(struct tee_shm *shm, size_t offs, phys_addr_t *pa);

+/**

• • tee_shm_get_from_fd() - Get a shared memory handle from a file descriptor
• • @fd: A user space file descriptor
• • This function increases the reference counter on the shared memory and
• • returns a handle.
• • @returns handle to shared memory
• */

+struct tee_shm *tee_shm_get_from_fd(int fd);

+/**

• • tee_shm_put() - Decrease reference count on a shared memory handle
• • @shm: Shared memory handle
• */

+void tee_shm_put(struct tee_shm *shm);

+/**

• • tee_shm_get_fd() - Increase reference count and return file descriptor
• • @shm: Shared memory handle
• • @returns user space file descriptor to shared memory
• */

+int tee_shm_get_fd(struct tee_shm *shm);

+/**

• • tee_shm_put_fd() - Decrease reference count and close file descriptor
• • @fd: File descriptor to close
• • @returns < 0 on failure
• */

+int tee_shm_put_fd(int fd);

+#endif /*__TEE_DRV_H*/ diff --git a/include/uapi/linux/tee.h b/include/uapi/linux/tee.h new file mode 100644 index 0000000..aead79a --- /dev/null +++ b/include/uapi/linux/tee.h @@ -0,0 +1,383 @@ +/*

• • Copyright (c) 2015, Linaro Limited
• • This software is licensed under the terms of the GNU General Public
• • License version 2, as published by the Free Software Foundation, and
• • may be copied, distributed, and modified under those terms.
• • This program is distributed in the hope that it will be useful,
• • but WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• • GNU General Public License for more details.
• */

+#ifndef __TEE_H +#define __TEE_H

+#include <linux/ioctl.h> +#include <linux/types.h>

+/*

• • This file describes the API provided by a TEE driver to user space.
• • Each TEE driver defines a TEE specific protocol which is used for the
• • data passed back and forth using TEE_IOC_CMD.
• */

+/* Helpers to make the ioctl defines */ +#define TEE_IOC_MAGIC 0xa4 +#define TEE_IOC_BASE 0

+/* Flags relating to shared memory */ +#define TEE_IOCTL_SHM_MAPPED 0x1 /* memory mapped in normal world */ +#define TEE_IOCTL_SHM_DMA_BUF 0x2 /* dma-buf handle on shared memory */

+#define TEE_MAX_ARG_SIZE 1024

+#define TEE_GEN_CAP_GP (1 << 0)/* Global Platform compliant TEE */

+/*

• • TEE Implementation ID
• */

+#define TEE_IMPL_ID_OPTEE 1

+/*

• • OP-TEE specific capabilities
• */

+#define TEE_OPTEE_CAP_TZ (1 << 0)

+/**

• • struct tee_version - TEE version

Name mismatch

• • @impl_id: [out] TEE implementation id
• • @impl_caps: [out] Implementation specific capabilities
• • @gen_caps: [out] Generic capabilities, defined by TEE_GEN_CAPS_* above
• • Identifies the TEE implementaion, @impl_id is one of TEE_IMPL_ID_* above.
• • @impl_caps is implementation specific, for example TEE_OPTEE_CAP_*
• • is valid when @impl_id == TEE_IMPL_ID_OPTEE.
• */

+struct tee_ioctl_version_data {

• __u32 impl_id;
• __u32 impl_caps;
• __u32 gen_caps;

+}; +/**

• • TEE_IOC_VERSION - query version of TEE
• • Takes a tee_version struct and returns with the TEE version data filled
• • in.
• */

+#define TEE_IOC_VERSION _IOR(TEE_IOC_MAGIC, TEE_IOC_BASE + 0, \

• 		     struct tee_ioctl_version_data)
  

+/**

• • struct tee_shm_alloc_data - Shared memory allocate argument

Name mismatch

• • @size: [in/out] Size of shared memory to allocate
• • @flags: [in/out] Flags to/from allocation.
• • @fd: [out] dma_buf file descriptor of the shared memory
• • The flags field should currently be zero as input. Updated by the call
• • with actual flags as defined by TEE_IOCTL_SHM_* above.
• • This structure is used as argument for TEE_IOC_SHM_ALLOC below.
• */

+struct tee_ioctl_shm_alloc_data {

• __u64 size;
• __u32 flags;
• __s32 fd;

+}; +/**

• • TEE_IOC_SHM_ALLOC - allocate shared memory
• • Allocates shared memory between the user space process and secure OS.
• • The returned file descriptor is used to map the shared memory into user
• • space. The shared memory is freed when the descriptor is closed and the
• • memory is unmapped.
• */

+#define TEE_IOC_SHM_ALLOC _IOWR(TEE_IOC_MAGIC, TEE_IOC_BASE + 1, \

• 		     struct tee_ioctl_shm_alloc_data)
  

+/**

• • struct tee_buf_data - Variable sized buffer

Name mismatch

• • @buf_ptr: [in] A __user pointer to a buffer
• • @buf_len: [in] Length of the buffer above
• • Used as argument for TEE_IOC_OPEN_SESSION, TEE_IOC_INVOKE,
• • TEE_IOC_SUPPL_RECV, and TEE_IOC_SUPPL_SEND below.
• */

+struct tee_ioctl_buf_data {

• __u64 buf_ptr;
• __u64 buf_len;

+};

+/*

• • Attributes for struct tee_ioctl_param, selects field in the union
• */

+#define TEE_IOCTL_PARAM_ATTR_TYPE_NONE 0 /* parameter not used */

+/*

• • These defines value parameters (struct tee_ioctl_param_value)
• */

+#define TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT 1 +#define TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT 2 +#define TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT 3 /* input and output */

+/*

• • These defines shared memory reference parameters (struct
• • tee_ioctl_param_memref)
• */

+#define TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT 5 +#define TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT 6 +#define TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT 7 /* input and output */

+/*

• • Mask for the type part of the attribute, leaves room for more types
• */

+#define TEE_IOCTL_PARAM_ATTR_TYPE_MASK 0xff

+/*

• • Matches TEEC_LOGIN_* in GP TEE Client API
• • Is only defined for GP compliant TEEs
• */

+#define TEE_IOCTL_LOGIN_PUBLIC 0 +#define TEE_IOCTL_LOGIN_USER 1 +#define TEE_IOCTL_LOGIN_GROUP 2 +#define TEE_IOCTL_LOGIN_APPLICATION 4 +#define TEE_IOCTL_LOGIN_USER_APPLICATION 5 +#define TEE_IOCTL_LOGIN_GROUP_APPLICATION 6

+/**

• • struct tee_ioctl_param_memref - memory reference
• • @shm_offs: Offset into the shared memory object
• • @size: Size of the buffer
• • @shm_fd: Shared memory file descriptor
• • Shared memory is allocated with TEE_IOC_SHM_ALLOC which returns a file
• • descriptor connected to the shared memory object. A memref can reference
• • a part of a shared memory by specifying an offset (@shm_offs) and @size
• • of the object. To supply the entire shared memory object set @shm_offs to 0
• • and @size to the previously returned size of the object.
• */

+struct tee_ioctl_param_memref {

• __u64 shm_offs;
• __u64 size;
• __s64 shm_fd;

+};

+/**

• • struct tee_ioctl_param_value - values
• • @a: first value
• • @b: second value
• • @c: third value
• */

+struct tee_ioctl_param_value {

• __u64 a;
• __u64 b;
• __u64 c;

+};

+/**

• • struct tee_ioctl_param - parameter
• • @attr: attributes
• • @memref: a memory reference
• • @value: a value
• • @attr & TEE_PARAM_ATTR_TYPE_MASK indicates if memref or value is used in
• • the union. TEE_PARAM_ATTR_TYPE_VALUE_* indicates value and
• • TEE_PARAM_ATTR_TYPE_MEMREF_* indicates memref. TEE_PARAM_ATTR_TYPE_NONE
• • indicates that none of the members are used.
• */

+struct tee_ioctl_param {

• __u64 attr;
• union {

• struct tee_ioctl_param_memref memref;
  

• struct tee_ioctl_param_value value;
  

• } u;

+};

+#define TEE_IOCTL_UUID_LEN 16

+/**

• • struct tee_open_session_arg - Open session argument
• • @uuid: [in] UUID of the Trusted Application
• • @clnt_uuid: [in] UUID of client
• • @clnt_login: [in] Login class of client, TEE_LOGIN_* above
• • @cancel_id: [in] Cancellation id, a unique value to identify this request
• • @session: [out] Session id
• • @ret: [out] return value
• • @ret_origin [out] origin of the return value
• • @num_params [in] number of parameters following this struct
• */

+struct tee_ioctl_open_session_arg {

• __u8 uuid[TEE_IOCTL_UUID_LEN];
• __u8 clnt_uuid[TEE_IOCTL_UUID_LEN];
• __u32 clnt_login;
• __u32 cancel_id;
• __u32 session;
• __u32 ret;
• __u32 ret_origin;
• __u32 num_params;
• /*

• * this struct is 8 byte aligned since the 'struct tee_ioctl_param'
  

• * which follows requires 8 byte alignment.
  

• *
  

• * Commented out element used to visualize the layout dynamic part
  

• * of the struct. This field is not available at all if
  

• * num_params == 0.
  

• *
  

• * struct tee_ioctl_param params[num_params];
  

• */
  

+} __aligned(8);

+/**

• • TEE_IOC_OPEN_SESSION - opens a session to a Trusted Application
• • Takes a struct tee_ioctl_buf_data which contains a struct
• • tee_ioctl_open_session_arg followed by any array of struct
• • tee_ioctl_param
• */

+#define TEE_IOC_OPEN_SESSION _IOR(TEE_IOC_MAGIC, TEE_IOC_BASE + 2, \

• 		     struct tee_ioctl_buf_data)
  

+/**

• • struct tee_invoke_func_arg - Invokes a function in a Trusted Application

Name mismatch

• • @func: [in] Trusted Application function, specific to the TA
• • @session: [in] Session id
• • @cancel_id: [in] Cancellation id, a unique value to identify this request
• • @ret: [out] return value
• • @ret_origin [out] origin of the return value
• • @num_params [in] number of parameters following this struct
• */

+struct tee_ioctl_invoke_arg {

• __u32 func;
• __u32 session;
• __u32 cancel_id;
• __u32 ret;
• __u32 ret_origin;
• __u32 num_params;
• /*

• * this struct is 8 byte aligned since the 'struct tee_ioctl_param'
  

• * which follows requires 8 byte alignment.
  

• *
  

• * Commented out element used to visualize the layout dynamic part
  

• * of the struct. This field is not available at all if
  

• * num_params == 0.
  

• *
  

• * struct tee_ioctl_param params[num_params];
  

• */
  

+} __aligned(8);

+/**

• • TEE_IOC_INVOKE - Invokes a function in a Trusted Application
• • Takes a struct tee_ioctl_buf_data which contains a struct
• • tee_invoke_func_arg followed by any array of struct tee_param
• */

+#define TEE_IOC_INVOKE _IOR(TEE_IOC_MAGIC, TEE_IOC_BASE + 3, \

• 		     struct tee_ioctl_buf_data)
  

+/**

• • struct tee_ioctl_cancel_arg - Cancels an open session or invoke ioctl
• • @cancel_id: [in] Cancellation id, a unique value to identify this request
• • @session: [in] Session id, if the session is opened, else set to 0
• */

+struct tee_ioctl_cancel_arg {

• __u32 cancel_id;
• __u32 session;

+}; +/**

• • TEE_IOC_CANCEL - Cancels an open session or invoke
• */

+#define TEE_IOC_CANCEL _IOR(TEE_IOC_MAGIC, TEE_IOC_BASE + 4, \

• 		     struct tee_ioctl_cancel_arg)
  

+/**

• • struct tee_ioctl_close_session_arg - Closes an open session
• • @session: [in] Session id
• */

+struct tee_ioctl_close_session_arg {

• __u32 session;

+}; +/**

• • TEE_IOC_CLOSE_SESSION - Closes a session
• */

+#define TEE_IOC_CLOSE_SESSION _IOR(TEE_IOC_MAGIC, TEE_IOC_BASE + 5, \

• 		     struct tee_ioctl_close_session_arg)
  

+/**

• • struct tee_iocl_supp_recv_arg - Receive a request for a supplicant function
• • @func: [in] supplicant function
• • @num_params [in/out] number of parameters following this struct
• • @num_params is the number of params that tee-supplicant has room to
• • receive when input, @num_params is the number of actual params
• • tee-supplicant receives when output.
• */

+struct tee_iocl_supp_recv_arg {

• __u32 func;
• __u32 num_params;
• /*

• * this struct is 8 byte aligned since the 'struct tee_ioctl_param'
  

• * which follows requires 8 byte alignment.
  

• *
  

• * Commented out element used to visualize the layout dynamic part
  

• * of the struct. This field is not available at all if
  

• * num_params == 0.
  

• *
  

• * struct tee_ioctl_param params[num_params];
  

• */
  

+} __aligned(8); +/**

• • TEE_IOC_SUPPL_RECV - Receive a request for a supplicant function
• • Takes a struct tee_ioctl_buf_data which contains a struct
• • tee_iocl_supp_recv_arg followed by any array of struct tee_param
• */

+#define TEE_IOC_SUPPL_RECV _IOR(TEE_IOC_MAGIC, TEE_IOC_BASE + 6, \

• 		     struct tee_ioctl_buf_data)
  

+/**

• • struct tee_iocl_supp_send_arg - Send a response to a received request
• • @ret: [out] return value
• • @num_params [in] number of parameters following this struct
• */

+struct tee_iocl_supp_send_arg {

• __u32 ret;
• __u32 num_params;
• /*

• * this struct is 8 byte aligned since the 'struct tee_ioctl_param'
  

• * which follows requires 8 byte alignment.
  

• *
  

• * Commented out element used to visualize the layout dynamic part
  

• * of the struct. This field is not available at all if
  

• * num_params == 0.
  

• *
  

• * struct tee_ioctl_param params[num_params];
  

• */
  

+} __aligned(8); +/**

• • TEE_IOC_SUPPL_SEND - Receive a request for a supplicant function
• • Takes a struct tee_ioctl_buf_data which contains a struct
• • tee_iocl_supp_send_arg followed by any array of struct tee_param
• */

+#define TEE_IOC_SUPPL_SEND _IOR(TEE_IOC_MAGIC, TEE_IOC_BASE + 7, \

• 		     struct tee_ioctl_buf_data)
  

+/*

• • Five syscalls are used when communicating with the TEE driver.
• • open(): opens the device associated with the driver
• • ioctl(): as described above operating on the file descriptor from open()
• • close(): two cases
• • • closes the device file descriptor
• • • closes a file descriptor connected to allocated shared memory
• • mmap(): maps shared memory into user space using information from struct

• •   tee_ioctl_shm_alloc_data
    

• • munmap(): unmaps previously shared memory
• */

+#endif /*__TEE_H*/