Merge "msm: vidc: Handle max clients error from video hardware" (700c5d87) · Commits · e / devices / android_kernel_sony_msm8994

drivers/media/platform/msm/vidc/hfi_response_handler.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -222,6 +222,7 @@ static void hfi_process_session_error(
		struct msm_vidc_cb_cmd_done cmd_done = {0};
		cmd_done.device_id = device_id;
		cmd_done.session_id = session->session_id;
		cmd_done.status = hfi_map_err_status(pkt->event_data1);
		dprintk(VIDC_INFO, "Received : SESSION_ERROR with event id : %d\n",
		pkt->event_data1);
		switch (pkt->event_data1) {
		@@ -229,6 +230,7 @@ static void hfi_process_session_error(
		case HFI_ERR_SESSION_UNSUPPORT_BUFFERTYPE:
		case HFI_ERR_SESSION_UNSUPPORTED_SETTING:
		case HFI_ERR_SESSION_UPSCALE_NOT_SUPPORTED:
		cmd_done.status = VIDC_ERR_NONE;
		dprintk(VIDC_INFO, "Non Fatal : HFI_EVENT_SESSION_ERROR\n");
		break;
		default:
		@@ -899,11 +901,9 @@ static void hfi_process_session_init_done(
		cmd_done.status = hfi_process_sess_init_done_prop_read(
		pkt, &session_init_done);
		} else if (session) {
		dprintk(VIDC_INFO,
		"Sess init failed: Deleting session: 0x%p 0x%p\n",
		dprintk(VIDC_WARN,
		"Sess init failed: 0x%p, 0x%p\n",
		session->session_id, session);
		list_del(&session->list);
		kfree(session);
		}
		cmd_done.size = sizeof(struct vidc_hal_session_init_done);
		callback(SESSION_INIT_DONE, &cmd_done);

drivers/media/platform/msm/vidc/msm_vidc_common.c

+32 −22

Original line number	Diff line number	Diff line
		@@ -47,6 +47,7 @@ struct getprop_buf {

		static void msm_comm_generate_session_error(struct msm_vidc_inst *inst);
		static void msm_comm_generate_sys_error(struct msm_vidc_inst *inst);
		static void handle_session_error(enum command_response cmd, void *data);

		static inline bool is_turbo_session(struct msm_vidc_inst *inst)
		{
		@@ -551,17 +552,17 @@ void msm_vidc_queue_v4l2_event(struct msm_vidc_inst *inst, int event_type)

		static void msm_comm_generate_max_clients_error(struct msm_vidc_inst *inst)
		{
		enum command_response cmd = SESSION_ERROR;
		struct msm_vidc_cb_cmd_done response = {0};

		if (!inst) {
		dprintk(VIDC_ERR, "%s: invalid input parameters\n", __func__);
		return;
		}
		mutex_lock(&inst->sync_lock);
		inst->session = NULL;
		inst->state = MSM_VIDC_CORE_INVALID;
		msm_vidc_queue_v4l2_event(inst, V4L2_EVENT_MSM_VIDC_MAX_CLIENTS);
		dprintk(VIDC_ERR,
		"%s: Too many clients\n", __func__);
		mutex_unlock(&inst->sync_lock);
		dprintk(VIDC_ERR, "%s: Too many clients\n", __func__);
		response.session_id = inst;
		response.status = VIDC_ERR_MAX_CLIENTS;
		handle_session_error(cmd, (void *)&response);
		}

		static void handle_session_init_done(enum command_response cmd, void *data)
		@@ -963,19 +964,30 @@ static void handle_session_error(enum command_response cmd, void *data)

		hdev = inst->core->device;
		dprintk(VIDC_WARN, "Session error received for session %p\n", inst);
		change_inst_state(inst, MSM_VIDC_CORE_INVALID);

		mutex_lock(&inst->sync_lock);
		inst->state = MSM_VIDC_CORE_INVALID;

		mutex_lock(&inst->lock);
		dprintk(VIDC_DBG, "cleaning up inst: %p\n", inst);
		rc = call_hfi_op(hdev, session_clean, inst->session);
		if (rc)
		dprintk(VIDC_ERR, "Session (%p) clean failed: %d\n", inst, rc);

		inst->session = NULL;
		mutex_unlock(&inst->sync_lock);
		mutex_unlock(&inst->lock);

		msm_vidc_queue_v4l2_event(inst, V4L2_EVENT_MSM_VIDC_SYS_ERROR);
		if (response->status == VIDC_ERR_MAX_CLIENTS) {
		dprintk(VIDC_WARN,
		"send max clients reached error to client: %p\n",
		inst);
		msm_vidc_queue_v4l2_event(inst,
		V4L2_EVENT_MSM_VIDC_MAX_CLIENTS);
		} else {
		dprintk(VIDC_ERR,
		"send session error to client: %p\n",
		inst);
		msm_vidc_queue_v4l2_event(inst,
		V4L2_EVENT_MSM_VIDC_SYS_ERROR);
		}
		}

		struct sys_err_handler_data {
		@@ -2986,9 +2998,8 @@ int msm_comm_release_scratch_buffers(struct msm_vidc_inst *inst)
		rc = wait_for_sess_signal_receipt(inst,
		SESSION_RELEASE_BUFFER_DONE);
		if (rc) {
		mutex_lock(&inst->sync_lock);
		inst->state = MSM_VIDC_CORE_INVALID;
		mutex_unlock(&inst->sync_lock);
		change_inst_state(inst,
		MSM_VIDC_CORE_INVALID);
		msm_comm_kill_session(inst);
		}
		mutex_lock(&inst->lock);
		@@ -3056,9 +3067,8 @@ int msm_comm_release_persist_buffers(struct msm_vidc_inst *inst)
		rc = wait_for_sess_signal_receipt(inst,
		SESSION_RELEASE_BUFFER_DONE);
		if (rc) {
		mutex_lock(&inst->sync_lock);
		inst->state = MSM_VIDC_CORE_INVALID;
		mutex_unlock(&inst->sync_lock);
		change_inst_state(inst,
		MSM_VIDC_CORE_INVALID);
		msm_comm_kill_session(inst);
		}
		mutex_lock(&inst->lock);
		@@ -3658,9 +3668,7 @@ int msm_vidc_check_session_supported(struct msm_vidc_inst *inst)
		}
		}
		if (rc) {
		mutex_lock(&inst->sync_lock);
		inst->state = MSM_VIDC_CORE_INVALID;
		mutex_unlock(&inst->sync_lock);
		change_inst_state(inst, MSM_VIDC_CORE_INVALID);
		msm_vidc_queue_v4l2_event(inst,
		V4L2_EVENT_MSM_VIDC_HW_OVERLOAD);
		dprintk(VIDC_WARN,
		@@ -3674,12 +3682,14 @@ static void msm_comm_generate_session_error(struct msm_vidc_inst *inst)
		enum command_response cmd = SESSION_ERROR;
		struct msm_vidc_cb_cmd_done response = {0};

		dprintk(VIDC_WARN, "msm_comm_generate_session_error\n");
		if (!inst \|\| !inst->core) {
		dprintk(VIDC_ERR, "%s: invalid input parameters\n", __func__);
		return;
		}

		response.session_id = inst;
		response.status = VIDC_ERR_FAIL;
		handle_session_error(cmd, (void *)&response);
		}

		@@ -3715,7 +3725,7 @@ int msm_comm_kill_session(struct msm_vidc_inst *inst)
		* the session send session_abort to firmware to clean up and release
		* the session, else just kill the session inside the driver.
		*/
		if (inst->state >= MSM_VIDC_OPEN_DONE \|\|
		if (inst->state >= MSM_VIDC_OPEN_DONE &&
		inst->state < MSM_VIDC_CLOSE_DONE) {
		struct hfi_device *hdev = inst->core->device;
		int abort_completion = SESSION_MSG_INDEX(SESSION_ABORT_DONE);