Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 09382c1b authored by Zhen Kong's avatar Zhen Kong
Browse files

qseecom: Improve reentrancy operation for QSEE OS-level scm_call cmds 



-- QSEE reentrancy(RE) doesn't support QSEE OS class service until phase-3,
and QSEE OS level scm_call operations will fail if there is any blocked
TZ app. So, qseecom driver needs to first check if no app blocked before
sending QSEE OS level scm call, and then wait until all apps are unblocked.
This check was only added to app_loading/unloading/querying cmds before,
then add it to other QSEE OS level cmds.

-- Some ioctl reqs don't have global tz access mutex, like KMS requests,
which should be added as only one scm call can be sent to TZ.

-- Wrap the new scm_call to continue blocked req into qseecom_scm_call.

-- Improve wait event processing, block signals before wait and restore
after wakeup.

Change-Id: I3c7ad9165318b27d73ae5cec878fa9ae7748a76a
Signed-off-by: default avatarZhen Kong <zkong@codeaurora.org>
parent 9f5234bb

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 */