From 2a61b52cc9e5e51e98d7513af5d55abe33b65d9f Mon Sep 17 00:00:00 2001 From: Zhen Kong Date: Thu, 29 Aug 2019 12:29:36 -0700 Subject: [PATCH] shmbridge: Add shmbridge driver snapshot for lahaina Add snapshot for qtee_shmbridge from msm-4.19 commit 4260f49233b7 ("drivers: soc: qcom: enable shared memory bridge in hypervisor"). Change-Id: I3247eedc0fbcebd3db212e8835d8a68090123ee4 Signed-off-by: Zhen Kong --- drivers/soc/qcom/Kconfig | 10 + drivers/soc/qcom/Makefile | 1 + drivers/soc/qcom/qtee_shmbridge.c | 413 +++++++++++++++++ include/soc/qcom/qseecomi.h | 723 ++++++++++++++++++++++++++++++ include/soc/qcom/qtee_shmbridge.h | 90 ++++ 5 files changed, 1237 insertions(+) create mode 100644 drivers/soc/qcom/qtee_shmbridge.c create mode 100644 include/soc/qcom/qseecomi.h create mode 100644 include/soc/qcom/qtee_shmbridge.h diff --git a/drivers/soc/qcom/Kconfig b/drivers/soc/qcom/Kconfig index 8d3f12656789..e413ff8d754a 100644 --- a/drivers/soc/qcom/Kconfig +++ b/drivers/soc/qcom/Kconfig @@ -509,4 +509,14 @@ config QCOM_SOC_SLEEP_STATS the shared memory exported by the remote processor related to various SoC level low power modes statistics and export to sysfs interface. + +config QTEE_SHM_BRIDGE + bool "QTI TEE shared memory bridge" + help + QTEE shared memory bridge driver provides kernel APIs to share + memory between trustzone & other VMs through shared memory bridge. + It allows kernel clients to create bridge, delete bridge, and do + memory sub-allocation and free from the default kernel bridge + created by bridge driver. + endmenu diff --git a/drivers/soc/qcom/Makefile b/drivers/soc/qcom/Makefile index 5ba70c6fb2d9..e9fd5a1f5b3f 100644 --- a/drivers/soc/qcom/Makefile +++ b/drivers/soc/qcom/Makefile @@ -52,3 +52,4 @@ obj-$(CONFIG_QTI_DDR_STATS_LOG) += ddr_stats.o obj-$(CONFIG_QTI_SYSTEM_PM) += system_pm.o obj-$(CONFIG_MSM_IDLE_STATS) += lpm-stats.o obj-$(CONFIG_QTI_RPM_STATS_LOG) += rpmh_master_stat.o +obj-$(CONFIG_QTEE_SHM_BRIDGE) += qtee_shmbridge.o diff --git a/drivers/soc/qcom/qtee_shmbridge.c b/drivers/soc/qcom/qtee_shmbridge.c new file mode 100644 index 000000000000..990817729130 --- /dev/null +++ b/drivers/soc/qcom/qtee_shmbridge.c @@ -0,0 +1,413 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * QTI TEE shared memory bridge driver + * + * Copyright (c) 2019, The Linux Foundation. All rights reserved. + */ + +#include +#include +#include +#include + +#include +#include +#include + +#define DEFAULT_BRIDGE_SIZE SZ_4M /*4M*/ +/* + * tz_enable_shm_bridge + * smc_id: 0x02000C1C + */ +#define TZ_SVC_MEMORY_PROTECTION 12 + +#define TZ_SHM_BRIDGE_ENABLE \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_SIP, TZ_SVC_MEMORY_PROTECTION, 0x1C) + +#define TZ_SHM_BRIDGE_ENABLE_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_0 + +/* + * tz_create_shm_bridge + * smc_id: 0x02000C1E + */ + +#define TZ_SHM_BRIDGE_CREATE \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_SIP, TZ_SVC_MEMORY_PROTECTION, 0x1E) + +#define TZ_SHM_BRIDGE_CREATE_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_4( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_VAL, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_VAL) + +/** + * tz_delete_shm_bridge + * smc_id: 0x02000C1D + */ +#define TZ_SHM_BRIDGE_DELETE \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_SIP, TZ_SVC_MEMORY_PROTECTION, 0x1D) + +#define TZ_SHM_BRIDGE_DELETE_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_1( \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define MAXSHMVMS 4 +#define PERM_BITS 3 +#define VM_BITS 16 +#define SELF_OWNER_BIT 1 +#define SHM_NUM_VM_SHIFT 9 +#define SHM_VM_MASK 0xFFFF +#define SHM_PERM_MASK 0x7 + +#define VM_PERM_R PERM_READ +#define VM_PERM_W PERM_WRITE + +#define SHMBRIDGE_E_NOT_SUPPORTED 4 /* SHMbridge is not implemented */ + +/* ns_vmids */ +#define UPDATE_NS_VMIDS(ns_vmids, id) \ + (((uint64_t)(ns_vmids) << VM_BITS) \ + | ((uint64_t)(id) & SHM_VM_MASK)) + +/* ns_perms */ +#define UPDATE_NS_PERMS(ns_perms, perm) \ + (((uint64_t)(ns_perms) << PERM_BITS) \ + | ((uint64_t)(perm) & SHM_PERM_MASK)) + +/* pfn_and_ns_perm_flags = paddr | ns_perms */ +#define UPDATE_PFN_AND_NS_PERM_FLAGS(paddr, ns_perms) \ + ((uint64_t)(paddr) | (ns_perms)) + + +/* ipfn_and_s_perm_flags = ipaddr | tz_perm */ +#define UPDATE_IPFN_AND_S_PERM_FLAGS(ipaddr, tz_perm) \ + ((uint64_t)(ipaddr) | (uint64_t)(tz_perm)) + +/* size_and_flags when dest_vm is not HYP */ +#define UPDATE_SIZE_AND_FLAGS(size, destnum) \ + ((size) | (destnum) << SHM_NUM_VM_SHIFT) + +struct bridge_info { + phys_addr_t paddr; + void *vaddr; + size_t size; + uint64_t handle; + int min_alloc_order; + struct gen_pool *genpool; +}; + +struct bridge_list { + struct list_head head; + struct mutex lock; +}; + +struct bridge_list_entry { + struct list_head list; + phys_addr_t paddr; + uint64_t handle; +}; + +static struct bridge_info default_bridge; +static struct bridge_list bridge_list_head; +static bool qtee_shmbridge_enabled; + +/* enable shared memory bridge mechanism in HYP */ +static int32_t qtee_shmbridge_enable(bool enable) +{ + int32_t ret = 0; + struct scm_desc desc = {0}; + + qtee_shmbridge_enabled = false; + if (!enable) { + pr_warn("shmbridge isn't enabled\n"); + return ret; + } + + desc.arginfo = TZ_SHM_BRIDGE_ENABLE_PARAM_ID; + ret = scm_call2(TZ_SHM_BRIDGE_ENABLE, &desc); + if (ret || desc.ret[0]) { + pr_err("Failed to enable shmbridge, rsp = %lld, ret = %d\n", + desc.ret[0], ret); + if (ret == -EIO || desc.ret[0] == SHMBRIDGE_E_NOT_SUPPORTED) + pr_warn("shmbridge is not supported by this target\n"); + return ret | desc.ret[0]; + } + qtee_shmbridge_enabled = true; + pr_warn("shmbridge is enabled\n"); + return ret; +} + +/* Check whether shmbridge mechanism is enabled in HYP or not */ +bool qtee_shmbridge_is_enabled(void) +{ + return qtee_shmbridge_enabled; +} +EXPORT_SYMBOL(qtee_shmbridge_is_enabled); + +static int32_t qtee_shmbridge_list_add_nolock(phys_addr_t paddr, + uint64_t handle) +{ + struct bridge_list_entry *entry; + + entry = kzalloc(sizeof(*entry), GFP_KERNEL); + if (!entry) + return -ENOMEM; + entry->handle = handle; + entry->paddr = paddr; + list_add_tail(&entry->list, &bridge_list_head.head); + return 0; +} + +static void qtee_shmbridge_list_del_nolock(uint64_t handle) +{ + struct bridge_list_entry *entry; + + list_for_each_entry(entry, &bridge_list_head.head, list) { + if (entry->handle == handle) { + list_del(&entry->list); + kfree(entry); + break; + } + } +} + +static int32_t qtee_shmbridge_query_nolock(phys_addr_t paddr) +{ + struct bridge_list_entry *entry; + + list_for_each_entry(entry, &bridge_list_head.head, list) + if (entry->paddr == paddr) { + pr_debug("A bridge on %llx exists\n", (uint64_t)paddr); + return -EEXIST; + } + return 0; +} + +/* Check whether a bridge starting from paddr exists */ +int32_t qtee_shmbridge_query(phys_addr_t paddr) +{ + int32_t ret = 0; + + mutex_lock(&bridge_list_head.lock); + ret = qtee_shmbridge_query_nolock(paddr); + mutex_unlock(&bridge_list_head.lock); + return ret; +} +EXPORT_SYMBOL(qtee_shmbridge_query); + +/* Register paddr & size as a bridge, return bridge handle */ +int32_t qtee_shmbridge_register( + phys_addr_t paddr, + size_t size, + uint32_t *ns_vmid_list, + uint32_t *ns_vm_perm_list, + uint32_t ns_vmid_num, + uint32_t tz_perm, + uint64_t *handle) + +{ + int32_t ret = 0; + uint64_t ns_perms = 0; + uint64_t ns_vmids = 0; + struct scm_desc desc = {0}; + int i = 0; + + if (!qtee_shmbridge_enabled) + return 0; + + if (!handle || !ns_vmid_list || !ns_vm_perm_list || + ns_vmid_num > MAXSHMVMS) { + pr_err("invalid input parameters\n"); + return -EINVAL; + } + + mutex_lock(&bridge_list_head.lock); + ret = qtee_shmbridge_query_nolock(paddr); + if (ret) + goto exit; + + for (i = 0; i < ns_vmid_num; i++) { + ns_perms = UPDATE_NS_PERMS(ns_perms, ns_vm_perm_list[i]); + ns_vmids = UPDATE_NS_VMIDS(ns_vmids, ns_vmid_list[i]); + } + + desc.arginfo = TZ_SHM_BRIDGE_CREATE_PARAM_ID; + desc.args[0] = UPDATE_PFN_AND_NS_PERM_FLAGS(paddr, ns_perms); + desc.args[1] = UPDATE_IPFN_AND_S_PERM_FLAGS(paddr, tz_perm); + desc.args[2] = UPDATE_SIZE_AND_FLAGS(size, ns_vmid_num); + desc.args[3] = ns_vmids; + + pr_debug("%s: arginfo %x, desc.args[0] %llx, args[1] %llx, args[2] %llx, args[3] %llx\n", + __func__, desc.arginfo, desc.args[0], + desc.args[1], desc.args[2], desc.args[3]); + ret = scm_call2(TZ_SHM_BRIDGE_CREATE, &desc); + if (ret || desc.ret[0]) { + pr_err("create shmbridge failed, ret = %d, status = %llx\n", + ret, desc.ret[0]); + ret = -EINVAL; + goto exit; + } + *handle = desc.ret[1]; + + ret = qtee_shmbridge_list_add_nolock(paddr, *handle); +exit: + mutex_unlock(&bridge_list_head.lock); + return ret; +} +EXPORT_SYMBOL(qtee_shmbridge_register); + +/* Deregister bridge */ +int32_t qtee_shmbridge_deregister(uint64_t handle) +{ + int32_t ret = 0; + struct scm_desc desc = {0}; + + if (!qtee_shmbridge_enabled) + return 0; + + mutex_lock(&bridge_list_head.lock); + desc.arginfo = TZ_SHM_BRIDGE_DELETE_PARAM_ID; + desc.args[0] = handle; + ret = scm_call2(TZ_SHM_BRIDGE_DELETE, &desc); + if (ret) { + pr_err("Failed to del bridge %lld, ret = %d\n", handle, ret); + goto exit; + } + qtee_shmbridge_list_del_nolock(handle); + +exit: + mutex_unlock(&bridge_list_head.lock); + return ret; +} +EXPORT_SYMBOL(qtee_shmbridge_deregister); + + +/* Sub-allocate from default kernel bridge created by shmb driver */ +int32_t qtee_shmbridge_allocate_shm(size_t size, struct qtee_shm *shm) +{ + int32_t ret = 0; + unsigned long va; + + if (size > DEFAULT_BRIDGE_SIZE) { + pr_err("requestd size %zu is larger than bridge size %d\n", + size, DEFAULT_BRIDGE_SIZE); + ret = -EINVAL; + goto exit; + } + + if (IS_ERR_OR_NULL(shm)) { + pr_err("qtee_shm is NULL\n"); + ret = -EINVAL; + goto exit; + } + size = roundup(size, 1 << default_bridge.min_alloc_order); + + va = gen_pool_alloc(default_bridge.genpool, size); + if (!va) { + pr_err("failed to sub-allocate %zu bytes from bridge\n", size); + ret = -ENOMEM; + goto exit; + } + + memset((void *)va, 0, size); + shm->vaddr = (void *)va; + shm->paddr = gen_pool_virt_to_phys(default_bridge.genpool, va); + shm->size = size; + + pr_debug("%s: shm->paddr %llx, size %zu\n", + __func__, (uint64_t)shm->paddr, shm->size); + +exit: + return ret; +} +EXPORT_SYMBOL(qtee_shmbridge_allocate_shm); + + +/* Free buffer that is sub-allocated from default kernel bridge */ +void qtee_shmbridge_free_shm(struct qtee_shm *shm) +{ + if (IS_ERR_OR_NULL(shm) || !shm->vaddr) + return; + gen_pool_free(default_bridge.genpool, (unsigned long)shm->vaddr, + shm->size); +} +EXPORT_SYMBOL(qtee_shmbridge_free_shm); + +/* + * shared memory bridge initialization + * + */ +static int __init qtee_shmbridge_init(void) +{ + int ret = 0; + uint32_t ns_vm_ids[] = {VMID_HLOS}; + uint32_t ns_vm_perms[] = {VM_PERM_R|VM_PERM_W}; + + if (default_bridge.vaddr) { + pr_warn("qtee shmbridge is already initialized\n"); + return 0; + } + + /* allocate a contiguous page aligned buffer */ + default_bridge.size = DEFAULT_BRIDGE_SIZE; + default_bridge.vaddr = (void *)__get_free_pages(GFP_KERNEL|__GFP_COMP, + get_order(default_bridge.size)); + if (!default_bridge.vaddr) + return -ENOMEM; + default_bridge.paddr = virt_to_phys(default_bridge.vaddr); + + /* create a general mem pool */ + default_bridge.min_alloc_order = PAGE_SHIFT; /* 4K page size aligned */ + default_bridge.genpool = gen_pool_create( + default_bridge.min_alloc_order, -1); + if (!default_bridge.genpool) { + pr_err("gen_pool_add_virt() failed\n"); + ret = -ENOMEM; + goto exit_freebuf; + } + + gen_pool_set_algo(default_bridge.genpool, gen_pool_best_fit, NULL); + ret = gen_pool_add_virt(default_bridge.genpool, + (uintptr_t)default_bridge.vaddr, + default_bridge.paddr, default_bridge.size, -1); + if (ret) { + pr_err("gen_pool_add_virt() failed, ret = %d\n", ret); + goto exit_destroy_pool; + } + + mutex_init(&bridge_list_head.lock); + INIT_LIST_HEAD(&bridge_list_head.head); + + /* enable shm bridge mechanism */ + ret = qtee_shmbridge_enable(true); + if (ret) { + /* keep the mem pool and return if failed to enable bridge */ + ret = 0; + goto exit; + } + + /*register default bridge*/ + ret = qtee_shmbridge_register(default_bridge.paddr, + default_bridge.size, ns_vm_ids, + ns_vm_perms, 1, VM_PERM_R|VM_PERM_W, + &default_bridge.handle); + if (ret) { + pr_err("Failed to register default bridge, size %zu\n", + default_bridge.size); + goto exit; + } + + pr_debug("qtee shmbridge registered default bridge with size %d bytes\n", + DEFAULT_BRIDGE_SIZE); + + return 0; + +exit_destroy_pool: + gen_pool_destroy(default_bridge.genpool); +exit_freebuf: + free_pages((long)default_bridge.vaddr, get_order(default_bridge.size)); +exit: + return ret; +} + +early_initcall(qtee_shmbridge_init); diff --git a/include/soc/qcom/qseecomi.h b/include/soc/qcom/qseecomi.h new file mode 100644 index 000000000000..2e9025fc727e --- /dev/null +++ b/include/soc/qcom/qseecomi.h @@ -0,0 +1,723 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2013-2019, The Linux Foundation. All rights reserved. + */ + +#ifndef __QSEECOMI_H_ +#define __QSEECOMI_H_ + +#include + +#define QSEECOM_KEY_ID_SIZE 32 + +#define QSEOS_RESULT_FAIL_SEND_CMD_NO_THREAD -19 /*0xFFFFFFED*/ +#define QSEOS_RESULT_FAIL_UNSUPPORTED_CE_PIPE -63 +#define QSEOS_RESULT_FAIL_KS_OP -64 +#define QSEOS_RESULT_FAIL_KEY_ID_EXISTS -65 +#define QSEOS_RESULT_FAIL_MAX_KEYS -66 +#define QSEOS_RESULT_FAIL_SAVE_KS -67 +#define QSEOS_RESULT_FAIL_LOAD_KS -68 +#define QSEOS_RESULT_FAIL_KS_ALREADY_DONE -69 +#define QSEOS_RESULT_FAIL_KEY_ID_DNE -70 +#define QSEOS_RESULT_FAIL_INCORRECT_PSWD -71 +#define QSEOS_RESULT_FAIL_MAX_ATTEMPT -72 +#define QSEOS_RESULT_FAIL_PENDING_OPERATION -73 + +enum qseecom_command_scm_resp_type { + QSEOS_APP_ID = 0xEE01, + QSEOS_LISTENER_ID +}; + +enum qseecom_qceos_cmd_id { + QSEOS_APP_START_COMMAND = 0x01, + QSEOS_APP_SHUTDOWN_COMMAND, + QSEOS_APP_LOOKUP_COMMAND, + QSEOS_REGISTER_LISTENER, + QSEOS_DEREGISTER_LISTENER, + QSEOS_CLIENT_SEND_DATA_COMMAND, + QSEOS_LISTENER_DATA_RSP_COMMAND, + QSEOS_LOAD_EXTERNAL_ELF_COMMAND, + QSEOS_UNLOAD_EXTERNAL_ELF_COMMAND, + QSEOS_GET_APP_STATE_COMMAND, + QSEOS_LOAD_SERV_IMAGE_COMMAND, + QSEOS_UNLOAD_SERV_IMAGE_COMMAND, + QSEOS_APP_REGION_NOTIFICATION, + QSEOS_REGISTER_LOG_BUF_COMMAND, + QSEOS_RPMB_PROVISION_KEY_COMMAND, + QSEOS_RPMB_ERASE_COMMAND, + QSEOS_GENERATE_KEY = 0x11, + QSEOS_DELETE_KEY, + QSEOS_MAX_KEY_COUNT, + QSEOS_SET_KEY, + QSEOS_UPDATE_KEY_USERINFO, + QSEOS_TEE_OPEN_SESSION, + QSEOS_TEE_INVOKE_COMMAND, + QSEOS_TEE_INVOKE_MODFD_COMMAND = QSEOS_TEE_INVOKE_COMMAND, + QSEOS_TEE_CLOSE_SESSION, + QSEOS_TEE_REQUEST_CANCELLATION, + QSEOS_CONTINUE_BLOCKED_REQ_COMMAND, + QSEOS_RPMB_CHECK_PROV_STATUS_COMMAND = 0x1B, + QSEOS_CLIENT_SEND_DATA_COMMAND_WHITELIST = 0x1C, + QSEOS_TEE_OPEN_SESSION_WHITELIST = 0x1D, + QSEOS_TEE_INVOKE_COMMAND_WHITELIST = 0x1E, + QSEOS_LISTENER_DATA_RSP_COMMAND_WHITELIST = 0x1F, + QSEOS_FSM_LTEOTA_REQ_CMD = 0x109, + QSEOS_FSM_LTEOTA_REQ_RSP_CMD = 0x110, + QSEOS_FSM_IKE_REQ_CMD = 0x203, + QSEOS_FSM_IKE_REQ_RSP_CMD = 0x204, + QSEOS_FSM_OEM_FUSE_WRITE_ROW = 0x301, + QSEOS_FSM_OEM_FUSE_READ_ROW = 0x302, + QSEOS_FSM_ENCFS_REQ_CMD = 0x403, + QSEOS_FSM_ENCFS_REQ_RSP_CMD = 0x404, + + QSEOS_CMD_MAX = 0xEFFFFFFF +}; + +enum qseecom_qceos_cmd_status { + QSEOS_RESULT_SUCCESS = 0, + QSEOS_RESULT_INCOMPLETE, + QSEOS_RESULT_BLOCKED_ON_LISTENER, + QSEOS_RESULT_FAILURE = 0xFFFFFFFF +}; + +enum qseecom_pipe_type { + QSEOS_PIPE_ENC = 0x1, + QSEOS_PIPE_ENC_XTS = 0x2, + QSEOS_PIPE_AUTH = 0x4, + QSEOS_PIPE_ENUM_FILL = 0x7FFFFFFF +}; + +/* QSEE Reentrancy support phase */ +enum qseecom_qsee_reentrancy_phase { + QSEE_REENTRANCY_PHASE_0 = 0, + QSEE_REENTRANCY_PHASE_1, + QSEE_REENTRANCY_PHASE_2, + QSEE_REENTRANCY_PHASE_3, + QSEE_REENTRANCY_PHASE_MAX = 0xFF +}; + +struct qsee_apps_region_info_ireq { + uint32_t qsee_cmd_id; + uint32_t addr; + uint32_t size; +} __attribute__((__packed__)); + +struct qsee_apps_region_info_64bit_ireq { + uint32_t qsee_cmd_id; + uint64_t addr; + uint32_t size; +} __attribute__((__packed__)); + +struct qseecom_check_app_ireq { + uint32_t qsee_cmd_id; + char app_name[MAX_APP_NAME_SIZE]; +} __attribute__((__packed__)); + +struct qseecom_load_app_ireq { + uint32_t qsee_cmd_id; + uint32_t mdt_len; /* Length of the mdt file */ + uint32_t img_len; /* Length of .bxx and .mdt files */ + uint32_t phy_addr; /* phy addr of the start of image */ + char app_name[MAX_APP_NAME_SIZE]; /* application name*/ +} __attribute__((__packed__)); + +struct qseecom_load_app_64bit_ireq { + uint32_t qsee_cmd_id; + uint32_t mdt_len; + uint32_t img_len; + uint64_t phy_addr; + char app_name[MAX_APP_NAME_SIZE]; +} __attribute__((__packed__)); + +struct qseecom_unload_app_ireq { + uint32_t qsee_cmd_id; + uint32_t app_id; +} __attribute__((__packed__)); + +struct qseecom_load_lib_image_ireq { + uint32_t qsee_cmd_id; + uint32_t mdt_len; + uint32_t img_len; + uint32_t phy_addr; +} __attribute__((__packed__)); + +struct qseecom_load_lib_image_64bit_ireq { + uint32_t qsee_cmd_id; + uint32_t mdt_len; + uint32_t img_len; + uint64_t phy_addr; +} __attribute__((__packed__)); + +struct qseecom_unload_lib_image_ireq { + uint32_t qsee_cmd_id; +} __attribute__((__packed__)); + +struct qseecom_register_listener_ireq { + uint32_t qsee_cmd_id; + uint32_t listener_id; + uint32_t sb_ptr; + uint32_t sb_len; +} __attribute__((__packed__)); + +struct qseecom_register_listener_64bit_ireq { + uint32_t qsee_cmd_id; + uint32_t listener_id; + uint64_t sb_ptr; + uint32_t sb_len; +} __attribute__((__packed__)); + +struct qseecom_unregister_listener_ireq { + uint32_t qsee_cmd_id; + uint32_t listener_id; +} __attribute__((__packed__)); + +struct qseecom_client_send_data_ireq { + uint32_t qsee_cmd_id; + uint32_t app_id; + uint32_t req_ptr; + uint32_t req_len; + uint32_t rsp_ptr;/* First 4 bytes should be the return status */ + uint32_t rsp_len; + uint32_t sglistinfo_ptr; + uint32_t sglistinfo_len; +} __attribute__((__packed__)); + +struct qseecom_client_send_data_64bit_ireq { + uint32_t qsee_cmd_id; + uint32_t app_id; + uint64_t req_ptr; + uint32_t req_len; + uint64_t rsp_ptr; + uint32_t rsp_len; + uint64_t sglistinfo_ptr; + uint32_t sglistinfo_len; +} __attribute__((__packed__)); + +struct qseecom_reg_log_buf_ireq { + uint32_t qsee_cmd_id; + uint32_t phy_addr; + uint32_t len; +} __attribute__((__packed__)); + +struct qseecom_reg_log_buf_64bit_ireq { + uint32_t qsee_cmd_id; + uint64_t phy_addr; + uint32_t len; +} __attribute__((__packed__)); + +/* send_data resp */ +struct qseecom_client_listener_data_irsp { + uint32_t qsee_cmd_id; + uint32_t listener_id; + uint32_t status; + uint32_t sglistinfo_ptr; + uint32_t sglistinfo_len; +} __attribute__((__packed__)); + +struct qseecom_client_listener_data_64bit_irsp { + uint32_t qsee_cmd_id; + uint32_t listener_id; + uint32_t status; + uint64_t sglistinfo_ptr; + uint32_t sglistinfo_len; +} __attribute__((__packed__)); + +/* + * struct qseecom_command_scm_resp - qseecom response buffer + * @cmd_status: value from enum tz_sched_cmd_status + * @sb_in_rsp_addr: points to physical location of response + * buffer + * @sb_in_rsp_len: length of command response + */ +struct qseecom_command_scm_resp { + uint32_t result; + enum qseecom_command_scm_resp_type resp_type; + unsigned int data; +} __attribute__((__packed__)); + +struct qseecom_rpmb_provision_key { + uint32_t key_type; +}; + +struct qseecom_client_send_service_ireq { + uint32_t qsee_cmd_id; + uint32_t key_type; /* in */ + unsigned int req_len; /* in */ + uint32_t rsp_ptr; /* in/out */ + unsigned int rsp_len; /* in/out */ +} __attribute__((__packed__)); + +struct qseecom_client_send_service_64bit_ireq { + uint32_t qsee_cmd_id; + uint32_t key_type; + unsigned int req_len; + uint64_t rsp_ptr; + unsigned int rsp_len; +} __attribute__((__packed__)); + +struct qseecom_key_generate_ireq { + uint32_t qsee_command_id; + uint32_t flags; + uint8_t key_id[QSEECOM_KEY_ID_SIZE]; + uint8_t hash32[QSEECOM_HASH_SIZE]; +} __attribute__((__packed__)); + +struct qseecom_key_select_ireq { + uint32_t qsee_command_id; + uint32_t ce; + uint32_t pipe; + uint32_t pipe_type; + uint32_t flags; + uint8_t key_id[QSEECOM_KEY_ID_SIZE]; + uint8_t hash32[QSEECOM_HASH_SIZE]; +} __attribute__((__packed__)); + +struct qseecom_key_delete_ireq { + uint32_t qsee_command_id; + uint32_t flags; + uint8_t key_id[QSEECOM_KEY_ID_SIZE]; + uint8_t hash32[QSEECOM_HASH_SIZE]; + +} __attribute__((__packed__)); + +struct qseecom_key_userinfo_update_ireq { + uint32_t qsee_command_id; + uint32_t flags; + uint8_t key_id[QSEECOM_KEY_ID_SIZE]; + uint8_t current_hash32[QSEECOM_HASH_SIZE]; + uint8_t new_hash32[QSEECOM_HASH_SIZE]; +} __attribute__((__packed__)); + +struct qseecom_key_max_count_query_ireq { + uint32_t flags; +} __attribute__((__packed__)); + +struct qseecom_key_max_count_query_irsp { + uint32_t max_key_count; +} __attribute__((__packed__)); + +struct qseecom_qteec_ireq { + uint32_t qsee_cmd_id; + uint32_t app_id; + uint32_t req_ptr; + uint32_t req_len; + uint32_t resp_ptr; + uint32_t resp_len; + uint32_t sglistinfo_ptr; + uint32_t sglistinfo_len; +} __attribute__((__packed__)); + +struct qseecom_qteec_64bit_ireq { + uint32_t qsee_cmd_id; + uint32_t app_id; + uint64_t req_ptr; + uint32_t req_len; + uint64_t resp_ptr; + uint32_t resp_len; + uint64_t sglistinfo_ptr; + uint32_t sglistinfo_len; +} __attribute__((__packed__)); + +struct qseecom_client_send_fsm_key_req { + uint32_t qsee_cmd_id; + uint32_t req_ptr; + uint32_t req_len; + uint32_t rsp_ptr; + uint32_t rsp_len; +} __attribute__((__packed__)); + +struct qseecom_continue_blocked_request_ireq { + uint32_t qsee_cmd_id; + uint32_t app_or_session_id; /*legacy: app_id; smcinvoke: session_id*/ +} __attribute__((__packed__)); + +/********** ARMV8 SMC INTERFACE TZ MACRO *******************/ + +#define TZ_SVC_APP_MGR 1 /* Application management */ +#define TZ_SVC_LISTENER 2 /* Listener service management */ +#define TZ_SVC_EXTERNAL 3 /* External image loading */ +#define TZ_SVC_RPMB 4 /* RPMB */ +#define TZ_SVC_KEYSTORE 5 /* Keystore management */ +#define TZ_SVC_ES 16 /* Enterprise Security */ +#define TZ_SVC_MDTP 18 /* Mobile Device Theft */ + +/*---------------------------------------------------------------------------- + * Owning Entity IDs (defined by ARM SMC doc) + * --------------------------------------------------------------------------- + */ +#define TZ_OWNER_ARM 0 /** ARM Architecture call ID */ +#define TZ_OWNER_CPU 1 /** CPU service call ID */ +#define TZ_OWNER_SIP 2 /** SIP service call ID */ +#define TZ_OWNER_OEM 3 /** OEM service call ID */ +#define TZ_OWNER_STD 4 /** Standard service call ID */ + +/** Values 5-47 are reserved for future use */ + +/** Trusted Application call IDs */ +#define TZ_OWNER_TZ_APPS 48 +#define TZ_OWNER_TZ_APPS_RESERVED 49 +/** Trusted OS Call IDs */ +#define TZ_OWNER_QSEE_OS 50 +#define TZ_OWNER_MOBI_OS 51 +#define TZ_OWNER_OS_RESERVED_3 52 +#define TZ_OWNER_OS_RESERVED_4 53 +#define TZ_OWNER_OS_RESERVED_5 54 +#define TZ_OWNER_OS_RESERVED_6 55 +#define TZ_OWNER_OS_RESERVED_7 56 +#define TZ_OWNER_OS_RESERVED_8 57 +#define TZ_OWNER_OS_RESERVED_9 58 +#define TZ_OWNER_OS_RESERVED_10 59 +#define TZ_OWNER_OS_RESERVED_11 60 +#define TZ_OWNER_OS_RESERVED_12 61 +#define TZ_OWNER_OS_RESERVED_13 62 +#define TZ_OWNER_OS_RESERVED_14 63 + +#define TZ_SVC_INFO 6 /* Misc. information services */ + +/** Trusted Application call groups */ +#define TZ_SVC_APP_ID_PLACEHOLDER 0 /* SVC bits will contain App ID */ + +/** General helper macro to create a bitmask from bits low to high. */ +#define TZ_MASK_BITS(h, l) ((0xffffffff >> (32 - ((h - l) + 1))) << l) + +/* + * Macro used to define an SMC ID based on the owner ID, + * service ID, and function number. + */ +#define TZ_SYSCALL_CREATE_SMC_ID(o, s, f) \ + ((uint32_t)((((o & 0x3f) << 24) | (s & 0xff) << 8) | (f & 0xff))) + +#define TZ_SYSCALL_PARAM_NARGS_MASK TZ_MASK_BITS(3, 0) +#define TZ_SYSCALL_PARAM_TYPE_MASK TZ_MASK_BITS(1, 0) + +#define TZ_SYSCALL_CREATE_PARAM_ID(nargs, p1, p2, p3, \ + p4, p5, p6, p7, p8, p9, p10) \ + ((nargs&TZ_SYSCALL_PARAM_NARGS_MASK)+ \ + ((p1&TZ_SYSCALL_PARAM_TYPE_MASK)<<4)+ \ + ((p2&TZ_SYSCALL_PARAM_TYPE_MASK)<<6)+ \ + ((p3&TZ_SYSCALL_PARAM_TYPE_MASK)<<8)+ \ + ((p4&TZ_SYSCALL_PARAM_TYPE_MASK)<<10)+ \ + ((p5&TZ_SYSCALL_PARAM_TYPE_MASK)<<12)+ \ + ((p6&TZ_SYSCALL_PARAM_TYPE_MASK)<<14)+ \ + ((p7&TZ_SYSCALL_PARAM_TYPE_MASK)<<16)+ \ + ((p8&TZ_SYSCALL_PARAM_TYPE_MASK)<<18)+ \ + ((p9&TZ_SYSCALL_PARAM_TYPE_MASK)<<20)+ \ + ((p10&TZ_SYSCALL_PARAM_TYPE_MASK)<<22)) + +/* + * Macros used to create the Parameter ID associated with the syscall + */ +#define TZ_SYSCALL_CREATE_PARAM_ID_0 0 +#define TZ_SYSCALL_CREATE_PARAM_ID_1(p1) \ + TZ_SYSCALL_CREATE_PARAM_ID(1, p1, 0, 0, 0, 0, 0, 0, 0, 0, 0) +#define TZ_SYSCALL_CREATE_PARAM_ID_2(p1, p2) \ + TZ_SYSCALL_CREATE_PARAM_ID(2, p1, p2, 0, 0, 0, 0, 0, 0, 0, 0) +#define TZ_SYSCALL_CREATE_PARAM_ID_3(p1, p2, p3) \ + TZ_SYSCALL_CREATE_PARAM_ID(3, p1, p2, p3, 0, 0, 0, 0, 0, 0, 0) +#define TZ_SYSCALL_CREATE_PARAM_ID_4(p1, p2, p3, p4) \ + TZ_SYSCALL_CREATE_PARAM_ID(4, p1, p2, p3, p4, 0, 0, 0, 0, 0, 0) +#define TZ_SYSCALL_CREATE_PARAM_ID_5(p1, p2, p3, p4, p5) \ + TZ_SYSCALL_CREATE_PARAM_ID(5, p1, p2, p3, p4, p5, 0, 0, 0, 0, 0) +#define TZ_SYSCALL_CREATE_PARAM_ID_6(p1, p2, p3, p4, p5, p6) \ + TZ_SYSCALL_CREATE_PARAM_ID(6, p1, p2, p3, p4, p5, p6, 0, 0, 0, 0) +#define TZ_SYSCALL_CREATE_PARAM_ID_7(p1, p2, p3, p4, p5, p6, p7) \ + TZ_SYSCALL_CREATE_PARAM_ID(7, p1, p2, p3, p4, p5, p6, p7, 0, 0, 0) +#define TZ_SYSCALL_CREATE_PARAM_ID_8(p1, p2, p3, p4, p5, p6, p7, p8) \ + TZ_SYSCALL_CREATE_PARAM_ID(8, p1, p2, p3, p4, p5, p6, p7, p8, 0, 0) +#define TZ_SYSCALL_CREATE_PARAM_ID_9(p1, p2, p3, p4, p5, p6, p7, p8, p9) \ + TZ_SYSCALL_CREATE_PARAM_ID(9, p1, p2, p3, p4, p5, p6, p7, p8, p9, 0) +#define TZ_SYSCALL_CREATE_PARAM_ID_10(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) \ + TZ_SYSCALL_CREATE_PARAM_ID(10, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) + +/* + * Macro used to obtain the Parameter ID associated with the syscall + */ +#define TZ_SYSCALL_GET_PARAM_ID(CMD_ID) CMD_ID ## _PARAM_ID + +/** Helper macro to extract the owning entity from the SMC ID. */ +#define TZ_SYSCALL_OWNER_ID(r0) ((r0 & TZ_MASK_BITS(29, 24)) >> 24) + +/** Helper macro for checking whether an owning entity is of type trusted OS. */ +#define IS_OWNER_TRUSTED_OS(owner_id) \ + (((owner_id >= 50) && (owner_id <= 63)) ? 1:0) + +#define TZ_SYSCALL_PARAM_TYPE_VAL 0x0 /* type of value */ +#define TZ_SYSCALL_PARAM_TYPE_BUF_RO 0x1 /* type of buffer RO */ +#define TZ_SYSCALL_PARAM_TYPE_BUF_RW 0x2 /* type of buffer RW */ + +#define TZ_OS_APP_START_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_APP_MGR, 0x01) + +#define TZ_OS_APP_START_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_3( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_VAL, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_APP_SHUTDOWN_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_APP_MGR, 0x02) + +#define TZ_OS_APP_SHUTDOWN_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_1(TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_APP_LOOKUP_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_APP_MGR, 0x03) + +#define TZ_OS_APP_LOOKUP_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_2( \ + TZ_SYSCALL_PARAM_TYPE_BUF_RW, TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_APP_GET_STATE_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_APP_MGR, 0x04) + +#define TZ_OS_APP_GET_STATE_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_1(TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_APP_REGION_NOTIFICATION_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_APP_MGR, 0x05) + +#define TZ_OS_APP_REGION_NOTIFICATION_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_2( \ + TZ_SYSCALL_PARAM_TYPE_BUF_RW, TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_REGISTER_LOG_BUFFER_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_APP_MGR, 0x06) + +#define TZ_OS_REGISTER_LOG_BUFFER_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_2( \ + TZ_SYSCALL_PARAM_TYPE_BUF_RW, TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_LOAD_SERVICES_IMAGE_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_APP_MGR, 0x07) + +#define TZ_OS_LOAD_SERVICES_IMAGE_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_3( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_VAL, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_UNLOAD_SERVICES_IMAGE_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_APP_MGR, 0x08) + +#define TZ_OS_UNLOAD_SERVICES_IMAGE_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_0 + +#define TZ_OS_REGISTER_LISTENER_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_LISTENER, 0x01) + +#define TZ_OS_REGISTER_LISTENER_SMCINVOKE_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_LISTENER, 0x06) + +#define TZ_OS_REGISTER_LISTENER_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_3( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_DEREGISTER_LISTENER_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_LISTENER, 0x02) + +#define TZ_OS_DEREGISTER_LISTENER_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_1(TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_LISTENER_RESPONSE_HANDLER_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_LISTENER, 0x03) + +#define TZ_OS_LISTENER_RESPONSE_HANDLER_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_2( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_LOAD_EXTERNAL_IMAGE_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_EXTERNAL, 0x01) + +#define TZ_OS_LOAD_EXTERNAL_IMAGE_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_3( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_VAL, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_APP_QSAPP_SEND_DATA_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_TZ_APPS, \ + TZ_SVC_APP_ID_PLACEHOLDER, 0x01) + + +#define TZ_APP_QSAPP_SEND_DATA_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_5( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_UNLOAD_EXTERNAL_IMAGE_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_EXTERNAL, 0x02) + +#define TZ_OS_UNLOAD_EXTERNAL_IMAGE_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_0 + +#define TZ_INFO_IS_SVC_AVAILABLE_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_SIP, TZ_SVC_INFO, 0x01) + +#define TZ_INFO_IS_SVC_AVAILABLE_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_1(TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_INFO_GET_FEATURE_VERSION_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_SIP, TZ_SVC_INFO, 0x03) + +#define TZ_INFO_GET_FEATURE_VERSION_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_1(TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_RPMB_PROVISION_KEY_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_RPMB, 0x01) + +#define TZ_OS_RPMB_PROVISION_KEY_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_1(TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_RPMB_ERASE_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_RPMB, 0x02) + +#define TZ_OS_RPMB_ERASE_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_0 + +#define TZ_OS_RPMB_CHECK_PROV_STATUS_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_RPMB, 0x03) + +#define TZ_OS_RPMB_CHECK_PROV_STATUS_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_0 + +#define TZ_OS_KS_GEN_KEY_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_KEYSTORE, 0x01) + +#define TZ_OS_KS_GEN_KEY_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_2( \ + TZ_SYSCALL_PARAM_TYPE_BUF_RW, TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_KS_DEL_KEY_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_KEYSTORE, 0x02) + +#define TZ_OS_KS_DEL_KEY_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_2( \ + TZ_SYSCALL_PARAM_TYPE_BUF_RW, TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_KS_GET_MAX_KEYS_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_KEYSTORE, 0x03) + +#define TZ_OS_KS_GET_MAX_KEYS_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_1(TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_KS_SET_PIPE_KEY_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_KEYSTORE, 0x04) + +#define TZ_OS_KS_SET_PIPE_KEY_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_2( \ + TZ_SYSCALL_PARAM_TYPE_BUF_RW, TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_KS_UPDATE_KEY_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_KEYSTORE, 0x05) + +#define TZ_OS_KS_UPDATE_KEY_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_2( \ + TZ_SYSCALL_PARAM_TYPE_BUF_RW, TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_ES_SAVE_PARTITION_HASH_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_SIP, TZ_SVC_ES, 0x01) + +#define TZ_ES_SAVE_PARTITION_HASH_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_3( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_APP_GPAPP_OPEN_SESSION_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_TZ_APPS, \ + TZ_SVC_APP_ID_PLACEHOLDER, 0x02) + +#define TZ_APP_GPAPP_OPEN_SESSION_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_5( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_APP_GPAPP_CLOSE_SESSION_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_TZ_APPS, \ + TZ_SVC_APP_ID_PLACEHOLDER, 0x03) + +#define TZ_APP_GPAPP_CLOSE_SESSION_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_5( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_APP_GPAPP_INVOKE_COMMAND_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_TZ_APPS, \ + TZ_SVC_APP_ID_PLACEHOLDER, 0x04) + +#define TZ_APP_GPAPP_INVOKE_COMMAND_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_5( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_APP_GPAPP_REQUEST_CANCELLATION_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_TZ_APPS, \ + TZ_SVC_APP_ID_PLACEHOLDER, 0x05) + +#define TZ_APP_GPAPP_REQUEST_CANCELLATION_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_5( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_MDTP_CIPHER_DIP_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_SIP, TZ_SVC_MDTP, 0x1) + +#define TZ_MDTP_CIPHER_DIP_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_5( \ + TZ_SYSCALL_PARAM_TYPE_BUF_RO, TZ_SYSCALL_PARAM_TYPE_VAL, \ + TZ_SYSCALL_PARAM_TYPE_BUF_RW, TZ_SYSCALL_PARAM_TYPE_VAL, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_CONTINUE_BLOCKED_REQUEST_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_LISTENER, 0x04) + +#define TZ_OS_CONTINUE_BLOCKED_REQUEST_SMCINVOKE_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_LISTENER, 0x07) + +#define TZ_OS_CONTINUE_BLOCKED_REQUEST_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_1(TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_APP_QSAPP_SEND_DATA_WITH_WHITELIST_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_TZ_APPS, \ + TZ_SVC_APP_ID_PLACEHOLDER, 0x06) + +#define TZ_APP_QSAPP_SEND_DATA_WITH_WHITELIST_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_7( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_APP_GPAPP_OPEN_SESSION_WITH_WHITELIST_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_TZ_APPS, \ + TZ_SVC_APP_ID_PLACEHOLDER, 0x07) + +#define TZ_APP_GPAPP_OPEN_SESSION_WITH_WHITELIST_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_7( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_APP_GPAPP_INVOKE_COMMAND_WITH_WHITELIST_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_TZ_APPS, \ + TZ_SVC_APP_ID_PLACEHOLDER, 0x09) + +#define TZ_APP_GPAPP_INVOKE_COMMAND_WITH_WHITELIST_ID_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_7( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#define TZ_OS_LISTENER_RESPONSE_HANDLER_WITH_WHITELIST_ID \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_QSEE_OS, TZ_SVC_LISTENER, 0x05) + +#define TZ_OS_LISTENER_RESPONSE_HANDLER_WITH_WHITELIST_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_4( \ + TZ_SYSCALL_PARAM_TYPE_VAL, TZ_SYSCALL_PARAM_TYPE_VAL, \ + TZ_SYSCALL_PARAM_TYPE_BUF_RW, TZ_SYSCALL_PARAM_TYPE_VAL) + +#endif /* __QSEECOMI_H_ */ diff --git a/include/soc/qcom/qtee_shmbridge.h b/include/soc/qcom/qtee_shmbridge.h new file mode 100644 index 000000000000..ee12264ad5eb --- /dev/null +++ b/include/soc/qcom/qtee_shmbridge.h @@ -0,0 +1,90 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2019, The Linux Foundation. All rights reserved. + */ + +#ifndef __QTEE_SHMBRIDGE_H__ +#define __QTEE_SHMBRIDGE_H__ + +/* VMID and permission definitions */ +#include + +/** + * struct qtee_shm - info of shared memory allocated from the default bridge + * @ paddr: physical address of the shm allocated from the default bridge + * @ vaddr: virtual address of the shm + * @ size: size of the shm + */ +struct qtee_shm { + phys_addr_t paddr; + void *vaddr; + size_t size; +}; + +/** + * Check whether shmbridge mechanism is enabled in HYP or not + * + * return true when enabled, false when not enabled + */ +bool qtee_shmbridge_is_enabled(void); + +/** + * Check whether a bridge starting from paddr exists + * + * @ [IN] paddr: physical addr of the buffer + * + * return 0 or -EEXIST + */ +int32_t qtee_shmbridge_query(phys_addr_t paddr); + +/** + * Register paddr & size as a bridge, get bridge handle + * + * @ [IN] paddr: physical addr of the buffer to be turned into bridge + * @ [IN] size: size of the bridge + * @ [IN] ns_vmid_list: non-secure vmids array + * @ [IN] ns_vm_perm_list: NS VM permission array + * @ [IN] ns_vmid_num: number of NS VMIDs (at most 4) + * @ [IN] tz_perm: TZ permission + * @ [OUT] *handle: output shmbridge handle + * + * return success or error + */ +int32_t qtee_shmbridge_register( + phys_addr_t paddr, + size_t size, + uint32_t *ns_vmid_list, + uint32_t *ns_vm_perm_list, + uint32_t ns_vmid_num, + uint32_t tz_perm, + uint64_t *handle); + +/** + * Deregister bridge + * + * @ [IN] handle: shmbridge handle + * + * return success or error + */ +int32_t qtee_shmbridge_deregister(uint64_t handle); + +/** + * Sub-allocate from default kernel bridge created by shmb driver + * + * @ [IN] size: size of the buffer to be sub-allocated from the bridge + * @ [OUT] *shm: output qtee_shm structure with buffer paddr, vaddr and + * size; returns ERR_PTR or NULL otherwise + * + * return success or error + */ +int32_t qtee_shmbridge_allocate_shm(size_t size, struct qtee_shm *shm); + +/* + * Free buffer that is sub-allocated from default kernel bridge + * + * @ [IN] shm: qtee_shm structure to be freed + * + */ +void qtee_shmbridge_free_shm(struct qtee_shm *shm); + +#endif /*__QTEE_SHMBRIDGE_H__*/