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

Commit 05d1b777 authored by George Shen's avatar George Shen
Browse files

msm: cvp: Remove unused code in CVP driver 



Remove unused code in CVP driver. Wait longer for CVP boot.

Change-Id: Iea9c2b25a7d2e935106ba03044d40a4ca4938400
Signed-off-by: default avatarGeorge Shen <sqiao@codeaurora.org>
parent 67b79c04

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

+8 −4
Original line number Original line Diff line number Diff line
@@ -1190,7 +1190,7 @@ static int __tzbsp_set_video_state(enum tzbsp_video_state state) 
static inline int __boot_firmware(struct venus_hfi_device *device)

static inline int __boot_firmware(struct venus_hfi_device *device)

{

{

	int rc = 0;

	int rc = 0;

	u32 ctrl_init_val = 0, ctrl_status = 0, count = 0, max_tries = 10;

	u32 ctrl_init_val = 0, ctrl_status = 0, count = 0, max_tries = 1000;





	ctrl_init_val = BIT(0);

	ctrl_init_val = BIT(0);

	__write_register(device, CVP_CTRL_INIT, ctrl_init_val);

	__write_register(device, CVP_CTRL_INIT, ctrl_init_val);
@@ -1206,7 +1206,11 @@ static inline int __boot_firmware(struct venus_hfi_device *device) 
		usleep_range(50, 100);

		usleep_range(50, 100);

		count++;

		count++;

	}

	}

	dprintk(CVP_DBG, "Run to end of firmware boot\n");



	if (ctrl_status != 0x1)

		dprintk(CVP_DBG, "Failed to boot FW status: %x\n",

			ctrl_status);



	return 0;

	return 0;

}

}

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

+2 −373
Original line number Original line Diff line number Diff line
@@ -15,11 +15,6 @@ 
#include "msm_cvp_debug.h"

#include "msm_cvp_debug.h"

#include "cvp_hfi.h"

#include "cvp_hfi.h"





static enum cvp_status hfi_parse_init_done_properties(

		struct msm_cvp_capability *capability,

		u32 num_sessions, u8 *data_ptr, u32 num_properties,

		u32 rem_bytes);



static enum cvp_status hfi_map_err_status(u32 hfi_err)

static enum cvp_status hfi_map_err_status(u32 hfi_err)

{

{

	enum cvp_status cvp_err;

	enum cvp_status cvp_err;
@@ -683,359 +678,12 @@ static inline void copy_cap_prop( 
	}

	}

}

}





static int hfi_fill_codec_info(u8 *data_ptr,

		struct cvp_hal_sys_init_done *sys_init_done)

{

	u32 i;

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

	struct msm_cvp_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(CVP_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) {

			capability =

				&sys_init_done->capabilities[codec_count++];

			capability->codec =

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

			capability->domain =

				cvp_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) {

			capability =

				&sys_init_done->capabilities[codec_count++];

			capability->codec =

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

			capability->domain =

				cvp_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(CVP_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_cvp_capability *capabilities,

		u32 num_sessions, u32 codecs, u32 domain)

{

	u32 i = 0, j = 0;

	struct msm_cvp_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 =

				cvp_get_hfi_codec(capability->codec);

		if (capability->domain)

			sess_domain =

				cvp_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_cvp_capability *capabilities,

		u32 num_sessions, u32 codecs, u32 domain)

{

	u32 i = 0, j = 0;

	struct msm_cvp_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 =

				cvp_get_hfi_codec(capability->codec);

		if (capability->domain)

			sess_domain =

				cvp_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_cvp_capability *capabilities, u32 num_sessions,

		u32 codecs, u32 domain)

{

	u32 i = 0;

	struct msm_cvp_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 =

				cvp_get_hfi_codec(capability->codec);

		if (capability->domain)

			sess_domain =

				cvp_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 cvp_status hfi_parse_init_done_properties(

		struct msm_cvp_capability *capabilities,

		u32 num_sessions, u8 *data_ptr, u32 num_properties,

		u32 rem_bytes)

{

	enum cvp_status status = CVP_ERR_NONE;

	u32 prop_id, next_offset;

	u32 codecs = 0, domain = 0;



	while (status == CVP_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 = CVP_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 = CVP_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 = CVP_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(CVP_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(CVP_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 cvp_status cvp_hfi_process_sys_init_done_prop_read(

enum cvp_status cvp_hfi_process_sys_init_done_prop_read(

	struct hfi_msg_sys_init_done_packet *pkt,

	struct hfi_msg_sys_init_done_packet *pkt,

	struct cvp_hal_sys_init_done *sys_init_done)

	struct cvp_hal_sys_init_done *sys_init_done)

{

{

	enum cvp_status status = CVP_ERR_NONE;

	enum cvp_status status = CVP_ERR_NONE;

	u32 rem_bytes, bytes_read, num_properties;

	u32 rem_bytes, num_properties;

	u8 *data_ptr;

	u8 *data_ptr;





	if (!pkt || !sys_init_done) {

	if (!pkt || !sys_init_done) {
@@ -1064,27 +712,8 @@ enum cvp_status cvp_hfi_process_sys_init_done_prop_read( 
	dprintk(CVP_DBG,

	dprintk(CVP_DBG,

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

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

		__func__, data_ptr, num_properties);

		__func__, data_ptr, num_properties);

	if (!num_properties) {

		sys_init_done->capabilities = NULL;

		dprintk(CVP_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,

			CVP_MAX_SESSIONS, data_ptr, num_properties,

			rem_bytes);

	if (status) {

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

			__func__, status);

		return status;

	}





	sys_init_done->capabilities = NULL;

	return status;

	return status;

}

}