Merge "qseecom: Improve reentrancy operation for QSEE OS-level scm_call cmds" (e8bd2efb) · Commits · e / devices / android_kernel_xiaomi_markw

Documentation/devicetree/bindings/qseecom/qseecom.txt

+1 −1

Original line number	Diff line number	Diff line
		@@ -22,7 +22,7 @@ Optional properties:
		- qcom,no-clock-support : indicates clocks are not handled by qseecom (could be handled by RPM)
		- qcom,appsbl-qseecom-support : indicates if there is qseecom support in appsbootloader
		- vdd-hba-supply : handle for fixed power regulator
		- qcom,qsee-reentrancy-support: indicates if driver supports qsee command reentrancy
		- qcom,qsee-reentrancy-support: indicates the qsee reentrancy phase supported by the target

		Example:
		qcom,qseecom@fe806000 {

drivers/misc/qseecom.c

+100 −40

Original line number	Diff line number	Diff line
		@@ -204,7 +204,7 @@ struct qseecom_control {
		bool no_clock_support;
		unsigned int ce_opp_freq_hz;
		bool appsbl_qseecom_support;
		bool qsee_reentrancy_support;
		uint32_t qsee_reentrancy_support;

		uint32_t app_block_ref_cnt;
		wait_queue_head_t app_block_wq;
		@@ -283,6 +283,7 @@ 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_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id,
		const void req_buf, void resp_buf)
		@@ -368,6 +369,7 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id,
		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;
		}
		@@ -377,6 +379,7 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id,
		smc_id = TZ_OS_APP_SHUTDOWN_ID;
		desc.arginfo = TZ_OS_APP_SHUTDOWN_ID_PARAM_ID;
		desc.args[0] = req->app_id;
		__qseecom_reentrancy_check_if_no_app_blocked(smc_id);
		ret = scm_call2(smc_id, &desc);
		break;
		}
		@@ -397,6 +400,7 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_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;
		@@ -419,6 +423,7 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id,
		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;
		}
		@@ -441,12 +446,14 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id,
		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;
		}
		@@ -470,6 +477,7 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_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;
		}
		@@ -480,6 +488,7 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id,
		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;
		}
		@@ -512,12 +521,14 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id,
		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;
		}
		@@ -555,12 +566,14 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id,
		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;
		}
		@@ -578,6 +591,7 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_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;
		@@ -599,6 +613,7 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_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;
		@@ -620,6 +635,7 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_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;
		@@ -641,6 +657,7 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_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;
		@@ -742,6 +759,17 @@ static int qseecom_scm_call2(uint32_t svc_id, uint32_t tz_cmd_id,
		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);
		@@ -1484,14 +1512,14 @@ static int __qseecom_reentrancy_process_incomplete_cmd(
		do {
		if (!wait_event_freezable(qseecom.send_resp_wq,
		__qseecom_listener_has_sent_rsp(data))) {
		/* wakeup if this listener sent resp */
		if (ptr_svc->send_resp_flag)
		/* wakeup if this listener sent resp or abort */
		if (ptr_svc->send_resp_flag \|\| data->abort)
		break;
		}
		} while (1);
		/* lock mutex again after resp sent */
		ptr_svc->send_resp_flag = 0;
		mutex_lock(&app_access_lock);
		ptr_svc->send_resp_flag = 0;

		/* restore signal mask */
		sigprocmask(SIG_SETMASK, &old_sigset, NULL);
		@@ -1546,14 +1574,22 @@ static int __qseecom_reentrancy_process_incomplete_cmd(
		}

		/*
		* QSEE OS level cmds, like app lookup/load/unload, will fail
		* if there exists blocked TZ app. So, first check and then wait
		* until all apps are unblocked
		* 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(void)
		static void __qseecom_reentrancy_check_if_no_app_blocked(uint32_t smc_id)
		{
		while (qseecom.qsee_reentrancy_support &&
		qseecom.app_block_ref_cnt > 0) {
		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,
		@@ -1561,6 +1597,8 @@ static void __qseecom_reentrancy_check_if_no_app_blocked(void)
		break;
		} while (1);
		mutex_lock(&app_access_lock);
		sigprocmask(SIG_SETMASK, &old_sigset, NULL);
		}
		}
		}

		@@ -1571,9 +1609,12 @@ static void __qseecom_reentrancy_check_if_no_app_blocked(void)
		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,
		@@ -1581,6 +1622,7 @@ static void __qseecom_reentrancy_check_if_this_app_blocked(
		break;
		} while (1);
		mutex_lock(&app_access_lock);
		sigprocmask(SIG_SETMASK, &old_sigset, NULL);
		}
		}
		}
		@@ -1612,8 +1654,6 @@ static int __qseecom_check_app_exists(struct qseecom_check_app_ireq req)

		memset((void *)&resp, 0, sizeof(resp));

		__qseecom_reentrancy_check_if_no_app_blocked();

		/* 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),
		@@ -1770,8 +1810,6 @@ static int qseecom_load_app(struct qseecom_dev_handle data, void __user argp)
		msm_ion_do_cache_op(qseecom.ion_clnt, ihandle, NULL, len,
		ION_IOC_CLEAN_INV_CACHES);

		__qseecom_reentrancy_check_if_no_app_blocked();

		/* 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));
		@@ -1945,7 +1983,6 @@ static int qseecom_unload_app(struct qseecom_dev_handle *data,
		req.qsee_cmd_id = QSEOS_APP_SHUTDOWN_COMMAND;
		req.app_id = data->client.app_id;

		__qseecom_reentrancy_check_if_no_app_blocked();
		/* SCM_CALL to unload the app */
		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, &req,
		sizeof(struct qseecom_unload_app_ireq),
		@@ -2352,8 +2389,9 @@ int __qseecom_process_reentrancy(struct qseecom_command_scm_resp *resp,
		{
		struct qseecom_registered_listener_list *list_ptr;
		int ret = 0;
		uint32_t smc_id = 0;
		struct scm_desc desc = {0};
		struct qseecom_continue_blocked_request_ireq ireq;
		struct qseecom_command_scm_resp continue_resp;
		sigset_t new_sigset, old_sigset;

		switch (resp->result) {
		case QSEOS_RESULT_BLOCKED_ON_LISTENER:
		@@ -2367,9 +2405,12 @@ int __qseecom_process_reentrancy(struct qseecom_command_scm_resp *resp,
		}
		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(
		@@ -2378,21 +2419,24 @@ int __qseecom_process_reentrancy(struct qseecom_command_scm_resp *resp,
		break;
		}
		} while (1);
		ptr_app->app_blocked = false;
		mutex_lock(&app_access_lock);
		sigprocmask(SIG_SETMASK, &old_sigset, NULL);
		ptr_app->app_blocked = false;
		qseecom.app_block_ref_cnt--;
		}
		/* notify the blocked app that listener is released */
		/* notify the blocked app that listener is available */
		pr_debug("Lsntr %d is available, unblock app(%d) %s in TZ\n",
		resp->data, data->client.app_id,
		data->client.app_name);
		smc_id = TZ_OS_CONTINUE_BLOCKED_REQUEST_ID;
		desc.arginfo = TZ_OS_CONTINUE_BLOCKED_REQUEST_ID_PARAM_ID;
		desc.args[0] = data->client.app_id;
		ret = scm_call2(smc_id, &desc);
		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 fail, ret %d\n",
		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);
		return ret;
		}
		/*
		@@ -3347,7 +3391,6 @@ static int __qseecom_load_fw(struct qseecom_dev_handle data, char appname)
		img_data, fw_size,
		ION_IOC_CLEAN_INV_CACHES);

		__qseecom_reentrancy_check_if_no_app_blocked();
		/* SCM_CALL to load the image */
		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, cmd_buf, cmd_len,
		&resp, sizeof(resp));
		@@ -3516,7 +3559,7 @@ static int qseecom_unload_commonlib_image(void)

		/* Populate the remaining parameters */
		unload_req.qsee_cmd_id = QSEOS_UNLOAD_SERV_IMAGE_COMMAND;
		__qseecom_reentrancy_check_if_no_app_blocked();

		/* SCM_CALL to load the image */
		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, &unload_req,
		sizeof(struct qseecom_unload_lib_image_ireq),
		@@ -4307,7 +4350,7 @@ static int qseecom_load_external_elf(struct qseecom_dev_handle *data,
		}
		msm_ion_do_cache_op(qseecom.ion_clnt, ihandle, NULL, len,
		ION_IOC_CLEAN_INV_CACHES);
		__qseecom_reentrancy_check_if_no_app_blocked();

		/* SCM_CALL to load the external elf */
		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, cmd_buf, cmd_len,
		&resp, sizeof(resp));
		@@ -4367,7 +4410,6 @@ static int qseecom_unload_external_elf(struct qseecom_dev_handle *data)
		/* Populate the structure for sending scm call to unload image */
		req.qsee_cmd_id = QSEOS_UNLOAD_EXTERNAL_ELF_COMMAND;

		__qseecom_reentrancy_check_if_no_app_blocked();
		/* SCM_CALL to unload the external elf */
		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, &req,
		sizeof(struct qseecom_unload_app_ireq),
		@@ -5778,11 +5820,13 @@ long qseecom_ioctl(struct file *file, unsigned cmd, unsigned long arg)
		break;
		}
		pr_debug("ioctl register_listener_req()\n");
		mutex_lock(&app_access_lock);
		atomic_inc(&data->ioctl_count);
		data->type = QSEECOM_LISTENER_SERVICE;
		ret = qseecom_register_listener(data, argp);
		atomic_dec(&data->ioctl_count);
		wake_up_all(&data->abort_wq);
		mutex_unlock(&app_access_lock);
		if (ret)
		pr_err("failed qseecom_register_listener: %d\n", ret);
		break;
		@@ -5796,10 +5840,12 @@ long qseecom_ioctl(struct file *file, unsigned cmd, unsigned long arg)
		break;
		}
		pr_debug("ioctl unregister_listener_req()\n");
		mutex_lock(&app_access_lock);
		atomic_inc(&data->ioctl_count);
		ret = qseecom_unregister_listener(data);
		atomic_dec(&data->ioctl_count);
		wake_up_all(&data->abort_wq);
		mutex_unlock(&app_access_lock);
		if (ret)
		pr_err("failed qseecom_unregister_listener: %d\n", ret);
		break;
		@@ -6179,12 +6225,14 @@ long qseecom_ioctl(struct file *file, unsigned cmd, unsigned long arg)
		return -EINVAL;
		}
		data->released = true;
		mutex_lock(&app_access_lock);
		atomic_inc(&data->ioctl_count);
		ret = qseecom_create_key(data, argp);
		if (ret)
		pr_err("failed to create encryption key: %d\n", ret);

		atomic_dec(&data->ioctl_count);
		mutex_unlock(&app_access_lock);
		break;
		}
		case QSEECOM_IOCTL_WIPE_KEY_REQ: {
		@@ -6202,11 +6250,13 @@ long qseecom_ioctl(struct file *file, unsigned cmd, unsigned long arg)
		return -EINVAL;
		}
		data->released = true;
		mutex_lock(&app_access_lock);
		atomic_inc(&data->ioctl_count);
		ret = qseecom_wipe_key(data, argp);
		if (ret)
		pr_err("failed to wipe encryption key: %d\n", ret);
		atomic_dec(&data->ioctl_count);
		mutex_unlock(&app_access_lock);
		break;
		}
		case QSEECOM_IOCTL_UPDATE_KEY_USER_INFO_REQ: {
		@@ -6224,11 +6274,13 @@ long qseecom_ioctl(struct file *file, unsigned cmd, unsigned long arg)
		return -EINVAL;
		}
		data->released = true;
		mutex_lock(&app_access_lock);
		atomic_inc(&data->ioctl_count);
		ret = qseecom_update_key_user_info(data, argp);
		if (ret)
		pr_err("failed to update key user info: %d\n", ret);
		atomic_dec(&data->ioctl_count);
		mutex_unlock(&app_access_lock);
		break;
		}
		case QSEECOM_IOCTL_SAVE_PARTITION_HASH_REQ: {
		@@ -6286,6 +6338,7 @@ long qseecom_ioctl(struct file *file, unsigned cmd, unsigned long arg)
		break;
		}
		/* Only one client allowed here at a time */
		mutex_lock(&app_access_lock);
		atomic_inc(&data->ioctl_count);
		if (cmd == QSEECOM_IOCTL_SEND_MODFD_RESP)
		ret = qseecom_send_modfd_resp(data, argp);
		@@ -6293,6 +6346,7 @@ long qseecom_ioctl(struct file *file, unsigned cmd, unsigned long arg)
		ret = qseecom_send_modfd_resp_64(data, argp);
		atomic_dec(&data->ioctl_count);
		wake_up_all(&data->abort_wq);
		mutex_unlock(&app_access_lock);
		if (ret)
		pr_err("failed qseecom_send_mod_resp: %d\n", ret);
		break;
		@@ -6432,7 +6486,9 @@ static int qseecom_release(struct inode inode, struct file file)
		data->type, data->mode, data);
		switch (data->type) {
		case QSEECOM_LISTENER_SERVICE:
		mutex_lock(&app_access_lock);
		ret = qseecom_unregister_listener(data);
		mutex_unlock(&app_access_lock);
		break;
		case QSEECOM_CLIENT_APP:
		mutex_lock(&app_access_lock);
		@@ -6816,11 +6872,15 @@ static int qseecom_probe(struct platform_device *pdev)
		qseecom.no_clock_support);
		}

		qseecom.qsee_reentrancy_support =
		of_property_read_bool((&pdev->dev)->of_node,
		"qcom,qsee-reentrancy-support");
		pr_debug("qseecom.qsee_reentrancy_support = 0x%x\n",
		if (of_property_read_u32((&pdev->dev)->of_node,
		"qcom,qsee-reentrancy-support",
		&qseecom.qsee_reentrancy_support)) {
		pr_warn("qsee reentrancy support phase is not defined, setting to default 0\n");
		qseecom.qsee_reentrancy_support = 0;
		} else {
		pr_warn("qseecom.qsee_reentrancy_support = %d\n",
		qseecom.qsee_reentrancy_support);
		}

		/*
		* The qseecom bus scaling flag can not be enabled when

include/soc/qcom/qseecomi.h

+22 −0

Original line number	Diff line number	Diff line
		@@ -61,6 +61,7 @@ enum qseecom_qceos_cmd_id {
		QSEOS_TEE_INVOKE_MODFD_COMMAND = QSEOS_TEE_INVOKE_COMMAND,
		QSEOS_TEE_CLOSE_SESSION,
		QSEOS_TEE_REQUEST_CANCELLATION,
		QSEOS_CONTINUE_BLOCKED_REQ_COMMAND,
		QSEOS_FSM_LTE_INIT_DB = 0x100,
		QSEOS_FSM_LTE_STORE_KENB = 0x101,
		QSEOS_FSM_LTE_GEN_KEYS = 0x102,
		@@ -92,6 +93,15 @@ enum qseecom_pipe_type {
		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
		};

		__packed struct qsee_apps_region_info_ireq {
		uint32_t qsee_cmd_id;
		uint32_t addr;
		@@ -304,6 +314,11 @@ __packed struct qseecom_client_send_fsm_key_req {
		uint32_t rsp_len;
		};

		__packed struct qseecom_continue_blocked_request_ireq {
		uint32_t qsee_cmd_id;
		uint32_t app_id;
		};


		/******** ARMV8 SMC INTERFACE TZ MACRO *****************/

		@@ -407,6 +422,13 @@ __packed struct qseecom_client_send_fsm_key_req {
		*/
		#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 read-only */
		#define TZ_SYSCALL_PARAM_TYPE_BUF_RW 0x2 /** type of buffer read-write */