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

Commit ed24a007 authored by Maheshwar Ajja's avatar Maheshwar Ajja
Browse files

msm: vidc: add platform specific capabilities 



Add platform specific capabilities and use them
in place of firmware capabilities.

Change-Id: I58e34aefe7594c701e261c8c5ec3f98f1fb7f2bd
Signed-off-by: default avatarMaheshwar Ajja <majja@codeaurora.org>
parent 00474817

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

+0 −661
Original line number Diff line number Diff line
@@ -15,11 +15,6 @@ 
#include "msm_vidc_debug.h"

#include "vidc_hfi.h"



static enum vidc_status hfi_parse_init_done_properties(

		struct msm_vidc_capability *capability,

		u32 num_sessions, u8 *data_ptr, u32 num_properties,

		u32 rem_bytes);



static enum vidc_status hfi_map_err_status(u32 hfi_err)

{

	enum vidc_status vidc_err;
@@ -469,662 +464,6 @@ static int hfi_process_sys_rel_resource_done(u32 device_id, 
	return 0;

}



enum hal_capability get_hal_cap_type(u32 capability_type)

{

	enum hal_capability hal_cap = 0;



	switch (capability_type) {

	case HFI_CAPABILITY_FRAME_WIDTH:

		hal_cap = HAL_CAPABILITY_FRAME_WIDTH;

		break;

	case HFI_CAPABILITY_FRAME_HEIGHT:

		hal_cap = HAL_CAPABILITY_FRAME_HEIGHT;

		break;

	case HFI_CAPABILITY_MBS_PER_FRAME:

		hal_cap = HAL_CAPABILITY_MBS_PER_FRAME;

		break;

	case HFI_CAPABILITY_MBS_PER_SECOND:

		hal_cap = HAL_CAPABILITY_MBS_PER_SECOND;

		break;

	case HFI_CAPABILITY_FRAMERATE:

		hal_cap = HAL_CAPABILITY_FRAMERATE;

		break;

	case HFI_CAPABILITY_SCALE_X:

		hal_cap = HAL_CAPABILITY_SCALE_X;

		break;

	case HFI_CAPABILITY_SCALE_Y:

		hal_cap = HAL_CAPABILITY_SCALE_Y;

		break;

	case HFI_CAPABILITY_BITRATE:

		hal_cap = HAL_CAPABILITY_BITRATE;

		break;

	case HFI_CAPABILITY_BFRAME:

		hal_cap = HAL_CAPABILITY_BFRAME;

		break;

	case HFI_CAPABILITY_PEAKBITRATE:

		hal_cap = HAL_CAPABILITY_PEAKBITRATE;

		break;

	case HFI_CAPABILITY_HIER_P_NUM_ENH_LAYERS:

		hal_cap = HAL_CAPABILITY_HIER_P_NUM_ENH_LAYERS;

		break;

	case HFI_CAPABILITY_ENC_LTR_COUNT:

		hal_cap = HAL_CAPABILITY_ENC_LTR_COUNT;

		break;

	case HFI_CAPABILITY_CP_OUTPUT2_THRESH:

		hal_cap = HAL_CAPABILITY_SECURE_OUTPUT2_THRESHOLD;

		break;

	case HFI_CAPABILITY_HIER_B_NUM_ENH_LAYERS:

		hal_cap = HAL_CAPABILITY_HIER_B_NUM_ENH_LAYERS;

		break;

	case HFI_CAPABILITY_LCU_SIZE:

		hal_cap = HAL_CAPABILITY_LCU_SIZE;

		break;

	case HFI_CAPABILITY_HIER_P_HYBRID_NUM_ENH_LAYERS:

		hal_cap = HAL_CAPABILITY_HIER_P_HYBRID_NUM_ENH_LAYERS;

		break;

	case HFI_CAPABILITY_MBS_PER_SECOND_POWERSAVE:

		hal_cap = HAL_CAPABILITY_MBS_PER_SECOND_POWER_SAVE;

		break;

	case HFI_CAPABILITY_EXTRADATA:

		hal_cap = HAL_CAPABILITY_EXTRADATA;

		break;

	case HFI_CAPABILITY_PROFILE:

		hal_cap = HAL_CAPABILITY_PROFILE;

		break;

	case HFI_CAPABILITY_LEVEL:

		hal_cap = HAL_CAPABILITY_LEVEL;

		break;

	case HFI_CAPABILITY_I_FRAME_QP:

		hal_cap = HAL_CAPABILITY_I_FRAME_QP;

		break;

	case HFI_CAPABILITY_P_FRAME_QP:

		hal_cap = HAL_CAPABILITY_P_FRAME_QP;

		break;

	case HFI_CAPABILITY_B_FRAME_QP:

		hal_cap = HAL_CAPABILITY_B_FRAME_QP;

		break;

	case HFI_CAPABILITY_RATE_CONTROL_MODES:

		hal_cap = HAL_CAPABILITY_RATE_CONTROL_MODES;

		break;

	case HFI_CAPABILITY_BLUR_WIDTH:

		hal_cap = HAL_CAPABILITY_BLUR_WIDTH;

		break;

	case HFI_CAPABILITY_BLUR_HEIGHT:

		hal_cap = HAL_CAPABILITY_BLUR_HEIGHT;

		break;

	case HFI_CAPABILITY_SLICE_BYTE:

		hal_cap = HAL_CAPABILITY_SLICE_BYTE;

		break;

	case HFI_CAPABILITY_SLICE_MB:

		hal_cap = HAL_CAPABILITY_SLICE_MB;

		break;

	case HFI_CAPABILITY_SECURE:

		hal_cap = HAL_CAPABILITY_SECURE;

		break;

	case HFI_CAPABILITY_MAX_NUM_B_FRAMES:

		hal_cap = HAL_CAPABILITY_MAX_NUM_B_FRAMES;

		break;

	case HFI_CAPABILITY_MAX_VIDEOCORES:

		hal_cap = HAL_CAPABILITY_MAX_VIDEOCORES;

		break;

	case HFI_CAPABILITY_MAX_WORKMODES:

		hal_cap = HAL_CAPABILITY_MAX_WORKMODES;

		break;

	case HFI_CAPABILITY_UBWC_CR_STATS:

		hal_cap = HAL_CAPABILITY_UBWC_CR_STATS;

		break;

	default:

		dprintk(VIDC_DBG, "%s: unknown capablity %#x\n",

			__func__, capability_type);

		break;

	}



	return hal_cap;

}



static inline void copy_cap_prop(

		struct hfi_capability_supported *in,

		struct msm_vidc_capability *capability)

{

	struct hal_capability_supported *out = NULL;



	if (!in || !capability) {

		dprintk(VIDC_ERR, "%s Invalid input parameters\n",

			__func__);

		return;

	}



	switch (in->capability_type) {

	case HFI_CAPABILITY_FRAME_WIDTH:

		out = &capability->width;

		break;

	case HFI_CAPABILITY_FRAME_HEIGHT:

		out = &capability->height;

		break;

	case HFI_CAPABILITY_MBS_PER_FRAME:

		out = &capability->mbs_per_frame;

		break;

	case HFI_CAPABILITY_MBS_PER_SECOND:

		out = &capability->mbs_per_sec;

		break;

	case HFI_CAPABILITY_FRAMERATE:

		out = &capability->frame_rate;

		break;

	case HFI_CAPABILITY_SCALE_X:

		out = &capability->scale_x;

		break;

	case HFI_CAPABILITY_SCALE_Y:

		out = &capability->scale_y;

		break;

	case HFI_CAPABILITY_BITRATE:

		out = &capability->bitrate;

		break;

	case HFI_CAPABILITY_BFRAME:

		out = &capability->bframe;

		break;

	case HFI_CAPABILITY_HIER_P_NUM_ENH_LAYERS:

		out = &capability->hier_p;

		break;

	case HFI_CAPABILITY_ENC_LTR_COUNT:

		out = &capability->ltr_count;

		break;

	case HFI_CAPABILITY_CP_OUTPUT2_THRESH:

		out = &capability->secure_output2_threshold;

		break;

	case HFI_CAPABILITY_HIER_B_NUM_ENH_LAYERS:

		out = &capability->hier_b;

		break;

	case HFI_CAPABILITY_LCU_SIZE:

		out = &capability->lcu_size;

		break;

	case HFI_CAPABILITY_HIER_P_HYBRID_NUM_ENH_LAYERS:

		out = &capability->hier_p_hybrid;

		break;

	case HFI_CAPABILITY_MBS_PER_SECOND_POWERSAVE:

		out = &capability->mbs_per_sec_power_save;

		break;

	case HFI_CAPABILITY_EXTRADATA:

		out = &capability->extradata;

		break;

	case HFI_CAPABILITY_PROFILE:

		out = &capability->profile;

		break;

	case HFI_CAPABILITY_LEVEL:

		out = &capability->level;

		break;

	case HFI_CAPABILITY_I_FRAME_QP:

		out = &capability->i_qp;

		break;

	case HFI_CAPABILITY_P_FRAME_QP:

		out = &capability->p_qp;

		break;

	case HFI_CAPABILITY_B_FRAME_QP:

		out = &capability->b_qp;

		break;

	case HFI_CAPABILITY_RATE_CONTROL_MODES:

		out = &capability->rc_modes;

		break;

	case HFI_CAPABILITY_BLUR_WIDTH:

		out = &capability->blur_width;

		break;

	case HFI_CAPABILITY_BLUR_HEIGHT:

		out = &capability->blur_height;

		break;

	case HFI_CAPABILITY_SLICE_BYTE:

		out = &capability->slice_bytes;

		break;

	case HFI_CAPABILITY_SLICE_MB:

		out = &capability->slice_mbs;

		break;

	case HFI_CAPABILITY_SECURE:

		out = &capability->secure;

		break;

	case HFI_CAPABILITY_MAX_NUM_B_FRAMES:

		out = &capability->max_num_b_frames;

		break;

	case HFI_CAPABILITY_MAX_VIDEOCORES:

		out = &capability->max_video_cores;

		break;

	case HFI_CAPABILITY_MAX_WORKMODES:

		out = &capability->max_work_modes;

		break;

	case HFI_CAPABILITY_UBWC_CR_STATS:

		out = &capability->ubwc_cr_stats;

		break;

	default:

		dprintk(VIDC_DBG, "%s: unknown capablity %#x\n",

			__func__, in->capability_type);

		break;

	}



	if (out) {

		out->capability_type = get_hal_cap_type(in->capability_type);

		out->min = in->min;

		out->max = in->max;

		out->step_size = in->step_size;

	}

}



static int hfi_fill_codec_info(u8 *data_ptr,

		struct vidc_hal_sys_init_done *sys_init_done)

{

	u32 i;

	u32 codecs = 0, codec_count = 0, size = 0;

	struct msm_vidc_capability *capability;

	u32 prop_id = *((u32 *)data_ptr);

	u8 *orig_data_ptr = data_ptr;



	if (prop_id ==  HFI_PROPERTY_PARAM_CODEC_SUPPORTED) {

		struct hfi_codec_supported *prop;



		data_ptr = data_ptr + sizeof(u32);

		prop = (struct hfi_codec_supported *) data_ptr;

		sys_init_done->dec_codec_supported =

			prop->decoder_codec_supported;

		sys_init_done->enc_codec_supported =

			prop->encoder_codec_supported;

		size = sizeof(struct hfi_codec_supported) + sizeof(u32);

	} else {

		dprintk(VIDC_WARN,

			"%s: prop_id %#x, expected codec_supported property\n",

			__func__, prop_id);

	}



	codecs = sys_init_done->dec_codec_supported;

	for (i = 0; i < 8 * sizeof(codecs); i++) {

		if ((1 << i) & codecs) {

			if (codec_count >= VIDC_MAX_SESSIONS) {

				dprintk(VIDC_ERR,

					"%s: codec count exceeding max sessions %d\n",

					__func__, VIDC_MAX_SESSIONS);

				break;

			}



			capability =

				&sys_init_done->capabilities[codec_count++];

			capability->codec =

				vidc_get_hal_codec((1 << i) & codecs);

			capability->domain =

				vidc_get_hal_domain(HFI_VIDEO_DOMAIN_DECODER);

		}

	}



	codecs = sys_init_done->enc_codec_supported;

	for (i = 0; i < 8 * sizeof(codecs); i++) {

		if ((1 << i) & codecs) {

			if (codec_count >= VIDC_MAX_SESSIONS) {

				dprintk(VIDC_ERR,

					"%s: codec count exceeding max sessions %d\n",

					__func__, VIDC_MAX_SESSIONS);

				break;

			}



			capability =

				&sys_init_done->capabilities[codec_count++];

			capability->codec =

				vidc_get_hal_codec((1 << i) & codecs);

			capability->domain =

				vidc_get_hal_domain(HFI_VIDEO_DOMAIN_ENCODER);

		}

	}

	sys_init_done->codec_count = codec_count;



	prop_id = *((u32 *)(orig_data_ptr + size));

	if (prop_id == HFI_PROPERTY_PARAM_MAX_SESSIONS_SUPPORTED) {

		struct hfi_max_sessions_supported *prop =

			(struct hfi_max_sessions_supported *)

			(orig_data_ptr + size + sizeof(u32));



		sys_init_done->max_sessions_supported = prop->max_sessions;

		size += sizeof(struct hfi_max_sessions_supported) + sizeof(u32);

		dprintk(VIDC_DBG, "max_sessions_supported %d\n",

				prop->max_sessions);

	}

	return size;

}



static int copy_profile_caps_to_sessions(struct hfi_profile_level *prof,

		u32 profile_count, struct msm_vidc_capability *capabilities,

		u32 num_sessions, u32 codecs, u32 domain)

{

	u32 i = 0, j = 0;

	struct msm_vidc_capability *capability;

	u32 sess_codec;

	u32 sess_domain;



	/*

	 * iterate over num_sessions and copy all the profile capabilities

	 * to matching sessions.

	 */

	for (i = 0; i < num_sessions; i++) {

		sess_codec = 0;

		sess_domain = 0;

		capability = &capabilities[i];



		if (capability->codec)

			sess_codec =

				vidc_get_hfi_codec(capability->codec);

		if (capability->domain)

			sess_domain =

				vidc_get_hfi_domain(capability->domain);



		if (!(sess_codec & codecs && sess_domain & domain))

			continue;



		capability->profile_level.profile_count = profile_count;

		for (j = 0; j < profile_count; j++) {

			/* HFI and HAL follow same enums, hence no conversion */

			capability->profile_level.profile_level[j].profile =

				prof[j].profile;

			capability->profile_level.profile_level[j].level =

				prof[j].level;

		}

	}



	return 0;

}



static int copy_caps_to_sessions(struct hfi_capability_supported *cap,

		u32 num_caps, struct msm_vidc_capability *capabilities,

		u32 num_sessions, u32 codecs, u32 domain)

{

	u32 i = 0, j = 0;

	struct msm_vidc_capability *capability;

	u32 sess_codec;

	u32 sess_domain;



	/*

	 * iterate over num_sessions and copy all the capabilities

	 * to matching sessions.

	 */

	for (i = 0; i < num_sessions; i++) {

		sess_codec = 0;

		sess_domain = 0;

		capability = &capabilities[i];



		if (capability->codec)

			sess_codec =

				vidc_get_hfi_codec(capability->codec);

		if (capability->domain)

			sess_domain =

				vidc_get_hfi_domain(capability->domain);



		if (!(sess_codec & codecs && sess_domain & domain))

			continue;



		for (j = 0; j < num_caps; j++)

			copy_cap_prop(&cap[j], capability);

	}



	return 0;

}



static int copy_nal_stream_format_caps_to_sessions(u32 nal_stream_format_value,

		struct msm_vidc_capability *capabilities, u32 num_sessions,

		u32 codecs, u32 domain)

{

	u32 i = 0;

	struct msm_vidc_capability *capability;

	u32 sess_codec;

	u32 sess_domain;



	for (i = 0; i < num_sessions; i++) {

		sess_codec = 0;

		sess_domain = 0;

		capability = &capabilities[i];



		if (capability->codec)

			sess_codec =

				vidc_get_hfi_codec(capability->codec);

		if (capability->domain)

			sess_domain =

				vidc_get_hfi_domain(capability->domain);



		if (!(sess_codec & codecs && sess_domain & domain))

			continue;



		capability->nal_stream_format.nal_stream_format_supported =

				nal_stream_format_value;

	}



	return 0;

}



static enum vidc_status hfi_parse_init_done_properties(

		struct msm_vidc_capability *capabilities,

		u32 num_sessions, u8 *data_ptr, u32 num_properties,

		u32 rem_bytes)

{

	enum vidc_status status = VIDC_ERR_NONE;

	u32 prop_id, next_offset;

	u32 codecs = 0, domain = 0;



	while (status == VIDC_ERR_NONE && num_properties &&

			rem_bytes >= sizeof(u32)) {



		prop_id = *((u32 *)data_ptr);

		next_offset = sizeof(u32);



		switch (prop_id) {

		case HFI_PROPERTY_PARAM_CODEC_MASK_SUPPORTED:

		{

			struct hfi_codec_mask_supported *prop =

				(struct hfi_codec_mask_supported *)

				(data_ptr + next_offset);



			codecs = prop->codecs;

			domain = prop->video_domains;

			next_offset += sizeof(struct hfi_codec_mask_supported);

			num_properties--;

			break;

		}

		case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED:

		{

			struct hfi_capability_supported_info *prop =

				(struct hfi_capability_supported_info *)

				(data_ptr + next_offset);



			if ((rem_bytes - next_offset) < prop->num_capabilities *

				sizeof(struct hfi_capability_supported)) {

				status = VIDC_ERR_BAD_PARAM;

				break;

			}

			next_offset += sizeof(u32) +

				prop->num_capabilities *

				sizeof(struct hfi_capability_supported);



			copy_caps_to_sessions(&prop->rg_data[0],

					prop->num_capabilities,

					capabilities, num_sessions,

					codecs, domain);

			num_properties--;

			break;

		}

		case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED:

		{

			struct hfi_uncompressed_format_supported *prop =

				(struct hfi_uncompressed_format_supported *)

				(data_ptr + next_offset);

			u32 num_format_entries;

			char *fmt_ptr;

			struct hfi_uncompressed_plane_info *plane_info;



			if ((rem_bytes - next_offset) < sizeof(*prop)) {

				status = VIDC_ERR_BAD_PARAM;

				break;

			}

			num_format_entries = prop->format_entries;

			next_offset = sizeof(*prop);

			fmt_ptr = (char *)&prop->rg_format_info[0];



			while (num_format_entries) {

				u32 bytes_to_skip;



				plane_info =

				(struct hfi_uncompressed_plane_info *) fmt_ptr;



				if ((rem_bytes - next_offset) <

						sizeof(*plane_info)) {

					status = VIDC_ERR_BAD_PARAM;

					break;

				}

				bytes_to_skip = sizeof(*plane_info) -

					sizeof(struct

					hfi_uncompressed_plane_constraints) +

					plane_info->num_planes *

					sizeof(struct

					hfi_uncompressed_plane_constraints);



				fmt_ptr += bytes_to_skip;

				next_offset += bytes_to_skip;

				num_format_entries--;

			}

			num_properties--;

			break;

		}

		case HFI_PROPERTY_PARAM_PROPERTIES_SUPPORTED:

		{

			struct hfi_properties_supported *prop =

				(struct hfi_properties_supported *)

				(data_ptr + next_offset);

			next_offset += sizeof(*prop) - sizeof(u32)

				+ prop->num_properties * sizeof(u32);

			num_properties--;

			break;

		}

		case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED:

		{

			struct hfi_profile_level_supported *prop =

				(struct hfi_profile_level_supported *)

				(data_ptr + next_offset);



			next_offset += sizeof(u32) +

				prop->profile_count *

				sizeof(struct hfi_profile_level);



			if (prop->profile_count > MAX_PROFILE_COUNT) {

				prop->profile_count = MAX_PROFILE_COUNT;

				dprintk(VIDC_WARN,

					"prop count exceeds max profile count\n");

				break;

			}



			copy_profile_caps_to_sessions(

					&prop->rg_profile_level[0],

					prop->profile_count, capabilities,

					num_sessions, codecs, domain);

			num_properties--;

			break;

		}

		case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SUPPORTED:

		{

			struct hfi_nal_stream_format_supported *prop =

				(struct hfi_nal_stream_format_supported *)

					(data_ptr + next_offset);



			copy_nal_stream_format_caps_to_sessions(

					prop->nal_stream_format_supported,

					capabilities, num_sessions,

					codecs, domain);



			next_offset +=

				sizeof(struct hfi_nal_stream_format_supported);

			num_properties--;

			break;

		}

		case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SELECT:

		{

			next_offset += sizeof(u32);

			num_properties--;

			break;

		}

		case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH:

		{

			next_offset +=

				sizeof(struct hfi_intra_refresh);

			num_properties--;

			break;

		}

		case HFI_PROPERTY_TME_VERSION_SUPPORTED:

		{

			capabilities->tme_version =

				*((u32 *)(data_ptr + next_offset));

			next_offset +=

				sizeof(u32);

			num_properties--;

			break;

		}

		default:

			dprintk(VIDC_DBG,

				"%s: default case - data_ptr %pK, prop_id 0x%x\n",

				__func__, data_ptr, prop_id);

			break;

		}

		rem_bytes -= next_offset;

		data_ptr += next_offset;

	}



	return status;

}



enum vidc_status hfi_process_sys_init_done_prop_read(

	struct hfi_msg_sys_init_done_packet *pkt,

	struct vidc_hal_sys_init_done *sys_init_done)

{

	enum vidc_status status = VIDC_ERR_NONE;

	u32 rem_bytes, bytes_read, num_properties;

	u8 *data_ptr;



	if (!pkt || !sys_init_done) {

		dprintk(VIDC_ERR,

			"hfi_msg_sys_init_done: Invalid input\n");

		return VIDC_ERR_FAIL;

	}



	rem_bytes = pkt->size - sizeof(struct

			hfi_msg_sys_init_done_packet) + sizeof(u32);



	if (!rem_bytes) {

		dprintk(VIDC_ERR,

			"hfi_msg_sys_init_done: missing_prop_info\n");

		return VIDC_ERR_FAIL;

	}



	status = hfi_map_err_status(pkt->error_type);

	if (status) {

		dprintk(VIDC_ERR, "%s: status %#x\n", __func__, status);

		return status;

	}



	data_ptr = (u8 *) &pkt->rg_property_data[0];

	num_properties = pkt->num_properties;

	dprintk(VIDC_DBG,

		"%s: data_start %pK, num_properties %#x\n",

		__func__, data_ptr, num_properties);

	if (!num_properties) {

		sys_init_done->capabilities = NULL;

		dprintk(VIDC_DBG,

			"Venus didn't set any properties in SYS_INIT_DONE");

		return status;

	}

	bytes_read = hfi_fill_codec_info(data_ptr, sys_init_done);

	data_ptr += bytes_read;

	rem_bytes -= bytes_read;

	num_properties--;



	status = hfi_parse_init_done_properties(

			sys_init_done->capabilities,

			VIDC_MAX_SESSIONS, data_ptr, num_properties,

			rem_bytes);

	if (status) {

		dprintk(VIDC_ERR, "%s: parse status %#x\n",

			__func__, status);

		return status;

	}



	return status;

}



static void hfi_process_sess_get_prop_buf_req(

	struct hfi_msg_session_property_info_packet *prop,

	struct buffer_requirements *buffreq)

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

+1 −13
Original line number Diff line number Diff line
@@ -763,12 +763,6 @@ int msm_vdec_inst_init(struct msm_vidc_inst *inst) 
	inst->prop.width[CAPTURE_PORT] = DEFAULT_WIDTH;

	inst->prop.height[OUTPUT_PORT] = DEFAULT_HEIGHT;

	inst->prop.width[OUTPUT_PORT] = DEFAULT_WIDTH;

	inst->capability.height.min = MIN_SUPPORTED_HEIGHT;

	inst->capability.height.max = DEFAULT_HEIGHT;

	inst->capability.width.min = MIN_SUPPORTED_WIDTH;

	inst->capability.width.max = DEFAULT_WIDTH;

	inst->capability.secure_output2_threshold.min = 0;

	inst->capability.secure_output2_threshold.max = 0;

	inst->buffer_mode_set[OUTPUT_PORT] = HAL_BUFFER_MODE_STATIC;

	inst->buffer_mode_set[CAPTURE_PORT] = HAL_BUFFER_MODE_DYNAMIC;

	inst->stream_output_mode = HAL_VIDEO_DECODER_PRIMARY;
@@ -909,13 +903,7 @@ int msm_vdec_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) 
			inst->flags |= VIDC_REALTIME;

		break;

	case V4L2_CID_MPEG_VIDC_VIDEO_OPERATING_RATE:

		if (((ctrl->val >> 16) < inst->capability.frame_rate.min ||

			(ctrl->val >> 16) > inst->capability.frame_rate.max) &&

			ctrl->val != INT_MAX) {

			dprintk(VIDC_ERR, "Invalid operating rate %u\n",

				(ctrl->val >> 16));

			rc = -ENOTSUPP;

		} else if (ctrl->val == INT_MAX) {

		if (ctrl->val == INT_MAX) {

			dprintk(VIDC_DBG,

				"inst(%pK) Request for turbo mode\n", inst);

			inst->clk_data.turbo_mode = true;

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

+4 −16
Original line number Diff line number Diff line
@@ -1068,16 +1068,9 @@ int msm_venc_inst_init(struct msm_vidc_inst *inst) 
	inst->prop.height[OUTPUT_PORT] = DEFAULT_HEIGHT;

	inst->prop.width[OUTPUT_PORT] = DEFAULT_WIDTH;

	inst->prop.bframe_changed = false;

	inst->capability.height.min = MIN_SUPPORTED_HEIGHT;

	inst->capability.height.max = DEFAULT_HEIGHT;

	inst->capability.width.min = MIN_SUPPORTED_WIDTH;

	inst->capability.width.max = DEFAULT_WIDTH;

	inst->capability.secure_output2_threshold.min = 0;

	inst->capability.secure_output2_threshold.max = 0;

	inst->buffer_mode_set[OUTPUT_PORT] = HAL_BUFFER_MODE_DYNAMIC;

	inst->buffer_mode_set[CAPTURE_PORT] = HAL_BUFFER_MODE_STATIC;

	inst->clk_data.frame_rate = (DEFAULT_FPS << 16);

	inst->capability.pixelprocess_capabilities = 0;



	inst->bufq[OUTPUT_PORT].num_planes = 2;

	inst->bufq[CAPTURE_PORT].num_planes = 1;
@@ -1497,13 +1490,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) 
		}

		break;

	case V4L2_CID_MPEG_VIDC_VIDEO_OPERATING_RATE:

		if (((ctrl->val >> 16) < inst->capability.frame_rate.min ||

			(ctrl->val >> 16) > inst->capability.frame_rate.max) &&

			ctrl->val != INT_MAX) {

			dprintk(VIDC_ERR, "Invalid operating rate %u\n",

				(ctrl->val >> 16));

			rc = -ENOTSUPP;

		} else if (ctrl->val == INT_MAX) {

		if (ctrl->val == INT_MAX) {

			dprintk(VIDC_DBG, "inst(%pK) Request for turbo mode\n",

				inst);

			inst->clk_data.turbo_mode = true;
@@ -3435,9 +3422,10 @@ int msm_venc_set_ltr_mode(struct msm_vidc_inst *inst) 
	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_LTRCOUNT);

	if (!ctrl->val)

		return 0;

	if (ctrl->val > inst->capability.ltr_count.max) {

	if (ctrl->val > inst->capability.cap[CAP_LTR_COUNT].max) {

		dprintk(VIDC_ERR, "%s: invalid ltr count %d, max %d\n",

			__func__, ctrl->val, inst->capability.ltr_count.max);

			__func__, ctrl->val,

			inst->capability.cap[CAP_LTR_COUNT].max);

		return -EINVAL;

	}

	ltr.ltr_count =  ctrl->val;

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

+31 −90

File changed.

Preview size limit exceeded, changes collapsed.

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

+1 −1
Original line number Diff line number Diff line
@@ -759,7 +759,7 @@ u32 msm_vidc_calculate_dec_input_frame_size(struct msm_vidc_inst *inst) 
	num_mbs = ((width + 15) >> 4) * ((height + 15) >> 4);

	if (num_mbs > NUM_MBS_4k) {

		div_factor = 4;

		base_res_mbs = inst->capability.mbs_per_frame.max;

		base_res_mbs = inst->capability.cap[CAP_MBS_PER_FRAME].max;

	} else {

		base_res_mbs = NUM_MBS_4k;

		if (inst->fmts[OUTPUT_PORT].fourcc == V4L2_PIX_FMT_VP9)