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 <[email protected]>

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 <linux/delay.h>
@@ -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;

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

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;

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;
 	}

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;

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;
 	}

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,

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 <linux/slab.h>
@@ -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)

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 <linux/iopoll.h>
@@ -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);
 	}

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

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) {

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 <linux/iopoll.h>
@@ -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);

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

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

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 <linux/of.h>
@@ -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;

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 <linux/of.h>
@@ -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;

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 <linux/timer.h>
@@ -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) {

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 <linux/of.h>
@@ -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) {

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 <linux/of.h>
@@ -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));
 

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 <linux/module.h>
@@ -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:

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 <linux/module.h>
@@ -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);
 

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

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,

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 <linux/init.h>
@@ -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) {

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 <linux/string.h>
 #include <linux/types.h>
 #include <linux/slab.h>
-
+#include <linux/completion.h>
+#include <linux/module.h>
+#include <linux/iopoll.h>
+#include <linux/moduleparam.h>
 #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;
+}

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_ */