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

Commit 79a752b3 authored by Sridhar Gujje's avatar Sridhar Gujje
Browse files

Merge remote-tracking branch 'dev/msm-4.14-camx' into msm-4.14.c4 08/12 



* commit '5ec74675':
  msm: camera: cam_isp: Change default fps value
  ARM: dts: msm: Add camera sensor nodes for atoll
  ARM: dts: qcom: Enable phy regulators for atoll
  ARM: dts: qcom: Add csiphy, cci for atoll
  msm: camera: cpas: Add cpas support for camera v150_110 platform
  ARM: dts: msm: Add AHB-IB voting bandwidth to bring up v150_110 camera
  msm: camera: eeprom: Release the mutex even though got error
  ARM: dts: msm: Add PPI clock sources to bring up v150_110 camera
  msm: camera: isp: Added PPI driver functionality
  ARM: dts: msm: Add dtsi support for v150_110 camera
  msm: camera: Add csiphy version for atoll
  msm: camera: isp: Log information during IFE acquire failure
  msm: camera: cam_isp: Recovery after IRQ delayed
  msm: camera: isp: Add fps Blob support
  msm: camera: isp: Enable pixel_format_measurement in CSID
  msm: camera: isp: Handle wait and active list during flush all
  msm: camera: isp: Add irq status prints to CAM_ERR

Change-Id: I7caa2253ad5dfcc5275ee5945ff8b118e7de225a
Signed-off-by: default avatarSridhar Gujje <sgujje@codeaurora.org>
parents f5b8c133 5ec74675

drivers/media/platform/msm/camera/cam_core/cam_hw_mgr_intf.h

+12 −0
Original line number Diff line number Diff line
@@ -262,6 +262,16 @@ struct cam_hw_dump_pf_args { 
	bool                           *mem_found;

};



/**

 * struct cam_hw_reset_args -hw reset arguments

 *

 * @ctxt_to_hw_map:        HW context from the acquire

 *

 */

struct cam_hw_reset_args {

	void                           *ctxt_to_hw_map;

};



/* enum cam_hw_mgr_command - Hardware manager command type */

enum cam_hw_mgr_command {

	CAM_HW_MGR_CMD_INTERNAL,
@@ -313,6 +323,7 @@ struct cam_hw_cmd_args { 
 * @hw_open:                   Function pointer for HW init

 * @hw_close:                  Function pointer for HW deinit

 * @hw_flush:                  Function pointer for HW flush

 * @hw_reset:                  Function pointer for HW reset

 *

 */

struct cam_hw_mgr_intf {
@@ -333,6 +344,7 @@ struct cam_hw_mgr_intf { 
	int (*hw_open)(void *hw_priv, void *fw_download_args);

	int (*hw_close)(void *hw_priv, void *hw_close_args);

	int (*hw_flush)(void *hw_priv, void *hw_flush_args);

	int (*hw_reset)(void *hw_priv, void *hw_reset_args);

};



#endif /* _CAM_HW_MGR_INTF_H_ */

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

+190 −17
Original line number Diff line number Diff line
@@ -452,6 +452,14 @@ static int __cam_isp_ctx_handle_buf_done_in_activated_state( 
	trace_cam_buf_done("ISP", ctx, req);



	req_isp = (struct cam_isp_ctx_req *) req->req_priv;

	if (ctx_isp->frame_id == 1)

		ctx_isp->irq_timestamps = done->irq_mono_boot_time;

	else if (ctx_isp->fps && ((done->irq_mono_boot_time -

		ctx_isp->irq_timestamps) > ((1000*1000)/ctx_isp->fps)))

		ctx_isp->irq_delay_detect = true;



	ctx_isp->irq_timestamps = done->irq_mono_boot_time;



	for (i = 0; i < done->num_handles; i++) {

		for (j = 0; j < req_isp->num_fence_map_out; j++) {

			if (done->resource_handle[i] ==
@@ -565,6 +573,26 @@ static int __cam_isp_ctx_handle_buf_done_in_activated_state( 
			ctx_isp->substate_activated);

	}



	if (ctx_isp->active_req_cnt && ctx_isp->irq_delay_detect) {

		CAM_ERR(CAM_ISP, "isp req[%lld] IRQ buf done got delayed",

				req->request_id);

		req = list_first_entry(&ctx->active_req_list,

			struct cam_ctx_request, list);

		req_isp = (struct cam_isp_ctx_req *) req->req_priv;



		for (j = 0; j < req_isp->num_fence_map_out; j++) {

			rc = cam_sync_signal(req_isp->fence_map_out[j].sync_id,

				CAM_SYNC_STATE_SIGNALED_ERROR);

			if (rc)

				CAM_DBG(CAM_ISP, "Sync failed with rc = %d",

					rc);

			req_isp->fence_map_out[j].sync_id = -1;

		}

		list_del_init(&req->list);

		list_add_tail(&req->list, &ctx->free_req_list);

		ctx_isp->active_req_cnt--;

	}

	ctx_isp->irq_delay_detect = false;

end:

	return rc;

}
@@ -643,12 +671,47 @@ static void __cam_isp_ctx_send_sof_timestamp( 
static int __cam_isp_ctx_reg_upd_in_epoch_state(

	struct cam_isp_context *ctx_isp, void *evt_data)

{

	if (ctx_isp->frame_id == 1)

	struct cam_isp_hw_reg_update_event_data  *rup_event_data = evt_data;



	struct cam_context      *ctx     = ctx_isp->base;

	struct cam_ctx_request  *req     = NULL;

	struct cam_isp_ctx_req  *req_isp = NULL;



	if (ctx_isp->frame_id == 1) {

		CAM_DBG(CAM_ISP, "Reg update for early PCR");

	else

		if (!list_empty(&ctx->active_req_list)) {

			req = list_first_entry(&ctx->active_req_list,

					struct cam_ctx_request, list);

			req_isp = (struct cam_isp_ctx_req *) req->req_priv;

		} else if (!list_empty(&ctx->wait_req_list)) {

			req = list_first_entry(&ctx->active_req_list,

					struct cam_ctx_request, list);

			req_isp = (struct cam_isp_ctx_req *) req->req_priv;

		}

	} else {

		if (!list_empty(&ctx->wait_req_list)) {

			req = list_first_entry(&ctx->active_req_list,

					struct cam_ctx_request, list);

			req_isp = (struct cam_isp_ctx_req *) req->req_priv;

		}

		CAM_WARN(CAM_ISP,

			"Unexpected reg update in activated substate:%d for frame_id:%lld",

			ctx_isp->substate_activated, ctx_isp->frame_id);

	}



	if (req_isp && req_isp->hw_update_data.fps) {

		ctx_isp->fps = req_isp->hw_update_data.fps;

		CAM_DBG(CAM_ISP, "req_isp %pK, Upadting ctx_isp->fps %d",

				req_isp, ctx_isp->fps);

	}



	if (ctx_isp->frame_id == 1)

		ctx_isp->irq_timestamps = rup_event_data->irq_mono_boot_time;

	else if (ctx_isp->fps && ((rup_event_data->irq_mono_boot_time -

			ctx_isp->irq_timestamps) > ((1000*1000)/ctx_isp->fps)))

		ctx_isp->irq_delay_detect = true;



	ctx_isp->irq_timestamps = rup_event_data->irq_mono_boot_time;

	return 0;

}
@@ -658,7 +721,8 @@ static int __cam_isp_ctx_reg_upd_in_activated_state( 
	int rc = 0;

	struct cam_ctx_request  *req;

	struct cam_context      *ctx = ctx_isp->base;

	struct cam_isp_ctx_req  *req_isp;

	struct cam_isp_ctx_req  *req_isp = NULL;

	struct cam_isp_hw_reg_update_event_data  *rup_event_data = evt_data;



	if (list_empty(&ctx->wait_req_list)) {

		CAM_ERR(CAM_ISP, "Reg upd ack with no waiting request");
@@ -683,13 +747,22 @@ static int __cam_isp_ctx_reg_upd_in_activated_state( 
			req->request_id, ctx_isp->active_req_cnt, ctx->ctx_id);

	}



	if (req_isp && req_isp->hw_update_data.fps)

		ctx_isp->fps = req_isp->hw_update_data.fps;



	/*

	 * This function only called directly from applied and bubble applied

	 * state so change substate here.

	 */

	ctx_isp->substate_activated = CAM_ISP_CTX_ACTIVATED_EPOCH;

	CAM_DBG(CAM_ISP, "next substate %d", ctx_isp->substate_activated);

	if (ctx_isp->frame_id == 1)

		ctx_isp->irq_timestamps = rup_event_data->irq_mono_boot_time;

	else if (ctx_isp->fps && ((rup_event_data->irq_mono_boot_time -

			ctx_isp->irq_timestamps) > ((1000*1000)/ctx_isp->fps)))

		ctx_isp->irq_delay_detect = true;



	ctx_isp->irq_timestamps = rup_event_data->irq_mono_boot_time;

end:

	return rc;

}
@@ -817,6 +890,14 @@ static int __cam_isp_ctx_sof_in_activated_state( 
	ctx_isp->sof_timestamp_val = sof_event_data->timestamp;

	ctx_isp->boot_timestamp = sof_event_data->boot_time;



	if (ctx_isp->frame_id == 1)

		ctx_isp->irq_timestamps = sof_event_data->irq_mono_boot_time;

	else if (ctx_isp->fps && ((sof_event_data->irq_mono_boot_time -

			ctx_isp->irq_timestamps) > ((1000*1000)/ctx_isp->fps)))

		ctx_isp->irq_delay_detect = true;



	ctx_isp->irq_timestamps = sof_event_data->irq_mono_boot_time;



	CAM_DBG(CAM_ISP, "frame id: %lld time stamp:0x%llx, ctx %u",

		ctx_isp->frame_id, ctx_isp->sof_timestamp_val, ctx->ctx_id);
@@ -828,8 +909,9 @@ static int __cam_isp_ctx_reg_upd_in_sof(struct cam_isp_context *ctx_isp, 
{

	int rc = 0;

	struct cam_ctx_request *req = NULL;

	struct cam_isp_ctx_req *req_isp;

	struct cam_isp_ctx_req *req_isp = NULL;

	struct cam_context *ctx = ctx_isp->base;

	struct cam_isp_hw_reg_update_event_data  *rup_event_data = evt_data;



	if (ctx->state != CAM_CTX_ACTIVATED && ctx_isp->frame_id > 1) {

		CAM_DBG(CAM_ISP, "invalid RUP");
@@ -852,6 +934,16 @@ static int __cam_isp_ctx_reg_upd_in_sof(struct cam_isp_context *ctx_isp, 
				"receive rup in unexpected state");

	}



	if (req_isp && req_isp->hw_update_data.fps)

		ctx_isp->fps = req_isp->hw_update_data.fps;



	if (ctx_isp->frame_id == 1)

		ctx_isp->irq_timestamps = rup_event_data->irq_mono_boot_time;

	else if (ctx_isp->fps && ((rup_event_data->irq_mono_boot_time -

			ctx_isp->irq_timestamps) > ((1000*1000)/ctx_isp->fps)))

		ctx_isp->irq_delay_detect = true;



	ctx_isp->irq_timestamps = rup_event_data->irq_mono_boot_time;

end:

	return rc;

}
@@ -860,9 +952,10 @@ static int __cam_isp_ctx_epoch_in_applied(struct cam_isp_context *ctx_isp, 
	void *evt_data)

{

	struct cam_ctx_request    *req;

	struct cam_isp_ctx_req    *req_isp;

	struct cam_isp_ctx_req    *req_isp = NULL;

	struct cam_context        *ctx = ctx_isp->base;

	uint64_t  request_id = 0;

	struct cam_isp_hw_epoch_event_data *epoch_hw_event_data = evt_data;



	if (list_empty(&ctx->wait_req_list)) {

		/*
@@ -928,6 +1021,15 @@ static int __cam_isp_ctx_epoch_in_applied(struct cam_isp_context *ctx_isp, 
		ctx_isp->substate_activated);

end:



	if (ctx_isp->frame_id == 1)

		ctx_isp->irq_timestamps =

			epoch_hw_event_data->irq_mono_boot_time;

	else if (ctx_isp->fps && ((epoch_hw_event_data->irq_mono_boot_time -

			ctx_isp->irq_timestamps) > ((1000*1000)/ctx_isp->fps)))

		ctx_isp->irq_delay_detect = true;



	ctx_isp->irq_timestamps = epoch_hw_event_data->irq_mono_boot_time;



	return 0;

}
@@ -960,6 +1062,14 @@ static int __cam_isp_ctx_sof_in_epoch(struct cam_isp_context *ctx_isp, 
	ctx_isp->sof_timestamp_val = sof_event_data->timestamp;

	ctx_isp->boot_timestamp = sof_event_data->boot_time;



	if (ctx_isp->frame_id == 1)

		ctx_isp->irq_timestamps = sof_event_data->irq_mono_boot_time;

	else if (ctx_isp->fps && ((sof_event_data->irq_mono_boot_time -

			ctx_isp->irq_timestamps) > ((1000*1000)/ctx_isp->fps)))

		ctx_isp->irq_delay_detect = true;



	ctx_isp->irq_timestamps = sof_event_data->irq_mono_boot_time;



	if (list_empty(&ctx->active_req_list))

		ctx_isp->substate_activated = CAM_ISP_CTX_ACTIVATED_SOF;

	else
@@ -1442,7 +1552,7 @@ static int __cam_isp_ctx_fs2_reg_upd_in_sof(struct cam_isp_context *ctx_isp, 
{

	int rc = 0;

	struct cam_ctx_request *req = NULL;

	struct cam_isp_ctx_req *req_isp;

	struct cam_isp_ctx_req *req_isp = NULL;

	struct cam_context *ctx = ctx_isp->base;



	if (ctx->state != CAM_CTX_ACTIVATED && ctx_isp->frame_id > 1) {
@@ -1466,6 +1576,9 @@ static int __cam_isp_ctx_fs2_reg_upd_in_sof(struct cam_isp_context *ctx_isp, 
				"receive rup in unexpected state");

	}



	if (req_isp && req_isp->hw_update_data.fps)

		ctx_isp->fps = req_isp->hw_update_data.fps;



end:

	return rc;

}
@@ -1476,7 +1589,7 @@ static int __cam_isp_ctx_fs2_reg_upd_in_applied_state( 
	int rc = 0;

	struct cam_ctx_request  *req = NULL;

	struct cam_context      *ctx = ctx_isp->base;

	struct cam_isp_ctx_req  *req_isp;

	struct cam_isp_ctx_req  *req_isp = NULL;

	struct cam_req_mgr_trigger_notify  notify;

	uint64_t  request_id  = 0;
@@ -1499,6 +1612,9 @@ static int __cam_isp_ctx_fs2_reg_upd_in_applied_state( 
		list_add_tail(&req->list, &ctx->free_req_list);

	}



	if (req_isp && req_isp->hw_update_data.fps)

		ctx_isp->fps = req_isp->hw_update_data.fps;



	/*

	 * This function only called directly from applied and bubble applied

	 * state so change substate here.
@@ -1922,16 +2038,19 @@ static int __cam_isp_ctx_flush_req_in_top_state( 
	struct cam_req_mgr_flush_request *flush_req)

{

	int rc = 0;

	struct cam_isp_context *ctx_isp;



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

	struct cam_isp_context           *ctx_isp =

		(struct cam_isp_context *) ctx->ctx_priv;

	struct cam_isp_stop_args          stop_isp;

	struct cam_hw_stop_args           stop_args;

	struct cam_isp_start_args         start_isp;

	struct cam_hw_reset_args          reset_args;

	if (flush_req->type == CAM_REQ_MGR_FLUSH_TYPE_ALL) {

		CAM_INFO(CAM_ISP, "Last request id to flush is %lld",

			flush_req->req_id);

		CAM_INFO(CAM_ISP, "ctx id:%d Last request id to flush is %lld",

			ctx->ctx_id, flush_req->req_id);

		ctx->last_flush_req = flush_req->req_id;

	}



	CAM_DBG(CAM_ISP, "try to flush pending list");

	CAM_DBG(CAM_ISP, "ctx id:%d try to flush pending list", ctx->ctx_id);

	spin_lock_bh(&ctx->lock);

	rc = __cam_isp_ctx_flush_req(ctx, &ctx->pending_req_list, flush_req);
@@ -1954,6 +2073,57 @@ static int __cam_isp_ctx_flush_req_in_top_state( 
	spin_unlock_bh(&ctx->lock);



	atomic_set(&ctx_isp->process_bubble, 0);

	if (flush_req->type == CAM_REQ_MGR_FLUSH_TYPE_ALL) {

		/* if active and wait list are empty, return */

		spin_lock_bh(&ctx->lock);

		if ((list_empty(&ctx->wait_req_list)) &&

			(list_empty(&ctx->active_req_list))) {

			spin_unlock_bh(&ctx->lock);

			CAM_DBG(CAM_ISP, "ctx id:%d active,wait list are empty",

				ctx->ctx_id);

			goto end;

		}

		spin_unlock_bh(&ctx->lock);



		/* Stop hw first before active list flush */

		CAM_DBG(CAM_ISP, "ctx id:%d try to stop hw", ctx->ctx_id);

		stop_args.ctxt_to_hw_map = ctx_isp->hw_ctx;

		stop_isp.hw_stop_cmd = CAM_ISP_HW_STOP_AT_FRAME_BOUNDARY;

		stop_isp.stop_only = true;

		stop_args.args = (void *)&stop_isp;

		ctx->hw_mgr_intf->hw_stop(ctx->hw_mgr_intf->hw_mgr_priv,

				&stop_args);



		spin_lock_bh(&ctx->lock);

		CAM_DBG(CAM_ISP, "try to flush wait list");

		rc = __cam_isp_ctx_flush_req(ctx, &ctx->wait_req_list,

		flush_req);

		CAM_DBG(CAM_ISP, "try to flush active list");

		rc = __cam_isp_ctx_flush_req(ctx, &ctx->active_req_list,

		flush_req);

		ctx_isp->active_req_cnt = 0;

		spin_unlock_bh(&ctx->lock);



		CAM_DBG(CAM_ISP, "try to reset hw");

		/* Reset hw */

		reset_args.ctxt_to_hw_map = ctx_isp->hw_ctx;

		rc = ctx->hw_mgr_intf->hw_reset(ctx->hw_mgr_intf->hw_mgr_priv,

			&reset_args);

		if (rc)

			goto end;



		CAM_DBG(CAM_ISP, "ctx id%d try to start hw", ctx->ctx_id);

		/* Start hw */

		start_isp.hw_config.ctxt_to_hw_map = ctx_isp->hw_ctx;

		start_isp.start_only = true;

		start_isp.hw_config.priv = NULL;



		rc = ctx->hw_mgr_intf->hw_start(ctx->hw_mgr_intf->hw_mgr_priv,

			&start_isp);

	}



end:

	ctx_isp->substate_activated = CAM_ISP_CTX_ACTIVATED_SOF;

	return rc;

}
@@ -2339,7 +2509,7 @@ static int __cam_isp_ctx_rdi_only_reg_upd_in_bubble_applied_state( 
{

	struct cam_ctx_request  *req;

	struct cam_context      *ctx = ctx_isp->base;

	struct cam_isp_ctx_req  *req_isp;

	struct cam_isp_ctx_req  *req_isp = NULL;

	struct cam_req_mgr_trigger_notify  notify;

	uint64_t  request_id  = 0;
@@ -2394,6 +2564,9 @@ static int __cam_isp_ctx_rdi_only_reg_upd_in_bubble_applied_state( 
			jiffies_to_msecs(jiffies);

	}



	if (req_isp && req_isp->hw_update_data.fps)

		ctx_isp->fps = req_isp->hw_update_data.fps;



	__cam_isp_ctx_send_sof_timestamp(ctx_isp, request_id,

		CAM_REQ_MGR_SOF_EVENT_SUCCESS);

	CAM_DBG(CAM_ISP, "next substate %d", ctx_isp->substate_activated);
@@ -2669,7 +2842,7 @@ static int __cam_isp_ctx_config_dev_in_top_state( 
{

	int rc = 0, i;

	struct cam_ctx_request           *req = NULL;

	struct cam_isp_ctx_req           *req_isp;

	struct cam_isp_ctx_req           *req_isp = NULL;

	uintptr_t                         packet_addr;

	struct cam_packet                *packet;

	size_t                            len = 0;
@@ -2758,6 +2931,7 @@ static int __cam_isp_ctx_config_dev_in_top_state( 
		rc = -EFAULT;

		goto free_cpu_buf;

	}



	req_isp->num_cfg = cfg.num_hw_update_entries;

	req_isp->num_fence_map_out = cfg.num_out_map_entries;

	req_isp->num_fence_map_in = cfg.num_in_map_entries;
@@ -2814,6 +2988,7 @@ static int __cam_isp_ctx_config_dev_in_top_state( 
			CAM_ERR(CAM_ISP, "Recevied Update in wrong state");

		}

	}



	if (rc)

		goto put_ref;
@@ -3595,8 +3770,6 @@ static int __cam_isp_ctx_apply_req(struct cam_context *ctx, 
	return rc;

}







static int __cam_isp_ctx_handle_irq_in_activated(void *context,

	uint32_t evt_id, void *evt_data)

{

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

+11 −0
Original line number Diff line number Diff line
@@ -34,6 +34,11 @@ 
 */

#define CAM_ISP_CTX_CFG_MAX                     22



/*

 * Defalut fps value set to 30

 */

#define CAM_ISP_CTX_DEFAULT_FPS                 30



/*

 * Maximum entries in state monitoring array for error logging

 */
@@ -180,6 +185,9 @@ struct cam_isp_context_req_id_info { 
 * @hw_acquired:               Indicate whether HW resources are acquired

 * @init_received:             Indicate whether init config packet is received

 * @split_acquire:             Indicate whether a separate acquire is expected

 * @irq_delay_detect:          Indicate whether a irq delay has detected or not

 * @irq_timestamps:            Timestamp from last handled IRQ

 * @fps:                       Current FPS for the activated state.

 *

 */

struct cam_isp_context {
@@ -209,6 +217,9 @@ struct cam_isp_context { 
	bool                             hw_acquired;

	bool                             init_received;

	bool                             split_acquire;

	bool                             irq_delay_detect;

	uint64_t                         irq_timestamps;

	uint32_t                         fps;

};



/**

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

+356 −18

File changed.

Preview size limit exceeded, changes collapsed.

drivers/media/platform/msm/camera/cam_isp/isp_hw_mgr/include/cam_isp_hw_mgr_intf.h

+16 −4
Original line number Diff line number Diff line
@@ -130,6 +130,7 @@ struct cam_isp_bw_config_internal { 
 * @bw_config:              BW config information

 * @bw_config_valid:        Flag indicating whether the bw_config at the index

 *                          is valid or not

 * @fps:                    fps vaue which has been updated in hw

 *

 */

struct cam_isp_prepare_hw_update_data {
@@ -137,6 +138,7 @@ struct cam_isp_prepare_hw_update_data { 
	struct cam_isp_bw_config_internal     bw_config[CAM_IFE_HW_NUM_MAX];

	struct cam_isp_bw_config_internal_ab  bw_config_ab[CAM_IFE_HW_NUM_MAX];

	bool                                bw_config_valid[CAM_IFE_HW_NUM_MAX];

	uint32_t                            fps;

};
@@ -145,11 +147,13 @@ struct cam_isp_prepare_hw_update_data { 
 *

 * @timestamp:          Time stamp for the sof event

 * @boot_time:          Boot time stamp for the sof event

 * @irq_mono_boot_time: Time stamp till the execution of IRQ wrt event started

 *

 */

struct cam_isp_hw_sof_event_data {

	uint64_t       timestamp;

	uint64_t       boot_time;

	uint64_t       irq_mono_boot_time;

};



/**
@@ -157,20 +161,24 @@ struct cam_isp_hw_sof_event_data { 
 *                         CAM_HW_EVENT_REG_UPDATE

 *

 * @timestamp:          Time stamp for the reg update event

 * @irq_mono_boot_time: Time stamp till the execution of IRQ wrt event started

 *

 */

struct cam_isp_hw_reg_update_event_data {

	uint64_t       timestamp;

	uint64_t       irq_mono_boot_time;

};



/**

 * struct cam_isp_hw_epoch_event_data - Event payload for CAM_HW_EVENT_EPOCH

 *

 * @timestamp:          Time stamp for the epoch event

 * @irq_mono_boot_time: Time stamp till the execution of this event started

 *

 */

struct cam_isp_hw_epoch_event_data {

	uint64_t       timestamp;

	uint64_t       irq_mono_boot_time;

};



/**
@@ -179,6 +187,7 @@ struct cam_isp_hw_epoch_event_data { 
 * @num_handles:           Number of resource handeles

 * @resource_handle:       Resource handle array

 * @timestamp:             Timestamp for the buf done event

 * @irq_mono_boot_time:    Time stamp till the execution of this event started

 *

 */

struct cam_isp_hw_done_event_data {
@@ -186,16 +195,19 @@ struct cam_isp_hw_done_event_data { 
	uint32_t             resource_handle[

				CAM_NUM_OUT_PER_COMP_IRQ_MAX];

	uint64_t       timestamp;

	uint64_t       irq_mono_boot_time;

};



/**

 * struct cam_isp_hw_eof_event_data - Event payload for CAM_HW_EVENT_EOF

 *

 * @timestamp:             Timestamp for the eof event

 * @irq_mono_boot_time:    Time stamp till the execution of this event started

 *

 */

struct cam_isp_hw_eof_event_data {

	uint64_t       timestamp;

	uint64_t       irq_mono_boot_time;

};



/**