Merge "Merge commit '0bb03714' into msm-4.9 - PC 141" (94f3fc11) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/media/platform/msm/camera/cam_core/cam_context.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -70,7 +70,7 @@ struct cam_ctx_request {
		uint32_t num_in_map_entries;
		struct cam_hw_fence_map_entry out_map_entries[CAM_CTX_CFG_MAX];
		uint32_t num_out_map_entries;
		uint32_t num_in_acked;
		atomic_t num_in_acked;
		uint32_t num_out_acked;
		int flushed;
		struct cam_context *ctx;

drivers/media/platform/msm/camera/cam_core/cam_context_utils.c

+53 −6

Original line number	Diff line number	Diff line
		@@ -189,8 +189,7 @@ static void cam_context_sync_callback(int32_t sync_obj, int status, void *data)
		return;
		}

		req->num_in_acked++;
		if (req->num_in_acked == req->num_in_map_entries) {
		if (atomic_inc_return(&req->num_in_acked) == req->num_in_map_entries) {
		apply.request_id = req->request_id;
		/*
		* take mutex to ensure that another thread does
		@@ -342,6 +341,7 @@ int32_t cam_context_prepare_dev_to_hw(struct cam_context *ctx,
		req->num_hw_update_entries = cfg.num_hw_update_entries;
		req->num_out_map_entries = cfg.num_out_map_entries;
		req->num_in_map_entries = cfg.num_in_map_entries;
		atomic_set(&req->num_in_acked, 0);
		req->request_id = packet->header.request_id;
		req->status = 1;
		req->req_priv = cfg.priv;
		@@ -492,6 +492,7 @@ int32_t cam_context_flush_ctx_to_hw(struct cam_context *ctx)
		struct cam_ctx_request *req;
		uint32_t i;
		int rc = 0;
		bool free_req;

		CAM_DBG(CAM_CTXT, "[%s] E: NRT flush ctx", ctx->dev_name);

		@@ -528,6 +529,21 @@ int32_t cam_context_flush_ctx_to_hw(struct cam_context *ctx)

		flush_args.flush_req_pending[flush_args.num_req_pending++] =
		req->req_priv;

		free_req = false;
		for (i = 0; i < req->num_in_map_entries; i++) {
		rc = cam_sync_deregister_callback(
		cam_context_sync_callback,
		(void *)req,
		req->in_map_entries[i].sync_id);
		if (!rc) {
		cam_context_putref(ctx);
		if (atomic_inc_return(&req->num_in_acked) ==
		req->num_in_map_entries)
		free_req = true;
		}
		}

		for (i = 0; i < req->num_out_map_entries; i++) {
		if (req->out_map_entries[i].sync_id != -1) {
		rc = cam_sync_signal(
		@@ -543,6 +559,17 @@ int32_t cam_context_flush_ctx_to_hw(struct cam_context *ctx)
		}
		}

		/*
		* If we have deregistered the last sync callback, req will
		* not be put on the free list. So put it on the free list here
		*/
		if (free_req) {
		req->ctx = NULL;
		spin_lock(&ctx->lock);
		list_add_tail(&req->list, &ctx->free_req_list);
		spin_unlock(&ctx->lock);
		}

		if (cam_debug_ctx_req_list & ctx->dev_id)
		CAM_INFO(CAM_CTXT,
		"[%s][%d] : Deleting req[%llu] from temp_list",
		@@ -630,6 +657,7 @@ int32_t cam_context_flush_req_to_hw(struct cam_context *ctx,
		uint32_t i;
		int32_t sync_id = 0;
		int rc = 0;
		bool free_req = false;

		CAM_DBG(CAM_CTXT, "[%s] E: NRT flush req", ctx->dev_name);

		@@ -682,6 +710,22 @@ int32_t cam_context_flush_req_to_hw(struct cam_context *ctx,
		}

		if (req) {
		if (flush_args.num_req_pending) {
		for (i = 0; i < req->num_in_map_entries; i++) {
		rc = cam_sync_deregister_callback(
		cam_context_sync_callback,
		(void *)req,
		req->in_map_entries[i].sync_id);
		if (rc)
		continue;

		cam_context_putref(ctx);
		if (atomic_inc_return(&req->num_in_acked) ==
		req->num_in_map_entries)
		free_req = true;
		}
		}

		if (flush_args.num_req_pending \|\| flush_args.num_req_active) {
		for (i = 0; i < req->num_out_map_entries; i++) {
		sync_id =
		@@ -697,17 +741,20 @@ int32_t cam_context_flush_req_to_hw(struct cam_context *ctx,
		}
		}
		}
		if (flush_args.num_req_active) {
		if (flush_args.num_req_active \|\| free_req) {
		req->ctx = NULL;
		spin_lock(&ctx->lock);
		list_add_tail(&req->list, &ctx->free_req_list);
		spin_unlock(&ctx->lock);
		req->ctx = NULL;

		if (cam_debug_ctx_req_list & ctx->dev_id)
		CAM_INFO(CAM_CTXT,
		"[%s][%d] : Moving req[%llu] from active_list to free_list",
		"[%s][%d] : Moving req[%llu] from %s to free_list",
		ctx->dev_name, ctx->ctx_id,
		req->request_id);
		req->request_id,
		flush_args.num_req_active ?
		"active_list" :
		"pending_list");
		}
		}
		}

drivers/media/platform/msm/camera/cam_icp/icp_hw/icp_hw_mgr/cam_icp_hw_mgr.c

+3 −1

Original line number	Diff line number	Diff line
		@@ -57,6 +57,8 @@
		#define ICP_DEV_TYPE_TO_CLK_TYPE(dev_type) \
		((dev_type == CAM_ICP_RES_TYPE_BPS) ? ICP_CLK_HW_BPS : ICP_CLK_HW_IPE)

		#define ICP_DEVICE_IDLE_TIMEOUT 400

		static struct cam_icp_hw_mgr icp_hw_mgr;

		static int cam_icp_send_ubwc_cfg(struct cam_icp_hw_mgr *hw_mgr)
		@@ -549,7 +551,7 @@ static int cam_icp_device_timer_start(struct cam_icp_hw_mgr *hw_mgr)
		for (i = 0; i < ICP_CLK_HW_MAX; i++) {
		if (!hw_mgr->clk_info[i].watch_dog) {
		rc = crm_timer_init(&hw_mgr->clk_info[i].watch_dog,
		3000, &hw_mgr->clk_info[i],
		ICP_DEVICE_IDLE_TIMEOUT, &hw_mgr->clk_info[i],
		&cam_icp_device_timer_cb);

		if (rc)

drivers/media/platform/msm/camera/cam_isp/cam_isp_context.c

+55 −6

Original line number	Diff line number	Diff line
		@@ -447,6 +447,33 @@ static int __cam_isp_ctx_handle_buf_done_in_activated_state(
		return rc;
		}

		static void __cam_isp_ctx_send_sof_boot_timestamp(
		struct cam_isp_context *ctx_isp, uint64_t request_id,
		uint32_t sof_event_status)
		{
		struct cam_req_mgr_message req_msg;

		req_msg.session_hdl = ctx_isp->base->session_hdl;
		req_msg.u.frame_msg.frame_id = ctx_isp->frame_id;
		req_msg.u.frame_msg.request_id = request_id;
		req_msg.u.frame_msg.timestamp = ctx_isp->boot_timestamp;
		req_msg.u.frame_msg.link_hdl = ctx_isp->base->link_hdl;
		req_msg.u.frame_msg.sof_status = sof_event_status;

		CAM_DBG(CAM_ISP,
		"request id:%lld frame number:%lld boot time stamp:0x%llx",
		request_id, ctx_isp->frame_id,
		ctx_isp->boot_timestamp);

		if (cam_req_mgr_notify_message(&req_msg,
		V4L_EVENT_CAM_REQ_MGR_SOF_BOOT_TS,
		V4L_EVENT_CAM_REQ_MGR_EVENT))
		CAM_ERR(CAM_ISP,
		"Error in notifying the boot time for req id:%lld",
		request_id);
		}


		static void __cam_isp_ctx_send_sof_timestamp(
		struct cam_isp_context *ctx_isp, uint64_t request_id,
		uint32_t sof_event_status)
		@@ -471,6 +498,10 @@ static void __cam_isp_ctx_send_sof_timestamp(
		CAM_ERR(CAM_ISP,
		"Error in notifying the sof time for req id:%lld",
		request_id);

		__cam_isp_ctx_send_sof_boot_timestamp(ctx_isp,
		request_id, sof_event_status);

		}

		static int __cam_isp_ctx_reg_upd_in_activated_state(
		@@ -617,6 +648,7 @@ static int __cam_isp_ctx_sof_in_activated_state(

		ctx_isp->frame_id++;
		ctx_isp->sof_timestamp_val = sof_event_data->timestamp;
		ctx_isp->boot_timestamp = sof_event_data->boot_time;
		__cam_isp_ctx_update_state_monitor_array(ctx_isp,
		CAM_ISP_STATE_CHANGE_TRIGGER_SOF, req->request_id);
		CAM_DBG(CAM_ISP, "frame id: %lld time stamp:0x%llx",
		@@ -773,6 +805,7 @@ static int __cam_isp_ctx_sof_in_epoch(struct cam_isp_context *ctx_isp,

		ctx_isp->frame_id++;
		ctx_isp->sof_timestamp_val = sof_event_data->timestamp;
		ctx_isp->boot_timestamp = sof_event_data->boot_time;

		if (list_empty(&ctx->active_req_list))
		ctx_isp->substate_activated = CAM_ISP_CTX_ACTIVATED_SOF;
		@@ -1045,6 +1078,7 @@ static int __cam_isp_ctx_sof_in_flush(
		}
		ctx_isp->frame_id++;
		ctx_isp->sof_timestamp_val = sof_event_data->timestamp;
		ctx_isp->boot_timestamp = sof_event_data->boot_time;
		CAM_DBG(CAM_ISP, "frame id: %lld time stamp:0x%llx",
		ctx_isp->frame_id, ctx_isp->sof_timestamp_val);

		@@ -1470,6 +1504,8 @@ static int __cam_isp_ctx_rdi_only_sof_in_top_state(

		ctx_isp->frame_id++;
		ctx_isp->sof_timestamp_val = sof_event_data->timestamp;
		ctx_isp->boot_timestamp = sof_event_data->boot_time;

		CAM_DBG(CAM_ISP, "frame id: %lld time stamp:0x%llx",
		ctx_isp->frame_id, ctx_isp->sof_timestamp_val);

		@@ -1523,6 +1559,7 @@ static int __cam_isp_ctx_rdi_only_sof_in_applied_state(

		ctx_isp->frame_id++;
		ctx_isp->sof_timestamp_val = sof_event_data->timestamp;
		ctx_isp->boot_timestamp = sof_event_data->boot_time;
		CAM_DBG(CAM_ISP, "frame id: %lld time stamp:0x%llx",
		ctx_isp->frame_id, ctx_isp->sof_timestamp_val);

		@@ -1554,6 +1591,7 @@ static int __cam_isp_ctx_rdi_only_sof_in_bubble_applied(

		ctx_isp->frame_id++;
		ctx_isp->sof_timestamp_val = sof_event_data->timestamp;
		ctx_isp->boot_timestamp = sof_event_data->boot_time;
		CAM_DBG(CAM_ISP, "frame id: %lld time stamp:0x%llx",
		ctx_isp->frame_id, ctx_isp->sof_timestamp_val);

		@@ -1639,6 +1677,7 @@ static int __cam_isp_ctx_rdi_only_sof_in_bubble_state(

		ctx_isp->frame_id++;
		ctx_isp->sof_timestamp_val = sof_event_data->timestamp;
		ctx_isp->boot_timestamp = sof_event_data->boot_time;
		CAM_DBG(CAM_ISP, "frame id: %lld time stamp:0x%llx",
		ctx_isp->frame_id, ctx_isp->sof_timestamp_val);
		/*
		@@ -1701,6 +1740,7 @@ static int __cam_isp_ctx_rdi_only_reg_upd_in_bubble_applied_state(
		struct cam_req_mgr_trigger_notify notify;
		uint64_t request_id = 0;

		ctx_isp->substate_activated = CAM_ISP_CTX_ACTIVATED_EPOCH;
		/* notify reqmgr with sof signal*/
		if (ctx->ctx_crm_intf && ctx->ctx_crm_intf->notify_trigger) {
		if (list_empty(&ctx->pending_req_list)) {
		@@ -1712,13 +1752,19 @@ static int __cam_isp_ctx_rdi_only_reg_upd_in_bubble_applied_state(
		list_del_init(&req->list);

		req_isp = (struct cam_isp_ctx_req *) req->req_priv;
		request_id = req->request_id;
		request_id =
		(req_isp->hw_update_data.packet_opcode_type ==
		CAM_ISP_PACKET_INIT_DEV) ?
		0 : req->request_id;

		if (req_isp->num_fence_map_out != 0) {
		list_add_tail(&req->list, &ctx->active_req_list);
		ctx_isp->active_req_cnt++;
		CAM_DBG(CAM_ISP,
		"move request %lld to active list(cnt = %d)",
		req->request_id, ctx_isp->active_req_cnt);
		/* if packet has buffers, set correct request id */
		request_id = req->request_id;
		} else {
		/* no io config, so the request is completed. */
		list_add_tail(&req->list, &ctx->free_req_list);
		@@ -1738,10 +1784,11 @@ static int __cam_isp_ctx_rdi_only_reg_upd_in_bubble_applied_state(
		} else {
		CAM_ERR(CAM_ISP, "Can not notify SOF to CRM");
		}
		if (request_id)
		ctx_isp->reported_req_id = request_id;

		__cam_isp_ctx_send_sof_timestamp(ctx_isp, request_id,
		CAM_REQ_MGR_SOF_EVENT_SUCCESS);

		ctx_isp->substate_activated = CAM_ISP_CTX_ACTIVATED_EPOCH;
		CAM_DBG(CAM_ISP, "next substate %d", ctx_isp->substate_activated);

		return 0;
		@@ -2042,7 +2089,7 @@ static int __cam_isp_ctx_config_dev_in_top_state(
		req->request_id = packet->header.request_id;
		req->status = 1;

		CAM_DBG(CAM_ISP, "Packet request id 0x%llx packet opcode:%d",
		CAM_DBG(CAM_ISP, "Packet request id %lld packet opcode:%d",
		packet->header.request_id,
		req_isp->hw_update_data.packet_opcode_type);

		@@ -2185,6 +2232,7 @@ static int __cam_isp_ctx_acquire_dev_in_available(struct cam_context *ctx,
		cam_isp_ctx_activated_state_machine;
		}

		ctx_isp->rdi_only_context = hw_cmd_args.u.is_rdi_only_context;
		ctx_isp->hw_ctx = param.ctxt_to_hw_map;

		req_hdl_param.session_hdl = cmd->session_handle;
		@@ -2330,7 +2378,8 @@ static int __cam_isp_ctx_start_dev_in_ready(struct cam_context *ctx,
		ctx_isp->frame_id = 0;
		ctx_isp->active_req_cnt = 0;
		ctx_isp->reported_req_id = 0;
		ctx_isp->substate_activated = CAM_ISP_CTX_ACTIVATED_SOF;
		ctx_isp->substate_activated = ctx_isp->rdi_only_context ?
		CAM_ISP_CTX_ACTIVATED_APPLIED : CAM_ISP_CTX_ACTIVATED_SOF;

		/*
		* Only place to change state before calling the hw due to

drivers/media/platform/msm/camera/cam_isp/cam_isp_context.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -149,6 +149,7 @@ struct cam_isp_context_state_monitor {
		* @req_isp: ISP private request object storage
		* @hw_ctx: HW object returned by the acquire device command
		* @sof_timestamp_val: Captured time stamp value at sof hw event
		* @boot_timestamp: Boot time stamp for a given req_id
		* @active_req_cnt: Counter for the active request
		* @reported_req_id: Last reported request id
		* @subscribe_event: The irq event mask that CRM subscribes to, IFE
		@@ -157,6 +158,8 @@ struct cam_isp_context_state_monitor {
		* @frame_skip_count: Number of frame to skip before change state
		* @state_monitor_head: Write index to the state monitoring array
		* @cam_isp_ctx_state_monitor: State monitoring array
		* @rdi_only_context: Get context type information.
		* true, if context is rdi only context
		*
		*/
		struct cam_isp_context {
		@@ -172,6 +175,7 @@ struct cam_isp_context {

		void *hw_ctx;
		uint64_t sof_timestamp_val;
		uint64_t boot_timestamp;
		int32_t active_req_cnt;
		int64_t reported_req_id;
		uint32_t subscribe_event;
		@@ -180,6 +184,7 @@ struct cam_isp_context {
		atomic64_t state_monitor_head;
		struct cam_isp_context_state_monitor cam_isp_ctx_state_monitor[
		CAM_ISP_CTX_STATE_MONITOR_MAX_ENTRIES];
		bool rdi_only_context;
		};

		/**