samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Código Issues Pull requests Ações Pacotes Projetos Versões Wiki Atividade

Merge "msm: camera: common: Improve IFE and CRM Logging" into camera-kernel.lnx.4.0

Ver código fonte
Esse commit está contido em:
Haritha Chintalapati
2020-12-02 19:08:56 -08:00
commit de Gerrit - the friendly Code Review server
pai ce18cf3937 05abdc71b0
commit 56434293e9
3 arquivos alterados com 67 adições e 35 exclusões
Baixar arquivo de patch Baixar arquivo de diferenças Expandir todos os arquivos Colapsar todos os arquivos

55
drivers/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c
Ver arquivo

@@ -742,6 +742,12 @@ static void cam_ife_hw_mgr_dump_all_ctx(void)
struct cam_ife_hw_mgr_ctx *ctx_temp;
mutex_lock(&g_ife_hw_mgr.ctx_mutex);
if (list_empty(&g_ife_hw_mgr.used_ctx_list)) {
CAM_INFO(CAM_ISP, "Currently no ctx in use");
mutex_unlock(&g_ife_hw_mgr.ctx_mutex);
return;
}
list_for_each_entry_safe(ctx, ctx_temp,
&g_ife_hw_mgr.used_ctx_list, list) {
CAM_INFO_RATE_LIMIT(CAM_ISP,
@@ -799,17 +805,15 @@ static void cam_ife_hw_mgr_print_acquire_info(
int hw_idx[CAM_ISP_HW_SPLIT_MAX] = {-1, -1};
int i = 0;
hw_mgr_res = list_first_entry(&hw_mgr_ctx->res_list_ife_csid,
struct cam_isp_hw_mgr_res, list);
if (hw_mgr_ctx->is_offline)
if (!list_empty(&hw_mgr_ctx->res_list_ife_src)) {
hw_mgr_res = list_first_entry(&hw_mgr_ctx->res_list_ife_src,
struct cam_isp_hw_mgr_res, list);
for (i = 0; i < CAM_ISP_HW_SPLIT_MAX; i++) {
hw_res = hw_mgr_res->hw_res[i];
if (hw_res && hw_res->hw_intf)
hw_idx[i] = hw_res->hw_intf->hw_idx;
for (i = 0; i < CAM_ISP_HW_SPLIT_MAX; i++) {
hw_res = hw_mgr_res->hw_res[i];
if (hw_res && hw_res->hw_intf)
hw_idx[i] = hw_res->hw_intf->hw_idx;
}
}
if (acquire_failed)
@@ -824,12 +828,12 @@ static void cam_ife_hw_mgr_print_acquire_info(
return;
fail:
CAM_ERR(CAM_ISP, "Acquire HW failed for ctx:%u", hw_mgr_ctx->ctx_index);
CAM_INFO(CAM_ISP,
"Acquire fail for ctx:%u %s IFE[%d %d] with [%u pix] [%u pd] [%u rdi] ports",
hw_mgr_ctx->ctx_index, (hw_mgr_ctx->is_dual) ? "dual" : "single",
hw_idx[CAM_ISP_HW_SPLIT_LEFT], hw_idx[CAM_ISP_HW_SPLIT_RIGHT],
num_pix_port, num_pd_port, num_rdi_port);
CAM_ERR(CAM_ISP,
"Failed to acquire %s-IFE with [%u pix] [%u pd] [%u rdi] ports for ctx:%u",
(hw_mgr_ctx->is_dual) ? "dual" : "single",
num_pix_port, num_pd_port, num_rdi_port, hw_mgr_ctx->ctx_index);
CAM_INFO(CAM_ISP, "Previously acquired IFEs[%d %d]",
hw_idx[CAM_ISP_HW_SPLIT_LEFT], hw_idx[CAM_ISP_HW_SPLIT_RIGHT]);
list_for_each_entry_safe(hw_mgr_res, hw_mgr_res_temp,
&hw_mgr_ctx->res_list_ife_src, list) {
@@ -1706,6 +1710,7 @@ static int cam_ife_hw_mgr_acquire_csid_hw(
return -EINVAL;
}
CAM_DBG(CAM_ISP, "Acquire CSID HW lower_idx: %d", is_start_lower_idx);
if (is_start_lower_idx) {
for (i = 0; i < CAM_IFE_CSID_HW_NUM_MAX; i++) {
if (!ife_hw_mgr->csid_devices[i])
@@ -1767,6 +1772,7 @@ static int cam_ife_mgr_acquire_cid_res(
csid_acquire.res_type = CAM_ISP_RESOURCE_CID;
csid_acquire.in_port = in_port;
csid_acquire.res_id = path_res_id;
csid_acquire.node_res = NULL;
if (ife_ctx->is_rdi_only_context)
csid_acquire.can_use_lite = true;
@@ -1840,8 +1846,12 @@ static int cam_ife_mgr_acquire_cid_res(
}
}
/* Acquire right if not already acquired */
/* For dual IFE cases, master will be lower idx */
/* Acquire Left if not already acquired */
/* For dual IFE cases, start acquiring the lower idx first */
CAM_DBG(CAM_ISP, "acquire new rsrc fe: %d usage_type %d dsp %d rsrc %p",
ife_ctx->is_fe_enabled, in_port->usage_type,
ife_ctx->dsp_enabled, csid_acquire.node_res);
if (ife_ctx->is_fe_enabled ||
ife_ctx->dsp_enabled)
rc = cam_ife_hw_mgr_acquire_csid_hw(ife_hw_mgr,
@@ -1851,7 +1861,8 @@ static int cam_ife_mgr_acquire_cid_res(
&csid_acquire, false);
if (rc || !csid_acquire.node_res) {
CAM_ERR(CAM_ISP, "No %d paths available", path_res_id);
CAM_ERR(CAM_ISP, "No %d paths available rc %d rsrc %p",
path_res_id, rc, csid_acquire.node_res);
goto put_res;
}
@@ -2718,6 +2729,7 @@ static int cam_ife_mgr_acquire_hw_for_ctx(
is_dual_isp = in_port->usage_type;
ife_ctx->dsp_enabled = (bool)in_port->dsp_mode;
ife_ctx->is_dual = (bool)in_port->usage_type;
/* get root node resource */
rc = cam_ife_hw_mgr_acquire_res_root(ife_ctx, in_port);
@@ -3132,6 +3144,7 @@ static int cam_ife_mgr_acquire_hw(void *hw_mgr_priv, void *acquire_hw_args)
CAM_ERR(CAM_ISP, "Failed in parsing: %d", rc);
goto free_mem;
}
CAM_DBG(CAM_ISP, "in_res_type %x", in_port->res_type);
cam_ife_hw_mgr_preprocess_port(ife_ctx, &in_port[i]);
total_pix_port += in_port[i].ipp_count +
@@ -3149,7 +3162,6 @@ static int cam_ife_mgr_acquire_hw(void *hw_mgr_priv, void *acquire_hw_args)
/* acquire HW resources */
for (i = 0; i < acquire_hw_info->num_inputs; i++) {
CAM_DBG(CAM_ISP, "in_res_type %x", in_port[i].res_type);
if ((in_port[i].cust_node) && (!ife_ctx->custom_enabled)) {
@@ -3185,8 +3197,11 @@ static int cam_ife_mgr_acquire_hw(void *hw_mgr_priv, void *acquire_hw_args)
if (rc) {
cam_ife_hw_mgr_print_acquire_info(ife_ctx,
total_pix_port, total_pd_port,
total_rdi_port, rc);
(in_port[i].ipp_count +
in_port[i].ife_rd_count +
in_port[i].lcr_count),
in_port[i].ppp_count,
in_port[i].rdi_count, rc);
goto free_res;
}

32
drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_core.c
Ver arquivo

@@ -692,19 +692,20 @@ int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw,
struct cam_csid_soc_private *soc_priv;
CAM_DBG(CAM_ISP,
"CSID:%d res_sel:0x%x Lane type:%d lane_num:%d dt:%d vc:%d",
"CSID:%d res_sel:0x%x Lane type:%d lane_num:%d dt:%d vc:%d cust_node:%u",
csid_hw->hw_intf->hw_idx,
cid_reserv->in_port->res_type,
cid_reserv->in_port->lane_type,
cid_reserv->in_port->lane_num,
cid_reserv->in_port->dt[0],
cid_reserv->in_port->vc[0]);
cid_reserv->in_port->vc[0],
cid_reserv->in_port->cust_node);
soc_priv = (struct cam_csid_soc_private *)
(csid_hw->hw_info->soc_info.soc_private);
if (soc_priv->is_ife_csid_lite && !cid_reserv->can_use_lite) {
CAM_INFO(CAM_ISP, "CSID[%u] not lite context",
CAM_DBG(CAM_ISP, "CSID[%u] not lite context",
csid_hw->hw_intf->hw_idx);
return -EINVAL;
}
@@ -821,8 +822,10 @@ int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw,
if (cid_reserv->in_port->cust_node ==
CAM_ISP_ACQ_CUSTOM_PRIMARY) {
if (csid_hw->hw_intf->hw_idx != 0) {
CAM_ERR(CAM_ISP, "CSID%d not eligible",
csid_hw->hw_intf->hw_idx);
CAM_ERR(CAM_ISP,
"CSID%d not eligible for cust_node: %u",
csid_hw->hw_intf->hw_idx,
cid_reserv->in_port->cust_node);
rc = -EINVAL;
goto end;
}
@@ -831,8 +834,10 @@ int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw,
if (cid_reserv->in_port->cust_node ==
CAM_ISP_ACQ_CUSTOM_SECONDARY) {
if (csid_hw->hw_intf->hw_idx != 1) {
CAM_ERR(CAM_ISP, "CSID%d not eligible",
csid_hw->hw_intf->hw_idx);
CAM_ERR(CAM_ISP,
"CSID%d not eligible for cust_node: %u",
csid_hw->hw_intf->hw_idx,
cid_reserv->in_port->cust_node);
rc = -EINVAL;
goto end;
}
@@ -859,7 +864,6 @@ int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw,
cid_reserv->in_port->lane_type ||
csid_hw->csi2_rx_cfg.lane_num !=
cid_reserv->in_port->lane_num)) {
rc = -EINVAL;
goto end;
}
@@ -873,7 +877,6 @@ int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw,
cid_reserv->in_port->height ||
csid_hw->tpg_cfg.test_pattern !=
cid_reserv->in_port->test_pattern)) {
rc = -EINVAL;
goto end;
}
@@ -953,6 +956,7 @@ int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw,
cid_data = (struct cam_ife_csid_cid_data *)
cid_reserv->node_res->res_priv;
CAM_DBG(CAM_ISP, "Obtained cid:%d", cid_reserv->node_res->res_id);
if (!csid_hw->csi2_reserve_cnt) {
csid_hw->res_type = cid_reserv->in_port->res_type;
@@ -1018,9 +1022,10 @@ int cam_ife_csid_cid_reserve(struct cam_ife_csid_hw *csid_hw,
}
csid_hw->csi2_reserve_cnt++;
CAM_DBG(CAM_ISP, "CSID:%d CID:%d acquired",
CAM_DBG(CAM_ISP, "CSID:%d CID:%d acquired phy_sel %u",
csid_hw->hw_intf->hw_idx,
cid_reserv->node_res->res_id);
cid_reserv->node_res->res_id,
csid_hw->csi2_rx_cfg.phy_sel);
end:
return rc;
@@ -3681,9 +3686,10 @@ int cam_ife_csid_release(void *hw_priv,
memset(&csid_hw->csi2_rx_cfg, 0,
sizeof(struct cam_ife_csid_csi2_rx_cfg));
CAM_DBG(CAM_ISP, "CSID:%d res id :%d cnt:%d reserv cnt:%d",
CAM_DBG(CAM_ISP, "CSID:%d res id :%d cnt:%d reserv cnt:%d res_state:%d",
csid_hw->hw_intf->hw_idx,
res->res_id, cid_data->cnt, csid_hw->csi2_reserve_cnt);
res->res_id, cid_data->cnt, csid_hw->csi2_reserve_cnt,
res->res_state);
break;
case CAM_ISP_RESOURCE_PIX_PATH:

15
drivers/cam_req_mgr/cam_req_mgr_core.c
Ver arquivo

@@ -2048,9 +2048,11 @@ static void __cam_req_mgr_notify_sof_freeze(
static int __cam_req_mgr_process_sof_freeze(void *priv, void *data)
{
struct cam_req_mgr_core_link *link = NULL;
struct cam_req_mgr_req_queue *in_q = NULL;
struct cam_req_mgr_core_session *session = NULL;
struct cam_req_mgr_message msg;
int rc = 0;
int64_t last_applied_req_id = -EINVAL;
if (!data || !priv) {
CAM_ERR(CAM_CRM, "input args NULL %pK %pK", data, priv);
@@ -2064,6 +2066,13 @@ static int __cam_req_mgr_process_sof_freeze(void *priv, void *data)
return -EINVAL;
}
in_q = link->req.in_q;
if (in_q) {
mutex_lock(&link->req.lock);
last_applied_req_id = in_q->slot[in_q->last_applied_idx].req_id;
mutex_unlock(&link->req.lock);
}
spin_lock_bh(&link->link_state_spin_lock);
if ((link->watchdog) && (link->watchdog->pause_timer)) {
CAM_INFO(CAM_CRM, "Watchdog Paused");
@@ -2072,8 +2081,10 @@ static int __cam_req_mgr_process_sof_freeze(void *priv, void *data)
}
spin_unlock_bh(&link->link_state_spin_lock);
CAM_ERR(CAM_CRM, "SOF freeze for session %d link 0x%x",
session->session_hdl, link->link_hdl);
CAM_ERR(CAM_CRM,
"SOF freeze for session: %d link: 0x%x max_pd: %d last_req_id:%d",
session->session_hdl, link->link_hdl, link->max_delay,
last_applied_req_id);
__cam_req_mgr_notify_sof_freeze(link);
memset(&msg, 0, sizeof(msg));