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

Commit adc05896 authored by qctecmdr Service's avatar qctecmdr Service Committed by Gerrit - the friendly Code Review server
Browse files

Merge "msm: cvp: Enable DFS and DME features on CVP"

parents 5b40f23e 5c026fcb

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,