msm: camera: icp: PIL loading changes for kvm

Map fw region in hlos in case of kvm hypervisor.

Change-Id: I9ca102b5f47cc33b966f60075d46d18ad027453d
Signed-off-by: Vikram Sharma <vikramsa@qti.qualcomm.com>
Signed-off-by: Ignatius Michael Jihan <mignatiu@qti.qualcomm.com>

Author: quic-vikramsa

camera/drivers/cam_cpas/cam_cpas_soc.c

@@ -1468,10 +1468,14 @@ int cam_cpas_get_custom_dt_info(struct cam_hw_info *cpas_hw,
 
 	soc_private->enable_smart_qos = of_property_read_bool(of_node,
 			"enable-smart-qos");
-	soc_private->enable_secure_qos_update = of_property_read_bool(of_node,
-			"enable-secure-qos-update");
-	CAM_DBG(CAM_CPAS, "Enable secure qos update: %s",
-		CAM_BOOL_TO_YESNO(soc_private->enable_secure_qos_update));
+	rc = of_property_read_u32(of_node, "enable-secure-qos-update",
+			&soc_private->enable_secure_qos_update);
+	if (rc) {
+		soc_private->enable_secure_qos_update = 0;
+		rc = 0;
+	}
+	CAM_DBG(CAM_CPAS, "Enable secure qos update: %d",
+		soc_private->enable_secure_qos_update);
 
 	if (soc_private->enable_smart_qos) {
 		uint32_t value;

camera/drivers/cam_cpas/cam_cpas_soc.h

@@ -304,7 +304,7 @@ struct cam_cpas_private_soc {
 	uint32_t num_caches;
 	uint32_t part_info;
 	struct cam_sys_cache_info *llcc_info;
-	bool enable_secure_qos_update;
+	uint32_t enable_secure_qos_update;
 	bool enable_smart_qos;
 	bool enable_cam_ddr_drv;
 	bool enable_cam_clk_drv;

camera/drivers/cam_icp/cam_icp_subdev.c

@@ -28,6 +28,7 @@
 #include "cam_icp_context.h"
 #include "cam_hw_mgr_intf.h"
 #include "cam_icp_hw_mgr_intf.h"
+#include "cam_icp_hw_intf.h"
 #include "cam_debug_util.h"
 #include "cam_smmu_api.h"
 #include "camera_main.h"
@@ -50,6 +51,7 @@ struct cam_icp_subdev {
 	int32_t reserved;
 };
 
+struct camera_firmware cam_fw;
 static DEFINE_MUTEX(g_dev_lock);
 static struct cam_icp_subdev *g_icp_dev[CAM_ICP_SUBDEV_MAX];
 
@@ -257,6 +259,89 @@ static inline int cam_icp_subdev_clean_up(uint32_t device_idx)
 	return 0;
 }
 
+void cam_put_domain_for_fw(struct camera_firmware *fw)
+{
+	if (!fw)
+		return;
+
+	if (fw->iommu_domain) {
+		/*
+		 * No explicit release function for iommu_get_domain_for_dev,
+		 * but if you attached a domain, detach it here.
+		 */
+		iommu_detach_device(fw->iommu_domain, fw->dev);
+		fw->iommu_domain = NULL;
+	}
+
+	if (fw->dev) {
+		of_node_put(fw->dev->of_node);
+		platform_device_unregister(to_platform_device(fw->dev));
+		fw->dev = NULL;
+	}
+
+	fw->has_el2_iommu = false;
+}
+
+static int cam_get_domain_for_fw(struct device *dev, struct camera_firmware *fw)
+{
+	struct platform_device *pdev_fw = NULL;
+	struct platform_device_info info;
+	struct device_node *np = NULL;
+	int rc = 0;
+
+	np = of_get_child_by_name(dev->of_node, "camera-firmware");
+	if (!np) {
+		CAM_INFO(CAM_ICP, "camera-firmware, not overlayed. no KVM");
+		fw->has_el2_iommu = false;
+		return 0;
+	}
+
+	fw->has_el2_iommu = true;
+	memset(&info, 0, sizeof(info));
+	info.fwnode   = &np->fwnode;
+	info.parent   = dev;
+	info.name     = np->name;
+	info.dma_mask = DMA_BIT_MASK(32);
+
+	pdev_fw = platform_device_register_full(&info);
+	if (IS_ERR(pdev_fw)) {
+		rc = PTR_ERR(pdev_fw);
+		CAM_ERR(CAM_ICP, "platform_device_register_full failed: %d", rc);
+		goto cleanup_np;
+	}
+
+	pdev_fw->dev.of_node = np;
+
+	rc = of_dma_configure(&pdev_fw->dev, np, true);
+	if (rc) {
+		CAM_ERR(CAM_ICP, "DMA configuration failed: %d", rc);
+		pdev_fw->dev.of_node = NULL;
+		goto unregister_pdev;
+	}
+
+	fw->dev = &pdev_fw->dev;
+
+	fw->iommu_domain = iommu_get_domain_for_dev(fw->dev);
+	if (!fw->iommu_domain) {
+		CAM_ERR(CAM_ICP, "Failed to get IOMMU domain");
+		rc = -ENOMEM;
+		goto unregister_pdev;
+	}
+
+	CAM_INFO(CAM_ICP, "KVM Enabled - fw.dev: %p, fw.iommu_domain: %p", fw->dev,
+			fw->iommu_domain);
+	return 0;
+
+unregister_pdev:
+	platform_device_unregister(pdev_fw);
+	fw->dev = NULL;
+
+cleanup_np:
+	of_node_put(np);
+	fw->has_el2_iommu = false;
+	return rc;
+}
+
 static int cam_icp_component_bind(struct device *dev,
 	struct device *master_dev, void *data)
 {
@@ -356,6 +441,12 @@ static int cam_icp_component_bind(struct device *dev,
 		goto ctx_fail;
 	}
 
+	rc = cam_get_domain_for_fw(dev, &cam_fw);
+	if (rc) {
+		CAM_ERR(CAM_ICP, "device[%s] get domain for fw failed: %d", subdev_name, rc);
+		goto ctx_fail;
+	}
+
 	cam_common_register_evt_inject_cb(cam_icp_dev_evt_inject_cb,
 		CAM_COMMON_EVT_INJECT_HW_ICP);
 
@@ -364,12 +455,18 @@ static int cam_icp_component_bind(struct device *dev,
 
 	icp_dev->open_cnt = 0;
 	rc = cam_subdev_register(&icp_dev->sd, pdev);
+	if (rc) {
+		CAM_ERR(CAM_ICP, "device[%s] subdev register failed: %d", subdev_name, rc);
+		goto fw_cleanup;
+	}
 
 	CAM_DBG(CAM_ICP, "device[%s] id: %u component bound successfully",
 		subdev_name, device_idx);
 
 	return rc;
 
+fw_cleanup:
+	cam_put_domain_for_fw(&cam_fw);
 ctx_fail:
 	for (--i; i >= 0; i--)
 		cam_icp_context_deinit(&icp_dev->ctx_icp[i]);

camera/drivers/cam_icp/icp_hw/icp_hw_mgr/include/cam_icp_hw_intf.h

@@ -133,4 +133,13 @@ struct cam_icp_ubwc_cfg_cmd {
 	bool disable_ubwc_comp;
 };
 
+struct camera_firmware {
+	struct device *dev;
+	struct iommu_domain *iommu_domain;
+	struct qcom_scm_pas_context *ctx;
+	phys_addr_t mem_phys;
+	size_t mem_size;
+	bool has_el2_iommu;
+};
+
 #endif

camera/drivers/cam_icp/icp_hw/icp_proc/icp_v2_hw/cam_icp_v2_core.c

@@ -595,7 +595,7 @@ static int cam_icp_v2_non_sec_boot(
 
 #if IS_REACHABLE(CONFIG_QCOM_MDT_LOADER)
 static int __load_firmware(struct platform_device *pdev,
-	uint32_t fw_pas_id)
+	uint32_t fw_pas_id, struct camera_firmware *fw)
 {
 	const char *fw_name;
 	const struct firmware *firmware = NULL;
@@ -670,13 +670,26 @@ static int __load_firmware(struct platform_device *pdev,
 		goto out;
 	}
 
-	rc = qcom_mdt_load(&pdev->dev, firmware, firmware_name, fw_pas_id,
-			vaddr, res_start, res_size, NULL);
+	fw->ctx = qcom_scm_pas_context_init(&pdev->dev, fw_pas_id, res_start,
+			res_size);
+	if (IS_ERR_OR_NULL(fw->ctx)) {
+		rc = fw->ctx ? PTR_ERR(fw->ctx) : -ENOMEM;
+		fw->ctx = NULL;
+		goto out;
+	}
+	fw->ctx->has_iommu = fw->has_el2_iommu;
+
+	rc = qcom_mdt_pas_load(fw->ctx, firmware, firmware_name, vaddr, NULL);
 	if (rc) {
 		CAM_ERR(CAM_ICP, "failed to load firmware rc=%d", rc);
+		fw->ctx = NULL;
 		goto out;
 	}
 
+	fw->mem_phys = res_start;
+	fw->mem_size = res_size;
+
+	CAM_DBG(CAM_ICP, "res_start=0x%x, res_size=%zu", res_start, res_size);
 out:
 	if (vaddr)
 		iounmap(vaddr);
@@ -714,14 +727,28 @@ static int cam_icp_v2_boot(struct cam_hw_info *icp_v2_info,
 	prepare_boot(icp_v2_info, args);
 
 #if IS_REACHABLE(CONFIG_QCOM_MDT_LOADER)
-	rc = __load_firmware(icp_v2_info->soc_info.pdev, soc_priv->fw_pas_id);
+	rc = __load_firmware(icp_v2_info->soc_info.pdev,
+			soc_priv->fw_pas_id, core_info->fw);
 	if (rc) {
 		CAM_ERR(CAM_ICP, "firmware loading failed rc=%d", rc);
 		goto err;
 	}
 #endif
 
-	rc = qcom_scm_pas_auth_and_reset(soc_priv->fw_pas_id);
+	if (core_info->fw->has_el2_iommu) {
+		rc = iommu_map(core_info->fw->iommu_domain, 0, core_info->fw->mem_phys,
+				core_info->fw->mem_size, IOMMU_READ | IOMMU_WRITE | IOMMU_PRIV,
+				GFP_KERNEL);
+		if (rc) {
+			CAM_ERR(CAM_ICP, "FW Region mapping failed for KVM rc=%d", rc);
+			goto err;
+		}
+	} else {
+		core_info->fw->mem_phys = 0;
+		core_info->fw->mem_size = 0;
+	}
+
+	rc = qcom_scm_pas_prepare_and_auth_reset(core_info->fw->ctx);
 	if (rc) {
 		CAM_ERR(CAM_ICP, "auth and reset failed rc=%d", rc);
 		goto err;
@@ -746,8 +773,10 @@ static int cam_icp_v2_shutdown(struct cam_hw_info *icp_v2_info)
 
 	if (core_info->use_sec_pil) {
 		rc = qcom_scm_pas_shutdown(soc_priv->fw_pas_id);
-	}
-	else {
+		if (core_info->fw->has_el2_iommu)
+			iommu_unmap(core_info->fw->iommu_domain, 0,
+				core_info->fw->mem_size);
+	} else {
 		int32_t sys_base_idx = core_info->reg_base_idx[ICP_V2_SYS_BASE];
 		void __iomem *base;
 

camera/drivers/cam_icp/icp_hw/icp_proc/icp_v2_hw/cam_icp_v2_core.h

@@ -39,6 +39,7 @@ struct cam_icp_v2_core_info {
 		uintptr_t fw_kva_addr;
 		uint64_t fw_buf_len;
 	} fw_params;
+	struct camera_firmware *fw;
 	bool cpas_start;
 	bool use_sec_pil;
 	bool is_irq_test;

camera/drivers/cam_icp/icp_hw/icp_proc/icp_v2_hw/cam_icp_v2_dev.c

@@ -17,6 +17,7 @@
 #include "cam_icp_soc_common.h"
 
 static int max_icp_v2_hw_idx = -1;
+extern struct camera_firmware cam_fw;
 
 struct cam_icp_v2_hw_info cam_icp_v2_hw_info[] = {
 	{
@@ -171,6 +172,7 @@ static int cam_icp_v2_component_bind(struct device *dev,
 
 	platform_set_drvdata(pdev, icp_v2_intf);
 
+	core_info->fw = &cam_fw;
 	return 0;
 
 res_deinit: