From 9831108abfd9d06ce32f66d723919d31d927c1f6 Mon Sep 17 00:00:00 2001 From: Shivakumar Malke Date: Sun, 13 Nov 2022 19:20:11 +0530 Subject: [PATCH] msm: camera: isp: Handle early bufdones In case of early bufones, signalling fence for few ports are missed for target which do not support last consumed address which result in a unsignalled fence Issue is fixed by handling early bufdones and signalling success for resource which got early bufdone. CRs-Fixed: 3333269 Change-Id: I0a56f770806d48034bcc45d2ca68d8f9adcc8eee Signed-off-by: Shivakumar Malke --- drivers/cam_isp/cam_isp_context.c | 121 +++++++++++++++++++++++++++--- drivers/cam_isp/cam_isp_context.h | 9 ++- 2 files changed, 117 insertions(+), 13 deletions(-) diff --git a/drivers/cam_isp/cam_isp_context.c b/drivers/cam_isp/cam_isp_context.c index b01a2a63744c..dcb3570340a4 100644 --- a/drivers/cam_isp/cam_isp_context.c +++ b/drivers/cam_isp/cam_isp_context.c @@ -894,6 +894,33 @@ static int __cam_isp_ctx_handle_buf_done_for_req_list( return rc; } +static int __cam_isp_ctx_handle_early_buf_done( + struct cam_isp_context *ctx_isp, + struct cam_ctx_request *req) +{ + int i, rc = 0; + + struct cam_isp_ctx_req *req_isp = (struct cam_isp_ctx_req *) req->req_priv; + struct cam_context *ctx = ctx_isp->base; + + for (i = 0; i < req_isp->num_fence_map_out; i++) { + if (req_isp->early_fence_map_index[i] == 1) { + rc = cam_sync_signal(req_isp->fence_map_out[i].sync_id, + CAM_SYNC_STATE_SIGNALED_SUCCESS, + CAM_SYNC_COMMON_EVENT_SUCCESS); + req_isp->early_fence_map_index[i] = 0; + req_isp->fence_map_out[i].sync_id = -1; + CAM_DBG(CAM_ISP, + "Sync :req %lld res 0x%x fd 0x%x idx %d ctx %u", + req->request_id, + req_isp->fence_map_out[i].resource_handle, + req_isp->fence_map_out[i].sync_id, i, + ctx->ctx_id); + req_isp->flag_sync_set = true; + } + } + return rc; +} static int __cam_isp_ctx_handle_buf_done_for_request( struct cam_isp_context *ctx_isp, struct cam_ctx_request *req, @@ -968,6 +995,13 @@ static int __cam_isp_ctx_handle_buf_done_for_request( } if (!req_isp->bubble_detected) { + /* Signal fence for early bufdones got during reapply of a bubble req*/ + if ((req_isp->num_acked != 0) && (!req_isp->flag_sync_set)) { + rc = __cam_isp_ctx_handle_early_buf_done(ctx_isp, req); + if (rc) + CAM_ERR(CAM_ISP, "Sync early bufdone failed rc=%d", rc); + } + CAM_DBG(CAM_ISP, "Sync with success: req %lld res 0x%x fd 0x%x, ctx %u, Bad_frame %u", req->request_id, @@ -1017,18 +1051,19 @@ static int __cam_isp_ctx_handle_buf_done_for_request( */ req_isp->num_acked++; CAM_DBG(CAM_ISP, - "buf done with bubble state %d recovery %d", - bubble_state, req_isp->bubble_report); + "buf done with bubble state %d recovery %d num_acked %d ctx %u", + bubble_state, req_isp->bubble_report, + req_isp->num_acked, ctx->ctx_id); continue; } - CAM_DBG(CAM_ISP, "req %lld, reset sync id 0x%x ctx %u", - req->request_id, - req_isp->fence_map_out[j].sync_id, ctx->ctx_id); if (!rc) { req_isp->num_acked++; req_isp->fence_map_out[j].sync_id = -1; } + CAM_DBG(CAM_ISP, "rc %d num_acked %d req %lld, reset sync id 0x%x ctx %u", + rc, req_isp->num_acked, req->request_id, + req_isp->fence_map_out[j].sync_id, ctx->ctx_id); if ((ctx_isp->use_frame_header_ts) && (req_isp->hw_update_data.frame_header_res_id == @@ -1275,8 +1310,10 @@ static int __cam_isp_ctx_handle_buf_done_for_request_verify_addr( */ req_isp->num_acked++; CAM_DBG(CAM_ISP, - "buf done with bubble state %d recovery %d", - bubble_state, req_isp->bubble_report); + "num_acked %d buf done with bubble state %d recovery %d ctx %d", + req_isp->num_acked, bubble_state, + req_isp->bubble_report, + ctx->ctx_id); /* Process deferred buf_done acks */ if (req_isp->num_deferred_acks) @@ -1288,13 +1325,13 @@ static int __cam_isp_ctx_handle_buf_done_for_request_verify_addr( continue; } - CAM_DBG(CAM_ISP, "req %lld, reset sync id 0x%x ctx %u", - req->request_id, - req_isp->fence_map_out[j].sync_id, ctx->ctx_id); if (!rc) { req_isp->num_acked++; req_isp->fence_map_out[j].sync_id = -1; } + CAM_DBG(CAM_ISP, "num_acked %d req %lld, reset sync id 0x%x ctx %u", + req_isp->num_acked, req->request_id, + req_isp->fence_map_out[j].sync_id, ctx->ctx_id); if ((ctx_isp->use_frame_header_ts) && (req_isp->hw_update_data.frame_header_res_id == @@ -1329,9 +1366,60 @@ static int __cam_isp_ctx_handle_buf_done( struct cam_ctx_request *req; struct cam_context *ctx = ctx_isp->base; struct cam_isp_hw_done_event_data done_next_req; + int i, j; if (list_empty(&ctx->active_req_list)) { CAM_WARN(CAM_ISP, "Buf done with no active request"); + + if (!list_empty(&ctx->wait_req_list)) { + struct cam_isp_ctx_req *req_isp; + + req = list_first_entry(&ctx->wait_req_list, + struct cam_ctx_request, list); + + if (ctx_isp->last_applied_req_id != + ctx_isp->last_bufdone_err_apply_req_id) { + CAM_WARN(CAM_ISP, + "Buf done with req %llu in wait list apply id:%lld last err id:%lld", + req->request_id, + ctx_isp->last_applied_req_id, + ctx_isp->last_bufdone_err_apply_req_id); + ctx_isp->last_bufdone_err_apply_req_id = + ctx_isp->last_applied_req_id; + } + + req_isp = (struct cam_isp_ctx_req *) req->req_priv; + + /* + * do not signal the fence as this request may go into + * Bubble state eventually. + */ + for (i = 0; i < done->num_handles; i++) { + for (j = 0; j < req_isp->num_fence_map_out; j++) { + if (done->resource_handle[i] == + req_isp->fence_map_out[j].resource_handle) { + req_isp->num_acked++; + /* + * save the fence map out index for signalling + * fence during re-apply of bubble request. + */ + req_isp->early_fence_map_index[j]++; + + CAM_WARN(CAM_ISP, "Early done req %lld res 0x%x", + req->request_id, + done->resource_handle[i]); + + CAM_WARN(CAM_ISP, "ctx %u ack %d total %d idx %d", + ctx->ctx_id, + req_isp->num_acked, + req_isp->num_fence_map_out, j); + break; + } + } + } + } else { + CAM_WARN(CAM_ISP, "Buf done with no request in wait as well"); + } return 0; } @@ -2031,6 +2119,7 @@ static int __cam_isp_ctx_epoch_in_applied(struct cam_isp_context *ctx_isp, void *evt_data) { uint64_t request_id = 0; + uint32_t i; uint32_t sof_event_status = CAM_REQ_MGR_SOF_EVENT_SUCCESS; struct cam_req_mgr_trigger_notify notify; struct cam_ctx_request *req; @@ -2068,6 +2157,10 @@ static int __cam_isp_ctx_epoch_in_applied(struct cam_isp_context *ctx_isp, req_isp->reapply = true; req_isp->cdm_reset_before_apply = false; + /* reset early_fence_map_index array */ + for (i = 0; i < req_isp->num_fence_map_out; i++) + req_isp->early_fence_map_index[i] = 0; + CAM_INFO_RATE_LIMIT(CAM_ISP, "ctx:%d Report Bubble flag %d req id:%lld", ctx->ctx_id, req_isp->bubble_report, req->request_id); if (req_isp->bubble_report && ctx->ctx_crm_intf && @@ -3128,7 +3221,7 @@ static int __cam_isp_ctx_apply_req_in_activated_state( struct cam_context *ctx, struct cam_req_mgr_apply_request *apply, enum cam_isp_ctx_activated_substate next_state) { - int rc = 0; + int rc = 0, i; struct cam_ctx_request *req; struct cam_ctx_request *active_req = NULL; struct cam_isp_ctx_req *req_isp; @@ -3225,6 +3318,12 @@ static int __cam_isp_ctx_apply_req_in_activated_state( } req_isp->bubble_report = apply->report_if_bubble; + /* reset early_fence_map_index */ + for (i = 0; i < req_isp->num_fence_map_out; i++) + req_isp->early_fence_map_index[i] = 0; + + req_isp->flag_sync_set = false; + cfg.ctxt_to_hw_map = ctx_isp->hw_ctx; cfg.request_id = req->request_id; cfg.hw_update_entries = req_isp->cfg; diff --git a/drivers/cam_isp/cam_isp_context.h b/drivers/cam_isp/cam_isp_context.h index 108dc096d897..e216852cdbc5 100644 --- a/drivers/cam_isp/cam_isp_context.h +++ b/drivers/cam_isp/cam_isp_context.h @@ -143,6 +143,10 @@ struct cam_isp_ctx_irq_ops { * @num_acked: Count to track acked entried for output. * If count equals the number of fence out, it means * the request has been completed. + * @early_fence_map_index Array which stores fence map out index for resource + * which early buf done is received. + * @flag_sync_set Flags to track if early bufdone fence are signalled + * or not * @num_deferred_acks: Number of buf_dones/acks that are deferred to * handle or signalled in special scenarios. * Increment this count instead of num_acked and @@ -163,12 +167,13 @@ struct cam_isp_ctx_req { struct cam_ctx_request *base; struct cam_hw_update_entry cfg[CAM_ISP_CTX_CFG_MAX]; uint32_t num_cfg; - struct cam_hw_fence_map_entry fence_map_out - [CAM_ISP_CTX_RES_MAX]; + struct cam_hw_fence_map_entry fence_map_out[CAM_ISP_CTX_RES_MAX]; uint32_t num_fence_map_out; struct cam_hw_fence_map_entry fence_map_in[CAM_ISP_CTX_RES_MAX]; uint32_t num_fence_map_in; uint32_t num_acked; + uint32_t early_fence_map_index[CAM_ISP_CTX_RES_MAX]; + bool flag_sync_set; uint32_t num_deferred_acks; uint32_t deferred_fence_map_index[CAM_ISP_CTX_RES_MAX]; int32_t bubble_report;