msm: camera: isp: Assign max hw update entries based on stream type

In case of SFE/CSID cmd buffer update, more number of hw update entries
is needed. Assign and allocate this memory dynamically based
on stream type. Also the change makes cdm cmd memory allocation
based on the stream.

CRs-Fixed: 2841729
Change-Id: Iaaa3ce7152a103ace25b24d84776f5a665603994
Signed-off-by: Karthik Anantha Ram <[email protected]>

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);
@@ -6491,6 +6536,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);
 
@@ -11263,16 +11309,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;
 
@@ -11322,7 +11358,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;
@@ -11349,7 +11384,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
  */