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

Commit 228794d0 authored by George Shen's avatar George Shen
Browse files

msm: cvp: Remove deprecated old synx usage 



Remove redundant un-used code.

Change-Id: I3e2d37c464833371f0fd62c8c1c31f58317fbee7
Signed-off-by: default avatarGeorge Shen <sqiao@codeaurora.org>
parent 7b61e61f

drivers/media/platform/msm/cvp/msm_cvp.c

+10 −85
Original line number Diff line number Diff line
@@ -279,70 +279,6 @@ static bool cvp_fence_wait(struct cvp_fence_queue *q, 
	return true;

}



static int cvp_fence_dme(struct msm_cvp_inst *inst,

			struct cvp_fence_command *fc,

			struct cvp_hfi_cmd_session_hdr *pkt)

{

	int rc = 0;

	unsigned long timeout;

	u64 ktid;

	int synx_state = SYNX_STATE_SIGNALED_SUCCESS;

	struct cvp_hfi_device *hdev;

	struct cvp_session_queue *sq;

	u32 hfi_err = HFI_ERR_NONE;

	struct cvp_hfi_msg_session_hdr *hdr;



	dprintk(CVP_SYNX, "%s %s\n", current->comm, __func__);



	hdev = inst->core->device;

	sq = &inst->session_queue_fence;

	ktid = pkt->client_data.kdata;



	if (cvp_synx_ops(inst, CVP_INPUT_SYNX, fc, &synx_state)) {

		msm_cvp_unmap_frame(inst, pkt->client_data.kdata);

		goto exit;

	}



	rc = call_hfi_op(hdev, session_send, (void *)inst->session,

			(struct cvp_kmd_hfi_packet *)pkt);

	if (rc) {

		dprintk(CVP_ERR, "%s %s: Failed in call_hfi_op %d, %x\n",

			current->comm, __func__, pkt->size, pkt->packet_type);

		synx_state = SYNX_STATE_SIGNALED_ERROR;

		goto exit;

	}



	timeout = msecs_to_jiffies(CVP_MAX_WAIT_TIME);

	rc = cvp_wait_process_message(inst, sq, &ktid, timeout,

				(struct cvp_kmd_hfi_packet *)pkt);

	hdr = (struct cvp_hfi_msg_session_hdr *)pkt;

	hfi_err = hdr->error_type;

	if (rc) {

		dprintk(CVP_ERR, "%s %s: cvp_wait_process_message rc %d\n",

			current->comm, __func__, rc);

		synx_state = SYNX_STATE_SIGNALED_ERROR;

		goto exit;

	}

	if (hfi_err == HFI_ERR_SESSION_FLUSHED) {

		dprintk(CVP_SYNX, "%s %s: cvp_wait_process_message flushed\n",

			current->comm, __func__);

		synx_state = SYNX_STATE_SIGNALED_CANCEL;

	} else if (hfi_err == HFI_ERR_SESSION_STREAM_CORRUPT) {

		dprintk(CVP_ERR, "%s %s: cvp_wait_process_msg non-fatal %d\n",

		current->comm, __func__, hfi_err);

		synx_state = SYNX_STATE_SIGNALED_SUCCESS;

	} else if (hfi_err != HFI_ERR_NONE) {

		dprintk(CVP_ERR, "%s %s: cvp_wait_process_message hfi err %d\n",

			current->comm, __func__, hfi_err);

		synx_state = SYNX_STATE_SIGNALED_CANCEL;

	}



exit:

	rc = cvp_synx_ops(inst, CVP_OUTPUT_SYNX, fc, &synx_state);



	return rc;

}



static int cvp_fence_proc(struct msm_cvp_inst *inst,

			struct cvp_fence_command *fc,

			struct cvp_hfi_cmd_session_hdr *pkt)
@@ -466,31 +402,18 @@ static int cvp_fence_thread(void *data) 
	synx = (u32 *)f->synx;



	ktid = pkt->client_data.kdata & (FENCE_BIT - 1);

	dprintk(CVP_SYNX, "%s on frame %llu frameID %llu ktid %llu\n",

		current->comm, ktid, f->frame_id, ktid);

	dprintk(CVP_SYNX, "%s pkt type %d on ktid %llu frameID %llu\n",

		current->comm, pkt->packet_type, ktid, f->frame_id);



	switch (f->type) {

	case HFI_CMD_SESSION_CVP_DME_FRAME:

		rc = cvp_fence_dme(inst, f, pkt);

		break;

	case HFI_CMD_SESSION_CVP_FD_FRAME:

	rc = cvp_fence_proc(inst, f, pkt);

		break;

	default:

		dprintk(CVP_ERR, "%s: unknown hfi cmd type 0x%x\n",

			__func__, f->type);

		rc = -EINVAL;

		goto exit;

		break;

	}



	mutex_lock(&q->lock);

	cvp_release_synx(inst, f);

	list_del_init(&f->list);

	mutex_unlock(&q->lock);



	dprintk(CVP_SYNX, "%s is done with frame %llu frameID %llu rc %d\n",

		current->comm, ktid, f->frame_id, rc);

	dprintk(CVP_SYNX, "%s done with %d ktid %llu frameID %llu rc %d\n",

		current->comm, pkt->packet_type, ktid, f->frame_id, rc);



	cvp_free_fence_data(f);
@@ -562,7 +485,7 @@ static int msm_cvp_session_process_hfi_fence(struct msm_cvp_inst *inst, 


	if (!is_buf_param_valid(buf_num, offset)) {

		dprintk(CVP_ERR, "Incorrect buf num and offset in cmd\n");

		return -EINVAL;

		goto exit;

	}

	rc = msm_cvp_map_frame(inst, (struct cvp_kmd_hfi_packet *)pkt, offset,

				buf_num);
@@ -578,8 +501,10 @@ static int msm_cvp_session_process_hfi_fence(struct msm_cvp_inst *inst, 


	synx_pkt = &arg->data.hfi_synx_pkt;

	if (synx_pkt->fence_data[0] != 0xFEEDFACE) {

		fence = (u32 *)&fence_pkt->fence_data;

		f->frame_id = arg->data.hfi_fence_pkt.frame_id;

		dprintk(CVP_ERR, "%s deprecated synx path\n", __func__);

		cvp_free_fence_data(f);

		msm_cvp_unmap_frame(inst, pkt->client_data.kdata);

		goto exit;

	} else {

		kfc = &synx_pkt->fc;

		fence = (u32 *)&kfc->fences;

drivers/media/platform/msm/cvp/msm_cvp_synx.c

+10 −370
Original line number Diff line number Diff line
@@ -44,71 +44,6 @@ void cvp_dump_fence_queue(struct msm_cvp_inst *inst) 
	mutex_unlock(&q->lock);

}



static int cvp_import_synx_deprecate(struct msm_cvp_inst *inst, u32 type,

		u32 *fence, u32 *synx)

{

	int rc = 0;

	int i;

	int start = 0, end = 0;

	struct cvp_fence_type *f;

	struct synx_import_params params;

	s32 h_synx;

	struct synx_session ssid;



	f = (struct cvp_fence_type *)fence;

	ssid = inst->synx_session_id;



	switch (type) {

	case HFI_CMD_SESSION_CVP_DME_FRAME:

	{

		start = 0;

		end = HFI_DME_BUF_NUM;

		break;

	}

	case HFI_CMD_SESSION_CVP_FD_FRAME:

	{

		u32 in = fence[0];

		u32 out = fence[1];



		if (in > MAX_HFI_FENCE_SIZE || out > MAX_HFI_FENCE_SIZE

			|| in > MAX_HFI_FENCE_SIZE - out) {

			dprintk(CVP_ERR, "%s: failed!\n", __func__);

			rc = -EINVAL;

			return rc;

		}



		synx[0] = (in << 16) | out;

		start = 1;

		end = in + out + 1;

		break;

	}

	default:

		dprintk(CVP_ERR, "%s: unknown fence type\n", __func__);

		rc = -EINVAL;

		return rc;

	}



	for (i = start; i < end; ++i) {

		h_synx = f[i].h_synx;



		if (h_synx) {

			params.h_synx = h_synx;

			params.secure_key = f[i].secure_key;

			params.new_h_synx = &synx[i];



			rc = synx_import(ssid, &params);

			if (rc) {

				dprintk(CVP_ERR,

					"%s: synx_import failed\n",

					__func__);

				return rc;

			}

		}

	}



	return rc;

}



int cvp_import_synx(struct msm_cvp_inst *inst, struct cvp_fence_command *fc,

		u32 *fence)

{
@@ -119,9 +54,10 @@ int cvp_import_synx(struct msm_cvp_inst *inst, struct cvp_fence_command *fc, 
	s32 h_synx;

	struct synx_session ssid;



	if (fc->signature != 0xFEEDFACE)

		return cvp_import_synx_deprecate(inst, fc->type, fence,

					fc->synx);

	if (fc->signature != 0xFEEDFACE) {

		dprintk(CVP_ERR, "%s Deprecated synx path\n", __func__);

		return -EINVAL;

	}



	fs = (struct cvp_fence_type *)fence;

	ssid = inst->synx_session_id;
@@ -147,55 +83,6 @@ int cvp_import_synx(struct msm_cvp_inst *inst, struct cvp_fence_command *fc, 
	return 0;

}



static int cvp_release_synx_deprecate(struct msm_cvp_inst *inst, u32 type,

				u32 *synx)

{

	int rc = 0;

	int i;

	s32 h_synx;

	struct synx_session ssid;

	int start = 0, end = 0;



	ssid = inst->synx_session_id;



	switch (type) {

	case HFI_CMD_SESSION_CVP_DME_FRAME:

	{

		start = 0;

		end = HFI_DME_BUF_NUM;



		break;

	}

	case HFI_CMD_SESSION_CVP_FD_FRAME:

	{

		u32 in = synx[0] >> 16;

		u32 out = synx[0] & 0xFFFF;



		start = 1;

		end = in + out + 1;



		break;

	}

	default:

		dprintk(CVP_ERR, "%s: unknown fence type\n", __func__);

		rc = -EINVAL;

		return rc;

	}



	for (i = start; i < end; ++i) {

		h_synx = synx[i];

		if (h_synx) {

			rc = synx_release(ssid, h_synx);

			if (rc)

				dprintk(CVP_ERR,

				"%s: synx_release %d failed\n",

				__func__, i);

		}

	}



	return rc;

}



int cvp_release_synx(struct msm_cvp_inst *inst, struct cvp_fence_command *fc)

{

	int rc = 0;
@@ -203,8 +90,10 @@ int cvp_release_synx(struct msm_cvp_inst *inst, struct cvp_fence_command *fc) 
	s32 h_synx;

	struct synx_session ssid;



	if (fc->signature != 0xFEEDFACE)

		return cvp_release_synx_deprecate(inst, fc->type, fc->synx);

	if (fc->signature != 0xFEEDFACE) {

		dprintk(CVP_ERR, "%s deprecated synx_path\n", __func__);

		return -EINVAL;

	}



	ssid = inst->synx_session_id;

	for (i = 0; i < fc->num_fences; ++i) {
@@ -220,108 +109,6 @@ int cvp_release_synx(struct msm_cvp_inst *inst, struct cvp_fence_command *fc) 
	return rc;

}



static int cvp_cancel_input_synx_deprecate(struct msm_cvp_inst *inst, u32 type,

				u32 *synx)

{

	int rc = 0;

	int i;

	int h_synx;

	struct synx_session ssid;

	int start = 0, end = 0;

	int synx_state = SYNX_STATE_SIGNALED_CANCEL;



	ssid = inst->synx_session_id;



	switch (type) {

	case HFI_CMD_SESSION_CVP_DME_FRAME:

	{

		start = 1;

		end = HFI_DME_BUF_NUM - 1;

		break;

	}

	case HFI_CMD_SESSION_CVP_FD_FRAME:

	{

		u32 in, out;



		in = synx[0] >> 16;

		out = synx[0] & 0xFFFF;



		start = 1;

		end = in + 1;

		break;

	}

	default:

		dprintk(CVP_ERR, "%s: unknown fence type\n", __func__);

		rc = -EINVAL;

		return rc;

	}



	for (i = start; i < end; ++i) {

		h_synx = synx[i];

		if (h_synx) {

			rc = synx_signal(ssid, h_synx, synx_state);

			if (rc && rc != -EALREADY) {

				dprintk(CVP_ERR, "%s: synx_signal %d failed\n",

				__func__, i);

				synx_state = SYNX_STATE_SIGNALED_ERROR;

			}

		}

	}



	return rc;

}



static int cvp_cancel_output_synx_deprecate(struct msm_cvp_inst *inst, u32 type,

					u32 *synx)

{

	int rc = 0;

	int i;

	int h_synx;

	struct synx_session ssid;

	int start = 0, end = 0;

	int synx_state = SYNX_STATE_SIGNALED_CANCEL;



	ssid = inst->synx_session_id;



	switch (type) {

	case HFI_CMD_SESSION_CVP_DME_FRAME:

	{

		start = FENCE_DME_OUTPUT_IDX;

		end = FENCE_DME_OUTPUT_IDX + 1;

		break;

	}

	case HFI_CMD_SESSION_CVP_FD_FRAME:

	{

		u32 in, out;



		in = synx[0] >> 16;

		out = synx[0] & 0xFFFF;



		start = in + 1;

		end = in + out + 1;

		break;

	}

	default:

		dprintk(CVP_ERR, "%s: unknown fence type\n", __func__);

		rc = -EINVAL;

		return rc;

	}



	for (i = start; i < end; ++i) {

		h_synx = synx[i];

		if (h_synx) {

			rc = synx_signal(ssid, h_synx, synx_state);

			if (rc) {

				dprintk(CVP_ERR, "%s: synx_signal %d failed\n",

				__func__, i);

				synx_state = SYNX_STATE_SIGNALED_ERROR;

			}

		}

	}



	return rc;

}



static int cvp_cancel_synx_impl(struct msm_cvp_inst *inst,

			enum cvp_synx_type type,

			struct cvp_fence_command *fc)
@@ -367,139 +154,13 @@ int cvp_cancel_synx(struct msm_cvp_inst *inst, enum cvp_synx_type type, 
		struct cvp_fence_command *fc)

{

	if (fc->signature != 0xFEEDFACE) {

		if (type == CVP_INPUT_SYNX)

			return cvp_cancel_input_synx_deprecate(inst, fc->type,

							fc->synx);

		else if (type == CVP_OUTPUT_SYNX)

			return cvp_cancel_output_synx_deprecate(inst, fc->type,

							fc->synx);

		else {

			dprintk(CVP_ERR, "Incorrect synx type %d\n", type);

		dprintk(CVP_ERR, "%s deprecated synx path\n", __func__);

			return -EINVAL;

		}

	}



	return cvp_cancel_synx_impl(inst, type, fc);

}



static int cvp_wait_dme_synx_deprecate(struct synx_session ssid, u32 *synx,

				u32 *synx_state)

{

	int i, rc = 0;

	int h_synx;

	unsigned long timeout_ms = 1000;



	i = 0;

	while (i < HFI_DME_BUF_NUM - 1) {

		h_synx = synx[i];

		if (h_synx) {

			rc = synx_wait(ssid, h_synx, timeout_ms);

			if (rc) {

				dprintk(CVP_ERR, "%s %s: synx_wait %d failed\n",

					current->comm, __func__, i);

				*synx_state = SYNX_STATE_SIGNALED_ERROR;

				return -EINVAL;

			}

			/*

			 * Increase loop count to skip fence

			 * waiting on downscale image where i == 1.

			 */

			if (i == FENCE_DME_ICA_ENABLED_IDX)

				++i;

		}

		++i;

	}

	return rc;

}



static int cvp_signal_dme_synx_deprecate(struct synx_session ssid, u32 *synx,

				u32 synx_state)

{

	int rc = 0;

	int h_synx;



	if (synx[FENCE_DME_ICA_ENABLED_IDX]) {

		h_synx = synx[FENCE_DME_DS_IDX];



		rc = synx_signal(ssid, h_synx, synx_state);

		if (rc) {

			dprintk(CVP_ERR, "%s %s: synx_signal %d failed\n",

				current->comm, __func__, FENCE_DME_DS_IDX);

			synx_state = SYNX_STATE_SIGNALED_ERROR;

		}

	}



	h_synx = synx[FENCE_DME_OUTPUT_IDX];

	rc = synx_signal(ssid, h_synx, synx_state);

	if (rc)

		dprintk(CVP_ERR, "%s %s: synx_signal %d failed\n",

			current->comm, __func__, FENCE_DME_OUTPUT_IDX);



	return rc;

}



static int cvp_wait_fd_synx_deprecate(struct synx_session ssid, u32 *synx,

				u32 *synx_state)

{

	int i, rc = 0;

	unsigned long timeout_ms = 1000;

	int h_synx;

	u32 in;



	in = synx[0] >> 16;



	i = 1;

	while (i <= in) {

		h_synx = synx[i];

		if (h_synx) {

			rc = synx_wait(ssid, h_synx, timeout_ms);

			if (rc) {

				*synx_state = synx_get_status(ssid, h_synx);

				if (*synx_state == SYNX_STATE_SIGNALED_CANCEL) {

					dprintk(CVP_SYNX,

					"%s: synx_wait %d cancel %d state %d\n",

					current->comm, i, rc, *synx_state);

				} else {

					dprintk(CVP_ERR,

					"%s: synx_wait %d failed %d state %d\n",

					current->comm, i, rc, *synx_state);

					*synx_state = SYNX_STATE_SIGNALED_ERROR;

				}

				return rc;

			}

		}

		++i;

	}

	return rc;

}



static int cvp_signal_fd_synx_deprecate(struct synx_session ssid, u32 *synx,

				u32 synx_state)

{

	int i, rc = 0;

	u32 in, out;

	int h_synx;



	in = synx[0] >> 16;

	out = synx[0] & 0xFFFF;



	i = in + 1;

	while (i <= in + out) {

		h_synx = synx[i];

		if (h_synx) {

			rc = synx_signal(ssid, h_synx, synx_state);

			if (rc) {

				dprintk(CVP_ERR, "%s: synx_signal %d failed\n",

				current->comm, i);

				synx_state = SYNX_STATE_SIGNALED_ERROR;

			}

		}

		++i;

	}



	return rc;

}



static int cvp_wait_synx(struct synx_session ssid, u32 *synx, u32 num_synx,

		u32 *synx_state)

{
@@ -560,29 +221,8 @@ int cvp_synx_ops(struct msm_cvp_inst *inst, enum cvp_synx_type type, 
	ssid = inst->synx_session_id;



	if (fc->signature != 0xFEEDFACE) {

		if (fc->type == HFI_CMD_SESSION_CVP_DME_FRAME) {

			if (type == CVP_INPUT_SYNX)

				return cvp_wait_dme_synx_deprecate(ssid,

						fc->synx, synx_state);

			else if (type == CVP_OUTPUT_SYNX)

				return cvp_signal_dme_synx_deprecate(ssid,

						fc->synx, *synx_state);

			else

		dprintk(CVP_ERR, "%s deprecated synx, type %d\n", __func__);

				return -EINVAL;

		} else if (fc->type == HFI_CMD_SESSION_CVP_FD_FRAME) {

			if (type == CVP_INPUT_SYNX)

				return cvp_wait_fd_synx_deprecate(ssid,

						fc->synx, synx_state);

			else if (type == CVP_OUTPUT_SYNX)

				return cvp_signal_fd_synx_deprecate(ssid,

						fc->synx, *synx_state);

			else

				return -EINVAL;

		} else {

			dprintk(CVP_ERR, "%s Incorrect pkt type\n",

					__func__);

			return -EINVAL;

		}

	}



	if (type == CVP_INPUT_SYNX) {