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
Loading
Loading
Loading
Loading
+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;
	}
+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) {
+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;
	}
+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;
+14 −14

File changed.

Preview size limit exceeded, changes collapsed.

Loading