Merge "qseecom: fix incomplete error handling for several functions" (28c7c231) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/misc/qseecom.c

+199 −63

Original line number	Diff line number	Diff line
		@@ -1293,9 +1293,11 @@ static int __qseecom_set_msm_bus_request(uint32_t mode)
		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
		if (mode == INACTIVE) {
		ret = __qseecom_enable_clk(CLK_QSEE);
		if (ret)
		pr_err("CLK enable failed\n");
		} else
		__qseecom_disable_clk(CLK_QSEE);
		}
		}
		@@ -1603,12 +1605,21 @@ static int __qseecom_qseos_fail_return_resp_tz(struct qseecom_dev_handle *data,
		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,
		if (ptr_svc && ptr_svc->ihandle) {
		ret = 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);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		return ret;
		}
		}

		if (lstnr == RPMB_SERVICE) {
		ret = __qseecom_enable_clk(CLK_QSEE);
		if (ret)
		return ret;
		}
		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, send_data_rsp,
		sizeof(send_data_rsp), resp, sizeof(*resp));
		if (ret) {
		@@ -1764,13 +1775,22 @@ static int __qseecom_process_incomplete_cmd(struct qseecom_dev_handle *data,
		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,
		if (ptr_svc) {
		ret = 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 (ret) {
		pr_err("cache operation failed %d\n", ret);
		return ret;
		}
		}

		if ((lstnr == RPMB_SERVICE) \|\| (lstnr == SSD_SERVICE))
		__qseecom_enable_clk(CLK_QSEE);
		if ((lstnr == RPMB_SERVICE) \|\| (lstnr == SSD_SERVICE)) {
		ret = __qseecom_enable_clk(CLK_QSEE);
		if (ret)
		return ret;
		}

		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1,
		cmd_buf, cmd_len, resp, sizeof(*resp));
		@@ -2005,13 +2025,21 @@ static int __qseecom_reentrancy_process_incomplete_cmd(
		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,
		if (ptr_svc) {
		ret = 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);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		return ret;
		}
		}
		if (lstnr == RPMB_SERVICE) {
		ret = __qseecom_enable_clk(CLK_QSEE);
		if (ret)
		return ret;
		}

		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1,
		cmd_buf, cmd_len, resp, sizeof(*resp));
		@@ -2296,8 +2324,12 @@ static int qseecom_load_app(struct qseecom_dev_handle data, void __user argp)
		cmd_len = sizeof(struct qseecom_load_app_64bit_ireq);
		}

		msm_ion_do_cache_op(qseecom.ion_clnt, ihandle, NULL, len,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt, ihandle, NULL, len,
		ION_IOC_CLEAN_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		goto loadapp_err;
		}

		/* SCM_CALL to load the app and get the app_id back */
		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, cmd_buf,
		@@ -2775,15 +2807,16 @@ static int qseecom_send_service_cmd(struct qseecom_dev_handle *data,
		}
		}

		msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle,
		data->client.sb_virt, data->client.sb_length,
		ION_IOC_CLEAN_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		goto exit;
		}
		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) {
		@@ -2795,7 +2828,13 @@ static int qseecom_send_service_cmd(struct qseecom_dev_handle *data,
		}
		goto exit;
		}

		ret = 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("cache operation failed %d\n", ret);
		goto exit;
		}
		switch (resp.result) {
		case QSEOS_RESULT_SUCCESS:
		break;
		@@ -3028,10 +3067,14 @@ static int __qseecom_send_cmd(struct qseecom_dev_handle *data,
		else
		(uint32_t )cmd_buf = QSEOS_CLIENT_SEND_DATA_COMMAND_WHITELIST;

		msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle,
		data->client.sb_virt,
		reqd_len_sb_in,
		ION_IOC_CLEAN_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		return ret;
		}

		__qseecom_reentrancy_check_if_this_app_blocked(ptr_app);

		@@ -3062,9 +3105,11 @@ static int __qseecom_send_cmd(struct qseecom_dev_handle *data,
		}
		}
		}
		msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle,
		ret = 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("cache operation failed %d\n", ret);
		return ret;
		}

		@@ -3176,7 +3221,7 @@ static int __qseecom_update_cmd_buf(void *msg, bool cleanup,
		}
		/* Populate the cmd data structure with the phys_addr */
		sg_ptr = ion_sg_table(qseecom.ion_clnt, ihandle);
		if (sg_ptr == NULL) {
		if (IS_ERR_OR_NULL(sg_ptr)) {
		pr_err("IOn client could not retrieve sg table\n");
		goto err;
		}
		@@ -3284,13 +3329,21 @@ static int __qseecom_update_cmd_buf(void *msg, bool cleanup,
		}

		if (cleanup) {
		msm_ion_do_cache_op(qseecom.ion_clnt,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt,
		ihandle, NULL, len,
		ION_IOC_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		goto err;
		}
		} else {
		msm_ion_do_cache_op(qseecom.ion_clnt,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt,
		ihandle, NULL, len,
		ION_IOC_CLEAN_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		goto err;
		}
		if (data->type == QSEECOM_CLIENT_APP) {
		offset = req->ifd_data[i].cmd_buf_offset;
		data->sglistinfo_ptr[i].indexAndFlags =
		@@ -3431,7 +3484,7 @@ static int __qseecom_update_cmd_buf_64(void *msg, bool cleanup,
		}
		/* Populate the cmd data structure with the phys_addr */
		sg_ptr = ion_sg_table(qseecom.ion_clnt, ihandle);
		if (sg_ptr == NULL) {
		if (IS_ERR_OR_NULL(sg_ptr)) {
		pr_err("IOn client could not retrieve sg table\n");
		goto err;
		}
		@@ -3514,13 +3567,21 @@ static int __qseecom_update_cmd_buf_64(void *msg, bool cleanup,
		}
		cleanup:
		if (cleanup) {
		msm_ion_do_cache_op(qseecom.ion_clnt,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt,
		ihandle, NULL, len,
		ION_IOC_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		goto err;
		}
		} else {
		msm_ion_do_cache_op(qseecom.ion_clnt,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt,
		ihandle, NULL, len,
		ION_IOC_CLEAN_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		goto err;
		}
		if (data->type == QSEECOM_CLIENT_APP) {
		offset = req->ifd_data[i].cmd_buf_offset;
		data->sglistinfo_ptr[i].indexAndFlags =
		@@ -4009,9 +4070,13 @@ static int __qseecom_load_fw(struct qseecom_dev_handle data, char appname)
		goto exit_unregister_bus_bw_need;
		}

		msm_ion_do_cache_op(qseecom.ion_clnt, ihandle,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt, ihandle,
		img_data, fw_size,
		ION_IOC_CLEAN_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		goto exit_disable_clk_vote;
		}

		/* SCM_CALL to load the image */
		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, cmd_buf, cmd_len,
		@@ -4125,9 +4190,13 @@ static int qseecom_load_commonlib_image(struct qseecom_dev_handle *data,
		goto exit_unregister_bus_bw_need;
		}

		msm_ion_do_cache_op(qseecom.ion_clnt, qseecom.cmnlib_ion_handle,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt, qseecom.cmnlib_ion_handle,
		img_data, fw_size,
		ION_IOC_CLEAN_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		goto exit_disable_clk_vote;
		}

		/* SCM_CALL to load the image */
		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, cmd_buf, cmd_len,
		@@ -4693,9 +4762,10 @@ static int __qseecom_enable_clk(enum qseecom_ce_hw_instance ce)
		}
		mutex_lock(&clk_access_lock);

		if (qclk->clk_access_cnt == ULONG_MAX)
		if (qclk->clk_access_cnt == ULONG_MAX) {
		pr_err("clk_access_cnt beyond limitation\n");
		goto err;

		}
		if (qclk->clk_access_cnt > 0) {
		qclk->clk_access_cnt++;
		mutex_unlock(&clk_access_lock);
		@@ -5008,9 +5078,12 @@ static int qseecom_load_external_elf(struct qseecom_dev_handle *data,
		ret = -EIO;
		goto exit_register_bus_bandwidth_needs;
		}
		msm_ion_do_cache_op(qseecom.ion_clnt, ihandle, NULL, len,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt, ihandle, NULL, len,
		ION_IOC_CLEAN_INV_CACHES);

		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		goto exit_disable_clock;
		}
		/* SCM_CALL to load the external elf */
		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1, cmd_buf, cmd_len,
		&resp, sizeof(resp));
		@@ -5256,7 +5329,9 @@ static int __qseecom_generate_and_save_key(struct qseecom_dev_handle *data,
		pr_err("Error:: unsupported usage %d\n", usage);
		return -EFAULT;
		}
		__qseecom_enable_clk(CLK_QSEE);
		ret = __qseecom_enable_clk(CLK_QSEE);
		if (ret)
		return ret;

		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1,
		ireq, sizeof(struct qseecom_key_generate_ireq),
		@@ -5314,7 +5389,9 @@ static int __qseecom_delete_saved_key(struct qseecom_dev_handle *data,
		pr_err("Error:: unsupported usage %d\n", usage);
		return -EFAULT;
		}
		__qseecom_enable_clk(CLK_QSEE);
		ret = __qseecom_enable_clk(CLK_QSEE);
		if (ret)
		return ret;

		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1,
		ireq, sizeof(struct qseecom_key_delete_ireq),
		@@ -5373,10 +5450,15 @@ static int __qseecom_set_clear_ce_key(struct qseecom_dev_handle *data,
		pr_err("Error:: unsupported usage %d\n", usage);
		return -EFAULT;
		}
		ret = __qseecom_enable_clk(CLK_QSEE);
		if (ret)
		return ret;

		__qseecom_enable_clk(CLK_QSEE);
		if (qseecom.qsee.instance != qseecom.ce_drv.instance)
		__qseecom_enable_clk(CLK_CE_DRV);
		if (qseecom.qsee.instance != qseecom.ce_drv.instance) {
		ret = __qseecom_enable_clk(CLK_CE_DRV);
		if (ret)
		return ret;
		}

		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1,
		ireq, sizeof(struct qseecom_key_select_ireq),
		@@ -5451,8 +5533,9 @@ static int __qseecom_update_current_key_user_info(
		pr_err("Error:: unsupported usage %d\n", usage);
		return -EFAULT;
		}

		__qseecom_enable_clk(CLK_QSEE);
		ret = __qseecom_enable_clk(CLK_QSEE);
		if (ret)
		return ret;

		ret = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1,
		ireq, sizeof(struct qseecom_key_userinfo_update_ireq),
		@@ -5989,7 +6072,9 @@ static int qseecom_mdtp_cipher_dip(void __user *argp)
		desc.args[3] = req.out_buf_size;
		desc.args[4] = req.direction;

		__qseecom_enable_clk(CLK_QSEE);
		ret = __qseecom_enable_clk(CLK_QSEE);
		if (ret)
		break;

		ret = scm_call2(TZ_MDTP_CIPHER_DIP_ID, &desc);

		@@ -6176,7 +6261,7 @@ static int __qseecom_update_qteec_req_buf(struct qseecom_qteec_modfd_req *req,
		}
		/* Populate the cmd data structure with the phys_addr */
		sg_ptr = ion_sg_table(qseecom.ion_clnt, ihandle);
		if (sg_ptr == NULL) {
		if (IS_ERR_OR_NULL(sg_ptr)) {
		pr_err("IOn client could not retrieve sg table\n");
		goto err;
		}
		@@ -6232,13 +6317,21 @@ static int __qseecom_update_qteec_req_buf(struct qseecom_qteec_modfd_req *req,
		}
		clean:
		if (cleanup) {
		msm_ion_do_cache_op(qseecom.ion_clnt,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt,
		ihandle, NULL, sg->length,
		ION_IOC_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		goto err;
		}
		} else {
		msm_ion_do_cache_op(qseecom.ion_clnt,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt,
		ihandle, NULL, sg->length,
		ION_IOC_CLEAN_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		goto err;
		}
		data->sglistinfo_ptr[i].indexAndFlags =
		SGLISTINFO_SET_INDEX_FLAG(
		(sg_ptr->nents == 1), 0,
		@@ -6351,10 +6444,14 @@ static int __qseecom_qteec_issue_cmd(struct qseecom_dev_handle *data,
		(uint32_t )cmd_buf = cmd_id;

		reqd_len_sb_in = req->req_len + req->resp_len;
		msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle,
		data->client.sb_virt,
		reqd_len_sb_in,
		ION_IOC_CLEAN_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		return ret;
		}

		__qseecom_reentrancy_check_if_this_app_blocked(ptr_app);

		@@ -6385,9 +6482,13 @@ static int __qseecom_qteec_issue_cmd(struct qseecom_dev_handle *data,
		}
		}
		}
		msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle,
		ret = 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("cache operation failed %d\n", ret);
		return ret;
		}

		if ((cmd_id == QSEOS_TEE_OPEN_SESSION) \|\|
		(cmd_id == QSEOS_TEE_REQUEST_CANCELLATION)) {
		@@ -6531,10 +6632,14 @@ static int qseecom_qteec_invoke_modfd_cmd(struct qseecom_dev_handle *data,
		else
		(uint32_t )cmd_buf = QSEOS_TEE_INVOKE_COMMAND;

		msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle,
		ret = msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle,
		data->client.sb_virt,
		reqd_len_sb_in,
		ION_IOC_CLEAN_INV_CACHES);
		if (ret) {
		pr_err("cache operation failed %d\n", ret);
		return ret;
		}

		__qseecom_reentrancy_check_if_this_app_blocked(ptr_app);

		@@ -6569,9 +6674,13 @@ static int qseecom_qteec_invoke_modfd_cmd(struct qseecom_dev_handle *data,
		if (ret)
		return ret;

		msm_ion_do_cache_op(qseecom.ion_clnt, data->client.ihandle,
		ret = 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("cache operation failed %d\n", ret);
		return ret;
		}
		return 0;
		}

		@@ -8120,11 +8229,12 @@ static int qseecom_check_whitelist_feature(void)
		static int qseecom_probe(struct platform_device *pdev)
		{
		int rc;
		int ret = 0;
		int i;
		uint32_t feature = 10;
		struct device *class_dev;
		struct msm_bus_scale_pdata *qseecom_platform_support = NULL;
		struct qseecom_command_scm_resp resp;
		struct qseecom_ce_info_use *pce_info_use = NULL;

		qseecom.qsee_bw_count = 0;
		qseecom.qsee_perf_client = 0;
		@@ -8166,7 +8276,7 @@ static int qseecom_probe(struct platform_device *pdev)

		class_dev = device_create(driver_class, NULL, qseecom_device_no, NULL,
		QSEECOM_DEV);
		if (!class_dev) {
		if (IS_ERR(class_dev)) {
		pr_err("class_device_create failed %d\n", rc);
		rc = -ENOMEM;
		goto exit_destroy_class;
		@@ -8205,7 +8315,7 @@ static int qseecom_probe(struct platform_device *pdev)
		qseecom.pdev = class_dev;
		/* Create ION msm client */
		qseecom.ion_clnt = msm_ion_client_create("qseecom-kernel");
		if (qseecom.ion_clnt == NULL) {
		if (IS_ERR_OR_NULL(qseecom.ion_clnt)) {
		pr_err("Ion client cannot be created\n");
		rc = -ENOMEM;
		goto exit_del_cdev;
		@@ -8267,14 +8377,14 @@ static int qseecom_probe(struct platform_device *pdev)
		pr_debug("CE operating frequency is not defined, setting to default 100MHZ\n");
		qseecom.ce_opp_freq_hz = QSEE_CE_CLK_100MHZ;
		}
		ret = __qseecom_init_clk(CLK_QSEE);
		if (ret)
		rc = __qseecom_init_clk(CLK_QSEE);
		if (rc)
		goto exit_destroy_ion_client;

		if ((qseecom.qsee.instance != qseecom.ce_drv.instance) &&
		(qseecom.support_pfe \|\| qseecom.support_fde)) {
		ret = __qseecom_init_clk(CLK_CE_DRV);
		if (ret) {
		rc = __qseecom_init_clk(CLK_CE_DRV);
		if (rc) {
		__qseecom_deinit_clk(CLK_QSEE);
		goto exit_destroy_ion_client;
		}
		@@ -8328,9 +8438,14 @@ static int qseecom_probe(struct platform_device *pdev)
		} else {
		pr_err("Fail to get secure app region info\n");
		rc = -EINVAL;
		goto exit_destroy_ion_client;
		goto exit_deinit_clock;
		}
		rc = __qseecom_enable_clk(CLK_QSEE);
		if (rc) {
		pr_err("CLK_QSEE enabling failed (%d)\n", rc);
		rc = -EIO;
		goto exit_deinit_clock;
		}
		__qseecom_enable_clk(CLK_QSEE);
		rc = qseecom_scm_call(SCM_SVC_TZSCHEDULER, 1,
		cmd_buf, cmd_len,
		&resp, sizeof(resp));
		@@ -8339,7 +8454,7 @@ static int qseecom_probe(struct platform_device *pdev)
		pr_err("send secapp reg fail %d resp.res %d\n",
		rc, resp.result);
		rc = -EINVAL;
		goto exit_destroy_ion_client;
		goto exit_deinit_clock;
		}
		}
		/*
		@@ -8375,7 +8490,28 @@ static int qseecom_probe(struct platform_device *pdev)
		atomic_set(&qseecom.qseecom_state, QSEECOM_STATE_READY);
		return 0;

		exit_deinit_clock:
		__qseecom_deinit_clk(CLK_QSEE);
		if ((qseecom.qsee.instance != qseecom.ce_drv.instance) &&
		(qseecom.support_pfe \|\| qseecom.support_fde))
		__qseecom_deinit_clk(CLK_CE_DRV);
		exit_destroy_ion_client:
		if (qseecom.ce_info.fde) {
		pce_info_use = qseecom.ce_info.fde;
		for (i = 0; i < qseecom.ce_info.num_fde; i++) {
		kzfree(pce_info_use->ce_pipe_entry);
		pce_info_use++;
		}
		kfree(qseecom.ce_info.fde);
		}
		if (qseecom.ce_info.pfe) {
		pce_info_use = qseecom.ce_info.pfe;
		for (i = 0; i < qseecom.ce_info.num_pfe; i++) {
		kzfree(pce_info_use->ce_pipe_entry);
		pce_info_use++;
		}
		kfree(qseecom.ce_info.pfe);
		}
		ion_client_destroy(qseecom.ion_clnt);
		exit_del_cdev:
		cdev_del(&qseecom.cdev);