Merge "msm: vidc: add platform specific capabilities" (aa7b6614) · Commits · e / devices / android_kernel_oneplus_sm7250

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;
		@@ -3500,9 +3487,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)