msm: camera: ife: Changes CSID acquire resource logic (b4f4aa3f) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/media/platform/msm/camera/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c

+204 −169

Original line number	Original line	Diff line number	Diff line
	@@ -225,6 +225,8 @@ static int cam_ife_hw_mgr_start_hw_res(
	CAM_ERR(CAM_ISP, "Can not start HW resources");		CAM_ERR(CAM_ISP, "Can not start HW resources");
	goto err;		goto err;
	}		}
			CAM_DBG(CAM_ISP, "Start HW %d Res %d", hw_intf->hw_idx,
			isp_hw_res->hw_res[i]->res_id);
	} else {		} else {
	CAM_ERR(CAM_ISP, "function null");		CAM_ERR(CAM_ISP, "function null");
	goto err;		goto err;
	@@ -366,7 +368,8 @@ static int cam_ife_mgr_csid_stop_hw(
	isp_res = hw_mgr_res->hw_res[i];		isp_res = hw_mgr_res->hw_res[i];
	if (isp_res->hw_intf->hw_idx != base_idx)		if (isp_res->hw_intf->hw_idx != base_idx)
	continue;		continue;
			CAM_DBG(CAM_ISP, "base_idx %d res_id %d cnt %u",
			base_idx, isp_res->res_id, cnt);
	stop_res[cnt] = isp_res;		stop_res[cnt] = isp_res;
	cnt++;		cnt++;
	}		}
	@@ -483,8 +486,8 @@ static void cam_ife_mgr_add_base_info(
	"Add split id = %d for base idx = %d num_base=%d",		"Add split id = %d for base idx = %d num_base=%d",
	split_id, base_idx, ctx->num_base);		split_id, base_idx, ctx->num_base);
	} else {		} else {
	/Check if base index is alreay exist in the list /		/Check if base index already exists in the list /
	for (i = 0; i < CAM_IFE_HW_NUM_MAX; i++) {		for (i = 0; i < ctx->num_base; i++) {
	if (ctx->base[i].idx == base_idx) {		if (ctx->base[i].idx == base_idx) {
	if (split_id != CAM_ISP_HW_SPLIT_MAX &&		if (split_id != CAM_ISP_HW_SPLIT_MAX &&
	ctx->base[i].split_id ==		ctx->base[i].split_id ==
	@@ -495,7 +498,7 @@ static void cam_ife_mgr_add_base_info(
	}		}
	}		}

	if (i == CAM_IFE_HW_NUM_MAX) {		if (i == ctx->num_base) {
	ctx->base[ctx->num_base].split_id = split_id;		ctx->base[ctx->num_base].split_id = split_id;
	ctx->base[ctx->num_base].idx = base_idx;		ctx->base[ctx->num_base].idx = base_idx;
	ctx->num_base++;		ctx->num_base++;
	@@ -845,7 +848,8 @@ static int cam_ife_hw_mgr_acquire_res_ife_src(
	}		}
	ife_src_res->hw_res[i] = vfe_acquire.vfe_in.rsrc_node;		ife_src_res->hw_res[i] = vfe_acquire.vfe_in.rsrc_node;
	CAM_DBG(CAM_ISP,		CAM_DBG(CAM_ISP,
	"acquire success res type :0x%x res id:0x%x",		"acquire success IFE:%d res type :0x%x res id:0x%x",
			hw_intf->hw_idx,
	ife_src_res->hw_res[i]->res_type,		ife_src_res->hw_res[i]->res_type,
	ife_src_res->hw_res[i]->res_id);		ife_src_res->hw_res[i]->res_id);

	@@ -871,29 +875,75 @@ static int cam_ife_hw_mgr_acquire_res_ife_src(
	static int cam_ife_mgr_acquire_cid_res(		static int cam_ife_mgr_acquire_cid_res(
	struct cam_ife_hw_mgr_ctx *ife_ctx,		struct cam_ife_hw_mgr_ctx *ife_ctx,
	struct cam_isp_in_port_info *in_port,		struct cam_isp_in_port_info *in_port,
	uint32_t *cid_res_id,		struct cam_ife_hw_mgr_res **cid_res,
	enum cam_ife_pix_path_res_id csid_path)		enum cam_ife_pix_path_res_id csid_path)
	{		{
	int rc = -1;		int rc = -1;
	int i, j;		int i, j;
	struct cam_ife_hw_mgr *ife_hw_mgr;		struct cam_ife_hw_mgr *ife_hw_mgr;
	struct cam_ife_hw_mgr_res *cid_res;
	struct cam_hw_intf *hw_intf;		struct cam_hw_intf *hw_intf;
			struct cam_ife_hw_mgr_res cid_res_temp, cid_res_iterator;
	struct cam_csid_hw_reserve_resource_args csid_acquire;		struct cam_csid_hw_reserve_resource_args csid_acquire;
			uint32_t acquired_cnt = 0;

	ife_hw_mgr = ife_ctx->hw_mgr;		ife_hw_mgr = ife_ctx->hw_mgr;
			*cid_res = NULL;

	rc = cam_ife_hw_mgr_get_res(&ife_ctx->free_res_list, &cid_res);		rc = cam_ife_hw_mgr_get_res(&ife_ctx->free_res_list, cid_res);
	if (rc) {		if (rc) {
	CAM_ERR(CAM_ISP, "No more free hw mgr resource");		CAM_ERR(CAM_ISP, "No more free hw mgr resource");
	goto err;		goto end;
	}		}
	cam_ife_hw_mgr_put_res(&ife_ctx->res_list_ife_cid, &cid_res);
			cid_res_temp = *cid_res;

	csid_acquire.res_type = CAM_ISP_RESOURCE_CID;		csid_acquire.res_type = CAM_ISP_RESOURCE_CID;
	csid_acquire.in_port = in_port;		csid_acquire.in_port = in_port;
	csid_acquire.res_id = csid_path;		csid_acquire.res_id = csid_path;
			CAM_DBG(CAM_ISP, "path %d", csid_path);

			/* Try acquiring CID resource from previously acquired HW */
			list_for_each_entry(cid_res_iterator, &ife_ctx->res_list_ife_cid,
			list) {

			for (i = 0; i < CAM_ISP_HW_SPLIT_MAX; i++) {
			if (!cid_res_iterator->hw_res[i])
			continue;

			hw_intf = cid_res_iterator->hw_res[i]->hw_intf;
			rc = hw_intf->hw_ops.reserve(hw_intf->hw_priv,
			&csid_acquire, sizeof(csid_acquire));
			if (rc) {
			CAM_DBG(CAM_ISP,
			"No ife cid resource from hw %d",
			hw_intf->hw_idx);
			continue;
			}

			cid_res_temp->hw_res[acquired_cnt++] =
			csid_acquire.node_res;

			CAM_DBG(CAM_ISP,
			"acquired csid(%s)=%d CID rsrc successfully",
			(i == 0) ? "left" : "right",
			hw_intf->hw_idx);

			if (in_port->usage_type && acquired_cnt == 1 &&
			csid_path == CAM_IFE_PIX_PATH_RES_IPP)
			/* Continue to acquire Right */
			continue;

			if (acquired_cnt)
			/*
			* If successfully acquired CID from
			* previously acquired HW, skip the next
			* part
			*/
			goto acquire_successful;
			}
			}

			/* Acquire Left if not already acquired */
	for (i = 0; i < CAM_IFE_CSID_HW_NUM_MAX; i++) {		for (i = 0; i < CAM_IFE_CSID_HW_NUM_MAX; i++) {
	if (!ife_hw_mgr->csid_devices[i])		if (!ife_hw_mgr->csid_devices[i])
	continue;		continue;
	@@ -903,31 +953,45 @@ static int cam_ife_mgr_acquire_cid_res(
	sizeof(csid_acquire));		sizeof(csid_acquire));
	if (rc)		if (rc)
	continue;		continue;
	else		else {
			cid_res_temp->hw_res[acquired_cnt++] =
			csid_acquire.node_res;
	break;		break;
	}		}
			}

	if (i == CAM_IFE_CSID_HW_NUM_MAX \|\| !csid_acquire.node_res) {		if (i == CAM_IFE_CSID_HW_NUM_MAX \|\| !csid_acquire.node_res) {
	CAM_ERR(CAM_ISP, "Can not acquire ife csid rdi resource");		CAM_ERR(CAM_ISP, "Can not acquire ife cid resource for path %d",
	goto err;		csid_path);
			goto put_res;
	}		}

	cid_res->res_type = CAM_IFE_HW_MGR_RES_CID;		acquire_successful:
	cid_res->res_id = csid_acquire.node_res->res_id;		CAM_DBG(CAM_ISP, "CID left acquired success is_dual %d",
	cid_res->is_dual_vfe = in_port->usage_type;		in_port->usage_type);
	cid_res->hw_res[0] = csid_acquire.node_res;
	cid_res->hw_res[1] = NULL;		cid_res_temp->res_type = CAM_IFE_HW_MGR_RES_CID;
	/* CID(DT_ID) value of acquire device, require for path */		/* CID(DT_ID) value of acquire device, require for path */
	*cid_res_id = csid_acquire.node_res->res_id;		cid_res_temp->res_id = csid_acquire.node_res->res_id;
			cid_res_temp->is_dual_vfe = in_port->usage_type;
			cam_ife_hw_mgr_put_res(&ife_ctx->res_list_ife_cid, cid_res);

	if (cid_res->is_dual_vfe) {		/*
			* Acquire Right if not already acquired.
			* Dual IFE for RDI is not currently supported.
			*/
			if (cid_res_temp->is_dual_vfe && csid_path
			== CAM_IFE_PIX_PATH_RES_IPP && acquired_cnt == 1) {
	csid_acquire.node_res = NULL;		csid_acquire.node_res = NULL;
	csid_acquire.res_type = CAM_ISP_RESOURCE_CID;		csid_acquire.res_type = CAM_ISP_RESOURCE_CID;
	csid_acquire.in_port = in_port;		csid_acquire.in_port = in_port;
	for (j = i + 1; j < CAM_IFE_CSID_HW_NUM_MAX; j++) {		for (j = 0; j < CAM_IFE_CSID_HW_NUM_MAX; j++) {
	if (!ife_hw_mgr->csid_devices[j])		if (!ife_hw_mgr->csid_devices[j])
	continue;		continue;

			if (j == cid_res_temp->hw_res[0]->hw_intf->hw_idx)
			continue;

	hw_intf = ife_hw_mgr->csid_devices[j];		hw_intf = ife_hw_mgr->csid_devices[j];
	rc = hw_intf->hw_ops.reserve(hw_intf->hw_priv,		rc = hw_intf->hw_ops.reserve(hw_intf->hw_priv,
	&csid_acquire, sizeof(csid_acquire));		&csid_acquire, sizeof(csid_acquire));
	@@ -940,16 +1004,20 @@ static int cam_ife_mgr_acquire_cid_res(
	if (j == CAM_IFE_CSID_HW_NUM_MAX) {		if (j == CAM_IFE_CSID_HW_NUM_MAX) {
	CAM_ERR(CAM_ISP,		CAM_ERR(CAM_ISP,
	"Can not acquire ife csid rdi resource");		"Can not acquire ife csid rdi resource");
	goto err;		goto end;
	}		}
	cid_res->hw_res[1] = csid_acquire.node_res;		cid_res_temp->hw_res[1] = csid_acquire.node_res;
			CAM_DBG(CAM_ISP, "CID right acquired success is_dual %d",
			in_port->usage_type);
	}		}
	cid_res->parent = &ife_ctx->res_list_ife_in;		cid_res_temp->parent = &ife_ctx->res_list_ife_in;
	ife_ctx->res_list_ife_in.child[		ife_ctx->res_list_ife_in.child[
	ife_ctx->res_list_ife_in.num_children++] = cid_res;		ife_ctx->res_list_ife_in.num_children++] = cid_res_temp;

	return 0;		return 0;
	err:		put_res:
			cam_ife_hw_mgr_put_res(&ife_ctx->free_res_list, cid_res);
			end:
	return rc;		return rc;

	}		}
	@@ -966,35 +1034,25 @@ static int cam_ife_hw_mgr_acquire_res_ife_csid_ipp(
	struct cam_ife_hw_mgr_res *csid_res;		struct cam_ife_hw_mgr_res *csid_res;
	struct cam_ife_hw_mgr_res *cid_res;		struct cam_ife_hw_mgr_res *cid_res;
	struct cam_hw_intf *hw_intf;		struct cam_hw_intf *hw_intf;
	uint32_t cid_res_id;
	struct cam_csid_hw_reserve_resource_args csid_acquire;		struct cam_csid_hw_reserve_resource_args csid_acquire;

			ife_hw_mgr = ife_ctx->hw_mgr;
	/* get cid resource */		/* get cid resource */
	rc = cam_ife_mgr_acquire_cid_res(ife_ctx, in_port, &cid_res_id,		rc = cam_ife_mgr_acquire_cid_res(ife_ctx, in_port, &cid_res,
	CAM_IFE_PIX_PATH_RES_IPP);		CAM_IFE_PIX_PATH_RES_IPP);
	if (rc) {		if (rc) {
	CAM_ERR(CAM_ISP, "Acquire IFE CID resource Failed");		CAM_ERR(CAM_ISP, "Acquire IFE CID resource Failed");
	goto err;		goto end;
	}		}

	ife_hw_mgr = ife_ctx->hw_mgr;

	rc = cam_ife_hw_mgr_get_res(&ife_ctx->free_res_list, &csid_res);		rc = cam_ife_hw_mgr_get_res(&ife_ctx->free_res_list, &csid_res);
	if (rc) {		if (rc) {
	CAM_ERR(CAM_ISP, "No more free hw mgr resource");		CAM_ERR(CAM_ISP, "No more free hw mgr resource");
	goto err;		goto end;
	}		}
	cam_ife_hw_mgr_put_res(&ife_ctx->res_list_ife_csid, &csid_res);

	csid_acquire.res_type = CAM_ISP_RESOURCE_PIX_PATH;
	csid_acquire.res_id = CAM_IFE_PIX_PATH_RES_IPP;
	csid_acquire.cid = cid_res_id;
	csid_acquire.in_port = in_port;
	csid_acquire.out_port = in_port->data;

	csid_res->res_type = CAM_ISP_RESOURCE_PIX_PATH;		csid_res->res_type = CAM_ISP_RESOURCE_PIX_PATH;
	csid_res->res_id = CAM_IFE_PIX_PATH_RES_IPP;		csid_res->res_id = CAM_IFE_PIX_PATH_RES_IPP;
	csid_res->is_dual_vfe = in_port->usage_type;

	if (in_port->usage_type)		if (in_port->usage_type)
	csid_res->is_dual_vfe = 1;		csid_res->is_dual_vfe = 1;
	@@ -1003,19 +1061,18 @@ static int cam_ife_hw_mgr_acquire_res_ife_csid_ipp(
	csid_acquire.sync_mode = CAM_ISP_HW_SYNC_NONE;		csid_acquire.sync_mode = CAM_ISP_HW_SYNC_NONE;
	}		}

	list_for_each_entry(cid_res, &ife_ctx->res_list_ife_cid,		/* IPP resource needs to be from same HW as CID resource */
	list) {		for (i = 0; i <= csid_res->is_dual_vfe; i++) {
	if (cid_res->res_id != cid_res_id)		CAM_DBG(CAM_ISP, "i %d is_dual %d", i, csid_res->is_dual_vfe);
	continue;		csid_acquire.res_type = CAM_ISP_RESOURCE_PIX_PATH;
			csid_acquire.res_id = CAM_IFE_PIX_PATH_RES_IPP;
	for (i = 0; i < CAM_ISP_HW_SPLIT_MAX; i++) {		csid_acquire.cid = cid_res->hw_res[i]->res_id;
	if (!cid_res->hw_res[i])		csid_acquire.in_port = in_port;
	continue;		csid_acquire.out_port = in_port->data;
			csid_acquire.node_res = NULL;

	hw_intf = ife_hw_mgr->csid_devices[		hw_intf = cid_res->hw_res[i]->hw_intf;
	cid_res->hw_res[i]->hw_intf->hw_idx];

	csid_acquire.node_res = NULL;
	if (csid_res->is_dual_vfe) {		if (csid_res->is_dual_vfe) {
	if (i == CAM_ISP_HW_SPLIT_LEFT) {		if (i == CAM_ISP_HW_SPLIT_LEFT) {
	master_idx = hw_intf->hw_idx;		master_idx = hw_intf->hw_idx;
	@@ -1025,7 +1082,7 @@ static int cam_ife_hw_mgr_acquire_res_ife_csid_ipp(
	if (master_idx == -1) {		if (master_idx == -1) {
	CAM_ERR(CAM_ISP,		CAM_ERR(CAM_ISP,
	"No Master found");		"No Master found");
	goto err;		goto put_res;
	}		}
	csid_acquire.sync_mode =		csid_acquire.sync_mode =
	CAM_ISP_HW_SYNC_SLAVE;		CAM_ISP_HW_SYNC_SLAVE;
	@@ -1038,7 +1095,7 @@ static int cam_ife_hw_mgr_acquire_res_ife_csid_ipp(
	if (rc) {		if (rc) {
	CAM_ERR(CAM_ISP,		CAM_ERR(CAM_ISP,
	"Cannot acquire ife csid ipp resource");		"Cannot acquire ife csid ipp resource");
	goto err;		goto put_res;
	}		}

	csid_res->hw_res[i] = csid_acquire.node_res;		csid_res->hw_res[i] = csid_acquire.node_res;
	@@ -1046,23 +1103,18 @@ static int cam_ife_hw_mgr_acquire_res_ife_csid_ipp(
	"acquired csid(%s)=%d ipp rsrc successfully",		"acquired csid(%s)=%d ipp rsrc successfully",
	(i == 0) ? "left" : "right",		(i == 0) ? "left" : "right",
	hw_intf->hw_idx);		hw_intf->hw_idx);

	}

	if (i == CAM_IFE_CSID_HW_NUM_MAX) {
	CAM_ERR(CAM_ISP,
	"Can not acquire ife csid ipp resource");
	goto err;
	}		}
			cam_ife_hw_mgr_put_res(&ife_ctx->res_list_ife_csid, &csid_res);

	csid_res->parent = cid_res;		csid_res->parent = cid_res;
	cid_res->child[cid_res->num_children++] = csid_res;		cid_res->child[cid_res->num_children++] = csid_res;
	}

	CAM_DBG(CAM_ISP, "acquire res %d", csid_acquire.res_id);		CAM_DBG(CAM_ISP, "acquire res %d", csid_acquire.res_id);

	return 0;		return 0;
	err:		put_res:
			cam_ife_hw_mgr_put_res(&ife_ctx->free_res_list, &csid_res);
			end:
	return rc;		return rc;
	}		}

	@@ -1099,94 +1151,72 @@ static int cam_ife_hw_mgr_acquire_res_ife_csid_rdi(
	struct cam_ife_hw_mgr_ctx *ife_ctx,		struct cam_ife_hw_mgr_ctx *ife_ctx,
	struct cam_isp_in_port_info *in_port)		struct cam_isp_in_port_info *in_port)
	{		{
	int rc = -1;		int rc = -EINVAL;
	int i, j;		int i;

	struct cam_ife_hw_mgr *ife_hw_mgr;		struct cam_ife_hw_mgr *ife_hw_mgr;
	struct cam_ife_hw_mgr_res *csid_res;		struct cam_ife_hw_mgr_res *csid_res;
	struct cam_ife_hw_mgr_res *cid_res;		struct cam_ife_hw_mgr_res *cid_res;
	struct cam_hw_intf *hw_intf;		struct cam_hw_intf *hw_intf;
	struct cam_isp_out_port_info *out_port;		struct cam_isp_out_port_info *out_port;
	uint32_t cid_res_id;
	struct cam_csid_hw_reserve_resource_args csid_acquire;		struct cam_csid_hw_reserve_resource_args csid_acquire;
			enum cam_ife_pix_path_res_id path_type;

	ife_hw_mgr = ife_ctx->hw_mgr;		ife_hw_mgr = ife_ctx->hw_mgr;

	for (i = 0; i < in_port->num_out_res; i++) {		for (i = 0; i < in_port->num_out_res; i++) {
	out_port = &in_port->data[i];		out_port = &in_port->data[i];
	if (!cam_ife_hw_mgr_is_rdi_res(out_port->res_type))		path_type = cam_ife_hw_mgr_get_ife_csid_rdi_res_type(
			out_port->res_type);
			if (path_type == CAM_IFE_PIX_PATH_RES_MAX)
	continue;		continue;

	/* get cid resource */		/* get cid resource */
	rc = cam_ife_mgr_acquire_cid_res(ife_ctx,		rc = cam_ife_mgr_acquire_cid_res(ife_ctx, in_port, &cid_res,
	in_port, &cid_res_id,		path_type);
	cam_ife_hw_mgr_get_ife_csid_rdi_res_type(
	out_port->res_type));
	if (rc) {		if (rc) {
	CAM_ERR(CAM_ISP,		CAM_ERR(CAM_ISP, "Acquire IFE CID resource Failed");
	"Acquire IFE CID resource Failed");		goto end;
	goto err;
	}		}

			/* For each RDI we need CID + PATH resource */
	rc = cam_ife_hw_mgr_get_res(&ife_ctx->free_res_list,		rc = cam_ife_hw_mgr_get_res(&ife_ctx->free_res_list,
	&csid_res);		&csid_res);
	if (rc) {		if (rc) {
	CAM_ERR(CAM_ISP, "No more free hw mgr resource");		CAM_ERR(CAM_ISP, "No more free hw mgr resource");
	goto err;		goto end;
	}		}
	cam_ife_hw_mgr_put_res(&ife_ctx->res_list_ife_csid, &csid_res);

	/*
	* no need to check since we are doing one to one mapping
	* between the csid rdi type and out port rdi type
	*/

	memset(&csid_acquire, 0, sizeof(csid_acquire));		memset(&csid_acquire, 0, sizeof(csid_acquire));
	csid_acquire.res_id =		csid_acquire.res_id = path_type;
	cam_ife_hw_mgr_get_ife_csid_rdi_res_type(
	out_port->res_type);

	csid_acquire.res_type = CAM_ISP_RESOURCE_PIX_PATH;		csid_acquire.res_type = CAM_ISP_RESOURCE_PIX_PATH;
	csid_acquire.cid = cid_res_id;		csid_acquire.cid = cid_res->hw_res[0]->res_id;
	csid_acquire.in_port = in_port;		csid_acquire.in_port = in_port;
	csid_acquire.out_port = out_port;		csid_acquire.out_port = out_port;
	csid_acquire.sync_mode = CAM_ISP_HW_SYNC_NONE;		csid_acquire.sync_mode = CAM_ISP_HW_SYNC_NONE;

	list_for_each_entry(cid_res, &ife_ctx->res_list_ife_cid,
	list) {
	if (cid_res->res_id != cid_res_id)
	continue;

	for (j = 0; j < CAM_ISP_HW_SPLIT_MAX; j++) {
	if (!cid_res->hw_res[j])
	continue;

	csid_acquire.node_res = NULL;		csid_acquire.node_res = NULL;

	hw_intf = ife_hw_mgr->csid_devices[		hw_intf = cid_res->hw_res[0]->hw_intf;
	cid_res->hw_res[j]->hw_intf->hw_idx];
	rc = hw_intf->hw_ops.reserve(hw_intf->hw_priv,		rc = hw_intf->hw_ops.reserve(hw_intf->hw_priv,
	&csid_acquire, sizeof(csid_acquire));		&csid_acquire, sizeof(csid_acquire));
	if (rc) {		if (rc) {
	CAM_DBG(CAM_ISP,		CAM_ERR(CAM_ISP,
	"CSID Path reserve failed hw=%d rc=%d",		"CSID Path reserve failed hw=%d rc=%d cid=%d",
	hw_intf->hw_idx, rc);		hw_intf->hw_idx, rc,
	continue;		cid_res->hw_res[0]->res_id);
	}

	/* RDI does not need Dual ISP. Break */		goto put_res;
	break;
	}		}

	if (j == CAM_ISP_HW_SPLIT_MAX &&		if (csid_acquire.node_res == NULL) {
	csid_acquire.node_res == NULL) {		CAM_ERR(CAM_ISP, "Acquire CSID RDI rsrc failed");
	CAM_ERR(CAM_ISP,
	"acquire csid rdi rsrc failed, cid %d",		goto put_res;
	cid_res_id);
	goto err;
	}		}

	csid_res->res_type = CAM_ISP_RESOURCE_PIX_PATH;		csid_res->res_type = (enum cam_ife_hw_mgr_res_type)
			CAM_ISP_RESOURCE_PIX_PATH;
	csid_res->res_id = csid_acquire.res_id;		csid_res->res_id = csid_acquire.res_id;
	csid_res->is_dual_vfe = 0;		csid_res->is_dual_vfe = 0;
	csid_res->hw_res[0] = csid_acquire.node_res;		csid_res->hw_res[0] = csid_acquire.node_res;
	@@ -1196,14 +1226,13 @@ static int cam_ife_hw_mgr_acquire_res_ife_csid_rdi(
	csid_res->parent = cid_res;		csid_res->parent = cid_res;
	cid_res->child[cid_res->num_children++] =		cid_res->child[cid_res->num_children++] =
	csid_res;		csid_res;
			cam_ife_hw_mgr_put_res(&ife_ctx->res_list_ife_csid, &csid_res);
	/* Done with cid_res_id. Break */
	break;
	}
	}		}

	return 0;		return 0;
	err:		put_res:
			cam_ife_hw_mgr_put_res(&ife_ctx->free_res_list, &csid_res);
			end:
	return rc;		return rc;
	}		}

	@@ -1870,33 +1899,39 @@ static int cam_ife_mgr_stop_hw(void hw_mgr_priv, void stop_hw_args)
	*/		*/
	if (i == ctx->num_base)		if (i == ctx->num_base)
	master_base_idx = ctx->base[0].idx;		master_base_idx = ctx->base[0].idx;
			CAM_DBG(CAM_ISP, "Stopping master CSID idx %d", master_base_idx);

	/* Stop the master CIDs first */		/* Stop the master CSID path first */
	cam_ife_mgr_csid_stop_hw(ctx, &ctx->res_list_ife_cid,		cam_ife_mgr_csid_stop_hw(ctx, &ctx->res_list_ife_csid,
	master_base_idx, csid_halt_type);		master_base_idx, CAM_CSID_HALT_AT_FRAME_BOUNDARY);

	/* stop rest of the CIDs */		/* stop rest of the CSID paths */
	for (i = 0; i < ctx->num_base; i++) {		for (i = 0; i < ctx->num_base; i++) {
	if (i == master_base_idx)		if (ctx->base[i].idx == master_base_idx)
	continue;		continue;
	cam_ife_mgr_csid_stop_hw(ctx, &ctx->res_list_ife_cid,		CAM_DBG(CAM_ISP, "Stopping CSID idx %d i %d master %d",
	ctx->base[i].idx, csid_halt_type);		ctx->base[i].idx, i, master_base_idx);
	}

	/* Stop the master CSID path first */
	cam_ife_mgr_csid_stop_hw(ctx, &ctx->res_list_ife_csid,		cam_ife_mgr_csid_stop_hw(ctx, &ctx->res_list_ife_csid,
			ctx->base[i].idx, CAM_CSID_HALT_AT_FRAME_BOUNDARY);
			}

			CAM_DBG(CAM_ISP, "Stopping master CID idx %d", master_base_idx);

			/* Stop the master CIDs first */
			cam_ife_mgr_csid_stop_hw(ctx, &ctx->res_list_ife_cid,
	master_base_idx, csid_halt_type);		master_base_idx, csid_halt_type);

	/* stop rest of the CSID paths */		/* stop rest of the CIDs */
	for (i = 0; i < ctx->num_base; i++) {		for (i = 0; i < ctx->num_base; i++) {
	if (i == master_base_idx)		if (ctx->base[i].idx == master_base_idx)
	continue;		continue;
			CAM_DBG(CAM_ISP, "Stopping CID idx %d i %d master %d",
	cam_ife_mgr_csid_stop_hw(ctx, &ctx->res_list_ife_csid,		ctx->base[i].idx, i, master_base_idx);
			cam_ife_mgr_csid_stop_hw(ctx, &ctx->res_list_ife_cid,
	ctx->base[i].idx, csid_halt_type);		ctx->base[i].idx, csid_halt_type);
	}		}


	/* Deinit IFE CID */		/* Deinit IFE CID */
	list_for_each_entry(hw_mgr_res, &ctx->res_list_ife_cid, list) {		list_for_each_entry(hw_mgr_res, &ctx->res_list_ife_cid, list) {
	CAM_DBG(CAM_ISP, "%s: Going to DeInit IFE CID\n", __func__);		CAM_DBG(CAM_ISP, "%s: Going to DeInit IFE CID\n", __func__);

drivers/media/platform/msm/camera/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_core.c

+101 −71

Original line number	Original line	Diff line number	Diff line
	@@ -20,6 +20,7 @@
	#include "cam_soc_util.h"		#include "cam_soc_util.h"
	#include "cam_io_util.h"		#include "cam_io_util.h"
	#include "cam_debug_util.h"		#include "cam_debug_util.h"
			#include "cam_cpas_api.h"

	/* Timeout value in msec */		/* Timeout value in msec */
	#define IFE_CSID_TIMEOUT 1000		#define IFE_CSID_TIMEOUT 1000
	@@ -293,6 +294,7 @@ static int cam_ife_csid_cid_get(struct cam_ife_csid_hw *csid_hw,
	struct cam_ife_csid_cid_data *cid_data;		struct cam_ife_csid_cid_data *cid_data;
	uint32_t i = 0, j = 0;		uint32_t i = 0, j = 0;

			/* Return already reserved CID if the VC/DT matches */
	for (i = 0; i < CAM_IFE_CSID_CID_RES_MAX; i++) {		for (i = 0; i < CAM_IFE_CSID_CID_RES_MAX; i++) {
	if (csid_hw->cid_res[i].res_state >=		if (csid_hw->cid_res[i].res_state >=
	CAM_ISP_RESOURCE_STATE_RESERVED) {		CAM_ISP_RESOURCE_STATE_RESERVED) {
	@@ -547,6 +549,7 @@ static int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw,
	{		{
	int rc = 0;		int rc = 0;
	struct cam_ife_csid_cid_data *cid_data;		struct cam_ife_csid_cid_data *cid_data;
			uint32_t camera_hw_version;

	CAM_DBG(CAM_ISP,		CAM_DBG(CAM_ISP,
	"CSID:%d res_sel:0x%x Lane type:%d lane_num:%d dt:%d vc:%d",		"CSID:%d res_sel:0x%x Lane type:%d lane_num:%d dt:%d vc:%d",
	@@ -614,11 +617,39 @@ static int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw,
	goto end;		goto end;
	}		}

			if (csid_hw->csi2_reserve_cnt == UINT_MAX) {
			CAM_ERR(CAM_ISP,
			"CSID%d reserve cnt reached max",
			csid_hw->hw_intf->hw_idx);
			rc = -EINVAL;
			goto end;
			}

			rc = cam_cpas_get_cpas_hw_version(&camera_hw_version);
			if (rc) {
			CAM_ERR(CAM_ISP, "Failed to get HW version rc:%d", rc);
			goto end;
			}
			CAM_DBG(CAM_ISP, "HW version: %d", camera_hw_version);

			switch (camera_hw_version) {
			case CAM_CPAS_TITAN_NONE:
			case CAM_CPAS_TITAN_MAX:
			CAM_ERR(CAM_ISP, "Invalid HW version: %d", camera_hw_version);
			break;
			case CAM_CPAS_TITAN_170_V100:
			case CAM_CPAS_TITAN_170_V110:
			case CAM_CPAS_TITAN_170_V120:
	if (cid_reserv->in_port->res_type == CAM_ISP_IFE_IN_RES_PHY_3 &&		if (cid_reserv->in_port->res_type == CAM_ISP_IFE_IN_RES_PHY_3 &&
	csid_hw->hw_intf->hw_idx != 2) {		csid_hw->hw_intf->hw_idx != 2) {
	rc = -EINVAL;		rc = -EINVAL;
	goto end;		goto end;
	}		}
			break;
			default:
			break;
			}
			CAM_DBG(CAM_ISP, "Reserve_cnt %u", csid_hw->csi2_reserve_cnt);

	if (csid_hw->csi2_reserve_cnt) {		if (csid_hw->csi2_reserve_cnt) {
	/* current configure res type should match requested res type */		/* current configure res type should match requested res type */
	@@ -652,12 +683,54 @@ static int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw,
	}		}
	}		}

			switch (cid_reserv->res_id) {
			case CAM_IFE_PIX_PATH_RES_IPP:
			if (csid_hw->ipp_res.res_state !=
			CAM_ISP_RESOURCE_STATE_AVAILABLE) {
			CAM_DBG(CAM_ISP,
			"CSID:%d IPP resource not available",
			csid_hw->hw_intf->hw_idx);
			rc = -EINVAL;
			goto end;
			}
			break;
			case CAM_IFE_PIX_PATH_RES_RDI_0:
			case CAM_IFE_PIX_PATH_RES_RDI_1:
			case CAM_IFE_PIX_PATH_RES_RDI_2:
			case CAM_IFE_PIX_PATH_RES_RDI_3:
			if (csid_hw->rdi_res[cid_reserv->res_id].res_state !=
			CAM_ISP_RESOURCE_STATE_AVAILABLE) {
			CAM_ERR(CAM_ISP,
			"CSID:%d RDI:%d resource not available",
			csid_hw->hw_intf->hw_idx,
			cid_reserv->res_id);
			rc = -EINVAL;
			goto end;
			}
			break;
			default:
			CAM_ERR(CAM_ISP, "CSID%d: Invalid csid path",
			csid_hw->hw_intf->hw_idx);
			rc = -EINVAL;
			goto end;
			}

			rc = cam_ife_csid_cid_get(csid_hw,
			&cid_reserv->node_res,
			cid_reserv->in_port->vc,
			cid_reserv->in_port->dt,
			cid_reserv->in_port->res_type);
			if (rc) {
			CAM_ERR(CAM_ISP, "CSID:%d CID Reserve failed res_type %d",
			csid_hw->hw_intf->hw_idx,
			cid_reserv->in_port->res_type);
			goto end;
			}
			cid_data = (struct cam_ife_csid_cid_data *)
			cid_reserv->node_res->res_priv;

	if (!csid_hw->csi2_reserve_cnt) {		if (!csid_hw->csi2_reserve_cnt) {
	csid_hw->res_type = cid_reserv->in_port->res_type;		csid_hw->res_type = cid_reserv->in_port->res_type;
	/* Take the first CID resource*/
	csid_hw->cid_res[0].res_state = CAM_ISP_RESOURCE_STATE_RESERVED;
	cid_data = (struct cam_ife_csid_cid_data *)
	csid_hw->cid_res[0].res_priv;

	csid_hw->csi2_rx_cfg.lane_cfg =		csid_hw->csi2_rx_cfg.lane_cfg =
	cid_reserv->in_port->lane_cfg;		cid_reserv->in_port->lane_cfg;
	@@ -699,70 +772,12 @@ static int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw,
	csid_hw->csi2_rx_cfg.phy_sel =		csid_hw->csi2_rx_cfg.phy_sel =
	(cid_reserv->in_port->res_type & 0xFF) - 1;		(cid_reserv->in_port->res_type & 0xFF) - 1;
	}		}

	cid_data->vc = cid_reserv->in_port->vc;
	cid_data->dt = cid_reserv->in_port->dt;
	cid_data->cnt = 1;
	cid_reserv->node_res = &csid_hw->cid_res[0];
	csid_hw->csi2_reserve_cnt++;

	CAM_DBG(CAM_ISP,
	"CSID:%d CID :%d resource acquired successfully",
	csid_hw->hw_intf->hw_idx,
	cid_reserv->node_res->res_id);
	} else {
	switch (cid_reserv->res_id) {
	case CAM_IFE_PIX_PATH_RES_IPP:
	if (csid_hw->ipp_res.res_state !=
	CAM_ISP_RESOURCE_STATE_AVAILABLE) {
	CAM_DBG(CAM_ISP,
	"CSID:%d IPP resource not available",
	csid_hw->hw_intf->hw_idx);
	rc = -EINVAL;
	goto end;
	}
	break;
	case CAM_IFE_PIX_PATH_RES_RDI_0:
	case CAM_IFE_PIX_PATH_RES_RDI_1:
	case CAM_IFE_PIX_PATH_RES_RDI_2:
	case CAM_IFE_PIX_PATH_RES_RDI_3:
	if (csid_hw->rdi_res[cid_reserv->res_id].res_state !=
	CAM_ISP_RESOURCE_STATE_AVAILABLE) {
	CAM_DBG(CAM_ISP,
	"CSID:%d RDI:%d resource not available",
	csid_hw->hw_intf->hw_idx,
	cid_reserv->res_id);
	rc = -EINVAL;
	goto end;
	}
	break;
	default:
	CAM_ERR(CAM_ISP, "CSID%d: Invalid csid path",
	csid_hw->hw_intf->hw_idx);
	rc = -EINVAL;
	goto end;
	}		}

	rc = cam_ife_csid_cid_get(csid_hw,
	&cid_reserv->node_res,
	cid_reserv->in_port->vc,
	cid_reserv->in_port->dt,
	cid_reserv->in_port->res_type);
	/* if success then increment the reserve count */
	if (!rc) {
	if (csid_hw->csi2_reserve_cnt == UINT_MAX) {
	CAM_ERR(CAM_ISP,
	"CSID%d reserve cnt reached max",
	csid_hw->hw_intf->hw_idx);
	rc = -EINVAL;
	} else {
	csid_hw->csi2_reserve_cnt++;		csid_hw->csi2_reserve_cnt++;
	CAM_DBG(CAM_ISP, "CSID:%d CID:%d acquired",		CAM_DBG(CAM_ISP, "CSID:%d CID:%d acquired",
	csid_hw->hw_intf->hw_idx,		csid_hw->hw_intf->hw_idx,
	cid_reserv->node_res->res_id);		cid_reserv->node_res->res_id);
	}
	}
	}

	end:		end:
	return rc;		return rc;
	@@ -2415,12 +2430,24 @@ static int cam_ife_csid_stop(void *hw_priv,
	return -EINVAL;		return -EINVAL;
	}		}
	csid_stop = (struct cam_csid_hw_stop_args *) stop_args;		csid_stop = (struct cam_csid_hw_stop_args *) stop_args;

			if (!csid_stop->num_res) {
			CAM_ERR(CAM_ISP, "CSID: Invalid args");
			return -EINVAL;
			}

	csid_hw_info = (struct cam_hw_info *)hw_priv;		csid_hw_info = (struct cam_hw_info *)hw_priv;
	csid_hw = (struct cam_ife_csid_hw *)csid_hw_info->core_info;		csid_hw = (struct cam_ife_csid_hw *)csid_hw_info->core_info;
			CAM_DBG(CAM_ISP, "CSID:%d num_res %d",
			csid_hw->hw_intf->hw_idx,
			csid_stop->num_res);

	/* Stop the resource first */		/* Stop the resource first */
	for (i = 0; i < csid_stop->num_res; i++) {		for (i = 0; i < csid_stop->num_res; i++) {
	res = csid_stop->node_res[i];		res = csid_stop->node_res[i];
			CAM_DBG(CAM_ISP, "CSID:%d res_type %d res_id %d",
			csid_hw->hw_intf->hw_idx,
			res->res_type, res->res_id);
	switch (res->res_type) {		switch (res->res_type) {
	case CAM_ISP_RESOURCE_CID:		case CAM_ISP_RESOURCE_CID:
	if (csid_hw->res_type == CAM_ISP_IFE_IN_RES_TPG)		if (csid_hw->res_type == CAM_ISP_IFE_IN_RES_TPG)
	@@ -2777,6 +2804,7 @@ int cam_ife_csid_hw_probe_init(struct cam_hw_intf *csid_hw_intf,
	{		{
	int rc = -EINVAL;		int rc = -EINVAL;
	uint32_t i;		uint32_t i;
			uint32_t num_paths;
	struct cam_ife_csid_path_cfg *path_data;		struct cam_ife_csid_path_cfg *path_data;
	struct cam_ife_csid_cid_data *cid_data;		struct cam_ife_csid_cid_data *cid_data;
	struct cam_hw_info *csid_hw_info;		struct cam_hw_info *csid_hw_info;
	@@ -2828,8 +2856,10 @@ int cam_ife_csid_hw_probe_init(struct cam_hw_intf *csid_hw_intf,
	ife_csid_hw->hw_intf->hw_ops.write = cam_ife_csid_write;		ife_csid_hw->hw_intf->hw_ops.write = cam_ife_csid_write;
	ife_csid_hw->hw_intf->hw_ops.process_cmd = cam_ife_csid_process_cmd;		ife_csid_hw->hw_intf->hw_ops.process_cmd = cam_ife_csid_process_cmd;

	/Initialize the CID resoure /		num_paths = ife_csid_hw->csid_info->csid_reg->cmn_reg->no_pix +
	for (i = 0; i < CAM_IFE_CSID_CID_RES_MAX; i++) {		ife_csid_hw->csid_info->csid_reg->cmn_reg->no_rdis;
			/* Initialize the CID resource */
			for (i = 0; i < num_paths; i++) {
	ife_csid_hw->cid_res[i].res_type = CAM_ISP_RESOURCE_CID;		ife_csid_hw->cid_res[i].res_type = CAM_ISP_RESOURCE_CID;
	ife_csid_hw->cid_res[i].res_id = i;		ife_csid_hw->cid_res[i].res_id = i;
	ife_csid_hw->cid_res[i].res_state =		ife_csid_hw->cid_res[i].res_state =