Merge "msm: cvp: CVP driver clean up" (aa00f59b) · Commits · e / devices / android_kernel_oneplus_sm7250

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

+18 −391

Original line number	Diff line number	Diff line
		@@ -152,19 +152,12 @@ static int __disable_subcaches(struct venus_hfi_device *device);
		static int __power_collapse(struct venus_hfi_device *device, bool force);
		static int venus_hfi_noc_error_info(void *dev);

		static void interrupt_init_vpu4(struct venus_hfi_device *device);
		static void interrupt_init_vpu5(struct venus_hfi_device *device);
		static void setup_dsp_uc_memmap_vpu5(struct venus_hfi_device *device);
		static void clock_config_on_enable_vpu5(struct venus_hfi_device *device);

		static int __set_ubwc_config(struct venus_hfi_device *device);

		struct venus_hfi_vpu_ops cvp_vpu4_ops = {
		.interrupt_init = interrupt_init_vpu4,
		.setup_dsp_uc_memmap = NULL,
		.clock_config_on_enable = NULL,
		};

		struct venus_hfi_vpu_ops cvp_vpu5_ops = {
		.interrupt_init = interrupt_init_vpu5,
		.setup_dsp_uc_memmap = setup_dsp_uc_memmap_vpu5,
		@@ -229,96 +222,6 @@ static void __dump_packet(u8 *packet, enum cvp_msg_prio log_level)
		}
		}

		static void __sim_modify_cmd_packet(u8 packet, struct venus_hfi_device device)
		{
		struct hfi_cmd_sys_session_init_packet *sys_init;
		struct hal_session *session = NULL;
		u8 i;
		phys_addr_t fw_bias = 0;

		if (!device \|\| !packet) {
		dprintk(CVP_ERR, "Invalid Param\n");
		return;
		} else if (!device->hal_data->firmware_base
		\|\| is_iommu_present(device->res)) {
		return;
		}

		fw_bias = device->hal_data->firmware_base;
		sys_init = (struct hfi_cmd_sys_session_init_packet *)packet;

		session = __get_session(device, sys_init->session_id);
		if (!session) {
		dprintk(CVP_DBG, "%s :Invalid session id: %x\n",
		__func__, sys_init->session_id);
		return;
		}

		switch (sys_init->packet_type) {
		case HFI_CMD_SESSION_EMPTY_BUFFER:
		if (session->is_decoder) {
		struct hfi_cmd_session_empty_buffer_compressed_packet
		*pkt = (struct
		hfi_cmd_session_empty_buffer_compressed_packet
		*) packet;
		pkt->packet_buffer -= fw_bias;
		} else {
		struct
		hfi_cmd_session_empty_buffer_uncompressed_plane0_packet
		*pkt = (struct
		hfi_cmd_session_empty_buffer_uncompressed_plane0_packet
		*) packet;
		pkt->packet_buffer -= fw_bias;
		}
		break;
		case HFI_CMD_SESSION_FILL_BUFFER:
		{
		struct hfi_cmd_session_fill_buffer_packet *pkt =
		(struct hfi_cmd_session_fill_buffer_packet *)packet;
		pkt->packet_buffer -= fw_bias;
		break;
		}
		case HFI_CMD_SESSION_SET_BUFFERS:
		{
		struct hfi_cmd_session_set_buffers_packet *pkt =
		(struct hfi_cmd_session_set_buffers_packet *)packet;
		if (pkt->buffer_type == HFI_BUFFER_OUTPUT \|\|
		pkt->buffer_type == HFI_BUFFER_OUTPUT2) {
		struct hfi_buffer_info *buff;

		buff = (struct hfi_buffer_info *) pkt->rg_buffer_info;
		buff->buffer_addr -= fw_bias;
		if (buff->extra_data_addr >= fw_bias)
		buff->extra_data_addr -= fw_bias;
		} else {
		for (i = 0; i < pkt->num_buffers; i++)
		pkt->rg_buffer_info[i] -= fw_bias;
		}
		break;
		}
		case HFI_CMD_SESSION_RELEASE_BUFFERS:
		{
		struct hfi_cmd_session_release_buffer_packet *pkt =
		(struct hfi_cmd_session_release_buffer_packet *)packet;

		if (pkt->buffer_type == HFI_BUFFER_OUTPUT \|\|
		pkt->buffer_type == HFI_BUFFER_OUTPUT2) {
		struct hfi_buffer_info *buff;

		buff = (struct hfi_buffer_info *) pkt->rg_buffer_info;
		buff->buffer_addr -= fw_bias;
		buff->extra_data_addr -= fw_bias;
		} else {
		for (i = 0; i < pkt->num_buffers; i++)
		pkt->rg_buffer_info[i] -= fw_bias;
		}
		break;
		}
		default:
		break;
		}
		}

		static int __dsp_send_hfi_queue(struct venus_hfi_device *device)
		{
		int rc;
		@@ -446,88 +349,17 @@ static int __dsp_shutdown(struct venus_hfi_device *device, u32 flags)
		return rc;
		}

		static int __session_pause(struct venus_hfi_device *device,
		struct hal_session *session)
		{
		int rc = 0;

		/* ignore if session paused already */
		if (session->flags & SESSION_PAUSE)
		return 0;

		session->flags \|= SESSION_PAUSE;
		dprintk(CVP_DBG, "%s: cvp session %x paused\n", __func__,
		hash32_ptr(session));

		return rc;
		}

		static int __session_resume(struct venus_hfi_device *device,
		struct hal_session *session)
		{
		int rc = 0;

		/* ignore if session already resumed */
		if (!(session->flags & SESSION_PAUSE))
		return 0;

		session->flags &= ~SESSION_PAUSE;
		dprintk(CVP_DBG, "%s: cvp session %x resumed\n", __func__,
		hash32_ptr(session));

		rc = __resume(device);
		if (rc) {
		dprintk(CVP_ERR, "%s: resume failed\n", __func__);
		goto exit;
		}

		if (device->dsp_flags & DSP_SUSPEND) {
		dprintk(CVP_ERR, "%s: dsp not resumed\n", __func__);
		rc = -EINVAL;
		goto exit;
		}

		exit:
		return rc;
		}

		static int venus_hfi_session_pause(void *sess)
		{
		int rc;
		struct hal_session *session = sess;
		struct venus_hfi_device *device;

		if (!session \|\| !session->device) {
		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
		dprintk(CVP_ERR, "Deprecated function %s\n", __func__);
		return -EINVAL;
		}
		device = session->device;

		mutex_lock(&device->lock);
		rc = __session_pause(device, session);
		mutex_unlock(&device->lock);

		return rc;
		}

		static int venus_hfi_session_resume(void *sess)
		{
		int rc;
		struct hal_session *session = sess;
		struct venus_hfi_device *device;

		if (!session \|\| !session->device) {
		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
		dprintk(CVP_ERR, "Deprecated function %s\n", __func__);
		return -EINVAL;
		}
		device = session->device;

		mutex_lock(&device->lock);
		rc = __session_resume(device, session);
		mutex_unlock(&device->lock);

		return rc;
		}

		static int __acquire_regulator(struct regulator_info *rinfo,
		struct venus_hfi_device *device)
		@@ -686,71 +518,6 @@ static int __write_queue(struct cvp_iface_q_info qinfo, u8 packet,
		return 0;
		}

		static void __hal_sim_modify_msg_packet(u8 *packet,
		struct venus_hfi_device *device)
		{
		struct hfi_msg_sys_session_init_done_packet *init_done;
		struct hal_session *session = NULL;
		phys_addr_t fw_bias = 0;

		if (!device \|\| !packet) {
		dprintk(CVP_ERR, "Invalid Param\n");
		return;
		} else if (!device->hal_data->firmware_base
		\|\| is_iommu_present(device->res)) {
		return;
		}

		fw_bias = device->hal_data->firmware_base;
		init_done = (struct hfi_msg_sys_session_init_done_packet *)packet;
		session = __get_session(device, init_done->session_id);

		if (!session) {
		dprintk(CVP_DBG, "%s: Invalid session id: %x\n",
		__func__, init_done->session_id);
		return;
		}

		switch (init_done->packet_type) {
		case HFI_MSG_SESSION_FILL_BUFFER_DONE:
		if (session->is_decoder) {
		struct
		hfi_msg_session_fbd_uncompressed_plane0_packet
		*pkt_uc = (struct
		hfi_msg_session_fbd_uncompressed_plane0_packet
		*) packet;
		pkt_uc->packet_buffer += fw_bias;
		} else {
		struct
		hfi_msg_session_fill_buffer_done_compressed_packet
		*pkt = (struct
		hfi_msg_session_fill_buffer_done_compressed_packet
		*) packet;
		pkt->packet_buffer += fw_bias;
		}
		break;
		case HFI_MSG_SESSION_EMPTY_BUFFER_DONE:
		{
		struct hfi_msg_session_empty_buffer_done_packet *pkt =
		(struct hfi_msg_session_empty_buffer_done_packet *)packet;
		pkt->packet_buffer += fw_bias;
		break;
		}
		case HFI_MSG_SESSION_GET_SEQUENCE_HEADER_DONE:
		{
		struct
		hfi_msg_session_get_sequence_header_done_packet
		*pkt =
		(struct hfi_msg_session_get_sequence_header_done_packet *)
		packet;
		pkt->sequence_header += fw_bias;
		break;
		}
		default:
		break;
		}
		}

		static int __read_queue(struct cvp_iface_q_info qinfo, u8 packet,
		u32 *pb_tx_req_is_set)
		{
		@@ -1441,7 +1208,6 @@ static int __iface_cmdq_write_relaxed(struct venus_hfi_device *device,
		goto err_q_null;
		}

		__sim_modify_cmd_packet((u8 *)pkt, device);
		if (__resume(device)) {
		dprintk(CVP_ERR, "%s: Power on failed\n", __func__);
		goto err_q_write;
		@@ -1510,7 +1276,6 @@ static int __iface_msgq_read(struct venus_hfi_device device, void pkt)
		}

		if (!__read_queue(q_info, (u8 *)pkt, &tx_req_is_set)) {
		__hal_sim_modify_msg_packet((u8 *)pkt, device);
		if (tx_req_is_set)
		__write_register(device, CVP_CPU_CS_H2ASOFTINT, 1);
		rc = 0;
		@@ -2607,7 +2372,7 @@ static int venus_hfi_session_set_buffers(void *sess,
		goto err_create_pkt;
		}

		dprintk(CVP_INFO, "set buffers: %#x\n", buffer_info->buffer_type);
		dprintk(CVP_DBG, "set buffers: %#x\n", buffer_info->buffer_type);
		if (__iface_cmdq_write(session->device, &pkt))
		rc = -ENOTEMPTY;

		@@ -2665,46 +2430,16 @@ static int venus_hfi_session_start(void *session)

		static int venus_hfi_session_continue(void *session)
		{
		struct hal_session *sess;
		struct venus_hfi_device *device;
		int rc = 0;

		if (!session) {
		dprintk(CVP_ERR, "Invalid Params %s\n", __func__);
		dprintk(CVP_ERR, "Deprecated function %s\n", __func__);
		return -EINVAL;
		}

		sess = session;
		device = sess->device;

		mutex_lock(&device->lock);
		rc = __send_session_cmd(sess, HFI_CMD_SESSION_CONTINUE);
		mutex_unlock(&device->lock);

		return rc;
		}

		static int venus_hfi_session_stop(void *session)
		{
		struct hal_session *sess;
		struct venus_hfi_device *device;
		int rc = 0;

		if (!session) {
		dprintk(CVP_ERR, "Invalid Params %s\n", __func__);
		dprintk(CVP_ERR, "Deprecated function %s\n", __func__);
		return -EINVAL;
		}

		sess = session;
		device = sess->device;

		mutex_lock(&device->lock);
		rc = __send_session_cmd(sess, HFI_CMD_SESSION_STOP);
		mutex_unlock(&device->lock);

		return rc;
		}

		static int venus_hfi_session_send(void *sess,
		struct cvp_kmd_hfi_packet *in_pkt)
		{
		@@ -2725,7 +2460,7 @@ static int venus_hfi_session_send(void *sess,
		rc = -EINVAL;
		goto err_send_pkt;
		}
		rc = call_hfi_pkt_op(device, session_cvp_hfi_packetize,
		rc = call_hfi_pkt_op(device, session_send,
		&pkt, session, in_pkt);
		if (rc) {
		dprintk(CVP_ERR,
		@@ -2779,35 +2514,8 @@ static int venus_hfi_session_get_buf_req(void *sess)

		static int venus_hfi_session_flush(void *sess, enum hal_flush flush_mode)
		{
		struct hfi_cmd_session_flush_packet pkt;
		int rc = 0;
		struct hal_session *session = sess;
		struct venus_hfi_device *device;

		if (!session \|\| !session->device) {
		dprintk(CVP_ERR, "invalid session");
		return -ENODEV;
		}

		device = session->device;
		mutex_lock(&device->lock);

		if (!__is_session_valid(device, session, __func__)) {
		rc = -EINVAL;
		goto err_create_pkt;
		}
		rc = call_hfi_pkt_op(device, session_flush,
		&pkt, session, flush_mode);
		if (rc) {
		dprintk(CVP_ERR, "Session flush: failed to create pkt\n");
		goto err_create_pkt;
		}

		if (__iface_cmdq_write(session->device, &pkt))
		rc = -ENOTEMPTY;
		err_create_pkt:
		mutex_unlock(&device->lock);
		return rc;
		dprintk(CVP_ERR, "Deprecated function %s\n", __func__);
		return -EINVAL;
		}

		static int __check_core_registered(struct hal_device_data core,
		@@ -4000,10 +3708,6 @@ static void interrupt_init_vpu5(struct venus_hfi_device *device)
		CVP_WRAPPER_INTR_MASK, mask_val);
		}

		static void interrupt_init_vpu4(struct venus_hfi_device *device)
		{
		}

		static void setup_dsp_uc_memmap_vpu5(struct venus_hfi_device *device)
		{
		/* initialize DSP QTBL & UCREGION with CPU queues */
		@@ -4397,85 +4101,9 @@ static int venus_hfi_get_core_capabilities(void *dev)
		return rc;
		}

		static void __noc_error_info(struct venus_hfi_device *device, u32 core_num)
		{
		u32 vcodec_core_video_noc_base_offs, val;

		if (!device) {
		dprintk(CVP_ERR, "%s: null device\n", __func__);
		return;
		}
		if (!core_num) {
		vcodec_core_video_noc_base_offs =
		VCODEC_CORE0_VIDEO_NOC_BASE_OFFS;
		} else if (core_num == 1) {
		vcodec_core_video_noc_base_offs =
		VCODEC_CORE1_VIDEO_NOC_BASE_OFFS;
		} else {
		dprintk(CVP_ERR, "%s: invalid core_num %u\n",
		__func__, core_num);
		return;
		}

		val = __read_register(device, vcodec_core_video_noc_base_offs +
		VCODEC_COREX_VIDEO_NOC_ERR_SWID_LOW_OFFS);
		dprintk(CVP_ERR, "CORE%d_NOC_ERR_SWID_LOW: %#x\n", core_num, val);
		val = __read_register(device, vcodec_core_video_noc_base_offs +
		VCODEC_COREX_VIDEO_NOC_ERR_SWID_HIGH_OFFS);
		dprintk(CVP_ERR, "CORE%d_NOC_ERR_SWID_HIGH: %#x\n", core_num, val);
		val = __read_register(device, vcodec_core_video_noc_base_offs +
		VCODEC_COREX_VIDEO_NOC_ERR_MAINCTL_LOW_OFFS);
		dprintk(CVP_ERR, "CORE%d_NOC_ERR_MAINCTL_LOW: %#x\n", core_num, val);
		val = __read_register(device, vcodec_core_video_noc_base_offs +
		VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG0_LOW_OFFS);
		dprintk(CVP_ERR, "CORE%d_NOC_ERR_ERRLOG0_LOW: %#x\n", core_num, val);
		val = __read_register(device, vcodec_core_video_noc_base_offs +
		VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG0_HIGH_OFFS);
		dprintk(CVP_ERR, "CORE%d_NOC_ERR_ERRLOG0_HIGH: %#x\n", core_num, val);
		val = __read_register(device, vcodec_core_video_noc_base_offs +
		VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG1_LOW_OFFS);
		dprintk(CVP_ERR, "CORE%d_NOC_ERR_ERRLOG1_LOW: %#x\n", core_num, val);
		val = __read_register(device, vcodec_core_video_noc_base_offs +
		VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG1_HIGH_OFFS);
		dprintk(CVP_ERR, "CORE%d_NOC_ERR_ERRLOG1_HIGH: %#x\n", core_num, val);
		val = __read_register(device, vcodec_core_video_noc_base_offs +
		VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG2_LOW_OFFS);
		dprintk(CVP_ERR, "CORE%d_NOC_ERR_ERRLOG2_LOW: %#x\n", core_num, val);
		val = __read_register(device, vcodec_core_video_noc_base_offs +
		VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG2_HIGH_OFFS);
		dprintk(CVP_ERR, "CORE%d_NOC_ERR_ERRLOG2_HIGH: %#x\n", core_num, val);
		val = __read_register(device, vcodec_core_video_noc_base_offs +
		VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG3_LOW_OFFS);
		dprintk(CVP_ERR, "CORE%d_NOC_ERR_ERRLOG3_LOW: %#x\n", core_num, val);
		val = __read_register(device, vcodec_core_video_noc_base_offs +
		VCODEC_COREX_VIDEO_NOC_ERR_ERRLOG3_HIGH_OFFS);
		dprintk(CVP_ERR, "CORE%d_NOC_ERR_ERRLOG3_HIGH: %#x\n", core_num, val);
		}

		static int venus_hfi_noc_error_info(void *dev)
		{
		struct venus_hfi_device *device;
		const u32 core0 = 0, core1 = 1;

		if (!dev) {
		dprintk(CVP_ERR, "%s: null device\n", __func__);
		return -EINVAL;
		}
		device = dev;

		mutex_lock(&device->lock);
		dprintk(CVP_ERR, "%s: non error information\n", __func__);

		if (__read_register(device, VCODEC_CORE0_VIDEO_NOC_BASE_OFFS +
		VCODEC_COREX_VIDEO_NOC_ERR_ERRVLD_LOW_OFFS))
		__noc_error_info(device, core0);

		if (__read_register(device, VCODEC_CORE1_VIDEO_NOC_BASE_OFFS +
		VCODEC_COREX_VIDEO_NOC_ERR_ERRVLD_LOW_OFFS))
		__noc_error_info(device, core1);

		mutex_unlock(&device->lock);

		dprintk(CVP_ERR, "%s not supported yet!\n", __func__);
		return 0;
		}

		@@ -4502,9 +4130,6 @@ static int __initialize_packetization(struct venus_hfi_device *device)

		void __init_cvp_ops(struct venus_hfi_device *device)
		{
		if (device->res->vpu_ver == VPU_VERSION_4)
		device->vpu_ops = &cvp_vpu4_ops;
		else
		device->vpu_ops = &cvp_vpu5_ops;
		}

		@@ -4578,6 +4203,8 @@ static struct venus_hfi_device *__add_device(u32 device_id,
		return hdevice;

		err_cleanup:
		if (hdevice->venus_pm_workq)
		destroy_workqueue(hdevice->venus_pm_workq);
		if (hdevice->cvp_workq)
		destroy_workqueue(hdevice->cvp_workq);
		kfree(hdevice->response_pkt);
		@@ -4647,7 +4274,7 @@ static void venus_init_hfi_callbacks(struct hfi_device *hdev)
		hdev->session_continue = venus_hfi_session_continue;
		hdev->session_stop = venus_hfi_session_stop;
		hdev->session_get_buf_req = venus_hfi_session_get_buf_req;
		hdev->session_cvp_hfi_send = venus_hfi_session_send;
		hdev->session_send = venus_hfi_session_send;
		hdev->session_flush = venus_hfi_session_flush;
		hdev->session_set_property = venus_hfi_session_set_property;
		hdev->session_get_property = venus_hfi_session_get_property;

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

+0 −409

Original line number	Diff line number	Diff line
		@@ -80,26 +80,6 @@
		#define HFI_INDEX_EXTRADATA_OUTPUT_CROP 0x0700000F
		#define HFI_INDEX_EXTRADATA_ASPECT_RATIO 0x7F100003

		struct hfi_buffer_alloc_mode {
		u32 buffer_type;
		u32 buffer_mode;
		};


		struct hfi_index_extradata_config {
		int enable;
		u32 index_extra_data_id;
		};

		struct hfi_extradata_header {
		u32 size;
		u32 version;
		u32 port_index;
		u32 type;
		u32 data_size;
		u8 rg_data[1];
		};

		#define HFI_INTERLACE_FRAME_PROGRESSIVE 0x01
		#define HFI_INTERLACE_INTERLEAVE_FRAME_TOPFIELDFIRST 0x02
		#define HFI_INTERLACE_INTERLEAVE_FRAME_BOTTOMFIELDFIRST 0x04
		@@ -222,60 +202,6 @@ struct hfi_extradata_header {
		#define HFI_PROPERTY_CONFIG_VPE_OX_START \
		(HFI_DOMAIN_BASE_VPE + HFI_ARCH_OX_OFFSET + 0x8000)

		struct hfi_batch_info {
		u32 input_batch_count;
		u32 output_batch_count;
		};

		struct hfi_buffer_count_actual {
		u32 buffer_type;
		u32 buffer_count_actual;
		u32 buffer_count_min_host;
		};

		struct hfi_buffer_size_minimum {
		u32 buffer_type;
		u32 buffer_size;
		};

		struct hfi_buffer_requirements {
		u32 buffer_type;
		u32 buffer_size;
		u32 buffer_region_size;
		u32 buffer_count_min;
		u32 buffer_count_min_host;
		u32 buffer_count_actual;
		u32 contiguous;
		u32 buffer_alignment;
		};

		struct hfi_data_payload {
		u32 size;
		u8 rg_data[1];
		};

		struct hfi_enable_picture {
		u32 picture_type;
		};

		struct hfi_mb_error_map {
		u32 error_map_size;
		u8 rg_error_map[1];
		};

		struct hfi_metadata_pass_through {
		int enable;
		u32 size;
		};

		struct hfi_multi_view_select {
		u32 view_index;
		};

		struct hfi_hybrid_hierp {
		u32 layers;
		};

		#define HFI_PRIORITY_LOW 10
		#define HFI_PRIOIRTY_MEDIUM 20
		#define HFI_PRIORITY_HIGH 30
		@@ -292,13 +218,6 @@ struct hfi_hybrid_hierp {
		#define HFI_RATE_CONTROL_MBR_VFR (HFI_OX_BASE + 0x7)
		#define HFI_RATE_CONTROL_CQ (HFI_OX_BASE + 0x8)


		struct hfi_uncompressed_plane_actual_constraints_info {
		u32 buffer_type;
		u32 num_planes;
		struct hfi_uncompressed_plane_constraints rg_plane_format[1];
		};

		#define HFI_CMD_SYS_OX_START \
		(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_CMD_START_OFFSET + 0x0000)
		#define HFI_CMD_SYS_SESSION_ABORT (HFI_CMD_SYS_OX_START + 0x001)
		@@ -451,37 +370,12 @@ struct hfi_uncompressed_plane_actual_constraints_info {
		#define CVP_IFACEQ_VAR_LARGE_PKT_SIZE 512
		#define CVP_IFACEQ_VAR_HUGE_PKT_SIZE (1024*12)


		struct hfi_cmd_sys_session_abort_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		};

		struct hfi_cmd_sys_ping_packet {
		u32 size;
		u32 packet_type;
		u32 client_data;
		};

		struct hfi_cmd_session_load_resources_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		};

		struct hfi_cmd_session_start_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		};

		struct hfi_cmd_session_stop_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		};

		struct hfi_cmd_session_empty_buffer_compressed_packet {
		u32 size;
		u32 packet_type;
		@@ -519,24 +413,6 @@ struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet {
		u32 rgData[1];
		};

		struct hfi_cmd_session_empty_buffer_uncompressed_plane1_packet {
		u32 flags;
		u32 alloc_len;
		u32 filled_len;
		u32 offset;
		u32 packet_buffer2;
		u32 rgData[1];
		};

		struct hfi_cmd_session_empty_buffer_uncompressed_plane2_packet {
		u32 flags;
		u32 alloc_len;
		u32 filled_len;
		u32 offset;
		u32 packet_buffer3;
		u32 rgData[1];
		};

		struct hfi_cmd_session_fill_buffer_packet {
		u32 size;
		u32 packet_type;
		@@ -558,18 +434,6 @@ struct hfi_cmd_session_flush_packet {
		u32 flush_type;
		};

		struct hfi_cmd_session_suspend_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		};

		struct hfi_cmd_session_resume_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		};

		struct hfi_cmd_session_get_property_packet {
		u32 size;
		u32 packet_type;
		@@ -621,279 +485,6 @@ struct hfi_msg_sys_property_info_packet {
		u32 rg_property_data[1];
		};

		struct hfi_msg_session_load_resources_done_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 error_type;
		};

		struct hfi_msg_session_start_done_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 error_type;
		};

		struct hfi_msg_session_stop_done_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 error_type;
		};

		struct hfi_msg_session_suspend_done_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 error_type;
		};

		struct hfi_msg_session_resume_done_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 error_type;
		};

		struct hfi_msg_session_flush_done_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 error_type;
		u32 flush_type;
		};

		struct hfi_ubwc_cr_stats_info_type {
		u32 cr_stats_info0;
		u32 cr_stats_info1;
		u32 cr_stats_info2;
		u32 cr_stats_info3;
		u32 cr_stats_info4;
		u32 cr_stats_info5;
		u32 cr_stats_info6;
		};

		struct hfi_frame_cr_stats_type {
		u32 frame_index;
		struct hfi_ubwc_cr_stats_info_type ubwc_stats_info;
		u32 complexity_number;
		};

		struct hfi_msg_session_empty_buffer_done_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 error_type;
		u32 offset;
		u32 filled_len;
		u32 input_tag;
		u32 packet_buffer;
		u32 extra_data_buffer;
		u32 flags;
		struct hfi_frame_cr_stats_type ubwc_cr_stats;
		u32 rgData[0];
		};

		struct hfi_msg_session_fill_buffer_done_compressed_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 time_stamp_hi;
		u32 time_stamp_lo;
		u32 error_type;
		u32 flags;
		u32 mark_target;
		u32 mark_data;
		u32 stats;
		u32 offset;
		u32 alloc_len;
		u32 filled_len;
		u32 input_tag;
		u32 output_tag;
		u32 picture_type;
		u32 packet_buffer;
		u32 extra_data_buffer;
		u32 rgData[0];
		};

		struct hfi_msg_session_fbd_uncompressed_plane0_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 stream_id;
		u32 view_id;
		u32 error_type;
		u32 time_stamp_hi;
		u32 time_stamp_lo;
		u32 flags;
		u32 mark_target;
		u32 mark_data;
		u32 stats;
		u32 alloc_len;
		u32 filled_len;
		u32 offset;
		u32 frame_width;
		u32 frame_height;
		u32 start_x_coord;
		u32 start_y_coord;
		u32 input_tag;
		u32 input_tag2;
		u32 output_tag;
		u32 picture_type;
		u32 packet_buffer;
		u32 extra_data_buffer;
		u32 rgData[0];
		};

		struct hfi_msg_session_fill_buffer_done_uncompressed_plane1_packet {
		u32 flags;
		u32 alloc_len;
		u32 filled_len;
		u32 offset;
		u32 packet_buffer2;
		u32 rgData[0];
		};

		struct hfi_msg_session_fill_buffer_done_uncompressed_plane2_packet {
		u32 flags;
		u32 alloc_len;
		u32 filled_len;
		u32 offset;
		u32 packet_buffer3;
		u32 rgData[0];
		};

		struct hfi_msg_session_property_info_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 num_properties;
		u32 rg_property_data[1];
		};

		struct hfi_msg_session_release_resources_done_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 error_type;
		};

		struct hfi_msg_session_release_buffers_done_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 error_type;
		u32 num_buffers;
		u32 rg_buffer_info[1];
		};

		struct hfi_extradata_mb_quantization_payload {
		u8 rg_mb_qp[1];
		};

		struct hfi_extradata_timestamp_payload {
		u32 time_stamp_low;
		u32 time_stamp_high;
		};


		struct hfi_extradata_s3d_frame_packing_payload {
		u32 fpa_id;
		int cancel_flag;
		u32 fpa_type;
		int quin_cunx_flag;
		u32 content_interprtation_type;
		int spatial_flipping_flag;
		int frame0_flipped_flag;
		int field_views_flag;
		int current_frame_isFrame0_flag;
		int frame0_self_contained_flag;
		int frame1_self_contained_flag;
		u32 frame0_graid_pos_x;
		u32 frame0_graid_pos_y;
		u32 frame1_graid_pos_x;
		u32 frame1_graid_pos_y;
		u32 fpa_reserved_byte;
		u32 fpa_repetition_period;
		int fpa_extension_flag;
		};

		struct hfi_extradata_interlace_video_payload {
		u32 format;
		};

		struct hfi_conceal_color_type {
		u32 value_8bit;
		u32 value_10bit;
		};

		struct hfi_extradata_num_concealed_mb_payload {
		u32 num_mb_concealed;
		};

		struct hfi_extradata_sliceinfo {
		u32 offset_in_stream;
		u32 slice_length;
		};

		struct hfi_extradata_multislice_info_payload {
		u32 num_slices;
		struct hfi_extradata_sliceinfo rg_slice_info[1];
		};

		struct hfi_index_extradata_input_crop_payload {
		u32 size;
		u32 version;
		u32 port_index;
		u32 left;
		u32 top;
		u32 width;
		u32 height;
		};

		struct hfi_index_extradata_output_crop_payload {
		u32 size;
		u32 version;
		u32 port_index;
		u32 left;
		u32 top;
		u32 display_width;
		u32 display_height;
		u32 width;
		u32 height;
		};

		struct hfi_index_extradata_digital_zoom_payload {
		u32 size;
		u32 version;
		u32 port_index;
		int width;
		int height;
		};

		struct hfi_index_extradata_aspect_ratio_payload {
		u32 size;
		u32 version;
		u32 port_index;
		u32 aspect_width;
		u32 aspect_height;
		};

		struct hfi_extradata_frame_type_payload {
		u32 frame_rate;
		};

		struct hfi_extradata_recovery_point_sei_payload {
		u32 flag;
		};

		struct hfi_cmd_session_continue_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		};

		enum session_flags {
		SESSION_PAUSE = BIT(1),
		};

drivers/media/platform/msm/cvp/cvp_hfi_api.h

+1 −5

Original line number	Diff line number	Diff line
		@@ -1469,7 +1469,7 @@ struct hfi_device {
		int (session_start)(void sess);
		int (session_continue)(void sess);
		int (session_stop)(void sess);
		int (session_cvp_hfi_send)(void sess,
		int (session_send)(void sess,
		struct cvp_kmd_hfi_packet *in_pkt);
		int (session_get_buf_req)(void sess);
		int (session_flush)(void sess, enum hal_flush flush_mode);
		@@ -1499,10 +1499,6 @@ struct hfi_device *cvp_hfi_initialize(enum msm_cvp_hfi_type hfi_type,
		hfi_cmd_response_callback callback);
		void cvp_hfi_deinitialize(enum msm_cvp_hfi_type hfi_type,
		struct hfi_device *hdev);
		u32 cvp_get_hfi_domain(enum hal_domain hal_domain);
		u32 cvp_get_hfi_codec(enum hal_video_codec hal_codec);
		enum hal_domain cvp_get_hal_domain(u32 hfi_domain);
		enum hal_video_codec cvp_get_hal_codec(u32 hfi_codec);

		int get_pkt_index(struct cvp_hal_session_cmd_pkt *hdr);
		extern const struct msm_cvp_hfi_defs cvp_hfi_defs[];

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

+6 −1572

File changed.

Preview size limit exceeded, changes collapsed.

drivers/media/platform/msm/cvp/hfi_packetization.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -79,7 +79,7 @@ struct hfi_packetization_ops {
		int (*session_sync_process)(
		struct hfi_cmd_session_sync_process_packet *pkt,
		struct hal_session *session);
		int (*session_cvp_hfi_packetize)(
		int (*session_send)(
		struct cvp_kmd_hfi_packet *out_pkt,
		struct hal_session *session,
		struct cvp_kmd_hfi_packet *in_pkt);