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

Commit af4a40e3 authored by Praneeth Paladugu's avatar Praneeth Paladugu
Browse files

msm: vidc: read capabilities as part of sys_init_done



Venus firmware now giving codec capabilities as part
of sys_init_done instead of session_init_done message
for all codecs. Parse capabilities in sys_init_done
and assign them to codecs indicated by venus firmware.
This change also maintains the backward compatibility
where firmware will send the capability as part of
session_init_done.

Change-Id: I4fd9943321808fa01aaaaea8edec3d08a57d9f0b
Signed-off-by: default avatarVinay Kalia <vkalia@codeaurora.org>
Signed-off-by: default avatarPraneeth Paladugu <ppaladug@codeaurora.org>
parent bfbfa771
Loading
Loading
Loading
Loading
+109 −6
Original line number Diff line number Diff line
@@ -124,9 +124,10 @@ static inline int hal_to_hfi_type(int property, int hal_type)
	}
}

static inline u32 get_hfi_layout(enum hal_buffer_layout_type hal_buf_layout)
u32 get_hfi_layout(enum hal_buffer_layout_type hal_buf_layout)
{
	u32 hfi_layout;

	switch (hal_buf_layout) {
	case HAL_BUFFER_LAYOUT_TOP_BOTTOM:
		hfi_layout = HFI_MVC_BUFFER_LAYOUT_TOP_BOTTOM;
@@ -143,9 +144,110 @@ static inline u32 get_hfi_layout(enum hal_buffer_layout_type hal_buf_layout)
	return hfi_layout;
}

static inline u32 get_hfi_codec(enum hal_video_codec hal_codec)
enum hal_domain vidc_get_hal_domain(u32 hfi_domain)
{
	enum hal_domain hal_domain = 0;

	switch (hfi_domain) {
	case HFI_VIDEO_DOMAIN_VPE:
		hal_domain = HAL_VIDEO_DOMAIN_VPE;
		break;
	case HFI_VIDEO_DOMAIN_ENCODER:
		hal_domain = HAL_VIDEO_DOMAIN_ENCODER;
		break;
	case HFI_VIDEO_DOMAIN_DECODER:
		hal_domain = HAL_VIDEO_DOMAIN_DECODER;
		break;
	default:
		dprintk(VIDC_ERR, "%s: invalid domain %x\n",
			__func__, hfi_domain);
		hal_domain = 0;
		break;
	}
	return hal_domain;
}

enum hal_video_codec vidc_get_hal_codec(u32 hfi_codec)
{
	u32 hfi_codec;
	enum hal_video_codec hal_codec = 0;

	switch (hfi_codec) {
	case HFI_VIDEO_CODEC_H264:
		hal_codec = HAL_VIDEO_CODEC_H264;
		break;
	case HFI_VIDEO_CODEC_H263:
		hal_codec = HAL_VIDEO_CODEC_H263;
		break;
	case HFI_VIDEO_CODEC_MPEG1:
		hal_codec = HAL_VIDEO_CODEC_MPEG1;
		break;
	case HFI_VIDEO_CODEC_MPEG2:
		hal_codec = HAL_VIDEO_CODEC_MPEG2;
		break;
	case HFI_VIDEO_CODEC_MPEG4:
		hal_codec = HAL_VIDEO_CODEC_MPEG4;
		break;
	case HFI_VIDEO_CODEC_DIVX_311:
		hal_codec = HAL_VIDEO_CODEC_DIVX_311;
		break;
	case HFI_VIDEO_CODEC_DIVX:
		hal_codec = HAL_VIDEO_CODEC_DIVX;
		break;
	case HFI_VIDEO_CODEC_VC1:
		hal_codec = HAL_VIDEO_CODEC_VC1;
		break;
	case HFI_VIDEO_CODEC_SPARK:
		hal_codec = HAL_VIDEO_CODEC_SPARK;
		break;
	case HFI_VIDEO_CODEC_VP8:
		hal_codec = HAL_VIDEO_CODEC_VP8;
		break;
	case HFI_VIDEO_CODEC_HEVC:
		hal_codec = HAL_VIDEO_CODEC_HEVC;
		break;
	case HFI_VIDEO_CODEC_VP9:
		hal_codec = HAL_VIDEO_CODEC_VP9;
		break;
	case HFI_VIDEO_CODEC_HEVC_HYBRID:
		hal_codec = HAL_VIDEO_CODEC_HEVC_HYBRID;
		break;
	default:
		dprintk(VIDC_INFO, "%s: invalid codec 0x%x\n",
			__func__, hfi_codec);
		hal_codec = 0;
		break;
	}
	return hal_codec;
}


u32 vidc_get_hfi_domain(enum hal_domain hal_domain)
{
	u32 hfi_domain;

	switch (hal_domain) {
	case HAL_VIDEO_DOMAIN_VPE:
		hfi_domain = HFI_VIDEO_DOMAIN_VPE;
		break;
	case HAL_VIDEO_DOMAIN_ENCODER:
		hfi_domain = HFI_VIDEO_DOMAIN_ENCODER;
		break;
	case HAL_VIDEO_DOMAIN_DECODER:
		hfi_domain = HFI_VIDEO_DOMAIN_DECODER;
		break;
	default:
		dprintk(VIDC_ERR, "%s: invalid domain 0x%x\n",
			__func__, hal_domain);
		hfi_domain = 0;
		break;
	}
	return hfi_domain;
}

u32 vidc_get_hfi_codec(enum hal_video_codec hal_codec)
{
	u32 hfi_codec = 0;

	switch (hal_codec) {
	case HAL_VIDEO_CODEC_MVC:
	case HAL_VIDEO_CODEC_H264:
@@ -188,7 +290,8 @@ static inline u32 get_hfi_codec(enum hal_video_codec hal_codec)
		hfi_codec = HFI_VIDEO_CODEC_HEVC_HYBRID;
		break;
	default:
		dprintk(VIDC_ERR, "Invalid codec %#x\n", hal_codec);
		dprintk(VIDC_INFO, "%s: invalid codec 0x%x\n",
			__func__, hal_codec);
		hfi_codec = 0;
		break;
	}
@@ -377,8 +480,8 @@ inline int create_pkt_cmd_sys_session_init(
	pkt->size = sizeof(struct hfi_cmd_sys_session_init_packet);
	pkt->packet_type = HFI_CMD_SYS_SESSION_INIT;
	pkt->session_id = hash32_ptr(session);
	pkt->session_domain = session_domain;
	pkt->session_codec = get_hfi_codec(session_codec);
	pkt->session_domain = vidc_get_hfi_domain(session_domain);
	pkt->session_codec = vidc_get_hfi_codec(session_codec);
	if (!pkt->session_codec)
		return -EINVAL;

+427 −159

File changed.

Preview size limit exceeded, changes collapsed.

+12 −11
Original line number Diff line number Diff line
@@ -652,9 +652,9 @@ static u32 get_frame_size(struct msm_vidc_inst *inst,
		frame_size = fmt->get_frame_size(plane,
					inst->capability.mbs_per_frame.max,
					MB_SIZE_IN_PIXEL);
		if (inst->capability.buffer_size_limit &&
			(inst->capability.buffer_size_limit < frame_size)) {
			frame_size = inst->capability.buffer_size_limit;
		if (inst->buffer_size_limit &&
			(inst->buffer_size_limit < frame_size)) {
			frame_size = inst->buffer_size_limit;
			dprintk(VIDC_DBG, "input buffer size limited to %d\n",
				frame_size);
		} else {
@@ -1966,8 +1966,8 @@ int msm_vdec_inst_init(struct msm_vidc_inst *inst)
	inst->capability.height.max = DEFAULT_HEIGHT;
	inst->capability.width.min = MIN_SUPPORTED_WIDTH;
	inst->capability.width.max = DEFAULT_WIDTH;
	inst->capability.buffer_mode[OUTPUT_PORT] = HAL_BUFFER_MODE_STATIC;
	inst->capability.buffer_mode[CAPTURE_PORT] = HAL_BUFFER_MODE_STATIC;
	inst->capability.alloc_mode_in = HAL_BUFFER_MODE_STATIC;
	inst->capability.alloc_mode_out = HAL_BUFFER_MODE_STATIC;
	inst->capability.secure_output2_threshold.min = 0;
	inst->capability.secure_output2_threshold.max = 0;
	inst->buffer_mode_set[OUTPUT_PORT] = HAL_BUFFER_MODE_STATIC;
@@ -2397,10 +2397,10 @@ static int try_set_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl)
		alloc_mode.buffer_mode = get_buf_type(ctrl->val);

		if (!(alloc_mode.buffer_mode &
			inst->capability.buffer_mode[CAPTURE_PORT])) {
			dprintk(VIDC_ERR,
				"buffer mode[%d] not supported for Capture Port\n",
				ctrl->val);
			inst->capability.alloc_mode_out)) {
			dprintk(VIDC_WARN,
				"buffer mode[%d] not supported for capture port[0x%x]\n",
				ctrl->val, inst->capability.alloc_mode_out);
			rc = -ENOTSUPP;
			break;
		}
@@ -2541,9 +2541,10 @@ static int try_set_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl)
		pdata = &profile_level;
		break;
	case V4L2_CID_MPEG_VIDC_VIDEO_BUFFER_SIZE_LIMIT:
		inst->capability.buffer_size_limit = ctrl->val;
		dprintk(VIDC_DBG,
			"Limiting input buffer size to :%u\n", ctrl->val);
			"Limiting input buffer size from %u to %u\n",
			inst->buffer_size_limit, ctrl->val);
		inst->buffer_size_limit = ctrl->val;
		break;
	case V4L2_CID_MPEG_VIDC_VIDEO_NON_SECURE_OUTPUT2:
		property_id = HAL_PARAM_VDEC_NON_SECURE_OUTPUT2;
+11 −3

File changed.

Preview size limit exceeded, changes collapsed.

+1 −1
Original line number Diff line number Diff line
@@ -983,7 +983,7 @@ EXPORT_SYMBOL(msm_vidc_streamoff);
int msm_vidc_enum_framesizes(void *instance, struct v4l2_frmsizeenum *fsize)
{
	struct msm_vidc_inst *inst = instance;
	struct msm_vidc_core_capability *capability = NULL;
	struct msm_vidc_capability *capability = NULL;

	if (!inst || !fsize) {
		dprintk(VIDC_ERR, "%s: invalid parameter: %p %p\n",
Loading