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

Commit 2c714287 authored by Lakshmi Narayana Kalavala's avatar Lakshmi Narayana Kalavala Committed by Soundrapandian Jeyaprakash
Browse files

msm: camera: Enable Support for secure camera 



This patch enables the support for secure camera
feature. Secure camera lets trusted apps in user space
stream camera frames for various security applications.

Change-Id: Ia2204d2d62cef2764c106f57f64fac2981b27b94
Signed-off-by: default avatarSeemanta Dutta <seemanta@codeaurora.org>
Signed-off-by: default avatarLakshmi Narayana Kalavala <lkalaval@codeaurora.org>
Signed-off-by: default avatarSoundrapandian Jeyaprakash <jsoundra@codeaurora.org>
parent 53912dd1

Documentation/devicetree/bindings/media/video/msm-cam-smmu.txt

+5 −0
Original line number Diff line number Diff line
@@ -56,6 +56,11 @@ Second Level Node - CAM SMMU context bank device or firmware device 
  Value type: <string>

  Definition: Should specify a string label to identify the context bank.



- qcom,secure-cb

  Usage: optional

  Value type: boolean

  Definition: Specifies if the context bank is a secure context bank.



=============================================

Third Level Node - CAM SMMU memory map device

=============================================

arch/arm64/boot/dts/qcom/sdm845-camera.dtsi

+1 −11
Original line number Diff line number Diff line
@@ -325,18 +325,8 @@ 


		msm_cam_smmu_secure {

			compatible = "qcom,msm-cam-smmu-cb";

			iommus = <&apps_smmu 0x1001 0x0>;

			label = "cam-secure";

			cam_secure_iova_mem_map: iova-mem-map {

				/* Secure IO region is approximately 3.4 GB */

				iova-mem-region-io {

					iova-region-name = "io";

					iova-region-start = <0x7400000>;

					iova-region-len = <0xd8c00000>;

					iova-region-id = <0x3>;

					status = "ok";

				};

			};

			qcom,secure-cb;

		};



		msm_cam_smmu_fd {

arch/arm64/boot/dts/qcom/sdm845-v2-camera.dtsi

+1 −11
Original line number Diff line number Diff line
@@ -243,18 +243,8 @@ 


		msm_cam_smmu_secure {

			compatible = "qcom,msm-cam-smmu-cb";

			iommus = <&apps_smmu 0x1001 0x0>;

			label = "cam-secure";

			cam_secure_iova_mem_map: iova-mem-map {

				/* Secure IO region is approximately 3.4 GB */

				iova-mem-region-io {

					iova-region-name = "io";

					iova-region-start = <0x7400000>;

					iova-region-len = <0xd8c00000>;

					iova-region-id = <0x3>;

					status = "ok";

				};

			};

			qcom,secure-cb;

		};

	};

drivers/media/platform/msm/camera/cam_fd/fd_hw_mgr/cam_fd_hw_mgr.c

+1 −1
Original line number Diff line number Diff line
@@ -1376,7 +1376,7 @@ static int cam_fd_mgr_hw_prepare_update(void *hw_mgr_priv, 


	/* We do not expect any patching, but just do it anyway */

	rc = cam_packet_util_process_patches(prepare->packet,

		hw_mgr->device_iommu.non_secure);

		hw_mgr->device_iommu.non_secure, -1);

	if (rc) {

		CAM_ERR(CAM_FD, "Patch FD packet failed, rc=%d", rc);

		return rc;

drivers/media/platform/msm/camera/cam_icp/icp_hw/icp_hw_mgr/cam_icp_hw_mgr.c

+46 −17
Original line number Diff line number Diff line
@@ -1550,6 +1550,7 @@ static int cam_icp_mgr_hw_close(void *hw_priv, void *hw_close_args) 
	cam_icp_mgr_device_deinit(hw_mgr);

	cam_icp_free_hfi_mem();

	hw_mgr->fw_download = false;

	hw_mgr->secure_mode = CAM_SECURE_MODE_NON_SECURE;

	mutex_unlock(&hw_mgr->hw_mgr_mutex);



	return rc;
@@ -2146,7 +2147,8 @@ static int cam_icp_mgr_prepare_hw_update(void *hw_mgr_priv, 
	}



	/* Update Buffer Address from handles and patch information */

	rc = cam_packet_util_process_patches(packet, hw_mgr->iommu_hdl);

	rc = cam_packet_util_process_patches(packet, hw_mgr->iommu_hdl,

		hw_mgr->iommu_sec_hdl);

	if (rc) {

		mutex_unlock(&ctx_data->ctx_mutex);

		return rc;
@@ -2239,6 +2241,7 @@ static int cam_icp_mgr_release_hw(void *hw_mgr_priv, void *release_hw_args) 
			NULL, 0);

		cam_icp_mgr_hw_close(hw_mgr, NULL);

		cam_icp_hw_mgr_reset_clk_info(hw_mgr);

		hw_mgr->secure_mode = CAM_SECURE_MODE_NON_SECURE;

	}



	return rc;
@@ -2384,6 +2387,12 @@ static int cam_icp_get_acquire_info(struct cam_icp_hw_mgr *hw_mgr, 
		sizeof(struct cam_icp_acquire_dev_info)))

		return -EFAULT;



	if (icp_dev_acquire_info.secure_mode > CAM_SECURE_MODE_SECURE) {

		CAM_ERR(CAM_ICP, "Invalid mode:%d",

			icp_dev_acquire_info.secure_mode);

		return -EINVAL;

	}



	if (icp_dev_acquire_info.num_out_res > ICP_MAX_OUTPUT_SUPPORTED) {

		CAM_ERR(CAM_ICP, "num of out resources exceeding : %u",

			icp_dev_acquire_info.num_out_res);
@@ -2396,28 +2405,46 @@ static int cam_icp_get_acquire_info(struct cam_icp_hw_mgr *hw_mgr, 
		return -EFAULT;

	}



	if (!hw_mgr->ctxt_cnt) {

		hw_mgr->secure_mode = icp_dev_acquire_info.secure_mode;

	} else {

		if (hw_mgr->secure_mode != icp_dev_acquire_info.secure_mode) {

			CAM_ERR(CAM_ICP,

				"secure mode mismatch driver:%d, context:%d",

				hw_mgr->secure_mode,

				icp_dev_acquire_info.secure_mode);

			return -EINVAL;

		}

	}



	acquire_size = sizeof(struct cam_icp_acquire_dev_info) +

		(icp_dev_acquire_info.num_out_res *

		sizeof(struct cam_icp_res_info));

	ctx_data->icp_dev_acquire_info = kzalloc(acquire_size, GFP_KERNEL);

	if (!ctx_data->icp_dev_acquire_info)

	if (!ctx_data->icp_dev_acquire_info) {

		if (!hw_mgr->ctxt_cnt)

			hw_mgr->secure_mode = CAM_SECURE_MODE_NON_SECURE;

		return -ENOMEM;

	}



	if (copy_from_user(ctx_data->icp_dev_acquire_info,

		(void __user *)args->acquire_info, acquire_size)) {

		if (!hw_mgr->ctxt_cnt)

			hw_mgr->secure_mode = CAM_SECURE_MODE_NON_SECURE;

		kfree(ctx_data->icp_dev_acquire_info);

		ctx_data->icp_dev_acquire_info = NULL;

		return -EFAULT;

	}



	CAM_DBG(CAM_ICP, "%x %x %x %x %x %x %x",

	CAM_DBG(CAM_ICP, "%x %x %x %x %x %x %x %u",

		ctx_data->icp_dev_acquire_info->dev_type,

		ctx_data->icp_dev_acquire_info->in_res.format,

		ctx_data->icp_dev_acquire_info->in_res.width,

		ctx_data->icp_dev_acquire_info->in_res.height,

		ctx_data->icp_dev_acquire_info->in_res.fps,

		ctx_data->icp_dev_acquire_info->num_out_res,

		ctx_data->icp_dev_acquire_info->scratch_mem_size);

		ctx_data->icp_dev_acquire_info->scratch_mem_size,

		hw_mgr->secure_mode);



	p_icp_out = ctx_data->icp_dev_acquire_info->out_res;

	for (i = 0; i < icp_dev_acquire_info.num_out_res; i++)
@@ -2470,18 +2497,10 @@ static int cam_icp_mgr_acquire_hw(void *hw_mgr_priv, void *acquire_hw_args) 
		goto acquire_info_failed;

	icp_dev_acquire_info = ctx_data->icp_dev_acquire_info;



	/* Get IOCONFIG command info */

	if (icp_dev_acquire_info->secure_mode)

		rc = cam_mem_get_io_buf(

			icp_dev_acquire_info->io_config_cmd_handle,

			hw_mgr->iommu_sec_hdl,

			&io_buf_addr, &io_buf_size);

	else

	rc = cam_mem_get_io_buf(

		icp_dev_acquire_info->io_config_cmd_handle,

		hw_mgr->iommu_hdl,

		&io_buf_addr, &io_buf_size);



	if (rc) {

		CAM_ERR(CAM_ICP, "unable to get src buf info from io desc");

		goto get_io_buf_failed;
@@ -2808,6 +2827,7 @@ int cam_icp_hw_mgr_init(struct device_node *of_node, uint64_t *hw_mgr_hdl) 
	hw_mgr_intf->download_fw = cam_icp_mgr_download_fw;

	hw_mgr_intf->hw_close = cam_icp_mgr_hw_close;



	icp_hw_mgr.secure_mode = CAM_SECURE_MODE_NON_SECURE;

	mutex_init(&icp_hw_mgr.hw_mgr_mutex);

	spin_lock_init(&icp_hw_mgr.hw_mgr_lock);
@@ -2820,7 +2840,7 @@ int cam_icp_hw_mgr_init(struct device_node *of_node, uint64_t *hw_mgr_hdl) 


	rc = cam_smmu_get_handle("icp", &icp_hw_mgr.iommu_hdl);

	if (rc) {

		CAM_ERR(CAM_ICP, "icp get iommu handle failed: %d", rc);

		CAM_ERR(CAM_ICP, "get mmu handle failed: %d", rc);

		goto icp_get_hdl_failed;

	}
@@ -2830,6 +2850,12 @@ int cam_icp_hw_mgr_init(struct device_node *of_node, uint64_t *hw_mgr_hdl) 
		goto icp_attach_failed;

	}



	rc = cam_smmu_get_handle("cam-secure", &icp_hw_mgr.iommu_sec_hdl);

	if (rc) {

		CAM_ERR(CAM_ICP, "get secure mmu handle failed: %d", rc);

		goto secure_hdl_failed;

	}



	rc = cam_icp_mgr_create_wq();

	if (rc)

		goto icp_wq_create_failed;
@@ -2839,6 +2865,9 @@ int cam_icp_hw_mgr_init(struct device_node *of_node, uint64_t *hw_mgr_hdl) 
	return rc;



icp_wq_create_failed:

	cam_smmu_destroy_handle(icp_hw_mgr.iommu_sec_hdl);

	icp_hw_mgr.iommu_sec_hdl = -1;

secure_hdl_failed:

	cam_smmu_ops(icp_hw_mgr.iommu_hdl, CAM_SMMU_DETACH);

icp_attach_failed:

	cam_smmu_destroy_handle(icp_hw_mgr.iommu_hdl);