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

Commit 9b75f0f1 authored by Linux Build Service Account's avatar Linux Build Service Account Committed by Gerrit - the friendly Code Review server
Browse files

Merge "msm: vidc: Clean up session handling for 64 bit driver support"

parents 879cdf53 bb9cbd76

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

+75 −67
Original line number Diff line number Diff line
@@ -10,11 +10,12 @@ 
 * GNU General Public License for more details.

 *

 */

#include "hfi_packetization.h"

#include "msm_vidc_debug.h"

#include <linux/errno.h>

#include <linux/log2.h>

#include <linux/hash.h>

#include <soc/qcom/ocmem.h>

#include "hfi_packetization.h"

#include "msm_vidc_debug.h"



/* Set up look-up tables to convert HAL_* to HFI_*.

 *
@@ -283,7 +284,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:
@@ -325,7 +326,8 @@ int create_pkt_cmd_sys_ping(struct hfi_cmd_sys_ping_packet *pkt) 


inline int create_pkt_cmd_sys_session_init(

		struct hfi_cmd_sys_session_init_packet *pkt,

		u32 session_id, u32 session_domain, u32 session_codec)

		struct hal_session *session,

		u32 session_domain, u32 session_codec)

{

	int rc = 0;

	if (!pkt)
@@ -333,7 +335,7 @@ inline int create_pkt_cmd_sys_session_init( 


	pkt->size = sizeof(struct hfi_cmd_sys_session_init_packet);

	pkt->packet_type = HFI_CMD_SYS_SESSION_INIT;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);

	pkt->session_domain = session_domain;

	pkt->session_codec = get_hfi_codec(session_codec);

	if (!pkt->session_codec)
@@ -343,7 +345,7 @@ inline int create_pkt_cmd_sys_session_init( 
}



int create_pkt_cmd_session_cmd(struct vidc_hal_session_cmd_pkt *pkt,

			int pkt_type, u32 session_id)

			int pkt_type, struct hal_session *session)

{

	int rc = 0;

	if (!pkt)
@@ -351,7 +353,7 @@ int create_pkt_cmd_session_cmd(struct vidc_hal_session_cmd_pkt *pkt, 


	pkt->size = sizeof(struct vidc_hal_session_cmd_pkt);

	pkt->packet_type = pkt_type;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);



	return rc;

}
@@ -554,16 +556,16 @@ static u32 get_hfi_ltr_mode(enum ltr_mode ltr_mode_type) 


int create_pkt_cmd_session_set_buffers(

		struct hfi_cmd_session_set_buffers_packet *pkt,

		u32 session_id,

		struct hal_session *session,

		struct vidc_buffer_addr_info *buffer_info)

{

	int rc = 0;

	int i = 0;

	if (!pkt || !session_id)

	if (!pkt || !session)

		return -EINVAL;



	pkt->packet_type = HFI_CMD_SESSION_SET_BUFFERS;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);

	pkt->buffer_size = buffer_info->buffer_size;

	pkt->min_buffer_size = buffer_info->buffer_size;

	pkt->num_buffers = buffer_info->num_buffers;
@@ -577,15 +579,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);
@@ -597,15 +603,16 @@ int create_pkt_cmd_session_set_buffers( 


int create_pkt_cmd_session_release_buffers(

		struct hfi_cmd_session_release_buffer_packet *pkt,

		u32 session_id, struct vidc_buffer_addr_info *buffer_info)

		struct hal_session *session,

		struct vidc_buffer_addr_info *buffer_info)

{

	int rc = 0;

	int i = 0;

	if (!pkt || !session_id)

	if (!pkt || !session)

		return -EINVAL;



	pkt->packet_type = HFI_CMD_SESSION_RELEASE_BUFFERS;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);

	pkt->buffer_size = buffer_info->buffer_size;

	pkt->num_buffers = buffer_info->num_buffers;
@@ -614,15 +621,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));
@@ -636,16 +647,16 @@ int create_pkt_cmd_session_release_buffers( 


int create_pkt_cmd_session_etb_decoder(

	struct hfi_cmd_session_empty_buffer_compressed_packet *pkt,

	u32 session_id, struct vidc_frame_data *input_frame)

	struct hal_session *session, struct vidc_frame_data *input_frame)

{

	int rc = 0;

	if (!pkt || !session_id)

	if (!pkt || !session)

		return -EINVAL;



	pkt->size =

		sizeof(struct hfi_cmd_session_empty_buffer_compressed_packet);

	pkt->packet_type = HFI_CMD_SESSION_EMPTY_BUFFER;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);

	pkt->time_stamp_hi = (int) (((u64)input_frame->timestamp) >> 32);

	pkt->time_stamp_lo = (int) input_frame->timestamp;

	pkt->flags = input_frame->flags;
@@ -655,25 +666,24 @@ 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;

}



int create_pkt_cmd_session_etb_encoder(

	struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet *pkt,

	u32 session_id, struct vidc_frame_data *input_frame)

	struct hal_session *session, struct vidc_frame_data *input_frame)

{

	int rc = 0;

	if (!pkt || !session_id)

	if (!pkt || !session)

		return -EINVAL;



	pkt->size = sizeof(struct

		hfi_cmd_session_empty_buffer_uncompressed_plane0_packet);

	pkt->packet_type = HFI_CMD_SESSION_EMPTY_BUFFER;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);

	pkt->view_id = 0;

	pkt->time_stamp_hi = (u32)(((u64)input_frame->timestamp) >> 32);

	pkt->time_stamp_lo = (u32)input_frame->timestamp;
@@ -684,24 +694,24 @@ 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;

}



int create_pkt_cmd_session_ftb(struct hfi_cmd_session_fill_buffer_packet *pkt,

		u32 session_id, struct vidc_frame_data *output_frame)

		struct hal_session *session,

		struct vidc_frame_data *output_frame)

{

	int rc = 0;

	if (!pkt || !session_id || !output_frame)

	if (!pkt || !session || !output_frame)

		return -EINVAL;



	pkt->size = sizeof(struct hfi_cmd_session_fill_buffer_packet);

	pkt->packet_type = HFI_CMD_SESSION_FILL_BUFFER;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);



	if (output_frame->buffer_type == HAL_BUFFER_OUTPUT)

		pkt->stream_id = 0;
@@ -711,9 +721,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;
@@ -726,55 +735,53 @@ int create_pkt_cmd_session_ftb(struct hfi_cmd_session_fill_buffer_packet *pkt, 


int create_pkt_cmd_session_parse_seq_header(

		struct hfi_cmd_session_parse_sequence_header_packet *pkt,

		u32 session_id, struct vidc_seq_hdr *seq_hdr)

		struct hal_session *session, struct vidc_seq_hdr *seq_hdr)

{

	int rc = 0;

	if (!pkt || !session_id || !seq_hdr)

	if (!pkt || !session || !seq_hdr)

		return -EINVAL;



	pkt->size = sizeof(struct hfi_cmd_session_parse_sequence_header_packet);

	pkt->packet_type = HFI_CMD_SESSION_PARSE_SEQUENCE_HEADER;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);

	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;

}



int create_pkt_cmd_session_get_seq_hdr(

		struct hfi_cmd_session_get_sequence_header_packet *pkt,

		u32 session_id, struct vidc_seq_hdr *seq_hdr)

		struct hal_session *session, struct vidc_seq_hdr *seq_hdr)

{

	int rc = 0;



	if (!pkt || !session_id || !seq_hdr)

	if (!pkt || !session || !seq_hdr)

		return -EINVAL;



	pkt->size = sizeof(struct hfi_cmd_session_get_sequence_header_packet);

	pkt->packet_type = HFI_CMD_SESSION_GET_SEQUENCE_HEADER;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);

	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;

}



int create_pkt_cmd_session_get_buf_req(

		struct hfi_cmd_session_get_property_packet *pkt,

		u32 session_id)

		struct hal_session *session)

{

	int rc = 0;



	if (!pkt || !session_id)

	if (!pkt || !session)

		return -EINVAL;



	pkt->size = sizeof(struct hfi_cmd_session_get_property_packet);

	pkt->packet_type = HFI_CMD_SESSION_GET_PROPERTY;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);

	pkt->num_properties = 1;

	pkt->rg_property_data[0] = HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS;
@@ -782,15 +789,15 @@ int create_pkt_cmd_session_get_buf_req( 
}



int create_pkt_cmd_session_flush(struct hfi_cmd_session_flush_packet *pkt,

			u32 session_id, enum hal_flush flush_mode)

			struct hal_session *session, enum hal_flush flush_mode)

{

	int rc = 0;

	if (!pkt || !session_id)

	if (!pkt || !session)

		return -EINVAL;



	pkt->size = sizeof(struct hfi_cmd_session_flush_packet);

	pkt->packet_type = HFI_CMD_SESSION_FLUSH;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);

	switch (flush_mode) {

	case HAL_FLUSH_INPUT:

		pkt->flush_type = HFI_FLUSH_INPUT;
@@ -813,16 +820,16 @@ int create_pkt_cmd_session_flush(struct hfi_cmd_session_flush_packet *pkt, 


int create_pkt_cmd_session_get_property(

		struct hfi_cmd_session_get_property_packet *pkt,

		u32 session_id, enum hal_property ptype)

		struct hal_session *session, enum hal_property ptype)

{

	int rc = 0;

	if (!pkt || !session_id) {

	if (!pkt || !session) {

		dprintk(VIDC_ERR, "%s Invalid parameters\n", __func__);

		return -EINVAL;

	}

	pkt->size = sizeof(struct hfi_cmd_session_get_property_packet);

	pkt->packet_type = HFI_CMD_SESSION_GET_PROPERTY;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);

	pkt->num_properties = 1;

	switch (ptype) {

	case HAL_PARAM_PROFILE_LEVEL_CURRENT:
@@ -840,15 +847,16 @@ int create_pkt_cmd_session_get_property( 


int create_pkt_cmd_session_set_property(

		struct hfi_cmd_session_set_property_packet *pkt,

		u32 session_id, enum hal_property ptype, void *pdata)

		struct hal_session *session,

		enum hal_property ptype, void *pdata)

{

	int rc = 0;

	if (!pkt || !session_id)

	if (!pkt || !session)

		return -EINVAL;



	pkt->size = sizeof(struct hfi_cmd_session_set_property_packet);

	pkt->packet_type = HFI_CMD_SESSION_SET_PROPERTY;

	pkt->session_id = session_id;

	pkt->session_id = hash32_ptr(session);

	pkt->num_properties = 1;



	switch (ptype) {
@@ -1160,7 +1168,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 +1232,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 +1259,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_packetization.h

+23 −17
Original line number Diff line number Diff line
@@ -50,53 +50,59 @@ int create_pkt_cmd_sys_ping(struct hfi_cmd_sys_ping_packet *pkt); 


int create_pkt_cmd_sys_session_init(

		struct hfi_cmd_sys_session_init_packet *pkt,

	u32 session_id, u32 session_domain, u32 session_codec);

		struct hal_session *session,

		u32 session_domain, u32 session_codec);



int create_pkt_cmd_session_cmd(struct vidc_hal_session_cmd_pkt *pkt,

			int pkt_type, u32 session_id);

		int pkt_type, struct hal_session *session);



int create_pkt_cmd_session_set_buffers(

		struct hfi_cmd_session_set_buffers_packet *pkt,

		u32 session_id,

		struct hal_session *session,

		struct vidc_buffer_addr_info *buffer_info);



int create_pkt_cmd_session_release_buffers(

		struct hfi_cmd_session_release_buffer_packet *pkt,

		u32 session_id, struct vidc_buffer_addr_info *buffer_info);

		struct hal_session *session,

		struct vidc_buffer_addr_info *buffer_info);



int create_pkt_cmd_session_etb_decoder(

		struct hfi_cmd_session_empty_buffer_compressed_packet *pkt,

	u32 session_id, struct vidc_frame_data *input_frame);

		struct hal_session *session,

		struct vidc_frame_data *input_frame);



int create_pkt_cmd_session_etb_encoder(

	struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet *pkt,

	u32 session_id, struct vidc_frame_data *input_frame);

		struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet

		*pkt, struct hal_session *session,

		struct vidc_frame_data *input_frame);



int create_pkt_cmd_session_ftb(struct hfi_cmd_session_fill_buffer_packet *pkt,

		u32 session_id, struct vidc_frame_data *output_frame);

		struct hal_session *session,

		struct vidc_frame_data *output_frame);



int create_pkt_cmd_session_parse_seq_header(

		struct hfi_cmd_session_parse_sequence_header_packet *pkt,

		u32 session_id, struct vidc_seq_hdr *seq_hdr);

		struct hal_session *session, struct vidc_seq_hdr *seq_hdr);



int create_pkt_cmd_session_get_seq_hdr(

		struct hfi_cmd_session_get_sequence_header_packet *pkt,

		u32 session_id, struct vidc_seq_hdr *seq_hdr);

		struct hal_session *session, struct vidc_seq_hdr *seq_hdr);



int create_pkt_cmd_session_get_buf_req(

		struct hfi_cmd_session_get_property_packet *pkt,

		u32 session_id);

		struct hal_session *session);



int create_pkt_cmd_session_flush(struct hfi_cmd_session_flush_packet *pkt,

			u32 session_id, enum hal_flush flush_mode);

		struct hal_session *session, enum hal_flush flush_mode);



int create_pkt_cmd_session_set_property(

		struct hfi_cmd_session_set_property_packet *pkt,

		u32 session_id, enum hal_property ptype, void *pdata);

		struct hal_session *session,

		enum hal_property ptype, void *pdata);



int create_pkt_cmd_session_get_property(

		struct hfi_cmd_session_get_property_packet *pkt,

		u32 session_id, enum hal_property ptype);

		struct hal_session *session, enum hal_property ptype);



int create_pkt_ssr_cmd(enum hal_ssr_trigger_type type,

		struct hfi_cmd_sys_test_ssr_packet *pkt);

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

+243 −309

File changed.

Preview size limit exceeded, changes collapsed.

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;