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

Commit bb9cbd76 authored by Shalaj Jain's avatar Shalaj Jain
Browse files

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



Instead of passing the session pointer value to fw, hash it to a
32 bit value and pass that.
Clean up the function to validate session pointer from the packet
received from fw.

Change-Id: Iff82ba9b81ddf544add570b62a7c0d6b0f5e32a2
Signed-off-by: default avatarShalaj Jain <shalajj@codeaurora.org>
parent 96c28c9a

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

+44 −39
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_*.

 *
@@ -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;
@@ -601,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;
@@ -644,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;
@@ -671,16 +674,16 @@ int create_pkt_cmd_session_etb_decoder( 


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;
@@ -699,15 +702,16 @@ int create_pkt_cmd_session_etb_encoder( 
}



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;
@@ -731,15 +735,15 @@ 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;
@@ -749,16 +753,16 @@ int create_pkt_cmd_session_parse_seq_header( 


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;
@@ -768,16 +772,16 @@ int create_pkt_cmd_session_get_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 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;
@@ -785,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;
@@ -816,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:
@@ -843,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) {

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

+205 −271

File changed.

Preview size limit exceeded, changes collapsed.

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

+15 −25
Original line number Diff line number Diff line
@@ -406,7 +406,7 @@ static void handle_session_release_buf_done(enum command_response cmd, 
		return;

	}



	inst = (struct msm_vidc_inst *)(unsigned long)response->session_id;

	inst = (struct msm_vidc_inst *)response->session_id;

	buffer = (struct hal_buffer_info *) response->data;

	address = buffer->buffer_addr;
@@ -566,8 +566,7 @@ static void handle_session_init_done(enum command_response cmd, void *data) 
		struct vidc_hal_session_init_done *session_init_done =

			(struct vidc_hal_session_init_done *)

			response->data;

		inst = (struct msm_vidc_inst *)

			(unsigned long)response->session_id;

		inst = (struct msm_vidc_inst *)response->session_id;

		if (!inst || !inst->core || !inst->core->device) {

			dprintk(VIDC_ERR, "%s: invalid parameters (0x%p)\n",

				__func__, inst);
@@ -616,8 +615,7 @@ static void handle_event_change(enum command_response cmd, void *data) 
	int event = V4L2_EVENT_SEQ_CHANGED_INSUFFICIENT;

	int rc = 0;

	if (response) {

		inst = (struct msm_vidc_inst *)

			(unsigned long)response->session_id;

		inst = (struct msm_vidc_inst *)response->session_id;

		event_notify = (struct msm_vidc_cb_event *) response->data;

		switch (event_notify->hal_event_type) {

		case HAL_EVENT_SEQ_CHANGED_SUFFICIENT_RESOURCES:
@@ -735,7 +733,7 @@ static void handle_session_prop_info(enum command_response cmd, void *data) 
			"Failed to get valid response for prop info\n");

		return;

	}

	inst = (struct msm_vidc_inst *)(unsigned long)response->session_id;

	inst = (struct msm_vidc_inst *)response->session_id;

	mutex_lock(&inst->lock);

	getprop = kzalloc(sizeof(*getprop), GFP_KERNEL);

	if (!getprop) {
@@ -762,8 +760,7 @@ static void handle_load_resource_done(enum command_response cmd, void *data) 
	struct msm_vidc_cb_cmd_done *response = data;

	struct msm_vidc_inst *inst;

	if (response) {

		inst = (struct msm_vidc_inst *)

			(unsigned long)response->session_id;

		inst = (struct msm_vidc_inst *)response->session_id;

		if (response->status) {

			dprintk(VIDC_ERR,

				"Load resource response from FW : 0x%x\n",
@@ -781,8 +778,7 @@ static void handle_start_done(enum command_response cmd, void *data) 
	struct msm_vidc_cb_cmd_done *response = data;

	struct msm_vidc_inst *inst;

	if (response) {

		inst = (struct msm_vidc_inst *)

			(unsigned long)response->session_id;

		inst = (struct msm_vidc_inst *)response->session_id;

		signal_session_msg_receipt(cmd, inst);

	} else {

		dprintk(VIDC_ERR,
@@ -795,8 +791,7 @@ static void handle_stop_done(enum command_response cmd, void *data) 
	struct msm_vidc_cb_cmd_done *response = data;

	struct msm_vidc_inst *inst;

	if (response) {

		inst = (struct msm_vidc_inst *)

			(unsigned long)response->session_id;

		inst = (struct msm_vidc_inst *)response->session_id;

		signal_session_msg_receipt(cmd, inst);

	} else {

		dprintk(VIDC_ERR,
@@ -809,8 +804,7 @@ static void handle_release_res_done(enum command_response cmd, void *data) 
	struct msm_vidc_cb_cmd_done *response = data;

	struct msm_vidc_inst *inst;

	if (response) {

		inst = (struct msm_vidc_inst *)

			(unsigned long)response->session_id;

		inst = (struct msm_vidc_inst *)response->session_id;

		signal_session_msg_receipt(cmd, inst);

	} else {

		dprintk(VIDC_ERR,
@@ -855,8 +849,7 @@ static void handle_session_flush(enum command_response cmd, void *data) 
	struct msm_vidc_cb_cmd_done *response = data;

	struct msm_vidc_inst *inst;

	if (response) {

		inst = (struct msm_vidc_inst *)

			(unsigned long)response->session_id;

		inst = (struct msm_vidc_inst *)response->session_id;

		if (msm_comm_get_stream_output_mode(inst) ==

			HAL_VIDEO_DECODER_SECONDARY) {

			mutex_lock(&inst->lock);
@@ -874,8 +867,7 @@ static void handle_session_error(enum command_response cmd, void *data) 
	struct msm_vidc_cb_cmd_done *response = data;

	struct msm_vidc_inst *inst = NULL;

	if (response) {

		inst = (struct msm_vidc_inst *)

			(unsigned long)response->session_id;

		inst = (struct msm_vidc_inst *)response->session_id;

		if (inst) {

			dprintk(VIDC_WARN,

				"Session error receivd for session %p\n", inst);
@@ -988,8 +980,7 @@ static void handle_session_close(enum command_response cmd, void *data) 
	struct hfi_device *hdev = NULL;



	if (response) {

		inst = (struct msm_vidc_inst *)

			(unsigned long)response->session_id;

		inst = (struct msm_vidc_inst *)response->session_id;

		if (!inst || !inst->core || !inst->core->device) {

			dprintk(VIDC_ERR, "%s invalid params\n", __func__);

			return;
@@ -1053,7 +1044,7 @@ static void handle_ebd(enum command_response cmd, void *data) 
		return;

	}



	inst = (struct msm_vidc_inst *)(unsigned long)response->session_id;

	inst = (struct msm_vidc_inst *)response->session_id;

	if (!inst) {

		dprintk(VIDC_ERR, "%s Invalid response from vidc_hal\n",

			__func__);
@@ -1265,7 +1256,7 @@ static void handle_fbd(enum command_response cmd, void *data) 
		dprintk(VIDC_ERR, "Invalid response from vidc_hal\n");

		return;

	}

	inst = (struct msm_vidc_inst *)(unsigned long)response->session_id;

	inst = (struct msm_vidc_inst *)response->session_id;

	fill_buf_done = (struct vidc_hal_fbd *)&response->output_done;

	buffer_type = msm_comm_get_hal_output_buffer(inst);

	if (fill_buf_done->buffer_type == buffer_type)
@@ -1399,7 +1390,7 @@ static void handle_seq_hdr_done(enum command_response cmd, void *data) 
		dprintk(VIDC_ERR, "Invalid response from vidc_hal\n");

		return;

	}

	inst = (struct msm_vidc_inst *)(unsigned long)response->session_id;

	inst = (struct msm_vidc_inst *)response->session_id;

	fill_buf_done = (struct vidc_hal_fbd *)&response->output_done;

	vb = get_vb_from_device_addr(&inst->bufq[CAPTURE_PORT],

				fill_buf_done->packet_buffer1);
@@ -1750,8 +1741,7 @@ static int msm_comm_session_init(int flipped_state, 
		&inst->completions[SESSION_MSG_INDEX(SESSION_INIT_DONE)]);

	mutex_lock(&inst->lock);

	inst->session = call_hfi_op(hdev, session_init, hdev->hfi_device_data,

			(u32)(unsigned long)inst,

			get_hal_domain(inst->session_type),

			inst, get_hal_domain(inst->session_type),

			get_hal_codec_type(fourcc));

	mutex_unlock(&inst->lock);

	if (!inst->session) {

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

+21 −26
Original line number Diff line number Diff line
@@ -541,7 +541,7 @@ static int q6_hfi_core_release(void *device) 
	return 0;

}



static void *q6_hfi_session_init(void *device, u32 session_id,

static void *q6_hfi_session_init(void *device, void *session_id,

	enum hal_domain session_type, enum hal_video_codec codec_type)

{

	struct q6_apr_cmd_sys_session_init_packet apr;
@@ -560,7 +560,7 @@ static void *q6_hfi_session_init(void *device, u32 session_id, 
		dprintk(VIDC_ERR, "new session fail: Out of memory\n");

		return NULL;

	}

	new_session->session_id = (u32) session_id;

	new_session->session_id = session_id;

	if (session_type == 1)

		new_session->is_decoder = 0;

	else if (session_type == 2)
@@ -569,7 +569,7 @@ static void *q6_hfi_session_init(void *device, u32 session_id, 


	q6_hfi_add_apr_hdr(dev, &apr.hdr, sizeof(apr));



	if (create_pkt_cmd_sys_session_init(&apr.pkt, (u32)new_session,

	if (create_pkt_cmd_sys_session_init(&apr.pkt, new_session,

					session_type, codec_type)) {

		dprintk(VIDC_ERR, "session_init: failed to create packet\n");

		goto err_session_init;
@@ -619,8 +619,7 @@ static int q6_hal_send_session_cmd(void *sess, 


	q6_hfi_add_apr_hdr(dev, &apr.hdr, sizeof(apr));



	rc = create_pkt_cmd_session_cmd(&apr.pkt, pkt_type,

					(u32)(unsigned long)session);

	rc = create_pkt_cmd_session_cmd(&apr.pkt, pkt_type, session);

	if (rc) {

		dprintk(VIDC_ERR, "send session cmd: create pkt failed\n");

		goto err_create_pkt;
@@ -657,7 +656,7 @@ static int q6_hfi_session_clean(void *session) 
		return -EINVAL;

	}

	sess_close = session;

	dprintk(VIDC_DBG, "deleted the session: 0x%x\n",

	dprintk(VIDC_DBG, "deleted the session: 0x%p\n",

			sess_close->session_id);

	mutex_lock(&((struct q6_hfi_device *)

			sess_close->device)->session_lock);
@@ -689,8 +688,8 @@ static int q6_hfi_session_set_buffers(void *sess, 


	q6_hfi_add_apr_hdr(dev, &apr->hdr, VIDC_IFACEQ_VAR_LARGE_PKT_SIZE);



	rc = create_pkt_cmd_session_set_buffers(&apr->pkt,

			(u32)(unsigned long)session, buffer_info);

	rc = create_pkt_cmd_session_set_buffers(

					&apr->pkt, session, buffer_info);

	if (rc) {

		dprintk(VIDC_ERR, "set buffers: failed to create packet\n");

		goto err_create_pkt;
@@ -731,8 +730,8 @@ static int q6_hfi_session_release_buffers(void *sess, 


	q6_hfi_add_apr_hdr(dev, &apr->hdr, VIDC_IFACEQ_VAR_LARGE_PKT_SIZE);



	rc = create_pkt_cmd_session_release_buffers(&apr->pkt,

				(u32)(unsigned long)session, buffer_info);

	rc = create_pkt_cmd_session_release_buffers(

					&apr->pkt, session, buffer_info);

	if (rc) {

		dprintk(VIDC_ERR, "release buffers: failed to create packet\n");

		goto err_create_pkt;
@@ -805,8 +804,8 @@ static int q6_hfi_session_etb(void *sess, 
		struct q6_apr_cmd_session_empty_buffer_compressed_packet apr;

		q6_hfi_add_apr_hdr(dev, &apr.hdr, sizeof(apr));



		rc = create_pkt_cmd_session_etb_decoder(&apr.pkt,

				(u32)(unsigned long)session, input_frame);

		rc = create_pkt_cmd_session_etb_decoder(

						&apr.pkt, session, input_frame);

		if (rc) {

			dprintk(VIDC_ERR,

				"Session etb decoder: failed to create pkt\n");
@@ -827,8 +826,8 @@ static int q6_hfi_session_etb(void *sess, 
		q6_apr_cmd_session_empty_buffer_uncompressed_plane0_packet apr;

		q6_hfi_add_apr_hdr(dev, &apr.hdr, sizeof(apr));



		rc =  create_pkt_cmd_session_etb_encoder(&apr.pkt,

				(u32)(unsigned long)session, input_frame);

		rc =  create_pkt_cmd_session_etb_encoder(

						&apr.pkt, session, input_frame);

		if (rc) {

			dprintk(VIDC_ERR,

				"Session etb encoder: failed to create pkt\n");
@@ -863,8 +862,7 @@ static int q6_hfi_session_ftb(void *sess, 


	q6_hfi_add_apr_hdr(dev, &apr.hdr, sizeof(apr));



	rc = create_pkt_cmd_session_ftb(&apr.pkt,

			(u32)(unsigned long)session, output_frame);

	rc = create_pkt_cmd_session_ftb(&apr.pkt, session, output_frame);

	if (rc) {

		dprintk(VIDC_ERR, "Session ftb: failed to create pkt\n");

		goto err_create_pkt;
@@ -901,8 +899,8 @@ static int q6_hfi_session_parse_seq_hdr(void *sess, 


	q6_hfi_add_apr_hdr(dev, &apr->hdr, VIDC_IFACEQ_VAR_SMALL_PKT_SIZE);



	rc = create_pkt_cmd_session_parse_seq_header(&apr->pkt,

				(u32)(unsigned long)session, seq_hdr);

	rc = create_pkt_cmd_session_parse_seq_header(

						&apr->pkt, session, seq_hdr);

	if (rc) {

		dprintk(VIDC_ERR,

			"Session parse seq hdr: failed to create pkt\n");
@@ -939,8 +937,7 @@ static int q6_hfi_session_get_seq_hdr(void *sess, 


	q6_hfi_add_apr_hdr(dev, &apr->hdr, VIDC_IFACEQ_VAR_SMALL_PKT_SIZE);



	rc = create_pkt_cmd_session_get_seq_hdr(&apr->pkt,

			(u32)(unsigned long)session, seq_hdr);

	rc = create_pkt_cmd_session_get_seq_hdr(&apr->pkt, session, seq_hdr);

	if (rc) {

		dprintk(VIDC_ERR, "Session get seqhdr: failed to create pkt\n");

		goto err_create_pkt;
@@ -973,8 +970,7 @@ static int q6_hfi_session_get_buf_req(void *sess) 


	q6_hfi_add_apr_hdr(dev, &apr.hdr, sizeof(apr));



	rc = create_pkt_cmd_session_get_buf_req(&apr.pkt,

					(u32)(unsigned long)session);

	rc = create_pkt_cmd_session_get_buf_req(&apr.pkt, session);

	if (rc) {

		dprintk(VIDC_ERR, "Session get bufreq: failed to create pkt\n");

		goto err_create_pkt;
@@ -1006,8 +1002,7 @@ static int q6_hfi_session_flush(void *sess, enum hal_flush flush_mode) 


	q6_hfi_add_apr_hdr(dev, &apr.hdr, sizeof(apr));



	rc = create_pkt_cmd_session_flush(&apr.pkt,

			(u32)(unsigned long)session, flush_mode);

	rc = create_pkt_cmd_session_flush(&apr.pkt, session, flush_mode);

	if (rc) {

		dprintk(VIDC_ERR, "Session flush: failed to create pkt\n");

		goto err_create_pkt;
@@ -1044,8 +1039,8 @@ static int q6_hfi_session_set_property(void *sess, 


	q6_hfi_add_apr_hdr(dev, &apr->hdr, VIDC_IFACEQ_VAR_LARGE_PKT_SIZE);



	rc = create_pkt_cmd_session_set_property(&apr->pkt,

				(u32)(unsigned long)session, ptype, pdata);

	rc = create_pkt_cmd_session_set_property(

					&apr->pkt, session, ptype, pdata);

	if (rc) {

		dprintk(VIDC_ERR, "set property: failed to create packet\n");

		goto err_create_pkt;