Merge "msm: cvp: Remove unused code in CVP driver" (0b3fc871) · Commits · e / devices / android_kernel_fairphone_FP4

arch/arm64/boot/dts/qcom/kona-cvp.dtsi

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -15,14 +15,14 @@
	interrupts = <GIC_SPI 234 IRQ_TYPE_LEVEL_HIGH>;		interrupts = <GIC_SPI 234 IRQ_TYPE_LEVEL_HIGH>;

	/* Supply */		/* Supply */
	cvp-supply = <&mvs1_gdsc>;		cvp-supply = <&mvs1c_gdsc>;

	/* Clocks */		/* Clocks */
	clock-names = "gcc_video_axi0",		clock-names = "gcc_video_axi0",
	"gcc_video_axi1", "cvp_clk";		"gcc_video_axi1", "cvp_clk";
	clocks = <&clock_gcc GCC_VIDEO_AXI0_CLK>,		clocks = <&clock_gcc GCC_VIDEO_AXI0_CLK>,
	<&clock_gcc GCC_VIDEO_AXI1_CLK>,		<&clock_gcc GCC_VIDEO_AXI1_CLK>,
	<&clock_videocc VIDEO_CC_MVS1_CLK>;		<&clock_videocc VIDEO_CC_MVS1C_CLK>;
	qcom,proxy-clock-names = "gcc_video_axi0", "gcc_video_axi1",		qcom,proxy-clock-names = "gcc_video_axi0", "gcc_video_axi1",
	"cvp_clk";		"cvp_clk";

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;
	}		}