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

Commit d7af3836 authored by Praneeth Paladugu's avatar Praneeth Paladugu Committed by Matt Wagantall
Browse files

msm: vidc: Remove the redundant command handling 



Both dec_cmd and enc_cmd are for the same purpose and in two
different files. Having them duplicate can cause mismatch of
handling commands. Hence combine them into single function to
remove the unnecessary code.

Change-Id: I788b3653e3eb4e5e8d019baeef0fabfb9d1d6e56
Signed-off-by: default avatarPraneeth Paladugu <ppaladug@codeaurora.org>
parent fc21d98a

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

+4 −16
Original line number Diff line number Diff line
@@ -198,28 +198,16 @@ static int msm_v4l2_decoder_cmd(struct file *file, void *fh, 
				struct v4l2_decoder_cmd *dec)

{

	struct msm_vidc_inst *vidc_inst = get_vidc_inst(file, fh);

	int rc = 0;

	if (dec->cmd == V4L2_DEC_CMD_STOP)

		rc = msm_vidc_release_buffers(vidc_inst,

				V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);

	if (rc)

		dprintk(VIDC_WARN,

			"Failed to release dec output buffers: %d\n", rc);

	return msm_vidc_decoder_cmd((void *)vidc_inst, dec);



	return msm_vidc_comm_cmd((void *)vidc_inst, (union msm_v4l2_cmd *)dec);

}



static int msm_v4l2_encoder_cmd(struct file *file, void *fh,

				struct v4l2_encoder_cmd *enc)

{

	struct msm_vidc_inst *vidc_inst = get_vidc_inst(file, fh);

	int rc = 0;

	if (enc->cmd == V4L2_ENC_CMD_STOP)

		rc = msm_vidc_release_buffers(vidc_inst,

				V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);

	if (rc)

		dprintk(VIDC_WARN,

			"Failed to release enc output buffers: %d\n", rc);

	return msm_vidc_encoder_cmd((void *)vidc_inst, enc);



	return msm_vidc_comm_cmd((void *)vidc_inst, (union msm_v4l2_cmd *)enc);

}

static int msm_v4l2_s_parm(struct file *file, void *fh,

			struct v4l2_streamparm *a)

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

+0 −71
Original line number Diff line number Diff line
@@ -1927,77 +1927,6 @@ static void msm_vdec_buf_queue(struct vb2_buffer *vb) 
		dprintk(VIDC_ERR, "Failed to queue buffer: %d\n", rc);

}



int msm_vdec_cmd(struct msm_vidc_inst *inst, struct v4l2_decoder_cmd *dec)

{

	int rc = 0;

	struct msm_vidc_core *core;



	if (!dec || !inst || !inst->core) {

		dprintk(VIDC_ERR, "%s invalid params\n", __func__);

		return -EINVAL;

	}

	core = inst->core;

	switch (dec->cmd) {

	case V4L2_DEC_QCOM_CMD_FLUSH:

		if (core->state != VIDC_CORE_INVALID &&

			inst->state ==  MSM_VIDC_CORE_INVALID) {

			rc = msm_comm_kill_session(inst);

			if (rc)

				dprintk(VIDC_ERR,

					"Failed to recover from session_error: %d\n",

					rc);

		}

		rc = msm_comm_flush(inst, dec->flags);

		if (rc) {

			dprintk(VIDC_ERR,

					"Failed to flush buffers: %d\n", rc);

		}

		break;

	case V4L2_DEC_CMD_STOP:

		if (core->state != VIDC_CORE_INVALID &&

			inst->state ==  MSM_VIDC_CORE_INVALID) {

			rc = msm_comm_kill_session(inst);

			if (rc)

				dprintk(VIDC_ERR,

					"Failed to recover from session_error: %d\n",

					rc);

		}

		rc = msm_comm_release_scratch_buffers(inst, false);

		if (rc)

			dprintk(VIDC_ERR,

				"Failed to release scratch buffers: %d\n", rc);

		rc = msm_comm_release_persist_buffers(inst);

		if (rc)

			pr_err("Failed to release persist buffers: %d\n", rc);

		if (inst->state == MSM_VIDC_CORE_INVALID ||

			core->state == VIDC_CORE_INVALID) {

			dprintk(VIDC_ERR,

				"Core %p in bad state, Sending CLOSE event\n",

					core);

			msm_vidc_queue_v4l2_event(inst,

					V4L2_EVENT_MSM_VIDC_CLOSE_DONE);

			goto exit;

		}

		rc = msm_comm_try_state(inst, MSM_VIDC_CLOSE_DONE);

		/* Clients rely on this event for joining poll thread.

		 * This event should be returned even if firmware has

		 * failed to respond */

		msm_vidc_queue_v4l2_event(inst, V4L2_EVENT_MSM_VIDC_CLOSE_DONE);

		break;

	default:

		dprintk(VIDC_ERR, "Unknown Decoder Command\n");

		rc = -ENOTSUPP;

		goto exit;

	}

	if (rc) {

		dprintk(VIDC_ERR, "Failed to exec decoder cmd %d\n", dec->cmd);

		goto exit;

	}

exit:

	return rc;

}





static const struct vb2_ops msm_vdec_vb2q_ops = {

	.queue_setup = msm_vdec_queue_setup,

	.start_streaming = msm_vdec_start_streaming,

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

+0 −37
Original line number Diff line number Diff line
@@ -2966,43 +2966,6 @@ int msm_venc_s_ext_ctrl(struct msm_vidc_inst *inst, 
	return rc;

}



int msm_venc_cmd(struct msm_vidc_inst *inst, struct v4l2_encoder_cmd *enc)

{

	int rc = 0;

	struct msm_vidc_core *core;

	core = inst->core;

	switch (enc->cmd) {

	case V4L2_ENC_QCOM_CMD_FLUSH:

		rc = msm_comm_flush(inst, enc->flags);

		break;

	case V4L2_ENC_CMD_STOP:

		if (inst->state == MSM_VIDC_CORE_INVALID ||

			core->state == VIDC_CORE_INVALID) {

			msm_vidc_queue_v4l2_event(inst,

					V4L2_EVENT_MSM_VIDC_CLOSE_DONE);

			return rc;

		}

		rc = msm_comm_release_scratch_buffers(inst, false);

		if (rc)

			dprintk(VIDC_ERR, "Failed to release scratch buf:%d\n",

				rc);

		rc = msm_comm_release_persist_buffers(inst);

		if (rc)

			dprintk(VIDC_ERR, "Failed to release persist buf:%d\n",

				rc);

		rc = msm_comm_try_state(inst, MSM_VIDC_CLOSE_DONE);

		/* Clients rely on this event for joining poll thread.

		 * This event should be returned even if firmware has

		 * failed to respond */

		msm_vidc_queue_v4l2_event(inst, V4L2_EVENT_MSM_VIDC_CLOSE_DONE);

		break;

	}

	if (rc)

		dprintk(VIDC_ERR,

			"Command: %d failed with rc = %d\n", enc->cmd, rc);

	return rc;

}



int msm_venc_querycap(struct msm_vidc_inst *inst, struct v4l2_capability *cap)

{

	if (!inst || !cap) {

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

+0 −26
Original line number Diff line number Diff line
@@ -808,32 +808,6 @@ free_and_unmap: 
}

EXPORT_SYMBOL(msm_vidc_release_buffers);



int msm_vidc_encoder_cmd(void *instance, struct v4l2_encoder_cmd *enc)

{

	struct msm_vidc_inst *inst = instance;

	if (!inst || !inst->core || !enc) {

		dprintk(VIDC_ERR, "%s invalid params\n", __func__);

		return -EINVAL;

	}

	if (inst->session_type == MSM_VIDC_ENCODER)

		return msm_venc_cmd(instance, enc);

	return -EINVAL;

}

EXPORT_SYMBOL(msm_vidc_encoder_cmd);



int msm_vidc_decoder_cmd(void *instance, struct v4l2_decoder_cmd *dec)

{

	struct msm_vidc_inst *inst = instance;

	if (!inst || !inst->core || !dec) {

		dprintk(VIDC_ERR, "%s invalid params\n", __func__);

		return -EINVAL;

	}

	if (inst->session_type == MSM_VIDC_DECODER)

		return msm_vdec_cmd(instance, dec);

	return -EINVAL;

}

EXPORT_SYMBOL(msm_vidc_decoder_cmd);



int msm_vidc_qbuf(void *instance, struct v4l2_buffer *b)

{

	struct msm_vidc_inst *inst = instance;

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

+117 −0
Original line number Diff line number Diff line
@@ -3048,6 +3048,123 @@ exit: 
	return rc;

}



void msm_comm_cleanup_internal_buffers(struct msm_vidc_inst *inst)

{

	struct internal_buf *buf, *dummy;



	dprintk(VIDC_DBG,

		"Inst %p is in bad state. Cleaning internal buffers\n", inst);



	mutex_lock(&inst->internalbufs.lock);

	list_for_each_entry_safe(buf, dummy, &inst->internalbufs.list, list) {

		if (!buf->handle) {

			dprintk(VIDC_ERR, "%s - buf->handle NULL\n", __func__);

			continue;

		}

		list_del(&buf->list);

		msm_comm_smem_free(inst, buf->handle);

		kfree(buf);

	}

	mutex_unlock(&inst->internalbufs.lock);



	mutex_lock(&inst->persistbufs.lock);

	list_for_each_entry_safe(buf, dummy, &inst->persistbufs.list, list) {

		if (!buf->handle) {

			dprintk(VIDC_ERR, "%s - buf->handle NULL\n", __func__);

			continue;

		}

		list_del(&buf->list);

		msm_comm_smem_free(inst, buf->handle);

		kfree(buf);

	}

	mutex_unlock(&inst->persistbufs.lock);



	return;

}



int msm_vidc_comm_cmd(void *instance, union msm_v4l2_cmd *cmd)

{

	struct msm_vidc_inst *inst = instance;

	struct v4l2_decoder_cmd *dec;

	struct v4l2_encoder_cmd *enc;

	struct msm_vidc_core *core;

	int which_cmd = 0, flags = 0, rc = 0;



	if (!inst || !inst->core || !cmd) {

		dprintk(VIDC_ERR, "%s invalid params\n", __func__);

		return -EINVAL;

	}

	core = inst->core;

	if (inst->session_type == MSM_VIDC_ENCODER) {

		enc = (struct v4l2_encoder_cmd *)cmd;

		which_cmd = enc->cmd;

		flags = enc->flags;

	} else if (inst->session_type == MSM_VIDC_DECODER) {

		dec = (struct v4l2_decoder_cmd *)cmd;

		which_cmd = dec->cmd;

		flags = dec->flags;

	}



	rc = msm_vidc_release_buffers(inst,

		V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);



	switch (which_cmd) {

	case V4L2_DEC_QCOM_CMD_FLUSH:

		if (core->state != VIDC_CORE_INVALID &&

			inst->state ==  MSM_VIDC_CORE_INVALID) {

			rc = msm_comm_kill_session(inst);

			if (rc)

				dprintk(VIDC_ERR,

					"Fail to clean session: %d\n",

					rc);

		}

		rc = msm_comm_flush(inst, flags);

		if (rc) {

			dprintk(VIDC_ERR,

				"Failed to flush buffers: %d\n", rc);

		}

		break;

	case V4L2_ENC_CMD_STOP:

		if (core->state != VIDC_CORE_INVALID &&

				inst->state ==  MSM_VIDC_CORE_INVALID) {

			rc = msm_comm_kill_session(inst);

			if (rc)

				dprintk(VIDC_ERR,

					"Failed to clean session: %d\n",

					rc);

			msm_comm_cleanup_internal_buffers(inst);

			msm_vidc_queue_v4l2_event(inst,

				V4L2_EVENT_MSM_VIDC_CLOSE_DONE);

			goto exit;

		}



		rc = msm_comm_release_scratch_buffers(inst, false);

		if (rc)

			dprintk(VIDC_ERR,

				"Failed to release scratch buffers: %d\n", rc);

		rc = msm_comm_release_persist_buffers(inst);

		if (rc)

			dprintk(VIDC_ERR,

				"Failed to release persist buffers: %d\n", rc);

		rc = msm_comm_try_state(inst, MSM_VIDC_CLOSE_DONE);



		/*

		 * Clients rely on this event for joining poll thread.

		 * This event should be returned even if firmware has

		 * failed to respond.

		 */



		msm_vidc_queue_v4l2_event(inst, V4L2_EVENT_MSM_VIDC_CLOSE_DONE);

		break;

	default:

		dprintk(VIDC_ERR, "Unknown Command %d\n", which_cmd);

		rc = -ENOTSUPP;

		break;

	}

exit:

	return rc;

}



int msm_comm_qbuf(struct vb2_buffer *vb)

{

	int rc = 0;