msm: camera: req_mgr: CRM Code refactoring

Due to major changes in CRM code, refactoring CRM
kernel driver code. Fix apply threshold calculation logic.

CRs-Fixed: 2783209
Change-Id: I08ba6c89b0d4f0e982c017bab4226a569327f861
Signed-off-by: Ayush Kumar <[email protected]>

drivers/cam_isp/cam_isp_context.c

@@ -581,6 +581,7 @@ static int __cam_isp_ctx_enqueue_init_request(
 				req_isp_new->hw_update_data.frame_header_res_id;
 			req_isp_old->hw_update_data.frame_header_cpu_addr =
 				hw_update_data->frame_header_cpu_addr;
+			req_isp_old->hw_update_data.fps = req_isp_new->hw_update_data.fps;
 
 			req_old->request_id = req->request_id;
 
@@ -1118,10 +1119,8 @@ static int __cam_isp_ctx_handle_buf_done_for_request(
 		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) {
+		if (!rc)
 			req_isp->num_acked++;
-			req_isp->fence_map_out[j].sync_id = -1;
-		}
 
 		if ((ctx_isp->use_frame_header_ts) &&
 			(req_isp->hw_update_data.frame_header_res_id ==
@@ -1975,14 +1974,14 @@ notify_only:
 				req = list_first_entry(&ctx->active_req_list,
 					struct cam_ctx_request, list);
 				req_isp = (struct cam_isp_ctx_req *) req->req_priv;
-				notify.fps = req_isp->hw_update_data.fps;
-			} else {
-				notify.fps = 0;
+				if (req_isp->hw_update_data.fps != -1)
+					ctx_isp->fps = req_isp->hw_update_data.fps;
 			}
 
+			notify.fps = ctx_isp->fps;
 			ctx->ctx_crm_intf->notify_trigger(&notify);
-			CAM_DBG(CAM_ISP, "Notify CRM  SOF frame %lld ctx %u",
-				ctx_isp->frame_id, ctx->ctx_id);
+			CAM_DBG(CAM_ISP, "Notify CRM  SOF frame %lld ctx %u fps %d",
+				ctx_isp->frame_id, ctx->ctx_id, ctx_isp->fps);
 		}
 
 		list_for_each_entry(req, &ctx->active_req_list, list) {
@@ -2213,8 +2212,6 @@ static int __cam_isp_ctx_epoch_in_applied(struct cam_isp_context *ctx_isp,
 			req->request_id, ctx->ctx_id);
 		rc = ctx->ctx_crm_intf->notify_err(&notify);
 
-		CAM_DBG(CAM_CRM, "Need bubble recovery %d", rc);
-
 		if (rc) {
 			req_isp->bubble_detected = false;
 			req_isp->reapply = false;
@@ -4043,6 +4040,7 @@ static struct cam_ctx_ops
 			.notify_frame_skip =
 				__cam_isp_ctx_apply_default_req_settings,
 			.change_state = __cam_isp_ctx_change_substate,
+			.signal_buf_done = __cam_isp_ctx_signal_buf_done,
 		},
 		.irq_ops = NULL,
 	},
@@ -4979,6 +4977,7 @@ static int __cam_isp_ctx_config_dev_in_top_state(
 	cfg.num_out_map_entries = 0;
 	cfg.num_in_map_entries = 0;
 	req_isp->hw_update_data.fps = -1;
+	req_isp->hw_update_data.packet = packet;
 
 	CAM_DBG(CAM_ISP, "try to prepare config packet......");
 
@@ -4997,7 +4996,6 @@ static int __cam_isp_ctx_config_dev_in_top_state(
 	req_isp->num_deferred_acks = 0;
 	req_isp->bubble_detected = false;
 	req_isp->cdm_reset_before_apply = false;
-	req_isp->hw_update_data.packet = packet;
 	atomic_set(&req_isp->buf_done_ready, INIT_BUF_DONE);
 
 	for (i = 0; i < req_isp->num_fence_map_out; i++) {
@@ -5908,6 +5906,7 @@ static int __cam_isp_ctx_start_dev_in_ready(struct cam_context *ctx,
 	ctx_isp->active_req_cnt = 0;
 	ctx_isp->reported_req_id = 0;
 	ctx_isp->bubble_frame_cnt = 0;
+	ctx_isp->fps = req_isp->hw_update_data.fps;
 	ctx_isp->substate_activated = ctx_isp->rdi_only_context ?
 		CAM_ISP_CTX_ACTIVATED_APPLIED :
 		(req_isp->num_fence_map_out) ? CAM_ISP_CTX_ACTIVATED_EPOCH :
@@ -6089,6 +6088,7 @@ static int __cam_isp_ctx_stop_dev_in_activated_unlock(
 	ctx_isp->last_applied_req_id = 0;
 	ctx_isp->req_info.last_bufdone_req_id = 0;
 	ctx_isp->bubble_frame_cnt = 0;
+	ctx_isp->fps = -1;
 	atomic_set(&ctx_isp->process_bubble, 0);
 	atomic_set(&ctx_isp->rxd_epoch, 0);
 	atomic64_set(&ctx_isp->state_monitor_head, -1);

drivers/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c

@@ -8815,11 +8815,12 @@ static int cam_isp_packet_generic_blob_handler(void *user_data,
 
 		prepare_hw_data = (struct cam_isp_prepare_hw_update_data *)
 				prepare->priv;
-		if (fps_config->fps) {
+		if (fps_config->fps)
 			prepare_hw_data->fps = fps_config->fps;
-			CAM_DBG(CAM_ISP, "FPS value %u", fps_config->fps);
-		} else
-			CAM_WARN(CAM_ISP, "FPS value 0");
+		CAM_DBG(CAM_ISP, "FPS value %u ctx %d req id %lld",
+			fps_config->fps, ife_mgr_ctx->ctx_index,
+			prepare_hw_data->packet->header.request_id);
+
 	}
 		break;
 	default:

drivers/cam_req_mgr/cam_req_mgr_core.h

@@ -264,7 +264,6 @@ struct cam_req_mgr_req_tbl {
  * @recover            : if user enabled recovery for this request.
  * @req_id             : mask tracking which all devices have request ready
  * @sync_mode          : Modified sync mode in which req id in this slot has to applied
- * @real_sync_mode     : Actual sync mode in which req id in this slot has to applied
  * @additional_timeout : Adjusted watchdog timeout value associated with
  * this request
  */
@@ -275,7 +274,6 @@ struct cam_req_mgr_slot {
 	int32_t               recover;
 	int64_t               req_id;
 	int32_t               sync_mode;
-	int32_t               real_sync_mode;
 	int32_t               additional_timeout;
 };
 
@@ -334,6 +332,48 @@ struct cam_req_mgr_connected_device {
 	void                           *parent;
 };
 
+/**
+ * struct cam_req_mgr_sof_time
+ * - Frame sof time in ns
+ * @csid_timestamp_ns        : CSID SOF timestamp value
+ * @prev_csid_timestamp_ns   : Previous CSID SOF timestamp value
+ * @boottime_ns              : SOF Boottime value
+ * @last_sof_trigger_jiffies : Record the jiffies of last sof trigger jiffies
+ */
+struct cam_req_mgr_sof_time {
+	uint64_t          boottime_ns;
+	uint64_t          csid_timestamp_ns;
+	uint64_t          prev_csid_timestamp_ns;
+	uint64_t          last_sof_trigger_jiffies;
+};
+
+/**
+ * struct cam_req_mgr_sync_data
+ * - Sync link data and properties
+ * @num_sync_link          : total number of sync links
+ * @sync_link              : array of pointer to the sync link for synchronization
+ * @initial_sync_req       : The initial req which is required to sync with the
+ *                           other link
+ * @modified_init_sync_req : Modified initial req which is required to sync
+ *                           with the other link
+ * @sync_link_sof_skip     : flag determines if a pkt is not available for a given
+ *                           frame in a particular link skip corresponding
+ *                           frame in sync link as well.
+ * @sync_frame_id          : current frame id of sync link
+ * @sof_time               : sof timing value in different format
+ * @is_sync_req            : flag used for deciding sync and non-sync
+ */
+struct cam_req_mgr_sync_data {
+	int32_t                        num_sync_link;
+	struct cam_req_mgr_core_link  *sync_link[MAXIMUM_LINKS_PER_SESSION];
+	int64_t                        initial_sync_req;
+	int64_t                        modified_init_sync_req;
+	bool                           sync_link_sof_skip;
+	uint64_t                       sync_frame_id;
+	struct cam_req_mgr_sof_time    sof_time;
+	bool                           is_sync_req;
+};
+
 /**
  * struct cam_req_mgr_core_link
  * -  Link Properties
@@ -357,11 +397,7 @@ struct cam_req_mgr_connected_device {
  * @parent               : pvt data - link's parent is session
  * @lock                 : mutex lock to guard link data operations
  * @link_state_spin_lock : spin lock to protect link state variable
- * @sync_link            : array of pointer to the sync link for synchronization
- * @num_sync_link        : total number of sync links
- * @sync_link_sof_skip   : flag determines if a pkt is not available for a given
- *                         frame in a particular link skip corresponding
- *                         frame in sync link as well.
+ * @sync_data            : sync data datails needed in sync mode
  * @open_req_cnt         : Counter to keep track of open requests that are yet
  *                         to be serviced in the kernel.
  * @last_flush_id        : Last request to flush
@@ -370,29 +406,20 @@ struct cam_req_mgr_connected_device {
  *                         is assigned as master
  * @initial_skip         : Flag to determine if initial req need to skip for
  *                         diff pd
- * @is_sync_req          : flag used for deciding sync and non-sync
  * @in_msync_mode        : Flag to determine if a link is in master-slave mode
- * @initial_sync_req     : The initial req which is required to sync with the
- *                         other link
- * @modified_init_sync_req : Modified initial req which is required to sync
- *                          with the other link
  * @retry_cnt            : Counter that tracks number of attempts to apply
  *                         the same req
  * @is_shutdown          : Flag to indicate if link needs to be disconnected
  *                         as part of shutdown.
- * @sof_timestamp_value  : SOF timestamp value
- * @prev_sof_timestamp   : Previous SOF timestamp value
  * @dual_trigger         : Links needs to wait for two triggers prior to
  *                         applying the settings
  * @trigger_cnt          : trigger count value per device initiating the trigger
  * @eof_event_cnt        : Atomic variable to track the number of EOF requests
  * @skip_init_frame      : skip initial frames crm_wd_timer validation in the
  *                         case of long exposure use case
- * @last_sof_trigger_jiffies : Record the jiffies of last sof trigger jiffies
  * @wq_congestion        : Indicates if WQ congestion is detected or not
  * @activate_seq         : sequence in which link is activated
  * @frame_id             : current frame id
- * @sync_frame_id        : current frame id of sync link
  * @bubble_skip          : req to skip on bubble
  * @num_isp_dev          : number of isp dev in a link
  * @retry_threshold      : number of times to retry apply on increased threshold
@@ -413,38 +440,27 @@ struct cam_req_mgr_core_link {
 	void                                *parent;
 	struct mutex                         lock;
 	spinlock_t                           link_state_spin_lock;
-	struct cam_req_mgr_core_link        *sync_link[
-						MAXIMUM_LINKS_PER_SESSION];
-	int32_t                              num_sync_link;
-	bool                                 sync_link_sof_skip;
+	struct cam_req_mgr_sync_data         sync_data;
 	uint32_t                             open_req_cnt;
 	uint32_t                             last_flush_id;
 	atomic_t                             is_used;
 	bool                                 is_master;
 	uint32_t                             initial_skip;
-	bool                                 is_sync_req;
 	bool                                 in_msync_mode;
-	int64_t                              initial_sync_req;
-	int64_t                              modified_init_sync_req;
 	uint32_t                             retry_cnt;
 	bool                                 is_shutdown;
-	uint64_t                             sof_boottime;
-	uint64_t                             sof_timestamp;
-	uint64_t                             prev_sof_timestamp;
 	bool                                 dual_trigger;
 	uint32_t trigger_cnt[CAM_REQ_MGR_MAX_TRIGGERS][CAM_TRIGGER_MAX_POINTS];
 	atomic_t                             eof_event_cnt;
 	bool                                 skip_init_frame;
-	uint64_t                             last_sof_trigger_jiffies;
 	bool                                 wq_congestion;
 	int32_t                              activate_seq;
 	uint64_t                             frame_id;
-	uint64_t                             sync_frame_id;
 	int32_t                              bubble_skip;
 	bool                                 skip_sync_apply;
 	uint32_t                             num_isp_dev;
 	uint32_t                             retry_threshold;
-	uint32_t                             fps;
+	int32_t                              fps;
 };
 
 /**

drivers/cam_req_mgr/cam_req_mgr_interface.h

@@ -254,7 +254,7 @@ struct cam_req_mgr_trigger_notify {
 	uint64_t sof_boottime;
 	uint64_t req_id;
 	int32_t  trigger_id;
-	uint32_t fps;
+	int32_t  fps;
 };
 
 /**

include/uapi/camera/media/cam_req_mgr.h

@@ -82,9 +82,13 @@
  * @CAM_REQ_MGR_SYNC_MODE_NO_SYNC: Req mgr will apply non-sync mode for this
  * request.
  * @CAM_REQ_MGR_SYNC_MODE_SYNC: Req mgr will apply sync mode for this request.
+ * @CAM_REQ_MGR_SYNC_MODE_TRANSITION_SYNC: Req mgr will apply transition sync
+ * mode for this request. Only first few request before sync mode will apply
+ * transition sync mode.
  */
-#define CAM_REQ_MGR_SYNC_MODE_NO_SYNC   0
-#define CAM_REQ_MGR_SYNC_MODE_SYNC      1
+#define CAM_REQ_MGR_SYNC_MODE_NO_SYNC            0
+#define CAM_REQ_MGR_SYNC_MODE_SYNC               1
+#define CAM_REQ_MGR_SYNC_MODE_TRANSITION_SYNC    2
 
 /**
  * struct cam_req_mgr_event_data