A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-10 06:09:23 -04:00
Code Issues Projects Releases Packages Wiki Activity

Revert "msm: camera: req_mgr: Re-design CRM to support multi links in sync mode"

Browse source 
This reverts commit 65a86de979.

CRs-Fixed: 2898158
Change-Id: I40efe11908603fddc8aec025edca2536ada46e99
Signed-off-by: Ayush Kumar <ayushkr@codeaurora.org>
This commit is contained in:
Ayush Kumar 2020-12-22 13:59:52 +05:30
commit bb921ff616
12 changed files with 656 additions and 1545 deletions
Download patch file Download diff file Expand all files Collapse all files

29
drivers/cam_core/cam_context.c
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
*/
#include <linux/slab.h>
@ -182,33 +182,6 @@ int cam_context_handle_crm_apply_req(struct cam_context *ctx,
return rc;
}
int cam_context_handle_crm_state_change(struct cam_context *ctx,
struct cam_req_mgr_request_change_state *state_info)
{
int rc;
if (!ctx->state_machine) {
CAM_ERR(CAM_CORE, "Context is not ready");
return -EINVAL;
}
if (!state_info) {
CAM_ERR(CAM_CORE, "Invalid change state payload");
return -EINVAL;
}
if (ctx->state_machine[ctx->state].crm_ops.change_state) {
rc = ctx->state_machine[ctx->state].crm_ops.change_state(ctx,
state_info);
} else {
CAM_ERR(CAM_CORE, "No crm change state req in dev %d, state %d",
ctx->dev_hdl, ctx->state);
rc = -EPROTO;
}
return rc;
}
int cam_context_handle_crm_notify_frame_skip(
struct cam_context *ctx,
struct cam_req_mgr_apply_request *apply)

17
drivers/cam_core/cam_context.h
View file

@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
*/
#ifndef _CAM_CONTEXT_H_
@ -127,7 +127,6 @@ struct cam_ctx_ioctl_ops {
* @flush_req: Flush request to remove request ids
* @process_evt: Handle event notification from CRM.(optional)
* @dump_req: Dump information for the issue request
* @change_state: Change sub-state of hw context layer to bubble
*
*/
struct cam_ctx_crm_ops {
@ -147,8 +146,6 @@ struct cam_ctx_crm_ops {
struct cam_req_mgr_link_evt_data *evt_data);
int (*dump_req)(struct cam_context *ctx,
struct cam_req_mgr_dump_info *dump);
int (*change_state)(struct cam_context *ctx,
struct cam_req_mgr_request_change_state *change_state);
};
@ -313,18 +310,6 @@ int cam_context_handle_crm_unlink(struct cam_context *ctx,
int cam_context_handle_crm_apply_req(struct cam_context *ctx,
struct cam_req_mgr_apply_request *apply);
/**
* cam_context_handle_crm_state_change()
*
* @brief: Handle state change request
*
* @ctx: Object pointer for cam_context
* @state_info: State change request command payload
*
*/
int cam_context_handle_crm_state_change(struct cam_context *ctx,
struct cam_req_mgr_request_change_state *state_info);
/**
* cam_context_handle_crm_notify_frame_skip()
*

21
drivers/cam_core/cam_node.c
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2017-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
*/
#include <linux/debugfs.h>
@ -619,24 +619,6 @@ static int __cam_node_crm_flush_req(struct cam_req_mgr_flush_request *flush)
return cam_context_handle_crm_flush_req(ctx, flush);
}
static int __cam_node_crm_state_change_req(
struct cam_req_mgr_request_change_state *state_info)
{
struct cam_context *ctx = NULL;
if (!state_info)
return -EINVAL;
ctx = (struct cam_context *) cam_get_device_priv(state_info->dev_hdl);
if (!ctx) {
CAM_ERR(CAM_CORE, "Can not get context for handle %d",
state_info->dev_hdl);
return -EINVAL;
}
return cam_context_handle_crm_state_change(ctx, state_info);
}
static int __cam_node_crm_process_evt(
struct cam_req_mgr_link_evt_data *evt_data)
{
@ -733,7 +715,6 @@ int cam_node_init(struct cam_node *node, struct cam_hw_mgr_intf *hw_mgr_intf,
node->crm_node_intf.dump_req = __cam_node_crm_dump_req;
node->crm_node_intf.notify_frame_skip =
__cam_node_crm_notify_frame_skip;
node->crm_node_intf.change_state = __cam_node_crm_state_change_req;
mutex_init(&node->list_mutex);
INIT_LIST_HEAD(&node->free_ctx_list);

1
drivers/cam_cust/cam_custom_context.c
View file

@ -549,7 +549,6 @@ static int __cam_custom_ctx_get_dev_info_in_acquired(struct cam_context *ctx,
dev_info->dev_id = CAM_REQ_MGR_DEVICE_CUSTOM_HW;
dev_info->p_delay = 1;
dev_info->trigger = CAM_TRIGGER_POINT_SOF;
dev_info->sof_ts_cb = NULL;
return 0;
}

202
drivers/cam_isp/cam_isp_context.c
View file

@ -743,8 +743,8 @@ static void __cam_isp_ctx_send_sof_timestamp(
req_msg.u.frame_msg.frame_id_meta = ctx_isp->frame_id_meta;
CAM_DBG(CAM_ISP,
"link hdl 0x%x request id:%lld frame number:%lld SOF time stamp:%lld status:%u",
ctx_isp->base->link_hdl, request_id, ctx_isp->frame_id,
"request id:%lld frame number:%lld SOF time stamp:0x%llx status:%u",
request_id, ctx_isp->frame_id,
ctx_isp->sof_timestamp_val, sof_event_status);
if (cam_req_mgr_notify_message(&req_msg,
@ -1700,7 +1700,6 @@ static int __cam_isp_ctx_reg_upd_in_applied_state(
}
req = list_first_entry(&ctx->wait_req_list,
struct cam_ctx_request, list);
list_del_init(&req->list);
req_isp = (struct cam_isp_ctx_req *) req->req_priv;
@ -1709,9 +1708,8 @@ static int __cam_isp_ctx_reg_upd_in_applied_state(
ctx_isp->active_req_cnt++;
request_id = req->request_id;
CAM_DBG(CAM_REQ,
"move request %lld to active list(cnt = %d), ctx %u link %x",
req->request_id, ctx_isp->active_req_cnt,
ctx->ctx_id, ctx->link_hdl);
"move request %lld to active list(cnt = %d), ctx %u",
req->request_id, ctx_isp->active_req_cnt, ctx->ctx_id);
__cam_isp_ctx_update_event_record(ctx_isp,
CAM_ISP_CTX_EVENT_RUP, req);
} else {
@ -1853,7 +1851,6 @@ notify_only:
notify.trigger = CAM_TRIGGER_POINT_SOF;
notify.req_id = ctx_isp->req_info.last_bufdone_req_id;
notify.sof_timestamp_val = ctx_isp->sof_timestamp_val;
notify.sof_boottime = ctx_isp->boot_timestamp;
notify.trigger_id = ctx_isp->trigger_id;
ctx->ctx_crm_intf->notify_trigger(&notify);
@ -1973,9 +1970,8 @@ static int __cam_isp_ctx_sof_in_activated_state(
__cam_isp_ctx_update_state_monitor_array(ctx_isp,
CAM_ISP_STATE_CHANGE_TRIGGER_SOF, request_id);
CAM_DBG(CAM_ISP, "frame id: %lld time stamp:0x%llx, ctx %u link %x",
ctx_isp->frame_id, ctx_isp->sof_timestamp_val,
ctx->ctx_id, ctx->link_hdl);
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);
return rc;
}
@ -2020,7 +2016,6 @@ end:
static int __cam_isp_ctx_epoch_in_applied(struct cam_isp_context *ctx_isp,
void *evt_data)
{
bool rc = false;
uint64_t request_id = 0;
uint32_t sof_event_status = CAM_REQ_MGR_SOF_EVENT_SUCCESS;
struct cam_req_mgr_trigger_notify notify;
@ -2059,9 +2054,8 @@ 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;
CAM_INFO_RATE_LIMIT(CAM_ISP, "ctx:%d link %x Report Bubble flag %d req id:%lld",
ctx->ctx_id, ctx->link_hdl,
req_isp->bubble_report, req->request_id);
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 &&
ctx->ctx_crm_intf->notify_err) {
struct cam_req_mgr_error_notify notify;
@ -2075,25 +2069,12 @@ static int __cam_isp_ctx_epoch_in_applied(struct cam_isp_context *ctx_isp,
notify.trigger = CAM_TRIGGER_POINT_SOF;
notify.frame_id = ctx_isp->frame_id;
notify.sof_timestamp_val = ctx_isp->sof_timestamp_val;
notify.sof_boottime_val = ctx_isp->boot_timestamp;
notify.need_recovery = true;
CAM_WARN_RATE_LIMIT(CAM_ISP,
"Notify CRM about Bubble req %lld frame %lld, ctx %u",
req->request_id, ctx_isp->frame_id, ctx->ctx_id);
trace_cam_log_event("Bubble", "Rcvd epoch in applied state",
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;
CAM_DBG(CAM_ISP, "Disable bubble for ctx %d link %d",
ctx->ctx_id, ctx->link_hdl);
return 0;
}
ctx->ctx_crm_intf->notify_err(&notify);
atomic_set(&ctx_isp->process_bubble, 1);
} else {
req_isp->bubble_report = 0;
@ -2268,7 +2249,6 @@ static int __cam_isp_ctx_buf_done_in_bubble(
static int __cam_isp_ctx_epoch_in_bubble_applied(
struct cam_isp_context *ctx_isp, void *evt_data)
{
int rc = 0;
uint64_t request_id = 0;
struct cam_req_mgr_trigger_notify notify;
struct cam_ctx_request *req;
@ -2326,17 +2306,10 @@ static int __cam_isp_ctx_epoch_in_bubble_applied(
notify.trigger = CAM_TRIGGER_POINT_SOF;
notify.frame_id = ctx_isp->frame_id;
notify.sof_timestamp_val = ctx_isp->sof_timestamp_val;
notify.sof_boottime_val = ctx_isp->boot_timestamp;
notify.need_recovery = true;
CAM_WARN_RATE_LIMIT(CAM_REQ,
"Notify CRM about Bubble req_id %llu frame %lld, ctx %u",
req->request_id, ctx_isp->frame_id, ctx->ctx_id);
rc = ctx->ctx_crm_intf->notify_err(&notify);
if (rc) {
req_isp->bubble_detected = false;
req_isp->reapply = false;
return 0;
}
ctx->ctx_crm_intf->notify_err(&notify);
atomic_set(&ctx_isp->process_bubble, 1);
} else {
req_isp->bubble_report = 0;
@ -3200,10 +3173,10 @@ static int __cam_isp_ctx_apply_req_in_activated_state(
goto end;
}
CAM_DBG(CAM_REQ, "Apply request %lld in Substate[%s] ctx %u link %x",
CAM_DBG(CAM_REQ, "Apply request %lld in Substate[%s] ctx %u",
req->request_id,
__cam_isp_ctx_substate_val_to_type(ctx_isp->substate_activated),
ctx->ctx_id, ctx->link_hdl);
ctx->ctx_id);
req_isp = (struct cam_isp_ctx_req *) req->req_priv;
if (ctx_isp->active_req_cnt >= 2) {
@ -3286,81 +3259,6 @@ end:
return rc;
}
static int __cam_isp_ctx_change_substate(
struct cam_context *ctx,
struct cam_req_mgr_request_change_state *state_info)
{
int rc = 0;
uint64_t request_id = 0;
struct cam_ctx_request *req = NULL;
struct cam_ctx_request *req_temp = NULL;
struct cam_ctx_request *bubble_req = NULL;
struct cam_isp_ctx_req *req_isp = NULL;
struct cam_isp_context *ctx_isp =
(struct cam_isp_context *) ctx->ctx_priv;
if (!list_empty(&ctx->wait_req_list)) {
req = list_first_entry(&ctx->wait_req_list,
struct cam_ctx_request,
list);
if (req->request_id == state_info->req_id) {
req_isp = (struct cam_isp_ctx_req *)req->req_priv;
req_isp->bubble_detected = true;
req_isp->reapply = true;
bubble_req = req;
list_del_init(&req->list);
list_add_tail(&req->list, &ctx->active_req_list);
goto end;
}
} else {
CAM_ERR(CAM_ISP, "Ctx:%d No wait request", ctx->ctx_id);
}
if (!bubble_req) {
list_for_each_entry_safe(req, req_temp,
&ctx->active_req_list, list) {
if (req->request_id == state_info->req_id) {
req_isp =
(struct cam_isp_ctx_req *)req->req_priv;
req_isp->bubble_detected = true;
req_isp->reapply = true;
bubble_req = req;
break;
}
}
}
if (!bubble_req) {
CAM_ERR(CAM_ISP, "Req %lld not in active list ctx : %d",
state_info->req_id,
ctx->ctx_id);
goto done;
}
end:
if (req_isp->bubble_report)
atomic_set(&ctx_isp->process_bubble, 1);
if ((req->request_id > ctx_isp->reported_req_id)
&& !req_isp->bubble_report) {
request_id = req->request_id;
ctx_isp->reported_req_id = request_id;
}
__cam_isp_ctx_send_sof_timestamp(ctx_isp, request_id,
CAM_REQ_MGR_SOF_EVENT_ERROR);
ctx_isp->substate_activated = CAM_ISP_CTX_ACTIVATED_BUBBLE;
CAM_DBG(CAM_ISP, "next Substate[%s] ctx : %d",
__cam_isp_ctx_substate_val_to_type(
ctx_isp->substate_activated), ctx->ctx_id);
done:
return rc;
}
static int __cam_isp_ctx_apply_req_in_sof(
struct cam_context *ctx, struct cam_req_mgr_apply_request *apply)
{
@ -3421,8 +3319,8 @@ static int __cam_isp_ctx_apply_req_in_bubble(
ctx_isp->substate_activated));
rc = __cam_isp_ctx_apply_req_in_activated_state(ctx, apply,
CAM_ISP_CTX_ACTIVATED_BUBBLE_APPLIED);
CAM_DBG(CAM_ISP, "ctx %d link %x new Substate[%s]",
ctx->ctx_id, ctx->link_hdl, __cam_isp_ctx_substate_val_to_type(
CAM_DBG(CAM_ISP, "new Substate[%s]",
__cam_isp_ctx_substate_val_to_type(
ctx_isp->substate_activated));
if (rc)
@ -3786,7 +3684,6 @@ static int __cam_isp_ctx_flush_req_in_top_state(
flush_req);
ctx_isp->active_req_cnt = 0;
spin_unlock_bh(&ctx->lock);
reset_args.ctxt_to_hw_map = ctx_isp->hw_ctx;
@ -3834,16 +3731,13 @@ static struct cam_ctx_ops
.ioctl_ops = {},
.crm_ops = {
.apply_req = __cam_isp_ctx_apply_req_in_sof,
.change_state = __cam_isp_ctx_change_substate,
},
.irq_ops = NULL,
},
/* APPLIED */
{
.ioctl_ops = {},
.crm_ops = {
.change_state = __cam_isp_ctx_change_substate,
},
.crm_ops = {},
.irq_ops = NULL,
},
/* EPOCH */
@ -3851,7 +3745,6 @@ static struct cam_ctx_ops
.ioctl_ops = {},
.crm_ops = {
.apply_req = __cam_isp_ctx_apply_req_in_epoch,
.change_state = __cam_isp_ctx_change_substate,
},
.irq_ops = NULL,
},
@ -3860,16 +3753,13 @@ static struct cam_ctx_ops
.ioctl_ops = {},
.crm_ops = {
.apply_req = __cam_isp_ctx_apply_req_in_bubble,
.change_state = __cam_isp_ctx_change_substate,
},
.irq_ops = NULL,
},
/* Bubble Applied */
{
.ioctl_ops = {},
.crm_ops = {
.change_state = __cam_isp_ctx_change_substate,
},
.crm_ops = {},
.irq_ops = NULL,
},
/* HW ERROR */
@ -5462,33 +5352,6 @@ static int __cam_isp_ctx_unlink_in_acquired(struct cam_context *ctx,
return rc;
}
static int __cam_isp_ctx_get_isp_info(int32_t dev_hdl, void *data)
{
int rc = 0;
struct cam_context *ctx;
struct cam_req_mgr_dev_info *isp_dev = data;
struct cam_isp_context *isp_ctx = NULL;
ctx = (struct cam_context *)cam_get_device_priv(dev_hdl);
isp_ctx = (struct cam_isp_context *)ctx->ctx_priv;
isp_dev->state = isp_ctx->substate_activated;
isp_dev->timestamp = isp_ctx->sof_timestamp_val;
isp_dev->boot_time = isp_ctx->boot_timestamp;
isp_dev->frame_id = isp_ctx->frame_id;
if ((isp_ctx->substate_activated ==
CAM_ISP_CTX_ACTIVATED_APPLIED) ||
(isp_ctx->substate_activated ==
CAM_ISP_CTX_ACTIVATED_BUBBLE_APPLIED))
isp_dev->is_applied = true;
else
isp_dev->is_applied = false;
return rc;
}
static int __cam_isp_ctx_get_dev_info_in_acquired(struct cam_context *ctx,
struct cam_req_mgr_device_info *dev_info)
{
@ -5500,7 +5363,6 @@ static int __cam_isp_ctx_get_dev_info_in_acquired(struct cam_context *ctx,
dev_info->p_delay = 1;
dev_info->trigger = CAM_TRIGGER_POINT_SOF;
dev_info->trigger_on = true;
dev_info->sof_ts_cb = &__cam_isp_ctx_get_isp_info;
return rc;
}
@ -5558,8 +5420,6 @@ static int __cam_isp_ctx_start_dev_in_ready(struct cam_context *ctx,
atomic_set(&ctx_isp->process_bubble, 0);
atomic_set(&ctx_isp->rxd_epoch, 0);
ctx_isp->frame_id = 0;
ctx_isp->sof_timestamp_val = 0;
ctx_isp->boot_timestamp = 0;
ctx_isp->active_req_cnt = 0;
ctx_isp->reported_req_id = 0;
ctx_isp->bubble_frame_cnt = 0;
@ -5909,33 +5769,6 @@ static int __cam_isp_ctx_unlink_in_activated(struct cam_context *ctx,
return rc;
}
static int __cam_isp_ctx_change_state_req(struct cam_context *ctx,
struct cam_req_mgr_request_change_state *state_info)
{
int rc = 0;
struct cam_ctx_ops *ctx_ops = NULL;
struct cam_isp_context *ctx_isp =
(struct cam_isp_context *) ctx->ctx_priv;
CAM_DBG(CAM_ISP, "Enter: changes state ctx id %d link 0x%x",
ctx->ctx_id, ctx->link_hdl);
ctx_ops = &ctx_isp->substate_machine[ctx_isp->substate_activated];
if (ctx_ops->crm_ops.change_state) {
rc = ctx_ops->crm_ops.change_state(ctx, state_info);
} else {
CAM_WARN_RATE_LIMIT(CAM_ISP,
"No handle function in activated Substate[%s]",
__cam_isp_ctx_substate_val_to_type(
ctx_isp->substate_activated));
rc = -EFAULT;
}
if (rc)
CAM_WARN_RATE_LIMIT(CAM_ISP,
"changes state failed");
return rc;
}
static int __cam_isp_ctx_apply_req(struct cam_context *ctx,
struct cam_req_mgr_apply_request *apply)
{
@ -6088,7 +5921,6 @@ static struct cam_ctx_ops
.flush_req = __cam_isp_ctx_flush_req_in_top_state,
.process_evt = __cam_isp_ctx_process_evt,
.dump_req = __cam_isp_ctx_dump_in_top_state,
.change_state = __cam_isp_ctx_change_state_req,
},
.irq_ops = __cam_isp_ctx_handle_irq_in_activated,
.pagefault_ops = cam_isp_context_dump_requests,
@ -6313,8 +6145,6 @@ int cam_isp_context_init(struct cam_isp_context *ctx,
ctx->base = ctx_base;
ctx->frame_id = 0;
ctx->sof_timestamp_val = 0;
ctx->boot_timestamp = 0;
ctx->custom_enabled = false;
ctx->use_frame_header_ts = false;
ctx->active_req_cnt = 0;

10
drivers/cam_isp/isp_hw_mgr/include/cam_isp_hw_mgr_intf.h
View file

@ -261,17 +261,15 @@ enum cam_isp_ctx_type {
* @ctx_type: RDI_ONLY, PIX and RDI, or FS2
* @packet_op_code: Packet opcode
* @last_cdm_done: Last cdm done request
* @cam_isp_hw_sof_event_data sof event timestamp
*/
struct cam_isp_hw_cmd_args {
uint32_t cmd_type;
void *cmd_data;
union {
uint32_t sof_irq_enable;
uint32_t ctx_type;
uint32_t packet_op_code;
uint64_t last_cdm_done;
struct cam_isp_hw_sof_event_data sof_done_event_data;
uint32_t sof_irq_enable;
uint32_t ctx_type;
uint32_t packet_op_code;
uint64_t last_cdm_done;
} u;
};

1796
drivers/cam_req_mgr/cam_req_mgr_core.c
View file

File diff suppressed because it is too large Load diff

55
drivers/cam_req_mgr/cam_req_mgr_core.h
View file

@ -263,8 +263,7 @@ struct cam_req_mgr_req_tbl {
* - members updated due to external events
* @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
* @sync_mode : 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;
};
@ -357,7 +355,7 @@ struct cam_req_mgr_connected_device {
* @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
* @num_sync_links : num of links sync associated with this 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.
@ -367,14 +365,11 @@ struct cam_req_mgr_connected_device {
* @is_used : 1 if link is in use else 0
* @is_master : Based on pd among links, the link with the highest pd
* 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
* @initial_skip : Flag to determine if slave has started streaming in
* master-slave 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
@ -389,10 +384,6 @@ struct cam_req_mgr_connected_device {
* 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
*/
struct cam_req_mgr_core_link {
int32_t link_hdl;
@ -408,22 +399,19 @@ 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;
struct cam_req_mgr_core_link
*sync_link[MAXIMUM_LINKS_PER_SESSION - 1];
int32_t num_sync_links;
bool sync_link_sof_skip;
int32_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 initial_skip;
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;
@ -432,11 +420,6 @@ struct cam_req_mgr_core_link {
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;
};
/**
@ -470,33 +453,11 @@ struct cam_req_mgr_core_session {
* @session_head : list head holding sessions
* @crm_lock : mutex lock to protect session creation & destruction
* @recovery_on_apply_fail : Recovery on apply failure using debugfs.
* @bitmap : bitmap to store index of link
* @max_delay : max pipeline delay in a session
*/
struct cam_req_mgr_core_device {
struct list_head session_head;
struct mutex crm_lock;
bool recovery_on_apply_fail;
DECLARE_BITMAP(bitmap, MAXIMUM_LINKS_PER_SESSION);
uint32_t max_delay;
};
/**
* struct cam_req_mgr_dump_link_data
* - Dump data
* @m_link : master link handle
* @s_link : slave link handle
* @m_req_id : master req id
* @s_req_id : slave req id
* @dev_info : current timing data of slave link
*
*/
struct cam_req_mgr_dump_link_data {
struct cam_req_mgr_core_link *m_link;
struct cam_req_mgr_core_link *s_link;
uint64_t m_req_id;
uint64_t s_req_id;
struct cam_req_mgr_dev_info dev_data;
};
/**

66
drivers/cam_req_mgr/cam_req_mgr_interface.h
View file

@ -22,7 +22,6 @@ struct cam_req_mgr_apply_request;
struct cam_req_mgr_flush_request;
struct cam_req_mgr_link_evt_data;
struct cam_req_mgr_dump_info;
struct cam_req_mgr_request_change_state;
/* Request Manager -- camera device driver interface */
/**
@ -34,9 +33,8 @@ struct cam_req_mgr_request_change_state;
* userspace
* @cam_req_mgr_notify_timer : start the timer
*/
typedef int (*cam_req_mgr_notify_trigger)(
struct cam_req_mgr_trigger_notify *);
typedef bool (*cam_req_mgr_notify_err)(struct cam_req_mgr_error_notify *);
typedef int (*cam_req_mgr_notify_trigger)(struct cam_req_mgr_trigger_notify *);
typedef int (*cam_req_mgr_notify_err)(struct cam_req_mgr_error_notify *);
typedef int (*cam_req_mgr_add_req)(struct cam_req_mgr_add_request *);
typedef int (*cam_req_mgr_notify_timer)(struct cam_req_mgr_timer_notify *);
typedef int (*cam_req_mgr_notify_stop)(struct cam_req_mgr_notify_stop *);
@ -50,9 +48,8 @@ typedef int (*cam_req_mgr_notify_stop)(struct cam_req_mgr_notify_stop *);
* @cam_req_mgr_notify_frame_skip: CRM asks device to apply setting for
* frame skip
* @cam_req_mgr_flush_req : Flush or cancel request
* @cam_req_mgr_process_evt : generic events
* cam_req_mgr_process_evt : generic events
* @cam_req_mgr_dump_req : dump request
* @cam_req_mgr_change_state : CRM asks device to change its state
*/
typedef int (*cam_req_mgr_get_dev_info) (struct cam_req_mgr_device_info *);
typedef int (*cam_req_mgr_link_setup)(struct cam_req_mgr_core_dev_link_setup *);
@ -62,8 +59,6 @@ typedef int (*cam_req_mgr_notify_frame_skip)(
typedef int (*cam_req_mgr_flush_req)(struct cam_req_mgr_flush_request *);
typedef int (*cam_req_mgr_process_evt)(struct cam_req_mgr_link_evt_data *);
typedef int (*cam_req_mgr_dump_req)(struct cam_req_mgr_dump_info *);
typedef int (*cam_req_mgr_change_state)(
struct cam_req_mgr_request_change_state *);
/**
* @brief : cam_req_mgr_crm_cb - func table
@ -92,17 +87,15 @@ struct cam_req_mgr_crm_cb {
* @flush_req : payload to flush request
* @process_evt : payload to generic event
* @dump_req : payload to dump request
* @change_state : payload to change state
*/
struct cam_req_mgr_kmd_ops {
cam_req_mgr_get_dev_info get_dev_info;
cam_req_mgr_link_setup link_setup;
cam_req_mgr_apply_req apply_req;
cam_req_mgr_get_dev_info get_dev_info;
cam_req_mgr_link_setup link_setup;
cam_req_mgr_apply_req apply_req;
cam_req_mgr_notify_frame_skip notify_frame_skip;
cam_req_mgr_flush_req flush_req;
cam_req_mgr_process_evt process_evt;
cam_req_mgr_dump_req dump_req;
cam_req_mgr_change_state change_state;
cam_req_mgr_flush_req flush_req;
cam_req_mgr_process_evt process_evt;
cam_req_mgr_dump_req dump_req;
};
/**
@ -223,7 +216,6 @@ enum cam_req_mgr_link_evt_type {
* @trigger : trigger point of this notification, CRM will send apply
* only to the devices which subscribe to this point.
* @sof_timestamp_val: Captured time stamp value at sof hw event
* @sof_boottime : Captured boot time stamp value at sof hw event
* @req_id : req id which returned buf_done
* @trigger_id: ID to differentiate between the trigger devices
*/
@ -233,7 +225,6 @@ struct cam_req_mgr_trigger_notify {
int64_t frame_id;
uint32_t trigger;
uint64_t sof_timestamp_val;
uint64_t sof_boottime;
uint64_t req_id;
int32_t trigger_id;
};
@ -258,8 +249,6 @@ struct cam_req_mgr_timer_notify {
* @frame_id : frame id for internal tracking
* @trigger : trigger point of this notification, CRM will send apply
* @sof_timestamp_val : Captured time stamp value at sof hw event
* @sof_boottime_val : Captured boottime stamp value at sof hw event
* @need_recovery : flag to check if recovery is needed
* @error : what error device hit while processing this req
*/
struct cam_req_mgr_error_notify {
@ -269,8 +258,6 @@ struct cam_req_mgr_error_notify {
int64_t frame_id;
uint32_t trigger;
uint64_t sof_timestamp_val;
uint64_t sof_boottime_val;
bool need_recovery;
enum cam_req_mgr_device_error error;
};
@ -315,7 +302,6 @@ struct cam_req_mgr_notify_stop {
* @p_delay : delay between time settings applied and take effect
* @trigger : Trigger point for the client
* @trigger_on : This device provides trigger
* @sof_ts_cb : callback to real time drivers
*/
struct cam_req_mgr_device_info {
int32_t dev_hdl;
@ -324,7 +310,6 @@ struct cam_req_mgr_device_info {
enum cam_pipeline_delay p_delay;
uint32_t trigger;
bool trigger_on;
int32_t (*sof_ts_cb)(int32_t dev_hdl, void *data);
};
/**
@ -423,37 +408,4 @@ struct cam_req_mgr_dump_info {
int32_t link_hdl;
int32_t dev_hdl;
};
/**
* struct cam_req_mgr_dev_info
* @link_hdl : link identifier
* @state : Current substate for the activated state.
* @timestamp : time stamp for the sof event
* @boot_time : boot time stamp for the sof event
* @frame_id : frame id
* @is_applied : if ISP is in applied state
*
*/
struct cam_req_mgr_dev_info {
int32_t link_hdl;
uint32_t state;
uint64_t timestamp;
uint64_t boot_time;
uint64_t frame_id;
bool is_applied;
};
/**
* struct cam_req_mgr_request_change_state
* @link_hdl : link identifier
* @dev_hdl : device handle or identifier
* @req_id : request id
*
*/
struct cam_req_mgr_request_change_state {
int32_t link_hdl;
int32_t dev_hdl;
uint64_t req_id;
};
#endif

1
drivers/cam_sensor_module/cam_actuator/cam_actuator_core.c
View file

@ -410,7 +410,6 @@ int32_t cam_actuator_publish_dev_info(struct cam_req_mgr_device_info *info)
strlcpy(info->name, CAM_ACTUATOR_NAME, sizeof(info->name));
info->p_delay = 1;
info->trigger = CAM_TRIGGER_POINT_SOF;
info->sof_ts_cb = NULL;
return 0;
}

2
drivers/cam_sensor_module/cam_flash/cam_flash_core.c
View file

@ -1785,8 +1785,6 @@ int cam_flash_publish_dev_info(struct cam_req_mgr_device_info *info)
strlcpy(info->name, CAM_FLASH_NAME, sizeof(info->name));
info->p_delay = CAM_FLASH_PIPELINE_DELAY;
info->trigger = CAM_TRIGGER_POINT_SOF;
info->sof_ts_cb = NULL;
return 0;
}

1
drivers/cam_sensor_module/cam_sensor/cam_sensor_core.c
View file

@ -1129,7 +1129,6 @@ int cam_sensor_publish_dev_info(struct cam_req_mgr_device_info *info)
else
info->p_delay = 2;
info->trigger = CAM_TRIGGER_POINT_SOF;
info->sof_ts_cb = NULL;
return rc;
}