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

Commit 520c7591 authored by Praneeth Paladugu's avatar Praneeth Paladugu Committed by Gerrit - the friendly Code Review server
Browse files

msm: vidc: Enhance HW capabilities parsing 



    - HW sends all the capabilities in SYS_INIT_DONE only. Hence
          remove the parsing from SESSION_INIT_DONE.
    - Add parsing logic for new capabilities.

CRs-Fixed: 2006193
Change-Id: I08484995f3437806751aa37c4b036f7ab42b371c
Signed-off-by: default avatarPraneeth Paladugu <ppaladug@codeaurora.org>
Signed-off-by: default avatarChinmay Sawarkar <chinmays@codeaurora.org>
parent 881e2d3f

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

+106 −47
Original line number Diff line number Diff line
@@ -25,7 +25,7 @@ 
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, u32 codec, u32 domain);

		u32 rem_bytes);



static enum vidc_status hfi_map_err_status(u32 hfi_err)

{
@@ -485,6 +485,57 @@ enum hal_capability get_hal_cap_type(u32 capability_type) 
	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_DELIVERY_MODES:

		hal_cap = HAL_CAPABILITY_SLICE_DELIVERY_MODES;

		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);
@@ -558,6 +609,57 @@ static inline void copy_cap_prop( 
	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_DELIVERY_MODES:

		out = &capability->slice_delivery_mode;

		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);
@@ -634,44 +736,6 @@ static int hfi_fill_codec_info(u8 *data_ptr, 
	return size;

}



enum vidc_status hfi_process_session_init_done_prop_read(

		struct hfi_msg_sys_session_init_done_packet *pkt,

		struct vidc_hal_session_init_done *session_init_done)

{

	enum vidc_status status = VIDC_ERR_NONE;

	struct msm_vidc_capability *capability = NULL;

	u32 rem_bytes, num_properties;

	u8 *data_ptr;



	rem_bytes = pkt->size - sizeof(struct

			hfi_msg_sys_session_init_done_packet) + sizeof(u32);

	if (!rem_bytes) {

		dprintk(VIDC_ERR, "%s: invalid property info\n", __func__);

		return VIDC_ERR_FAIL;

	}



	status = hfi_map_err_status(pkt->error_type);

	if (status) {

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

		return status;

	}



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

	num_properties = pkt->num_properties;



	capability = &session_init_done->capability;

	status = hfi_parse_init_done_properties(

			capability, 1, data_ptr, num_properties, rem_bytes,

			vidc_get_hfi_codec(capability->codec),

			vidc_get_hfi_domain(capability->domain));

	if (status) {

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

		return status;

	}



	return status;

}



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)
@@ -710,10 +774,11 @@ static int copy_caps_to_sessions(struct hfi_capability_supported *cap, 
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, u32 codecs, u32 domain)

		u32 rem_bytes)

{

	enum vidc_status status = VIDC_ERR_NONE;

	u32 prop_id, next_offset;

	u32 codecs, domain;



	while (status == VIDC_ERR_NONE && num_properties &&

			rem_bytes >= sizeof(u32)) {
@@ -885,7 +950,6 @@ enum vidc_status hfi_process_sys_init_done_prop_read( 
	enum vidc_status status = VIDC_ERR_NONE;

	u32 rem_bytes, bytes_read, num_properties;

	u8 *data_ptr;

	u32 codecs = 0, domain = 0;



	if (!pkt || !sys_init_done) {

		dprintk(VIDC_ERR,
@@ -927,7 +991,7 @@ enum vidc_status hfi_process_sys_init_done_prop_read( 
	status = hfi_parse_init_done_properties(

			sys_init_done->capabilities,

			VIDC_MAX_SESSIONS, data_ptr, num_properties,

			rem_bytes, codecs, domain);

			rem_bytes);

	if (status) {

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

			__func__, status);
@@ -1203,11 +1267,6 @@ static int hfi_process_session_init_done(u32 device_id, 
	cmd_done.device_id = device_id;

	cmd_done.session_id = (void *)(uintptr_t)pkt->session_id;

	cmd_done.status = hfi_map_err_status(pkt->error_type);

	if (!cmd_done.status) {

		cmd_done.status = hfi_process_session_init_done_prop_read(

			pkt, &session_init_done);

	}



	cmd_done.data.session_init_done = session_init_done;

	cmd_done.size = sizeof(struct vidc_hal_session_init_done);

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

+32 −17
Original line number Diff line number Diff line
@@ -956,7 +956,6 @@ static void handle_session_init_done(enum hal_command_response cmd, void *data) 
{

	struct msm_vidc_cb_cmd_done *response = data;

	struct msm_vidc_inst *inst = NULL;

	struct vidc_hal_session_init_done *session_init_done = NULL;

	struct msm_vidc_capability *capability = NULL;

	struct hfi_device *hdev;

	struct msm_vidc_core *core;
@@ -1009,26 +1008,16 @@ static void handle_session_init_done(enum hal_command_response cmd, void *data) 


	if (capability) {

		dprintk(VIDC_DBG,

			"%s: capabilities available for codec 0x%x, domain %#x\n",

			"%s: capabilities for codec 0x%x, domain %#x\n",

			__func__, capability->codec, capability->domain);

		memcpy(&inst->capability, capability,

			sizeof(struct msm_vidc_capability));

	} else {

		session_init_done = (struct vidc_hal_session_init_done *)

				&response->data.session_init_done;

		if (!session_init_done) {

		dprintk(VIDC_ERR,

				"%s: Failed to get valid response for session init\n",

				__func__);

			return;

		}

		capability = &session_init_done->capability;

		dprintk(VIDC_DBG,

			"%s: got capabilities for codec 0x%x, domain 0x%x\n",

			__func__, capability->codec,

			capability->domain);

		memcpy(&inst->capability, capability,

			sizeof(struct msm_vidc_capability));

			"Watch out : Some property may fail inst %pK\n", inst);

		dprintk(VIDC_ERR,

			"Caps N/A for codec 0x%x, domain %#x\n",

			inst->capability.codec, inst->capability.domain);

	}

	inst->capability.pixelprocess_capabilities =

		call_hfi_op(hdev, get_core_capabilities, hdev->hfi_device_data);
@@ -1038,13 +1027,39 @@ static void handle_session_init_done(enum hal_command_response cmd, void *data) 
	print_cap("width", &inst->capability.width);

	print_cap("height", &inst->capability.height);

	print_cap("mbs_per_frame", &inst->capability.mbs_per_frame);

	print_cap("mbs_per_sec", &inst->capability.mbs_per_sec);

	print_cap("frame_rate", &inst->capability.frame_rate);

	print_cap("bitrate", &inst->capability.bitrate);

	print_cap("peak_bitrate", &inst->capability.peakbitrate);

	print_cap("scale_x", &inst->capability.scale_x);

	print_cap("scale_y", &inst->capability.scale_y);

	print_cap("hier_p", &inst->capability.hier_p);

	print_cap("ltr_count", &inst->capability.ltr_count);

	print_cap("bframe", &inst->capability.bframe);

	print_cap("secure_output2_threshold",

		&inst->capability.secure_output2_threshold);

	print_cap("hier_b", &inst->capability.hier_b);

	print_cap("lcu_size", &inst->capability.lcu_size);

	print_cap("hier_p_hybrid", &inst->capability.hier_p_hybrid);

	print_cap("mbs_per_sec_low_power",

		&inst->capability.mbs_per_sec_power_save);

	print_cap("extradata", &inst->capability.extradata);

	print_cap("profile", &inst->capability.profile);

	print_cap("level", &inst->capability.level);

	print_cap("i_qp", &inst->capability.i_qp);

	print_cap("p_qp", &inst->capability.p_qp);

	print_cap("b_qp", &inst->capability.b_qp);

	print_cap("rc_modes", &inst->capability.rc_modes);

	print_cap("blur_width", &inst->capability.blur_width);

	print_cap("blur_height", &inst->capability.blur_height);

	print_cap("slice_delivery_mode", &inst->capability.slice_delivery_mode);

	print_cap("slice_bytes", &inst->capability.slice_bytes);

	print_cap("slice_mbs", &inst->capability.slice_mbs);

	print_cap("secure", &inst->capability.secure);

	print_cap("max_num_b_frames", &inst->capability.max_num_b_frames);

	print_cap("max_video_cores", &inst->capability.max_video_cores);

	print_cap("max_work_modes", &inst->capability.max_work_modes);

	print_cap("ubwc_cr_stats", &inst->capability.ubwc_cr_stats);



	signal_session_msg_receipt(cmd, inst);

	put_inst(inst);

drivers/media/platform/msm/vidc/vidc_hfi_api.h

+34 −0
Original line number Diff line number Diff line
@@ -906,6 +906,23 @@ enum hal_capability { 
	HAL_CAPABILITY_LCU_SIZE,

	HAL_CAPABILITY_HIER_P_HYBRID_NUM_ENH_LAYERS,

	HAL_CAPABILITY_MBS_PER_SECOND_POWER_SAVE,

	HAL_CAPABILITY_EXTRADATA,

	HAL_CAPABILITY_PROFILE,

	HAL_CAPABILITY_LEVEL,

	HAL_CAPABILITY_I_FRAME_QP,

	HAL_CAPABILITY_P_FRAME_QP,

	HAL_CAPABILITY_B_FRAME_QP,

	HAL_CAPABILITY_RATE_CONTROL_MODES,

	HAL_CAPABILITY_BLUR_WIDTH,

	HAL_CAPABILITY_BLUR_HEIGHT,

	HAL_CAPABILITY_SLICE_DELIVERY_MODES,

	HAL_CAPABILITY_SLICE_BYTE,

	HAL_CAPABILITY_SLICE_MB,

	HAL_CAPABILITY_SECURE,

	HAL_CAPABILITY_MAX_NUM_B_FRAMES,

	HAL_CAPABILITY_MAX_VIDEOCORES,

	HAL_CAPABILITY_MAX_WORKMODES,

	HAL_CAPABILITY_UBWC_CR_STATS,

	HAL_UNUSED_CAPABILITY = 0x10000000,

};
@@ -1300,6 +1317,23 @@ struct msm_vidc_capability { 
	struct hal_capability_supported lcu_size;

	struct hal_capability_supported hier_p_hybrid;

	struct hal_capability_supported mbs_per_sec_power_save;

	struct hal_capability_supported extradata;

	struct hal_capability_supported profile;

	struct hal_capability_supported level;

	struct hal_capability_supported i_qp;

	struct hal_capability_supported p_qp;

	struct hal_capability_supported b_qp;

	struct hal_capability_supported rc_modes;

	struct hal_capability_supported blur_width;

	struct hal_capability_supported blur_height;

	struct hal_capability_supported slice_delivery_mode;

	struct hal_capability_supported slice_bytes;

	struct hal_capability_supported slice_mbs;

	struct hal_capability_supported secure;

	struct hal_capability_supported max_num_b_frames;

	struct hal_capability_supported max_video_cores;

	struct hal_capability_supported max_work_modes;

	struct hal_capability_supported ubwc_cr_stats;

	struct hal_profile_level_supported profile_level;

	struct hal_uncompressed_format_supported uncomp_format;

	struct hal_interlace_format_supported HAL_format;

drivers/media/platform/msm/vidc/vidc_hfi_helper.h

+17 −0
Original line number Diff line number Diff line
@@ -372,6 +372,23 @@ struct hfi_colour_space { 
#define HFI_CAPABILITY_LCU_SIZE				(HFI_COMMON_BASE + 0x14)

#define HFI_CAPABILITY_HIER_P_HYBRID_NUM_ENH_LAYERS	(HFI_COMMON_BASE + 0x15)

#define HFI_CAPABILITY_MBS_PER_SECOND_POWERSAVE		(HFI_COMMON_BASE + 0x16)

#define HFI_CAPABILITY_EXTRADATA			(HFI_COMMON_BASE + 0X17)

#define HFI_CAPABILITY_PROFILE				(HFI_COMMON_BASE + 0X18)

#define HFI_CAPABILITY_LEVEL				(HFI_COMMON_BASE + 0X19)

#define HFI_CAPABILITY_I_FRAME_QP			(HFI_COMMON_BASE + 0X20)

#define HFI_CAPABILITY_P_FRAME_QP			(HFI_COMMON_BASE + 0X21)

#define HFI_CAPABILITY_B_FRAME_QP			(HFI_COMMON_BASE + 0X22)

#define HFI_CAPABILITY_RATE_CONTROL_MODES		(HFI_COMMON_BASE + 0X23)

#define HFI_CAPABILITY_BLUR_WIDTH			(HFI_COMMON_BASE + 0X24)

#define HFI_CAPABILITY_BLUR_HEIGHT			(HFI_COMMON_BASE + 0X25)

#define HFI_CAPABILITY_SLICE_DELIVERY_MODES		(HFI_COMMON_BASE + 0X26)

#define HFI_CAPABILITY_SLICE_BYTE			(HFI_COMMON_BASE + 0X27)

#define HFI_CAPABILITY_SLICE_MB				(HFI_COMMON_BASE + 0X28)

#define HFI_CAPABILITY_SECURE				(HFI_COMMON_BASE + 0X29)

#define HFI_CAPABILITY_MAX_NUM_B_FRAMES			(HFI_COMMON_BASE + 0X2A)

#define HFI_CAPABILITY_MAX_VIDEOCORES			(HFI_COMMON_BASE + 0X2B)

#define HFI_CAPABILITY_MAX_WORKMODES			(HFI_COMMON_BASE + 0X2C)

#define HFI_CAPABILITY_UBWC_CR_STATS			(HFI_COMMON_BASE + 0X2D)



struct hfi_capability_supported {

	u32 capability_type;