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

Commit a5744214 authored by Abhijit Trivedi's avatar Abhijit Trivedi
Browse files

UPSTREAM: Merge remote-tracking branch 'quic/dev/msm-4.9-camx' into mainline(msm-4.9) 



* commit '730718d6':
  msm: camera: Initialize size field in ICP handles
  msm: camera: Use correct direct field size while copying
  msm: camera: isp: Update Bus and CSID to support RAW16 format

Change-Id: I9a73a33fa38cc85817af0877144d6d274284c502
Signed-off-by: default avatarAbhijit Trivedi <abhijitt@codeaurora.org>
parents 010ff9e0 730718d6

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

+51 −29
Original line number Diff line number Diff line
@@ -642,42 +642,52 @@ static int cam_icp_mgr_abort_handle( 
{

	int rc = 0;

	unsigned long rem_jiffies;

	size_t packet_size;

	int timeout = 5000;

	struct hfi_cmd_work_data *task_data;

	struct hfi_cmd_ipebps_async abort_cmd;

	struct hfi_cmd_ipebps_async *abort_cmd;

	struct crm_workq_task *task;



	task = cam_req_mgr_workq_get_task(icp_hw_mgr.cmd_work);

	if (!task)

		return -ENOMEM;



	abort_cmd.size =

	packet_size =

		sizeof(struct hfi_cmd_ipebps_async) +

		sizeof(struct hfi_cmd_abort_destroy) -

		sizeof(abort_cmd.payload.direct);

	abort_cmd.pkt_type = HFI_CMD_IPEBPS_ASYNC_COMMAND_DIRECT;

		sizeof(((struct hfi_cmd_ipebps_async *)0)->payload.direct);

	abort_cmd = kzalloc(packet_size, GFP_KERNEL);

	if (!abort_cmd) {

		rc = -ENOMEM;

		return rc;

	}



	abort_cmd->size = packet_size;

	abort_cmd->pkt_type = HFI_CMD_IPEBPS_ASYNC_COMMAND_DIRECT;

	if (ctx_data->icp_dev_acquire_info->dev_type == CAM_ICP_RES_TYPE_BPS)

		abort_cmd.opcode = HFI_IPEBPS_CMD_OPCODE_BPS_ABORT;

		abort_cmd->opcode = HFI_IPEBPS_CMD_OPCODE_BPS_ABORT;

	else

		abort_cmd.opcode = HFI_IPEBPS_CMD_OPCODE_IPE_ABORT;

		abort_cmd->opcode = HFI_IPEBPS_CMD_OPCODE_IPE_ABORT;



	reinit_completion(&ctx_data->wait_complete);

	abort_cmd.num_fw_handles = 1;

	abort_cmd.fw_handles[0] = ctx_data->fw_handle;

	abort_cmd.user_data1 = (uint64_t)ctx_data;

	abort_cmd.user_data2 = (uint64_t)0x0;

	memcpy(abort_cmd.payload.direct, &ctx_data->temp_payload,

		sizeof(uint32_t));

	abort_cmd->num_fw_handles = 1;

	abort_cmd->fw_handles[0] = ctx_data->fw_handle;

	abort_cmd->user_data1 = (uint64_t)ctx_data;

	abort_cmd->user_data2 = (uint64_t)0x0;

	memcpy(abort_cmd->payload.direct, &ctx_data->temp_payload,

		sizeof(uint64_t));



	task_data = (struct hfi_cmd_work_data *)task->payload;

	task_data->data = (void *)&abort_cmd;

	task_data->data = (void *)abort_cmd;

	task_data->request_id = 0;

	task_data->type = ICP_WORKQ_TASK_CMD_TYPE;

	task->process_cb = cam_icp_mgr_process_cmd;

	rc = cam_req_mgr_workq_enqueue_task(task, &icp_hw_mgr,

		CRM_TASK_PRIORITY_0);

	if (rc)

	if (rc) {

		kfree(abort_cmd);

		return rc;

	}



	CAM_DBG(CAM_ICP, "fw_handle = %x ctx_data = %pK",

		ctx_data->fw_handle, ctx_data);
@@ -688,6 +698,7 @@ static int cam_icp_mgr_abort_handle( 
		CAM_DBG(CAM_ICP, "FW timeout/err in abort handle command");

	}



	kfree(abort_cmd);

	return rc;

}
@@ -697,41 +708,51 @@ static int cam_icp_mgr_destroy_handle( 
	int rc = 0;

	int timeout = 5000;

	unsigned long rem_jiffies;

	size_t packet_size;

	struct hfi_cmd_work_data *task_data;

	struct hfi_cmd_ipebps_async destroy_cmd;

	struct hfi_cmd_ipebps_async *destroy_cmd;

	struct crm_workq_task *task;



	task = cam_req_mgr_workq_get_task(icp_hw_mgr.cmd_work);

	if (!task)

		return -ENOMEM;



	destroy_cmd.size =

	packet_size =

		sizeof(struct hfi_cmd_ipebps_async) +

		sizeof(struct ipe_bps_destroy) -

		sizeof(destroy_cmd.payload.direct);

	destroy_cmd.pkt_type = HFI_CMD_IPEBPS_ASYNC_COMMAND_DIRECT;

		sizeof(struct hfi_cmd_abort_destroy) -

		sizeof(((struct hfi_cmd_ipebps_async *)0)->payload.direct);

	destroy_cmd = kzalloc(packet_size, GFP_KERNEL);

	if (!destroy_cmd) {

		rc = -ENOMEM;

		return rc;

	}



	destroy_cmd->size = packet_size;

	destroy_cmd->pkt_type = HFI_CMD_IPEBPS_ASYNC_COMMAND_DIRECT;

	if (ctx_data->icp_dev_acquire_info->dev_type == CAM_ICP_RES_TYPE_BPS)

		destroy_cmd.opcode = HFI_IPEBPS_CMD_OPCODE_BPS_DESTROY;

		destroy_cmd->opcode = HFI_IPEBPS_CMD_OPCODE_BPS_DESTROY;

	else

		destroy_cmd.opcode = HFI_IPEBPS_CMD_OPCODE_IPE_DESTROY;

		destroy_cmd->opcode = HFI_IPEBPS_CMD_OPCODE_IPE_DESTROY;



	reinit_completion(&ctx_data->wait_complete);

	destroy_cmd.num_fw_handles = 1;

	destroy_cmd.fw_handles[0] = ctx_data->fw_handle;

	destroy_cmd.user_data1 = (uint64_t)ctx_data;

	destroy_cmd.user_data2 = (uint64_t)0x0;

	memcpy(destroy_cmd.payload.direct, &ctx_data->temp_payload,

						sizeof(uint32_t));

	destroy_cmd->num_fw_handles = 1;

	destroy_cmd->fw_handles[0] = ctx_data->fw_handle;

	destroy_cmd->user_data1 = (uint64_t)ctx_data;

	destroy_cmd->user_data2 = (uint64_t)0x0;

	memcpy(destroy_cmd->payload.direct, &ctx_data->temp_payload,

		sizeof(uint64_t));



	task_data = (struct hfi_cmd_work_data *)task->payload;

	task_data->data = (void *)&destroy_cmd;

	task_data->data = (void *)destroy_cmd;

	task_data->request_id = 0;

	task_data->type = ICP_WORKQ_TASK_CMD_TYPE;

	task->process_cb = cam_icp_mgr_process_cmd;

	rc = cam_req_mgr_workq_enqueue_task(task, &icp_hw_mgr,

		CRM_TASK_PRIORITY_0);

	if (rc)

	if (rc) {

		kfree(destroy_cmd);

		return rc;

	}



	CAM_DBG(CAM_ICP, "fw_handle = %x ctx_data = %pK",

		ctx_data->fw_handle, ctx_data);
@@ -742,6 +763,7 @@ static int cam_icp_mgr_destroy_handle( 
		CAM_ERR(CAM_ICP, "FW response timeout: %d", rc);

	}



	kfree(destroy_cmd);

	return rc;

}

drivers/media/platform/msm/camera/cam_isp/cam_isp_context.c

+4 −1
Original line number Diff line number Diff line
@@ -691,7 +691,7 @@ static int __cam_isp_ctx_apply_req_in_activated_state( 
	 */

	ctx_isp = (struct cam_isp_context *) ctx->ctx_priv;

	if (ctx_isp->active_req_cnt >=  2) {

		CAM_DBG(CAM_ISP,

		CAM_ERR_RATE_LIMIT(CAM_ISP,

			"Reject apply request due to congestion(cnt = %d)",

			ctx_isp->active_req_cnt);

		rc = -EFAULT;
@@ -706,6 +706,9 @@ static int __cam_isp_ctx_apply_req_in_activated_state( 
	 * we are in the middle of the error handling. Need to reject this apply

	 */

	if (req->request_id != apply->request_id) {

		CAM_ERR_RATE_LIMIT(CAM_ISP,

			"Invalid Request Id asking %llu existing %llu",

			apply->request_id, req->request_id);

		rc = -EFAULT;

		goto end;

	}

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

+31 −21
Original line number Diff line number Diff line
@@ -69,11 +69,11 @@ static int cam_ife_mgr_get_hw_caps(void *hw_mgr_priv, 
	return rc;

}



static int cam_ife_hw_mgr_is_rdi_res(uint32_t format)

static int cam_ife_hw_mgr_is_rdi_res(uint32_t res_id)

{

	int rc = 0;



	switch (format) {

	switch (res_id) {

	case CAM_ISP_IFE_OUT_RES_RDI_0:

	case CAM_ISP_IFE_OUT_RES_RDI_1:

	case CAM_ISP_IFE_OUT_RES_RDI_2:
@@ -379,11 +379,12 @@ static void cam_ife_mgr_add_base_info( 
	uint32_t    i;



	if (!ctx->num_base) {

		CAM_DBG(CAM_ISP, "Add split id = %d for base idx = %d",

			split_id, base_idx);

		ctx->base[0].split_id = split_id;

		ctx->base[0].idx      = base_idx;

		ctx->num_base++;

		CAM_DBG(CAM_ISP,

			"Add split id = %d for base idx = %d num_base=%d",

			split_id, base_idx, ctx->num_base);

	} else {

		/*Check if base index is alreay exist in the list */

		for (i = 0; i < CAM_IFE_HW_NUM_MAX; i++) {
@@ -398,11 +399,12 @@ static void cam_ife_mgr_add_base_info( 
		}



		if (i == CAM_IFE_HW_NUM_MAX) {

			CAM_DBG(CAM_ISP, "Add split id = %d for base idx = %d",

				 split_id, base_idx);

			ctx->base[ctx->num_base].split_id = split_id;

			ctx->base[ctx->num_base].idx      = base_idx;

			ctx->num_base++;

			CAM_DBG(CAM_ISP,

				"Add split_id=%d for base idx=%d num_base=%d",

				 split_id, base_idx, ctx->num_base);

		}

	}

}
@@ -427,14 +429,11 @@ static int cam_ife_mgr_process_base_info( 
		for (i = 0; i < CAM_ISP_HW_SPLIT_MAX; i++) {

			if (!hw_mgr_res->hw_res[i])

				continue;



			res = hw_mgr_res->hw_res[i];

			if (res->res_id == CAM_ISP_HW_VFE_IN_CAMIF)

			cam_ife_mgr_add_base_info(ctx, i,

					res->hw_intf->hw_idx);



			else

				cam_ife_mgr_add_base_info(ctx,

						CAM_ISP_HW_SPLIT_MAX,

			CAM_DBG(CAM_ISP, "add base info for hw %d",

				res->hw_intf->hw_idx);

		}

	}
@@ -676,7 +675,6 @@ static int cam_ife_hw_mgr_acquire_res_ife_src( 


		vfe_acquire.rsrc_type = CAM_ISP_RESOURCE_VFE_IN;

		vfe_acquire.tasklet = ife_ctx->common.tasklet_info;

		vfe_acquire.rsrc_type = CAM_ISP_RESOURCE_VFE_IN;

		vfe_acquire.vfe_in.cdm_ops = ife_ctx->cdm_ops;



		switch (csid_res->res_id) {
@@ -787,6 +785,7 @@ static int cam_ife_hw_mgr_acquire_res_ife_csid_ipp( 
	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;



	if (in_port->usage_type)

		csid_acquire.sync_mode = CAM_ISP_HW_SYNC_MASTER;
@@ -1288,8 +1287,10 @@ static int cam_ife_mgr_acquire_hw(void *hw_mgr_priv, 
	}



	/* Check whether context has only RDI resource */

	if (!num_pix_port)

	if (!num_pix_port) {

		ife_ctx->is_rdi_only_context = 1;

		CAM_DBG(CAM_ISP, "RDI only context");

	}



	/* Process base info */

	rc = cam_ife_mgr_process_base_info(ife_ctx);
@@ -1342,7 +1343,8 @@ static int cam_ife_mgr_config_hw(void *hw_mgr_priv, 
		return -EPERM;

	}



	CAM_DBG(CAM_ISP, "Enter ctx id:%d", ctx->ctx_index);

	CAM_DBG(CAM_ISP, "Enter ctx id:%d num_hw_upd_entries %d",

		ctx->ctx_index, cfg->num_hw_update_entries);



	if (cfg->num_hw_update_entries > 0) {

		cdm_cmd = ctx->cdm_cmd;
@@ -1359,6 +1361,7 @@ static int cam_ife_mgr_config_hw(void *hw_mgr_priv, 
			cdm_cmd->cmd[i].len = cmd->len;

		}



		CAM_DBG(CAM_ISP, "Submit to CDM");

		rc = cam_cdm_submit_bls(ctx->cdm_handle, cdm_cmd);

		if (rc)

			CAM_ERR(CAM_ISP, "Failed to apply the configs");
@@ -1914,7 +1917,6 @@ static int cam_ife_mgr_prepare_hw_update(void *hw_mgr_priv, 
	if (rc)

		return rc;



	CAM_DBG(CAM_ISP, "enter");

	/* Pre parse the packet*/

	rc = cam_packet_util_get_kmd_buffer(prepare->packet, &kmd_buf);

	if (rc)
@@ -2011,15 +2013,23 @@ static int cam_ife_mgr_prepare_hw_update(void *hw_mgr_priv, 
		/* Add change base */

		rc = cam_isp_add_change_base(prepare, &ctx->res_list_ife_src,

			ctx->base[i].idx, &kmd_buf);

		if (rc)

		if (rc) {

			CAM_ERR(CAM_ISP,

				"Failed in change base adding reg_update cmd i=%d, idx=%d, rc=%d",

				i, ctx->base[i].idx, rc);

			goto end;

		}



		/*Add reg update */

		rc = cam_isp_add_reg_update(prepare, &ctx->res_list_ife_src,

			ctx->base[i].idx, &kmd_buf);

		if (rc)

		if (rc) {

			CAM_ERR(CAM_ISP,

				"Add Reg_update cmd Failed i=%d, idx=%d, rc=%d",

				i, ctx->base[i].idx, rc);

			goto end;

		}

	}



end:

	kfree(blob_info.hfr_config);
@@ -2804,10 +2814,10 @@ static int cam_ife_hw_mgr_handle_sof( 
						ife_hw_mgr_ctx->common.cb_priv,

						CAM_ISP_HW_EVENT_SOF,

						&sof_done_event_data);

					CAM_DBG(CAM_ISP, "sof_status = %d",

						sof_status);

				}



				CAM_DBG(CAM_ISP, "sof_status = %d", sof_status);



				/* this is RDI only context so exit from here */

				return 0;

			}

drivers/media/platform/msm/camera/cam_isp/isp_hw_mgr/hw_utils/cam_isp_packet_parser.c

+2 −0
Original line number Diff line number Diff line
@@ -696,6 +696,8 @@ int cam_isp_add_reg_update( 
			if (rc)

				return rc;



			CAM_DBG(CAM_ISP, "Reg update added for res %d hw_id %d",

				res->res_id, res->hw_intf->hw_idx);

			reg_update_size += get_regup.used_bytes;

		}

	}

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

+208 −91
Original line number Diff line number Diff line
@@ -32,12 +32,14 @@ 
#define CAM_IFE_CSID_TIMEOUT_SLEEP_US                  1000

#define CAM_IFE_CSID_TIMEOUT_ALL_US                    1000000



#define MEASURE_EN                                     0



static int cam_ife_csid_is_ipp_format_supported(

				uint32_t decode_fmt)

	uint32_t in_format)

{

	int rc = -EINVAL;



	switch (decode_fmt) {

	switch (in_format) {

	case CAM_FORMAT_MIPI_RAW_6:

	case CAM_FORMAT_MIPI_RAW_8:

	case CAM_FORMAT_MIPI_RAW_10:
@@ -59,127 +61,221 @@ static int cam_ife_csid_is_ipp_format_supported( 
	return rc;

}



static int cam_ife_csid_get_format(uint32_t input_fmt,

	uint32_t *path_fmt)

static int cam_ife_csid_get_format_rdi(

	uint32_t in_format, uint32_t out_format,

	uint32_t *decode_fmt, uint32_t *plain_fmt)

{

	int rc = 0;



	switch (input_fmt) {

	switch (in_format) {

	case CAM_FORMAT_MIPI_RAW_6:

		switch (out_format) {

		case CAM_FORMAT_MIPI_RAW_6:

		*path_fmt  = 0;

			*decode_fmt = 0xf;

			break;

		case CAM_FORMAT_PLAIN8:

			*decode_fmt = 0x0;

			*plain_fmt = 0x0;

			break;

		default:

			rc = -EINVAL;

			break;

		}

		break;

	case CAM_FORMAT_MIPI_RAW_8:

		switch (out_format) {

		case CAM_FORMAT_MIPI_RAW_8:

		*path_fmt  = 1;

			*decode_fmt = 0xf;

			break;

		case CAM_FORMAT_PLAIN8:

			*decode_fmt = 0x1;

			*plain_fmt = 0x0;

			break;

		default:

			rc = -EINVAL;

			break;

		}

		break;

	case CAM_FORMAT_MIPI_RAW_10:

		*path_fmt  = 2;

		switch (out_format) {

		case CAM_FORMAT_MIPI_RAW_10:

			*decode_fmt = 0xf;

			break;

		case CAM_FORMAT_PLAIN16_10:

			*decode_fmt = 0x2;

			*plain_fmt = 0x1;

			break;

		default:

			rc = -EINVAL;

			break;

		}

		break;

	case CAM_FORMAT_MIPI_RAW_12:

		*path_fmt  = 3;

		switch (out_format) {

		case CAM_FORMAT_MIPI_RAW_12:

			*decode_fmt = 0xf;

			break;

		case CAM_FORMAT_PLAIN16_12:

			*decode_fmt = 0x3;

			*plain_fmt = 0x1;

			break;

		default:

			rc = -EINVAL;

			break;

		}

		break;

	case CAM_FORMAT_MIPI_RAW_14:

		switch (out_format) {

		case CAM_FORMAT_MIPI_RAW_14:

		*path_fmt  = 4;

			*decode_fmt = 0xf;

			break;

		case CAM_FORMAT_PLAIN16_14:

			*decode_fmt = 0x4;

			*plain_fmt = 0x1;

			break;

		default:

			rc = -EINVAL;

			break;

		}

		break;

	case CAM_FORMAT_MIPI_RAW_16:

		switch (out_format) {

		case CAM_FORMAT_MIPI_RAW_16:

		*path_fmt  = 5;

			*decode_fmt = 0xf;

			break;

		case CAM_FORMAT_PLAIN16_16:

			*decode_fmt = 0x5;

			*plain_fmt = 0x1;

			break;

		default:

			rc = -EINVAL;

			break;

		}

		break;

	case CAM_FORMAT_MIPI_RAW_20:

		*path_fmt  = 6;

		switch (out_format) {

		case CAM_FORMAT_MIPI_RAW_20:

			*decode_fmt = 0xf;

			break;

		case CAM_FORMAT_PLAIN32_20:

			*decode_fmt = 0x6;

			*plain_fmt = 0x2;

			break;

		default:

			rc = -EINVAL;

			break;

		}

		break;

	case CAM_FORMAT_DPCM_10_6_10:

		*path_fmt  = 7;

		*decode_fmt  = 0x7;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_DPCM_10_8_10:

		*path_fmt  = 8;

		*decode_fmt  = 0x8;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_DPCM_12_6_12:

		*path_fmt  = 9;

		*decode_fmt  = 0x9;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_DPCM_12_8_12:

		*path_fmt  = 0xA;

		*decode_fmt  = 0xA;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_DPCM_14_8_14:

		*path_fmt  = 0xB;

		*decode_fmt  = 0xB;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_DPCM_14_10_14:

		*path_fmt  = 0xC;

		*decode_fmt  = 0xC;

		*plain_fmt = 0x1;

		break;

	default:

		CAM_ERR(CAM_ISP, "CSID:%d un supported format",

			input_fmt);

		rc = -EINVAL;

		break;

	}



	if (rc)

		CAM_ERR(CAM_ISP, "Unsupported format pair in %d out %d\n",

			in_format, out_format);



	return rc;

}



static int cam_ife_csid_get_rdi_format(uint32_t input_fmt,

	uint32_t output_fmt, uint32_t *path_fmt, uint32_t *plain_fmt)

static int cam_ife_csid_get_format_ipp(

	uint32_t in_format,

	uint32_t *decode_fmt, uint32_t *plain_fmt)

{

	int rc = 0;



	CAM_DBG(CAM_ISP, "input format:%d output format:%d",

		 input_fmt, output_fmt);

	CAM_DBG(CAM_ISP, "input format:%d",

		 in_format);



	switch (output_fmt) {

	switch (in_format) {

	case CAM_FORMAT_MIPI_RAW_6:

		*decode_fmt  = 0;

		*plain_fmt = 0;

		break;

	case CAM_FORMAT_MIPI_RAW_8:

		*decode_fmt  = 0x1;

		*plain_fmt = 0;

		break;

	case CAM_FORMAT_MIPI_RAW_10:

		*decode_fmt  = 0x2;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_MIPI_RAW_12:

		*decode_fmt  = 0x3;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_MIPI_RAW_14:

		*decode_fmt  = 0x4;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_MIPI_RAW_16:

		*decode_fmt  = 0x5;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_MIPI_RAW_20:

		*decode_fmt  = 0x6;

		*plain_fmt = 0x2;

		break;

	case CAM_FORMAT_DPCM_10_6_10:

		*decode_fmt  = 0x7;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_DPCM_10_8_10:

		*decode_fmt  = 0x8;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_DPCM_12_6_12:

	case CAM_FORMAT_DPCM_12_8_12:

	case CAM_FORMAT_DPCM_14_8_14:

	case CAM_FORMAT_DPCM_14_10_14:

		*path_fmt  = 0xF;

		*plain_fmt = 0;

		*decode_fmt  = 0x9;

		*plain_fmt = 0x1;

		break;



	case CAM_FORMAT_PLAIN8:

		rc = cam_ife_csid_get_format(input_fmt, path_fmt);

		if (rc)

			goto error;



		*plain_fmt = 0;

	case CAM_FORMAT_DPCM_12_8_12:

		*decode_fmt  = 0xA;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_PLAIN16_8:

	case CAM_FORMAT_PLAIN16_10:

	case CAM_FORMAT_PLAIN16_12:

	case CAM_FORMAT_PLAIN16_14:

	case CAM_FORMAT_PLAIN16_16:

		rc = cam_ife_csid_get_format(input_fmt, path_fmt);

		if (rc)

			goto error;



		*plain_fmt = 1;

	case CAM_FORMAT_DPCM_14_8_14:

		*decode_fmt  = 0xB;

		*plain_fmt = 0x1;

		break;

	case CAM_FORMAT_PLAIN32_20:

		rc = cam_ife_csid_get_format(input_fmt, path_fmt);

		if (rc)

			goto error;



		*plain_fmt = 2;

	case CAM_FORMAT_DPCM_14_10_14:

		*decode_fmt  = 0xC;

		*plain_fmt = 0x1;

		break;

	default:

		*path_fmt  = 0xF;

		*plain_fmt = 0;

		break;

		CAM_ERR(CAM_ISP, "Unsupported format %d",

			in_format);

		rc = -EINVAL;

	}



	CAM_DBG(CAM_ISP, "path format value:%d plain format value:%d",

		 *path_fmt, *plain_fmt);

	CAM_DBG(CAM_ISP, "decode_fmt:%d plain_fmt:%d",

		 *decode_fmt, *plain_fmt);



	return 0;

error:

	return rc;



}





static int cam_ife_csid_cid_get(struct cam_ife_csid_hw *csid_hw,

	struct cam_isp_resource_node **res, int32_t vc, uint32_t dt,

	uint32_t res_type)
@@ -549,7 +645,7 @@ static int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw, 
				goto end;

				}

		} else {

			if (csid_hw->tpg_cfg.decode_fmt !=

			if (csid_hw->tpg_cfg.in_format !=

				cid_reserv->in_port->format     ||

				csid_hw->tpg_cfg.width !=

				cid_reserv->in_port->left_width ||
@@ -585,7 +681,7 @@ static int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw, 
				rc = -EINVAL;

				goto end;

			}

			csid_hw->tpg_cfg.decode_fmt =

			csid_hw->tpg_cfg.in_format =

				cid_reserv->in_port->format;

			csid_hw->tpg_cfg.width =

				cid_reserv->in_port->left_width;
@@ -712,20 +808,9 @@ static int cam_ife_csid_path_reserve(struct cam_ife_csid_hw *csid_hw, 
	res->res_state = CAM_ISP_RESOURCE_STATE_RESERVED;

	path_data = (struct cam_ife_csid_path_cfg   *)res->res_priv;



	/* store the output format for RDI */

	switch (reserve->res_id) {

	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:

		path_data->output_fmt = reserve->out_port->format;

		break;

	default:

		break;

	}



	path_data->cid = reserve->cid;

	path_data->decode_fmt = reserve->in_port->format;

	path_data->in_format = reserve->in_port->format;

	path_data->out_format = reserve->out_port->format;

	path_data->master_idx = reserve->master_idx;

	path_data->sync_mode = reserve->sync_mode;

	path_data->height  = reserve->in_port->height;
@@ -746,9 +831,14 @@ static int cam_ife_csid_path_reserve(struct cam_ife_csid_hw *csid_hw, 
		path_data->crop_enable = 1;

		path_data->start_pixel = reserve->in_port->right_start;

		path_data->width  = reserve->in_port->right_width;

	} else

	} else {

		path_data->crop_enable = 0;

		path_data->width  = reserve->in_port->left_width;

		path_data->start_pixel = reserve->in_port->left_start;

	}



	CAM_DBG(CAM_ISP, "Res %d width %d height %d\n", reserve->res_id,

		path_data->width, path_data->height);

	reserve->node_res = res;



end:
@@ -1027,10 +1117,10 @@ static int cam_ife_csid_config_tpg(struct cam_ife_csid_hw *csid_hw, 
		csid_reg->tpg_reg->csid_tpg_dt_n_cfg_1_addr);



	/*

	 * decode_fmt is the same as the input resource format.

	 * in_format is the same as the input resource format.

	 * it is one larger than the register spec format.

	 */

	val = ((csid_hw->tpg_cfg.decode_fmt - 1) << 16) | 0x8;

	val = ((csid_hw->tpg_cfg.in_format - 1) << 16) | 0x8;

	cam_io_w_mb(val, soc_info->reg_map[0].mem_base +

		csid_reg->tpg_reg->csid_tpg_dt_n_cfg_2_addr);
@@ -1160,7 +1250,7 @@ static int cam_ife_csid_init_config_ipp_path( 
	struct cam_ife_csid_path_cfg           *path_data;

	struct cam_ife_csid_reg_offset         *csid_reg;

	struct cam_hw_soc_info                 *soc_info;

	uint32_t path_format = 0, val = 0;

	uint32_t decode_format = 0, plain_format = 0, val = 0;



	path_data = (struct cam_ife_csid_path_cfg  *) res->res_priv;

	csid_reg = csid_hw->csid_info->csid_reg;
@@ -1173,8 +1263,9 @@ static int cam_ife_csid_init_config_ipp_path( 
		return -EINVAL;

	}



	CAM_DBG(CAM_ISP, "Enabled IPP Path.......");

	rc = cam_ife_csid_get_format(path_data->decode_fmt, &path_format);

	CAM_DBG(CAM_ISP, "Config IPP Path");

	rc = cam_ife_csid_get_format_ipp(path_data->in_format,

		&decode_format, &plain_format);

	if (rc)

		return rc;
@@ -1185,7 +1276,7 @@ static int cam_ife_csid_init_config_ipp_path( 
	val = (path_data->vc << csid_reg->cmn_reg->vc_shift_val) |

		(path_data->dt << csid_reg->cmn_reg->dt_shift_val) |

		(path_data->cid << csid_reg->cmn_reg->dt_id_shift_val) |

		(path_format << csid_reg->cmn_reg->fmt_shift_val) |

		(decode_format << csid_reg->cmn_reg->fmt_shift_val) |

		(path_data->crop_enable & 1 <<

		csid_reg->cmn_reg->crop_h_en_shift_val) |

		(path_data->crop_enable & 1 <<
@@ -1330,7 +1421,7 @@ static int cam_ife_csid_enable_ipp_path( 
		return -EINVAL;

	}



	CAM_DBG(CAM_ISP, "enable IPP path.......");

	CAM_DBG(CAM_ISP, "Enable IPP path");



	/* Resume at frame boundary */

	if (path_data->sync_mode == CAM_ISP_HW_SYNC_MASTER) {
@@ -1462,8 +1553,8 @@ static int cam_ife_csid_init_config_rdi_path( 
		return -EINVAL;

	}



	rc = cam_ife_csid_get_rdi_format(path_data->decode_fmt,

		path_data->output_fmt, &path_format, &plain_fmt);

	rc = cam_ife_csid_get_format_rdi(path_data->in_format,

		path_data->out_format, &path_format, &plain_fmt);

	if (rc)

		return rc;
@@ -1536,6 +1627,18 @@ static int cam_ife_csid_init_config_rdi_path( 
	val = cam_io_r_mb(soc_info->reg_map[0].mem_base +

		csid_reg->rdi_reg[id]->csid_rdi_cfg0_addr);

	val |= (1 << csid_reg->cmn_reg->path_en_shift_val);

#if MEASURE_EN

	val |= 0x2;

	cam_io_w_mb(0x3, soc_info->reg_map[0].mem_base +

		csid_reg->rdi_reg[id]->csid_rdi_format_measure_cfg0_addr);

	cam_io_w_mb(path_data->height << 16 | path_data->width,

		soc_info->reg_map[0].mem_base +

		csid_reg->rdi_reg[id]->csid_rdi_format_measure_cfg1_addr);

	CAM_DBG(CAM_ISP, "measure_cfg1 0x%x offset 0x%x\n",

		path_data->height << 16 | path_data->width,

		csid_reg->rdi_reg[id]->csid_rdi_format_measure_cfg0_addr);



#endif

	cam_io_w_mb(val, soc_info->reg_map[0].mem_base +

		csid_reg->rdi_reg[id]->csid_rdi_cfg0_addr);
@@ -1605,7 +1708,11 @@ static int cam_ife_csid_enable_rdi_path( 
			csid_reg->rdi_reg[id]->csid_rdi_ctrl_addr);



	/* Enable the required RDI interrupts */

	val = CSID_PATH_INFO_RST_DONE | CSID_PATH_ERROR_FIFO_OVERFLOW;

	val = CSID_PATH_INFO_RST_DONE |

#if MEASURE_EN

		CSID_PATH_INFO_INPUT_SOF |

#endif

		CSID_PATH_ERROR_FIFO_OVERFLOW;

	cam_io_w_mb(val, soc_info->reg_map[0].mem_base +

		csid_reg->rdi_reg[id]->csid_rdi_irq_mask_addr);
@@ -2298,6 +2405,9 @@ irqreturn_t cam_ife_csid_irq(int irq_num, void *data) 
	struct cam_ife_csid_reg_offset  *csid_reg;

	uint32_t i, irq_status_top, irq_status_rx, irq_status_ipp = 0,

		irq_status_rdi[4];

#if MEASURE_EN

	uint32_t val;

#endif



	csid_hw = (struct cam_ife_csid_hw *)data;
@@ -2428,8 +2538,15 @@ irqreturn_t cam_ife_csid_irq(int irq_num, void *data) 
			complete(&csid_hw->csid_rdin_complete[i]);

		}



		if (irq_status_rdi[i]  & CSID_PATH_INFO_INPUT_SOF)

		if (irq_status_rdi[i]  & CSID_PATH_INFO_INPUT_SOF) {

			CAM_DBG(CAM_ISP, "CSID RDI SOF received");

#if MEASURE_EN

			val = cam_io_r(soc_info->reg_map[0].mem_base +

				csid_reg->rdi_reg[i]->

				csid_rdi_format_measure0_addr);

			CAM_ERR(CAM_ISP, "measure 0x%x\n", val);

#endif

		}

		if (irq_status_rdi[i]  & CSID_PATH_INFO_INPUT_EOF)

			CAM_DBG(CAM_ISP, "CSID RDI EOF received");