samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

msm: camera: req_mgr: CRM Code refactoring

Browse Source 
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 <ayushkr@codeaurora.org>
This commit is contained in:
Ayush Kumar
2021-06-17 01:27:28 +05:30
parent c6903209f2
commit e8e814eda9
6 changed files with 551 additions and 551 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
drivers/cam_isp/cam_isp_context.c
View File

@@ -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);

9
drivers/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c
View File

@@ -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:

979
drivers/cam_req_mgr/cam_req_mgr_core.c
View File

File diff suppressed because it is too large Load Diff

74
drivers/cam_req_mgr/cam_req_mgr_core.h
View File

@@ -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;
};
/**

2
drivers/cam_req_mgr/cam_req_mgr_interface.h
View File

@@ -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;
};
/**

4
include/uapi/camera/media/cam_req_mgr.h
View File

@@ -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_TRANSITION_SYNC 2
/**
* struct cam_req_mgr_event_data