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

Commit 08440bf0 authored by Arun Menon's avatar Arun Menon
Browse files

msm: vidc: Load hfi packetization based on Venus version 



There is difference in hfi packetization between
Venus 2.x and Venus 3.x, which breaks backward compatibiity
in the video driver. To overcome this problem, load the
hfi packetization functions based on the Venus hardware
version.

Change-Id: Iece60d9765c8020ed5df55071595431bc6779453
Signed-off-by: default avatarArun Menon <avmenon@codeaurora.org>
parent c3e072e1

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

+57 −1
Original line number Diff line number Diff line
@@ -259,7 +259,7 @@ int create_pkt_cmd_sys_coverage_config( 
	return 0;

}



int create_pkt_set_cmd_sys_resource(

int create_pkt_cmd_sys_set_resource(

		struct hfi_cmd_sys_set_resource_packet *pkt,

		struct vidc_resource_hdr *resource_hdr,

		void *resource_value)
@@ -1927,3 +1927,59 @@ int create_pkt_cmd_sys_image_version( 
	pkt->rg_property_data[0] = HFI_PROPERTY_SYS_IMAGE_VERSION;

	return 0;

}



static struct hfi_packetization_ops hfi_default = {

	.sys_init = create_pkt_cmd_sys_init,

	.sys_pc_prep = create_pkt_cmd_sys_pc_prep,

	.sys_idle_indicator = create_pkt_cmd_sys_idle_indicator,

	.sys_power_control = create_pkt_cmd_sys_power_control,

	.sys_set_resource = create_pkt_cmd_sys_set_resource,

	.sys_debug_config = create_pkt_cmd_sys_debug_config,

	.sys_coverage_config = create_pkt_cmd_sys_coverage_config,

	.sys_release_resource = create_pkt_cmd_sys_release_resource,

	.sys_ping = create_pkt_cmd_sys_ping,

	.sys_image_version = create_pkt_cmd_sys_image_version,

	.ssr_cmd = create_pkt_ssr_cmd,

	.session_init = create_pkt_cmd_sys_session_init,

	.session_cmd = create_pkt_cmd_session_cmd,

	.session_set_buffers = create_pkt_cmd_session_set_buffers,

	.session_release_buffers = create_pkt_cmd_session_release_buffers,

	.session_etb_decoder = create_pkt_cmd_session_etb_decoder,

	.session_etb_encoder = create_pkt_cmd_session_etb_encoder,

	.session_ftb = create_pkt_cmd_session_ftb,

	.session_parse_seq_header = create_pkt_cmd_session_parse_seq_header,

	.session_get_seq_hdr = create_pkt_cmd_session_get_seq_hdr,

	.session_get_buf_req = create_pkt_cmd_session_get_buf_req,

	.session_flush = create_pkt_cmd_session_flush,

	.session_get_property = create_pkt_cmd_session_get_property,

	.session_set_property = create_pkt_cmd_session_set_property,

};



struct hfi_packetization_ops *get_venus_3_x_ops(void)

{

	static struct hfi_packetization_ops hfi_venus_3_x;



	hfi_venus_3_x = hfi_default;



	/* Override new HFI functions for HFI_3XX here. */



	return &hfi_venus_3_x;

}



struct hfi_packetization_ops *hfi_get_pkt_ops_handle(

			enum hfi_packetization_type type)

{

	dprintk(VIDC_DBG, "%s selected\n",

		type == HFI_PACKETIZATION_LEGACY ? "legacy packetization" :

		type == HFI_PACKETIZATION_3XX ? "3xx packetization" :

		"Unknown hfi");



	switch (type) {

	case HFI_PACKETIZATION_LEGACY:

		return &hfi_default;

	case HFI_PACKETIZATION_3XX:

		return get_venus_3_x_ops();

	}



	return NULL;

}

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

+43 −56
Original line number Diff line number Diff line
@@ -18,95 +18,82 @@ 
#include "vidc_hfi.h"

#include "vidc_hfi_api.h"



int create_pkt_cmd_sys_init(struct hfi_cmd_sys_init_packet *pkt,

		u32 arch_type);

int create_pkt_cmd_sys_pc_prep(struct hfi_cmd_sys_pc_prep_packet *pkt);



int create_pkt_cmd_sys_idle_indicator(

		struct hfi_cmd_sys_set_property_packet *pkt,

#define call_hfi_pkt_op(q, op, args...)			\

	(((q) && (q)->pkt_ops && (q)->pkt_ops->op) ?	\

	((q)->pkt_ops->op(args)) : 0)



enum hfi_packetization_type {

	HFI_PACKETIZATION_LEGACY,

	HFI_PACKETIZATION_3XX,

};



struct hfi_packetization_ops {

	int (*sys_init)(struct hfi_cmd_sys_init_packet *pkt, u32 arch_type);

	int (*sys_pc_prep)(struct hfi_cmd_sys_pc_prep_packet *pkt);

	int (*sys_idle_indicator)(struct hfi_cmd_sys_set_property_packet *pkt,

		u32 enable);



int create_pkt_cmd_sys_power_control(

	struct hfi_cmd_sys_set_property_packet *pkt, u32 enable);



int create_pkt_set_cmd_sys_resource(

	int (*sys_power_control)(struct hfi_cmd_sys_set_property_packet *pkt,

		u32 enable);

	int (*sys_set_resource)(

		struct hfi_cmd_sys_set_resource_packet *pkt,

		struct vidc_resource_hdr *resource_hdr,

		void *resource_value);



int create_pkt_cmd_sys_debug_config(

		struct hfi_cmd_sys_set_property_packet *pkt,

	int (*sys_debug_config)(struct hfi_cmd_sys_set_property_packet *pkt,

			u32 mode);



int create_pkt_cmd_sys_coverage_config(

		struct hfi_cmd_sys_set_property_packet *pkt,

	int (*sys_coverage_config)(struct hfi_cmd_sys_set_property_packet *pkt,

			u32 mode);



int create_pkt_cmd_sys_release_resource(

	int (*sys_release_resource)(

		struct hfi_cmd_sys_release_resource_packet *pkt,

		struct vidc_resource_hdr *resource_hdr);



int create_pkt_cmd_sys_ping(struct hfi_cmd_sys_ping_packet *pkt);



int create_pkt_cmd_sys_session_init(

	int (*sys_ping)(struct hfi_cmd_sys_ping_packet *pkt);

	int (*sys_image_version)(struct hfi_cmd_sys_get_property_packet *pkt);

	int (*ssr_cmd)(enum hal_ssr_trigger_type type,

		struct hfi_cmd_sys_test_ssr_packet *pkt);

	int (*session_init)(

		struct hfi_cmd_sys_session_init_packet *pkt,

		struct hal_session *session,

		u32 session_domain, u32 session_codec);



int create_pkt_cmd_session_cmd(struct vidc_hal_session_cmd_pkt *pkt,

	int (*session_cmd)(struct vidc_hal_session_cmd_pkt *pkt,

		int pkt_type, struct hal_session *session);



int create_pkt_cmd_session_set_buffers(

	int (*session_set_buffers)(

		struct hfi_cmd_session_set_buffers_packet *pkt,

		struct hal_session *session,

		struct vidc_buffer_addr_info *buffer_info);



int create_pkt_cmd_session_release_buffers(

	int (*session_release_buffers)(

		struct hfi_cmd_session_release_buffer_packet *pkt,

		struct hal_session *session,

		struct vidc_buffer_addr_info *buffer_info);



int create_pkt_cmd_session_etb_decoder(

	int (*session_etb_decoder)(

		struct hfi_cmd_session_empty_buffer_compressed_packet *pkt,

		struct hal_session *session,

		struct vidc_frame_data *input_frame);



int create_pkt_cmd_session_etb_encoder(

	int (*session_etb_encoder)(

		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,

	int (*session_ftb)(struct hfi_cmd_session_fill_buffer_packet *pkt,

		struct hal_session *session,

		struct vidc_frame_data *output_frame);



int create_pkt_cmd_session_parse_seq_header(

	int (*session_parse_seq_header)(

		struct hfi_cmd_session_parse_sequence_header_packet *pkt,

		struct hal_session *session, struct vidc_seq_hdr *seq_hdr);



int create_pkt_cmd_session_get_seq_hdr(

	int (*session_get_seq_hdr)(

		struct hfi_cmd_session_get_sequence_header_packet *pkt,

		struct hal_session *session, struct vidc_seq_hdr *seq_hdr);



int create_pkt_cmd_session_get_buf_req(

	int (*session_get_buf_req)(

		struct hfi_cmd_session_get_property_packet *pkt,

		struct hal_session *session);



int create_pkt_cmd_session_flush(struct hfi_cmd_session_flush_packet *pkt,

	int (*session_flush)(struct hfi_cmd_session_flush_packet *pkt,

		struct hal_session *session, enum hal_flush flush_mode);



int create_pkt_cmd_session_set_property(

	int (*session_get_property)(

		struct hfi_cmd_session_get_property_packet *pkt,

		struct hal_session *session, enum hal_property ptype);

	int (*session_set_property)(

		struct hfi_cmd_session_set_property_packet *pkt,

		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,

		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);



int create_pkt_cmd_sys_image_version(

		struct hfi_cmd_sys_get_property_packet *pkt);

struct hfi_packetization_ops *hfi_get_pkt_ops_handle(

		enum hfi_packetization_type);

#endif

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

+32 −20
Original line number Diff line number Diff line
@@ -364,6 +364,13 @@ static void *q6_hfi_get_device(u32 device_id, 
			dprintk(VIDC_ERR, "Failed to init resources: %d\n", rc);

		goto err_fail_init_res;

	}



	device->pkt_ops = hfi_get_pkt_ops_handle(HFI_PACKETIZATION_LEGACY);

	if (!device->pkt_ops) {

		dprintk(VIDC_ERR, "Failed to get pkt_ops handle\n");

		goto err_fail_init_res;

	}



	return device;



err_fail_init_res:
@@ -510,7 +517,7 @@ static int q6_hfi_core_init(void *device) 


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



	rc = create_pkt_cmd_sys_init(&apr.pkt, HFI_VIDEO_ARCH_OX);

	rc = call_hfi_pkt_op(dev, sys_init, &apr.pkt, HFI_VIDEO_ARCH_OX);

	if (rc) {

		dprintk(VIDC_ERR, "Failed to create sys init pkt\n");

		goto err_core_init;
@@ -569,8 +576,8 @@ static void *q6_hfi_session_init(void *device, void *session_id, 


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



	if (create_pkt_cmd_sys_session_init(&apr.pkt, new_session,

					session_type, codec_type)) {

	if (call_hfi_pkt_op(dev, 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,7 +626,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, session);

	rc = call_hfi_pkt_op(dev, session_cmd, &apr.pkt, pkt_type, session);

	if (rc) {

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

		goto err_create_pkt;
@@ -688,7 +695,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(



	rc = call_hfi_pkt_op(dev, session_set_buffers,

			&apr->pkt, session, buffer_info);

	if (rc) {

		dprintk(VIDC_ERR, "set buffers: failed to create packet\n");
@@ -730,7 +738,7 @@ 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(

	rc = call_hfi_pkt_op(dev, session_release_buffers,

			&apr->pkt, session, buffer_info);

	if (rc) {

		dprintk(VIDC_ERR, "release buffers: failed to create packet\n");
@@ -792,7 +800,7 @@ 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(

		rc = call_hfi_pkt_op(dev, session_etb_decoder,

				&apr.pkt, session, input_frame);

		if (rc) {

			dprintk(VIDC_ERR,
@@ -814,7 +822,7 @@ 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(

		rc = call_hfi_pkt_op(dev, session_etb_encoder,

				&apr.pkt, session, input_frame);

		if (rc) {

			dprintk(VIDC_ERR,
@@ -850,7 +858,8 @@ 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, session, output_frame);

	rc = call_hfi_pkt_op(dev, session_ftb,

			&apr.pkt, session, output_frame);

	if (rc) {

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

		goto err_create_pkt;
@@ -887,7 +896,7 @@ 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(

	rc = call_hfi_pkt_op(dev, session_parse_seq_header,

			&apr->pkt, session, seq_hdr);

	if (rc) {

		dprintk(VIDC_ERR,
@@ -925,7 +934,8 @@ 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, session, seq_hdr);

	rc = call_hfi_pkt_op(dev, 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;
@@ -958,7 +968,8 @@ 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, session);

	rc = call_hfi_pkt_op(dev, session_get_buf_req,

			&apr.pkt, session);

	if (rc) {

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

		goto err_create_pkt;
@@ -990,7 +1001,8 @@ 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, session, flush_mode);

	rc = call_hfi_pkt_op(dev, session_flush,

			&apr.pkt, session, flush_mode);

	if (rc) {

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

		goto err_create_pkt;
@@ -1032,7 +1044,7 @@ 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(

	rc = call_hfi_pkt_op(dev, session_set_property,

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

	if (rc) {

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

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

+2 −1
Original line number Diff line number Diff line 
/* Copyright (c) 2013, The Linux Foundation. All rights reserved.

/* Copyright (c) 2013-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
@@ -53,6 +53,7 @@ struct q6_hfi_device { 
	struct msm_vidc_platform_resources *res;

	void *apr;

	struct mutex session_lock;

	struct hfi_packetization_ops *pkt_ops;

};



struct q6_apr_cmd_sys_init_packet {

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

+157 −74
Original line number Diff line number Diff line
@@ -1042,12 +1042,13 @@ static int venus_hfi_core_set_resource(void *device, 


	pkt = (struct hfi_cmd_sys_set_resource_packet *) packet;



	rc = create_pkt_set_cmd_sys_resource(pkt, resource_hdr,

						resource_value);

	rc = call_hfi_pkt_op(dev, sys_set_resource,

			pkt, resource_hdr, resource_value);

	if (rc) {

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

		goto err_create_pkt;

	}



	rc = locked ? venus_hfi_iface_cmdq_write(dev, pkt) :

			venus_hfi_iface_cmdq_write_nolock(dev, pkt);

	if (rc)
@@ -1071,7 +1072,8 @@ static int venus_hfi_core_release_resource(void *device, 
		dev = device;

	}



	rc = create_pkt_cmd_sys_release_resource(&pkt, resource_hdr);

	rc = call_hfi_pkt_op(dev, sys_release_resource,

			&pkt, resource_hdr);

	if (rc) {

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

		goto err_create_pkt;
@@ -2154,7 +2156,8 @@ static int venus_hfi_sys_set_debug(struct venus_hfi_device *device, u32 debug) 
	int rc = 0;

	struct hfi_cmd_sys_set_property_packet *pkt =

		(struct hfi_cmd_sys_set_property_packet *) &packet;

	rc = create_pkt_cmd_sys_debug_config(pkt, debug);



	rc = call_hfi_pkt_op(device, sys_debug_config, pkt, debug);

	if (rc) {

		dprintk(VIDC_WARN,

			"Debug mode setting to FW failed\n");
@@ -2171,7 +2174,9 @@ static int venus_hfi_sys_set_coverage(struct venus_hfi_device *device, u32 mode) 
	int rc = 0;

	struct hfi_cmd_sys_set_property_packet *pkt =

		(struct hfi_cmd_sys_set_property_packet *) &packet;

	rc = create_pkt_cmd_sys_coverage_config(pkt, mode);



	rc = call_hfi_pkt_op(device, sys_coverage_config,

			pkt, mode);

	if (rc) {

		dprintk(VIDC_WARN,

			"Coverage mode setting to FW failed\n");
@@ -2194,7 +2199,7 @@ static int venus_hfi_sys_set_idle_message(struct venus_hfi_device *device, 
		dprintk(VIDC_DBG, "sys_idle_indicator is not enabled\n");

		return 0;

	}

	create_pkt_cmd_sys_idle_indicator(pkt, enable);

	call_hfi_pkt_op(device, sys_idle_indicator, pkt, enable);

	if (venus_hfi_iface_cmdq_write(device, pkt))

		return -ENOTEMPTY;

	return 0;
@@ -2219,7 +2224,7 @@ static int venus_hfi_sys_set_power_control(struct venus_hfi_device *device, 
	if (!supported)

		return 0;



	create_pkt_cmd_sys_power_control(pkt, enable);

	call_hfi_pkt_op(device, sys_power_control, pkt, enable);

	if (venus_hfi_iface_cmdq_write(device, pkt))

		return -ENOTEMPTY;

	return 0;
@@ -2277,7 +2282,7 @@ static int venus_hfi_core_init(void *device) 
		goto err_core_init;

	}



	rc = create_pkt_cmd_sys_init(&pkt, HFI_VIDEO_ARCH_OX);

	rc =  call_hfi_pkt_op(dev, sys_init, &pkt, HFI_VIDEO_ARCH_OX);

	if (rc) {

		dprintk(VIDC_ERR, "Failed to create sys init pkt\n");

		goto err_core_init;
@@ -2286,7 +2291,8 @@ static int venus_hfi_core_init(void *device) 
		rc = -ENOTEMPTY;

		goto err_core_init;

	}

	rc = create_pkt_cmd_sys_image_version(&version_pkt);



	rc = call_hfi_pkt_op(dev, sys_image_version, &version_pkt);

	if (rc || venus_hfi_iface_cmdq_write(dev, &version_pkt))

		dprintk(VIDC_WARN, "Failed to send image version pkt to f/w\n");
@@ -2410,7 +2416,7 @@ static int venus_hfi_core_ping(void *device) 
		return -ENODEV;

	}



	rc = create_pkt_cmd_sys_ping(&pkt);

	rc = call_hfi_pkt_op(dev, sys_ping, &pkt);

	if (rc) {

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

		goto err_create_pkt;
@@ -2437,7 +2443,7 @@ static int venus_hfi_core_trigger_ssr(void *device, 
		return -ENODEV;

	}



	rc = create_pkt_ssr_cmd(type, &pkt);

	rc = call_hfi_pkt_op(dev, ssr_cmd, type, &pkt);

	if (rc) {

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

		goto err_create_pkt;
@@ -2456,19 +2462,21 @@ static int venus_hfi_session_set_property(void *sess, 
	u8 packet[VIDC_IFACEQ_VAR_LARGE_PKT_SIZE];

	struct hfi_cmd_session_set_property_packet *pkt =

		(struct hfi_cmd_session_set_property_packet *) &packet;

	struct hal_session *session;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;

	int rc = 0;



	if (!sess || !pdata) {

	if (!session || !session->device || !pdata) {

		dprintk(VIDC_ERR, "Invalid Params\n");

		return -EINVAL;

	} else {

		session = sess;

	}

	device = session->device;



	dprintk(VIDC_INFO, "in set_prop,with prop id: 0x%x\n", ptype);



	if (create_pkt_cmd_session_set_property(pkt, session, ptype, pdata)) {

	rc = call_hfi_pkt_op(device, session_set_property,

			pkt, session, ptype, pdata);

	if (rc) {

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

		return -EINVAL;

	}
@@ -2483,21 +2491,25 @@ static int venus_hfi_session_get_property(void *sess, 
					enum hal_property ptype)

{

	struct hfi_cmd_session_get_property_packet pkt = {0};

	struct hal_session *session;

	struct hal_session *session = sess;

	int rc = 0;

	if (!sess) {

	struct venus_hfi_device *device;



	if (!session || !session->device) {

		dprintk(VIDC_ERR, "Invalid Params\n");

		return -EINVAL;

	} else {

		session = sess;

	}

	device = session->device;



	dprintk(VIDC_INFO, "%s: property id: %d\n", __func__, ptype);



	rc = create_pkt_cmd_session_get_property(&pkt, session, ptype);

	rc = call_hfi_pkt_op(device, session_get_property,

				&pkt, session, ptype);

	if (rc) {

		dprintk(VIDC_ERR, "get property profile: pkt failed\n");

		goto err_create_pkt;

	}



	if (venus_hfi_iface_cmdq_write(session->device, &pkt)) {

		rc = -ENOTEMPTY;

		dprintk(VIDC_ERR, "%s cmdq_write error\n", __func__);
@@ -2551,8 +2563,8 @@ static void *venus_hfi_session_init(void *device, void *session_id, 


	venus_hfi_set_default_sys_properties(device);



	if (create_pkt_cmd_sys_session_init(&pkt, new_session,

				session_type, codec_type)) {

	if (call_hfi_pkt_op(dev, session_init, &pkt,

			new_session, session_type, codec_type)) {

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

		goto err_session_init_fail;

	}
@@ -2571,16 +2583,17 @@ static int venus_hfi_send_session_cmd(void *session_id, 
{

	struct vidc_hal_session_cmd_pkt pkt;

	int rc = 0;

	struct hal_session *session;

	struct hal_session *session = session_id;

	struct venus_hfi_device *device;



	if (session_id) {

		session = session_id;

	} else {

	if (!session || !session->device) {

		dprintk(VIDC_ERR, "invalid session");

		return -ENODEV;

	}

	device = session->device;



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

	rc = call_hfi_pkt_op(device, session_cmd,

			&pkt, pkt_type, session);

	if (rc) {

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

		goto err_create_pkt;
@@ -2641,22 +2654,22 @@ static int venus_hfi_session_set_buffers(void *sess, 
	struct hfi_cmd_session_set_buffers_packet *pkt;

	u8 packet[VIDC_IFACEQ_VAR_LARGE_PKT_SIZE];

	int rc = 0;

	struct hal_session *session;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (!sess || !buffer_info) {

	if (!session || !session->device || !buffer_info) {

		dprintk(VIDC_ERR, "Invalid Params\n");

		return -EINVAL;

	} else {

		session = sess;

	}

	device = session->device;



	if (buffer_info->buffer_type == HAL_BUFFER_INPUT)

		return 0;



	pkt = (struct hfi_cmd_session_set_buffers_packet *)packet;



	rc = create_pkt_cmd_session_set_buffers(pkt,

			session, buffer_info);

	rc = call_hfi_pkt_op(device, session_set_buffers,

			pkt, session, buffer_info);

	if (rc) {

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

		goto err_create_pkt;
@@ -2676,18 +2689,21 @@ static int venus_hfi_session_release_buffers(void *sess, 
	u8 packet[VIDC_IFACEQ_VAR_LARGE_PKT_SIZE];

	int rc = 0;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (!session || !buffer_info) {

	if (!session || !session->device || !buffer_info) {

		dprintk(VIDC_ERR, "Invalid Params\n");

		return -EINVAL;

	}

	device = session->device;



	if (buffer_info->buffer_type == HAL_BUFFER_INPUT)

		return 0;



	pkt = (struct hfi_cmd_session_release_buffer_packet *) packet;



	rc = create_pkt_cmd_session_release_buffers(pkt, session, buffer_info);

	rc = call_hfi_pkt_op(device, session_release_buffers,

			pkt, session, buffer_info);

	if (rc) {

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

		goto err_create_pkt;
@@ -2728,20 +2744,20 @@ static int venus_hfi_session_etb(void *sess, 
				struct vidc_frame_data *input_frame)

{

	int rc = 0;

	struct hal_session *session;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (!sess || !input_frame) {

	if (!session || !session->device || !input_frame) {

		dprintk(VIDC_ERR, "Invalid Params\n");

		return -EINVAL;

	} else {

		session = sess;

	}

	device = session->device;



	if (session->is_decoder) {

		struct hfi_cmd_session_empty_buffer_compressed_packet pkt;



		rc = create_pkt_cmd_session_etb_decoder(&pkt,

						session, input_frame);

		rc = call_hfi_pkt_op(device, session_etb_decoder,

				&pkt, session, input_frame);

		if (rc) {

			dprintk(VIDC_ERR,

			"Session etb decoder: failed to create pkt\n");
@@ -2754,8 +2770,9 @@ static int venus_hfi_session_etb(void *sess, 
		struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet

			pkt;



		rc =  create_pkt_cmd_session_etb_encoder(&pkt,

						session, input_frame);



		rc = call_hfi_pkt_op(device, session_etb_encoder,

					 &pkt, session, input_frame);

		if (rc) {

			dprintk(VIDC_ERR,

			"Session etb encoder: failed to create pkt\n");
@@ -2774,16 +2791,17 @@ static int venus_hfi_session_ftb(void *sess, 
{

	struct hfi_cmd_session_fill_buffer_packet pkt;

	int rc = 0;

	struct hal_session *session;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (!sess || !output_frame) {

	if (!session || !session->device || !output_frame) {

		dprintk(VIDC_ERR, "Invalid Params\n");

		return -EINVAL;

	} else {

		session = sess;

	}

	device = session->device;



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

	rc = call_hfi_pkt_op(device, session_ftb,

			&pkt, session, output_frame);

	if (rc) {

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

		goto err_create_pkt;
@@ -2801,18 +2819,19 @@ static int venus_hfi_session_parse_seq_hdr(void *sess, 
	struct hfi_cmd_session_parse_sequence_header_packet *pkt;

	int rc = 0;

	u8 packet[VIDC_IFACEQ_VAR_SMALL_PKT_SIZE];

	struct hal_session *session;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (!sess || !seq_hdr) {

	if (!session || !session->device || !seq_hdr) {

		dprintk(VIDC_ERR, "Invalid Params\n");

		return -EINVAL;

	} else {

		session = sess;

	}

	device = session->device;



	pkt = (struct hfi_cmd_session_parse_sequence_header_packet *) packet;



	rc = create_pkt_cmd_session_parse_seq_header(pkt, session, seq_hdr);

	rc = call_hfi_pkt_op(device, session_parse_seq_header,

			pkt, session, seq_hdr);

	if (rc) {

		dprintk(VIDC_ERR,

		"Session parse seq hdr: failed to create pkt\n");
@@ -2831,17 +2850,19 @@ static int venus_hfi_session_get_seq_hdr(void *sess, 
	struct hfi_cmd_session_get_sequence_header_packet *pkt;

	int rc = 0;

	u8 packet[VIDC_IFACEQ_VAR_SMALL_PKT_SIZE];

	struct hal_session *session;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (!sess || !seq_hdr) {

	if (!session || !session->device || !seq_hdr) {

		dprintk(VIDC_ERR, "Invalid Params\n");

		return -EINVAL;

	} else {

		session = sess;

	}

	device = session->device;



	pkt = (struct hfi_cmd_session_get_sequence_header_packet *) packet;

	rc = create_pkt_cmd_session_get_seq_hdr(pkt, session, seq_hdr);



	rc = call_hfi_pkt_op(device, session_get_seq_hdr,

			pkt, session, seq_hdr);

	if (rc) {

		dprintk(VIDC_ERR,

				"Session get seq hdr: failed to create pkt\n");
@@ -2858,16 +2879,17 @@ static int venus_hfi_session_get_buf_req(void *sess) 
{

	struct hfi_cmd_session_get_property_packet pkt;

	int rc = 0;

	struct hal_session *session;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (sess) {

		session = sess;

	} else {

	if (!session || !session->device) {

		dprintk(VIDC_ERR, "invalid session");

		return -ENODEV;

	}

	device = session->device;



	rc = create_pkt_cmd_session_get_buf_req(&pkt, session);

	rc = call_hfi_pkt_op(device, session_get_buf_req,

			&pkt, session);

	if (rc) {

		dprintk(VIDC_ERR,

				"Session get buf req: failed to create pkt\n");
@@ -2884,16 +2906,17 @@ static int venus_hfi_session_flush(void *sess, enum hal_flush flush_mode) 
{

	struct hfi_cmd_session_flush_packet pkt;

	int rc = 0;

	struct hal_session *session;

	struct hal_session *session = sess;

	struct venus_hfi_device *device;



	if (sess) {

		session = sess;

	} else {

	if (!session || !session->device) {

		dprintk(VIDC_ERR, "invalid session");

		return -ENODEV;

	}

	device = session->device;



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

	rc = call_hfi_pkt_op(device, session_flush,

			&pkt, session, flush_mode);

	if (rc) {

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

		goto err_create_pkt;
@@ -2968,16 +2991,14 @@ static int venus_hfi_core_pc_prep(void *device) 
{

	struct hfi_cmd_sys_pc_prep_packet pkt;

	int rc = 0;

	struct venus_hfi_device *dev;

	struct venus_hfi_device *dev = device;



	if (device) {

		dev = device;

	} else {

	if (!dev) {

		dprintk(VIDC_ERR, "invalid device\n");

		return -ENODEV;

	}



	rc = create_pkt_cmd_sys_pc_prep(&pkt);

	rc = call_hfi_pkt_op(dev, sys_pc_prep, &pkt);

	if (rc) {

		dprintk(VIDC_ERR, "Failed to create sys pc prep pkt\n");

		goto err_create_pkt;
@@ -4074,6 +4095,62 @@ int venus_hfi_get_core_capabilities(void) 
	return rc;

}



static int venus_hfi_initialize_packetization(struct venus_hfi_device *device)

{

	int major_version;

	enum hfi_packetization_type packetization_type;

	int rc = 0;



	if (!device) {

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

		return -EINVAL;

	}



	rc = venus_hfi_enable_regulators(device);

	if (rc) {

		dprintk(VIDC_ERR, "Failed to enable GDSC in %s Err code = %d\n",

			__func__, rc);

		goto exit;

	}



	rc = venus_hfi_prepare_enable_clks(device);

	if (rc) {

		dprintk(VIDC_ERR, "Failed to enable clocks\n");

		goto exit;

	}



	rc = venus_hfi_read_register(device, VIDC_WRAPPER_HW_VERSION);

	major_version = (rc & VIDC_WRAPPER_HW_VERSION_MAJOR_VERSION_MASK) >>

			VIDC_WRAPPER_HW_VERSION_MAJOR_VERSION_SHIFT;



	venus_hfi_disable_unprepare_clks(device);



	rc = venus_hfi_disable_regulators(device);

	if (rc) {

		dprintk(VIDC_ERR, "Failed to disable gdsc\n");

		goto exit;

	}



	dprintk(VIDC_DBG, "VENUS H/w Version is %d.%d.%d\n",

		major_version,

		(rc & VIDC_WRAPPER_HW_VERSION_MINOR_VERSION_MASK) >>

		VIDC_WRAPPER_HW_VERSION_MINOR_VERSION_SHIFT,

		rc & VIDC_WRAPPER_HW_VERSION_STEP_VERSION_MASK);



	if (major_version <= 2)

		packetization_type = HFI_PACKETIZATION_LEGACY;

	else

		packetization_type = HFI_PACKETIZATION_3XX;



	device->pkt_ops = hfi_get_pkt_ops_handle(packetization_type);

	if (!device->pkt_ops) {

		rc = -EINVAL;

		dprintk(VIDC_ERR, "Failed to get pkt_ops handle\n");

	}

exit:

	return rc;

}



static void *venus_hfi_add_device(u32 device_id,

			struct msm_vidc_platform_resources *res,

			hfi_cmd_response_callback callback)
@@ -4160,6 +4237,12 @@ static void *venus_hfi_get_device(u32 device_id, 
			dprintk(VIDC_ERR, "Failed to init resources: %d\n", rc);

		goto err_fail_init_res;

	}



	rc = venus_hfi_initialize_packetization(device);

	if (rc) {

		dprintk(VIDC_ERR, "Failed to initialize packetization\n");

		goto err_fail_init_res;

	}

	return device;



err_fail_init_res: