tee.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 EPAM Systems
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
/*
 * Copyright (c) 2015-2016, Linaro Limited
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef ZEPHYR_INCLUDE_DRIVERS_TEE_H_
#define ZEPHYR_INCLUDE_DRIVERS_TEE_H_
 
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>

 
#ifdef __cplusplus
extern "C" {
#endif
#define TEE_UUID_LEN 16
 
#define TEE_GEN_CAP_GP          BIT(0) /* GlobalPlatform compliant TEE */
#define TEE_GEN_CAP_PRIVILEGED  BIT(1) /* Privileged device (for supplicant) */
#define TEE_GEN_CAP_REG_MEM     BIT(2) /* Supports registering shared memory */
#define TEE_GEN_CAP_MEMREF_NULL BIT(3) /* Support NULL MemRef */
 
#define TEE_SHM_REGISTER        BIT(0)
#define TEE_SHM_ALLOC           BIT(1)
 
#define TEE_PARAM_ATTR_TYPE_NONE                0 /* parameter not used */
#define TEE_PARAM_ATTR_TYPE_VALUE_INPUT         1
#define TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT        2
#define TEE_PARAM_ATTR_TYPE_VALUE_INOUT         3 /* input and output */
#define TEE_PARAM_ATTR_TYPE_MEMREF_INPUT        5
#define TEE_PARAM_ATTR_TYPE_MEMREF_OUTPUT       6
#define TEE_PARAM_ATTR_TYPE_MEMREF_INOUT        7 /* input and output */
#define TEE_PARAM_ATTR_TYPE_MASK                0xff
#define TEE_PARAM_ATTR_META                     0x100
#define TEE_PARAM_ATTR_MASK                     (TEE_PARAM_ATTR_TYPE_MASK | TEE_PARAM_ATTR_META)

#define TEEC_ORIGIN_API         0x00000001
#define TEEC_ORIGIN_COMMS       0x00000002
#define TEEC_ORIGIN_TEE         0x00000003
#define TEEC_ORIGIN_TRUSTED_APP 0x00000004


#define TEEC_SUCCESS                            0x00000000
#define TEEC_ERROR_STORAGE_NOT_AVAILABLE        0xF0100003
#define TEEC_ERROR_GENERIC                      0xFFFF0000
#define TEEC_ERROR_ACCESS_DENIED                0xFFFF0001
#define TEEC_ERROR_CANCEL                       0xFFFF0002
#define TEEC_ERROR_ACCESS_CONFLICT              0xFFFF0003
#define TEEC_ERROR_EXCESS_DATA                  0xFFFF0004
#define TEEC_ERROR_BAD_FORMAT                   0xFFFF0005
#define TEEC_ERROR_BAD_PARAMETERS               0xFFFF0006
#define TEEC_ERROR_BAD_STATE                    0xFFFF0007
#define TEEC_ERROR_ITEM_NOT_FOUND               0xFFFF0008
#define TEEC_ERROR_NOT_IMPLEMENTED              0xFFFF0009
#define TEEC_ERROR_NOT_SUPPORTED                0xFFFF000A
#define TEEC_ERROR_NO_DATA                      0xFFFF000B
#define TEEC_ERROR_OUT_OF_MEMORY                0xFFFF000C
#define TEEC_ERROR_BUSY                         0xFFFF000D
#define TEEC_ERROR_COMMUNICATION                0xFFFF000E
#define TEEC_ERROR_SECURITY                     0xFFFF000F
#define TEEC_ERROR_SHORT_BUFFER                 0xFFFF0010
#define TEEC_ERROR_EXTERNAL_CANCEL              0xFFFF0011
#define TEEC_ERROR_TARGET_DEAD                  0xFFFF3024
#define TEEC_ERROR_STORAGE_NO_SPACE             0xFFFF3041

#define TEEC_LOGIN_PUBLIC               0x00000000
#define TEEC_LOGIN_USER                 0x00000001
#define TEEC_LOGIN_GROUP                0x00000002
#define TEEC_LOGIN_APPLICATION          0x00000004
#define TEEC_LOGIN_USER_APPLICATION     0x00000005
#define TEEC_LOGIN_GROUP_APPLICATION    0x00000006

struct tee_version_info {
        uint32_t impl_id; 
        uint32_t impl_caps; 
        uint32_t gen_caps;  
};

struct tee_open_session_arg {
        uint8_t uuid[TEE_UUID_LEN]; 
        uint8_t clnt_uuid[TEE_UUID_LEN]; 
        uint32_t clnt_login; 
        uint32_t cancel_id; 
        uint32_t session; 
        uint32_t ret; 
        uint32_t ret_origin; 
};

struct tee_param {
        uint64_t attr; 
        uint64_t a; 
        uint64_t b; 
        uint64_t c; 
};

struct tee_invoke_func_arg {
        uint32_t func;       
        uint32_t session;    
        uint32_t cancel_id;  
        uint32_t ret;        
        uint32_t ret_origin; 
};

struct tee_shm {
        const struct device *dev; 
        void *addr;               
        uint64_t size;            
        uint32_t flags;           
};

typedef int (*tee_get_version_t)(const struct device *dev, struct tee_version_info *info);

typedef int (*tee_open_session_t)(const struct device *dev, struct tee_open_session_arg *arg,
                                  unsigned int num_param, struct tee_param *param,
                                  uint32_t *session_id);
typedef int (*tee_close_session_t)(const struct device *dev, uint32_t session_id);

typedef int (*tee_cancel_t)(const struct device *dev, uint32_t session_id, uint32_t cancel_id);

typedef int (*tee_invoke_func_t)(const struct device *dev, struct tee_invoke_func_arg *arg,
                                 unsigned int num_param, struct tee_param *param);
typedef int (*tee_shm_register_t)(const struct device *dev, struct tee_shm *shm);

typedef int (*tee_shm_unregister_t)(const struct device *dev, struct tee_shm *shm);

typedef int (*tee_suppl_recv_t)(const struct device *dev, uint32_t *func, unsigned int *num_params,
                                struct tee_param *param);

typedef int (*tee_suppl_send_t)(const struct device *dev, unsigned int ret, unsigned int num_params,
                                struct tee_param *param);
 
__subsystem struct tee_driver_api {
        tee_get_version_t get_version;
        tee_open_session_t open_session;
        tee_close_session_t close_session;
        tee_cancel_t cancel;
        tee_invoke_func_t invoke_func;
        tee_shm_register_t shm_register;
        tee_shm_unregister_t shm_unregister;
        tee_suppl_recv_t suppl_recv;
        tee_suppl_send_t suppl_send;
};

__syscall int tee_get_version(const struct device *dev, struct tee_version_info *info);
 
static inline int z_impl_tee_get_version(const struct device *dev, struct tee_version_info *info)
{
        const struct tee_driver_api *api = DEVICE_API_GET(tee, dev);
 
        if (!api->get_version) {
                return -ENOSYS;
        }
 
        return api->get_version(dev, info);
}

__syscall int tee_open_session(const struct device *dev, struct tee_open_session_arg *arg,
                               unsigned int num_param, struct tee_param *param,
                               uint32_t *session_id);
 
static inline int z_impl_tee_open_session(const struct device *dev,
                                          struct tee_open_session_arg *arg,
                                          unsigned int num_param, struct tee_param *param,
                                          uint32_t *session_id)
{
        const struct tee_driver_api *api = DEVICE_API_GET(tee, dev);
 
        if (!api->open_session) {
                return -ENOSYS;
        }
 
        return api->open_session(dev, arg, num_param, param, session_id);
}

__syscall int tee_close_session(const struct device *dev, uint32_t session_id);
 
static inline int z_impl_tee_close_session(const struct device *dev, uint32_t session_id)
{
        const struct tee_driver_api *api = DEVICE_API_GET(tee, dev);
 
        if (!api->close_session) {
                return -ENOSYS;
        }
 
        return api->close_session(dev, session_id);
}

__syscall int tee_cancel(const struct device *dev, uint32_t session_id, uint32_t cancel_id);
 
static inline int z_impl_tee_cancel(const struct device *dev, uint32_t session_id,
                                    uint32_t cancel_id)
{
        const struct tee_driver_api *api = DEVICE_API_GET(tee, dev);
 
        if (!api->cancel) {
                return -ENOSYS;
        }
 
        return api->cancel(dev, session_id, cancel_id);
}

__syscall int tee_invoke_func(const struct device *dev, struct tee_invoke_func_arg *arg,
                              unsigned int num_param, struct tee_param *param);
 
static inline int z_impl_tee_invoke_func(const struct device *dev, struct tee_invoke_func_arg *arg,
                                         unsigned int num_param, struct tee_param *param)
{
        const struct tee_driver_api *api = DEVICE_API_GET(tee, dev);
 
        if (!api->invoke_func) {
                return -ENOSYS;
        }
 
        return api->invoke_func(dev, arg, num_param, param);
}

int tee_add_shm(const struct device *dev, void *addr, size_t align, size_t size, uint32_t flags,
                struct tee_shm **shmp);

int tee_rm_shm(const struct device *dev, struct tee_shm *shm);

__syscall int tee_shm_register(const struct device *dev, void *addr, size_t size,
                               uint32_t flags, struct tee_shm **shm);
 
static inline int z_impl_tee_shm_register(const struct device *dev, void *addr, size_t size,
                                          uint32_t flags, struct tee_shm **shm)
{
        flags &= ~TEE_SHM_ALLOC;
        return tee_add_shm(dev, addr, 0, size, flags | TEE_SHM_REGISTER, shm);
}

__syscall int tee_shm_unregister(const struct device *dev, struct tee_shm *shm);
 
static inline int z_impl_tee_shm_unregister(const struct device *dev, struct tee_shm *shm)
{
        return tee_rm_shm(dev, shm);
}

__syscall int tee_shm_alloc(const struct device *dev, size_t size, uint32_t flags,
                            struct tee_shm **shm);
 
static inline int z_impl_tee_shm_alloc(const struct device *dev, size_t size, uint32_t flags,
                                       struct tee_shm **shm)
{
        return tee_add_shm(dev, NULL, 0, size, flags | TEE_SHM_ALLOC | TEE_SHM_REGISTER, shm);
}

__syscall int tee_shm_free(const struct device *dev, struct tee_shm *shm);
 
static inline int z_impl_tee_shm_free(const struct device *dev, struct tee_shm *shm)
{
        return tee_rm_shm(dev, shm);
}

__syscall int tee_suppl_recv(const struct device *dev, uint32_t *func, unsigned int *num_params,
                             struct tee_param *param);
 
static inline int z_impl_tee_suppl_recv(const struct device *dev, uint32_t *func,
                                        unsigned int *num_params, struct tee_param *param)
{
        const struct tee_driver_api *api = DEVICE_API_GET(tee, dev);
 
        if (!api->suppl_recv) {
                return -ENOSYS;
        }
 
        return api->suppl_recv(dev, func, num_params, param);
}

__syscall int tee_suppl_send(const struct device *dev, unsigned int ret, unsigned int num_params,
                             struct tee_param *param);
 
static inline int z_impl_tee_suppl_send(const struct device *dev, unsigned int ret,
                                        unsigned int num_params, struct tee_param *param)
{
        const struct tee_driver_api *api = DEVICE_API_GET(tee, dev);
 
        if (!api->suppl_send) {
                return -ENOSYS;
        }
 
        return api->suppl_send(dev, ret, num_params, param);
}
 
#ifdef __cplusplus
}
#endif

 
#include <zephyr/syscalls/tee.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_TEE_H_ */