diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig index e5cfb01353d8..4dc973176f3f 100644 --- a/drivers/firmware/Kconfig +++ b/drivers/firmware/Kconfig @@ -217,6 +217,17 @@ config QCOM_SCM_DOWNLOAD_MODE_DEFAULT Say Y here to enable "download mode" by default. +config QTEE_SHM_BRIDGE + bool "QTI TEE shared memory bridge" + depends on QCOM_SCM + default y if QCOM_SCM + 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. + config SYSFB bool default y diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile index 4e58cb474a68..d4022185b83c 100644 --- a/drivers/firmware/Makefile +++ b/drivers/firmware/Makefile @@ -18,7 +18,8 @@ obj-$(CONFIG_FIRMWARE_MEMMAP) += memmap.o obj-$(CONFIG_RASPBERRYPI_FIRMWARE) += raspberrypi.o obj-$(CONFIG_FW_CFG_SYSFS) += qemu_fw_cfg.o obj-$(CONFIG_QCOM_SCM) += qcom-scm.o -qcom-scm-objs += qcom_scm.o qcom_scm-smc.o qcom_scm-legacy.o +qcom-scm-objs-$(CONFIG_QTEE_SHM_BRIDGE) += qtee_shmbridge.o +qcom-scm-objs += qcom_scm.o qcom_scm-smc.o qcom_scm-legacy.o $(qcom-scm-objs-y) obj-$(CONFIG_SYSFB) += sysfb.o obj-$(CONFIG_SYSFB_SIMPLEFB) += sysfb_simplefb.o obj-$(CONFIG_TI_SCI_PROTOCOL) += ti_sci.o diff --git a/drivers/firmware/qtee_shmbridge.c b/drivers/firmware/qtee_shmbridge.c new file mode 100644 index 000000000000..6ce7d8d1a6bb --- /dev/null +++ b/drivers/firmware/qtee_shmbridge.c @@ -0,0 +1,517 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * QTI TEE shared memory bridge driver + * + * Copyright (c) 2021, The Linux Foundation. All rights reserved. + * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "qtee_shmbridge_internal.h" + +#define DEFAULT_BRIDGE_SIZE SZ_4M /*4M*/ +#define MIN_BRIDGE_SIZE SZ_4K /*4K*/ + +#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 */ + +#define AC_ERR_SHARED_MEMORY_SINGLE_SOURCE 15 + +/* 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 device *dev; +}; + +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; +}; + +struct cma_heap_bridge_info { + uint32_t heapid; + uint64_t handle; +}; + +enum CMA_HEAP_TYPE { + QSEECOM_HEAP = 0, + QSEECOM_TA_HEAP, + USER_CONTI_HEAP, + HEAP_TYPE_MAX +}; + +static struct bridge_info default_bridge; +static struct bridge_list bridge_list_head; +static bool qtee_shmbridge_enabled; +static bool support_hyp; + +/* enable shared memory bridge mechanism in HYP */ +static int32_t qtee_shmbridge_enable(bool enable) +{ + int32_t ret = 0; + + qtee_shmbridge_enabled = false; + if (!enable) { + pr_warn("shmbridge isn't enabled\n"); + return ret; + } + + ret = qcom_scm_enable_shm_bridge(); + + if (ret) { + pr_err("Failed to enable shmbridge, ret = %d\n", ret); + + if (ret == -EIO || ret == SHMBRIDGE_E_NOT_SUPPORTED) + pr_warn("shmbridge is not supported by this target\n"); + return ret; + } + 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 pfn_and_ns_perm_flags = 0; + uint64_t ipfn_and_s_perm_flags = 0; + uint64_t size_and_flags = 0; + uint64_t ns_perms = 0; + uint64_t ns_vmids = 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]); + } + + pfn_and_ns_perm_flags = UPDATE_PFN_AND_NS_PERM_FLAGS(paddr, ns_perms); + ipfn_and_s_perm_flags = UPDATE_IPFN_AND_S_PERM_FLAGS(paddr, tz_perm); + size_and_flags = UPDATE_SIZE_AND_FLAGS(size, ns_vmid_num); + + if (support_hyp) { + size_and_flags |= SELF_OWNER_BIT << 1; + size_and_flags |= (VM_PERM_R | VM_PERM_W) << 2; + } + + pr_debug("%s: desc.args[0] %llx, args[1] %llx, args[2] %llx, args[3] %llx\n", + __func__, pfn_and_ns_perm_flags, ipfn_and_s_perm_flags, + size_and_flags, ns_vmids); + + ret = qcom_scm_create_shm_bridge(pfn_and_ns_perm_flags, + ipfn_and_s_perm_flags, size_and_flags, ns_vmids, + handle); + + if (ret) { + pr_err("create shmbridge failed, ret = %d\n", ret); + if (ret == AC_ERR_SHARED_MEMORY_SINGLE_SOURCE) + ret = -EEXIST; + else + ret = -EINVAL; + goto exit; + } + + 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; + + if (!qtee_shmbridge_enabled) + return 0; + + mutex_lock(&bridge_list_head.lock); + + ret = qcom_scm_delete_shm_bridge(handle); + + 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 (IS_ERR_OR_NULL(shm)) { + pr_err("qtee_shm is NULL\n"); + ret = -EINVAL; + goto exit; + } + + 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; + } + + 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); + +/* cache clean operation for buffer sub-allocated from default bridge */ +void qtee_shmbridge_flush_shm_buf(struct qtee_shm *shm) +{ + if (shm) + return dma_sync_single_for_device(default_bridge.dev, + shm->paddr, shm->size, DMA_TO_DEVICE); +} +EXPORT_SYMBOL(qtee_shmbridge_flush_shm_buf); + +/* cache invalidation operation for buffer sub-allocated from default bridge */ +void qtee_shmbridge_inv_shm_buf(struct qtee_shm *shm) +{ + if (shm) + return dma_sync_single_for_cpu(default_bridge.dev, + shm->paddr, shm->size, DMA_FROM_DEVICE); +} +EXPORT_SYMBOL(qtee_shmbridge_inv_shm_buf); + +/* + * shared memory bridge initialization + * + */ +static int qtee_shmbridge_init(struct platform_device *pdev) +{ + int ret = 0; + uint32_t custom_bridge_size; + uint32_t *ns_vm_ids; + uint32_t ns_vm_ids_hlos[] = {VMID_HLOS}; + uint32_t ns_vm_ids_hyp[] = {}; + uint32_t ns_vm_perms[] = {VM_PERM_R|VM_PERM_W}; + int mem_protection_enabled = 0; + + support_hyp = of_property_read_bool((&pdev->dev)->of_node, + "qcom,support-hypervisor"); + if (support_hyp) + ns_vm_ids = ns_vm_ids_hyp; + else + ns_vm_ids = ns_vm_ids_hlos; + + if (default_bridge.vaddr) { + pr_err("qtee shmbridge is already initialized\n"); + return 0; + } + + ret = of_property_read_u32((&pdev->dev)->of_node, + "qcom,custom-bridge-size", &custom_bridge_size); + if (ret) + default_bridge.size = DEFAULT_BRIDGE_SIZE; + else + default_bridge.size = custom_bridge_size * MIN_BRIDGE_SIZE; + + pr_err("qtee shmbridge registered default bridge with size %d bytes\n", + 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 = dma_map_single(&pdev->dev, + default_bridge.vaddr, default_bridge.size, + DMA_TO_DEVICE); + if (dma_mapping_error(&pdev->dev, default_bridge.paddr)) { + pr_err("dma_map_single() failed\n"); + ret = -ENOMEM; + goto exit_freebuf; + } + default_bridge.dev = &pdev->dev; + + /* 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_unmap; + } + + 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); + + /* temporarily disable 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*/ + if (support_hyp) + ret = qtee_shmbridge_register(default_bridge.paddr, + default_bridge.size, ns_vm_ids, + ns_vm_perms, 0, VM_PERM_R|VM_PERM_W, + &default_bridge.handle); + else + 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_deregister_default_bridge; + } + + pr_debug("qtee shmbridge registered default bridge with size %d bytes\n", + default_bridge.size); + + mem_protection_enabled = scm_mem_protection_init_do(); + pr_err("MEM protection %s, %d\n", + (!mem_protection_enabled ? "Enabled" : "Not enabled"), + mem_protection_enabled); + return 0; + +exit_deregister_default_bridge: + qtee_shmbridge_deregister(default_bridge.handle); + qtee_shmbridge_enable(false); +exit_destroy_pool: + gen_pool_destroy(default_bridge.genpool); +exit_unmap: + dma_unmap_single(&pdev->dev, default_bridge.paddr, default_bridge.size, + DMA_TO_DEVICE); +exit_freebuf: + free_pages((long)default_bridge.vaddr, get_order(default_bridge.size)); + default_bridge.vaddr = NULL; +exit: + return ret; +} + +static int qtee_shmbridge_probe(struct platform_device *pdev) +{ +#ifdef CONFIG_ARM64 + dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)); +#endif + return qtee_shmbridge_init(pdev); +} + +static int qtee_shmbridge_remove(struct platform_device *pdev) +{ + qtee_shmbridge_deregister(default_bridge.handle); + gen_pool_destroy(default_bridge.genpool); + dma_unmap_single(&pdev->dev, default_bridge.paddr, default_bridge.size, + DMA_TO_DEVICE); + free_pages((long)default_bridge.vaddr, get_order(default_bridge.size)); + return 0; +} + +static const struct of_device_id qtee_shmbridge_of_match[] = { + { .compatible = "qcom,tee-shared-memory-bridge"}, + {} +}; +MODULE_DEVICE_TABLE(of, qtee_shmbridge_of_match); + +static struct platform_driver qtee_shmbridge_driver = { + .probe = qtee_shmbridge_probe, + .remove = qtee_shmbridge_remove, + .driver = { + .name = "shared_memory_bridge", + .of_match_table = qtee_shmbridge_of_match, + }, +}; + +int __init qtee_shmbridge_driver_init(void) +{ + return platform_driver_register(&qtee_shmbridge_driver); +} + +void __exit qtee_shmbridge_driver_exit(void) +{ + platform_driver_unregister(&qtee_shmbridge_driver); +} diff --git a/drivers/firmware/qtee_shmbridge_internal.h b/drivers/firmware/qtee_shmbridge_internal.h new file mode 100644 index 000000000000..4337fdf2b1eb --- /dev/null +++ b/drivers/firmware/qtee_shmbridge_internal.h @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* Copyright (c) 2019 The Linux Foundation. All rights reserved. + * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved. + */ +#ifndef __QCOM_QTEE_SHM_BRIDGE_INT_H_ +#define __QCOM_QTEE_SHM_BRIDGE_INT_H_ + +int __init qtee_shmbridge_driver_init(void); +void __exit qtee_shmbridge_driver_exit(void); + +#define SCM_SVC_RTIC 0x19 +#define TZ_HLOS_NOTIFY_CORE_KERNEL_BOOTUP 0x7 +int scm_mem_protection_init_do(void); +#endif diff --git a/include/linux/qtee_shmbridge.h b/include/linux/qtee_shmbridge.h new file mode 100644 index 000000000000..9a4972c1c893 --- /dev/null +++ b/include/linux/qtee_shmbridge.h @@ -0,0 +1,113 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2019, 2021 The Linux Foundation. All rights reserved. + * Copyright (c) 2022 Qualcomm Innovation Center, Inc. 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 + * + * Note: This will allocate a cached buffer, so after a client allocates + * a bridge buffer, it need to first flush cache with + * "qtee_shmbridge_flush_shm_buf" before invoke scm_call to TZ, + * and then invalidate cache with "qtee_shmbridge_inv_shm_buf" + * after scm_call return. + */ +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); + +/* + * cache clean operation for buffer sub-allocated from default bridge + * + * @ [IN] shm: qtee_shm, its cache to be cleaned + * + */ +void qtee_shmbridge_flush_shm_buf(struct qtee_shm *shm); + +/* + * cache invalidation operation for buffer sub-allocated from default bridge + * + * @ [IN] shm: qtee_shm, its cache to be invalidated + * + */ +void qtee_shmbridge_inv_shm_buf(struct qtee_shm *shm); + +#endif /*__QTEE_SHMBRIDGE_H__*/ diff --git a/include/soc/qcom/qseecomi.h b/include/soc/qcom/qseecomi.h new file mode 100644 index 000000000000..c9d702ea64bd --- /dev/null +++ b/include/soc/qcom/qseecomi.h @@ -0,0 +1,739 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2013-2021, The Linux Foundation. All rights reserved. + * Copyright (c) 2022 Qualcomm Innovation Center, Inc. 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 + +#define SMCINVOKE_RESULT_INBOUND_REQ_NEEDED 3 + +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_DIAG_FUSE_REQ_CMD = 0x501, + QSEOS_DIAG_FUSE_REQ_RSP_CMD = 0x502, + QSEOS_CMD_MAX = 0xEFFFFFFF +}; + +enum qseecom_qceos_cmd_status { + QSEOS_RESULT_SUCCESS = 0, + QSEOS_RESULT_INCOMPLETE, + QSEOS_RESULT_BLOCKED_ON_LISTENER, + QSEOS_RESULT_CBACK_REQUEST, + 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; +} __packed; + +struct qsee_apps_region_info_64bit_ireq { + uint32_t qsee_cmd_id; + uint64_t addr; + uint32_t size; +} __packed; + +struct qseecom_check_app_ireq { + uint32_t qsee_cmd_id; + char app_name[MAX_APP_NAME_SIZE]; +} __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*/ +} __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]; +} __packed; + +struct qseecom_unload_app_ireq { + uint32_t qsee_cmd_id; + uint32_t app_id; +} __packed; + +struct qseecom_load_lib_image_ireq { + uint32_t qsee_cmd_id; + uint32_t mdt_len; + uint32_t img_len; + uint32_t phy_addr; +} __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; +} __packed; + +struct qseecom_unload_lib_image_ireq { + uint32_t qsee_cmd_id; +} __packed; + +struct qseecom_register_listener_ireq { + uint32_t qsee_cmd_id; + uint32_t listener_id; + uint32_t sb_ptr; + uint32_t sb_len; +} __packed; + +struct qseecom_register_listener_64bit_ireq { + uint32_t qsee_cmd_id; + uint32_t listener_id; + uint64_t sb_ptr; + uint32_t sb_len; +} __packed; + +struct qseecom_unregister_listener_ireq { + uint32_t qsee_cmd_id; + uint32_t listener_id; +} __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; +} __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; +} __packed; + +struct qseecom_reg_log_buf_ireq { + uint32_t qsee_cmd_id; + uint32_t phy_addr; + uint32_t len; +} __packed; + +struct qseecom_reg_log_buf_64bit_ireq { + uint32_t qsee_cmd_id; + uint64_t phy_addr; + uint32_t len; +} __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; +} __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; +} __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; +} __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 */ +} __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; +} __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]; +} __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]; +} __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]; + +} __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]; +} __packed; + +struct qseecom_key_max_count_query_ireq { + uint32_t flags; +} __packed; + +struct qseecom_key_max_count_query_irsp { + uint32_t max_key_count; +} __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; +} __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; +} __packed; + +struct qseecom_client_send_fsm_diag_req { + uint32_t qsee_cmd_id; + uint32_t req_ptr; + uint32_t req_len; + uint32_t rsp_ptr; + uint32_t rsp_len; +} __packed; + +struct qseecom_continue_blocked_request_ireq { + uint32_t qsee_cmd_id; + uint32_t app_or_session_id; /*legacy: app_id; smcinvoke: session_id*/ +} __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_FUSE 8 /* Fuse services */ +#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_SECBOOT_GET_FUSE_INFO \ + TZ_SYSCALL_CREATE_SMC_ID(TZ_OWNER_SIP, TZ_SVC_FUSE, 0x09) + +#define TZ_SECBOOT_GET_FUSE_INFO_PARAM_ID \ + TZ_SYSCALL_CREATE_PARAM_ID_4(\ + TZ_SYSCALL_PARAM_TYPE_BUF_RO, \ + TZ_SYSCALL_PARAM_TYPE_VAL, \ + TZ_SYSCALL_PARAM_TYPE_BUF_RW, \ + TZ_SYSCALL_PARAM_TYPE_VAL) + +#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/uapi/linux/qseecom.h b/include/uapi/linux/qseecom.h new file mode 100644 index 000000000000..7237f47419bb --- /dev/null +++ b/include/uapi/linux/qseecom.h @@ -0,0 +1,414 @@ +/* SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note */ +/* + * Copyright (c) 2017, 2019, 2021, The Linux Foundation. All rights reserved. + * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved. + */ + +#ifndef _QSEECOM_H_ +#define _QSEECOM_H_ + +#include +#include + +#define MAX_ION_FD 4 +#define MAX_APP_NAME_SIZE 64 +#define QSEECOM_HASH_SIZE 32 + +/* qseecom_ta_heap allocation retry delay (ms) and max attempt count */ +#define QSEECOM_TA_ION_ALLOCATE_DELAY 50 +#define QSEECOM_TA_ION_ALLOCATE_MAX_ATTEMP 20 + +#define ICE_KEY_SIZE 32 +#define ICE_SALT_SIZE 32 + +/* + * struct qseecom_register_listener_req - + * for register listener ioctl request + * @listener_id - service id (shared between userspace and QSE) + * @ifd_data_fd - ion handle + * @virt_sb_base - shared buffer base in user space + * @sb_size - shared buffer size + */ +struct qseecom_register_listener_req { + __u32 listener_id; /* in */ + __s32 ifd_data_fd; /* in */ + void *virt_sb_base; /* in */ + __u32 sb_size; /* in */ +}; + +/* + * struct qseecom_send_cmd_req - for send command ioctl request + * @cmd_req_len - command buffer length + * @cmd_req_buf - command buffer + * @resp_len - response buffer length + * @resp_buf - response buffer + */ +struct qseecom_send_cmd_req { + void *cmd_req_buf; /* in */ + unsigned int cmd_req_len; /* in */ + void *resp_buf; /* in/out */ + unsigned int resp_len; /* in/out */ +}; + +/* + * struct qseecom_ion_fd_info - ion fd handle data information + * @fd - ion handle to some memory allocated in user space + * @cmd_buf_offset - command buffer offset + */ +struct qseecom_ion_fd_info { + __s32 fd; + __u32 cmd_buf_offset; +}; +/* + * struct qseecom_send_modfd_cmd_req - for send command ioctl request + * @cmd_req_len - command buffer length + * @cmd_req_buf - command buffer + * @resp_len - response buffer length + * @resp_buf - response buffer + * @ifd_data_fd - ion handle to memory allocated in user space + * @cmd_buf_offset - command buffer offset + */ +struct qseecom_send_modfd_cmd_req { + void *cmd_req_buf; /* in */ + unsigned int cmd_req_len; /* in */ + void *resp_buf; /* in/out */ + unsigned int resp_len; /* in/out */ + struct qseecom_ion_fd_info ifd_data[MAX_ION_FD]; +}; + +/* + * struct qseecom_listener_send_resp_req - signal to continue the send_cmd req. + * Used as a trigger from HLOS service to notify QSEECOM that it's done with its + * operation and provide the response for QSEECOM can continue the incomplete + * command execution + * @resp_len - Length of the response + * @resp_buf - Response buffer where the response of the cmd should go. + */ +struct qseecom_send_resp_req { + void *resp_buf; /* in */ + unsigned int resp_len; /* in */ +}; + +/* + * struct qseecom_load_img_data - for sending image length information and + * ion file descriptor to the qseecom driver. ion file descriptor is used + * for retrieving the ion file handle and in turn the physical address of + * the image location. + * @mdt_len - Length of the .mdt file in bytes. + * @img_len - Length of the .mdt + .b00 +..+.bxx images files in bytes + * @ion_fd - Ion file descriptor used when allocating memory. + * @img_name - Name of the image. + * @app_arch - Architecture of the image, i.e. 32bit or 64bit app + */ +struct qseecom_load_img_req { + __u32 mdt_len; /* in */ + __u32 img_len; /* in */ + __s32 ifd_data_fd; /* in */ + char img_name[MAX_APP_NAME_SIZE]; /* in */ + __u32 app_arch; /* in */ + __u32 app_id; /* out*/ +}; + +struct qseecom_set_sb_mem_param_req { + __s32 ifd_data_fd; /* in */ + void *virt_sb_base; /* in */ + __u32 sb_len; /* in */ +}; + +/* + * struct qseecom_qseos_version_req - get qseos version + * @qseos_version - version number + */ +struct qseecom_qseos_version_req { + unsigned int qseos_version; /* in */ +}; + +/* + * struct qseecom_qseos_app_load_query - verify if app is loaded in qsee + * @app_name[MAX_APP_NAME_SIZE]- name of the app. + * @app_id - app id. + */ +struct qseecom_qseos_app_load_query { + char app_name[MAX_APP_NAME_SIZE]; /* in */ + __u32 app_id; /* out */ + __u32 app_arch; +}; + +struct qseecom_send_svc_cmd_req { + __u32 cmd_id; + void *cmd_req_buf; /* in */ + unsigned int cmd_req_len; /* in */ + void *resp_buf; /* in/out */ + unsigned int resp_len; /* in/out */ +}; + +enum qseecom_key_management_usage_type { + QSEOS_KM_USAGE_DISK_ENCRYPTION = 0x01, + QSEOS_KM_USAGE_FILE_ENCRYPTION = 0x02, + QSEOS_KM_USAGE_UFS_ICE_DISK_ENCRYPTION = 0x03, + QSEOS_KM_USAGE_SDCC_ICE_DISK_ENCRYPTION = 0x04, + QSEOS_KM_USAGE_MAX +}; + +struct qseecom_create_key_req { + unsigned char hash32[QSEECOM_HASH_SIZE]; + enum qseecom_key_management_usage_type usage; +}; + +struct qseecom_wipe_key_req { + enum qseecom_key_management_usage_type usage; + int wipe_key_flag;/* 1->remove key from storage(alone with clear key) */ + /* 0->do not remove from storage (clear key) */ +}; + +struct qseecom_update_key_userinfo_req { + unsigned char current_hash32[QSEECOM_HASH_SIZE]; + unsigned char new_hash32[QSEECOM_HASH_SIZE]; + enum qseecom_key_management_usage_type usage; +}; + +#define SHA256_DIGEST_LENGTH (256/8) +/* + * struct qseecom_save_partition_hash_req + * @partition_id - partition id. + * @hash[SHA256_DIGEST_LENGTH] - sha256 digest. + */ +struct qseecom_save_partition_hash_req { + int partition_id; /* in */ + char digest[SHA256_DIGEST_LENGTH]; /* in */ +}; + +/* + * struct qseecom_is_es_activated_req + * @is_activated - 1=true , 0=false + */ +struct qseecom_is_es_activated_req { + int is_activated; /* out */ +}; + +/* + * struct qseecom_mdtp_cipher_dip_req + * @in_buf - input buffer + * @in_buf_size - input buffer size + * @out_buf - output buffer + * @out_buf_size - output buffer size + * @direction - 0=encrypt, 1=decrypt + */ +struct qseecom_mdtp_cipher_dip_req { + __u8 *in_buf; + __u32 in_buf_size; + __u8 *out_buf; + __u32 out_buf_size; + __u32 direction; +}; + +enum qseecom_bandwidth_request_mode { + INACTIVE = 0, + LOW, + MEDIUM, + HIGH, +}; + +/* + * struct qseecom_send_modfd_resp - for send command ioctl request + * @req_len - command buffer length + * @req_buf - command buffer + * @ifd_data_fd - ion handle to memory allocated in user space + * @cmd_buf_offset - command buffer offset + */ +struct qseecom_send_modfd_listener_resp { + void *resp_buf_ptr; /* in */ + unsigned int resp_len; /* in */ + struct qseecom_ion_fd_info ifd_data[MAX_ION_FD]; /* in */ +}; + +struct qseecom_qteec_req { + void *req_ptr; + __u32 req_len; + void *resp_ptr; + __u32 resp_len; +}; + +struct qseecom_qteec_modfd_req { + void *req_ptr; + __u32 req_len; + void *resp_ptr; + __u32 resp_len; + struct qseecom_ion_fd_info ifd_data[MAX_ION_FD]; +}; + +struct qseecom_sg_entry { + __u32 phys_addr; + __u32 len; +}; + +struct qseecom_sg_entry_64bit { + __u64 phys_addr; + __u32 len; +} __attribute__ ((packed)); + +/* + * sg list buf format version + * 1: Legacy format to support only 512 SG list entries + * 2: new format to support > 512 entries + */ +#define QSEECOM_SG_LIST_BUF_FORMAT_VERSION_1 1 +#define QSEECOM_SG_LIST_BUF_FORMAT_VERSION_2 2 + +struct qseecom_sg_list_buf_hdr_64bit { + struct qseecom_sg_entry_64bit blank_entry; /* must be all 0 */ + __u32 version; /* sg list buf format version */ + __u64 new_buf_phys_addr; /* PA of new buffer */ + __u32 nents_total; /* Total number of SG entries */ +} __attribute__ ((packed)); + +#define QSEECOM_SG_LIST_BUF_HDR_SZ_64BIT \ + sizeof(struct qseecom_sg_list_buf_hdr_64bit) + +#define MAX_CE_PIPE_PAIR_PER_UNIT 3 +#define INVALID_CE_INFO_UNIT_NUM 0xffffffff + +#define CE_PIPE_PAIR_USE_TYPE_FDE 0 +#define CE_PIPE_PAIR_USE_TYPE_PFE 1 + +struct qseecom_ce_pipe_entry { + int valid; + unsigned int ce_num; + unsigned int ce_pipe_pair; +}; + +struct qseecom_ice_data_t { + int flag; +}; + +#define MAX_CE_INFO_HANDLE_SIZE 32 +struct qseecom_ce_info_req { + unsigned char handle[MAX_CE_INFO_HANDLE_SIZE]; + unsigned int usage; + unsigned int unit_num; + unsigned int num_ce_pipe_entries; + struct qseecom_ce_pipe_entry ce_pipe_entry[MAX_CE_PIPE_PAIR_PER_UNIT]; +}; + +struct qseecom_ice_key_data_t { + __u8 key[ICE_KEY_SIZE]; + __u32 key_len; + __u8 salt[ICE_SALT_SIZE]; + __u32 salt_len; +}; + +#define SG_ENTRY_SZ sizeof(struct qseecom_sg_entry) +#define SG_ENTRY_SZ_64BIT sizeof(struct qseecom_sg_entry_64bit) + +struct file; + + +#define QSEECOM_IOC_MAGIC 0x97 + + +#define QSEECOM_IOCTL_REGISTER_LISTENER_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 1, struct qseecom_register_listener_req) + +#define QSEECOM_IOCTL_UNREGISTER_LISTENER_REQ \ + _IO(QSEECOM_IOC_MAGIC, 2) + +#define QSEECOM_IOCTL_SEND_CMD_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 3, struct qseecom_send_cmd_req) + +#define QSEECOM_IOCTL_SEND_MODFD_CMD_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 4, struct qseecom_send_modfd_cmd_req) + +#define QSEECOM_IOCTL_RECEIVE_REQ \ + _IO(QSEECOM_IOC_MAGIC, 5) + +#define QSEECOM_IOCTL_SEND_RESP_REQ \ + _IO(QSEECOM_IOC_MAGIC, 6) + +#define QSEECOM_IOCTL_LOAD_APP_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 7, struct qseecom_load_img_req) + +#define QSEECOM_IOCTL_SET_MEM_PARAM_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 8, struct qseecom_set_sb_mem_param_req) + +#define QSEECOM_IOCTL_UNLOAD_APP_REQ \ + _IO(QSEECOM_IOC_MAGIC, 9) + +#define QSEECOM_IOCTL_GET_QSEOS_VERSION_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 10, struct qseecom_qseos_version_req) + +#define QSEECOM_IOCTL_PERF_ENABLE_REQ \ + _IO(QSEECOM_IOC_MAGIC, 11) + +#define QSEECOM_IOCTL_PERF_DISABLE_REQ \ + _IO(QSEECOM_IOC_MAGIC, 12) + +#define QSEECOM_IOCTL_LOAD_EXTERNAL_ELF_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 13, struct qseecom_load_img_req) + +#define QSEECOM_IOCTL_UNLOAD_EXTERNAL_ELF_REQ \ + _IO(QSEECOM_IOC_MAGIC, 14) + +#define QSEECOM_IOCTL_APP_LOADED_QUERY_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 15, struct qseecom_qseos_app_load_query) + +#define QSEECOM_IOCTL_SEND_CMD_SERVICE_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 16, struct qseecom_send_svc_cmd_req) + +#define QSEECOM_IOCTL_CREATE_KEY_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 17, struct qseecom_create_key_req) + +#define QSEECOM_IOCTL_WIPE_KEY_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 18, struct qseecom_wipe_key_req) + +#define QSEECOM_IOCTL_SAVE_PARTITION_HASH_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 19, struct qseecom_save_partition_hash_req) + +#define QSEECOM_IOCTL_IS_ES_ACTIVATED_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 20, struct qseecom_is_es_activated_req) + +#define QSEECOM_IOCTL_SEND_MODFD_RESP \ + _IOWR(QSEECOM_IOC_MAGIC, 21, struct qseecom_send_modfd_listener_resp) + +#define QSEECOM_IOCTL_SET_BUS_SCALING_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 23, int) + +#define QSEECOM_IOCTL_UPDATE_KEY_USER_INFO_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 24, struct qseecom_update_key_userinfo_req) + +#define QSEECOM_QTEEC_IOCTL_OPEN_SESSION_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 30, struct qseecom_qteec_modfd_req) + +#define QSEECOM_QTEEC_IOCTL_CLOSE_SESSION_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 31, struct qseecom_qteec_req) + +#define QSEECOM_QTEEC_IOCTL_INVOKE_MODFD_CMD_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 32, struct qseecom_qteec_modfd_req) + +#define QSEECOM_QTEEC_IOCTL_REQUEST_CANCELLATION_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 33, struct qseecom_qteec_modfd_req) + +#define QSEECOM_IOCTL_MDTP_CIPHER_DIP_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 34, struct qseecom_mdtp_cipher_dip_req) + +#define QSEECOM_IOCTL_SEND_MODFD_CMD_64_REQ \ + _IOWR(QSEECOM_IOC_MAGIC, 35, struct qseecom_send_modfd_cmd_req) + +#define QSEECOM_IOCTL_SEND_MODFD_RESP_64 \ + _IOWR(QSEECOM_IOC_MAGIC, 36, struct qseecom_send_modfd_listener_resp) + +#define QSEECOM_IOCTL_GET_CE_PIPE_INFO \ + _IOWR(QSEECOM_IOC_MAGIC, 40, struct qseecom_ce_info_req) + +#define QSEECOM_IOCTL_FREE_CE_PIPE_INFO \ + _IOWR(QSEECOM_IOC_MAGIC, 41, struct qseecom_ce_info_req) + +#define QSEECOM_IOCTL_QUERY_CE_PIPE_INFO \ + _IOWR(QSEECOM_IOC_MAGIC, 42, struct qseecom_ce_info_req) + +#define QSEECOM_IOCTL_SET_ICE_INFO \ + _IOWR(QSEECOM_IOC_MAGIC, 43, struct qseecom_ice_data_t) + +#define QSEECOM_IOCTL_FBE_CLEAR_KEY \ + _IOWR(QSEECOM_IOC_MAGIC, 44, struct qseecom_ice_key_data_t) + +#endif /* _QSEECOM_H_ */