Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 22aa6ee5 authored by Krishnankutty Kolathappilly's avatar Krishnankutty Kolathappilly Committed by Sunid Wilson
Browse files

msm: cpp: Add error handling for cpp poll and load firmware functions 



If CPP micro is in bad state, driver reloads the firmware and
reschedules the payload. This helps in recovery from most error
conditions. During stability runs if hardware is in bad state,
reload firmware and rescheduling the payload fails. In these cases
error is not handled in poll/ load firmware API causing frames to
be send to hardware in bad state. This can cause stability failures
and device crashes. Add error handling for cpp poll and load firmware
functions and prevent sending frames to hardware for processing if
hardware is in bad state.

CRs-Fixed: 876275
Change-Id: I85b1130959d941ad49d6c90c24b1d284cfc116b2
Signed-off-by: default avatarKrishnankutty Kolathappilly <kkolatha@codeaurora.org>
Signed-off-by: default avatarSunid Wilson <sunidw@codeaurora.org>
parent 0600f6c1

drivers/media/platform/msm/camera_v2/pproc/cpp/msm_cpp.c

+256 −70
Original line number Diff line number Diff line
@@ -318,7 +318,7 @@ static int get_clock_index(const char *clk_name) 


static int msm_cpp_notify_frame_done(struct cpp_device *cpp_dev,

	uint8_t put_buf);

static void cpp_load_fw(struct cpp_device *cpp_dev, char *fw_name_bin);

static int32_t cpp_load_fw(struct cpp_device *cpp_dev, char *fw_name_bin);

static void cpp_timer_callback(unsigned long data);



uint8_t induce_error;
@@ -640,24 +640,29 @@ static void msm_cpp_delete_buff_queue(struct cpp_device *cpp_dev) 
	return;

}



static void msm_cpp_poll(void __iomem *cpp_base, u32 val)

static int32_t msm_cpp_poll(void __iomem *cpp_base, u32 val)

{

	uint32_t tmp, retry = 0;

	int32_t rc = 0;

	do {

		tmp = msm_cpp_read(cpp_base);

		if (tmp != 0xDEADBEEF)

			CPP_LOW("poll: 0%x\n", tmp);

		usleep_range(200, 250);

	} while ((tmp != val) && (retry++ < MSM_CPP_POLL_RETRIES));

	if (retry < MSM_CPP_POLL_RETRIES)

	if (retry < MSM_CPP_POLL_RETRIES) {

		CPP_LOW("Poll finished\n");

	else

	} else {

		pr_err("Poll failed: expect: 0x%x\n", val);

		rc = -EINVAL;

	}

	return rc;

}



static void msm_cpp_poll_rx_empty(void __iomem *cpp_base)

static int32_t msm_cpp_poll_rx_empty(void __iomem *cpp_base)

{

	uint32_t tmp, retry = 0;

	int32_t rc = 0;



	tmp = msm_camera_io_r(cpp_base + MSM_CPP_MICRO_FIFO_RX_STAT);

	while (((tmp & 0x2) != 0x0) && (retry++ < MSM_CPP_POLL_RETRIES)) {
@@ -671,10 +676,13 @@ static void msm_cpp_poll_rx_empty(void __iomem *cpp_base) 
		tmp = msm_camera_io_r(cpp_base + MSM_CPP_MICRO_FIFO_RX_STAT);

	}



	if (retry < MSM_CPP_POLL_RETRIES)

	if (retry < MSM_CPP_POLL_RETRIES) {

		CPP_LOW("Poll rx empty\n");

	else

	} else {

		pr_err("Poll rx empty failed\n");

		rc = -EINVAL;

	}

	return rc;

}
@@ -1149,10 +1157,14 @@ static int cpp_init_hardware(struct cpp_device *cpp_dev) 
	}

	pr_err("stream_cnt:%d\n", cpp_dev->stream_cnt);

	cpp_dev->stream_cnt = 0;

	if (cpp_dev->is_firmware_loaded == 1) {

	if (cpp_dev->fw_name_bin) {

		disable_irq(cpp_dev->irq->start);

		cpp_load_fw(cpp_dev, cpp_dev->fw_name_bin);

		rc = cpp_load_fw(cpp_dev, cpp_dev->fw_name_bin);

		enable_irq(cpp_dev->irq->start);

		if (rc < 0) {

			pr_err("%s: load firmware failure %d\n", __func__, rc);

			goto pwr_collapse_reset;

		}

		msm_camera_io_w_mb(0x7C8, cpp_dev->base +

			MSM_CPP_MICRO_IRQGEN_MASK);

		msm_camera_io_w_mb(0xFFFF, cpp_dev->base +
@@ -1243,54 +1255,115 @@ static void cpp_release_hardware(struct cpp_device *cpp_dev) 
		pr_err("%s: failed to remove vote for AHB\n", __func__);

}



static void cpp_load_fw(struct cpp_device *cpp_dev, char *fw_name_bin)

static int32_t cpp_load_fw(struct cpp_device *cpp_dev, char *fw_name_bin)

{

	uint32_t i;

	uint32_t *ptr_bin = NULL;

	int32_t rc = 0;



	if (!fw_name_bin) {

		pr_err("%s:%d] invalid fw name", __func__, __LINE__);

		rc = -EINVAL;

		goto end;

	}

	pr_debug("%s:%d] FW file: %s\n", __func__, __LINE__, fw_name_bin);

	if (NULL == cpp_dev->fw) {

		pr_err("%s:%d] fw NULL", __func__, __LINE__);

		rc = -EINVAL;

		goto end;

	}



	ptr_bin = (uint32_t *)cpp_dev->fw->data;

	if (!ptr_bin) {

		pr_err("%s:%d] Fw bin NULL", __func__, __LINE__);

		rc = -EINVAL;

		goto end;

	}



	msm_camera_io_w(0x1, cpp_dev->base + MSM_CPP_MICRO_CLKEN_CTL);

	msm_camera_io_w(0x1, cpp_dev->base +

			 MSM_CPP_MICRO_BOOT_START);

	msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_CMD);



	if (fw_name_bin) {

		pr_debug("%s: FW file: %s\n", __func__, fw_name_bin);

		if (NULL != cpp_dev->fw)

			ptr_bin = (uint32_t *)cpp_dev->fw->data;

	rc = msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_CMD);

	if (rc) {

		pr_err("%s:%d] poll command %x failed %d", __func__, __LINE__,

			MSM_CPP_MSG_ID_CMD, rc);

		goto end;

	}



	msm_camera_io_w(0xFFFFFFFF, cpp_dev->base +

		MSM_CPP_MICRO_IRQGEN_CLR);



	/*Start firmware loading*/

	msm_cpp_write(MSM_CPP_CMD_FW_LOAD, cpp_dev->base);

		if (cpp_dev->fw)

	msm_cpp_write(cpp_dev->fw->size, cpp_dev->base);

		else

			msm_cpp_write(MSM_CPP_END_ADDRESS, cpp_dev->base);

	msm_cpp_write(MSM_CPP_START_ADDRESS, cpp_dev->base);



		if (ptr_bin) {

			msm_cpp_poll_rx_empty(cpp_dev->base);

	rc = msm_cpp_poll_rx_empty(cpp_dev->base);

	if (rc) {

		pr_err("%s:%d] poll rx empty failed %d",

			__func__, __LINE__, rc);

		goto end;

	}

	for (i = 0; i < cpp_dev->fw->size/4; i++) {

		msm_cpp_write(*ptr_bin, cpp_dev->base);

				if (i % MSM_CPP_RX_FIFO_LEVEL == 0)

					msm_cpp_poll_rx_empty(cpp_dev->base);

				ptr_bin++;

		if (i % MSM_CPP_RX_FIFO_LEVEL == 0) {

			rc = msm_cpp_poll_rx_empty(cpp_dev->base);

			if (rc) {

				pr_err("%s:%d] poll rx empty failed %d",

					__func__, __LINE__, rc);

				goto end;

			}

		}

		ptr_bin++;

	}

	msm_camera_io_w_mb(0x00, cpp_dev->cpp_hw_base + 0xC);

		msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_OK);

		msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_CMD);

	rc = msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_OK);

	if (rc) {

		pr_err("%s:%d] poll command %x failed %d", __func__, __LINE__,

			MSM_CPP_MSG_ID_OK, rc);

		goto end;

	}



	rc = msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_CMD);

	if (rc) {

		pr_err("%s:%d] poll command %x failed %d", __func__, __LINE__,

			MSM_CPP_MSG_ID_CMD, rc);

		goto end;

	}



	/*Trigger MC to jump to start address*/

	msm_cpp_write(MSM_CPP_CMD_EXEC_JUMP, cpp_dev->base);

	msm_cpp_write(MSM_CPP_JUMP_ADDRESS, cpp_dev->base);



	msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_CMD);

	msm_cpp_poll(cpp_dev->base, 0x1);

	msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_JUMP_ACK);

	msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_TRAILER);

	rc = msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_CMD);

	if (rc) {

		pr_err("%s:%d] poll command %x failed %d", __func__, __LINE__,

			MSM_CPP_MSG_ID_CMD, rc);

		goto end;

	}



	rc = msm_cpp_poll(cpp_dev->base, 0x1);

	if (rc) {

		pr_err("%s:%d] poll command 0x1 failed %d", __func__, __LINE__,

			rc);

		goto end;

	}



	rc = msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_JUMP_ACK);

	if (rc) {

		pr_err("%s:%d] poll command %x failed %d", __func__, __LINE__,

			MSM_CPP_MSG_ID_JUMP_ACK, rc);

		goto end;

	}



	rc = msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_TRAILER);

	if (rc) {

		pr_err("%s:%d] poll command %x failed %d", __func__, __LINE__,

			MSM_CPP_MSG_ID_JUMP_ACK, rc);

	}



end:

	return rc;

}



static int cpp_open_node(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
@@ -1621,10 +1694,24 @@ static int msm_cpp_dump_frame_cmd(struct msm_cpp_frame_info_t *frame_info) 
}

#endif



static void msm_cpp_flush_queue_and_release_buffer(struct cpp_device *cpp_dev,

	int queue_len) {

	uint32_t i;



	while (queue_len) {

		msm_cpp_notify_frame_done(cpp_dev, 1);

		queue_len--;

	}

	atomic_set(&cpp_timer.used, 0);

	for (i = 0; i < MAX_CPP_PROCESSING_FRAME; i++)

		cpp_timer.data.processed_frame[i] = NULL;

	cpp_dev->timeout_trial_cnt = 0;

}



static void msm_cpp_do_timeout_work(struct work_struct *work)

{

	uint32_t j = 0, i = 0, i1 = 0, i2 = 0;

	int32_t queue_len = 0;

	int32_t queue_len = 0, rc = 0;

	struct msm_device_queue *queue = NULL;

	struct msm_cpp_frame_info_t *processed_frame[MAX_CPP_PROCESSING_FRAME];

	struct cpp_device *cpp_dev = cpp_timer.data.cpp_dev;
@@ -1636,18 +1723,33 @@ static void msm_cpp_do_timeout_work(struct work_struct *work) 
	if (!work || cpp_timer.data.cpp_dev->state != CPP_STATE_ACTIVE) {

		pr_err("Invalid work:%p or state:%d\n", work,

			cpp_timer.data.cpp_dev->state);

		/* Do not flush queue here as it is not a fatal error */

		goto end;

	}

	if (!atomic_read(&cpp_timer.used)) {

		pr_warn("Delayed trigger, IRQ serviced\n");

		/* Do not flush queue here as it is not a fatal error */

		goto end;

	}





	disable_irq(cpp_timer.data.cpp_dev->irq->start);



	queue = &cpp_timer.data.cpp_dev->processing_q;

	queue_len = queue->len;



	pr_debug("Reloading firmware\n");

	cpp_load_fw(cpp_timer.data.cpp_dev,

	rc = cpp_load_fw(cpp_timer.data.cpp_dev,

		cpp_timer.data.cpp_dev->fw_name_bin);

	pr_warn("Firmware loading done\n");

	if (rc) {

		pr_warn("Firmware loading failed\n");

		cpp_dev->state = CPP_STATE_OFF;

		/* clean buf queue here */

		msm_cpp_flush_queue_and_release_buffer(cpp_dev, queue_len);

		goto end;

	} else {

		pr_debug("Firmware loading done\n");

	}

	enable_irq(cpp_timer.data.cpp_dev->irq->start);

	msm_camera_io_w_mb(0x8, cpp_timer.data.cpp_dev->base +

		MSM_CPP_MICRO_IRQGEN_MASK);
@@ -1657,23 +1759,14 @@ static void msm_cpp_do_timeout_work(struct work_struct *work) 


	if (!atomic_read(&cpp_timer.used)) {

		pr_warn("Delayed trigger, IRQ serviced\n");

		/* Do not flush queue here as it is not a fatal error */

		goto end;

	}



	queue = &cpp_timer.data.cpp_dev->processing_q;

	queue_len = queue->len;



	if (cpp_dev->timeout_trial_cnt >=

		cpp_dev->max_timeout_trial_cnt) {

		pr_warn("Max trial reached\n");

		while (queue_len) {

			msm_cpp_notify_frame_done(cpp_dev, 1);

			queue_len--;

		}

		atomic_set(&cpp_timer.used, 0);

		for (i = 0; i < MAX_CPP_PROCESSING_FRAME; i++)

			cpp_timer.data.processed_frame[i] = NULL;

		cpp_dev->timeout_trial_cnt = 0;

		msm_cpp_flush_queue_and_release_buffer(cpp_dev, queue_len);

		goto end;

	}
@@ -1694,11 +1787,26 @@ static void msm_cpp_do_timeout_work(struct work_struct *work) 
		msm_cpp_write(0x6, cpp_dev->base);

		/* send top level and plane level */

		for (j = 0; j < cpp_dev->payload_params.stripe_base; j++) {

			if (j % MSM_CPP_RX_FIFO_LEVEL == 0)

				msm_cpp_poll_rx_empty(cpp_dev->base);

			if (j % MSM_CPP_RX_FIFO_LEVEL == 0) {

				rc = msm_cpp_poll_rx_empty(cpp_dev->base);

				if (rc) {

					pr_err("%s:%d] poll failed %d rc %d",

						__func__, __LINE__, j, rc);

					goto end;

				}

			}

			msm_cpp_write(processed_frame[i]->cpp_cmd_msg[j],

				cpp_dev->base);

		}

		if (rc) {

			pr_err("%s: Rescheduling plane info failed %d\n",

				__func__, rc);

			/* flush the queue */

			msm_cpp_flush_queue_and_release_buffer(cpp_dev,

				queue_len);

			cpp_dev->state = CPP_STATE_OFF;

			goto end;

		}

		/* send stripes */

		i1 = cpp_dev->payload_params.stripe_base +

			cpp_dev->payload_params.stripe_size *
@@ -1707,11 +1815,26 @@ static void msm_cpp_do_timeout_work(struct work_struct *work) 
			(processed_frame[i]->last_stripe_index -

			processed_frame[i]->first_stripe_index + 1);

		for (j = 0; j < i2; j++) {

			if (j % MSM_CPP_RX_FIFO_LEVEL == 0)

				msm_cpp_poll_rx_empty(cpp_dev->base);

			if (j % MSM_CPP_RX_FIFO_LEVEL == 0) {

				rc = msm_cpp_poll_rx_empty(cpp_dev->base);

				if (rc) {

					pr_err("%s:%d] poll failed %d rc %d",

						__func__, __LINE__, j, rc);

					break;

				}

			}

			msm_cpp_write(processed_frame[i]->cpp_cmd_msg[j+i1],

				cpp_dev->base);

		}

		if (rc) {

			pr_err("%s:%d] Rescheduling stripe info failed %d\n",

				__func__, __LINE__, rc);

			/* flush the queue */

			msm_cpp_flush_queue_and_release_buffer(cpp_dev,

				queue_len);

			cpp_dev->state = CPP_STATE_OFF;

			goto end;

		}

		/* send trailer */

		msm_cpp_write(0xabcdefaa, cpp_dev->base);

		pr_debug("After frame:%d write\n", i+1);
@@ -1768,11 +1891,19 @@ static int msm_cpp_send_frame_to_hardware(struct cpp_device *cpp_dev, 
		msm_cpp_write(0x6, cpp_dev->base);

		/* send top level and plane level */

		for (i = 0; i < cpp_dev->payload_params.stripe_base; i++) {

			if (i % MSM_CPP_RX_FIFO_LEVEL == 0)

				msm_cpp_poll_rx_empty(cpp_dev->base);

			if (i % MSM_CPP_RX_FIFO_LEVEL == 0) {

				rc = msm_cpp_poll_rx_empty(cpp_dev->base);

				if (rc)

					break;

			}

			msm_cpp_write(process_frame->cpp_cmd_msg[i],

				cpp_dev->base);

		}

		if (rc) {

			pr_err("%s: Rescheduling plane info failed %d\n",

				__func__, rc);

			goto end;

		}

		/* send stripes */

		i1 = cpp_dev->payload_params.stripe_base +

			cpp_dev->payload_params.stripe_size *
@@ -1781,17 +1912,26 @@ static int msm_cpp_send_frame_to_hardware(struct cpp_device *cpp_dev, 
			(process_frame->last_stripe_index -

			process_frame->first_stripe_index + 1);

		for (i = 0; i < i2; i++) {

			if (i % MSM_CPP_RX_FIFO_LEVEL == 0)

				msm_cpp_poll_rx_empty(cpp_dev->base);

			if (i % MSM_CPP_RX_FIFO_LEVEL == 0) {

				rc = msm_cpp_poll_rx_empty(cpp_dev->base);

				if (rc)

					break;

			}

			msm_cpp_write(process_frame->cpp_cmd_msg[i+i1],

				cpp_dev->base);

		}

		if (rc) {

			pr_err("%s: Rescheduling stripe info failed %d\n",

				__func__, rc);

			goto end;

		}

		/* send trailer */

		msm_cpp_write(MSM_CPP_MSG_ID_TRAILER, cpp_dev->base);



		do_gettimeofday(&(process_frame->in_time));

		rc = 0;

	}

end:

	if (rc < 0)

		pr_err("process queue full. drop frame\n");

	return rc;
@@ -2173,6 +2313,12 @@ static int msm_cpp_cfg_frame(struct cpp_device *cpp_dev, 
		pr_err("%s: Frame is Null\n", __func__);

		return -EINVAL;

	}



	if (cpp_dev->state == CPP_STATE_OFF) {

		pr_err("%s: cpp state is off, return fatal error\n", __func__);

		return -EINVAL;

	}



	cpp_frame_msg = new_frame->cpp_cmd_msg;



	if (cpp_frame_msg == NULL ||
@@ -2485,8 +2631,10 @@ static int msm_cpp_copy_from_ioctl_ptr(void *dst_ptr, 
}

#endif



static void msm_cpp_fw_version(struct cpp_device *cpp_dev)

static int32_t msm_cpp_fw_version(struct cpp_device *cpp_dev)

{

	int32_t rc = 0;



	/*Get Firmware Version*/

	msm_cpp_write(MSM_CPP_CMD_GET_FW_VER, cpp_dev->base);

	msm_cpp_write(MSM_CPP_MSG_ID_CMD, cpp_dev->base);
@@ -2494,12 +2642,37 @@ static void msm_cpp_fw_version(struct cpp_device *cpp_dev) 
	msm_cpp_write(MSM_CPP_CMD_GET_FW_VER, cpp_dev->base);

	msm_cpp_write(MSM_CPP_MSG_ID_TRAILER, cpp_dev->base);



	msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_CMD);

	msm_cpp_poll(cpp_dev->base, 0x2);

	msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_FW_VER);

	rc = msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_CMD);

	if (rc) {

		pr_err("%s:%d] poll command %x failed %d", __func__, __LINE__,

			MSM_CPP_MSG_ID_CMD, rc);

		goto end;

	}

	rc = msm_cpp_poll(cpp_dev->base, 0x2);

	if (rc) {

		pr_err("%s:%d] poll command 0x2 failed %d", __func__, __LINE__,

			rc);

		goto end;

	}

	rc = msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_FW_VER);

	if (rc) {

		pr_err("%s:%d] poll command %x failed %d", __func__, __LINE__,

			MSM_CPP_MSG_ID_FW_VER, rc);

		goto end;

	}



	cpp_dev->fw_version = msm_cpp_read(cpp_dev->base);

	pr_info("CPP FW Version: 0x%08x\n", cpp_dev->fw_version);

	msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_TRAILER);

	pr_debug("CPP FW Version: 0x%08x\n", cpp_dev->fw_version);



	rc = msm_cpp_poll(cpp_dev->base, MSM_CPP_MSG_ID_TRAILER);

	if (rc) {

		pr_err("%s:%d] poll command %x failed %d", __func__, __LINE__,

			MSM_CPP_MSG_ID_TRAILER, rc);

	}



end:



	return rc;

}



static int msm_cpp_validate_input(unsigned int cmd, void *arg,
@@ -2548,6 +2721,7 @@ long msm_cpp_subdev_ioctl(struct v4l2_subdev *sd, 
		return rc;

	}

	mutex_lock(&cpp_dev->mutex);



	CPP_DBG("E cmd: 0x%x\n", cmd);

	switch (cmd) {

	case VIDIOC_MSM_CPP_GET_HW_INFO: {
@@ -2619,8 +2793,20 @@ long msm_cpp_subdev_ioctl(struct v4l2_subdev *sd, 
				return -EINVAL;

			}

			disable_irq(cpp_dev->irq->start);

			cpp_load_fw(cpp_dev, cpp_dev->fw_name_bin);

			msm_cpp_fw_version(cpp_dev);

			rc = cpp_load_fw(cpp_dev, cpp_dev->fw_name_bin);

			if (rc < 0) {

				pr_err("%s: load firmware failure %d\n",

					__func__, rc);

				enable_irq(cpp_dev->irq->start);

				return rc;

			}

			rc = msm_cpp_fw_version(cpp_dev);

			if (rc < 0) {

				pr_err("%s: get firmware failure %d\n",

					__func__, rc);

				enable_irq(cpp_dev->irq->start);

				return rc;

			}

			enable_irq(cpp_dev->irq->start);

			cpp_dev->is_firmware_loaded = 1;

		}