Merge tag 'armsoc-tee' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc

Pull TEE driver infrastructure and OP-TEE drivers from Arnd Bergmann:
 "This introduces a generic TEE framework in the kernel, to handle
  trusted environemtns (security coprocessor or software implementations
  such as OP-TEE/TrustZone). I'm sending it separately from the other
  arm-soc driver changes to give it a little more visibility, once the
  subsystem is merged, we will likely keep this in the arm₋soc drivers
  branch or have the maintainers submit pull requests directly,
  depending on the patch volume.

  I have reviewed earlier versions in the past, and have reviewed the
  latest version in person during Linaro Connect BUD17.

  Here is my overall assessment of the subsystem:

   - There is clearly demand for this, both for the generic
     infrastructure and the specific OP-TEE implementation.

   - The code has gone through a large number of reviews, and the review
     comments have all been addressed, but the reviews were not coming
     up with serious issues any more and nobody volunteered to vouch for
     the quality.

   - The user space ioctl interface is sufficient to work with the
     OP-TEE driver, and it should in principle work with other TEE
     implementations that follow the GlobalPlatform[1] standards, but it
     might need to be extended in minor ways depending on specific
     requirements of future TEE implementations

   - The main downside of the API to me is how the user space is tied to
     the TEE implementation in hardware or firmware, but uses a generic
     way to communicate with it. This seems to be an inherent problem
     with what it is trying to do, and I could not come up with any
     better solution than what is implemented here.

  For a detailed history of the patch series, see

    https://lkml.org/lkml/2017/3/10/1277"

* tag 'armsoc-tee' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc:
  arm64: dt: hikey: Add optee node
  Documentation: tee subsystem and op-tee driver
  tee: add OP-TEE driver
  tee: generic TEE subsystem
  dt/bindings: add bindings for optee

2 files changed, 623 insertions, 0 deletions

diff --git a/include/linux/tee_drv.h b/include/linux/tee_drv.h
new file mode 100644
index 000000000000..0f175b8f6456
--- /dev/null
+++ b/include/linux/tee_drv.h
@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) 2015-2016, 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/idr.h>
+#include <linux/list.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
+ * @list_shm:   List of shared memory object owned by this context
+ * @data:       driver specific context data, managed by the driver
+ */
+struct tee_context {
+        struct tee_device *teedev;
+        struct list_head list_shm;
+        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
+ * @open_session:       open a new session
+ * @close_session:      close a session
+ * @invoke_func:        invoke a trusted function
+ * @cancel_req:         request cancel of an ongoing invoke or open
+ * @supp_revc:          called for supplicant to get a command
+ * @supp_send:          called for supplicant to send a response
+ */
+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;
+        phys_addr_t paddr;
+        size_t size;
+};
+
+/**
+ * tee_shm_pool_alloc_res_mem() - Create a shared memory pool from reserved
+ * memory range
+ * @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 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
+ * @ctx:        Context 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.