| /*Qualcomm Secure Execution Environment Communicator (QSEECOM) driver |
| * |
| * Copyright (c) 2012-2017, The Linux Foundation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only version 2 as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| |
| #define pr_fmt(fmt) "QSEECOM: %s: " fmt, __func__ |
| |
| #include <linux/kernel.h> |
| #include <linux/slab.h> |
| #include <linux/module.h> |
| #include <linux/fs.h> |
| #include <linux/platform_device.h> |
| #include <linux/debugfs.h> |
| #include <linux/cdev.h> |
| #include <linux/uaccess.h> |
| #include <linux/sched.h> |
| #include <linux/list.h> |
| #include <linux/mutex.h> |
| #include <linux/io.h> |
| #include <linux/msm_ion.h> |
| #include <linux/types.h> |
| #include <linux/clk.h> |
| #include <linux/qseecom.h> |
| #include <linux/elf.h> |
| #include <linux/firmware.h> |
| #include <linux/freezer.h> |
| #include <linux/scatterlist.h> |
| #include <linux/regulator/consumer.h> |
| #include <linux/dma-mapping.h> |
| #include <soc/qcom/subsystem_restart.h> |
| #include <soc/qcom/scm.h> |
| #include <soc/qcom/socinfo.h> |
| #include <linux/msm-bus.h> |
| #include <linux/msm-bus-board.h> |
| #include <soc/qcom/qseecomi.h> |
| #include <asm/cacheflush.h> |
| #include "qseecom_legacy.h" |
| #include "qseecom_kernel.h" |
| #include <crypto/ice.h> |
| #include <linux/delay.h> |
| |
| #include <linux/compat.h> |
| #include "compat_qseecom.h" |
| |
| #define QSEECOM_DEV "qseecom" |
| #define QSEOS_VERSION_14 0x14 |
| #define QSEEE_VERSION_00 0x400000 |
| #define QSEE_VERSION_01 0x401000 |
| #define QSEE_VERSION_02 0x402000 |
| #define QSEE_VERSION_03 0x403000 |
| #define QSEE_VERSION_04 0x404000 |
| #define QSEE_VERSION_05 0x405000 |
| #define QSEE_VERSION_20 0x800000 |
| #define QSEE_VERSION_40 0x1000000 /* TZ.BF.4.0 */ |
| |
| #define QSEE_CE_CLK_100MHZ 100000000 |
| #define CE_CLK_DIV 1000000 |
| |
| #define QSEECOM_MAX_SG_ENTRY 512 |
| #define QSEECOM_SG_ENTRY_MSG_BUF_SZ_64BIT \ |
| (QSEECOM_MAX_SG_ENTRY * SG_ENTRY_SZ_64BIT) |
| |
| #define QSEECOM_INVALID_KEY_ID 0xff |
| |
| /* Save partition image hash for authentication check */ |
| #define SCM_SAVE_PARTITION_HASH_ID 0x01 |
| |
| /* Check if enterprise security is activate */ |
| #define SCM_IS_ACTIVATED_ID 0x02 |
| |
| /* Encrypt/Decrypt Data Integrity Partition (DIP) for MDTP */ |
| #define SCM_MDTP_CIPHER_DIP 0x01 |
| |
| /* Maximum Allowed Size (128K) of Data Integrity Partition (DIP) for MDTP */ |
| #define MAX_DIP 0x20000 |
| |
| #define RPMB_SERVICE 0x2000 |
| #define SSD_SERVICE 0x3000 |
| |
| #define QSEECOM_SEND_CMD_CRYPTO_TIMEOUT 2000 |
| #define QSEECOM_LOAD_APP_CRYPTO_TIMEOUT 2000 |
| #define TWO 2 |
| #define QSEECOM_UFS_ICE_CE_NUM 10 |
| #define QSEECOM_SDCC_ICE_CE_NUM 20 |
| #define QSEECOM_ICE_FDE_KEY_INDEX 0 |
| |
| #define PHY_ADDR_4G (1ULL<<32) |
| |
| #define QSEECOM_STATE_NOT_READY 0 |
| #define QSEECOM_STATE_SUSPEND 1 |
| #define QSEECOM_STATE_READY 2 |
| |
| /* |
| * default ce info unit to 0 for |
| * services which |
| * support only single instance. |
| * Most of services are in this category. |
| */ |
| #define DEFAULT_CE_INFO_UNIT 0 |
| #define DEFAULT_NUM_CE_INFO_UNIT 1 |
| |
| enum qseecom_clk_definitions { |
| CLK_DFAB = 0, |
| CLK_SFPB, |
| }; |
| |
| enum qseecom_client_handle_type { |
| QSEECOM_CLIENT_APP = 1, |
| QSEECOM_LISTENER_SERVICE, |
| QSEECOM_SECURE_SERVICE, |
| QSEECOM_GENERIC, |
| QSEECOM_UNAVAILABLE_CLIENT_APP, |
| }; |
| |
| enum qseecom_ce_hw_instance { |
| CLK_QSEE = 0, |
| CLK_CE_DRV, |
| CLK_INVALID, |
| }; |
| |
| static struct class *driver_class; |
| static dev_t qseecom_device_no; |
| |
| static DEFINE_MUTEX(qsee_bw_mutex); |
| static DEFINE_MUTEX(app_access_lock); |
| static DEFINE_MUTEX(clk_access_lock); |
| |
| struct sglist_info { |
| uint32_t indexAndFlags; |
| uint32_t sizeOrCount; |
| }; |
| |
| /* |
| * The 31th bit indicates only one or multiple physical address inside |
| * the request buffer. If it is set, the index locates a single physical addr |
| * inside the request buffer, and `sizeOrCount` is the size of the memory being |
| * shared at that physical address. |
| * Otherwise, the index locates an array of {start, len} pairs (a |
| * "scatter/gather list"), and `sizeOrCount` gives the number of entries in |
| * that array. |
| * |
| * The 30th bit indicates 64 or 32bit address; when it is set, physical addr |
| * and scatter gather entry sizes are 64-bit values. Otherwise, 32-bit values. |
| * |
| * The bits [0:29] of `indexAndFlags` hold an offset into the request buffer. |
| */ |
| #define SGLISTINFO_SET_INDEX_FLAG(c, s, i) \ |
| ((uint32_t)(((c & 1) << 31) | ((s & 1) << 30) | (i & 0x3fffffff))) |
| |
| #define SGLISTINFO_TABLE_SIZE (sizeof(struct sglist_info) * MAX_ION_FD) |
| |
| #define FEATURE_ID_WHITELIST 15 /*whitelist feature id*/ |
| |
| #define MAKE_WHITELIST_VERSION(major, minor, patch) \ |
| (((major & 0x3FF) << 22) | ((minor & 0x3FF) << 12) | (patch & 0xFFF)) |
| |
| struct qseecom_registered_listener_list { |
| struct list_head list; |
| struct qseecom_register_listener_req svc; |
| void *user_virt_sb_base; |
| u8 *sb_virt; |
| phys_addr_t sb_phys; |
| size_t sb_length; |
| struct ion_handle *ihandle; /* Retrieve phy addr */ |
| wait_queue_head_t rcv_req_wq; |
| int rcv_req_flag; |
| int send_resp_flag; |
| bool listener_in_use; |
| /* wq for thread blocked on this listener*/ |
| wait_queue_head_t listener_block_app_wq; |
| struct sglist_info sglistinfo_ptr[MAX_ION_FD]; |
| uint32_t sglist_cnt; |
| }; |
| |
| struct qseecom_registered_app_list { |
| struct list_head list; |
| u32 app_id; |
| u32 ref_cnt; |
| char app_name[MAX_APP_NAME_SIZE]; |
| u32 app_arch; |
| bool app_blocked; |
| u32 blocked_on_listener_id; |
| }; |
| |
| struct qseecom_registered_kclient_list { |
| struct list_head list; |
| struct qseecom_handle *handle; |
| }; |
| |
| struct qseecom_ce_info_use { |
| unsigned char handle[MAX_CE_INFO_HANDLE_SIZE]; |
| unsigned int unit_num; |
| unsigned int num_ce_pipe_entries; |
| struct qseecom_ce_pipe_entry *ce_pipe_entry; |
| bool alloc; |
| uint32_t type; |
| }; |
| |
| struct ce_hw_usage_info { |
| uint32_t qsee_ce_hw_instance; |
| uint32_t num_fde; |
| struct qseecom_ce_info_use *fde; |
| uint32_t num_pfe; |
| struct qseecom_ce_info_use *pfe; |
| }; |
| |
| struct qseecom_clk { |
| enum qseecom_ce_hw_instance instance; |
| struct clk *ce_core_clk; |
| struct clk *ce_clk; |
| struct clk *ce_core_src_clk; |
| struct clk *ce_bus_clk; |
| uint32_t clk_access_cnt; |
| }; |
| |
| struct qseecom_control { |
| struct ion_client *ion_clnt; /* Ion client */ |
| struct list_head registered_listener_list_head; |
| spinlock_t registered_listener_list_lock; |
| |
| struct list_head registered_app_list_head; |
| spinlock_t registered_app_list_lock; |
| |
| struct list_head registered_kclient_list_head; |
| spinlock_t registered_kclient_list_lock; |
| |
| wait_queue_head_t send_resp_wq; |
| int send_resp_flag; |
| |
| uint32_t qseos_version; |
| uint32_t qsee_version; |
| struct device *pdev; |
| bool whitelist_support; |
| bool commonlib_loaded; |
| bool commonlib64_loaded; |
| struct ion_handle *cmnlib_ion_handle; |
| struct ce_hw_usage_info ce_info; |
| |
| int qsee_bw_count; |
| int qsee_sfpb_bw_count; |
| |
| uint32_t qsee_perf_client; |
| struct qseecom_clk qsee; |
| struct qseecom_clk ce_drv; |
| |
| bool support_bus_scaling; |
| bool support_fde; |
| bool support_pfe; |
| uint32_t cumulative_mode; |
| enum qseecom_bandwidth_request_mode current_mode; |
| struct timer_list bw_scale_down_timer; |
| struct work_struct bw_inactive_req_ws; |
| struct cdev cdev; |
| bool timer_running; |
| bool no_clock_support; |
| unsigned int ce_opp_freq_hz; |
| bool appsbl_qseecom_support; |
| uint32_t qsee_reentrancy_support; |
| |
| uint32_t app_block_ref_cnt; |
| wait_queue_head_t app_block_wq; |
| atomic_t qseecom_state; |
| int is_apps_region_protected; |
| }; |
| |
| struct qseecom_sec_buf_fd_info { |
| bool is_sec_buf_fd; |
| size_t size; |
| void *vbase; |
| dma_addr_t pbase; |
| }; |
| |
| struct qseecom_param_memref { |
| uint32_t buffer; |
| uint32_t size; |
| }; |
| |
| struct qseecom_client_handle { |
| u32 app_id; |
| u8 *sb_virt; |
| phys_addr_t sb_phys; |
| unsigned long user_virt_sb_base; |
| size_t sb_length; |
| struct ion_handle *ihandle; /* Retrieve phy addr */ |
| char app_name[MAX_APP_NAME_SIZE]; |
| u32 app_arch; |
| struct qseecom_sec_buf_fd_info sec_buf_fd[MAX_ION_FD]; |
| }; |
| |
| struct qseecom_listener_handle { |
| u32 id; |
| }; |
| |
| static struct qseecom_control qseecom; |
| |
| struct qseecom_dev_handle { |
| enum qseecom_client_handle_type type; |
| union { |
| struct qseecom_client_handle client; |
| struct qseecom_listener_handle listener; |
| }; |
| bool released; |
| int abort; |
| wait_queue_head_t abort_wq; |
| atomic_t ioctl_count; |
| bool perf_enabled; |
| bool fast_load_enabled; |
| enum qseecom_bandwidth_request_mode mode; |
| struct sglist_info sglistinfo_ptr[MAX_ION_FD]; |
| uint32_t sglist_cnt; |
| bool use_legacy_cmd; |
| }; |
| |
| struct qseecom_key_id_usage_desc { |
| uint8_t desc[QSEECOM_KEY_ID_SIZE]; |
| }; |
| |
| struct qseecom_crypto_info { |
| unsigned int unit_num; |
| unsigned int ce; |
| unsigned int pipe_pair; |
| }; |
| |
| static struct qseecom_key_id_usage_desc key_id_array[] = { |
| { |
| .desc = "Undefined Usage Index", |
| }, |
| |
| { |
| .desc = "Full Disk Encryption", |
| }, |
| |
| { |
| .desc = "Per File Encryption", |
| }, |
| |
| { |
| .desc = "UFS ICE Full Disk Encryption", |
| }, |
| |
| { |
| .desc = "SDCC ICE Full Disk Encryption", |
| }, |
| }; |
| |
| /* Function proto types */ |
| static int qsee_vote_for_clock(struct qseecom_dev_handle *, int32_t); |
| static void qsee_disable_clock_vote(struct qseecom_dev_handle *, int32_t); |
| static int __qseecom_enable_clk(enum qseecom_ce_hw_instance ce); |
| static void __qseecom_disable_clk(enum qseecom_ce_hw_instance ce); |
| static int __qseecom_init_clk(enum qseecom_ce_hw_instance ce); |
| static int qseecom_load_commonlib_image(struct qseecom_dev_handle *data, |
| char *cmnlib_name); |
| static int qseecom_enable_ice_setup(int usage); |
| static int qseecom_disable_ice_setup(int usage); |
| static void __qseecom_reentrancy_check_if_no_app_blocked(uint32_t smc_id); |
| static int qseecom_get_ce_info(struct qseecom_dev_handle *data, |
| void __user *argp); |
| static int qseecom_free_ce_info(struct qseecom_dev_handle *data, |
| void __user *argp); |
| static int qseecom_query_ce_info(struct qseecom_dev_handle *data, |
| void __user *argp); |
| |
| static int get_qseecom_keymaster_status(char *str) |
| { |
| get_option(&str, &qseecom.is_apps_region_protected); |
| return 1; |
| } |
| __setup("androidboot.keymaster=", get_qseecom_keymaster_status); |
| |
| static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id, |
| const void *req_buf, void *resp_buf) |
| { |
| int ret = 0; |
| uint32_t smc_id = 0; |
| uint32_t qseos_cmd_id = 0; |
| struct scm_desc desc = {0}; |
| struct qseecom_command_scm_resp *scm_resp = NULL; |
| |
| if (!req_buf || !resp_buf) { |
| pr_err("Invalid buffer pointer\n"); |
| return -EINVAL; |
| } |
| qseos_cmd_id = *(uint32_t *)req_buf; |
| scm_resp = (struct qseecom_command_scm_resp *)resp_buf; |
| |
| switch (svc_id) { |
| case 6: { |
| if (tz_cmd_id == 3) { |
| smc_id = TZ_INFO_GET_FEATURE_VERSION_ID; |
| desc.arginfo = TZ_INFO_GET_FEATURE_VERSION_ID_PARAM_ID; |
| desc.args[0] = *(uint32_t *)req_buf; |
| } else { |
| pr_err("Unsupported svc_id %d, tz_cmd_id %d\n", |
| svc_id, tz_cmd_id); |
| return -EINVAL; |
| } |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case SCM_SVC_ES: { |
| switch (tz_cmd_id) { |
| case SCM_SAVE_PARTITION_HASH_ID: { |
| u32 tzbuflen = PAGE_ALIGN(SHA256_DIGEST_LENGTH); |
| struct qseecom_save_partition_hash_req *p_hash_req = |
| (struct qseecom_save_partition_hash_req *) |
| req_buf; |
| char *tzbuf = kzalloc(tzbuflen, GFP_KERNEL); |
| if (!tzbuf) { |
| pr_err("error allocating data\n"); |
| return -ENOMEM; |
| } |
| memset(tzbuf, 0, tzbuflen); |
| memcpy(tzbuf, p_hash_req->digest, |
| SHA256_DIGEST_LENGTH); |
| dmac_flush_range(tzbuf, tzbuf + tzbuflen); |
| smc_id = TZ_ES_SAVE_PARTITION_HASH_ID; |
| desc.arginfo = TZ_ES_SAVE_PARTITION_HASH_ID_PARAM_ID; |
| desc.args[0] = p_hash_req->partition_id; |
| desc.args[1] = virt_to_phys(tzbuf); |
| desc.args[2] = SHA256_DIGEST_LENGTH; |
| ret = scm_call2(smc_id, &desc); |
| kzfree(tzbuf); |
| break; |
| } |
| default: { |
| pr_err("tz_cmd_id %d is not supported by scm_call2\n", |
| tz_cmd_id); |
| ret = -EINVAL; |
| break; |
| } |
| } /* end of switch (tz_cmd_id) */ |
| break; |
| } /* end of case SCM_SVC_ES */ |
| case SCM_SVC_TZSCHEDULER: { |
| switch (qseos_cmd_id) { |
| case QSEOS_APP_START_COMMAND: { |
| struct qseecom_load_app_ireq *req; |
| struct qseecom_load_app_64bit_ireq *req_64bit; |
| smc_id = TZ_OS_APP_START_ID; |
| desc.arginfo = TZ_OS_APP_START_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_load_app_ireq *)req_buf; |
| desc.args[0] = req->mdt_len; |
| desc.args[1] = req->img_len; |
| desc.args[2] = req->phy_addr; |
| } else { |
| req_64bit = |
| (struct qseecom_load_app_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->mdt_len; |
| desc.args[1] = req_64bit->img_len; |
| desc.args[2] = req_64bit->phy_addr; |
| } |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_APP_SHUTDOWN_COMMAND: { |
| struct qseecom_unload_app_ireq *req; |
| req = (struct qseecom_unload_app_ireq *)req_buf; |
| smc_id = TZ_OS_APP_SHUTDOWN_ID; |
| desc.arginfo = TZ_OS_APP_SHUTDOWN_ID_PARAM_ID; |
| desc.args[0] = req->app_id; |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_APP_LOOKUP_COMMAND: { |
| struct qseecom_check_app_ireq *req; |
| u32 tzbuflen = PAGE_ALIGN(sizeof(req->app_name)); |
| char *tzbuf = kzalloc(tzbuflen, GFP_KERNEL); |
| if (!tzbuf) { |
| pr_err("Allocate %d bytes buffer failed\n", |
| tzbuflen); |
| return -ENOMEM; |
| } |
| req = (struct qseecom_check_app_ireq *)req_buf; |
| pr_debug("Lookup app_name = %s\n", req->app_name); |
| strlcpy(tzbuf, req->app_name, sizeof(req->app_name)); |
| dmac_flush_range(tzbuf, tzbuf + tzbuflen); |
| smc_id = TZ_OS_APP_LOOKUP_ID; |
| desc.arginfo = TZ_OS_APP_LOOKUP_ID_PARAM_ID; |
| desc.args[0] = virt_to_phys(tzbuf); |
| desc.args[1] = strlen(req->app_name); |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| kzfree(tzbuf); |
| break; |
| } |
| case QSEOS_APP_REGION_NOTIFICATION: { |
| struct qsee_apps_region_info_ireq *req; |
| struct qsee_apps_region_info_64bit_ireq *req_64bit; |
| smc_id = TZ_OS_APP_REGION_NOTIFICATION_ID; |
| desc.arginfo = |
| TZ_OS_APP_REGION_NOTIFICATION_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qsee_apps_region_info_ireq *) |
| req_buf; |
| desc.args[0] = req->addr; |
| desc.args[1] = req->size; |
| } else { |
| req_64bit = |
| (struct qsee_apps_region_info_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->addr; |
| desc.args[1] = req_64bit->size; |
| } |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_LOAD_SERV_IMAGE_COMMAND: { |
| struct qseecom_load_lib_image_ireq *req; |
| struct qseecom_load_lib_image_64bit_ireq *req_64bit; |
| smc_id = TZ_OS_LOAD_SERVICES_IMAGE_ID; |
| desc.arginfo = TZ_OS_LOAD_SERVICES_IMAGE_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_load_lib_image_ireq *) |
| req_buf; |
| desc.args[0] = req->mdt_len; |
| desc.args[1] = req->img_len; |
| desc.args[2] = req->phy_addr; |
| } else { |
| req_64bit = |
| (struct qseecom_load_lib_image_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->mdt_len; |
| desc.args[1] = req_64bit->img_len; |
| desc.args[2] = req_64bit->phy_addr; |
| } |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_UNLOAD_SERV_IMAGE_COMMAND: { |
| smc_id = TZ_OS_UNLOAD_SERVICES_IMAGE_ID; |
| desc.arginfo = TZ_OS_UNLOAD_SERVICES_IMAGE_ID_PARAM_ID; |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_REGISTER_LISTENER: { |
| struct qseecom_register_listener_ireq *req; |
| struct qseecom_register_listener_64bit_ireq *req_64bit; |
| smc_id = TZ_OS_REGISTER_LISTENER_ID; |
| desc.arginfo = |
| TZ_OS_REGISTER_LISTENER_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_register_listener_ireq *) |
| req_buf; |
| desc.args[0] = req->listener_id; |
| desc.args[1] = req->sb_ptr; |
| desc.args[2] = req->sb_len; |
| } else { |
| req_64bit = |
| (struct qseecom_register_listener_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->listener_id; |
| desc.args[1] = req_64bit->sb_ptr; |
| desc.args[2] = req_64bit->sb_len; |
| } |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_DEREGISTER_LISTENER: { |
| struct qseecom_unregister_listener_ireq *req; |
| req = (struct qseecom_unregister_listener_ireq *) |
| req_buf; |
| smc_id = TZ_OS_DEREGISTER_LISTENER_ID; |
| desc.arginfo = TZ_OS_DEREGISTER_LISTENER_ID_PARAM_ID; |
| desc.args[0] = req->listener_id; |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_LISTENER_DATA_RSP_COMMAND: { |
| struct qseecom_client_listener_data_irsp *req; |
| req = (struct qseecom_client_listener_data_irsp *) |
| req_buf; |
| smc_id = TZ_OS_LISTENER_RESPONSE_HANDLER_ID; |
| desc.arginfo = |
| TZ_OS_LISTENER_RESPONSE_HANDLER_ID_PARAM_ID; |
| desc.args[0] = req->listener_id; |
| desc.args[1] = req->status; |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_LISTENER_DATA_RSP_COMMAND_WHITELIST: { |
| struct qseecom_client_listener_data_irsp *req; |
| struct qseecom_client_listener_data_64bit_irsp *req_64; |
| |
| smc_id = |
| TZ_OS_LISTENER_RESPONSE_HANDLER_WITH_WHITELIST_ID; |
| desc.arginfo = |
| TZ_OS_LISTENER_RESPONSE_HANDLER_WITH_WHITELIST_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = |
| (struct qseecom_client_listener_data_irsp *) |
| req_buf; |
| desc.args[0] = req->listener_id; |
| desc.args[1] = req->status; |
| desc.args[2] = req->sglistinfo_ptr; |
| desc.args[3] = req->sglistinfo_len; |
| } else { |
| req_64 = |
| (struct qseecom_client_listener_data_64bit_irsp *) |
| req_buf; |
| desc.args[0] = req_64->listener_id; |
| desc.args[1] = req_64->status; |
| desc.args[2] = req_64->sglistinfo_ptr; |
| desc.args[3] = req_64->sglistinfo_len; |
| } |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_LOAD_EXTERNAL_ELF_COMMAND: { |
| struct qseecom_load_app_ireq *req; |
| struct qseecom_load_app_64bit_ireq *req_64bit; |
| smc_id = TZ_OS_LOAD_EXTERNAL_IMAGE_ID; |
| desc.arginfo = TZ_OS_LOAD_SERVICES_IMAGE_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_load_app_ireq *)req_buf; |
| desc.args[0] = req->mdt_len; |
| desc.args[1] = req->img_len; |
| desc.args[2] = req->phy_addr; |
| } else { |
| req_64bit = |
| (struct qseecom_load_app_64bit_ireq *)req_buf; |
| desc.args[0] = req_64bit->mdt_len; |
| desc.args[1] = req_64bit->img_len; |
| desc.args[2] = req_64bit->phy_addr; |
| } |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_UNLOAD_EXTERNAL_ELF_COMMAND: { |
| smc_id = TZ_OS_UNLOAD_EXTERNAL_IMAGE_ID; |
| desc.arginfo = TZ_OS_UNLOAD_SERVICES_IMAGE_ID_PARAM_ID; |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| |
| case QSEOS_CLIENT_SEND_DATA_COMMAND: { |
| struct qseecom_client_send_data_ireq *req; |
| struct qseecom_client_send_data_64bit_ireq *req_64bit; |
| smc_id = TZ_APP_QSAPP_SEND_DATA_ID; |
| desc.arginfo = TZ_APP_QSAPP_SEND_DATA_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_client_send_data_ireq *) |
| req_buf; |
| desc.args[0] = req->app_id; |
| desc.args[1] = req->req_ptr; |
| desc.args[2] = req->req_len; |
| desc.args[3] = req->rsp_ptr; |
| desc.args[4] = req->rsp_len; |
| } else { |
| req_64bit = |
| (struct qseecom_client_send_data_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->app_id; |
| desc.args[1] = req_64bit->req_ptr; |
| desc.args[2] = req_64bit->req_len; |
| desc.args[3] = req_64bit->rsp_ptr; |
| desc.args[4] = req_64bit->rsp_len; |
| } |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_CLIENT_SEND_DATA_COMMAND_WHITELIST: { |
| struct qseecom_client_send_data_ireq *req; |
| struct qseecom_client_send_data_64bit_ireq *req_64bit; |
| |
| smc_id = TZ_APP_QSAPP_SEND_DATA_WITH_WHITELIST_ID; |
| desc.arginfo = |
| TZ_APP_QSAPP_SEND_DATA_WITH_WHITELIST_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_client_send_data_ireq *) |
| req_buf; |
| desc.args[0] = req->app_id; |
| desc.args[1] = req->req_ptr; |
| desc.args[2] = req->req_len; |
| desc.args[3] = req->rsp_ptr; |
| desc.args[4] = req->rsp_len; |
| desc.args[5] = req->sglistinfo_ptr; |
| desc.args[6] = req->sglistinfo_len; |
| } else { |
| req_64bit = |
| (struct qseecom_client_send_data_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->app_id; |
| desc.args[1] = req_64bit->req_ptr; |
| desc.args[2] = req_64bit->req_len; |
| desc.args[3] = req_64bit->rsp_ptr; |
| desc.args[4] = req_64bit->rsp_len; |
| desc.args[5] = req_64bit->sglistinfo_ptr; |
| desc.args[6] = req_64bit->sglistinfo_len; |
| } |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_RPMB_PROVISION_KEY_COMMAND: { |
| struct qseecom_client_send_service_ireq *req; |
| req = (struct qseecom_client_send_service_ireq *) |
| req_buf; |
| smc_id = TZ_OS_RPMB_PROVISION_KEY_ID; |
| desc.arginfo = TZ_OS_RPMB_PROVISION_KEY_ID_PARAM_ID; |
| desc.args[0] = req->key_type; |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_RPMB_ERASE_COMMAND: { |
| smc_id = TZ_OS_RPMB_ERASE_ID; |
| desc.arginfo = TZ_OS_RPMB_ERASE_ID_PARAM_ID; |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_RPMB_CHECK_PROV_STATUS_COMMAND: { |
| smc_id = TZ_OS_RPMB_CHECK_PROV_STATUS_ID; |
| desc.arginfo = TZ_OS_RPMB_CHECK_PROV_STATUS_ID_PARAM_ID; |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_GENERATE_KEY: { |
| u32 tzbuflen = PAGE_ALIGN(sizeof |
| (struct qseecom_key_generate_ireq) - |
| sizeof(uint32_t)); |
| char *tzbuf = kzalloc(tzbuflen, GFP_KERNEL); |
| if (!tzbuf) |
| return -ENOMEM; |
| memset(tzbuf, 0, tzbuflen); |
| memcpy(tzbuf, req_buf + sizeof(uint32_t), |
| (sizeof(struct qseecom_key_generate_ireq) - |
| sizeof(uint32_t))); |
| dmac_flush_range(tzbuf, tzbuf + tzbuflen); |
| smc_id = TZ_OS_KS_GEN_KEY_ID; |
| desc.arginfo = TZ_OS_KS_GEN_KEY_ID_PARAM_ID; |
| desc.args[0] = virt_to_phys(tzbuf); |
| desc.args[1] = tzbuflen; |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| kzfree(tzbuf); |
| break; |
| } |
| case QSEOS_DELETE_KEY: { |
| u32 tzbuflen = PAGE_ALIGN(sizeof |
| (struct qseecom_key_delete_ireq) - |
| sizeof(uint32_t)); |
| char *tzbuf = kzalloc(tzbuflen, GFP_KERNEL); |
| if (!tzbuf) { |
| pr_err("Allocate %d bytes buffer failed\n", |
| tzbuflen); |
| return -ENOMEM; |
| } |
| memset(tzbuf, 0, tzbuflen); |
| memcpy(tzbuf, req_buf + sizeof(uint32_t), |
| (sizeof(struct qseecom_key_delete_ireq) - |
| sizeof(uint32_t))); |
| dmac_flush_range(tzbuf, tzbuf + tzbuflen); |
| smc_id = TZ_OS_KS_DEL_KEY_ID; |
| desc.arginfo = TZ_OS_KS_DEL_KEY_ID_PARAM_ID; |
| desc.args[0] = virt_to_phys(tzbuf); |
| desc.args[1] = tzbuflen; |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| kzfree(tzbuf); |
| break; |
| } |
| case QSEOS_SET_KEY: { |
| u32 tzbuflen = PAGE_ALIGN(sizeof |
| (struct qseecom_key_select_ireq) - |
| sizeof(uint32_t)); |
| char *tzbuf = kzalloc(tzbuflen, GFP_KERNEL); |
| if (!tzbuf) { |
| pr_err("Allocate %d bytes buffer failed\n", |
| tzbuflen); |
| return -ENOMEM; |
| } |
| memset(tzbuf, 0, tzbuflen); |
| memcpy(tzbuf, req_buf + sizeof(uint32_t), |
| (sizeof(struct qseecom_key_select_ireq) - |
| sizeof(uint32_t))); |
| dmac_flush_range(tzbuf, tzbuf + tzbuflen); |
| smc_id = TZ_OS_KS_SET_PIPE_KEY_ID; |
| desc.arginfo = TZ_OS_KS_SET_PIPE_KEY_ID_PARAM_ID; |
| desc.args[0] = virt_to_phys(tzbuf); |
| desc.args[1] = tzbuflen; |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| kzfree(tzbuf); |
| break; |
| } |
| case QSEOS_UPDATE_KEY_USERINFO: { |
| u32 tzbuflen = PAGE_ALIGN(sizeof |
| (struct qseecom_key_userinfo_update_ireq) - |
| sizeof(uint32_t)); |
| char *tzbuf = kzalloc(tzbuflen, GFP_KERNEL); |
| if (!tzbuf) { |
| pr_err("Allocate %d bytes buffer failed\n", |
| tzbuflen); |
| return -ENOMEM; |
| } |
| memset(tzbuf, 0, tzbuflen); |
| memcpy(tzbuf, req_buf + sizeof(uint32_t), (sizeof |
| (struct qseecom_key_userinfo_update_ireq) - |
| sizeof(uint32_t))); |
| dmac_flush_range(tzbuf, tzbuf + tzbuflen); |
| smc_id = TZ_OS_KS_UPDATE_KEY_ID; |
| desc.arginfo = TZ_OS_KS_UPDATE_KEY_ID_PARAM_ID; |
| desc.args[0] = virt_to_phys(tzbuf); |
| desc.args[1] = tzbuflen; |
| __qseecom_reentrancy_check_if_no_app_blocked(smc_id); |
| ret = scm_call2(smc_id, &desc); |
| kzfree(tzbuf); |
| break; |
| } |
| case QSEOS_TEE_OPEN_SESSION: { |
| struct qseecom_qteec_ireq *req; |
| struct qseecom_qteec_64bit_ireq *req_64bit; |
| smc_id = TZ_APP_GPAPP_OPEN_SESSION_ID; |
| desc.arginfo = TZ_APP_GPAPP_OPEN_SESSION_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_qteec_ireq *)req_buf; |
| desc.args[0] = req->app_id; |
| desc.args[1] = req->req_ptr; |
| desc.args[2] = req->req_len; |
| desc.args[3] = req->resp_ptr; |
| desc.args[4] = req->resp_len; |
| } else { |
| req_64bit = (struct qseecom_qteec_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->app_id; |
| desc.args[1] = req_64bit->req_ptr; |
| desc.args[2] = req_64bit->req_len; |
| desc.args[3] = req_64bit->resp_ptr; |
| desc.args[4] = req_64bit->resp_len; |
| } |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_TEE_OPEN_SESSION_WHITELIST: { |
| struct qseecom_qteec_ireq *req; |
| struct qseecom_qteec_64bit_ireq *req_64bit; |
| |
| smc_id = TZ_APP_GPAPP_OPEN_SESSION_WITH_WHITELIST_ID; |
| desc.arginfo = |
| TZ_APP_GPAPP_OPEN_SESSION_WITH_WHITELIST_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_qteec_ireq *)req_buf; |
| desc.args[0] = req->app_id; |
| desc.args[1] = req->req_ptr; |
| desc.args[2] = req->req_len; |
| desc.args[3] = req->resp_ptr; |
| desc.args[4] = req->resp_len; |
| desc.args[5] = req->sglistinfo_ptr; |
| desc.args[6] = req->sglistinfo_len; |
| } else { |
| req_64bit = (struct qseecom_qteec_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->app_id; |
| desc.args[1] = req_64bit->req_ptr; |
| desc.args[2] = req_64bit->req_len; |
| desc.args[3] = req_64bit->resp_ptr; |
| desc.args[4] = req_64bit->resp_len; |
| desc.args[5] = req_64bit->sglistinfo_ptr; |
| desc.args[6] = req_64bit->sglistinfo_len; |
| } |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_TEE_INVOKE_COMMAND: { |
| struct qseecom_qteec_ireq *req; |
| struct qseecom_qteec_64bit_ireq *req_64bit; |
| smc_id = TZ_APP_GPAPP_INVOKE_COMMAND_ID; |
| desc.arginfo = TZ_APP_GPAPP_INVOKE_COMMAND_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_qteec_ireq *)req_buf; |
| desc.args[0] = req->app_id; |
| desc.args[1] = req->req_ptr; |
| desc.args[2] = req->req_len; |
| desc.args[3] = req->resp_ptr; |
| desc.args[4] = req->resp_len; |
| } else { |
| req_64bit = (struct qseecom_qteec_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->app_id; |
| desc.args[1] = req_64bit->req_ptr; |
| desc.args[2] = req_64bit->req_len; |
| desc.args[3] = req_64bit->resp_ptr; |
| desc.args[4] = req_64bit->resp_len; |
| } |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_TEE_INVOKE_COMMAND_WHITELIST: { |
| struct qseecom_qteec_ireq *req; |
| struct qseecom_qteec_64bit_ireq *req_64bit; |
| |
| smc_id = TZ_APP_GPAPP_INVOKE_COMMAND_WITH_WHITELIST_ID; |
| desc.arginfo = |
| TZ_APP_GPAPP_INVOKE_COMMAND_WITH_WHITELIST_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_qteec_ireq *)req_buf; |
| desc.args[0] = req->app_id; |
| desc.args[1] = req->req_ptr; |
| desc.args[2] = req->req_len; |
| desc.args[3] = req->resp_ptr; |
| desc.args[4] = req->resp_len; |
| desc.args[5] = req->sglistinfo_ptr; |
| desc.args[6] = req->sglistinfo_len; |
| } else { |
| req_64bit = (struct qseecom_qteec_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->app_id; |
| desc.args[1] = req_64bit->req_ptr; |
| desc.args[2] = req_64bit->req_len; |
| desc.args[3] = req_64bit->resp_ptr; |
| desc.args[4] = req_64bit->resp_len; |
| desc.args[5] = req_64bit->sglistinfo_ptr; |
| desc.args[6] = req_64bit->sglistinfo_len; |
| } |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_TEE_CLOSE_SESSION: { |
| struct qseecom_qteec_ireq *req; |
| struct qseecom_qteec_64bit_ireq *req_64bit; |
| smc_id = TZ_APP_GPAPP_CLOSE_SESSION_ID; |
| desc.arginfo = TZ_APP_GPAPP_CLOSE_SESSION_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_qteec_ireq *)req_buf; |
| desc.args[0] = req->app_id; |
| desc.args[1] = req->req_ptr; |
| desc.args[2] = req->req_len; |
| desc.args[3] = req->resp_ptr; |
| desc.args[4] = req->resp_len; |
| } else { |
| req_64bit = (struct qseecom_qteec_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->app_id; |
| desc.args[1] = req_64bit->req_ptr; |
| desc.args[2] = req_64bit->req_len; |
| desc.args[3] = req_64bit->resp_ptr; |
| desc.args[4] = req_64bit->resp_len; |
| } |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_TEE_REQUEST_CANCELLATION: { |
| struct qseecom_qteec_ireq *req; |
| struct qseecom_qteec_64bit_ireq *req_64bit; |
| smc_id = TZ_APP_GPAPP_REQUEST_CANCELLATION_ID; |
| desc.arginfo = |
| TZ_APP_GPAPP_REQUEST_CANCELLATION_ID_PARAM_ID; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req = (struct qseecom_qteec_ireq *)req_buf; |
| desc.args[0] = req->app_id; |
| desc.args[1] = req->req_ptr; |
| desc.args[2] = req->req_len; |
| desc.args[3] = req->resp_ptr; |
| desc.args[4] = req->resp_len; |
| } else { |
| req_64bit = (struct qseecom_qteec_64bit_ireq *) |
| req_buf; |
| desc.args[0] = req_64bit->app_id; |
| desc.args[1] = req_64bit->req_ptr; |
| desc.args[2] = req_64bit->req_len; |
| desc.args[3] = req_64bit->resp_ptr; |
| desc.args[4] = req_64bit->resp_len; |
| } |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| case QSEOS_CONTINUE_BLOCKED_REQ_COMMAND: { |
| struct qseecom_continue_blocked_request_ireq *req = |
| (struct qseecom_continue_blocked_request_ireq *) |
| req_buf; |
| smc_id = TZ_OS_CONTINUE_BLOCKED_REQUEST_ID; |
| desc.arginfo = |
| TZ_OS_CONTINUE_BLOCKED_REQUEST_ID_PARAM_ID; |
| desc.args[0] = req->app_id; |
| ret = scm_call2(smc_id, &desc); |
| break; |
| } |
| default: { |
| pr_err("qseos_cmd_id 0x%d is not supported by armv8 scm_call2.\n", |
| qseos_cmd_id); |
| ret = -EINVAL; |
| break; |
| } |
| } /*end of switch (qsee_cmd_id) */ |
| break; |
| } /*end of case SCM_SVC_TZSCHEDULER*/ |
| default: { |
| pr_err("svc_id 0x%x is not supported by armv8 scm_call2.\n", |
| svc_id); |
| ret = -EINVAL; |
| break; |
| } |
| } /*end of switch svc_id */ |
| scm_resp->result = desc.ret[0]; |
| scm_resp->resp_type = desc.ret[1]; |
| scm_resp->data = desc.ret[2]; |
| pr_debug("svc_id = 0x%x, tz_cmd_id = 0x%x, qseos_cmd_id = 0x%x, smc_id = 0x%x, param_id = 0x%x\n", |
| svc_id, tz_cmd_id, qseos_cmd_id, smc_id, desc.arginfo); |
| pr_debug("scm_resp->result = 0x%x, scm_resp->resp_type = 0x%x, scm_resp->data = 0x%x\n", |
| scm_resp->result, scm_resp->resp_type, scm_resp->data); |
| return ret; |
| } |
| |
| |
| static int qseecom_scm_call(u32 svc_id, u32 tz_cmd_id, const void *cmd_buf, |
| size_t cmd_len, void *resp_buf, size_t resp_len) |
| { |
| if (!is_scm_armv8()) |
| return scm_call(svc_id, tz_cmd_id, cmd_buf, cmd_len, |
| resp_buf, resp_len); |
| else |
| return qseecom_scm_call2(svc_id, tz_cmd_id, cmd_buf, resp_buf); |
| } |
| |
| static int __qseecom_is_svc_unique(struct qseecom_dev_handle *data, |
| struct qseecom_register_listener_req *svc) |
| { |
| struct qseecom_registered_listener_list *ptr; |
| int unique = 1; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&qseecom.registered_listener_list_lock, flags); |
| list_for_each_entry(ptr, &qseecom.registered_listener_list_head, list) { |
| if (ptr->svc.listener_id == svc->listener_id) { |
| pr_err("Service id: %u is already registered\n", |
| ptr->svc.listener_id); |
| unique = 0; |
| break; |
| } |
| } |
| spin_unlock_irqrestore(&qseecom.registered_listener_list_lock, flags); |
| return unique; |
| } |
| |
| static struct qseecom_registered_listener_list *__qseecom_find_svc( |
| int32_t listener_id) |
| { |
| struct qseecom_registered_listener_list *entry = NULL; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&qseecom.registered_listener_list_lock, flags); |
| list_for_each_entry(entry, &qseecom.registered_listener_list_head, list) |
| { |
| if (entry->svc.listener_id == listener_id) |
| break; |
| } |
| spin_unlock_irqrestore(&qseecom.registered_listener_list_lock, flags); |
| |
| if ((entry != NULL) && (entry->svc.listener_id != listener_id)) { |
| pr_err("Service id: %u is not found\n", listener_id); |
| return NULL; |
| } |
| |
| return entry; |
| } |
| |
| static int __qseecom_set_sb_memory(struct qseecom_registered_listener_list *svc, |
| struct qseecom_dev_handle *handle, |
| struct qseecom_register_listener_req *listener) |
| { |
| int ret = 0; |
| struct qseecom_register_listener_ireq req; |
| struct qseecom_register_listener_64bit_ireq req_64bit; |
| struct qseecom_command_scm_resp resp; |
| ion_phys_addr_t pa; |
| void *cmd_buf = NULL; |
| size_t cmd_len; |
| |
| /* Get the handle of the shared fd */ |
| svc->ihandle = ion_import_dma_buf(qseecom.ion_clnt, |
| listener->ifd_data_fd); |
| if (IS_ERR_OR_NULL(svc->ihandle)) { |
| pr_err("Ion client could not retrieve the handle\n"); |
| return -ENOMEM; |
| } |
| |
| /* Get the physical address of the ION BUF */ |
| ret = ion_phys(qseecom.ion_clnt, svc->ihandle, &pa, &svc->sb_length); |
| if (ret) { |
| pr_err("Cannot get phys_addr for the Ion Client, ret = %d\n", |
| ret); |
| return ret; |
| } |
| /* Populate the structure for sending scm call to load image */ |
| svc->sb_virt = (char *) ion_map_kernel(qseecom.ion_clnt, svc->ihandle); |
| svc->sb_phys = (phys_addr_t)pa; |
| |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| req.qsee_cmd_id = QSEOS_REGISTER_LISTENER; |
| req.listener_id = svc->svc.listener_id; |
| req.sb_len = svc->sb_length; |
| req.sb_ptr = (uint32_t)svc->sb_phys; |
| cmd_buf = (void *)&req; |
| cmd_len = sizeof(struct qseecom_register_listener_ireq); |
| } else { |
| req_64bit.qsee_cmd_id = QSEOS_REGISTER_LISTENER; |
| req_64bit.listener_id = svc->svc.listener_id; |
| req_64bit.sb_len = svc->sb_length; |
| req_64bit.sb_ptr = (uint64_t)svc->sb_phys; |
| cmd_buf = (void *)&req_64bit; |
| cmd_len = sizeof(struct qseecom_register_listener_64bit_ireq); |
| } |
| |
| resp.result = QSEOS_RESULT_INCOMPLETE; |
| |
| ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, cmd_buf, cmd_len, |
| &resp, sizeof(resp)); |
| if (ret) { |
| pr_err("qseecom_scm_call failed with err: %d\n", ret); |
| return -EINVAL; |
| } |
| |
| if (resp.result != QSEOS_RESULT_SUCCESS) { |
| pr_err("Error SB registration req: resp.result = %d\n", |
| resp.result); |
| return -EPERM; |
| } |
| return 0; |
| } |
| |
| static int qseecom_register_listener(struct qseecom_dev_handle *data, |
| void __user *argp) |
| { |
| int ret = 0; |
| unsigned long flags; |
| struct qseecom_register_listener_req rcvd_lstnr; |
| struct qseecom_registered_listener_list *new_entry; |
| |
| ret = copy_from_user(&rcvd_lstnr, argp, sizeof(rcvd_lstnr)); |
| if (ret) { |
| pr_err("copy_from_user failed\n"); |
| return ret; |
| } |
| if (!access_ok(VERIFY_WRITE, (void __user *)rcvd_lstnr.virt_sb_base, |
| rcvd_lstnr.sb_size)) |
| return -EFAULT; |
| |
| data->listener.id = 0; |
| if (!__qseecom_is_svc_unique(data, &rcvd_lstnr)) { |
| pr_err("Service is not unique and is already registered\n"); |
| data->released = true; |
| return -EBUSY; |
| } |
| |
| new_entry = kzalloc(sizeof(*new_entry), GFP_KERNEL); |
| if (!new_entry) { |
| pr_err("kmalloc failed\n"); |
| return -ENOMEM; |
| } |
| memcpy(&new_entry->svc, &rcvd_lstnr, sizeof(rcvd_lstnr)); |
| new_entry->rcv_req_flag = 0; |
| |
| new_entry->svc.listener_id = rcvd_lstnr.listener_id; |
| new_entry->sb_length = rcvd_lstnr.sb_size; |
| new_entry->user_virt_sb_base = rcvd_lstnr.virt_sb_base; |
| if (__qseecom_set_sb_memory(new_entry, data, &rcvd_lstnr)) { |
| pr_err("qseecom_set_sb_memoryfailed\n"); |
| kzfree(new_entry); |
| return -ENOMEM; |
| } |
| |
| data->listener.id = rcvd_lstnr.listener_id; |
| init_waitqueue_head(&new_entry->rcv_req_wq); |
| init_waitqueue_head(&new_entry->listener_block_app_wq); |
| new_entry->send_resp_flag = 0; |
| new_entry->listener_in_use = false; |
| spin_lock_irqsave(&qseecom.registered_listener_list_lock, flags); |
| list_add_tail(&new_entry->list, &qseecom.registered_listener_list_head); |
| spin_unlock_irqrestore(&qseecom.registered_listener_list_lock, flags); |
| |
| return ret; |
| } |
| |
| static int qseecom_unregister_listener(struct qseecom_dev_handle *data) |
| { |
| int ret = 0; |
| unsigned long flags; |
| uint32_t unmap_mem = 0; |
| struct qseecom_register_listener_ireq req; |
| struct qseecom_registered_listener_list *ptr_svc = NULL; |
| struct qseecom_command_scm_resp resp; |
| struct ion_handle *ihandle = NULL; /* Retrieve phy addr */ |
| |
| req.qsee_cmd_id = QSEOS_DEREGISTER_LISTENER; |
| req.listener_id = data->listener.id; |
| resp.result = QSEOS_RESULT_INCOMPLETE; |
| |
| ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, &req, |
| sizeof(req), &resp, sizeof(resp)); |
| if (ret) { |
| pr_err("scm_call() failed with err: %d (lstnr id=%d)\n", |
| ret, data->listener.id); |
| return ret; |
| } |
| |
| if (resp.result != QSEOS_RESULT_SUCCESS) { |
| pr_err("Failed resp.result=%d,(lstnr id=%d)\n", |
| resp.result, data->listener.id); |
| return -EPERM; |
| } |
| |
| data->abort = 1; |
| spin_lock_irqsave(&qseecom.registered_listener_list_lock, flags); |
| list_for_each_entry(ptr_svc, &qseecom.registered_listener_list_head, |
| list) { |
| if (ptr_svc->svc.listener_id == data->listener.id) { |
| wake_up_all(&ptr_svc->rcv_req_wq); |
| break; |
| } |
| } |
| spin_unlock_irqrestore(&qseecom.registered_listener_list_lock, flags); |
| |
| while (atomic_read(&data->ioctl_count) > 1) { |
| if (wait_event_freezable(data->abort_wq, |
| atomic_read(&data->ioctl_count) <= 1)) { |
| pr_err("Interrupted from abort\n"); |
| ret = -ERESTARTSYS; |
| break; |
| } |
| } |
| |
| spin_lock_irqsave(&qseecom.registered_listener_list_lock, flags); |
| list_for_each_entry(ptr_svc, |
| &qseecom.registered_listener_list_head, |
| list) |
| { |
| if (ptr_svc->svc.listener_id == data->listener.id) { |
| if (ptr_svc->sb_virt) { |
| unmap_mem = 1; |
| ihandle = ptr_svc->ihandle; |
| } |
| list_del(&ptr_svc->list); |
| kzfree(ptr_svc); |
| break; |
| } |
| } |
| spin_unlock_irqrestore(&qseecom.registered_listener_list_lock, flags); |
| |
| /* Unmap the memory */ |
| if (unmap_mem) { |
| if (!IS_ERR_OR_NULL(ihandle)) { |
| ion_unmap_kernel(qseecom.ion_clnt, ihandle); |
| ion_free(qseecom.ion_clnt, ihandle); |
| } |
| } |
| data->released = true; |
| return ret; |
| } |
| |
| static int __qseecom_set_msm_bus_request(uint32_t mode) |
| { |
| int ret = 0; |
| struct qseecom_clk *qclk; |
| |
| qclk = &qseecom.qsee; |
| if (qclk->ce_core_src_clk != NULL) { |
| if (mode == INACTIVE) { |
| __qseecom_disable_clk(CLK_QSEE); |
| } else { |
| ret = __qseecom_enable_clk(CLK_QSEE); |
| if (ret) |
| pr_err("CLK enabling failed (%d) MODE (%d)\n", |
| ret, mode); |
| } |
| } |
| |
| if ((!ret) && (qseecom.current_mode != mode)) { |
| ret = msm_bus_scale_client_update_request( |
| qseecom.qsee_perf_client, mode); |
| if (ret) { |
| pr_err("Bandwidth req failed(%d) MODE (%d)\n", |
| ret, mode); |
| if (qclk->ce_core_src_clk != NULL) { |
| if (mode == INACTIVE) |
| __qseecom_enable_clk(CLK_QSEE); |
| else |
| __qseecom_disable_clk(CLK_QSEE); |
| } |
| } |
| qseecom.current_mode = mode; |
| } |
| return ret; |
| } |
| |
| static void qseecom_bw_inactive_req_work(struct work_struct *work) |
| { |
| mutex_lock(&app_access_lock); |
| mutex_lock(&qsee_bw_mutex); |
| if (qseecom.timer_running) |
| __qseecom_set_msm_bus_request(INACTIVE); |
| pr_debug("current_mode = %d, cumulative_mode = %d\n", |
| qseecom.current_mode, qseecom.cumulative_mode); |
| qseecom.timer_running = false; |
| mutex_unlock(&qsee_bw_mutex); |
| mutex_unlock(&app_access_lock); |
| return; |
| } |
| |
| static void qseecom_scale_bus_bandwidth_timer_callback(unsigned long data) |
| { |
| schedule_work(&qseecom.bw_inactive_req_ws); |
| return; |
| } |
| |
| static int __qseecom_decrease_clk_ref_count(enum qseecom_ce_hw_instance ce) |
| { |
| struct qseecom_clk *qclk; |
| int ret = 0; |
| mutex_lock(&clk_access_lock); |
| if (ce == CLK_QSEE) |
| qclk = &qseecom.qsee; |
| else |
| qclk = &qseecom.ce_drv; |
| |
| if (qclk->clk_access_cnt > 2) { |
| pr_err("Invalid clock ref count %d\n", qclk->clk_access_cnt); |
| ret = -EINVAL; |
| goto err_dec_ref_cnt; |
| } |
| if (qclk->clk_access_cnt == 2) |
| qclk->clk_access_cnt--; |
| |
| err_dec_ref_cnt: |
| mutex_unlock(&clk_access_lock); |
| return ret; |
| } |
| |
| |
| static int qseecom_scale_bus_bandwidth_timer(uint32_t mode) |
| { |
| int32_t ret = 0; |
| int32_t request_mode = INACTIVE; |
| |
| mutex_lock(&qsee_bw_mutex); |
| if (mode == 0) { |
| if (qseecom.cumulative_mode > MEDIUM) |
| request_mode = HIGH; |
| else |
| request_mode = qseecom.cumulative_mode; |
| } else { |
| request_mode = mode; |
| } |
| |
| ret = __qseecom_set_msm_bus_request(request_mode); |
| if (ret) { |
| pr_err("set msm bus request failed (%d),request_mode (%d)\n", |
| ret, request_mode); |
| goto err_scale_timer; |
| } |
| |
| if (qseecom.timer_running) { |
| ret = __qseecom_decrease_clk_ref_count(CLK_QSEE); |
| if (ret) { |
| pr_err("Failed to decrease clk ref count.\n"); |
| goto err_scale_timer; |
| } |
| del_timer_sync(&(qseecom.bw_scale_down_timer)); |
| qseecom.timer_running = false; |
| } |
| err_scale_timer: |
| mutex_unlock(&qsee_bw_mutex); |
| return ret; |
| } |
| |
| |
| static int qseecom_unregister_bus_bandwidth_needs( |
| struct qseecom_dev_handle *data) |
| { |
| int32_t ret = 0; |
| |
| qseecom.cumulative_mode -= data->mode; |
| data->mode = INACTIVE; |
| |
| return ret; |
| } |
| |
| static int __qseecom_register_bus_bandwidth_needs( |
| struct qseecom_dev_handle *data, uint32_t request_mode) |
| { |
| int32_t ret = 0; |
| |
| if (data->mode == INACTIVE) { |
| qseecom.cumulative_mode += request_mode; |
| data->mode = request_mode; |
| } else { |
| if (data->mode != request_mode) { |
| qseecom.cumulative_mode -= data->mode; |
| qseecom.cumulative_mode += request_mode; |
| data->mode = request_mode; |
| } |
| } |
| return ret; |
| } |
| |
| static int qseecom_perf_enable(struct qseecom_dev_handle *data) |
| { |
| int ret = 0; |
| ret = qsee_vote_for_clock(data, CLK_DFAB); |
| if (ret) { |
| pr_err("Failed to vote for DFAB clock with err %d\n", ret); |
| goto perf_enable_exit; |
| } |
| ret = qsee_vote_for_clock(data, CLK_SFPB); |
| if (ret) { |
| qsee_disable_clock_vote(data, CLK_DFAB); |
| pr_err("Failed to vote for SFPB clock with err %d\n", ret); |
| goto perf_enable_exit; |
| } |
| |
| perf_enable_exit: |
| return ret; |
| } |
| |
| static int qseecom_scale_bus_bandwidth(struct qseecom_dev_handle *data, |
| void __user *argp) |
| { |
| int32_t ret = 0; |
| int32_t req_mode; |
| |
| if (qseecom.no_clock_support) |
| return 0; |
| |
| ret = copy_from_user(&req_mode, argp, sizeof(req_mode)); |
| if (ret) { |
| pr_err("copy_from_user failed\n"); |
| return ret; |
| } |
| if (req_mode > HIGH) { |
| pr_err("Invalid bandwidth mode (%d)\n", req_mode); |
| return -EINVAL; |
| } |
| |
| /* |
| * Register bus bandwidth needs if bus scaling feature is enabled; |
| * otherwise, qseecom enable/disable clocks for the client directly. |
| */ |
| if (qseecom.support_bus_scaling) { |
| mutex_lock(&qsee_bw_mutex); |
| ret = __qseecom_register_bus_bandwidth_needs(data, req_mode); |
| mutex_unlock(&qsee_bw_mutex); |
| } else { |
| pr_debug("Bus scaling feature is NOT enabled\n"); |
| pr_debug("request bandwidth mode %d for the client\n", |
| req_mode); |
| if (req_mode != INACTIVE) { |
| ret = qseecom_perf_enable(data); |
| if (ret) |
| pr_err("Failed to vote for clock with err %d\n", |
| ret); |
| } else { |
| qsee_disable_clock_vote(data, CLK_DFAB); |
| qsee_disable_clock_vote(data, CLK_SFPB); |
| } |
| } |
| return ret; |
| } |
| |
| static void __qseecom_add_bw_scale_down_timer(uint32_t duration) |
| { |
| if (qseecom.no_clock_support) |
| return; |
| |
| mutex_lock(&qsee_bw_mutex); |
| qseecom.bw_scale_down_timer.expires = jiffies + |
| msecs_to_jiffies(duration); |
| mod_timer(&(qseecom.bw_scale_down_timer), |
| qseecom.bw_scale_down_timer.expires); |
| qseecom.timer_running = true; |
| mutex_unlock(&qsee_bw_mutex); |
| } |
| |
| static void __qseecom_disable_clk_scale_down(struct qseecom_dev_handle *data) |
| { |
| if (!qseecom.support_bus_scaling) |
| qsee_disable_clock_vote(data, CLK_SFPB); |
| else |
| __qseecom_add_bw_scale_down_timer( |
| QSEECOM_LOAD_APP_CRYPTO_TIMEOUT); |
| return; |
| } |
| |
| static int __qseecom_enable_clk_scale_up(struct qseecom_dev_handle *data) |
| { |
| int ret = 0; |
| if (qseecom.support_bus_scaling) { |
| ret = qseecom_scale_bus_bandwidth_timer(MEDIUM); |
| if (ret) |
| pr_err("Failed to set bw MEDIUM.\n"); |
| } else { |
| ret = qsee_vote_for_clock(data, CLK_SFPB); |
| if (ret) |
| pr_err("Fail vote for clk SFPB ret %d\n", ret); |
| } |
| return ret; |
| } |
| |
| static int qseecom_set_client_mem_param(struct qseecom_dev_handle *data, |
| void __user *argp) |
| { |
| ion_phys_addr_t pa; |
| int32_t ret; |
| struct qseecom_set_sb_mem_param_req req; |
| size_t len; |
| |
| /* Copy the relevant information needed for loading the image */ |
| if (copy_from_user(&req, (void __user *)argp, sizeof(req))) |
| return -EFAULT; |
| |
| if ((req.ifd_data_fd <= 0) || (req.virt_sb_base == NULL) || |
| (req.sb_len == 0)) { |
| pr_err("Inavlid input(s)ion_fd(%d), sb_len(%d), vaddr(0x%pK)\n", |
| req.ifd_data_fd, req.sb_len, req.virt_sb_base); |
| return -EFAULT; |
| } |
| if (!access_ok(VERIFY_WRITE, (void __user *)req.virt_sb_base, |
| req.sb_len)) |
| return -EFAULT; |
| |
| /* Get the handle of the shared fd */ |
| data->client.ihandle = ion_import_dma_buf(qseecom.ion_clnt, |
| req.ifd_data_fd); |
| if (IS_ERR_OR_NULL(data->client.ihandle)) { |
| pr_err("Ion client could not retrieve the handle\n"); |
| return -ENOMEM; |
| } |
| /* Get the physical address of the ION BUF */ |
| ret = ion_phys(qseecom.ion_clnt, data->client.ihandle, &pa, &len); |
| if (ret) { |
| |
| pr_err("Cannot get phys_addr for the Ion Client, ret = %d\n", |
| ret); |
| return ret; |
| } |
| |
| if (len < req.sb_len) { |
| pr_err("Requested length (0x%x) is > allocated (0x%zu)\n", |
| req.sb_len, len); |
| return -EINVAL; |
| } |
| /* Populate the structure for sending scm call to load image */ |
| data->client.sb_virt = (char *) ion_map_kernel(qseecom.ion_clnt, |
| data->client.ihandle); |
| data->client.sb_phys = (phys_addr_t)pa; |
| data->client.sb_length = req.sb_len; |
| data->client.user_virt_sb_base = (uintptr_t)req.virt_sb_base; |
| return 0; |
| } |
| |
| static int __qseecom_listener_has_sent_rsp(struct qseecom_dev_handle *data) |
| { |
| int ret; |
| ret = (qseecom.send_resp_flag != 0); |
| return ret || data->abort; |
| } |
| |
| static int __qseecom_reentrancy_listener_has_sent_rsp( |
| struct qseecom_dev_handle *data, |
| struct qseecom_registered_listener_list *ptr_svc) |
| { |
| int ret; |
| |
| ret = (ptr_svc->send_resp_flag != 0); |
| return ret || data->abort; |
| } |
| |
| static int __qseecom_qseos_fail_return_resp_tz(struct qseecom_dev_handle *data, |
| struct qseecom_command_scm_resp *resp, |
| struct qseecom_client_listener_data_irsp *send_data_rsp, |
| struct qseecom_registered_listener_list *ptr_svc, |
| uint32_t lstnr) { |
| int ret = 0; |
| |
| send_data_rsp->status = QSEOS_RESULT_FAILURE; |
| qseecom.send_resp_flag = 0; |
| send_data_rsp->qsee_cmd_id = QSEOS_LISTENER_DATA_RSP_COMMAND; |
| send_data_rsp->listener_id = lstnr; |
| if (ptr_svc) |
| pr_warn("listener_id:%x, lstnr: %x\n", |
| ptr_svc->svc.listener_id, lstnr); |
| if (ptr_svc && ptr_svc->ihandle) |
| msm_ion_do_cache_op(qseecom.ion_clnt, ptr_svc->ihandle, |
| ptr_svc->sb_virt, ptr_svc->sb_length, |
| ION_IOC_CLEAN_INV_CACHES); |
| if (lstnr == RPMB_SERVICE) |
| __qseecom_enable_clk(CLK_QSEE); |
| ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, send_data_rsp, |
| sizeof(send_data_rsp), resp, sizeof(*resp)); |
| if (ret) { |
| pr_err("scm_call() failed with err: %d (app_id = %d)\n", |
| ret, data->client.app_id); |
| if (lstnr == RPMB_SERVICE) |
| __qseecom_disable_clk(CLK_QSEE); |
| return ret; |
| } |
| if ((resp->result != QSEOS_RESULT_SUCCESS) && |
| (resp->result != QSEOS_RESULT_INCOMPLETE)) { |
| pr_err("fail:resp res= %d,app_id = %d,lstr = %d\n", |
| resp->result, data->client.app_id, lstnr); |
| ret = -EINVAL; |
| } |
| if (lstnr == RPMB_SERVICE) |
| __qseecom_disable_clk(CLK_QSEE); |
| return ret; |
| } |
| |
| static void __qseecom_clean_listener_sglistinfo( |
| struct qseecom_registered_listener_list *ptr_svc) |
| { |
| if (ptr_svc->sglist_cnt) { |
| memset(ptr_svc->sglistinfo_ptr, 0, |
| SGLISTINFO_TABLE_SIZE); |
| ptr_svc->sglist_cnt = 0; |
| } |
| } |
| |
| static int __qseecom_process_incomplete_cmd(struct qseecom_dev_handle *data, |
| struct qseecom_command_scm_resp *resp) |
| { |
| int ret = 0; |
| int rc = 0; |
| uint32_t lstnr; |
| unsigned long flags; |
| struct qseecom_client_listener_data_irsp send_data_rsp; |
| struct qseecom_client_listener_data_64bit_irsp send_data_rsp_64bit; |
| struct qseecom_registered_listener_list *ptr_svc = NULL; |
| sigset_t new_sigset; |
| sigset_t old_sigset; |
| uint32_t status; |
| void *cmd_buf = NULL; |
| size_t cmd_len; |
| struct sglist_info *table = NULL; |
| |
| while (resp->result == QSEOS_RESULT_INCOMPLETE) { |
| lstnr = resp->data; |
| /* |
| * Wake up blocking lsitener service with the lstnr id |
| */ |
| spin_lock_irqsave(&qseecom.registered_listener_list_lock, |
| flags); |
| list_for_each_entry(ptr_svc, |
| &qseecom.registered_listener_list_head, list) { |
| if (ptr_svc->svc.listener_id == lstnr) { |
| ptr_svc->listener_in_use = true; |
| ptr_svc->rcv_req_flag = 1; |
| wake_up_interruptible(&ptr_svc->rcv_req_wq); |
| break; |
| } |
| } |
| spin_unlock_irqrestore(&qseecom.registered_listener_list_lock, |
| flags); |
| |
| if (ptr_svc == NULL) { |
| pr_err("Listener Svc %d does not exist\n", lstnr); |
| __qseecom_qseos_fail_return_resp_tz(data, resp, |
| &send_data_rsp, ptr_svc, lstnr); |
| return -EINVAL; |
| } |
| |
| if (!ptr_svc->ihandle) { |
| pr_err("Client handle is not initialized\n"); |
| __qseecom_qseos_fail_return_resp_tz(data, resp, |
| &send_data_rsp, ptr_svc, lstnr); |
| return -EINVAL; |
| } |
| |
| if (ptr_svc->svc.listener_id != lstnr) { |
| pr_warn("Service requested does not exist\n"); |
| __qseecom_qseos_fail_return_resp_tz(data, resp, |
| &send_data_rsp, ptr_svc, lstnr); |
| return -ERESTARTSYS; |
| } |
| pr_debug("waking up rcv_req_wq and waiting for send_resp_wq\n"); |
| |
| /* initialize the new signal mask with all signals*/ |
| sigfillset(&new_sigset); |
| /* block all signals */ |
| sigprocmask(SIG_SETMASK, &new_sigset, &old_sigset); |
| |
| do { |
| /* |
| * When reentrancy is not supported, check global |
| * send_resp_flag; otherwise, check this listener's |
| * send_resp_flag. |
| */ |
| if (!qseecom.qsee_reentrancy_support && |
| !wait_event_freezable(qseecom.send_resp_wq, |
| __qseecom_listener_has_sent_rsp(data))) { |
| break; |
| } |
| |
| if (qseecom.qsee_reentrancy_support && |
| !wait_event_freezable(qseecom.send_resp_wq, |
| __qseecom_reentrancy_listener_has_sent_rsp( |
| data, ptr_svc))) { |
| break; |
| } |
| } while (1); |
| |
| /* restore signal mask */ |
| sigprocmask(SIG_SETMASK, &old_sigset, NULL); |
| if (data->abort) { |
| pr_err("Abort clnt %d waiting on lstnr svc %d, ret %d", |
| data->client.app_id, lstnr, ret); |
| rc = -ENODEV; |
| status = QSEOS_RESULT_FAILURE; |
| } else { |
| status = QSEOS_RESULT_SUCCESS; |
| } |
| |
| qseecom.send_resp_flag = 0; |
| ptr_svc->send_resp_flag = 0; |
| table = ptr_svc->sglistinfo_ptr; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| send_data_rsp.listener_id = lstnr; |
| send_data_rsp.status = status; |
| send_data_rsp.sglistinfo_ptr = |
| (uint32_t)virt_to_phys(table); |
| send_data_rsp.sglistinfo_len = |
| SGLISTINFO_TABLE_SIZE; |
| dmac_flush_range((void *)table, |
| (void *)table + SGLISTINFO_TABLE_SIZE); |
| cmd_buf = (void *)&send_data_rsp; |
| cmd_len = sizeof(send_data_rsp); |
| } else { |
| send_data_rsp_64bit.listener_id = lstnr; |
| send_data_rsp_64bit.status = status; |
| send_data_rsp_64bit.sglistinfo_ptr = |
| virt_to_phys(table); |
| send_data_rsp_64bit.sglistinfo_len = |
| SGLISTINFO_TABLE_SIZE; |
| dmac_flush_range((void *)table, |
| (void *)table + SGLISTINFO_TABLE_SIZE); |
| cmd_buf = (void *)&send_data_rsp_64bit; |
| cmd_len = sizeof(send_data_rsp_64bit); |
| } |
| if (qseecom.whitelist_support == false) |
| *(uint32_t *)cmd_buf = QSEOS_LISTENER_DATA_RSP_COMMAND; |
| else |
| *(uint32_t *)cmd_buf = |
| QSEOS_LISTENER_DATA_RSP_COMMAND_WHITELIST; |
| if (ptr_svc) |
| msm_ion_do_cache_op(qseecom.ion_clnt, ptr_svc->ihandle, |
| ptr_svc->sb_virt, ptr_svc->sb_length, |
| ION_IOC_CLEAN_INV_CACHES); |
| |
| if ((lstnr == RPMB_SERVICE) || (lstnr == SSD_SERVICE)) |
| __qseecom_enable_clk(CLK_QSEE); |
| |
| ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, |
| cmd_buf, cmd_len, resp, sizeof(*resp)); |
| ptr_svc->listener_in_use = false; |
| __qseecom_clean_listener_sglistinfo(ptr_svc); |
| if (ret) { |
| pr_err("scm_call() failed with err: %d (app_id = %d)\n", |
| ret, data->client.app_id); |
| if ((lstnr == RPMB_SERVICE) || (lstnr == SSD_SERVICE)) |
| __qseecom_disable_clk(CLK_QSEE); |
| return ret; |
| } |
| if ((resp->result != QSEOS_RESULT_SUCCESS) && |
| (resp->result != QSEOS_RESULT_INCOMPLETE)) { |
| pr_err("fail:resp res= %d,app_id = %d,lstr = %d\n", |
| resp->result, data->client.app_id, lstnr); |
| ret = -EINVAL; |
| } |
| if ((lstnr == RPMB_SERVICE) || (lstnr == SSD_SERVICE)) |
| __qseecom_disable_clk(CLK_QSEE); |
| |
| } |
| if (rc) |
| return rc; |
| |
| return ret; |
| } |
| |
| int __qseecom_process_reentrancy_blocked_on_listener( |
| struct qseecom_command_scm_resp *resp, |
| struct qseecom_registered_app_list *ptr_app, |
| struct qseecom_dev_handle *data) |
| { |
| struct qseecom_registered_listener_list *list_ptr; |
| int ret = 0; |
| struct qseecom_continue_blocked_request_ireq ireq; |
| struct qseecom_command_scm_resp continue_resp; |
| sigset_t new_sigset, old_sigset; |
| unsigned long flags; |
| bool found_app = false; |
| |
| if (!resp || !data) { |
| pr_err("invalid resp or data pointer\n"); |
| ret = -EINVAL; |
| goto exit; |
| } |
| |
| /* find app_id & img_name from list */ |
| if (!ptr_app) { |
| spin_lock_irqsave(&qseecom.registered_app_list_lock, flags); |
| list_for_each_entry(ptr_app, &qseecom.registered_app_list_head, |
| list) { |
| if ((ptr_app->app_id == data->client.app_id) && |
| (!strcmp(ptr_app->app_name, |
| data->client.app_name))) { |
| found_app = true; |
| break; |
| } |
| } |
| spin_unlock_irqrestore(&qseecom.registered_app_list_lock, |
| flags); |
| if (!found_app) { |
| pr_err("app_id %d (%s) is not found\n", |
| data->client.app_id, |
| (char *)data->client.app_name); |
| ret = -ENOENT; |
| goto exit; |
| } |
| } |
| |
| list_ptr = __qseecom_find_svc(resp->data); |
| if (!list_ptr) { |
| pr_err("Invalid listener ID\n"); |
| ret = -ENODATA; |
| goto exit; |
| } |
| ptr_app->blocked_on_listener_id = resp->data; |
| list_ptr->listener_in_use = true; |
| /* sleep until listener is available */ |
| while (list_ptr->listener_in_use == true) { |
| qseecom.app_block_ref_cnt++; |
| ptr_app->app_blocked = true; |
| sigfillset(&new_sigset); |
| sigprocmask(SIG_SETMASK, &new_sigset, &old_sigset); |
| mutex_unlock(&app_access_lock); |
| do { |
| if (!wait_event_freezable( |
| list_ptr->listener_block_app_wq, |
| !list_ptr->listener_in_use)) { |
| break; |
| } |
| } while (1); |
| mutex_lock(&app_access_lock); |
| sigprocmask(SIG_SETMASK, &old_sigset, NULL); |
| ptr_app->app_blocked = false; |
| qseecom.app_block_ref_cnt--; |
| } |
| ptr_app->blocked_on_listener_id = 0; |
| /* notify the blocked app that listener is available */ |
| pr_warn("Lsntr %d is available, unblock app(%d) %s in TZ\n", |
| resp->data, data->client.app_id, |
| data->client.app_name); |
| ireq.qsee_cmd_id = QSEOS_CONTINUE_BLOCKED_REQ_COMMAND; |
| ireq.app_id = data->client.app_id; |
| ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, |
| &ireq, sizeof(ireq), |
| &continue_resp, sizeof(continue_resp)); |
| if (ret) { |
| pr_err("scm_call for continue blocked req for app(%d) %s failed, ret %d\n", |
| data->client.app_id, |
| data->client.app_name, ret); |
| goto exit; |
| } |
| /* |
| * After TZ app is unblocked, then continue to next case |
| * for incomplete request processing |
| */ |
| resp->result = QSEOS_RESULT_INCOMPLETE; |
| exit: |
| return ret; |
| } |
| |
| static int __qseecom_reentrancy_process_incomplete_cmd( |
| struct qseecom_dev_handle *data, |
| struct qseecom_command_scm_resp *resp) |
| { |
| int ret = 0; |
| int rc = 0; |
| uint32_t lstnr = 0; |
| unsigned long flags; |
| struct qseecom_client_listener_data_irsp send_data_rsp; |
| struct qseecom_client_listener_data_64bit_irsp send_data_rsp_64bit; |
| struct qseecom_registered_listener_list *ptr_svc = NULL; |
| sigset_t new_sigset; |
| sigset_t old_sigset; |
| uint32_t status; |
| void *cmd_buf = NULL; |
| size_t cmd_len; |
| struct sglist_info *table = NULL; |
| |
| while (resp->result == QSEOS_RESULT_INCOMPLETE) { |
| lstnr = resp->data; |
| /* |
| * Wake up blocking lsitener service with the lstnr id |
| */ |
| spin_lock_irqsave(&qseecom.registered_listener_list_lock, |
| flags); |
| list_for_each_entry(ptr_svc, |
| &qseecom.registered_listener_list_head, list) { |
| if (ptr_svc->svc.listener_id == lstnr) { |
| ptr_svc->listener_in_use = true; |
| ptr_svc->rcv_req_flag = 1; |
| wake_up_interruptible(&ptr_svc->rcv_req_wq); |
| break; |
| } |
| } |
| spin_unlock_irqrestore(&qseecom.registered_listener_list_lock, |
| flags); |
| |
| if (ptr_svc == NULL) { |
| pr_err("Listener Svc %d does not exist\n", lstnr); |
| return -EINVAL; |
| } |
| |
| if (!ptr_svc->ihandle) { |
| pr_err("Client handle is not initialized\n"); |
| return -EINVAL; |
| } |
| |
| if (ptr_svc->svc.listener_id != lstnr) { |
| pr_warn("Service requested does not exist\n"); |
| return -ERESTARTSYS; |
| } |
| pr_debug("waking up rcv_req_wq and waiting for send_resp_wq\n"); |
| |
| /* initialize the new signal mask with all signals*/ |
| sigfillset(&new_sigset); |
| |
| /* block all signals */ |
| sigprocmask(SIG_SETMASK, &new_sigset, &old_sigset); |
| |
| /* unlock mutex btw waking listener and sleep-wait */ |
| mutex_unlock(&app_access_lock); |
| do { |
| if (!wait_event_freezable(qseecom.send_resp_wq, |
| __qseecom_reentrancy_listener_has_sent_rsp( |
| data, ptr_svc))) { |
| break; |
| } |
| } while (1); |
| /* lock mutex again after resp sent */ |
| mutex_lock(&app_access_lock); |
| ptr_svc->send_resp_flag = 0; |
| qseecom.send_resp_flag = 0; |
| |
| /* restore signal mask */ |
| sigprocmask(SIG_SETMASK, &old_sigset, NULL); |
| if (data->abort) { |
| pr_err("Abort clnt %d waiting on lstnr svc %d, ret %d", |
| data->client.app_id, lstnr, ret); |
| rc = -ENODEV; |
| status = QSEOS_RESULT_FAILURE; |
| } else { |
| status = QSEOS_RESULT_SUCCESS; |
| } |
| table = ptr_svc->sglistinfo_ptr; |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| send_data_rsp.listener_id = lstnr; |
| send_data_rsp.status = status; |
| send_data_rsp.sglistinfo_ptr = |
| (uint32_t)virt_to_phys(table); |
| send_data_rsp.sglistinfo_len = SGLISTINFO_TABLE_SIZE; |
| dmac_flush_range((void *)table, |
| (void *)table + SGLISTINFO_TABLE_SIZE); |
| cmd_buf = (void *)&send_data_rsp; |
| cmd_len = sizeof(send_data_rsp); |
| } else { |
| send_data_rsp_64bit.listener_id = lstnr; |
| send_data_rsp_64bit.status = status; |
| send_data_rsp_64bit.sglistinfo_ptr = |
| virt_to_phys(table); |
| send_data_rsp_64bit.sglistinfo_len = |
| SGLISTINFO_TABLE_SIZE; |
| dmac_flush_range((void *)table, |
| (void *)table + SGLISTINFO_TABLE_SIZE); |
| cmd_buf = (void *)&send_data_rsp_64bit; |
| cmd_len = sizeof(send_data_rsp_64bit); |
| } |
| if (qseecom.whitelist_support == false) |
| *(uint32_t *)cmd_buf = QSEOS_LISTENER_DATA_RSP_COMMAND; |
| else |
| *(uint32_t *)cmd_buf = |
| QSEOS_LISTENER_DATA_RSP_COMMAND_WHITELIST; |
| if (ptr_svc) |
| msm_ion_do_cache_op(qseecom.ion_clnt, ptr_svc->ihandle, |
| ptr_svc->sb_virt, ptr_svc->sb_length, |
| ION_IOC_CLEAN_INV_CACHES); |
| |
| if (lstnr == RPMB_SERVICE) |
| __qseecom_enable_clk(CLK_QSEE); |
| |
| ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, |
| cmd_buf, cmd_len, resp, sizeof(*resp)); |
| ptr_svc->listener_in_use = false; |
| __qseecom_clean_listener_sglistinfo(ptr_svc); |
| wake_up_interruptible(&ptr_svc->listener_block_app_wq); |
| |
| if (ret) { |
| pr_err("scm_call() failed with err: %d (app_id = %d)\n", |
| ret, data->client.app_id); |
| goto exit; |
| } |
| |
| switch (resp->result) { |
| case QSEOS_RESULT_BLOCKED_ON_LISTENER: |
| pr_warn("send lsr %d rsp, but app %d block on lsr %d\n", |
| lstnr, data->client.app_id, resp->data); |
| if (lstnr == resp->data) { |
| pr_err("lstnr %d should not be blocked!\n", |
| lstnr); |
| ret = -EINVAL; |
| goto exit; |
| } |
| ret = __qseecom_process_reentrancy_blocked_on_listener( |
| resp, NULL, data); |
| if (ret) { |
| pr_err("failed to process App(%d) %s blocked on listener %d\n", |
| data->client.app_id, |
| data->client.app_name, resp->data); |
| goto exit; |
| } |
| case QSEOS_RESULT_SUCCESS: |
| case QSEOS_RESULT_INCOMPLETE: |
| break; |
| default: |
| pr_err("fail:resp res= %d,app_id = %d,lstr = %d\n", |
| resp->result, data->client.app_id, lstnr); |
| ret = -EINVAL; |
| goto exit; |
| } |
| |
| } |
| exit: |
| if (lstnr == RPMB_SERVICE) |
| __qseecom_disable_clk(CLK_QSEE); |
| if (rc) |
| return rc; |
| |
| return ret; |
| } |
| |
| /* |
| * QSEE doesn't support OS level cmds reentrancy until RE phase-3, |
| * and QSEE OS level scm_call cmds will fail if there is any blocked TZ app. |
| * So, needs to first check if no app blocked before sending OS level scm call, |
| * then wait until all apps are unblocked. |
| */ |
| static void __qseecom_reentrancy_check_if_no_app_blocked(uint32_t smc_id) |
| { |
| sigset_t new_sigset, old_sigset; |
| |
| if (qseecom.qsee_reentrancy_support > QSEE_REENTRANCY_PHASE_0 && |
| qseecom.qsee_reentrancy_support < QSEE_REENTRANCY_PHASE_3 && |
| IS_OWNER_TRUSTED_OS(TZ_SYSCALL_OWNER_ID(smc_id))) { |
| /* thread sleep until this app unblocked */ |
| while (qseecom.app_block_ref_cnt > 0) { |
| sigfillset(&new_sigset); |
| sigprocmask(SIG_SETMASK, &new_sigset, &old_sigset); |
| mutex_unlock(&app_access_lock); |
| do { |
| if (!wait_event_freezable(qseecom.app_block_wq, |
| (qseecom.app_block_ref_cnt == 0))) |
| break; |
| } while (1); |
| mutex_lock(&app_access_lock); |
| sigprocmask(SIG_SETMASK, &old_sigset, NULL); |
| } |
| } |
| } |
| |
| /* |
| * scm_call send command to a blocked TZ app will fail |
| * So, first check and then wait until this apps is unblocked |
| */ |
| static void __qseecom_reentrancy_check_if_this_app_blocked( |
| struct qseecom_registered_app_list *ptr_app) |
| { |
| sigset_t new_sigset, old_sigset; |
| if (qseecom.qsee_reentrancy_support) { |
| while (ptr_app->app_blocked) { |
| /* thread sleep until this app unblocked */ |
| sigfillset(&new_sigset); |
| sigprocmask(SIG_SETMASK, &new_sigset, &old_sigset); |
| mutex_unlock(&app_access_lock); |
| do { |
| if (!wait_event_freezable(qseecom.app_block_wq, |
| !ptr_app->app_blocked)) |
| break; |
| } while (1); |
| mutex_lock(&app_access_lock); |
| sigprocmask(SIG_SETMASK, &old_sigset, NULL); |
| } |
| } |
| } |
| |
| static int __qseecom_check_app_exists(struct qseecom_check_app_ireq req) |
| { |
| int32_t ret; |
| struct qseecom_command_scm_resp resp; |
| bool found_app = false; |
| struct qseecom_registered_app_list *entry = NULL; |
| unsigned long flags = 0; |
| |
| /* check if app exists and has been registered locally */ |
| spin_lock_irqsave(&qseecom.registered_app_list_lock, flags); |
| list_for_each_entry(entry, |
| &qseecom.registered_app_list_head, list) { |
| if (!strcmp(entry->app_name, req.app_name)) { |
| found_app = true; |
| break; |
| } |
| } |
| spin_unlock_irqrestore(&qseecom.registered_app_list_lock, flags); |
| if (found_app) { |
| pr_debug("Found app with id %d\n", entry->app_id); |
| return entry->app_id; |
| } |
| |
| memset((void *)&resp, 0, sizeof(resp)); |
| |
| /* SCM_CALL to check if app_id for the mentioned app exists */ |
| ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, &req, |
| sizeof(struct qseecom_check_app_ireq), |
| &resp, sizeof(resp)); |
| if (ret) { |
| pr_err("scm_call to check if app is already loaded failed\n"); |
| return -EINVAL; |
| } |
| |
| if (resp.result == QSEOS_RESULT_FAILURE) |
| return 0; |
| |
| switch (resp.resp_type) { |
| /*qsee returned listener type response */ |
| case QSEOS_LISTENER_ID: |
| pr_err("resp type is of listener type instead of app"); |
| return -EINVAL; |
| case QSEOS_APP_ID: |
| return resp.data; |
| default: |
| pr_err("invalid resp type (%d) from qsee", |
| resp.resp_type); |
| return -ENODEV; |
| } |
| } |
| |
| static int qseecom_load_app(struct qseecom_dev_handle *data, void __user *argp) |
| { |
| struct qseecom_registered_app_list *entry = NULL; |
| unsigned long flags = 0; |
| u32 app_id = 0; |
| struct ion_handle *ihandle; /* Ion handle */ |
| struct qseecom_load_img_req load_img_req; |
| int32_t ret = 0; |
| ion_phys_addr_t pa = 0; |
| size_t len; |
| struct qseecom_command_scm_resp resp; |
| struct qseecom_check_app_ireq req; |
| struct qseecom_load_app_ireq load_req; |
| struct qseecom_load_app_64bit_ireq load_req_64bit; |
| void *cmd_buf = NULL; |
| size_t cmd_len; |
| bool first_time = false; |
| |
| /* Copy the relevant information needed for loading the image */ |
| if (copy_from_user(&load_img_req, |
| (void __user *)argp, |
| sizeof(struct qseecom_load_img_req))) { |
| pr_err("copy_from_user failed\n"); |
| return -EFAULT; |
| } |
| |
| /* Check and load cmnlib */ |
| if (qseecom.qsee_version > QSEEE_VERSION_00) { |
| if (!qseecom.commonlib_loaded && |
| load_img_req.app_arch == ELFCLASS32) { |
| ret = qseecom_load_commonlib_image(data, "cmnlib"); |
| if (ret) { |
| pr_err("failed to load cmnlib\n"); |
| return -EIO; |
| } |
| qseecom.commonlib_loaded = true; |
| pr_debug("cmnlib is loaded\n"); |
| } |
| |
| if (!qseecom.commonlib64_loaded && |
| load_img_req.app_arch == ELFCLASS64) { |
| ret = qseecom_load_commonlib_image(data, "cmnlib64"); |
| if (ret) { |
| pr_err("failed to load cmnlib64\n"); |
| return -EIO; |
| } |
| qseecom.commonlib64_loaded = true; |
| pr_debug("cmnlib64 is loaded\n"); |
| } |
| } |
| |
| if (qseecom.support_bus_scaling) { |
| mutex_lock(&qsee_bw_mutex); |
| ret = __qseecom_register_bus_bandwidth_needs(data, MEDIUM); |
| mutex_unlock(&qsee_bw_mutex); |
| if (ret) |
| return ret; |
| } |
| |
| /* Vote for the SFPB clock */ |
| ret = __qseecom_enable_clk_scale_up(data); |
| if (ret) |
| goto enable_clk_err; |
| |
| req.qsee_cmd_id = QSEOS_APP_LOOKUP_COMMAND; |
| load_img_req.img_name[MAX_APP_NAME_SIZE-1] = '\0'; |
| strlcpy(req.app_name, load_img_req.img_name, MAX_APP_NAME_SIZE); |
| |
| ret = __qseecom_check_app_exists(req); |
| if (ret < 0) |
| goto loadapp_err; |
| |
| app_id = ret; |
| if (app_id) { |
| pr_debug("App id %d (%s) already exists\n", app_id, |
| (char *)(req.app_name)); |
| spin_lock_irqsave(&qseecom.registered_app_list_lock, flags); |
| list_for_each_entry(entry, |
| &qseecom.registered_app_list_head, list){ |
| if (entry->app_id == app_id) { |
| entry->ref_cnt++; |
| break; |
| } |
| } |
| spin_unlock_irqrestore( |
| &qseecom.registered_app_list_lock, flags); |
| ret = 0; |
| } else { |
| first_time = true; |
| pr_warn("App (%s) does'nt exist, loading apps for first time\n", |
| (char *)(load_img_req.img_name)); |
| /* Get the handle of the shared fd */ |
| ihandle = ion_import_dma_buf(qseecom.ion_clnt, |
| load_img_req.ifd_data_fd); |
| if (IS_ERR_OR_NULL(ihandle)) { |
| pr_err("Ion client could not retrieve the handle\n"); |
| ret = -ENOMEM; |
| goto loadapp_err; |
| } |
| |
| /* Get the physical address of the ION BUF */ |
| ret = ion_phys(qseecom.ion_clnt, ihandle, &pa, &len); |
| if (ret) { |
| pr_err("Cannot get phys_addr for the Ion Client, ret = %d\n", |
| ret); |
| goto loadapp_err; |
| } |
| |
| /* Populate the structure for sending scm call to load image */ |
| if (qseecom.qsee_version < QSEE_VERSION_40) { |
| load_req.qsee_cmd_id = QSEOS_APP_START_COMMAND; |
| load_req.mdt_len = load_img_req.mdt_len; |
| load_req.img_len = load_img_req.img_len; |
| strlcpy(load_req.app_name, load_img_req.img_name, |
| MAX_APP_NAME_SIZE); |
| load_req.phy_addr = (uint32_t)pa; |
| cmd_buf = (void *)&load_req; |
| cmd_len = sizeof(struct qseecom_load_app_ireq); |
| } else { |
| load_req_64bit.qsee_cmd_id = QSEOS_APP_START_COMMAND; |
| load_req_64bit.mdt_len = load_img_req.mdt_len; |
| load_req_64bit.img_len = load_img_req.img_len; |
| strlcpy(load_req_64bit.app_name, load_img_req.img_name, |
| MAX_APP_NAME_SIZE); |
| load_req_64bit.phy_addr = (uint64_t)pa; |
| cmd_buf = (void *)&load_req_64bit; |
| cmd_len = sizeof(struct qseecom_load_app_64bit_ireq); |
| } |
| |
| msm_ion_do_cache_op(qseecom.ion_clnt, ihandle, NULL, len, |
| ION_IOC_CLEAN_INV_CACHES); |
| |
| /* SCM_CALL to load the app and get the app_id back */ |
| ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, cmd_buf, |
| cmd_len, &resp, sizeof(resp)); |
| if (ret) { |
| pr_err("scm_call to load app failed\n"); |
| if (!IS_ERR_OR_NULL(ihandle)) |
| ion_free(qseecom.ion_clnt, ihandle); |
| ret = -EINVAL; |
| goto loadapp_err; |
| } |
| |
| if (resp.result == QSEOS_RESULT_FAILURE) { |
| pr_err("scm_call rsp.result is QSEOS_RESULT_FAILURE\n"); |
| if (!IS_ERR_OR_NULL(ihandle)) |
| ion_free(qseecom.ion_clnt, ihandle); |
| ret = -EFAULT; |
| goto loadapp_err; |
| } |
| |
| if (resp.result == QSEOS_RESULT_INCOMPLETE) { |
| ret = __qseecom_process_incomplete_cmd(data, &resp); |
| if (ret) { |
| pr_err("process_incomplete_cmd failed err: %d\n", |
| ret); |
| if (!IS_ERR_OR_NULL(ihandle)) |
| ion_free(qseecom.ion_clnt, ihandle); |
| ret = -EFAULT; |
| goto loadapp_err; |
| } |
| } |
| |
| if (resp.result != QSEOS_RESULT_SUCCESS) { |
| pr_err("scm_call failed resp.result unknown, %d\n", |
| resp.result); |
| if (!IS_ERR_OR_NULL(ihandle)) |
| ion_free(qseecom.ion_clnt, ihandle); |
| ret = -EFAULT; |
| goto loadapp_err; |
| } |
| |
| app_id = resp.data; |
| |
| entry = kmalloc(sizeof(*entry), GFP_KERNEL); |
| if (!entry) { |
| pr_err("kmalloc failed\n"); |
| ret = -ENOMEM; |
| goto loadapp_err; |
| } |
| entry->app_id = app_id; |
| entry->ref_cnt = 1; |
| entry->app_arch = load_img_req.app_arch; |
| /* |
| * keymaster app may be first loaded as "keymaste" by qseecomd, |
| * and then used as "keymaster" on some targets. To avoid app |
| * name checking error, register "keymaster" into app_list and |
| * thread private data. |
| */ |
| if (!strcmp(load_img_req.img_name, "keymaste")) |
| strlcpy(entry->app_name, "keymaster", |
| MAX_APP_NAME_SIZE); |
| else |
| strlcpy(entry->app_name, load_img_req.img_name, |
| MAX_APP_NAME_SIZE); |
| entry->app_blocked = false; |
| entry->blocked_on_listener_id = 0; |
| |
| /* Deallocate the handle */ |
| if (!IS_ERR_OR_NULL(ihandle)) |
| ion_free(qseecom.ion_clnt, ihandle); |
| |
| spin_lock_irqsave(&qseecom.registered_app_list_lock, flags); |
| list_add_tail(&entry->list, &qseecom.registered_app_list_head); |
| spin_unlock_irqrestore(&qseecom.registered_app_list_lock, |
| flags); |
| |
| pr_warn("App with id %d (%s) now loaded\n", app_id, |
| (char *)(load_img_req.img_name)); |
| } |
| data->client.app_id = app_id; |
| data->client.app_arch = load_img_req.app_arch; |
| if (!strcmp(load_img_req.img_name, "keymaste")) |
| strlcpy(data->client.app_name, "keymaster", MAX_APP_NAME_SIZE); |
| else |
| strlcpy(data->client.app_name, load_img_req.img_name, |
| MAX_APP_NAME_SIZE); |
| load_img_req.app_id = app_id; |
| if (copy_to_user(argp, &load_img_req, sizeof(load_img_req))) { |
| pr_err("copy_to_user failed\n"); |
| ret = -EFAULT; |
| if (first_time == true) { |
| spin_lock_irqsave( |
| &qseecom.registered_app_list_lock, flags); |
| list_del(&entry->list); |
| spin_unlock_irqrestore( |
| &qseecom.registered_app_list_lock, flags); |
| kzfree(entry); |
| } |
| } |
| |
| loadapp_err: |
| __qseecom_disable_clk_scale_down(data); |
| enable_clk_err: |
| if (qseecom.support_bus_scaling) { |
| mutex_lock(&qsee_bw_mutex); |
| qseecom_unregister_bus_bandwidth_needs(data); |
| mutex_unlock(&qsee_bw_mutex); |
| } |
| return ret; |
| } |
| |
| static int __qseecom_cleanup_app(struct qseecom_dev_handle *data) |
| { |
| int ret = 1; /* Set unload app */ |
| wake_up_all(&qseecom.send_resp_wq); |
| if (qseecom.qsee_reentrancy_support) |
| mutex_unlock(&app_access_lock); |
| while (atomic_read(&data->ioctl_count) > 1) { |
| if (wait_event_freezable(data->abort_wq, |
| atomic_read(&data->ioctl_count) <= 1)) { |
| pr_err("Interrupted from abort\n"); |
| ret = -ERESTARTSYS; |
| break; |
| } |
| } |
| if (qseecom.qsee_reentrancy_support) |
| mutex_lock(&app_access_lock); |
| return ret; |
| } |
| |
| static int qseecom_unmap_ion_allocated_memory(struct qseecom_dev_handle *data) |
| { |
| int ret = 0; |
| if (!IS_ERR_OR_NULL(data->client.ihandle)) { |
| ion_unmap_kernel(qseecom.ion_clnt, data->client.ihandle); |
| ion_free(qseecom.ion_clnt, data->client.ihandle); |
| data->client.ihandle = NULL; |
| } |
| return ret; |
| } |
| |
| static int qseecom_unload_app(struct qseecom_dev_handle *data, |
| bool app_crash) |
| { |
| unsigned long flags; |
| unsigned long flags1; |
| int ret = 0; |
| struct qseecom_command_scm_resp resp; |
| struct qseecom_registered_app_list *ptr_app = NULL; |
| bool unload = false; |
| bool found_app = false; |
| bool found_dead_app = false; |
| |
| if (!data) { |
| pr_err("Invalid/uninitialized device handle\n"); |
| return -EINVAL; |
| } |
| |
| if (!memcmp(data->client.app_name, "keymaste", strlen("keymaste"))) { |
| pr_debug("Do not unload keymaster app from tz\n"); |
| goto unload_exit; |
| } |
| |
| __qseecom_cleanup_app(data); |
| __qseecom_reentrancy_check_if_no_app_blocked(TZ_OS_APP_SHUTDOWN_ID); |
| |
| if (data->client.app_id > 0) { |
| spin_lock_irqsave(&qseecom.registered_app_list_lock, flags); |
| list_for_each_entry(ptr_app, &qseecom.registered_app_list_head, |
| list) { |
| if (ptr_app->app_id == data->client.app_id) { |
| if (!strcmp((void *)ptr_app->app_name, |
| (void *)data->client.app_name)) { |
| found_app = true; |
| if (ptr_app->app_blocked) |
| app_crash = false; |
| if (app_crash || ptr_app->ref_cnt == 1) |
| unload = true; |
| break; |
| } else { |
| found_dead_app = true; |
| break; |
| } |
| } |
| } |
| spin_unlock_irqrestore(&qseecom.registered_app_list_lock, |
| flags); |
| if (found_app == false && found_dead_app == false) { |
| pr_err("Cannot find app with id = %d (%s)\n", |
| data->client.app_id, |
| (char *)data->client.app_name); |
| ret = -EINVAL; |
| goto unload_exit; |
| } |
| } |
| |
| if (found_dead_app) |
| pr_warn("cleanup app_id %d(%s)\n", data->client.app_id, |
| (char *)data->client.app_name); |
| |
| if (unload) { |
| struct qseecom_unload_app_ireq req; |
| /* Populate the structure for sending scm call to load image */ |
| req.qsee_cmd_id = QSEOS_APP_SHUTDOWN_COMMAND; |
| req.app_id = data->client.app_id; |
| |
| /* SCM_CALL to unload the app */ |
| ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, &req, |
| sizeof(struct qseecom_unload_app_ireq), |
| &resp, sizeof(resp)); |
| if (ret) { |
| pr_err("scm_call to unload app (id = %d) failed\n", |
| req.app_id); |
| ret = -EFAULT; |
| goto unload_exit; |
| } else { |
| pr_warn("App id %d now unloaded\n", req.app_id); |
| } |
| if (resp.result == QSEOS_RESULT_FAILURE) { |
| pr_err("app (%d) unload_failed!!\n", |
| data->client.app_id); |
| ret = -EFAULT; |
| goto unload_exit; |
| } |
| if (resp.result == QSEOS_RESULT_SUCCESS) |
| pr_debug("App (%d) is unloaded!!\n", |
| data->client.app_id); |
| if (resp.result == QSEOS_RESULT_INCOMPLETE) { |
| ret = __qseecom_process_incomplete_cmd(data, &resp); |
| if (ret) { |
| pr_err("process_incomplete_cmd fail err: %d\n", |
| ret); |
| goto unload_exit; |
| } |
| } |
| } |
| |
| if (found_app) { |
| spin_lock_irqsave(&qseecom.registered_app_list_lock, flags1); |
| if (app_crash) { |
| ptr_app->ref_cnt = 0; |
| pr_debug("app_crash: ref_count = 0\n"); |
| } else { |
| if (ptr_app->ref_cnt == 1) { |
| ptr_app->ref_cnt = 0; |
| pr_debug("ref_count set to 0\n"); |
| } else { |
| ptr_app->ref_cnt--; |
| pr_debug("Can't unload app(%d) inuse\n", |
| ptr_app->app_id); |
| } |
| } |
| if (unload) { |
| list_del(&ptr_app->list); |
| kzfree(ptr_app); |
| } |
| spin_unlock_irqrestore(&qseecom.registered_app_list_lock, |
| flags1); |
| } |
| unload_exit: |
| qseecom_unmap_ion_allocated_memory(data); |
| data->released = true; |
| return ret; |
| } |
| |
| static phys_addr_t __qseecom_uvirt_to_kphys(struct qseecom_dev_handle *data, |
| unsigned long virt) |
| { |
| return data->client.sb_phys + (virt - data->client.user_virt_sb_base); |
| } |
| |
| static uintptr_t __qseecom_uvirt_to_kvirt(struct qseecom_dev_handle *data, |
| unsigned long virt) |
| { |
| return (uintptr_t)data->client.sb_virt + |
| (virt - data->client.user_virt_sb_base); |
| } |
| |
| int __qseecom_process_rpmb_svc_cmd(struct qseecom_dev_handle *data_ptr, |
| struct qseecom_send_svc_cmd_req *req_ptr, |
| struct qseecom_client_send_service_ireq *send_svc_ireq_ptr) |
| { |
| int ret = 0; |
| void *req_buf = NULL; |
| |
| if ((req_ptr == NULL) || (send_svc_ireq_ptr == NULL)) { |
| pr_err("Error with pointer: req_ptr = %pK, send_svc_ptr = %pK\n", |
| req_ptr, send_svc_ireq_ptr); |
| return -EINVAL; |
| } |
| |
| /* Clients need to ensure req_buf is at base offset of shared buffer */ |
| if ((uintptr_t)req_ptr->cmd_req_buf != |
| data_ptr->client.user_virt_sb_base) { |
| pr_err("cmd buf not pointing to base offset of shared buffer\n"); |
| return -EINVAL; |
| } |
| |
| if (data_ptr->client.sb_length < |
| sizeof(struct qseecom_rpmb_provision_key)) { |
| pr_err("shared buffer is too small to hold key type\n"); |
| return -EINVAL; |
| } |
| req_buf = data_ptr->client.sb_virt; |
| |
| send_svc_ireq_ptr->qsee_cmd_id = req_ptr->cmd_id; |
| send_svc_ireq_ptr->key_type = |
| ((struct qseecom_rpmb_provision_key *)req_buf)->key_type; |
| send_svc_ireq_ptr->req_len = req_ptr->cmd_req_len; |
| send_svc_ireq_ptr->rsp_ptr = (uint32_t)(__qseecom_uvirt_to_kphys( |
| data_ptr, (uintptr_t)req_ptr->resp_buf)); |
| send_svc_ireq_ptr->rsp_len = req_ptr->resp_len; |
| |
| return ret; |
| } |
| |
| int __qseecom_process_fsm_key_svc_cmd(struct qseecom_dev_handle *data_ptr, |
| struct qseecom_send_svc_cmd_req *req_ptr, |
| struct qseecom_client_send_fsm_key_req *send_svc_ireq_ptr) |
| { |
| int ret = 0; |
| uint32_t reqd_len_sb_in = 0; |
| |
| if ((req_ptr == NULL) || (send_svc_ireq_ptr == NULL)) { |
| pr_err("Error with pointer: req_ptr = %pK, send_svc_ptr = %pK\n", |
| req_ptr, send_svc_ireq_ptr); |
| return -EINVAL; |
| } |
| |
| reqd_len_sb_in = req_ptr->cmd_req_len + req_ptr->resp_len; |
| if (reqd_len_sb_in > data_ptr->client.sb_length) { |
| pr_err("Not enough memory to fit cmd_buf and resp_buf. "); |
| pr_err("Required: %u, Available: %zu\n", |
| reqd_len_sb_in, data_ptr->client.sb_length); |
| return -ENOMEM; |
| } |
| |
| send_svc_ireq_ptr->qsee_cmd_id = req_ptr->cmd_id; |
| send_svc_ireq_ptr->req_len = req_ptr->cmd_req_len; |
| send_svc_ireq_ptr->rsp_ptr = (uint32_t)(__qseecom_uvirt_to_kphys( |
| data_ptr, (uintptr_t)req_ptr->resp_buf)); |
| send_svc_ireq_ptr->rsp_len = req_ptr->resp_len; |
| |
| send_svc_ireq_ptr->req_ptr = (uint32_t)(__qseecom_uvirt_to_kphys( |
| data_ptr, (uintptr_t)req_ptr->cmd_req_buf)); |
| |
| |
| return ret; |
| } |
| |
| static int __validate_send_service_cmd_inputs(struct qseecom_dev_handle *data, |
| struct qseecom_send_svc_cmd_req *req) |
| { |
| if (!req || !req->resp_buf || !req->cmd_req_buf) { |
| pr_err("req or cmd buffer or response buffer is null\n"); |
| return -EINVAL; |
| } |
| |
| if (!data || !data->client.ihandle) { |
| pr_err("Client or client handle is not initialized\n"); |
| return -EINVAL; |
| } |
| |
| if (data->client.sb_virt == NULL) { |
| pr_err("sb_virt null\n"); |
| return -EINVAL; |
| } |
| |
| if (data->client.user_virt_sb_base == 0) { |
| pr_err("user_virt_sb_base is null\n"); |
| return -EINVAL; |
| } |
| |
| if (data->client.sb_length == 0) { |
| pr_err("sb_length is 0\n"); |
| return -EINVAL; |
| } |
| |
| if (((uintptr_t)req->cmd_req_buf < |
| data->client.user_virt_sb_base) || |
| ((uintptr_t)req->cmd_req_buf >= |
| (data->client.user_virt_sb_base + data->client.sb_length))) { |
| pr_err("cmd buffer address not within shared bufffer\n"); |
| return -EINVAL; |
| } |
| if (((uintptr_t)req->resp_buf < |
| data->client.user_virt_sb_base) || |
| ((uintptr_t)req->resp_buf >= |
| (data->client.user_virt_sb_base + data->client.sb_length))) { |
| pr_err("response buffer address not within shared bufffer\n"); |
| return -EINVAL; |
| } |
| if ((req->cmd_req_len == 0) || (req->resp_len == 0) || |
| (req->cmd_req_len > data->client.sb_length) || |
| (req->resp_len > data->client.sb_length)) { |
| pr_err("cmd buf length or response buf length not valid\n"); |
| return -EINVAL; |
| } |
| if (req->cmd_req_len > UINT_MAX - req->resp_len) { |
| pr_err("Integer overflow detected in req_len & rsp_len\n"); |
| return -EINVAL; |
| } |
| |
| if ((req->cmd_req_len + req->resp_len) > data->client.sb_length) { |
| pr_debug("Not enough memory to fit cmd_buf.\n"); |
| pr_debug("resp_buf. Required: %u, Available: %zu\n", |
| (req->cmd_req_len + req->resp_len), |
| data->client.sb_length); |
| return -ENOMEM; |
| } |
| if ((uintptr_t)req->cmd_req_buf > (ULONG_MAX - req->cmd_req_len)) { |
| pr_err("Integer overflow in req_len & cmd_req_buf\n"); |
| return -EINVAL; |
| } |
| if ((uintptr_t)req->resp_buf > (ULONG_MAX - req->resp_len)) { |
| pr_err("Integer overflow in resp_len & resp_buf\n"); |
| return -EINVAL; |
| } |
| if (data->client.user_virt_sb_base > |
| (ULONG_MAX - data->client.sb_length)) { |
| pr_err("Integer overflow in user_virt_sb_base & sb_length\n"); |
| return -EINVAL; |
| } |
| if ((((uintptr_t)req->cmd_req_buf + req->cmd_req_len) > |
| ((uintptr_t)data->client.user_virt_sb_base + |
| data->client.sb_length)) || |
| (((uintptr_t)req->resp_buf + req->resp_len) > |
| ((uintptr_t)data->client.user_virt_sb_base + |
| data->client.sb_length))) { |
| pr_err("cmd buf or resp buf is out of shared buffer region\n"); |
| return -EINVAL; |
| } |
| return 0; |
| } |
| |
| static int qseecom_send_service_cmd(struct qseecom_dev_handle *data, |
| void __user *argp) |
| { |
| int ret = 0; |
| struct qseecom_client_send_service_ireq send_svc_ireq; |
| struct qseecom_client_send_fsm_key_req send_fsm_key_svc_ireq; |
| struct qseecom_command_scm_resp resp; |
| struct qseecom_send_svc_cmd_req req; |
| void *send_req_ptr; |
| size_t req_buf_size; |
| |
| /*struct qseecom_command_scm_resp resp;*/ |
| |
| if (copy_from_user(&req, |
| (void __user *)argp, |
| sizeof(req))) { |
| pr_err("copy_from_user failed\n"); |
| return -EFAULT; |
| } |
| |
| if (__validate_send_service_cmd_inputs(data, &req)) |
| return -EINVAL; |
| |
| data->type = QSEECOM_SECURE_SERVICE; |
| |
| switch (req.cmd_id) { |
| case QSEOS_RPMB_PROVISION_KEY_COMMAND: |
| case QSEOS_RPMB_ERASE_COMMAND: |
| case QSEOS_RPMB_CHECK_PROV_STATUS_COMMAND: |
| send_req_ptr = &send_svc_ireq; |
| req_buf_size = sizeof(send_svc_ireq); |
| if (__qseecom_process_rpmb_svc_cmd(data, &req, |
| send_req_ptr)) |
| return -EINVAL; |
| break; |
| case QSEOS_FSM_LTEOTA_REQ_CMD: |
| case QSEOS_FSM_LTEOTA_REQ_RSP_CMD: |
| case QSEOS_FSM_IKE_REQ_CMD: |
| case QSEOS_FSM_IKE_REQ_RSP_CMD: |
| case QSEOS_FSM_OEM_FUSE_WRITE_ROW: |
| case QSEOS_FSM_OEM_FUSE_READ_ROW: |
| case QSEOS_FSM_ENCFS_REQ_CMD: |
| case QSEOS_FSM_ENCFS_REQ_RSP_CMD: |
| send_req_ptr = &send_fsm_key_svc_ireq; |
| req_buf_size = sizeof(send_fsm_key_svc_ireq); |
| if (__qseecom_process_fsm_key_svc_cmd(data, &req, |
| send_req_ptr)) |
| return -EINVAL; |
| break; |
| default: |
| pr_err("Unsupported cmd_id %d\n", req.cmd_id); |
| return -EINVAL; |
| } |
| |
| if (qseecom.support_bus_scaling) { |
| ret = qseecom_scale_bus_bandwidth_timer(HIGH); |
| if (ret) { |
| pr_err("Fail to set bw HIGH\n"); |
| return ret; |
| } |
| } else { |
| ret = qseecom_perf_enable(data); |
| if (ret) { |
| pr_err("Failed to vote for clocks with err %d\n", ret); |
| goto exit; |
| } |
| } |
| |
| msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle, |
| data->client.sb_virt, data->client.sb_length, |
| ION_IOC_CLEAN_INV_CACHES); |
| ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, |
| (const void *)send_req_ptr, |
| req_buf_size, &resp, sizeof(resp)); |
| msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle, |
| data->client.sb_virt, data->client.sb_length, |
| ION_IOC_INV_CACHES); |
| if (ret) { |
| pr_err("qseecom_scm_call failed with err: %d\n", ret); |
| if (!qseecom.support_bus_scaling) { |
| qsee_disable_clock_vote(data, CLK_DFAB); |
| qsee_disable_clock_vote(data, CLK_SFPB); |
| } else { |
| __qseecom_add_bw_scale_down_timer( |
| QSEECOM_SEND_CMD_CRYPTO_TIMEOUT); |
| } |
| goto exit; |
| } |
| |
| switch (resp.result) { |
| case QSEOS_RESULT_SUCCESS: |
| break; |
| case QSEOS_RESULT_INCOMPLETE: |
| pr_debug("qseos_result_incomplete\n"); |
| ret = __qseecom_process_incomplete_cmd(data, &resp); |
| if (ret) { |
| pr_err("process_incomplete_cmd fail with result: %d\n", |
| resp.result); |
| } |
| if (req.cmd_id == QSEOS_RPMB_CHECK_PROV_STATUS_COMMAND) { |
| pr_warn("RPMB key status is 0x%x\n", resp.result); |
| if (put_user(resp.result, |
| (uint32_t __user *)req.resp_buf)) { |
| ret = -EINVAL; |
| goto exit; |
| } |
| ret = 0; |
| } |
| break; |
| case QSEOS_RESULT_FAILURE: |
| pr_err("scm call failed with resp.result: %d\n", resp.result); |
| ret = -EINVAL; |
| break; |
| default: |
| pr_err("Response result %d not supported\n", |
| resp.result); |
| ret = -EINVAL; |
| break; |
| } |
| if (!qseecom.support_bus_scaling) { |
| qsee_disable_clock_vote(data, CLK_DFAB); |
| qsee_disable_clock_vote(data, CLK_SFPB); |
| } else { |
| __qseecom_add_bw_scale_down_timer( |
| QSEECOM_SEND_CMD_CRYPTO_TIMEOUT); |
| } |
| |
| exit: |
| return ret; |
| } |
| |
| static int __validate_send_cmd_inputs(struct qseecom_dev_handle *data, |
| struct qseecom_send_cmd_req *req) |
| |
| { |
| if (!data || !data->client.ihandle) { |
| pr_err("Client or client handle is not initialized\n"); |
| return -EINVAL; |
| } |
| if (((req->resp_buf == NULL) && (req->resp_len != 0)) || |
| (req->cmd_req_buf == NULL)) { |
| pr_err("cmd buffer or response buffer is null\n"); |
| return -EINVAL; |
| } |
| if (((uintptr_t)req->cmd_req_buf < |
| data->client.user_virt_sb_base) || |
| ((uintptr_t)req->cmd_req_buf >= |
| (data->client.user_virt_sb_base + data->client.sb_length))) { |
| pr_err("cmd buffer address not within shared bufffer\n"); |
| return -EINVAL; |
| } |
| if (((uintptr_t)req->resp_buf < |
| data->client.user_virt_sb_base) || |
| ((uintptr_t)req->resp_buf >= |
| (data->client.user_virt_sb_base + data->client.sb_length))) { |
| pr_err("response buffer address not within shared bufffer\n"); |
| return -EINVAL; |
| } |
| if ((req->cmd_req_len == 0) || |
| (req->cmd_req_len > data->client.sb_length) || |
| (req->resp_len > data->client.sb_length)) { |
| pr_err("cmd buf length or response buf length not valid\n"); |
| return -EINVAL; |
| } |
| if (req->cmd_req_len > UINT_MAX - req->resp_len) { |
| pr_err("Integer overflow detected in req_len & rsp_len\n"); |
| return -EINVAL; |
| } |
| |
| if ((req->cmd_req_len + req->resp_len) > data->client.sb_length) { |
| pr_debug("Not enough memory to fit cmd_buf.\n"); |
| pr_debug("resp_buf. Required: %u, Available: %zu\n", |
| (req->cmd_req_len + req->resp_len), |
| data->client.sb_length); |
| return -ENOMEM; |
| } |
| if ((uintptr_t)req->cmd_req_buf > (ULONG_MAX - req->cmd_req_len)) { |
| pr_err("Integer overflow in req_len & cmd_req_buf\n"); |
| return -EINVAL; |
| } |
| if ((uintptr_t)req->resp_buf > (ULONG_MAX - req->resp_len)) { |
| pr_err("Integer overflow in resp_len & resp_buf\n"); |
| return -EINVAL; |
| } |
| if (data->client.user_virt_sb_base > |
| (ULONG_MAX - data->client.sb_length)) { |
| pr_err("Integer overflow in user_virt_sb_base & sb_length\n"); |
| return -EINVAL; |
| } |
| if ((((uintptr_t)req->cmd_req_buf + req->cmd_req_len) > |
| ((uintptr_t)data->client.user_virt_sb_base + |
| data->client.sb_length)) || |
| (((uintptr_t)req->resp_buf + req->resp_len) > |
| ((uintptr_t)data->client.user_virt_sb_base + |
| data->client.sb_length))) { |
| pr_err("cmd buf or resp buf is out of shared buffer region\n"); |
| return -EINVAL; |
| } |
| return 0; |
| } |
| |
| int __qseecom_process_reentrancy(struct qseecom_command_scm_resp *resp, |
| struct qseecom_registered_app_list *ptr_app, |
| struct qseecom_dev_handle *data) |
| { |
| int ret = 0; |
| |
| switch (resp->result) { |
| case QSEOS_RESULT_BLOCKED_ON_LISTENER: |
| pr_warn("App(%d) %s is blocked on listener %d\n", |
| data->client.app_id, data->client.app_name, |
| resp->data); |
| ret = __qseecom_process_reentrancy_blocked_on_listener( |
| resp, ptr_app, data); |
| if (ret) { |
| pr_err("failed to process App(%d) %s is blocked on listener %d\n", |
| data->client.app_id, data->client.app_name, resp->data); |
| return ret; |
| } |
|