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

Commit 96c28c9a authored by Shalaj Jain's avatar Shalaj Jain
Browse files

msm: vidc: Initial changes for video driver 64 bit support 



Use ion_phys_addr_t type to hold all kinds of virtual addresses
and phys_addr_t for physical addresses.

Send zero clnt_data instead of vb_buffer address(truncated value)
to fw and get vb_buffer address in EBD/FBD using device address.

Change-Id: I610f96ba7add80daeddb5adb11a2d5a3f7ac52d3
Signed-off-by: default avatarShalaj Jain <shalajj@codeaurora.org>
parent 04ad2ccf

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

+31 −28
Original line number Diff line number Diff line
@@ -283,7 +283,7 @@ int create_pkt_set_cmd_sys_resource( 
		pkt->resource_type = HFI_RESOURCE_OCMEM;

		pkt->size += sizeof(struct hfi_resource_ocmem) - sizeof(u32);

		hfioc_mem->size = (u32)ocmem->len;

		hfioc_mem->mem = (u8 *) ocmem->addr;

		hfioc_mem->mem = (u32)ocmem->addr;

		break;

	}

	default:
@@ -577,15 +577,19 @@ int create_pkt_cmd_session_set_buffers( 
				sizeof(struct hfi_buffer_info));

		buff = (struct hfi_buffer_info *) pkt->rg_buffer_info;

		for (i = 0; i < pkt->num_buffers; i++) {

			buff->buffer_addr = buffer_info->align_device_addr;

			buff->extra_data_addr = buffer_info->extradata_addr;

			buff->buffer_addr =

				(u32)buffer_info->align_device_addr;

			buff->extra_data_addr =

				(u32)buffer_info->extradata_addr;

		}

	} else {

		pkt->extra_data_size = 0;

		pkt->size = sizeof(struct hfi_cmd_session_set_buffers_packet) +

			((buffer_info->num_buffers - 1) * sizeof(u32));

		for (i = 0; i < pkt->num_buffers; i++)

			pkt->rg_buffer_info[i] = buffer_info->align_device_addr;

		for (i = 0; i < pkt->num_buffers; i++) {

			pkt->rg_buffer_info[i] =

				(u32)buffer_info->align_device_addr;

		}

	}



	pkt->buffer_type = get_hfi_buffer(buffer_info->buffer_type);
@@ -614,15 +618,19 @@ int create_pkt_cmd_session_release_buffers( 
		struct hfi_buffer_info *buff;

		buff = (struct hfi_buffer_info *) pkt->rg_buffer_info;

		for (i = 0; i < pkt->num_buffers; i++) {

			buff->buffer_addr = buffer_info->align_device_addr;

			buff->extra_data_addr = buffer_info->extradata_addr;

			buff->buffer_addr =

				(u32)buffer_info->align_device_addr;

			buff->extra_data_addr =

				(u32)buffer_info->extradata_addr;

		}

		pkt->size = sizeof(struct hfi_cmd_session_set_buffers_packet) -

				sizeof(u32) + (buffer_info->num_buffers *

				sizeof(struct hfi_buffer_info));

	} else {

		for (i = 0; i < pkt->num_buffers; i++)

			pkt->rg_buffer_info[i] = buffer_info->align_device_addr;

		for (i = 0; i < pkt->num_buffers; i++) {

			pkt->rg_buffer_info[i] =

				(u32)buffer_info->align_device_addr;

		}

		pkt->extra_data_size = 0;

		pkt->size = sizeof(struct hfi_cmd_session_set_buffers_packet) +

			((buffer_info->num_buffers - 1) * sizeof(u32));
@@ -655,10 +663,9 @@ int create_pkt_cmd_session_etb_decoder( 
	pkt->alloc_len = input_frame->alloc_len;

	pkt->filled_len = input_frame->filled_len;

	pkt->input_tag = input_frame->clnt_data;

	pkt->packet_buffer = (u8 *) input_frame->device_addr;



	pkt->packet_buffer = (u32)input_frame->device_addr;

	if (!pkt->packet_buffer)

		return -EINVAL;

		rc = -EINVAL;

	return rc;

}
@@ -684,11 +691,10 @@ int create_pkt_cmd_session_etb_encoder( 
	pkt->alloc_len = input_frame->alloc_len;

	pkt->filled_len = input_frame->filled_len;

	pkt->input_tag = input_frame->clnt_data;

	pkt->packet_buffer = (u8 *) input_frame->device_addr;

	pkt->extra_data_buffer = (u8 *) input_frame->extradata_addr;



	pkt->packet_buffer = (u32)input_frame->device_addr;

	pkt->extra_data_buffer = (u32)input_frame->extradata_addr;

	if (!pkt->packet_buffer)

		return -EINVAL;

		rc = -EINVAL;

	return rc;

}
@@ -711,9 +717,8 @@ int create_pkt_cmd_session_ftb(struct hfi_cmd_session_fill_buffer_packet *pkt, 
	if (!output_frame->device_addr)

		return -EINVAL;



	pkt->packet_buffer = (u8 *) output_frame->device_addr;

	pkt->extra_data_buffer = (u8 *) output_frame->extradata_addr;



	pkt->packet_buffer = (u32)output_frame->device_addr;

	pkt->extra_data_buffer = (u32)output_frame->extradata_addr;

	pkt->alloc_len = output_frame->alloc_len;

	pkt->filled_len = output_frame->filled_len;

	pkt->offset = output_frame->offset;
@@ -738,8 +743,7 @@ int create_pkt_cmd_session_parse_seq_header( 
	pkt->header_len = seq_hdr->seq_hdr_len;

	if (!seq_hdr->seq_hdr)

		return -EINVAL;

	pkt->packet_buffer = seq_hdr->seq_hdr;



	pkt->packet_buffer = (u32)seq_hdr->seq_hdr;

	return rc;

}
@@ -758,8 +762,7 @@ int create_pkt_cmd_session_get_seq_hdr( 
	pkt->buffer_len = seq_hdr->seq_hdr_len;

	if (!seq_hdr->seq_hdr)

		return -EINVAL;

	pkt->packet_buffer = seq_hdr->seq_hdr;



	pkt->packet_buffer = (u32)seq_hdr->seq_hdr;

	return rc;

}
@@ -1160,7 +1163,7 @@ int create_pkt_cmd_session_set_property( 
			HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT;

		hfi = (struct hfi_profile_level *)

			&pkt->rg_property_data[1];

		hfi->level = (u32)prop->level;

		hfi->level = prop->level;

		hfi->profile = hal_to_hfi_type(HAL_PARAM_PROFILE_LEVEL_CURRENT,

				prop->profile);

		if (hfi->profile <= 0) {
@@ -1224,8 +1227,8 @@ int create_pkt_cmd_session_set_property( 
			break;

		default:

			dprintk(VIDC_ERR,

					"Invalid Rate control setting: 0x%x\n",

					(int)pdata);

					"Invalid Rate control setting: 0x%p\n",

					pdata);

			break;

		}

		pkt->size += sizeof(u32) * 2;
@@ -1251,7 +1254,7 @@ int create_pkt_cmd_session_set_property( 
			HFI_PROPERTY_PARAM_VENC_MPEG4_HEADER_EXTENSION;

		hfi = (struct hfi_mpeg4_header_extension *)

			&pkt->rg_property_data[1];

		hfi->header_extension = (u32) pdata;

		hfi->header_extension = (u32)(unsigned long) pdata;

		pkt->size += sizeof(u32) * 2;

		break;

	}

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

+80 −80
Original line number Diff line number Diff line
@@ -20,7 +20,7 @@ 
#include "msm_vidc_debug.h"

#include "vidc_hfi.h"



static enum vidc_status hfi_map_err_status(int hfi_err)

static enum vidc_status hfi_map_err_status(u32 hfi_err)

{

	enum vidc_status vidc_err;

	switch (hfi_err) {
@@ -125,8 +125,8 @@ static void hfi_process_sess_evt_seq_changed( 
				msm_vidc_cb_event));



	cmd_done.device_id = device_id;

	cmd_done.session_id = ((struct hal_session *) pkt->session_id)->

		session_id;

	cmd_done.session_id = ((struct hal_session *)

			(unsigned long)pkt->session_id)->session_id;

	cmd_done.status = VIDC_ERR_NONE;

	cmd_done.size = sizeof(struct msm_vidc_cb_event);

	num_properties_changed = pkt->event_data2;
@@ -203,14 +203,14 @@ static void hfi_process_evt_release_buffer_ref( 
				pkt->rg_ext_event_data;



	cmd_done.device_id = device_id;

	cmd_done.session_id = ((struct hal_session *) pkt->session_id)->

		session_id;

	cmd_done.session_id = ((struct hal_session *)

			(unsigned long)pkt->session_id)->session_id;

	cmd_done.status = VIDC_ERR_NONE;

	cmd_done.size = sizeof(struct msm_vidc_cb_event);



	event_notify.hal_event_type = HAL_EVENT_RELEASE_BUFFER_REFERENCE;

	event_notify.packet_buffer = data->packet_buffer;

	event_notify.exra_data_buffer = data->exra_data_buffer;

	event_notify.extra_data_buffer = data->extra_data_buffer;

	cmd_done.data = &event_notify;

	callback(VIDC_EVENT_CHANGE, &cmd_done);

}
@@ -230,8 +230,8 @@ static void hfi_process_session_error( 
	struct msm_vidc_cb_cmd_done cmd_done;

	memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));

	cmd_done.device_id = device_id;

	cmd_done.session_id = ((struct hal_session *) pkt->session_id)->

		session_id;

	cmd_done.session_id = ((struct hal_session *)

			(unsigned long)(pkt->session_id))->session_id;

	dprintk(VIDC_INFO, "Received : SESSION_ERROR with event id : %d\n",

		pkt->event_data1);

	switch (pkt->event_data1) {
@@ -259,7 +259,7 @@ static void hfi_process_event_notify( 
		dprintk(VIDC_ERR, "Invalid Params\n");

		return;

	}

	sess = (struct hal_session *)pkt->session_id;

	sess = (struct hal_session *)(unsigned long)pkt->session_id;



	switch (pkt->event_id) {

	case HFI_EVENT_SYS_ERROR:
@@ -317,7 +317,7 @@ static void hfi_process_sys_init_done( 
		return;

	}



	status = hfi_map_err_status((u32)pkt->error_type);

	status = hfi_map_err_status(pkt->error_type);



	if (!status) {

		if (pkt->num_properties == 0) {
@@ -401,7 +401,7 @@ static void hfi_process_sys_rel_resource_done( 
			pkt->size);

		return;

	}

	status = hfi_map_err_status((u32)pkt->error_type);

	status = hfi_map_err_status(pkt->error_type);

	cmd_done.device_id = device_id;

	cmd_done.session_id = 0;

	cmd_done.status = (u32) status;
@@ -476,7 +476,7 @@ enum vidc_status hfi_process_sess_init_done_prop_read( 
{

	u32 rem_bytes, num_properties;

	u8 *data_ptr;

	u32 status = VIDC_ERR_NONE;

	enum vidc_status status = VIDC_ERR_NONE;

	u32 prop_id, next_offset = 0;

	u32 prop_count = 0;
@@ -489,8 +489,7 @@ enum vidc_status hfi_process_sess_init_done_prop_read( 
		return VIDC_ERR_FAIL;

	}



	status = hfi_map_err_status((u32)pkt->error_type);



	status = hfi_map_err_status(pkt->error_type);

	if (status)

		return status;
@@ -857,8 +856,8 @@ static void hfi_process_session_prop_info( 
		memset(&buff_req, 0, sizeof(struct buffer_requirements));

		hfi_process_sess_get_prop_buf_req(pkt, &buff_req);

		cmd_done.device_id = device_id;

		cmd_done.session_id =

			((struct hal_session *) pkt->session_id)->session_id;

		cmd_done.session_id = ((struct hal_session *)

			(unsigned long)(pkt->session_id))->session_id;

		cmd_done.status = VIDC_ERR_NONE;

		cmd_done.data = &buff_req;

		cmd_done.size = sizeof(struct buffer_requirements);
@@ -867,8 +866,8 @@ static void hfi_process_session_prop_info( 
	case HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT:

		hfi_process_sess_get_prop_profile_level(pkt, &profile_level);

		cmd_done.device_id = device_id;

		cmd_done.session_id =

			((struct hal_session *) pkt->session_id)->session_id;

		cmd_done.session_id = ((struct hal_session *)

			(unsigned long)(pkt->session_id))->session_id;

		cmd_done.status = VIDC_ERR_NONE;

		cmd_done.data = &profile_level;

		cmd_done.size = sizeof(struct hal_profile_level);
@@ -903,15 +902,16 @@ static void hfi_process_session_init_done( 
				vidc_hal_session_init_done));



	cmd_done.device_id = device_id;

	cmd_done.session_id =

		((struct hal_session *) pkt->session_id)->session_id;

	cmd_done.status = hfi_map_err_status((u32)pkt->error_type);

	cmd_done.session_id = ((struct hal_session *)

		(unsigned long)(pkt->session_id))->session_id;

	cmd_done.status = hfi_map_err_status(pkt->error_type);

	cmd_done.data = &session_init_done;

	if (!cmd_done.status) {

		cmd_done.status = hfi_process_sess_init_done_prop_read(

			pkt, &session_init_done);

	} else {

		sess_close = (struct hal_session *)pkt->session_id;

		sess_close = (struct hal_session *)

			(unsigned long)pkt->session_id;

		if (sess_close) {

			dprintk(VIDC_INFO,

				"Sess init failed: Deleting session: 0x%x 0x%p\n",
@@ -944,9 +944,9 @@ static void hfi_process_session_load_res_done( 
	memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));



	cmd_done.device_id = device_id;

	cmd_done.session_id =

		((struct hal_session *) pkt->session_id)->session_id;

	cmd_done.status = hfi_map_err_status((u32)pkt->error_type);

	cmd_done.session_id = ((struct hal_session *)

		(unsigned long)(pkt->session_id))->session_id;

	cmd_done.status = hfi_map_err_status(pkt->error_type);

	cmd_done.data = NULL;

	cmd_done.size = 0;

	callback(SESSION_LOAD_RESOURCE_DONE, &cmd_done);
@@ -970,10 +970,10 @@ static void hfi_process_session_flush_done( 


	memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));

	cmd_done.device_id = device_id;

	cmd_done.session_id =

		((struct hal_session *) pkt->session_id)->session_id;

	cmd_done.status = hfi_map_err_status((u32)pkt->error_type);

	cmd_done.data = (void *) pkt->flush_type;

	cmd_done.session_id = ((struct hal_session *)

		(unsigned long)(pkt->session_id))->session_id;

	cmd_done.status = hfi_map_err_status(pkt->error_type);

	cmd_done.data = (void *)(unsigned long)pkt->flush_type;

	cmd_done.size = sizeof(u32);

	callback(SESSION_FLUSH_DONE, &cmd_done);

}
@@ -997,17 +997,19 @@ static void hfi_process_session_etb_done( 
	memset(&data_done, 0, sizeof(struct msm_vidc_cb_data_done));



	data_done.device_id = device_id;

	data_done.session_id =

		((struct hal_session *) pkt->session_id)->session_id;

	data_done.status = hfi_map_err_status((u32) pkt->error_type);

	data_done.session_id = ((struct hal_session *)

		(unsigned long)(pkt->session_id))->session_id;

	data_done.status = hfi_map_err_status(pkt->error_type);

	data_done.size = sizeof(struct msm_vidc_cb_data_done);

	data_done.clnt_data = (void *)pkt->input_tag;

	data_done.clnt_data = pkt->input_tag;

	data_done.input_done.offset = pkt->offset;

	data_done.input_done.filled_len = pkt->filled_len;

	data_done.input_done.packet_buffer = pkt->packet_buffer;

	data_done.input_done.extra_data_buffer = pkt->extra_data_buffer;

	data_done.input_done.packet_buffer =

		(ion_phys_addr_t)pkt->packet_buffer;

	data_done.input_done.extra_data_buffer =

		(ion_phys_addr_t)pkt->extra_data_buffer;

	data_done.input_done.status =

		hfi_map_err_status((u32) pkt->error_type);

		hfi_map_err_status(pkt->error_type);

	callback(SESSION_ETB_DONE, &data_done);

}
@@ -1018,7 +1020,8 @@ static void hfi_process_session_ftb_done( 
	struct msm_vidc_cb_data_done data_done;

	struct hfi_msg_session_fill_buffer_done_compressed_packet *pack =

	(struct hfi_msg_session_fill_buffer_done_compressed_packet *) msg_hdr;

	u32 is_decoder = ((struct hal_session *)pack->session_id)->is_decoder;

	u32 is_decoder = ((struct hal_session *)

			(unsigned long)(pack->session_id))->is_decoder;

	struct hal_session *session;



	if (!msg_hdr) {
@@ -1026,8 +1029,7 @@ static void hfi_process_session_ftb_done( 
		return;

	}



	session = (struct hal_session *)

		((struct hal_session *)	pack->session_id)->session_id;

	session = (struct hal_session *)(unsigned long)pack->session_id;

	dprintk(VIDC_DBG, "RECEIVED: SESSION_FTB_DONE[%u]\n",

		pack->session_id);
@@ -1051,11 +1053,10 @@ static void hfi_process_session_ftb_done( 
		}



		data_done.device_id = device_id;

		data_done.session_id = (u32) session;

		data_done.status = hfi_map_err_status((u32)

							pkt->error_type);

		data_done.session_id = (u32)(unsigned long) session;

		data_done.status = hfi_map_err_status(pkt->error_type);

		data_done.size = sizeof(struct msm_vidc_cb_data_done);

		data_done.clnt_data = (void *) pkt->input_tag;

		data_done.clnt_data = 0;



		data_done.output_done.timestamp_hi = pkt->time_stamp_hi;

		data_done.output_done.timestamp_lo = pkt->time_stamp_lo;
@@ -1067,30 +1068,28 @@ static void hfi_process_session_ftb_done( 
		data_done.output_done.alloc_len1 = pkt->alloc_len;

		data_done.output_done.filled_len1 = pkt->filled_len;

		data_done.output_done.picture_type = pkt->picture_type;

		data_done.output_done.packet_buffer1 = pkt->packet_buffer;

		data_done.output_done.packet_buffer1 =

			(ion_phys_addr_t)pkt->packet_buffer;

		data_done.output_done.extra_data_buffer =

			pkt->extra_data_buffer;

			(ion_phys_addr_t)pkt->extra_data_buffer;

		data_done.output_done.buffer_type = HAL_BUFFER_OUTPUT;

		dprintk(VIDC_DBG, "FBD: Received buf: %p, of len: %d\n",

				   pkt->packet_buffer, pkt->filled_len);

	} else if (is_decoder == 1) {

		struct hfi_msg_session_fbd_uncompressed_plane0_packet *pkt =

		(struct	hfi_msg_session_fbd_uncompressed_plane0_packet *)

		msg_hdr;

		if (sizeof(struct

		hfi_msg_session_fbd_uncompressed_plane0_packet)

		> pkt->size) {

		if (sizeof(

			struct hfi_msg_session_fbd_uncompressed_plane0_packet) >

			pkt->size) {

			dprintk(VIDC_ERR,

					"hal_process_session_ftb_done: bad_pkt_size\n");

			return;

		}



		data_done.device_id = device_id;

		data_done.session_id = (u32) session;

		data_done.status = hfi_map_err_status((u32)

			pkt->error_type);

		data_done.session_id = (u32)(unsigned long)session;

		data_done.status = hfi_map_err_status(pkt->error_type);

		data_done.size = sizeof(struct msm_vidc_cb_data_done);

		data_done.clnt_data = (void *)pkt->input_tag;

		data_done.clnt_data = 0;



		data_done.output_done.stream_id = pkt->stream_id;

		data_done.output_done.view_id = pkt->view_id;
@@ -1140,9 +1139,9 @@ static void hfi_process_session_start_done( 


	memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));

	cmd_done.device_id = device_id;

	cmd_done.session_id =

		((struct hal_session *) pkt->session_id)->session_id;

	cmd_done.status = hfi_map_err_status((u32)pkt->error_type);

	cmd_done.session_id = ((struct hal_session *)

		(unsigned long)(pkt->session_id))->session_id;

	cmd_done.status = hfi_map_err_status(pkt->error_type);

	cmd_done.data = NULL;

	cmd_done.size = 0;

	callback(SESSION_START_DONE, &cmd_done);
@@ -1167,9 +1166,9 @@ static void hfi_process_session_stop_done( 


	memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));

	cmd_done.device_id = device_id;

	cmd_done.session_id =

		((struct hal_session *) pkt->session_id)->session_id;

	cmd_done.status = hfi_map_err_status((u32)pkt->error_type);

	cmd_done.session_id = ((struct hal_session *)

		(unsigned long) (pkt->session_id))->session_id;

	cmd_done.status = hfi_map_err_status(pkt->error_type);

	cmd_done.data = NULL;

	cmd_done.size = 0;

	callback(SESSION_STOP_DONE, &cmd_done);
@@ -1194,9 +1193,9 @@ static void hfi_process_session_rel_res_done( 


	memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));

	cmd_done.device_id = device_id;

	cmd_done.session_id =

		((struct hal_session *) pkt->session_id)->session_id;

	cmd_done.status = hfi_map_err_status((u32)pkt->error_type);

	cmd_done.session_id = ((struct hal_session *)

		(unsigned long)(pkt->session_id))->session_id;

	cmd_done.status = hfi_map_err_status(pkt->error_type);

	cmd_done.data = NULL;

	cmd_done.size = 0;

	callback(SESSION_RELEASE_RESOURCE_DONE, &cmd_done);
@@ -1210,7 +1209,7 @@ static void hfi_process_session_rel_buf_done( 
	if (!pkt || pkt->size !=

		sizeof(struct

			   hfi_msg_session_release_buffers_done_packet)) {

		dprintk(VIDC_ERR, "bad packet/packet size: %d\n", pkt->size);

		dprintk(VIDC_ERR, "bad packet/packet size: 0x%x\n", pkt->size);

		return;

	}

	dprintk(VIDC_DBG, "RECEIVED:SESSION_RELEASE_BUFFER_DONE[%u]",
@@ -1218,9 +1217,9 @@ static void hfi_process_session_rel_buf_done( 
	memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));

	cmd_done.device_id = device_id;

	cmd_done.size = sizeof(struct msm_vidc_cb_cmd_done);

	cmd_done.session_id =

		((struct hal_session *) pkt->session_id)->session_id;

	cmd_done.status = hfi_map_err_status((u32)pkt->error_type);

	cmd_done.session_id = ((struct hal_session *)

		(unsigned long)(pkt->session_id))->session_id;

	cmd_done.status = hfi_map_err_status(pkt->error_type);

	if (pkt->rg_buffer_info) {

		cmd_done.data = (void *) &pkt->rg_buffer_info;

		cmd_done.size = sizeof(struct hfi_buffer_info);
@@ -1249,9 +1248,9 @@ static void hfi_process_session_end_done( 


	memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));

	cmd_done.device_id = device_id;

	cmd_done.session_id =

		((struct hal_session *) pkt->session_id)->session_id;

	cmd_done.status = hfi_map_err_status((u32)pkt->error_type);

	cmd_done.session_id = ((struct hal_session *)

		(unsigned long)(pkt->session_id))->session_id;

	cmd_done.status = hfi_map_err_status(pkt->error_type);

	cmd_done.data = NULL;

	cmd_done.size = 0;

	callback(SESSION_END_DONE, &cmd_done);
@@ -1274,9 +1273,9 @@ static void hfi_process_session_abort_done( 
	}

	memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));

	cmd_done.device_id = device_id;

	cmd_done.session_id =

		((struct hal_session *) pkt->session_id)->session_id;

	cmd_done.status = hfi_map_err_status((u32)pkt->error_type);

	cmd_done.session_id = ((struct hal_session *)

		(unsigned long)(pkt->session_id))->session_id;

	cmd_done.status = hfi_map_err_status(pkt->error_type);

	cmd_done.data = NULL;

	cmd_done.size = 0;
@@ -1299,12 +1298,13 @@ static void hfi_process_session_get_seq_hdr_done( 
	memset(&data_done, 0, sizeof(struct msm_vidc_cb_data_done));

	data_done.device_id = device_id;

	data_done.size = sizeof(struct msm_vidc_cb_data_done);

	data_done.session_id =

		((struct hal_session *) pkt->session_id)->session_id;

	data_done.status = hfi_map_err_status((u32)pkt->error_type);

	data_done.output_done.packet_buffer1 = pkt->sequence_header;

	data_done.session_id = ((struct hal_session *)

		(unsigned long)(pkt->session_id))->session_id;

	data_done.status = hfi_map_err_status(pkt->error_type);

	data_done.output_done.packet_buffer1 =

		(ion_phys_addr_t)pkt->sequence_header;

	data_done.output_done.filled_len1 = pkt->header_len;

	dprintk(VIDC_INFO, "seq_hdr: %p, Length: %d\n",

	dprintk(VIDC_INFO, "seq_hdr: 0x%x, Length: %d\n",

		   pkt->sequence_header, pkt->header_len);

	callback(SESSION_GET_SEQ_HDR_DONE, &data_done);

}
@@ -1401,7 +1401,7 @@ u32 hfi_process_msg_packet( 


	dprintk(VIDC_INFO, "Received: 0x%x\n", msg_hdr->packet);

	rc = (u32) msg_hdr->packet;

	sess = (struct hal_session *)((struct

	sess = (struct hal_session *)(unsigned long)((struct

			vidc_hal_session_cmd_pkt*)msg_hdr)->session_id;



	switch (msg_hdr->packet) {

drivers/media/platform/msm/vidc/msm_smem.c

+31 −21
Original line number Diff line number Diff line 
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.

/* Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -48,8 +48,8 @@ static u32 get_tz_usage(struct smem_client *client, enum hal_buffer buffer_type) 


static int get_device_address(struct smem_client *smem_client,

		struct ion_handle *hndl, unsigned long align,

		dma_addr_t *iova, unsigned long *buffer_size,

		u32 flags, enum hal_buffer buffer_type)

		ion_phys_addr_t *iova, unsigned long *buffer_size,

		unsigned long flags, enum hal_buffer buffer_type)

{

	int rc = 0;

	int domain, partition;
@@ -138,11 +138,10 @@ static int ion_user_to_kernel(struct smem_client *client, int fd, u32 offset, 
		struct msm_smem *mem, enum hal_buffer buffer_type)

{

	struct ion_handle *hndl;

	dma_addr_t iova = 0;

	ion_phys_addr_t iova = 0;

	unsigned long buffer_size = 0;

	unsigned long ionflags = 0;

	int rc = 0;

	int align = SZ_4K;

	unsigned long align = SZ_4K;



	hndl = ion_import_dma_buf(client->clnt, fd);

	if (IS_ERR_OR_NULL(hndl)) {
@@ -152,13 +151,12 @@ static int ion_user_to_kernel(struct smem_client *client, int fd, u32 offset, 
		goto fail_import_fd;

	}

	mem->kvaddr = NULL;

	rc = ion_handle_get_flags(client->clnt, hndl, &ionflags);

	rc = ion_handle_get_flags(client->clnt, hndl, &mem->flags);

	if (rc) {

		dprintk(VIDC_ERR, "Failed to get ion flags: %d\n", rc);

		goto fail_device_address;

	}



	mem->flags = ionflags;

	mem->buffer_type = buffer_type;

	if (mem->flags & SMEM_SECURE)

		align = ALIGN(align, SZ_1M);
@@ -174,10 +172,15 @@ static int ion_user_to_kernel(struct smem_client *client, int fd, u32 offset, 
	mem->smem_priv = hndl;

	mem->device_addr = iova;

	mem->size = buffer_size;

	if ((u32)mem->device_addr != iova) {

		dprintk(VIDC_ERR, "iova(0x%pa) truncated to 0x%x",

			&iova, (u32)mem->device_addr);

		goto fail_device_address;

	}

	dprintk(VIDC_DBG,

		"%s: ion_handle = 0x%p, fd = %d, device_addr = 0x%x, size = %d, kvaddr = 0x%p, buffer_type = %d\n",

		__func__, mem->smem_priv, fd, (u32)mem->device_addr,

		mem->size, mem->kvaddr, mem->buffer_type);

		"%s: ion_handle = 0x%p, fd = %d, device_addr = 0x%pa, size = %zx, kvaddr = 0x%p, buffer_type = %d, flags = 0x%lx\n",

		__func__, mem->smem_priv, fd, &mem->device_addr, mem->size,

		mem->kvaddr, mem->buffer_type, mem->flags);

	return rc;

fail_device_address:

	ion_free(client->clnt, hndl);
@@ -190,7 +193,7 @@ static int alloc_ion_mem(struct smem_client *client, size_t size, u32 align, 
	int map_kernel)

{

	struct ion_handle *hndl;

	dma_addr_t iova = 0;

	ion_phys_addr_t iova = 0;

	unsigned long buffer_size = 0;

	unsigned long heap_mask = 0;

	int rc = 0;
@@ -207,7 +210,7 @@ static int alloc_ion_mem(struct smem_client *client, size_t size, u32 align, 
		heap_mask = ION_HEAP(ION_IOMMU_HEAP_ID);

	} else {

		dprintk(VIDC_DBG,

			"allocate shared memory from adsp heap size %d align %d\n",

			"allocate shared memory from adsp heap size %zx align %d\n",

			size, align);

		heap_mask = ION_HEAP(ION_ADSP_HEAP_ID);

	}
@@ -218,7 +221,7 @@ static int alloc_ion_mem(struct smem_client *client, size_t size, u32 align, 
	hndl = ion_alloc(client->clnt, size, align, heap_mask, flags);

	if (IS_ERR_OR_NULL(hndl)) {

		dprintk(VIDC_ERR,

		"Failed to allocate shared memory = %p, %d, %d, 0x%x\n",

		"Failed to allocate shared memory = %p, %zx, %d, 0x%x\n",

		client, size, align, flags);

		rc = -ENOMEM;

		goto fail_shared_mem_alloc;
@@ -235,8 +238,9 @@ static int alloc_ion_mem(struct smem_client *client, size_t size, u32 align, 
			rc = -EIO;

			goto fail_map;

		}

	} else

	} else {

		mem->kvaddr = NULL;

	}



	rc = get_device_address(client, hndl, align, &iova, &buffer_size,

				flags, buffer_type);
@@ -246,11 +250,17 @@ static int alloc_ion_mem(struct smem_client *client, size_t size, u32 align, 
		goto fail_device_address;

	}

	mem->device_addr = iova;

	if ((u32)mem->device_addr != iova) {

		dprintk(VIDC_ERR, "iova(0x%pa) truncated to 0x%x",

			&iova, (u32)mem->device_addr);

		goto fail_device_address;

	}

	mem->size = size;

	dprintk(VIDC_DBG,

		"%s: ion_handle = 0x%p, device_addr = 0x%x, size = %d, kvaddr = 0x%p, buffer_type = %d\n",

		__func__, mem->smem_priv, (u32)mem->device_addr,

		mem->size, mem->kvaddr, mem->buffer_type);

		"%s: ion_handle = 0x%p, device_addr = 0x%pa, size = 0x%zx, kvaddr = 0x%p, buffer_type = 0x%x, flags = 0x%lx\n",

		__func__, mem->smem_priv, &mem->device_addr,

		mem->size, mem->kvaddr,

		mem->buffer_type, mem->flags);

	return rc;

fail_device_address:

	ion_unmap_kernel(client->clnt, hndl);
@@ -265,8 +275,8 @@ static void free_ion_mem(struct smem_client *client, struct msm_smem *mem) 
	int domain, partition, rc;



	dprintk(VIDC_DBG,

		"%s: ion_handle = 0x%p, device_addr = 0x%x, size = %d, kvaddr = 0x%p, buffer_type = %d\n",

		__func__, mem->smem_priv, (u32)mem->device_addr,

		"%s: ion_handle = 0x%p, device_addr = 0x%pa, size = 0x%zx, kvaddr = 0x%p, buffer_type = 0x%x\n",

		__func__, mem->smem_priv, &mem->device_addr,

		mem->size, mem->kvaddr, mem->buffer_type);

	rc = msm_smem_get_domain_partition((void *)client, mem->flags,

			mem->buffer_type, &domain, &partition);
@@ -442,7 +452,7 @@ struct msm_smem *msm_smem_alloc(void *clt, size_t size, u32 align, u32 flags, 
		return NULL;

	}

	if (!size) {

		dprintk(VIDC_ERR, "No need to allocate memory of size: %d\n",

		dprintk(VIDC_ERR, "No need to allocate memory of size: %zx\n",

			size);

		return NULL;

	}

drivers/media/platform/msm/vidc/msm_vdec.c

+4 −3
Original line number Diff line number Diff line
@@ -759,11 +759,12 @@ int msm_vdec_prepare_buf(struct msm_vidc_inst *inst, 
				b->m.planes[extra_idx].m.userptr) {

				buffer_info.extradata_addr =

					b->m.planes[extra_idx].m.userptr;

				dprintk(VIDC_DBG,

				"extradata: 0x%lx\n",

				b->m.planes[extra_idx].m.userptr);

				buffer_info.extradata_size =

					b->m.planes[extra_idx].length;

				dprintk(VIDC_DBG,

					"extradata: 0x%pa, length = %d\n",

					&buffer_info.extradata_addr,

					buffer_info.extradata_size);

			} else {

				buffer_info.extradata_addr = 0;

				buffer_info.extradata_size = 0;

drivers/media/platform/msm/vidc/msm_vidc.c

+14 −14

File changed.

Preview size limit exceeded, changes collapsed.