From bc400e47fab3753c8d36fd7c6ea47db8c4c5743a Mon Sep 17 00:00:00 2001 From: Gaurav Jindal Date: Fri, 12 Feb 2021 16:38:58 +0530 Subject: [PATCH] msm: camera: common: Add common wait and poll interface In current implementation, each driver call wait_for_completion_timeout and readl_poll_timeout with own timeout values. In case of slow environments like presil, lot of hacks are needed to change the timeouts for each driver. It needs multiple code changes and compilations, thus consuming time. This commit implements a common interface to call wait_for_completion_timeout and readl_poll_timeout. Debug variable is also introduced to change the timeout value. This will help to change the timeout without compilations and changes at multiple places. Change-Id: Iba51e0805a49ed325147a12688c2fe6619bb68e6 CRs-Fixed: 2830502 Signed-off-by: Gaurav Jindal --- drivers/cam_cdm/cam_cdm_hw_core.c | 20 ++++--- .../cam_fd/fd_hw_mgr/fd_hw/cam_fd_hw_core.c | 13 ++-- drivers/cam_icp/hfi.c | 23 ++++---- drivers/cam_icp/icp_hw/a5_hw/a5_core.c | 10 +++- .../icp_hw/icp_hw_mgr/cam_icp_hw_mgr.c | 39 +++++++----- drivers/cam_icp/icp_hw/lx7_hw/lx7_core.c | 8 ++- drivers/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c | 6 +- drivers/cam_isp/isp_hw_mgr/cam_tfe_hw_mgr.c | 6 +- .../isp_hw/ife_csid_hw/cam_ife_csid_hw_ver1.c | 21 ++++--- .../isp_hw/ife_csid_hw/cam_ife_csid_hw_ver2.c | 3 +- .../isp_hw/ppi_hw/cam_csid_ppi_core.c | 8 ++- .../isp_hw/tfe_csid_hw/cam_tfe_csid_core.c | 36 ++++++----- .../isp_hw_mgr/isp_hw/tfe_hw/cam_tfe_core.c | 6 +- .../isp_hw_mgr/isp_hw/vfe_hw/cam_vfe_core.c | 4 +- .../jpeg_hw/jpeg_dma_hw/jpeg_dma_core.c | 13 ++-- .../jpeg_hw/jpeg_enc_hw/jpeg_enc_core.c | 13 ++-- .../lrme_hw_mgr/lrme_hw/cam_lrme_hw_core.c | 6 +- .../ope_hw_mgr/ope_hw/bus_rd/ope_bus_rd.c | 5 +- .../cam_ope/ope_hw_mgr/ope_hw/top/ope_top.c | 7 ++- drivers/cam_req_mgr/cam_req_mgr_core.c | 5 +- .../cam_sensor_module/cam_cci/cam_cci_core.c | 16 ++--- .../cam_sensor_module/cam_cci/cam_cci_dev.h | 3 +- .../cam_sensor_module/cam_cci/cam_cci_soc.c | 4 +- drivers/cam_sync/cam_sync.c | 4 +- drivers/cam_utils/cam_common_util.c | 59 ++++++++++++++++++- drivers/cam_utils/cam_common_util.h | 39 +++++++++++- 26 files changed, 261 insertions(+), 116 deletions(-) diff --git a/drivers/cam_cdm/cam_cdm_hw_core.c b/drivers/cam_cdm/cam_cdm_hw_core.c index e635472e62..ae55bbc172 100644 --- a/drivers/cam_cdm/cam_cdm_hw_core.c +++ b/drivers/cam_cdm/cam_cdm_hw_core.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #include @@ -26,6 +26,7 @@ #include "camera_main.h" #include "cam_trace.h" #include "cam_req_mgr_workq.h" +#include "cam_common_util.h" #define CAM_CDM_BL_FIFO_WAIT_TIMEOUT 2000 #define CAM_CDM_DBG_GEN_IRQ_USR_DATA 0xff @@ -688,7 +689,7 @@ int cam_hw_cdm_wait_for_bl_fifo( CAM_ERR(CAM_CDM, "Enable BL done irq failed"); break; } - time_left = wait_for_completion_timeout( + time_left = cam_common_wait_for_completion_timeout( &core->bl_fifo[fifo_idx].bl_complete, msecs_to_jiffies( CAM_CDM_BL_FIFO_WAIT_TIMEOUT)); @@ -1727,8 +1728,9 @@ int cam_hw_cdm_reset_hw(struct cam_hw_info *cdm_hw, uint32_t handle) CAM_DBG(CAM_CDM, "Waiting for %s%u HW reset done", soc_info->label_name, soc_info->index); - time_left = wait_for_completion_timeout(&cdm_core->reset_complete, - msecs_to_jiffies(CAM_CDM_HW_RESET_TIMEOUT)); + time_left = cam_common_wait_for_completion_timeout( + &cdm_core->reset_complete, + msecs_to_jiffies(CAM_CDM_HW_RESET_TIMEOUT)); if (time_left <= 0) { rc = -ETIMEDOUT; @@ -1829,8 +1831,9 @@ int cam_hw_cdm_handle_error_info( } CAM_DBG(CAM_CDM, "Waiting for CDM HW resetdone"); - time_left = wait_for_completion_timeout(&cdm_core->reset_complete, - msecs_to_jiffies(CAM_CDM_HW_RESET_TIMEOUT)); + time_left = cam_common_wait_for_completion_timeout( + &cdm_core->reset_complete, + msecs_to_jiffies(CAM_CDM_HW_RESET_TIMEOUT)); if (time_left <= 0) { rc = -ETIMEDOUT; @@ -2131,8 +2134,9 @@ int cam_hw_cdm_deinit(void *hw_priv, CAM_DBG(CAM_CDM, "Waiting for %s%u HW reset done", soc_info->label_name, soc_info->index); - time_left = wait_for_completion_timeout(&cdm_core->reset_complete, - msecs_to_jiffies(CAM_CDM_HW_RESET_TIMEOUT)); + time_left = cam_common_wait_for_completion_timeout( + &cdm_core->reset_complete, + msecs_to_jiffies(CAM_CDM_HW_RESET_TIMEOUT)); if (time_left <= 0) { rc = -ETIMEDOUT; diff --git a/drivers/cam_fd/fd_hw_mgr/fd_hw/cam_fd_hw_core.c b/drivers/cam_fd/fd_hw_mgr/fd_hw/cam_fd_hw_core.c index 49cee7922f..156edb0492 100644 --- a/drivers/cam_fd/fd_hw_mgr/fd_hw/cam_fd_hw_core.c +++ b/drivers/cam_fd/fd_hw_mgr/fd_hw/cam_fd_hw_core.c @@ -1,11 +1,12 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #include "cam_fd_hw_core.h" #include "cam_fd_hw_soc.h" #include "cam_trace.h" +#include "cam_common_util.h" #define CAM_FD_REG_VAL_PAIR_SIZE 256 @@ -117,8 +118,9 @@ static int cam_fd_hw_util_fdwrapper_sync_reset(struct cam_hw_info *fd_hw) cam_fd_soc_register_write(soc_info, CAM_FD_REG_WRAPPER, hw_static_info->wrapper_regs.sw_reset, 0x1); - time_left = wait_for_completion_timeout(&fd_core->reset_complete, - msecs_to_jiffies(CAM_FD_HW_HALT_RESET_TIMEOUT)); + time_left = cam_common_wait_for_completion_timeout( + &fd_core->reset_complete, + msecs_to_jiffies(CAM_FD_HW_HALT_RESET_TIMEOUT)); if (time_left <= 0) CAM_WARN(CAM_FD, "HW reset timeout time_left=%ld", time_left); @@ -147,8 +149,9 @@ static int cam_fd_hw_util_fdwrapper_halt(struct cam_hw_info *fd_hw) cam_fd_soc_register_write(soc_info, CAM_FD_REG_WRAPPER, hw_static_info->wrapper_regs.hw_stop, 0x1); - time_left = wait_for_completion_timeout(&fd_core->halt_complete, - msecs_to_jiffies(CAM_FD_HW_HALT_RESET_TIMEOUT)); + time_left = cam_common_wait_for_completion_timeout( + &fd_core->halt_complete, + msecs_to_jiffies(CAM_FD_HW_HALT_RESET_TIMEOUT)); if (time_left <= 0) CAM_WARN(CAM_FD, "HW halt timeout time_left=%ld", time_left); diff --git a/drivers/cam_icp/hfi.c b/drivers/cam_icp/hfi.c index c179cbb506..8b22b06b7d 100644 --- a/drivers/cam_icp/hfi.c +++ b/drivers/cam_icp/hfi.c @@ -602,12 +602,13 @@ int cam_hfi_resume(struct hfi_mem_info *hfi_mem) return -EINVAL; } - if (readl_poll_timeout(icp_base + HFI_REG_ICP_HOST_INIT_RESPONSE, - status, status == ICP_INIT_RESP_SUCCESS, - HFI_POLL_DELAY_US, HFI_POLL_TIMEOUT_US)) { - CAM_ERR(CAM_HFI, "response poll timed out: status=0x%08x", - status); - return -ETIMEDOUT; + if (cam_common_read_poll_timeout(icp_base + + HFI_REG_ICP_HOST_INIT_RESPONSE, + HFI_POLL_DELAY_US, HFI_POLL_TIMEOUT_US, + 0x1, ICP_INIT_RESP_SUCCESS, &status)) { + CAM_ERR(CAM_HFI, "response poll timed out: status=0x%08x", + status); + return -ETIMEDOUT; } hfi_irq_enable(g_hfi); @@ -873,11 +874,11 @@ int cam_hfi_init(struct hfi_mem_info *hfi_mem, const struct hfi_ops *hfi_ops, hfi_mem->qtbl.iova, hfi_mem->qtbl.len, hfi_mem->sfr_buf.iova, hfi_mem->sfr_buf.len); - if (readl_poll_timeout(icp_base + HFI_REG_ICP_HOST_INIT_RESPONSE, - status, status == ICP_INIT_RESP_SUCCESS, - HFI_POLL_DELAY_US, HFI_POLL_TIMEOUT_US)) { - CAM_ERR(CAM_HFI, - "response poll timed out: status=0x%08x", + if (cam_common_read_poll_timeout(icp_base + + HFI_REG_ICP_HOST_INIT_RESPONSE, + HFI_POLL_DELAY_US, HFI_POLL_TIMEOUT_US, + 0x1, ICP_INIT_RESP_SUCCESS, &status)) { + CAM_ERR(CAM_HFI, "response poll timed out: status=0x%08x", status); rc = -ETIMEDOUT; goto regions_fail; diff --git a/drivers/cam_icp/icp_hw/a5_hw/a5_core.c b/drivers/cam_icp/icp_hw/a5_hw/a5_core.c index 544ec64e20..732df4fc4d 100644 --- a/drivers/cam_icp/icp_hw/a5_hw/a5_core.c +++ b/drivers/cam_icp/icp_hw/a5_hw/a5_core.c @@ -27,6 +27,7 @@ #include "cam_cpas_api.h" #include "cam_debug_util.h" #include "cam_icp_utils.h" +#include "cam_common_util.h" #define PC_POLL_DELAY_US 100 #define PC_POLL_TIMEOUT_US 10000 @@ -333,9 +334,12 @@ static int cam_a5_power_collapse(struct cam_hw_info *a5_info) * and Host can then proceed. No interrupt is expected * from FW at this time. */ - if (readl_poll_timeout(base + ICP_SIERRA_A5_CSR_A5_STATUS, - status, status & A5_CSR_A5_STANDBYWFI, - PC_POLL_DELAY_US, PC_POLL_TIMEOUT_US)) { + + if (cam_common_read_poll_timeout(base + + ICP_SIERRA_A5_CSR_A5_STATUS, + PC_POLL_DELAY_US, PC_POLL_TIMEOUT_US, + A5_CSR_A5_STANDBYWFI, + A5_CSR_A5_STANDBYWFI, &status)) { CAM_ERR(CAM_ICP, "WFI poll timed out: status=0x%08x", status); return -ETIMEDOUT; } diff --git a/drivers/cam_icp/icp_hw/icp_hw_mgr/cam_icp_hw_mgr.c b/drivers/cam_icp/icp_hw/icp_hw_mgr/cam_icp_hw_mgr.c index bb25b8396f..7426f10853 100644 --- a/drivers/cam_icp/icp_hw/icp_hw_mgr/cam_icp_hw_mgr.c +++ b/drivers/cam_icp/icp_hw/icp_hw_mgr/cam_icp_hw_mgr.c @@ -3179,8 +3179,9 @@ static int cam_icp_mgr_send_pc_prep(struct cam_icp_hw_mgr *hw_mgr) return rc; CAM_DBG(CAM_ICP, "Wait for PC_PREP_DONE Message\n"); - rem_jiffies = wait_for_completion_timeout(&icp_hw_mgr.icp_complete, - msecs_to_jiffies((timeout))); + rem_jiffies = cam_common_wait_for_completion_timeout( + &icp_hw_mgr.icp_complete, + msecs_to_jiffies((timeout))); if (!rem_jiffies) { rc = -ETIMEDOUT; CAM_ERR(CAM_ICP, "PC_PREP response timed out %d\n", rc); @@ -3512,7 +3513,7 @@ static int cam_icp_retry_wait_for_abort( CAM_WARN(CAM_ICP, "FW timeout in abort ctx: %u retry_left: %d", ctx_data->ctx_id, retry_cnt); while (retry_cnt > 0) { - rem_jiffies = wait_for_completion_timeout( + rem_jiffies = cam_common_wait_for_completion_timeout( &ctx_data->wait_complete, msecs_to_jiffies((timeout))); if (!rem_jiffies) { @@ -3624,7 +3625,8 @@ static int cam_icp_mgr_abort_handle( } CAM_DBG(CAM_ICP, "fw_handle = %x ctx_data = %pK", ctx_data->fw_handle, ctx_data); - rem_jiffies = wait_for_completion_timeout(&ctx_data->wait_complete, + rem_jiffies = cam_common_wait_for_completion_timeout( + &ctx_data->wait_complete, msecs_to_jiffies((timeout))); if (!rem_jiffies) { rc = cam_icp_retry_wait_for_abort(ctx_data); @@ -3682,7 +3684,8 @@ static int cam_icp_mgr_destroy_handle( } CAM_DBG(CAM_ICP, "fw_handle = %x ctx_data = %pK", ctx_data->fw_handle, ctx_data); - rem_jiffies = wait_for_completion_timeout(&ctx_data->wait_complete, + rem_jiffies = cam_common_wait_for_completion_timeout( + &ctx_data->wait_complete, msecs_to_jiffies((timeout))); if (!rem_jiffies) { rc = -ETIMEDOUT; @@ -3952,8 +3955,9 @@ static int cam_icp_mgr_send_fw_init(struct cam_icp_hw_mgr *hw_mgr) if (rc) return rc; - rem_jiffies = wait_for_completion_timeout(&icp_hw_mgr.icp_complete, - msecs_to_jiffies((timeout))); + rem_jiffies = cam_common_wait_for_completion_timeout( + &icp_hw_mgr.icp_complete, + msecs_to_jiffies((timeout))); if (!rem_jiffies) { rc = -ETIMEDOUT; CAM_ERR(CAM_ICP, "FW response timed out %d", rc); @@ -4218,8 +4222,9 @@ static int cam_icp_mgr_send_config_io(struct cam_icp_hw_ctx_data *ctx_data, return rc; } - rem_jiffies = wait_for_completion_timeout(&ctx_data->wait_complete, - msecs_to_jiffies((timeout))); + rem_jiffies = cam_common_wait_for_completion_timeout( + &ctx_data->wait_complete, + msecs_to_jiffies((timeout))); if (!rem_jiffies) { /* send specific error for io config failure */ rc = -EREMOTEIO; @@ -4675,8 +4680,9 @@ static int cam_icp_process_stream_settings( CAM_DBG(CAM_ICP, "Sent FW %s cmd", map_unmap ? "Map" : "Unmap"); - rem_jiffies = wait_for_completion_timeout(&ctx_data->wait_complete, - msecs_to_jiffies((timeout))); + rem_jiffies = cam_common_wait_for_completion_timeout( + &ctx_data->wait_complete, + msecs_to_jiffies((timeout))); if (!rem_jiffies) { rc = -ETIMEDOUT; CAM_ERR(CAM_ICP, "FW response timed out %d", rc); @@ -5392,8 +5398,9 @@ static int cam_icp_mgr_enqueue_abort( cam_req_mgr_workq_enqueue_task(task, &icp_hw_mgr, CRM_TASK_PRIORITY_0); - rem_jiffies = wait_for_completion_timeout(&ctx_data->wait_complete, - msecs_to_jiffies((timeout))); + rem_jiffies = cam_common_wait_for_completion_timeout( + &ctx_data->wait_complete, + msecs_to_jiffies((timeout))); if (!rem_jiffies) { rc = cam_icp_retry_wait_for_abort(ctx_data); if (rc) { @@ -5673,7 +5680,8 @@ static int cam_icp_mgr_create_handle(uint32_t dev_type, if (rc) return rc; - rem_jiffies = wait_for_completion_timeout(&ctx_data->wait_complete, + rem_jiffies = cam_common_wait_for_completion_timeout( + &ctx_data->wait_complete, msecs_to_jiffies((timeout))); if (!rem_jiffies) { rc = -ETIMEDOUT; @@ -5720,7 +5728,8 @@ static int cam_icp_mgr_send_ping(struct cam_icp_hw_ctx_data *ctx_data) if (rc) return rc; - rem_jiffies = wait_for_completion_timeout(&ctx_data->wait_complete, + rem_jiffies = cam_common_wait_for_completion_timeout( + &ctx_data->wait_complete, msecs_to_jiffies((timeout))); if (!rem_jiffies) { rc = -ETIMEDOUT; diff --git a/drivers/cam_icp/icp_hw/lx7_hw/lx7_core.c b/drivers/cam_icp/icp_hw/lx7_hw/lx7_core.c index 2dde505afa..f5ddf539ba 100644 --- a/drivers/cam_icp/icp_hw/lx7_hw/lx7_core.c +++ b/drivers/cam_icp/icp_hw/lx7_hw/lx7_core.c @@ -19,6 +19,7 @@ #include "lx7_core.h" #include "lx7_reg.h" #include "lx7_soc.h" +#include "cam_common_util.h" #define TZ_STATE_SUSPEND 0 #define TZ_STATE_RESUME 1 @@ -344,9 +345,10 @@ static int __cam_lx7_power_collapse(struct cam_hw_info *lx7_info) * and Host can then proceed. No interrupt is expected * from FW at this time. */ - if (readl_poll_timeout(base + ICP_LX7_SYS_STATUS, - status, status & ICP_LX7_STANDBYWFI, - PC_POLL_DELAY_US, PC_POLL_TIMEOUT_US)) { + if (cam_common_read_poll_timeout(base + ICP_LX7_SYS_STATUS, + PC_POLL_DELAY_US, PC_POLL_TIMEOUT_US, + ICP_LX7_STANDBYWFI, ICP_LX7_STANDBYWFI, + &status)) { CAM_ERR(CAM_ICP, "WFI poll timed out: status=0x%08x", status); return -ETIMEDOUT; } diff --git a/drivers/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c b/drivers/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c index 9ee3acabc1..3493176ced 100644 --- a/drivers/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c +++ b/drivers/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c @@ -5480,7 +5480,7 @@ static int cam_ife_mgr_config_hw(void *hw_mgr_priv, if (cfg->init_packet || hw_update_data->mup_en || (ctx->ctx_config & CAM_IFE_CTX_CFG_SW_SYNC_ON)) { - rem_jiffies = wait_for_completion_timeout( + rem_jiffies = cam_common_wait_for_completion_timeout( &ctx->config_done_complete, msecs_to_jiffies(60)); if (rem_jiffies == 0) { @@ -5741,7 +5741,7 @@ static int cam_ife_mgr_stop_hw(void *hw_mgr_priv, void *stop_hw_args) sizeof(struct cam_sfe_scratch_buf_cfg)); cam_ife_mgr_pause_hw(ctx); - rem_jiffies = wait_for_completion_timeout( + rem_jiffies = cam_common_wait_for_completion_timeout( &ctx->config_done_complete, msecs_to_jiffies(10)); if (rem_jiffies == 0) @@ -9701,7 +9701,7 @@ static int cam_ife_mgr_cmd(void *hw_mgr_priv, void *cmd_args) if (ctx->last_dump_flush_req_id == ctx->applied_req_id) return 0; - rem_jiffies = wait_for_completion_timeout( + rem_jiffies = cam_common_wait_for_completion_timeout( &ctx->config_done_complete, msecs_to_jiffies(30)); if (rem_jiffies == 0) CAM_ERR(CAM_ISP, diff --git a/drivers/cam_isp/isp_hw_mgr/cam_tfe_hw_mgr.c b/drivers/cam_isp/isp_hw_mgr/cam_tfe_hw_mgr.c index 9db0fd5528..cb67bfe58a 100644 --- a/drivers/cam_isp/isp_hw_mgr/cam_tfe_hw_mgr.c +++ b/drivers/cam_isp/isp_hw_mgr/cam_tfe_hw_mgr.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2019-2021, The Linux Foundation. All rights reserved. */ #include @@ -2613,7 +2613,7 @@ static int cam_tfe_mgr_config_hw(void *hw_mgr_priv, goto end; for (i = 0; i < CAM_TFE_HW_CONFIG_WAIT_MAX_TRY; i++) { - rc = wait_for_completion_timeout( + rc = cam_common_wait_for_completion_timeout( &ctx->config_done_complete, msecs_to_jiffies( CAM_TFE_HW_CONFIG_TIMEOUT)); @@ -2873,7 +2873,7 @@ static int cam_tfe_mgr_stop_hw(void *hw_mgr_priv, void *stop_hw_args) cam_tfe_mgr_pause_hw(ctx); - wait_for_completion_timeout(&ctx->config_done_complete, + cam_common_wait_for_completion_timeout(&ctx->config_done_complete, msecs_to_jiffies(5)); if (ctx->is_tpg) diff --git a/drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_hw_ver1.c b/drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_hw_ver1.c index bda19980ee..8492f15259 100644 --- a/drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_hw_ver1.c +++ b/drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_hw_ver1.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved. */ #include @@ -20,6 +20,7 @@ #include "cam_cpas_api.h" #include "cam_isp_hw_mgr_intf.h" #include "cam_tasklet_util.h" +#include "cam_common_util.h" #define IFE_CSID_TIMEOUT 1000 @@ -440,7 +441,7 @@ static int cam_ife_csid_ver1_hw_reset( spin_unlock_irqrestore(&csid_hw->hw_info->hw_lock, flags); CAM_DBG(CAM_ISP, "CSID reset start"); - rem_jiffies = wait_for_completion_timeout( + rem_jiffies = cam_common_wait_for_completion_timeout( &csid_hw->irq_complete[CAM_IFE_CSID_IRQ_REG_TOP], msecs_to_jiffies(CAM_IFE_CSID_RESET_TIMEOUT_MS)); @@ -516,7 +517,7 @@ static int cam_ife_csid_ver1_sw_reset( CAM_DBG(CAM_ISP, "CSID[%d] top reset start", csid_hw->hw_intf->hw_idx); - rem_jiffies = wait_for_completion_timeout( + rem_jiffies = cam_common_wait_for_completion_timeout( &csid_hw->irq_complete[CAM_IFE_CSID_IRQ_REG_TOP], msecs_to_jiffies(CAM_IFE_CSID_RESET_TIMEOUT_MS)); @@ -651,7 +652,7 @@ static int cam_ife_csid_path_reset( irq_reg = cam_ife_csid_convert_res_to_irq_reg(res->res_id); reinit_completion(&csid_hw->irq_complete[irq_reg]); - rem_jiffies = wait_for_completion_timeout( + rem_jiffies = cam_common_wait_for_completion_timeout( &csid_hw->irq_complete[irq_reg], msecs_to_jiffies(IFE_CSID_TIMEOUT)); @@ -3060,16 +3061,20 @@ static int cam_ife_csid_poll_stop_status( CAM_DBG(CAM_ISP, "start polling CSID:%d res_id:%d", csid_hw->hw_intf->hw_idx, res_id); - rc = readl_poll_timeout(soc_info->reg_map[0].mem_base + - status_addr, val, (val & 0x1) == 0x1, - CAM_IFE_CSID_TIMEOUT_SLEEP_US, - CAM_IFE_CSID_TIMEOUT_ALL_US); + rc = cam_common_read_poll_timeout( + soc_info->reg_map[0].mem_base + + status_addr, + CAM_IFE_CSID_TIMEOUT_SLEEP_US, + CAM_IFE_CSID_TIMEOUT_ALL_US, + 0x1, 0x1, &val); + if (rc < 0) { CAM_ERR(CAM_ISP, "CSID:%d res:%d halt failed rc %d", csid_hw->hw_intf->hw_idx, res_id, rc); rc = -ETIMEDOUT; break; } + CAM_DBG(CAM_ISP, "End polling CSID:%d res_id:%d", csid_hw->hw_intf->hw_idx, res_id); } diff --git a/drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_hw_ver2.c b/drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_hw_ver2.c index 445d7b8b50..202c08be77 100644 --- a/drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_hw_ver2.c +++ b/drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_hw_ver2.c @@ -22,6 +22,7 @@ #include "cam_irq_controller.h" #include "cam_tasklet_util.h" #include "cam_cdm_util.h" +#include "cam_common_util.h" /* CSIPHY TPG VC/DT values */ @@ -1081,7 +1082,7 @@ static int cam_ife_csid_ver2_wait_for_reset( unsigned long rem_jiffies = 0; int rc = 0; - rem_jiffies = wait_for_completion_timeout( + rem_jiffies = cam_common_wait_for_completion_timeout( &csid_hw->irq_complete[CAM_IFE_CSID_IRQ_REG_TOP], msecs_to_jiffies(CAM_IFE_CSID_RESET_TIMEOUT_MS)); diff --git a/drivers/cam_isp/isp_hw_mgr/isp_hw/ppi_hw/cam_csid_ppi_core.c b/drivers/cam_isp/isp_hw_mgr/isp_hw/ppi_hw/cam_csid_ppi_core.c index 42a84af64e..118073b5c1 100644 --- a/drivers/cam_isp/isp_hw_mgr/isp_hw/ppi_hw/cam_csid_ppi_core.c +++ b/drivers/cam_isp/isp_hw_mgr/isp_hw/ppi_hw/cam_csid_ppi_core.c @@ -12,6 +12,7 @@ #include "cam_soc_util.h" #include "cam_debug_util.h" #include "cam_io_util.h" +#include "cam_common_util.h" static int cam_csid_ppi_reset(struct cam_csid_ppi_hw *ppi_hw) { @@ -34,9 +35,10 @@ static int cam_csid_ppi_reset(struct cam_csid_ppi_hw *ppi_hw) cam_io_w_mb(PPI_IRQ_CMD_SET, soc_info->reg_map[0].mem_base + ppi_reg->ppi_irq_cmd_addr); - rc = readl_poll_timeout(soc_info->reg_map[0].mem_base + - ppi_reg->ppi_irq_status_addr, status, - (status & 0x1) == 0x1, 1000, 500000); + rc = cam_common_read_poll_timeout(soc_info->reg_map[0].mem_base + + ppi_reg->ppi_irq_status_addr, + 1000, 500000, 0x1, 0x1, &status); + CAM_DBG(CAM_ISP, "PPI:%d reset status %d", ppi_hw->hw_intf->hw_idx, status); if (rc < 0) { diff --git a/drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_csid_hw/cam_tfe_csid_core.c b/drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_csid_hw/cam_tfe_csid_core.c index 136b4e3821..6e643d4539 100644 --- a/drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_csid_hw/cam_tfe_csid_core.c +++ b/drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_csid_hw/cam_tfe_csid_core.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2019-2021, The Linux Foundation. All rights reserved. */ #include @@ -19,6 +19,7 @@ #include "cam_isp_hw_mgr_intf.h" #include "cam_subdev.h" #include "cam_tasklet_util.h" +#include "cam_common_util.h" /* Timeout value in msec */ #define TFE_CSID_TIMEOUT 1000 @@ -309,10 +310,11 @@ static int cam_tfe_csid_global_reset(struct cam_tfe_csid_hw *csid_hw) soc_info->reg_map[0].mem_base + csid_reg->cmn_reg->csid_rst_strobes_addr); - rc = readl_poll_timeout(soc_info->reg_map[0].mem_base + + rc = cam_common_read_poll_timeout(soc_info->reg_map[0].mem_base + csid_reg->cmn_reg->csid_top_irq_status_addr, - status, (status & 0x1) == 0x1, - CAM_TFE_CSID_TIMEOUT_SLEEP_US, CAM_TFE_CSID_TIMEOUT_ALL_US); + CAM_TFE_CSID_TIMEOUT_SLEEP_US, CAM_TFE_CSID_TIMEOUT_ALL_US, + 0x1, 0x1, &status); + if (rc < 0) { CAM_ERR(CAM_ISP, "CSID:%d csid_reset fail rc = %d", csid_hw->hw_intf->hw_idx, rc); @@ -329,8 +331,9 @@ static int cam_tfe_csid_global_reset(struct cam_tfe_csid_hw *csid_hw) soc_info->reg_map[0].mem_base + csid_reg->cmn_reg->csid_rst_strobes_addr); - rc = wait_for_completion_timeout(&csid_hw->csid_top_complete, - msecs_to_jiffies(TFE_CSID_TIMEOUT)); + rc = cam_common_wait_for_completion_timeout( + &csid_hw->csid_top_complete, + msecs_to_jiffies(TFE_CSID_TIMEOUT)); if (rc <= 0) { CAM_ERR(CAM_ISP, "CSID:%d soft reg reset fail rc = %d", csid_hw->hw_intf->hw_idx, rc); @@ -429,7 +432,7 @@ static int cam_tfe_csid_path_reset(struct cam_tfe_csid_hw *csid_hw, cam_io_w_mb(reset_strb_val, soc_info->reg_map[0].mem_base + reset_strb_addr); - rc = wait_for_completion_timeout(complete, + rc = cam_common_wait_for_completion_timeout(complete, msecs_to_jiffies(TFE_CSID_TIMEOUT)); if (rc <= 0) { CAM_ERR(CAM_ISP, "CSID:%d Res id %d fail rc = %d", @@ -1651,10 +1654,13 @@ static int cam_tfe_csid_poll_stop_status( CAM_DBG(CAM_ISP, "start polling CSID:%d res_id:%d", csid_hw->hw_intf->hw_idx, res_id); - rc = readl_poll_timeout(soc_info->reg_map[0].mem_base + - csid_status_addr, val, (val & 0x1) == 0x1, - CAM_TFE_CSID_TIMEOUT_SLEEP_US, - CAM_TFE_CSID_TIMEOUT_ALL_US); + rc = cam_common_read_poll_timeout( + soc_info->reg_map[0].mem_base + + csid_status_addr, + CAM_TFE_CSID_TIMEOUT_SLEEP_US, + CAM_TFE_CSID_TIMEOUT_ALL_US, + 0x1, 0x1, &val); + if (rc < 0) { CAM_ERR(CAM_ISP, "CSID:%d res:%d halt failed rc %d", csid_hw->hw_intf->hw_idx, res_id, rc); @@ -1992,10 +1998,12 @@ static int cam_tfe_csid_reset_retain_sw_reg( cam_io_w_mb(csid_reg->cmn_reg->csid_rst_stb, soc_info->reg_map[0].mem_base + csid_reg->cmn_reg->csid_rst_strobes_addr); - rc = readl_poll_timeout(soc_info->reg_map[0].mem_base + + + rc = cam_common_read_poll_timeout(soc_info->reg_map[0].mem_base + csid_reg->cmn_reg->csid_top_irq_status_addr, - status, (status & 0x1) == 0x1, - CAM_TFE_CSID_TIMEOUT_SLEEP_US, CAM_TFE_CSID_TIMEOUT_ALL_US); + CAM_TFE_CSID_TIMEOUT_SLEEP_US, CAM_TFE_CSID_TIMEOUT_ALL_US, + 0x1, 0x1, &status); + if (rc < 0) { CAM_ERR(CAM_ISP, "CSID:%d csid_reset fail rc = %d", csid_hw->hw_intf->hw_idx, rc); diff --git a/drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_hw/cam_tfe_core.c b/drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_hw/cam_tfe_core.c index f6a98dc34f..c966757c88 100644 --- a/drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_hw/cam_tfe_core.c +++ b/drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_hw/cam_tfe_core.c @@ -19,6 +19,7 @@ #include "cam_debug_util.h" #include "cam_cpas_api.h" #include "cam_compat.h" +#include "cam_common_util.h" static const char drv_name[] = "tfe"; @@ -2517,8 +2518,9 @@ int cam_tfe_reset(void *hw_priv, void *reset_core_args, uint32_t arg_size) CAM_DBG(CAM_ISP, "TFE:%d waiting for tfe reset complete", core_info->core_index); /* Wait for Completion or Timeout of 100ms */ - rc = wait_for_completion_timeout(&core_info->reset_complete, - msecs_to_jiffies(100)); + rc = cam_common_wait_for_completion_timeout( + &core_info->reset_complete, + msecs_to_jiffies(100)); if (rc <= 0) { CAM_ERR(CAM_ISP, "TFE:%d Error Reset Timeout", core_info->core_index); diff --git a/drivers/cam_isp/isp_hw_mgr/isp_hw/vfe_hw/cam_vfe_core.c b/drivers/cam_isp/isp_hw_mgr/isp_hw/vfe_hw/cam_vfe_core.c index 1ff6a91e37..e71acba320 100644 --- a/drivers/cam_isp/isp_hw_mgr/isp_hw/vfe_hw/cam_vfe_core.c +++ b/drivers/cam_isp/isp_hw_mgr/isp_hw/vfe_hw/cam_vfe_core.c @@ -17,6 +17,7 @@ #include "cam_ife_hw_mgr.h" #include "cam_debug_util.h" #include "cam_cpas_api.h" +#include "cam_common_util.h" static const char drv_name[] = "vfe"; @@ -268,7 +269,8 @@ int cam_vfe_reset(void *hw_priv, void *reset_core_args, uint32_t arg_size) reset_core_args, arg_size); /* Wait for Completion or Timeout of 500ms */ - rc = wait_for_completion_timeout(&vfe_hw->hw_complete, 500); + rc = cam_common_wait_for_completion_timeout( + &vfe_hw->hw_complete, 500); if (!rc) CAM_ERR(CAM_ISP, "Reset Timeout"); diff --git a/drivers/cam_jpeg/jpeg_hw/jpeg_dma_hw/jpeg_dma_core.c b/drivers/cam_jpeg/jpeg_hw/jpeg_dma_hw/jpeg_dma_core.c index 87431897d4..14cffd6b2c 100644 --- a/drivers/cam_jpeg/jpeg_hw/jpeg_dma_hw/jpeg_dma_core.c +++ b/drivers/cam_jpeg/jpeg_hw/jpeg_dma_hw/jpeg_dma_core.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #include @@ -22,6 +22,7 @@ #include "cam_jpeg_hw_mgr_intf.h" #include "cam_cpas_api.h" #include "cam_debug_util.h" +#include "cam_common_util.h" #define CAM_JPEG_HW_IRQ_IS_FRAME_DONE(jpeg_irq_status, hi) \ ((jpeg_irq_status) & (hi)->int_status.framedone) @@ -280,8 +281,9 @@ int cam_jpeg_dma_reset_hw(void *data, cam_io_w_mb(hw_info->reg_val.reset_cmd, mem_base + hw_info->reg_offset.reset_cmd); - rem_jiffies = wait_for_completion_timeout(&jpeg_dma_dev->hw_complete, - CAM_JPEG_DMA_RESET_TIMEOUT); + rem_jiffies = cam_common_wait_for_completion_timeout( + &jpeg_dma_dev->hw_complete, + CAM_JPEG_DMA_RESET_TIMEOUT); if (!rem_jiffies) { CAM_ERR(CAM_JPEG, "dma error Reset Timeout"); core_info->core_state = CAM_JPEG_DMA_CORE_NOT_READY; @@ -361,8 +363,9 @@ int cam_jpeg_dma_stop_hw(void *data, cam_io_w_mb(hw_info->reg_val.hw_cmd_stop, mem_base + hw_info->reg_offset.hw_cmd); - rem_jiffies = wait_for_completion_timeout(&jpeg_dma_dev->hw_complete, - CAM_JPEG_DMA_RESET_TIMEOUT); + rem_jiffies = cam_common_wait_for_completion_timeout( + &jpeg_dma_dev->hw_complete, + CAM_JPEG_DMA_RESET_TIMEOUT); if (!rem_jiffies) { CAM_ERR(CAM_JPEG, "error Reset Timeout"); core_info->core_state = CAM_JPEG_DMA_CORE_NOT_READY; diff --git a/drivers/cam_jpeg/jpeg_hw/jpeg_enc_hw/jpeg_enc_core.c b/drivers/cam_jpeg/jpeg_hw/jpeg_enc_hw/jpeg_enc_core.c index 173e165dca..fd0b00ab5a 100644 --- a/drivers/cam_jpeg/jpeg_hw/jpeg_enc_hw/jpeg_enc_core.c +++ b/drivers/cam_jpeg/jpeg_hw/jpeg_enc_hw/jpeg_enc_core.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #include @@ -22,6 +22,7 @@ #include "cam_jpeg_hw_mgr_intf.h" #include "cam_cpas_api.h" #include "cam_debug_util.h" +#include "cam_common_util.h" #define CAM_JPEG_HW_IRQ_IS_FRAME_DONE(jpeg_irq_status, hi) \ ((jpeg_irq_status) & (hi)->int_status.framedone) @@ -313,8 +314,9 @@ int cam_jpeg_enc_reset_hw(void *data, cam_io_w_mb(hw_info->reg_val.reset_cmd, mem_base + hw_info->reg_offset.reset_cmd); - rem_jiffies = wait_for_completion_timeout(&jpeg_enc_dev->hw_complete, - CAM_JPEG_ENC_RESET_TIMEOUT); + rem_jiffies = cam_common_wait_for_completion_timeout( + &jpeg_enc_dev->hw_complete, + CAM_JPEG_ENC_RESET_TIMEOUT); if (!rem_jiffies) { CAM_ERR(CAM_JPEG, "error Reset Timeout"); core_info->core_state = CAM_JPEG_ENC_CORE_NOT_READY; @@ -408,8 +410,9 @@ int cam_jpeg_enc_stop_hw(void *data, cam_io_w_mb(hw_info->reg_val.hw_cmd_stop, mem_base + hw_info->reg_offset.hw_cmd); - rem_jiffies = wait_for_completion_timeout(&jpeg_enc_dev->hw_complete, - CAM_JPEG_ENC_RESET_TIMEOUT); + rem_jiffies = cam_common_wait_for_completion_timeout( + &jpeg_enc_dev->hw_complete, + CAM_JPEG_ENC_RESET_TIMEOUT); if (!rem_jiffies) { CAM_ERR(CAM_JPEG, "error Reset Timeout"); core_info->core_state = CAM_JPEG_ENC_CORE_NOT_READY; diff --git a/drivers/cam_lrme/lrme_hw_mgr/lrme_hw/cam_lrme_hw_core.c b/drivers/cam_lrme/lrme_hw_mgr/lrme_hw/cam_lrme_hw_core.c index dc4df1c579..e4d911c402 100644 --- a/drivers/cam_lrme/lrme_hw_mgr/lrme_hw/cam_lrme_hw_core.c +++ b/drivers/cam_lrme/lrme_hw_mgr/lrme_hw/cam_lrme_hw_core.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #include @@ -461,7 +461,7 @@ static int cam_lrme_hw_util_reset(struct cam_hw_info *lrme_hw, reinit_completion(&lrme_core->reset_complete); cam_io_w_mb(0x1, soc_info->reg_map[0].mem_base + hw_info->titan_reg.top_rst_cmd); - time_left = wait_for_completion_timeout( + time_left = cam_common_wait_for_completion_timeout( &lrme_core->reset_complete, msecs_to_jiffies(CAM_LRME_HW_RESET_TIMEOUT)); if (time_left <= 0) { @@ -479,7 +479,7 @@ static int cam_lrme_hw_util_reset(struct cam_hw_info *lrme_hw, reinit_completion(&lrme_core->reset_complete); cam_io_w_mb(0x2, soc_info->reg_map[0].mem_base + hw_info->titan_reg.top_rst_cmd); - time_left = wait_for_completion_timeout( + time_left = cam_common_wait_for_completion_timeout( &lrme_core->reset_complete, msecs_to_jiffies(CAM_LRME_HW_RESET_TIMEOUT)); if (time_left <= 0) { diff --git a/drivers/cam_ope/ope_hw_mgr/ope_hw/bus_rd/ope_bus_rd.c b/drivers/cam_ope/ope_hw_mgr/ope_hw/bus_rd/ope_bus_rd.c index 033df2b666..c89f4396ec 100644 --- a/drivers/cam_ope/ope_hw_mgr/ope_hw/bus_rd/ope_bus_rd.c +++ b/drivers/cam_ope/ope_hw_mgr/ope_hw/bus_rd/ope_bus_rd.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2019-2021, The Linux Foundation. All rights reserved. */ #include @@ -26,6 +26,7 @@ #include "ope_hw.h" #include "ope_dev_intf.h" #include "ope_bus_rd.h" +#include "cam_common_util.h" static struct ope_bus_rd *bus_rd; @@ -692,7 +693,7 @@ static int cam_ope_bus_rd_init(struct ope_hw *ope_hw_info, cam_io_w_mb(bus_rd_reg_val->sw_reset, ope_hw_info->bus_rd_reg->base + bus_rd_reg->sw_reset); - rc = wait_for_completion_timeout( + rc = cam_common_wait_for_completion_timeout( &bus_rd->reset_complete, msecs_to_jiffies(30000)); if (!rc || rc < 0) { diff --git a/drivers/cam_ope/ope_hw_mgr/ope_hw/top/ope_top.c b/drivers/cam_ope/ope_hw_mgr/ope_hw/top/ope_top.c index 1929a4d6e6..63910f1c48 100644 --- a/drivers/cam_ope/ope_hw_mgr/ope_hw/top/ope_top.c +++ b/drivers/cam_ope/ope_hw_mgr/ope_hw/top/ope_top.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2019-2021, The Linux Foundation. All rights reserved. */ #include @@ -26,6 +26,7 @@ #include "ope_hw.h" #include "ope_dev_intf.h" #include "ope_top.h" +#include "cam_common_util.h" static struct ope_top ope_top_info; @@ -79,7 +80,7 @@ static int cam_ope_top_reset(struct ope_hw *ope_hw_info, cam_io_w_mb(top_reg_val->sw_reset_cmd, ope_hw_info->top_reg->base + top_reg->reset_cmd); - rc = wait_for_completion_timeout( + rc = cam_common_wait_for_completion_timeout( &ope_top_info.reset_complete, msecs_to_jiffies(60)); @@ -184,7 +185,7 @@ static int cam_ope_top_init(struct ope_hw *ope_hw_info, cam_io_w_mb(top_reg_val->sw_reset_cmd, ope_hw_info->top_reg->base + top_reg->reset_cmd); - rc = wait_for_completion_timeout( + rc = cam_common_wait_for_completion_timeout( &ope_top_info.reset_complete, msecs_to_jiffies(60)); diff --git a/drivers/cam_req_mgr/cam_req_mgr_core.c b/drivers/cam_req_mgr/cam_req_mgr_core.c index 646cb6783f..ebd54e366f 100644 --- a/drivers/cam_req_mgr/cam_req_mgr_core.c +++ b/drivers/cam_req_mgr/cam_req_mgr_core.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2016-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2016-2021, The Linux Foundation. All rights reserved. */ #include @@ -16,6 +16,7 @@ #include "cam_debug_util.h" #include "cam_req_mgr_dev.h" #include "cam_req_mgr_debug.h" +#include "cam_common_util.h" static struct cam_req_mgr_core_device *g_crm_core_dev; static struct cam_req_mgr_core_link g_links[MAXIMUM_LINKS_PER_SESSION]; @@ -4233,7 +4234,7 @@ int cam_req_mgr_flush_requests( rc = cam_req_mgr_workq_enqueue_task(task, link, CRM_TASK_PRIORITY_0); /* Blocking call */ - rc = wait_for_completion_timeout( + rc = cam_common_wait_for_completion_timeout( &link->workq_comp, msecs_to_jiffies(CAM_REQ_MGR_SCHED_REQ_TIMEOUT)); end: diff --git a/drivers/cam_sensor_module/cam_cci/cam_cci_core.c b/drivers/cam_sensor_module/cam_cci/cam_cci_core.c index b1a6c65dd6..74c1ea9de7 100644 --- a/drivers/cam_sensor_module/cam_cci/cam_cci_core.c +++ b/drivers/cam_sensor_module/cam_cci/cam_cci_core.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #include @@ -46,7 +46,7 @@ static void cam_cci_flush_queue(struct cci_device *cci_dev, if (!cci_dev->cci_master_info[master].status) reinit_completion(&cci_dev->cci_master_info[master] .reset_complete); - if (!wait_for_completion_timeout( + if (!cam_common_wait_for_completion_timeout( &cci_dev->cci_master_info[master].reset_complete, CCI_TIMEOUT)) { CAM_DBG(CAM_CCI, @@ -66,7 +66,7 @@ static void cam_cci_flush_queue(struct cci_device *cci_dev, base + CCI_RESET_CMD_ADDR); /* wait for reset done irq */ - if (!wait_for_completion_timeout( + if (!cam_common_wait_for_completion_timeout( &cci_dev->cci_master_info[master].reset_complete, CCI_TIMEOUT)) { rc = -EINVAL; @@ -127,7 +127,7 @@ static int32_t cam_cci_validate_queue(struct cci_device *cci_dev, atomic_set(&cci_dev->cci_master_info[master].q_free[queue], 1); spin_unlock_irqrestore( &cci_dev->cci_master_info[master].lock_q[queue], flags); - if (!wait_for_completion_timeout( + if (!cam_common_wait_for_completion_timeout( &cci_dev->cci_master_info[master].report_q[queue], CCI_TIMEOUT)) { CAM_ERR(CAM_CCI, @@ -270,7 +270,7 @@ static uint32_t cam_cci_wait(struct cci_device *cci_dev, return -EINVAL; } - if (!wait_for_completion_timeout( + if (!cam_common_wait_for_completion_timeout( &cci_dev->cci_master_info[master].report_q[queue], CCI_TIMEOUT)) { cam_cci_dump_registers(cci_dev, master, queue); @@ -1085,7 +1085,7 @@ static int32_t cam_cci_burst_read(struct v4l2_subdev *sd, CAM_DBG(CAM_CCI, "waiting for threshold [exp_words %d]", exp_words); while (total_read_words != exp_words) { - rem_jiffies = wait_for_completion_timeout( + rem_jiffies = cam_common_wait_for_completion_timeout( &cci_dev->cci_master_info[master].th_complete, CCI_TIMEOUT); if (!rem_jiffies) { @@ -1174,7 +1174,7 @@ static int32_t cam_cci_burst_read(struct v4l2_subdev *sd, * wait is to compensate for the complete invoked for * RD_DONE exclusively. */ - rem_jiffies = wait_for_completion_timeout( + rem_jiffies = cam_common_wait_for_completion_timeout( &cci_dev->cci_master_info[master].rd_done, CCI_TIMEOUT); if (!rem_jiffies) { @@ -1355,7 +1355,7 @@ static int32_t cam_cci_read(struct v4l2_subdev *sd, CAM_DBG(CAM_CCI, "exp_words to be read: %d", ((read_cfg->num_byte / 4) + 1)); - if (!wait_for_completion_timeout( + if (!cam_common_wait_for_completion_timeout( &cci_dev->cci_master_info[master].rd_done, CCI_TIMEOUT)) { cam_cci_dump_registers(cci_dev, master, queue); diff --git a/drivers/cam_sensor_module/cam_cci/cam_cci_dev.h b/drivers/cam_sensor_module/cam_cci/cam_cci_dev.h index a72f4d8366..3ee02e448d 100644 --- a/drivers/cam_sensor_module/cam_cci/cam_cci_dev.h +++ b/drivers/cam_sensor_module/cam_cci/cam_cci_dev.h @@ -1,6 +1,6 @@ /* SPDX-License-Identifier: GPL-2.0-only */ /* - * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #ifndef _CAM_CCI_DEV_H_ @@ -32,6 +32,7 @@ #include "cam_soc_util.h" #include "cam_debug_util.h" #include "cam_req_mgr_workq.h" +#include "cam_common_util.h" #define CCI_I2C_QUEUE_0_SIZE 128 #define CCI_I2C_QUEUE_1_SIZE 32 diff --git a/drivers/cam_sensor_module/cam_cci/cam_cci_soc.c b/drivers/cam_sensor_module/cam_cci/cam_cci_soc.c index 39433a3f43..0f97565014 100644 --- a/drivers/cam_sensor_module/cam_cci/cam_cci_soc.c +++ b/drivers/cam_sensor_module/cam_cci/cam_cci_soc.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #include "cam_cci_dev.h" @@ -49,7 +49,7 @@ static int cam_cci_init_master(struct cci_device *cci_dev, CCI_M0_RESET_RMSK : CCI_M1_RESET_RMSK, base + CCI_RESET_CMD_ADDR); } - if (!wait_for_completion_timeout( + if (!cam_common_wait_for_completion_timeout( &cci_dev->cci_master_info[master].reset_complete, CCI_TIMEOUT)) { CAM_ERR(CAM_CCI, diff --git a/drivers/cam_sync/cam_sync.c b/drivers/cam_sync/cam_sync.c index 95a3bb89ae..917f9938aa 100644 --- a/drivers/cam_sync/cam_sync.c +++ b/drivers/cam_sync/cam_sync.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #include @@ -432,7 +432,7 @@ int cam_sync_wait(int32_t sync_obj, uint64_t timeout_ms) return -EINVAL; } - timeleft = wait_for_completion_timeout(&row->signaled, + timeleft = cam_common_wait_for_completion_timeout(&row->signaled, msecs_to_jiffies(timeout_ms)); if (!timeleft) { diff --git a/drivers/cam_utils/cam_common_util.c b/drivers/cam_utils/cam_common_util.c index dbcb31d7bf..e43fce4ab8 100644 --- a/drivers/cam_utils/cam_common_util.c +++ b/drivers/cam_utils/cam_common_util.c @@ -1,15 +1,21 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #include #include #include - +#include +#include +#include +#include #include "cam_common_util.h" #include "cam_debug_util.h" +static uint timeout_multiplier = 1; +module_param(timeout_multiplier, uint, 0644); + int cam_common_util_get_string_index(const char **strings, uint32_t num_strings, const char *matching_string, uint32_t *index) { @@ -48,3 +54,52 @@ uint32_t cam_common_util_remove_duplicate_arr(int32_t *arr, uint32_t num) return wr_idx; } + +unsigned long cam_common_wait_for_completion_timeout( + struct completion *complete, + unsigned long timeout_jiffies) +{ + unsigned long wait_jiffies; + unsigned long rem_jiffies; + + if (!complete) { + CAM_ERR(CAM_UTIL, "Null complete pointer"); + return 0; + } + + if (timeout_multiplier < 1) + timeout_multiplier = 1; + + wait_jiffies = timeout_jiffies * timeout_multiplier; + rem_jiffies = wait_for_completion_timeout( + complete, wait_jiffies); + + return rem_jiffies; +} + +int cam_common_read_poll_timeout( + void __iomem *addr, + unsigned long delay, + unsigned long timeout, + uint32_t mask, + uint32_t check_val, + uint32_t *status) +{ + unsigned long wait_time_us; + int rc = -EINVAL; + + if (!addr || !status) { + CAM_ERR(CAM_UTIL, "Invalid param addr: %pK status: %pK", + addr, status); + return rc; + } + + if (timeout_multiplier < 1) + timeout_multiplier = 1; + + wait_time_us = timeout * timeout_multiplier; + rc = readl_poll_timeout(addr, + *status, (*status & mask) == check_val, delay, wait_time_us); + + return rc; +} diff --git a/drivers/cam_utils/cam_common_util.h b/drivers/cam_utils/cam_common_util.h index 5bf20501af..686562ddec 100644 --- a/drivers/cam_utils/cam_common_util.h +++ b/drivers/cam_utils/cam_common_util.h @@ -1,6 +1,6 @@ /* SPDX-License-Identifier: GPL-2.0-only */ /* - * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2017-2021, The Linux Foundation. All rights reserved. */ #ifndef _CAM_COMMON_UTIL_H_ @@ -64,4 +64,41 @@ int cam_common_util_get_string_index(const char **strings, uint32_t cam_common_util_remove_duplicate_arr(int32_t *array, uint32_t num); +/** + * cam_common_wait_for_completion_timeout() + * + * @brief common interface to implement wait for completion + * for slow environment like presil, single debug + * timeout variable can take care + * + * @complete: Pointer to the first integer of array + * @timeout_jiffies: Timeout value in jiffie + * + * @return: Remaining jiffies, non-zero for success, zero + * in case of failure + */ +unsigned long cam_common_wait_for_completion_timeout( + struct completion *complete, + unsigned long timeout_jiffies); +/** + * cam_common_read_poll_timeout() + * + * @brief common interface to read poll timeout + * + * @addr: Address of IO register + * @delay: Delay interval of poll + * @timeout: Timeout for poll + * @mask: Mask to be checked + * @check_val: Value to be compared to break poll + * @status: Status of register of IO + * + * @return: 0 if success and negative if fail + * */ +int cam_common_read_poll_timeout( + void __iomem *addr, + unsigned long delay, + unsigned long timeout, + uint32_t mask, + uint32_t check_val, + uint32_t *status); #endif /* _CAM_COMMON_UTIL_H_ */