Merge "msm: camera: cdm: Debug info in case of cdm page fault" into camera-kernel.lnx.3.1 (0ebcb0bb) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/cam_cdm/cam_cdm_core_common.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -204,6 +204,7 @@ void cam_cdm_notify_clients(struct cam_hw_info *cdm_hw,
		} else if (status == CAM_CDM_CB_STATUS_HW_RESET_DONE \|\|
		status == CAM_CDM_CB_STATUS_HW_FLUSH \|\|
		status == CAM_CDM_CB_STATUS_HW_RESUBMIT \|\|
		status == CAM_CDM_CB_STATUS_INVALID_BL_CMD \|\|
		status == CAM_CDM_CB_STATUS_HW_ERROR) {
		int client_idx;
		struct cam_cdm_bl_cb_request_entry *node =

drivers/cam_cdm/cam_cdm_hw_core.c

+145 −112

Original line number	Diff line number	Diff line
		@@ -1056,7 +1056,8 @@ static void cam_hw_cdm_reset_cleanup(
		struct cam_cdm_bl_cb_request_entry node, tnode;
		bool flush_hw = false;

		if (test_bit(CAM_CDM_FLUSH_HW_STATUS, &core->cdm_status))
		if (test_bit(CAM_CDM_ERROR_HW_STATUS, &core->cdm_status) \|\|
		test_bit(CAM_CDM_FLUSH_HW_STATUS, &core->cdm_status))
		flush_hw = true;

		for (i = 0; i < core->offsets->reg_data->num_bl_fifo; i++) {
		@@ -1094,9 +1095,15 @@ static void cam_hw_cdm_work(struct work_struct *work)
		struct cam_hw_info *cdm_hw;
		struct cam_cdm *core;
		int i, fifo_idx;
		struct cam_cdm_bl_cb_request_entry *tnode = NULL;
		struct cam_cdm_bl_cb_request_entry *node = NULL;

		payload = container_of(work, struct cam_cdm_work_payload, work);
		if (payload) {
		if (!payload) {
		CAM_ERR(CAM_CDM, "NULL payload");
		return;
		}

		cdm_hw = payload->hw;
		core = (struct cam_cdm *)cdm_hw->core_info;
		fifo_idx = payload->fifo_idx;
		@@ -1107,17 +1114,16 @@ static void cam_hw_cdm_work(struct work_struct *work)
		payload = NULL;
		return;
		}

		cam_req_mgr_thread_switch_delay_detect(
		payload->workq_scheduled_ts);

		CAM_DBG(CAM_CDM, "IRQ status=0x%x", payload->irq_status);
		if (payload->irq_status &
		CAM_CDM_IRQ_STATUS_INLINE_IRQ_MASK) {
		struct cam_cdm_bl_cb_request_entry node, tnode;

		CAM_DBG(CAM_CDM, "inline IRQ data=0x%x last tag: 0x%x",
		payload->irq_data,
		core->bl_fifo[fifo_idx]
		core->bl_fifo[payload->fifo_idx]
		.last_bl_tag_done);

		if (payload->irq_data == 0xff) {
		@@ -1179,22 +1185,24 @@ static void cam_hw_cdm_work(struct work_struct *work)
		} else {
		CAM_INFO(CAM_CDM,
		"Skip GenIRQ, tag 0x%x fifo %d",
		payload->irq_data, fifo_idx);
		payload->irq_data, payload->fifo_idx);
		}
		mutex_unlock(&core->bl_fifo[fifo_idx]
		mutex_unlock(&core->bl_fifo[payload->fifo_idx]
		.fifo_lock);
		}

		if (payload->irq_status &
		CAM_CDM_IRQ_STATUS_BL_DONE_MASK) {
		if (test_bit(fifo_idx, &core->cdm_status)) {
		if (test_bit(payload->fifo_idx, &core->cdm_status)) {
		CAM_DBG(CAM_CDM, "CDM HW BL done IRQ");
		complete(&core->bl_fifo[fifo_idx]
		complete(&core->bl_fifo[payload->fifo_idx]
		.bl_complete);
		}
		}
		if (payload->irq_status &
		CAM_CDM_IRQ_STATUS_ERRORS) {
		int reset_hw_hdl = 0x0;

		CAM_ERR_RATE_LIMIT(CAM_CDM,
		"CDM Error IRQ status %d\n",
		payload->irq_status);
		@@ -1209,11 +1217,39 @@ static void cam_hw_cdm_work(struct work_struct *work)
		*/
		cam_hw_cdm_pause_core(cdm_hw, true);
		cam_hw_cdm_dump_core_debug_registers(cdm_hw);

		if (payload->irq_status &
		CAM_CDM_IRQ_STATUS_ERROR_INV_CMD_MASK) {
		node = list_first_entry_or_null(
		&core->bl_fifo[payload->fifo_idx].bl_request_list,
		struct cam_cdm_bl_cb_request_entry, entry);

		if (node != NULL) {
		if (node->request_type ==
		CAM_HW_CDM_BL_CB_CLIENT) {
		cam_cdm_notify_clients(cdm_hw,
		CAM_CDM_CB_STATUS_INVALID_BL_CMD,
		(void *)node);
		} else if (node->request_type ==
		CAM_HW_CDM_BL_CB_INTERNAL) {
		CAM_ERR(CAM_CDM,
		"Invalid node=%pK %d", node,
		node->request_type);
		}
		list_del_init(&node->entry);
		kfree(node);
		}
		}
		/* Resume CDM back */
		cam_hw_cdm_pause_core(cdm_hw, false);
		for (i = 0; i < core->offsets->reg_data->num_bl_fifo;
		i++)
		mutex_unlock(&core->bl_fifo[i].fifo_lock);

		if (payload->irq_status &
		CAM_CDM_IRQ_STATUS_ERROR_INV_CMD_MASK)
		cam_hw_cdm_reset_hw(cdm_hw, reset_hw_hdl);

		mutex_unlock(&cdm_hw->hw_mutex);
		if (!(payload->irq_status &
		CAM_CDM_IRQ_STATUS_ERROR_INV_CMD_MASK))
		@@ -1222,9 +1258,6 @@ static void cam_hw_cdm_work(struct work_struct *work)
		}
		kfree(payload);
		payload = NULL;
		} else {
		CAM_ERR(CAM_CDM, "NULL payload");
		}

		}

drivers/cam_cdm/cam_cdm_intf_api.h

+37 −0

Original line number	Diff line number	Diff line
		@@ -10,6 +10,8 @@
		#include "cam_cdm_util.h"
		#include "cam_soc_util.h"

		#define CAM_CDM_BL_CMD_MAX 25

		/* enum cam_cdm_id - Enum for possible CAM CDM hardwares */
		enum cam_cdm_id {
		CAM_CDM_VIRTUAL,
		@@ -150,6 +152,41 @@ struct cam_cdm_bl_request {
		struct cam_cdm_bl_cmd cmd[1];
		};

		/**
		* struct cam_cdm_bl_data - last submiited CDM BL data
		*
		* @mem_handle : Input mem handle of bl cmd
		* @hw_addr : Hw address of submitted Bl command
		* @offset : Input offset of the actual bl cmd in the memory pointed
		* by mem_handle
		* @len : length of submitted Bl command to CDM.
		* @input_len : Input length of the BL command, Cannot be more than 1MB and
		* this is will be validated with offset+size of the memory pointed
		* by mem_handle
		* @type : CDM bl cmd addr types.
		*/
		struct cam_cdm_bl_data {
		int32_t mem_handle;
		dma_addr_t hw_addr;
		uint32_t offset;
		size_t len;
		uint32_t input_len;
		enum cam_cdm_bl_cmd_addr_type type;
		};

		/**
		* struct cam_cdm_bl_info
		*
		* @bl_count : No. of Bl commands submiited to CDM.
		* @cmd : payload holding the BL cmd's arrary
		* that is sumbitted.
		*
		*/
		struct cam_cdm_bl_info {
		int32_t bl_count;
		struct cam_cdm_bl_data cmd[CAM_CDM_BL_CMD_MAX];
		};

		/**
		* @brief : API to get the CDM capabilities for a camera device type
		*

drivers/cam_cdm/cam_cdm_util.c

+66 −12

Original line number	Diff line number	Diff line
		@@ -689,25 +689,53 @@ int cam_cdm_util_cmd_buf_write(void __iomem **current_device_base,
		return ret;
		}

		static long cam_cdm_util_dump_dmi_cmd(uint32_t *cmd_buf_addr)
		static long cam_cdm_util_dump_dmi_cmd(uint32_t *cmd_buf_addr,
		uint32_t *cmd_buf_addr_end)
		{
		long ret = 0;
		struct cdm_dmi_cmd *p_dmi_cmd;
		uint32_t *temp_ptr = cmd_buf_addr;

		p_dmi_cmd = (struct cdm_dmi_cmd *)cmd_buf_addr;
		temp_ptr += CDMCmdHeaderSizes[CAM_CDM_CMD_DMI];
		ret += CDMCmdHeaderSizes[CAM_CDM_CMD_DMI];
		CAM_INFO(CAM_CDM, "DMI");

		if (temp_ptr > cmd_buf_addr_end)
		CAM_ERR(CAM_CDM,
		"Invalid cmd start addr:%pK end addr:%pK",
		temp_ptr, cmd_buf_addr_end);

		CAM_INFO(CAM_CDM,
		"DMI: LEN: %u DMIAddr: 0x%X DMISel: 0x%X LUT_addr: 0x%X",
		p_dmi_cmd->length, p_dmi_cmd->DMIAddr,
		p_dmi_cmd->DMISel, p_dmi_cmd->addr);
		return ret;
		}

		static long cam_cdm_util_dump_buff_indirect(uint32_t *cmd_buf_addr)
		static long cam_cdm_util_dump_buff_indirect(uint32_t *cmd_buf_addr,
		uint32_t *cmd_buf_addr_end)
		{
		long ret = 0;
		struct cdm_indirect_cmd *p_indirect_cmd;
		uint32_t *temp_ptr = cmd_buf_addr;

		p_indirect_cmd = (struct cdm_indirect_cmd *)cmd_buf_addr;
		temp_ptr += CDMCmdHeaderSizes[CAM_CDM_CMD_BUFF_INDIRECT];
		ret += CDMCmdHeaderSizes[CAM_CDM_CMD_BUFF_INDIRECT];
		CAM_INFO(CAM_CDM, "Buff Indirect");

		if (temp_ptr > cmd_buf_addr_end)
		CAM_ERR(CAM_CDM,
		"Invalid cmd start addr:%pK end addr:%pK",
		temp_ptr, cmd_buf_addr_end);

		CAM_INFO(CAM_CDM,
		"Buff Indirect: LEN: %u addr: 0x%X",
		p_indirect_cmd->length, p_indirect_cmd->addr);
		return ret;
		}

		static long cam_cdm_util_dump_reg_cont_cmd(uint32_t *cmd_buf_addr)
		static long cam_cdm_util_dump_reg_cont_cmd(uint32_t *cmd_buf_addr,
		uint32_t *cmd_buf_addr_end)
		{
		long ret = 0;
		struct cdm_regcontinuous_cmd *p_regcont_cmd;
		@@ -722,6 +750,12 @@ static long cam_cdm_util_dump_reg_cont_cmd(uint32_t *cmd_buf_addr)
		p_regcont_cmd->count, p_regcont_cmd->offset);

		for (i = 0; i < p_regcont_cmd->count; i++) {
		if (temp_ptr > cmd_buf_addr_end) {
		CAM_ERR(CAM_CDM,
		"Invalid cmd(%d) start addr:%pK end addr:%pK",
		i, temp_ptr, cmd_buf_addr_end);
		break;
		}
		CAM_INFO(CAM_CDM, "DATA_%d: 0x%X", i,
		*temp_ptr);
		temp_ptr++;
		@@ -731,7 +765,8 @@ static long cam_cdm_util_dump_reg_cont_cmd(uint32_t *cmd_buf_addr)
		return ret;
		}

		static long cam_cdm_util_dump_reg_random_cmd(uint32_t *cmd_buf_addr)
		static long cam_cdm_util_dump_reg_random_cmd(uint32_t *cmd_buf_addr,
		uint32_t *cmd_buf_addr_end)
		{
		struct cdm_regrandom_cmd *p_regrand_cmd;
		uint32_t *temp_ptr = cmd_buf_addr;
		@@ -746,6 +781,12 @@ static long cam_cdm_util_dump_reg_random_cmd(uint32_t *cmd_buf_addr)
		p_regrand_cmd->count);

		for (i = 0; i < p_regrand_cmd->count; i++) {
		if (temp_ptr > cmd_buf_addr_end) {
		CAM_ERR(CAM_CDM,
		"Invalid cmd(%d) start addr:%pK end addr:%pK",
		i, temp_ptr, cmd_buf_addr_end);
		break;
		}
		CAM_INFO(CAM_CDM, "OFFSET_%d: 0x%X DATA_%d: 0x%X",
		i, *temp_ptr & CAM_CDM_REG_OFFSET_MASK, i,
		*(temp_ptr + 1));
		@@ -778,15 +819,22 @@ static long cam_cdm_util_dump_wait_event_cmd(uint32_t *cmd_buf_addr)
		return ret;
		}

		static long cam_cdm_util_dump_change_base_cmd(uint32_t *cmd_buf_addr)
		static long cam_cdm_util_dump_change_base_cmd(uint32_t *cmd_buf_addr,
		uint32_t *cmd_buf_addr_end)
		{
		long ret = 0;
		struct cdm_changebase_cmd *p_cbase_cmd;
		uint32_t *temp_ptr = cmd_buf_addr;

		p_cbase_cmd = (struct cdm_changebase_cmd *)temp_ptr;
		temp_ptr += CDMCmdHeaderSizes[CAM_CDM_CMD_CHANGE_BASE];
		ret += CDMCmdHeaderSizes[CAM_CDM_CMD_CHANGE_BASE];

		if (temp_ptr > cmd_buf_addr_end)
		CAM_ERR(CAM_CDM,
		"Invalid cmd start addr:%pK end addr:%pK",
		temp_ptr, cmd_buf_addr_end);

		CAM_INFO(CAM_CDM, "CHANGE_BASE: 0x%X",
		p_cbase_cmd->base);

		@@ -808,6 +856,7 @@ void cam_cdm_util_dump_cmd_buf(
		uint32_t cmd_buf_start, uint32_t cmd_buf_end)
		{
		uint32_t *buf_now = cmd_buf_start;
		uint32_t *buf_end = cmd_buf_end;
		uint32_t cmd = 0;

		if (!cmd_buf_start \|\| !cmd_buf_end) {
		@@ -823,16 +872,20 @@ void cam_cdm_util_dump_cmd_buf(
		case CAM_CDM_CMD_DMI:
		case CAM_CDM_CMD_DMI_32:
		case CAM_CDM_CMD_DMI_64:
		buf_now += cam_cdm_util_dump_dmi_cmd(buf_now);
		buf_now += cam_cdm_util_dump_dmi_cmd(buf_now,
		buf_end);
		break;
		case CAM_CDM_CMD_REG_CONT:
		buf_now += cam_cdm_util_dump_reg_cont_cmd(buf_now);
		buf_now += cam_cdm_util_dump_reg_cont_cmd(buf_now,
		buf_end);
		break;
		case CAM_CDM_CMD_REG_RANDOM:
		buf_now += cam_cdm_util_dump_reg_random_cmd(buf_now);
		buf_now += cam_cdm_util_dump_reg_random_cmd(buf_now,
		buf_end);
		break;
		case CAM_CDM_CMD_BUFF_INDIRECT:
		buf_now += cam_cdm_util_dump_buff_indirect(buf_now);
		buf_now += cam_cdm_util_dump_buff_indirect(buf_now,
		buf_end);
		break;
		case CAM_CDM_CMD_GEN_IRQ:
		buf_now += cam_cdm_util_dump_gen_irq_cmd(buf_now);
		@@ -841,7 +894,8 @@ void cam_cdm_util_dump_cmd_buf(
		buf_now += cam_cdm_util_dump_wait_event_cmd(buf_now);
		break;
		case CAM_CDM_CMD_CHANGE_BASE:
		buf_now += cam_cdm_util_dump_change_base_cmd(buf_now);
		buf_now += cam_cdm_util_dump_change_base_cmd(buf_now,
		buf_end);
		break;
		case CAM_CDM_CMD_PERF_CTRL:
		buf_now += cam_cdm_util_dump_perf_ctrl_cmd(buf_now);

drivers/cam_isp/cam_isp_context.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -3626,6 +3626,7 @@ static int __cam_isp_ctx_config_dev_in_top_state(
		req_isp->num_fence_map_in = cfg.num_in_map_entries;
		req_isp->num_acked = 0;
		req_isp->bubble_detected = false;
		req_isp->hw_update_data.packet = packet;

		for (i = 0; i < req_isp->num_fence_map_out; i++) {
		rc = cam_sync_get_obj_ref(req_isp->fence_map_out[i].sync_id);