Merge "msm: cvp: Enable DFS and DME features on CVP" (adc05896) · Commits · e / devices / android_kernel_fairphone_FP4

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

+224 −163

Original line number	Diff line number	Diff line
		@@ -249,17 +249,6 @@ static void __sim_modify_cmd_packet(u8 packet, struct venus_hfi_device device)
		}
		break;
		}
		case HFI_CMD_SESSION_REGISTER_BUFFERS:
		{
		struct hfi_cmd_session_register_buffers_packet *pkt =
		(struct hfi_cmd_session_register_buffers_packet *)
		packet;
		struct hfi_buffer_mapping_type *buf =
		(struct hfi_buffer_mapping_type *)pkt->buffer;
		for (i = 0; i < pkt->num_buffers; i++)
		buf[i].device_addr -= fw_bias;
		break;
		}
		default:
		break;
		}
		@@ -2602,129 +2591,169 @@ static int venus_hfi_session_release_buffers(void *sess,
		return rc;
		}

		static int venus_hfi_session_register_buffer(void *sess,
		struct cvp_register_buffer *buffer)
		static int venus_hfi_session_start(void *session)
		{
		int rc = 0;
		u8 packet[CVP_IFACEQ_VAR_LARGE_PKT_SIZE];
		struct hfi_cmd_session_register_buffers_packet *pkt;
		struct hal_session *session = sess;
		dprintk(CVP_ERR, "Deprecated function %s\n", __func__);
		return -EINVAL;
		}

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

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

		sess = session;
		device = sess->device;

		mutex_lock(&device->lock);
		if (!__is_session_valid(device, session, __func__)) {
		rc = -EINVAL;
		goto exit;
		rc = __send_session_cmd(sess, HFI_CMD_SESSION_CONTINUE);
		mutex_unlock(&device->lock);

		return rc;
		}
		pkt = (struct hfi_cmd_session_register_buffers_packet *)packet;
		rc = call_hfi_pkt_op(device, session_register_buffer, pkt,
		session, buffer);
		if (rc) {
		dprintk(CVP_ERR, "%s: failed to create packet\n", __func__);
		goto exit;

		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__);
		return -EINVAL;
		}
		if (__iface_cmdq_write(session->device, pkt))
		rc = -ENOTEMPTY;
		exit:

		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_unregister_buffer(void *sess,
		struct cvp_unregister_buffer *buffer)
		static int venus_hfi_session_cvp_dme_config(void *sess,
		struct msm_cvp_internal_dmeconfig *dme_config)
		{
		int rc = 0;
		u8 packet[CVP_IFACEQ_VAR_LARGE_PKT_SIZE];
		struct hfi_cmd_session_unregister_buffers_packet *pkt;
		struct hfi_cmd_session_cvp_dme_config_packet pkt;
		struct hal_session *session = sess;
		struct venus_hfi_device *device;

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

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

		if (!__is_session_valid(device, session, __func__)) {
		rc = -EINVAL;
		goto exit;
		goto dme_config_err;
		}
		pkt = (struct hfi_cmd_session_unregister_buffers_packet *)packet;
		rc = call_hfi_pkt_op(device, session_unregister_buffer, pkt,
		session, buffer);
		rc = call_hfi_pkt_op(device, session_cvp_dme_config,
		&pkt, session, dme_config);
		if (rc) {
		dprintk(CVP_ERR, "%s: failed to create packet\n", __func__);
		goto exit;
		dprintk(CVP_ERR,
		"Session get buf req: failed to create pkt\n");
		goto dme_config_err;
		}
		if (__iface_cmdq_write(session->device, pkt))

		if (__iface_cmdq_write(session->device, &pkt))
		rc = -ENOTEMPTY;
		exit:
		dprintk(CVP_DBG, "%s: calling __iface_cmdq_write\n", __func__);
		dme_config_err:
		mutex_unlock(&device->lock);

		return rc;
		}

		static int venus_hfi_session_start(void *session)
		static int venus_hfi_session_cvp_dme_frame(void *sess,
		struct msm_cvp_internal_dmeframe *dme_frame)
		{
		dprintk(CVP_ERR, "Deprecated function %s\n", __func__);
		return -EINVAL;
		}

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

		if (!session) {
		dprintk(CVP_ERR, "Invalid Params %s\n", __func__);
		return -EINVAL;
		if (!session \|\| !session->device) {
		dprintk(CVP_ERR, "invalid session");
		return -ENODEV;
		}

		sess = session;
		device = sess->device;

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

		if (!__is_session_valid(device, session, __func__)) {
		rc = -EINVAL;
		goto dme_frame_err;
		}
		rc = call_hfi_pkt_op(device, session_cvp_dme_frame,
		&pkt, session, dme_frame);
		if (rc) {
		dprintk(CVP_ERR,
		"Session get buf req: failed to create pkt\n");
		goto dme_frame_err;
		}

		if (__iface_cmdq_write(session->device, &pkt))
		rc = -ENOTEMPTY;
		dprintk(CVP_DBG, "%s: done calling __iface_cmdq_write\n", __func__);
		dme_frame_err:
		mutex_unlock(&device->lock);
		return rc;
		}

		static int venus_hfi_session_stop(void *session)

		static int venus_hfi_session_cvp_persist(void *sess,
		struct msm_cvp_internal_persist_cmd *pbuf_cmd)
		{
		struct hal_session *sess;
		struct venus_hfi_device *device;
		int rc = 0;
		struct hfi_cmd_session_cvp_persist_packet pkt;
		struct hal_session *session = sess;
		struct venus_hfi_device *device;

		if (!session) {
		dprintk(CVP_ERR, "Invalid Params %s\n", __func__);
		return -EINVAL;
		if (!session \|\| !session->device) {
		dprintk(CVP_ERR, "invalid session");
		return -ENODEV;
		}

		sess = session;
		device = sess->device;

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

		if (!__is_session_valid(device, session, __func__)) {
		rc = -EINVAL;
		goto persist_err;
		}
		rc = call_hfi_pkt_op(device, session_cvp_persist,
		&pkt, session, pbuf_cmd);
		if (rc) {
		dprintk(CVP_ERR,
		"Failed to create persist pkt\n");
		goto persist_err;
		}

		if (__iface_cmdq_write(session->device, &pkt))
		rc = -ENOTEMPTY;

		dprintk(CVP_DBG, "%s: done calling __iface_cmdq_write\n", __func__);
		persist_err:
		mutex_unlock(&device->lock);
		return rc;
		}

		static int venus_hfi_session_cvp_dfs_config(void *sess,
		struct msm_cvp_dfsconfig *dfs_config)
		struct msm_cvp_internal_dfsconfig *dfs_config)
		{
		int rc = 0;
		struct hfi_cmd_session_cvp_dfs_config pkt;
		struct hfi_cmd_session_cvp_dfs_config_packet pkt;
		struct hal_session *session = sess;
		struct venus_hfi_device *device;

		@@ -2760,10 +2789,10 @@ static int venus_hfi_session_cvp_dfs_config(void *sess,
		}

		static int venus_hfi_session_cvp_dfs_frame(void *sess,
		struct msm_cvp_dfsframe *dfs_frame)
		struct msm_cvp_internal_dfsframe *dfs_frame)
		{
		int rc = 0;
		struct hfi_cmd_session_cvp_dfs_frame pkt;
		struct hfi_cmd_session_cvp_dfs_frame_packet pkt;
		struct hal_session *session = sess;
		struct venus_hfi_device *device;

		@@ -2796,12 +2825,6 @@ static int venus_hfi_session_cvp_dfs_frame(void *sess,
		return rc;
		}

		static int venus_hfi_session_cvp_send_cmd(void *sess,
		struct cvp_frame_data *input_frame)
		{
		return 0;
		}

		static int venus_hfi_session_get_buf_req(void *sess)
		{
		struct hfi_cmd_session_get_property_packet pkt;
		@@ -3205,6 +3228,80 @@ static struct hal_session __get_session(struct venus_hfi_device device,
		return NULL;
		}

		#define _INVALID_MSG_ "Unrecognized MSG (%#x) session (%pK), discarding\n"
		#define _INVALID_STATE_ "Ignore responses from %d to %d invalid state\n"
		#define _DEVFREQ_FAIL_ "Failed to add devfreq device bus %s governor %s: %d\n"

		static void process_system_msg(struct msm_cvp_cb_info *info,
		struct venus_hfi_device *device,
		void *raw_packet)
		{
		struct cvp_hal_sys_init_done sys_init_done = {0};

		switch (info->response_type) {
		case HAL_SYS_ERROR:
		__process_sys_error(device);
		break;
		case HAL_SYS_RELEASE_RESOURCE_DONE:
		dprintk(CVP_DBG, "Received SYS_RELEASE_RESOURCE\n");
		break;
		case HAL_SYS_INIT_DONE:
		dprintk(CVP_DBG, "Received SYS_INIT_DONE\n");

		sys_init_done.capabilities =
		device->sys_init_capabilities;
		cvp_hfi_process_sys_init_done_prop_read(
		(struct hfi_msg_sys_init_done_packet *)
		raw_packet, &sys_init_done);
		info->response.cmd.data.sys_init_done = sys_init_done;
		break;
		default:
		break;
		}
		}


		static void *get_session_id(struct msm_cvp_cb_info info)
		{
		void **session_id = NULL;

		/* For session-related packets, validate session */
		switch (info->response_type) {
		case HAL_SESSION_INIT_DONE:
		case HAL_SESSION_END_DONE:
		case HAL_SESSION_ABORT_DONE:
		case HAL_SESSION_STOP_DONE:
		case HAL_SESSION_FLUSH_DONE:
		case HAL_SESSION_SET_BUFFER_DONE:
		case HAL_SESSION_SUSPEND_DONE:
		case HAL_SESSION_RESUME_DONE:
		case HAL_SESSION_SET_PROP_DONE:
		case HAL_SESSION_GET_PROP_DONE:
		case HAL_SESSION_RELEASE_BUFFER_DONE:
		case HAL_SESSION_REGISTER_BUFFER_DONE:
		case HAL_SESSION_UNREGISTER_BUFFER_DONE:
		case HAL_SESSION_DFS_CONFIG_CMD_DONE:
		case HAL_SESSION_DME_CONFIG_CMD_DONE:
		case HAL_SESSION_DFS_FRAME_CMD_DONE:
		case HAL_SESSION_DME_FRAME_CMD_DONE:
		case HAL_SESSION_PERSIST_CMD_DONE:
		case HAL_SESSION_PROPERTY_INFO:
		session_id = &info->response.cmd.session_id;
		break;
		case HAL_SESSION_ERROR:
		session_id = &info->response.data.session_id;
		break;
		case HAL_SESSION_EVENT_CHANGE:
		session_id = &info->response.event.session_id;
		break;
		case HAL_RESPONSE_UNUSED:
		default:
		session_id = NULL;
		break;
		}
		return session_id;
		}

		static int __response_handler(struct venus_hfi_device *device)
		{
		struct msm_cvp_cb_info *packets;
		@@ -3249,7 +3346,6 @@ static int __response_handler(struct venus_hfi_device *device)
		while (!__iface_msgq_read(device, raw_packet)) {
		void **session_id = NULL;
		struct msm_cvp_cb_info *info = &packets[packet_count++];
		struct cvp_hal_sys_init_done sys_init_done = {0};
		int rc = 0;

		rc = cvp_hfi_process_msg_packet(device->device_id,
		@@ -3262,59 +3358,9 @@ static int __response_handler(struct venus_hfi_device *device)
		}

		/* Process the packet types that we're interested in */
		switch (info->response_type) {
		case HAL_SYS_ERROR:
		__process_sys_error(device);
		break;
		case HAL_SYS_RELEASE_RESOURCE_DONE:
		dprintk(CVP_DBG, "Received SYS_RELEASE_RESOURCE\n");
		break;
		case HAL_SYS_INIT_DONE:
		dprintk(CVP_DBG, "Received SYS_INIT_DONE\n");

		sys_init_done.capabilities =
		device->sys_init_capabilities;
		cvp_hfi_process_sys_init_done_prop_read(
		(struct hfi_msg_sys_init_done_packet *)
		raw_packet, &sys_init_done);
		info->response.cmd.data.sys_init_done = sys_init_done;
		break;
		default:
		break;
		}

		/* For session-related packets, validate session */
		switch (info->response_type) {
		case HAL_SESSION_INIT_DONE:
		case HAL_SESSION_END_DONE:
		case HAL_SESSION_ABORT_DONE:
		case HAL_SESSION_STOP_DONE:
		case HAL_SESSION_FLUSH_DONE:
		case HAL_SESSION_SET_BUFFER_DONE:
		case HAL_SESSION_SUSPEND_DONE:
		case HAL_SESSION_RESUME_DONE:
		case HAL_SESSION_SET_PROP_DONE:
		case HAL_SESSION_GET_PROP_DONE:
		case HAL_SESSION_RELEASE_BUFFER_DONE:
		case HAL_SESSION_REGISTER_BUFFER_DONE:
		case HAL_SESSION_UNREGISTER_BUFFER_DONE:
		case HAL_SESSION_DFS_CONFIG_CMD_DONE:
		case HAL_SESSION_DFS_FRAME_CMD_DONE:
		case HAL_SESSION_PROPERTY_INFO:
		session_id = &info->response.cmd.session_id;
		break;
		case HAL_SESSION_ERROR:
		session_id = &info->response.data.session_id;
		break;
		case HAL_SESSION_EVENT_CHANGE:
		session_id = &info->response.event.session_id;
		break;
		case HAL_RESPONSE_UNUSED:
		default:
		session_id = NULL;
		break;
		}
		process_system_msg(info, device, raw_packet);

		session_id = get_session_id(info);
		/*
		* hfi_process_msg_packet provides a session_id that's a hashed
		* value of struct hal_session, we need to coerce the hashed
		@@ -3333,8 +3379,7 @@ static int __response_handler(struct venus_hfi_device *device)
		session = __get_session(device,
		(u32)(uintptr_t)*session_id);
		if (!session) {
		dprintk(CVP_ERR,
		"Received a packet (%#x) for an unrecognized session (%pK), discarding\n",
		dprintk(CVP_ERR, _INVALID_MSG_,
		info->response_type,
		*session_id);
		--packet_count;
		@@ -3347,7 +3392,7 @@ static int __response_handler(struct venus_hfi_device *device)
		if (packet_count >= cvp_max_packets &&
		__get_q_size(device, CVP_IFACEQ_MSGQ_IDX)) {
		dprintk(CVP_WARN,
		"Too many packets in message queue to handle at once, deferring read\n");
		"Too many packets in message queue!\n");
		break;
		}

		@@ -3420,8 +3465,7 @@ static void venus_hfi_core_work_handler(struct work_struct *work)

		if (!__core_in_valid_state(device)) {
		dprintk(CVP_ERR,
		"Ignore responses from %d to %d as device is in invalid state",
		(i + 1), num_responses);
		_INVALID_STATE_, (i + 1), num_responses);
		break;
		}
		dprintk(CVP_DBG, "Processing response %d of %d, type %d\n",
		@@ -3732,8 +3776,7 @@ static int __init_bus(struct venus_hfi_device *device)
		&bus->devfreq_prof, bus->governor, NULL);
		if (IS_ERR_OR_NULL(bus->devfreq)) {
		rc = PTR_ERR(bus->devfreq) ?: -EBADHANDLE;
		dprintk(CVP_ERR,
		"Failed to add devfreq device for bus %s and governor %s: %d\n",
		dprintk(CVP_ERR, _DEVFREQ_FAIL_,
		bus->name, bus->governor, rc);
		bus->devfreq = NULL;
		goto err_add_dev;
		@@ -3969,6 +4012,19 @@ static int __enable_regulators(struct venus_hfi_device *device)
		dprintk(CVP_DBG, "Enabling regulators\n");

		venus_hfi_for_each_regulator(device, rinfo) {
		if (rinfo->has_hw_power_collapse) {
		rc = regulator_set_mode(rinfo->regulator,
		REGULATOR_MODE_FAST);
		if (rc) {
		dprintk(CVP_ERR,
		"Failed to enable hwctrl%s: %d\n",
		rinfo->name, rc);
		goto err_reg_enable_failed;
		}
		dprintk(CVP_DBG, "Enabled regulator %s hw ctrl\n",
		rinfo->name);

		} else {
		rc = regulator_enable(rinfo->regulator);
		if (rc) {
		dprintk(CVP_ERR,
		@@ -3979,6 +4035,7 @@ static int __enable_regulators(struct venus_hfi_device *device)

		dprintk(CVP_DBG, "Enabled regulator %s\n",
		rinfo->name);
		}
		c++;
		}

		@@ -3997,8 +4054,12 @@ static int __disable_regulators(struct venus_hfi_device *device)

		dprintk(CVP_DBG, "Disabling regulators\n");

		venus_hfi_for_each_regulator_reverse(device, rinfo)
		venus_hfi_for_each_regulator_reverse(device, rinfo) {
		__disable_regulator(rinfo, device);
		if (rinfo->has_hw_power_collapse)
		regulator_set_mode(rinfo->regulator,
		REGULATOR_MODE_NORMAL);
		}

		return 0;
		}
		@@ -4085,7 +4146,7 @@ static int __venus_power_on(struct venus_hfi_device *device)
		rc = __scale_clocks(device);
		if (rc) {
		dprintk(CVP_WARN,
		"Failed to scale clocks, performance might be affected\n");
		"Failed to scale clocks, perf may regress\n");
		rc = 0;
		}

		@@ -4647,15 +4708,15 @@ static void venus_init_hfi_callbacks(struct hfi_device *hdev)
		hdev->session_clean = venus_hfi_session_clean;
		hdev->session_set_buffers = venus_hfi_session_set_buffers;
		hdev->session_release_buffers = venus_hfi_session_release_buffers;
		hdev->session_register_buffer = venus_hfi_session_register_buffer;
		hdev->session_unregister_buffer = venus_hfi_session_unregister_buffer;
		hdev->session_start = venus_hfi_session_start;
		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_dfs_config = venus_hfi_session_cvp_dfs_config;
		hdev->session_cvp_dfs_frame = venus_hfi_session_cvp_dfs_frame;
		hdev->session_cvp_send_cmd = venus_hfi_session_cvp_send_cmd;
		hdev->session_cvp_dme_config = venus_hfi_session_cvp_dme_config;
		hdev->session_cvp_dme_frame = venus_hfi_session_cvp_dme_frame;
		hdev->session_cvp_persist = venus_hfi_session_cvp_persist;
		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

+42 −50

Original line number	Diff line number	Diff line
		@@ -326,10 +326,6 @@ struct hfi_uncompressed_plane_actual_constraints_info {
		#define HFI_CMD_SESSION_CVP_START \
		(HFI_DOMAIN_BASE_CVP + HFI_ARCH_COMMON_OFFSET + \
		HFI_CMD_START_OFFSET + 0x1000)
		#define HFI_CMD_SESSION_REGISTER_BUFFERS \
		(HFI_CMD_SESSION_CVP_START + 0x0A0)
		#define HFI_CMD_SESSION_UNREGISTER_BUFFERS \
		(HFI_CMD_SESSION_CVP_START + 0x0A1)

		/* =============BASIC OPERATIONS=================*/
		#define HFI_CMD_SESSION_CVP_SET_BUFFERS\
		@@ -384,6 +380,13 @@ struct hfi_uncompressed_plane_actual_constraints_info {
		#define HFI_CMD_SESSION_CVP_PYS_HCD_CONFIG\
		(HFI_CMD_SESSION_CVP_START + 0x017)

		#define HFI_CMD_SESSION_CVP_DME_CONFIG\
		(HFI_CMD_SESSION_CVP_START + 0x039)
		#define HFI_CMD_SESSION_CVP_DME_FRAME\
		(HFI_CMD_SESSION_CVP_START + 0x03A)

		#define HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS\
		(HFI_CMD_SESSION_CVP_START + 0x04D)

		#define HFI_MSG_SYS_OX_START \
		(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_MSG_START_OFFSET + 0x0000)
		@@ -409,10 +412,6 @@ struct hfi_uncompressed_plane_actual_constraints_info {
		#define HFI_MSG_SESSION_CVP_START \
		(HFI_DOMAIN_BASE_CVP + HFI_ARCH_COMMON_OFFSET + \
		HFI_MSG_START_OFFSET + 0x1000)
		#define HFI_MSG_SESSION_REGISTER_BUFFERS_DONE \
		(HFI_MSG_SESSION_CVP_START + 0x0A0)
		#define HFI_MSG_SESSION_UNREGISTER_BUFFERS_DONE \
		(HFI_MSG_SESSION_CVP_START + 0x0A1)

		/* =================BASIC OPERATIONS=================*/
		#define HFI_MSG_SESSION_CVP_SET_BUFFERS\
		@@ -436,7 +435,12 @@ struct hfi_uncompressed_plane_actual_constraints_info {
		#define HFI_MSG_SESSION_CVP_FTEXT\
		(HFI_MSG_SESSION_CVP_START + 0x00A)

		#define HFI_MSG_SESSION_CVP_OPERATION_CONFIG (HFI_MSG_SESSION_CVP_START + 0x010)
		#define HFI_MSG_SESSION_CVP_DME\
		(HFI_MSG_SESSION_CVP_START + 0x023)
		#define HFI_MSG_SESSION_CVP_OPERATION_CONFIG (HFI_MSG_SESSION_CVP_START + 0x030)

		#define HFI_MSG_SESSION_CVP_SET_PERSIST_BUFFERS\
		(HFI_MSG_SESSION_CVP_START + 0x034)

		#define CVP_IFACEQ_MAX_PKT_SIZE 1024
		#define CVP_IFACEQ_MED_PKT_SIZE 768
		@@ -577,36 +581,40 @@ struct HFI_CVP_COLOR_PLANE_INFO {
		u32 buf_size[HFI_MAX_PLANES];
		};

		struct hfi_cmd_session_cvp_dfs_config {
		struct hfi_cmd_session_hdr {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 srcbuffer_format;
		struct HFI_CVP_COLOR_PLANE_INFO left_plane_info;
		struct HFI_CVP_COLOR_PLANE_INFO right_plane_info;
		u32 width;
		u32 height;
		u32 occlusionmask_enable;
		u32 occlusioncost;
		u32 occlusionbound;
		u32 occlusionshift;
		u32 maxdisparity;
		u32 disparityoffset;
		u32 medianfilter_enable;
		u32 occlusionfilling_enable;
		u32 occlusionmaskdump;
		struct hfi_cvp_client_data clientdata;
		};

		struct hfi_cmd_session_cvp_dfs_frame {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 left_buffer_index;
		u32 right_buffer_index;
		u32 disparitymap_buffer_idx;
		u32 occlusionmask_buffer_idx;
		struct hfi_cvp_client_data clientdata;
		struct hfi_cmd_session_cvp_dfs_config_packet {
		u32 cvp_internal_dfs_config[CVP_DFS_CONFIG_CMD_SIZE];
		};

		struct hfi_cmd_session_cvp_dfs_frame_packet {
		u32 cvp_dfs_frame[CVP_DFS_FRAME_BUFFERS_OFFSET];
		u32 left_view_buffer_addr;
		u32 left_view_buffer_size;
		u32 right_view_buffer_addr;
		u32 right_view_buffer_size;
		u32 disparity_map_buffer_addr;
		u32 disparity_map_buffer_size;
		u32 occlusion_mask_buffer_addr;
		u32 occlusion_mask_buffer_size;
		};

		struct hfi_cmd_session_cvp_dme_config_packet {
		u32 cvp_internal_dme_config[CVP_DME_CONFIG_CMD_SIZE];
		};

		struct hfi_cmd_session_cvp_dme_frame_packet {
		u32 cvp_dme_frame[CVP_DME_FRAME_BUFFERS_OFFSET];
		struct buf_desc bufs[8];
		};

		struct hfi_cmd_session_cvp_persist_packet {
		u32 cvp_persist_frame[CVP_PERSIST_BUFFERS_OFFSET];
		struct buf_desc bufs[CVP_PSRSIST_BUF_NUM];
		};

		struct hfi_cmd_session_release_buffer_packet {
		@@ -814,22 +822,6 @@ struct hfi_msg_session_release_buffers_done_packet {
		u32 rg_buffer_info[1];
		};

		struct hfi_msg_session_register_buffers_done_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 client_data;
		u32 error_type;
		};

		struct hfi_msg_session_unregister_buffers_done_packet {
		u32 size;
		u32 packet_type;
		u32 session_id;
		u32 client_data;
		u32 error_type;
		};

		struct hfi_extradata_mb_quantization_payload {
		u8 rg_mb_qp[1];
		};

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

+81 −29

Original line number	Diff line number	Diff line
		@@ -904,24 +904,6 @@ struct cvp_resource_hdr {
		void *resource_handle;
		};

		struct cvp_register_buffer {
		enum hal_buffer type;
		u32 index;
		u32 size;
		u32 device_addr;
		u32 response_required;
		u32 client_data;
		};

		struct cvp_unregister_buffer {
		enum hal_buffer type;
		u32 index;
		u32 size;
		u32 device_addr;
		u32 response_required;
		u32 client_data;
		};

		struct cvp_buffer_addr_info {
		enum hal_buffer buffer_type;
		u32 buffer_size;
		@@ -1118,7 +1100,6 @@ enum hal_command_response {
		HAL_SESSION_ABORT_DONE,
		HAL_SESSION_STOP_DONE,
		HAL_SESSION_CVP_OPERATION_CONFIG,
		HAL_SESSION_CVP_DFS,
		HAL_SESSION_FLUSH_DONE,
		HAL_SESSION_SUSPEND_DONE,
		HAL_SESSION_RESUME_DONE,
		@@ -1130,6 +1111,9 @@ enum hal_command_response {
		HAL_SESSION_RELEASE_RESOURCE_DONE,
		HAL_SESSION_DFS_CONFIG_CMD_DONE,
		HAL_SESSION_DFS_FRAME_CMD_DONE,
		HAL_SESSION_DME_CONFIG_CMD_DONE,
		HAL_SESSION_DME_FRAME_CMD_DONE,
		HAL_SESSION_PERSIST_CMD_DONE,
		HAL_SESSION_PROPERTY_INFO,
		HAL_SESSION_ERROR,
		HAL_RESPONSE_UNUSED = 0x10000000,
		@@ -1278,8 +1262,6 @@ struct msm_cvp_cb_cmd_done {
		struct cvp_hal_sys_init_done sys_init_done;
		struct cvp_hal_session_init_done session_init_done;
		struct hal_buffer_info buffer_info;
		struct cvp_register_buffer regbuf;
		struct cvp_unregister_buffer unregbuf;
		union hal_get_property property;
		enum hal_flush flush_type;
		} data;
		@@ -1428,6 +1410,76 @@ struct hal_vbv_hdr_buf_size {
		#define call_hfi_op(q, op, args...) \
		(((q) && (q)->op) ? ((q)->op(args)) : 0)

		/* DFS related structures */
		struct msm_cvp_internal_dfsconfig {
		struct list_head list;
		struct msm_smem smem;
		struct msm_cvp_dfs_config dfs_config;
		};

		struct buf_desc {
		u32 fd;
		u32 size;
		};

		/**
		* struct msm_cvp_dfs_frame_kmd - argument passed with VIDIOC_CVP_CMD
		* @cvp_dfs_frame: parameters for DFS frame command
		* @left_view_buffer_fd: fd for left view buffer
		* @left_view_buffer_size: size for left view buffer
		* @right_view_buffer_fd: fd for right view buffer
		* @right_view_buffer_size: size for right view buffer
		* @disparity_map_buffer_fd: fd for disparity map buffer
		* @disparity_map_buffer_size: size for disparity map buffer
		* @occlusion_mask_buffer_fd: fd for occlusion mask buffer
		* @occlusion_mask_buffer_size: size for occlusion mask buffer
		*/

		struct msm_cvp_dfs_frame_kmd {
		unsigned int cvp_dfs_frame[CVP_DFS_FRAME_BUFFERS_OFFSET];
		unsigned int left_view_buffer_fd;
		unsigned int left_view_buffer_size;
		unsigned int right_view_buffer_fd;
		unsigned int right_view_buffer_size;
		unsigned int disparity_map_buffer_fd;
		unsigned int disparity_map_buffer_size;
		unsigned int occlusion_mask_buffer_fd;
		unsigned int occlusion_mask_buffer_size;
		};


		struct msm_cvp_internal_dfsframe {
		struct list_head list;
		struct msm_cvp_dfs_frame_kmd dfs_frame;
		};

		/* DME related structures */
		struct msm_cvp_internal_dmeconfig {
		struct list_head list;
		struct msm_smem smem;
		struct msm_cvp_dme_config dme_config;
		};

		struct msm_cvp_dme_frame_kmd {
		unsigned int cvp_dme_frame[CVP_DME_FRAME_BUFFERS_OFFSET];
		struct buf_desc bufs[CVP_DME_BUF_NUM];
		};

		struct msm_cvp_internal_dmeframe {
		struct list_head list;
		struct msm_cvp_dme_frame_kmd dme_frame;
		};

		struct msm_cvp_persist_kmd {
		unsigned int cvp_pcmd[CVP_PERSIST_BUFFERS_OFFSET];
		struct buf_desc bufs[CVP_PSRSIST_BUF_NUM];
		};

		struct msm_cvp_internal_persist_cmd {
		struct list_head list;
		struct msm_cvp_persist_kmd persist_cmd;
		};

		struct hfi_device {
		void *hfi_device_data;

		@@ -1445,10 +1497,6 @@ struct hfi_device {
		struct cvp_buffer_addr_info *buffer_info);
		int (session_release_buffers)(void sess,
		struct cvp_buffer_addr_info *buffer_info);
		int (session_register_buffer)(void sess,
		struct cvp_register_buffer *buffer);
		int (session_unregister_buffer)(void sess,
		struct cvp_unregister_buffer *buffer);
		int (session_load_res)(void sess);
		int (session_release_res)(void sess);
		int (session_start)(void sess);
		@@ -1457,11 +1505,15 @@ struct hfi_device {
		int (session_cvp_operation_config)(void sess,
		struct cvp_frame_data *input_frame);
		int (session_cvp_dfs_config)(void sess,
		struct msm_cvp_dfsconfig *dfs_config);
		struct msm_cvp_internal_dfsconfig *dfs_config);
		int (session_cvp_dfs_frame)(void sess,
		struct msm_cvp_dfsframe *dfs_frame);
		int (session_cvp_send_cmd)(void sess,
		struct cvp_frame_data *input_frame);
		struct msm_cvp_internal_dfsframe *dfs_frame);
		int (session_cvp_dme_config)(void sess,
		struct msm_cvp_internal_dmeconfig *dme_config);
		int (session_cvp_dme_frame)(void sess,
		struct msm_cvp_internal_dmeframe *dme_frame);
		int (session_cvp_persist)(void sess,
		struct msm_cvp_internal_persist_cmd *pbuf_cmd);
		int (session_get_buf_req)(void sess);
		int (session_flush)(void sess, enum hal_flush flush_mode);
		int (session_set_property)(void sess, enum hal_property ptype,

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

+57 −25

File changed.

Preview size limit exceeded, changes collapsed.

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

+147 −175

File changed.

Preview size limit exceeded, changes collapsed.