Merge "msm: camera: isp: Assign max hw update entries based on stream type" into camera-kernel.lnx.5.0

drivers/cam_isp/cam_isp_context.c

@@ -445,7 +445,7 @@ static int __cam_isp_ctx_enqueue_init_request(
 	if (req_isp_old->hw_update_data.packet_opcode_type ==
 		CAM_ISP_PACKET_INIT_DEV) {
 		if ((req_isp_old->num_cfg + req_isp_new->num_cfg) >=
-			CAM_ISP_CTX_CFG_MAX) {
+			ctx->max_hw_update_entries) {
 			CAM_WARN(CAM_ISP,
 				"Can not merge INIT pkt num_cfgs = %d",
 				(req_isp_old->num_cfg +
@@ -4317,6 +4317,7 @@ static void __cam_isp_ctx_free_mem_hw_entries(struct cam_context *ctx)
 	ctx->hw_update_entry = NULL;
 	ctx->max_out_map_entries = 0;
 	ctx->max_in_map_entries = 0;
+	ctx->max_hw_update_entries = 0;
 }
 
 static int __cam_isp_ctx_release_hw_in_top_state(struct cam_context *ctx,
@@ -4660,6 +4661,7 @@ static int __cam_isp_ctx_allocate_mem_hw_entries(
 {
 	int rc = 0;
 	uint32_t max_res = 0;
+	uint32_t max_hw_upd_entries = CAM_ISP_CTX_CFG_MAX;
 	struct cam_ctx_request          *req;
 	struct cam_ctx_request          *temp_req;
 	struct cam_isp_ctx_req          *req_isp;
@@ -4669,15 +4671,19 @@ static int __cam_isp_ctx_allocate_mem_hw_entries(
 		max_res = CAM_ISP_CTX_RES_MAX;
 	else {
 		max_res = param->op_params.param_list[0];
-		if (param->op_flags & CAM_IFE_CTX_SFE_EN)
+		if (param->op_flags & CAM_IFE_CTX_SFE_EN) {
 			max_res += param->op_params.param_list[1];
+			max_hw_upd_entries = CAM_ISP_SFE_CTX_CFG_MAX;
+		}
 	}
 
-	ctx->max_in_map_entries = max_res;
-	ctx->max_out_map_entries = max_res;
+	ctx->max_in_map_entries    = max_res;
+	ctx->max_out_map_entries   = max_res;
+	ctx->max_hw_update_entries = max_hw_upd_entries;
 
-	CAM_DBG(CAM_ISP, "Allocate max: 0x%x is_sfe_en: %d",
-		max_res, (param->op_flags & CAM_IFE_CTX_SFE_EN));
+	CAM_DBG(CAM_ISP,
+		"Allocate max_entries: 0x%x max_res: 0x%x is_sfe_en: %d",
+		max_hw_upd_entries, max_res, (param->op_flags & CAM_IFE_CTX_SFE_EN));
 
 	num_entries = ctx->max_hw_update_entries * CAM_ISP_CTX_REQ_MAX;
 	ctx->hw_update_entry = kcalloc(num_entries,
@@ -6202,8 +6208,6 @@ int cam_isp_context_init(struct cam_isp_context *ctx,
 	ctx_base->state_machine = cam_isp_ctx_top_state_machine;
 	ctx_base->ctx_priv = ctx;
 
-	ctx_base->max_hw_update_entries = CAM_ISP_CTX_CFG_MAX;
-
 	/* initializing current state for error logging */
 	for (i = 0; i < CAM_ISP_CTX_STATE_MONITOR_MAX_ENTRIES; i++) {
 		ctx->cam_isp_ctx_state_monitor[i].curr_state =

drivers/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c

@@ -233,6 +233,35 @@ static int cam_ife_mgr_handle_reg_dump(struct cam_ife_hw_mgr_ctx *ctx,
 	return rc;
 }
 
+static inline int cam_ife_mgr_allocate_cdm_cmd(
+	bool is_sfe_en,
+	struct cam_cdm_bl_request **cdm_cmd)
+{
+	int rc = 0;
+	uint32_t cfg_max = CAM_ISP_CTX_CFG_MAX;
+
+	if (is_sfe_en)
+		cfg_max = CAM_ISP_SFE_CTX_CFG_MAX;
+
+	*cdm_cmd = kzalloc(((sizeof(struct cam_cdm_bl_request)) +
+		((cfg_max - 1) *
+		sizeof(struct cam_cdm_bl_cmd))), GFP_KERNEL);
+
+	if (!(*cdm_cmd)) {
+		CAM_ERR(CAM_ISP, "Failed to allocate cdm bl memory");
+		rc = -ENOMEM;
+	}
+
+	return rc;
+}
+
+static inline void cam_ife_mgr_free_cdm_cmd(
+	struct cam_cdm_bl_request **cdm_cmd)
+{
+	kfree(*cdm_cmd);
+	*cdm_cmd = NULL;
+}
+
 static int cam_ife_mgr_get_hw_caps(void *hw_mgr_priv,
 	void *hw_caps_args)
 {
@@ -4675,6 +4704,12 @@ static int cam_ife_mgr_acquire_hw(void *hw_mgr_priv, void *acquire_hw_args)
 		goto free_res;
 	}
 
+	rc = cam_ife_mgr_allocate_cdm_cmd(
+		(ife_ctx->ctx_type == CAM_IFE_CTX_TYPE_SFE ? true : false),
+		&ife_ctx->cdm_cmd);
+	if (rc)
+		goto free_res;
+
 	if (ife_ctx->is_dual)
 		memcpy(cdm_acquire.identifier, "dualife", sizeof("dualife"));
 	else
@@ -4699,7 +4734,7 @@ static int cam_ife_mgr_acquire_hw(void *hw_mgr_priv, void *acquire_hw_args)
 	rc = cam_cdm_acquire(&cdm_acquire);
 	if (rc) {
 		CAM_ERR(CAM_ISP, "Failed to acquire the CDM HW");
-		goto free_res;
+		goto free_cdm_cmd;
 	}
 
 	CAM_DBG(CAM_ISP,
@@ -4755,6 +4790,8 @@ static int cam_ife_mgr_acquire_hw(void *hw_mgr_priv, void *acquire_hw_args)
 
 	return 0;
 
+free_cdm_cmd:
+	cam_ife_mgr_free_cdm_cmd(&ife_ctx->cdm_cmd);
 free_res:
 	cam_ife_hw_mgr_release_hw_for_ctx(ife_ctx);
 free_mem:
@@ -4976,6 +5013,11 @@ static int cam_ife_mgr_acquire_dev(void *hw_mgr_priv, void *acquire_hw_args)
 		goto free_res;
 	}
 
+	rc = cam_ife_mgr_allocate_cdm_cmd(false,
+		&ife_ctx->cdm_cmd);
+	if (rc)
+		goto free_res;
+
 	cam_cpas_get_cpas_hw_version(&ife_ctx->hw_version);
 	ife_ctx->internal_cdm = false;
 
@@ -4999,7 +5041,7 @@ static int cam_ife_mgr_acquire_dev(void *hw_mgr_priv, void *acquire_hw_args)
 	rc = cam_cdm_acquire(&cdm_acquire);
 	if (rc) {
 		CAM_ERR(CAM_ISP, "Failed to acquire the CDM HW");
-		goto free_res;
+		goto free_cdm_cmd;
 	}
 
 	CAM_DBG(CAM_ISP, "Successfully acquired CDM ID:%d, CDM HW hdl=%x",
@@ -5022,6 +5064,9 @@ static int cam_ife_mgr_acquire_dev(void *hw_mgr_priv, void *acquire_hw_args)
 	cam_ife_hw_mgr_put_ctx(&ife_hw_mgr->used_ctx_list, &ife_ctx);
 
 	return 0;
+
+free_cdm_cmd:
+	cam_ife_mgr_free_cdm_cmd(&ife_ctx->cdm_cmd);
 free_res:
 	cam_ife_hw_mgr_release_hw_for_ctx(ife_ctx);
 	cam_cdm_release(ife_ctx->cdm_handle);
@@ -6501,6 +6546,7 @@ static int cam_ife_mgr_release_hw(void *hw_mgr_priv,
 		ctx->epoch_cnt[i] = 0;
 	}
 
+	cam_ife_mgr_free_cdm_cmd(&ctx->cdm_cmd);
 	CAM_INFO(CAM_ISP, "Release HW success ctx id: %u",
 		ctx->ctx_index);
 
@@ -11273,16 +11319,6 @@ int cam_ife_hw_mgr_init(struct cam_hw_mgr_intf *hw_mgr_intf, int *iommu_hdl)
 				&g_ife_hw_mgr.ctx_pool[i].free_res_list);
 		}
 
-		g_ife_hw_mgr.ctx_pool[i].cdm_cmd =
-			kzalloc(((sizeof(struct cam_cdm_bl_request)) +
-				((CAM_ISP_CTX_CFG_MAX - 1) *
-				 sizeof(struct cam_cdm_bl_cmd))), GFP_KERNEL);
-		if (!g_ife_hw_mgr.ctx_pool[i].cdm_cmd) {
-			rc = -ENOMEM;
-			CAM_ERR(CAM_ISP, "Allocation Failed for cdm command");
-			goto end;
-		}
-
 		g_ife_hw_mgr.ctx_pool[i].ctx_index = i;
 		g_ife_hw_mgr.ctx_pool[i].hw_mgr = &g_ife_hw_mgr;
 
@@ -11332,7 +11368,6 @@ end:
 		for (i = 0; i < CAM_IFE_CTX_MAX; i++) {
 			cam_tasklet_deinit(
 				&g_ife_hw_mgr.mgr_common.tasklet_pool[i]);
-			kfree(g_ife_hw_mgr.ctx_pool[i].cdm_cmd);
 			g_ife_hw_mgr.ctx_pool[i].cdm_cmd = NULL;
 			kfree(g_ife_hw_mgr.ctx_pool[i].res_list_ife_out);
 			g_ife_hw_mgr.ctx_pool[i].res_list_ife_out = NULL;
@@ -11359,7 +11394,6 @@ void cam_ife_hw_mgr_deinit(void)
 	for (i = 0; i < CAM_IFE_CTX_MAX; i++) {
 		cam_tasklet_deinit(
 			&g_ife_hw_mgr.mgr_common.tasklet_pool[i]);
-		kfree(g_ife_hw_mgr.ctx_pool[i].cdm_cmd);
 		g_ife_hw_mgr.ctx_pool[i].cdm_cmd = NULL;
 		kfree(g_ife_hw_mgr.ctx_pool[i].res_list_ife_out);
 		g_ife_hw_mgr.ctx_pool[i].res_list_ife_out = NULL;

drivers/cam_isp/isp_hw_mgr/include/cam_isp_hw_mgr_intf.h

@@ -45,6 +45,13 @@
  */
 #define CAM_ISP_CTX_CFG_MAX                     25
 
+/*
+ * Maximum configuration entry size including SFE & CSID - This is based on the
+ * worst case DUAL IFE/SFE use case plus some margin.
+ */
+#define CAM_ISP_SFE_CTX_CFG_MAX                 40
+
+
 /**
  *  enum cam_isp_hw_event_type - Collection of the ISP hardware events
  */