/*
 * drivers/amlogic/media/frame_provider/decoder/h264/vh264.c
 *
 * Copyright (C) 2016 Amlogic, Inc. 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 as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 */

#define DEBUG
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/timer.h>
#include <linux/kfifo.h>
#include <linux/platform_device.h>

#include <linux/amlogic/media/utils/amstream.h>
#include <linux/amlogic/media/frame_sync/ptsserv.h>
#include <linux/amlogic/media/vfm/vframe.h>
#include <linux/amlogic/media/vfm/vframe_provider.h>
#include <linux/amlogic/media/vfm/vframe_receiver.h>
#include <linux/amlogic/media/utils/vformat.h>
#include <linux/amlogic/media/frame_sync/tsync.h>
#include <linux/workqueue.h>
#include <linux/dma-mapping.h>
#include <linux/atomic.h>
#include <linux/module.h>
#include <linux/slab.h>
#include "../../../stream_input/amports/amports_priv.h"
#include <linux/amlogic/media/canvas/canvas.h>

#include "../utils/vdec.h"
#include <linux/amlogic/media/utils/vdec_reg.h>
#include "../utils/amvdec.h"
#include "vh264.h"
#include "../../../stream_input/amports/streambuf.h"
#include <linux/delay.h>
#include <linux/amlogic/media/video_sink/video.h>
#include <linux/amlogic/tee.h>
#include <linux/amlogic/media/ge2d/ge2d.h>
#include "../utils/decoder_mmu_box.h"
#include "../utils/decoder_bmmu_box.h"
#include <linux/amlogic/media/codec_mm/codec_mm.h>
#include <linux/amlogic/media/codec_mm/configs.h>
#include "../utils/firmware.h"
#include <linux/amlogic/tee.h>
#include "../../../common/chips/decoder_cpu_ver_info.h"
#include <linux/uaccess.h>


#define DRIVER_NAME "amvdec_h264"
#define MODULE_NAME "amvdec_h264"
#define MEM_NAME "codec_264"
#define HANDLE_H264_IRQ

#if 0
/* currently, only iptv supports this function*/
#define SUPPORT_BAD_MACRO_BLOCK_REDUNDANCY
#endif

/* #define DEBUG_PTS */
#if 0 /* MESON_CPU_TYPE <= MESON_CPU_TYPE_MESON6TV */
#define DROP_B_FRAME_FOR_1080P_50_60FPS
#endif
#define RATE_MEASURE_NUM 8
#define RATE_CORRECTION_THRESHOLD 5
#define RATE_24_FPS  4004	/* 23.97 */
#define RATE_25_FPS  3840	/* 25 */
#define DUR2PTS(x) ((x)*90/96)
#define PTS2DUR(x) ((x)*96/90)
#define DUR2PTS_REM(x) (x*90 - DUR2PTS(x)*96)
#define FIX_FRAME_RATE_CHECK_IDRFRAME_NUM 2
#define VDEC_CLOCK_ADJUST_FRAME 30

static inline bool close_to(int a, int b, int m)
{
	return (abs(a - b) < m) ? true : false;
}

static DEFINE_MUTEX(vh264_mutex);
#define DEF_BUF_START_ADDR            0x1000000
#define V_BUF_ADDR_OFFSET_NEW         (0x1ee000)
#define V_BUF_ADDR_OFFSET             (0x13e000)

#define PIC_SINGLE_FRAME        0
#define PIC_TOP_BOT_TOP         1
#define PIC_BOT_TOP_BOT         2
#define PIC_DOUBLE_FRAME        3
#define PIC_TRIPLE_FRAME        4
#define PIC_TOP_BOT              5
#define PIC_BOT_TOP              6
#define PIC_INVALID              7

#define EXTEND_SAR                      0xff

#define VF_POOL_SIZE        64
#define VF_BUF_NUM          24
#define WORKSPACE_BUF_NUM	2
#define PUT_INTERVAL        (HZ/100)
#define NO_DISP_WD_COUNT    (3 * HZ / PUT_INTERVAL)

#define SWITCHING_STATE_OFF       0
#define SWITCHING_STATE_ON_CMD3   1
#define SWITCHING_STATE_ON_CMD1   2
#define SWITCHING_STATE_ON_CMD1_PENDING   3


#define DEC_CONTROL_FLAG_FORCE_2997_1080P_INTERLACE 0x0001
#define DEC_CONTROL_FLAG_FORCE_2500_576P_INTERLACE  0x0002
#define DEC_CONTROL_FLAG_DISABLE_FAST_POC              0x0004

#define INCPTR(p) ptr_atomic_wrap_inc(&p)

#define SLICE_TYPE_I 2
#define SLICE_TYPE_P 5
#define SLICE_TYPE_B 6

struct buffer_spec_s {
	unsigned int y_addr;
	unsigned int u_addr;
	unsigned int v_addr;

	int y_canvas_index;
	int u_canvas_index;
	int v_canvas_index;

	unsigned int y_canvas_width;
	unsigned int u_canvas_width;
	unsigned int v_canvas_width;

	unsigned int y_canvas_height;
	unsigned int u_canvas_height;
	unsigned int v_canvas_height;

	unsigned long phy_addr;
	int alloc_count;
};

#define spec2canvas(x)  \
	(((x)->v_canvas_index << 16) | \
	 ((x)->u_canvas_index << 8)  | \
	 ((x)->y_canvas_index << 0))

static struct vframe_s *vh264_vf_peek(void *);
static struct vframe_s *vh264_vf_get(void *);
static void vh264_vf_put(struct vframe_s *, void *);
static int vh264_vf_states(struct vframe_states *states, void *);
static int vh264_event_cb(int type, void *data, void *private_data);

static void vh264_prot_init(void);
static int vh264_local_init(void);
static void vh264_put_timer_func(unsigned long arg);
static void stream_switching_done(void);

static const char vh264_dec_id[] = "vh264-dev";

#define PROVIDER_NAME   "decoder.h264"

static const struct vframe_operations_s vh264_vf_provider_ops = {
	.peek = vh264_vf_peek,
	.get = vh264_vf_get,
	.put = vh264_vf_put,
	.event_cb = vh264_event_cb,
	.vf_states = vh264_vf_states,
};

static struct vframe_provider_s vh264_vf_prov;
/*TODO irq*/
#if 1
static u32 frame_width, frame_height, frame_dur, frame_prog, frame_packing_type,
	   last_duration;
static u32 saved_resolution;
static u32 last_mb_width, last_mb_height;
#else
static u32 frame_buffer_size;
static u32 frame_width, frame_height, frame_dur, frame_prog, last_duration;
static u32 last_mb_width, last_mb_height;
static u32 frame_packing_type;
#endif
static DECLARE_KFIFO(newframe_q, struct vframe_s *, VF_POOL_SIZE);
static DECLARE_KFIFO(display_q, struct vframe_s *, VF_POOL_SIZE);
static DECLARE_KFIFO(recycle_q, struct vframe_s *, VF_POOL_SIZE);
static DECLARE_KFIFO(delay_display_q, struct vframe_s *, VF_POOL_SIZE);

static struct vframe_s vfpool[VF_POOL_SIZE];
static s32 vfbuf_use[VF_BUF_NUM];
static struct buffer_spec_s buffer_spec[VF_BUF_NUM];
static struct buffer_spec_s fense_buffer_spec[2];
/* disp buf + keep buf+ fense buf + workspace  */

#define MAX_BLK_BUFFERS (VF_BUF_NUM + 2 + WORKSPACE_BUF_NUM)
#define VF_BUFFER_IDX(n) (WORKSPACE_BUF_NUM  + n)
#define FENSE_BUFFER_IDX(n) (WORKSPACE_BUF_NUM + VF_BUF_NUM + n)

#define USER_DATA_RUND_SIZE		(USER_DATA_SIZE + 4096)
static struct vframe_s fense_vf[2];

static struct timer_list recycle_timer;
static u32 stat;
static s32 buf_offset;
static u32 pts_outside;
static u32 sync_outside;
static u32 dec_control;
static u32 vh264_ratio;
static u32 vh264_rotation;
static u32 use_idr_framerate;
static u32 high_bandwidth;

static u32 seq_info;
static u32 timing_info_present_flag;
static u32 fixed_frame_rate_flag;
static u32 fixed_frame_rate_check_count;
static u32 aspect_ratio_info;
static u32 num_units_in_tick;
static u32 time_scale;
static u32 h264_ar;
static u32 decoder_debug_flag;
static u32 dpb_size_adj = 6;
static u32 fr_hint_status;

#ifdef DROP_B_FRAME_FOR_1080P_50_60FPS
static u32 last_interlaced;
#endif
static bool is_4k;
static unsigned char h264_first_pts_ready;
static bool h264_first_valid_pts_ready;
static u32 h264pts1, h264pts2;
static u32 h264_pts_count, duration_from_pts_done, duration_on_correcting;
static u32 vh264_error_count;
static u32 vh264_no_disp_count;
static u32 fatal_error_flag;
static u32 fatal_error_reset;
static u32 max_refer_buf = 1;
static u32 decoder_force_reset;
static unsigned int no_idr_error_count;
static unsigned int no_idr_error_max = 60;
static unsigned int canvas_mode;

#ifdef SUPPORT_BAD_MACRO_BLOCK_REDUNDANCY
/* 0~128*/
static u32 bad_block_scale;
#endif
static u32 enable_userdata_debug;

/* if not define, must clear AV_SCRATCH_J in isr when
 * ITU_T35 code enabled in ucode, otherwise may fatal
 * error repeatly.
 */
//#define ENABLE_SEI_ITU_T35


static unsigned int enable_switch_fense = 1;
#define EN_SWITCH_FENCE() (enable_switch_fense && !is_4k)
static struct vframe_qos_s s_vframe_qos;
static int frame_count;

#if 0
static u32 vh264_no_disp_wd_count;
#endif
static u32 vh264_running;
static s32 vh264_stream_switching_state;
static s32 vh264_eos;
static struct vframe_s *p_last_vf;
static s32 iponly_early_mode;
static void *mm_blk_handle;
static int tvp_flag;
static bool is_reset;

/*TODO irq*/
#if 1
static u32 last_pts, last_pts_remainder;
#else
static u32 last_pts;
#endif
static bool check_pts_discontinue;
static u32 wait_buffer_counter;
static u32 video_signal_from_vui;

static uint error_recovery_mode;
static uint error_recovery_mode_in = 3;
static uint error_recovery_mode_use = 3;

static uint mb_total = 0, mb_width = 0, mb_height;
static uint saved_idc_level;
#define UCODE_IP_ONLY 2
#define UCODE_IP_ONLY_PARAM 1
static uint ucode_type;

#ifdef DEBUG_PTS
static unsigned long pts_missed, pts_hit;
#endif
static uint debugfirmware;

static atomic_t vh264_active = ATOMIC_INIT(0);
static int vh264_reset;
static struct work_struct error_wd_work;
static struct work_struct stream_switching_work;
static struct work_struct set_parameter_work;
static struct work_struct notify_work;
static struct work_struct set_clk_work;
static struct work_struct userdata_push_work;

struct h264_qos_data_node_t {
	struct list_head list;

	uint32_t b_offset;
	int poc;
	/* picture qos infomation*/
	int max_qp;
	int avg_qp;
	int min_qp;
	int max_skip;
	int avg_skip;
	int min_skip;
	int max_mv;
	int min_mv;
	int avg_mv;
};

/*qos data records list waiting for match with picture that be display*/
static struct list_head picture_qos_list;
/*free qos data records list*/
static struct list_head free_qos_nodes_list;
#define MAX_FREE_QOS_NODES		64
static struct h264_qos_data_node_t free_nodes[MAX_FREE_QOS_NODES];
static struct work_struct qos_work;
static struct dec_sysinfo vh264_amstream_dec_info;
static dma_addr_t mc_dma_handle;
static void *mc_cpu_addr;
static u32 first_offset;
static u32 first_pts;
static u32 first_frame_size;
static u64 first_pts64;
static bool first_pts_cached;
static void *sei_data_buffer;
static dma_addr_t sei_data_buffer_phys;
static int clk_adj_frame_count;

#define MC_OFFSET_HEADER    0x0000
#define MC_OFFSET_DATA      0x1000
#define MC_OFFSET_MMCO      0x2000
#define MC_OFFSET_LIST      0x3000
#define MC_OFFSET_SLICE     0x4000

#define MC_TOTAL_SIZE       (20*SZ_1K)
#define MC_SWAP_SIZE        (4*SZ_1K)

#define MODE_ERROR 0
#define MODE_FULL  1

static DEFINE_SPINLOCK(lock);
static DEFINE_SPINLOCK(prepare_lock);
static DEFINE_SPINLOCK(recycle_lock);

static bool block_display_q;
static int vh264_stop(int mode);
static s32 vh264_init(void);


#define DFS_HIGH_THEASHOLD 3

static bool pts_discontinue;

static struct ge2d_context_s *ge2d_videoh264_context;

static struct vdec_info *gvs;

static struct vdec_s *vdec_h264;

static int ge2d_videoh264task_init(void)
{
	if (ge2d_videoh264_context == NULL)
		ge2d_videoh264_context = create_ge2d_work_queue();

	if (ge2d_videoh264_context == NULL) {
		pr_info("create_ge2d_work_queue video task failed\n");
		return -1;
	}
	return 0;
}

static int ge2d_videoh264task_release(void)
{
	if (ge2d_videoh264_context) {
		destroy_ge2d_work_queue(ge2d_videoh264_context);
		ge2d_videoh264_context = NULL;
	}
	return 0;
}

static int ge2d_canvas_dup(struct canvas_s *srcy, struct canvas_s *srcu,
		struct canvas_s *des, int format, u32 srcindex,
		u32 desindex)
{

	struct config_para_ex_s ge2d_config;
	/* pr_info("[%s]h264 ADDR srcy[0x%lx] srcu[0x%lx] des[0x%lx]\n",
	 *	   __func__, srcy->addr, srcu->addr, des->addr);
	 */
	memset(&ge2d_config, 0, sizeof(struct config_para_ex_s));

	ge2d_config.alu_const_color = 0;
	ge2d_config.bitmask_en = 0;
	ge2d_config.src1_gb_alpha = 0;

	ge2d_config.src_planes[0].addr = srcy->addr;
	ge2d_config.src_planes[0].w = srcy->width;
	ge2d_config.src_planes[0].h = srcy->height;

	ge2d_config.src_planes[1].addr = srcu->addr;
	ge2d_config.src_planes[1].w = srcu->width;
	ge2d_config.src_planes[1].h = srcu->height;

	ge2d_config.dst_planes[0].addr = des->addr;
	ge2d_config.dst_planes[0].w = des->width;
	ge2d_config.dst_planes[0].h = des->height;

	ge2d_config.src_para.canvas_index = srcindex;
	ge2d_config.src_para.mem_type = CANVAS_TYPE_INVALID;
	ge2d_config.src_para.format = format;
	ge2d_config.src_para.fill_color_en = 0;
	ge2d_config.src_para.fill_mode = 0;
	ge2d_config.src_para.color = 0;
	ge2d_config.src_para.top = 0;
	ge2d_config.src_para.left = 0;
	ge2d_config.src_para.width = srcy->width;
	ge2d_config.src_para.height = srcy->height;

	ge2d_config.dst_para.canvas_index = desindex;
	ge2d_config.dst_para.mem_type = CANVAS_TYPE_INVALID;
	ge2d_config.dst_para.format = format;
	ge2d_config.dst_para.fill_color_en = 0;
	ge2d_config.dst_para.fill_mode = 0;
	ge2d_config.dst_para.color = 0;
	ge2d_config.dst_para.top = 0;
	ge2d_config.dst_para.left = 0;
	ge2d_config.dst_para.width = srcy->width;
	ge2d_config.dst_para.height = srcy->height;

	if (ge2d_context_config_ex(ge2d_videoh264_context, &ge2d_config) < 0) {
		pr_info("ge2d_context_config_ex failed\n");
		return -1;
	}

	stretchblt_noalpha(ge2d_videoh264_context, 0, 0, srcy->width,
			srcy->height, 0, 0, srcy->width, srcy->height);

	return 0;
}

static inline int fifo_level(void)
{
	return VF_POOL_SIZE - kfifo_len(&newframe_q);
}


void spec_set_canvas(struct buffer_spec_s *spec,
		unsigned int width, unsigned int height)
{
	int endian;

	endian = (canvas_mode == CANVAS_BLKMODE_LINEAR)?7:0;
	canvas_config_ex(spec->y_canvas_index,
			spec->y_addr,
			width, height,
			CANVAS_ADDR_NOWRAP, canvas_mode, endian);

	canvas_config_ex(spec->u_canvas_index,
			spec->u_addr,
			width, height / 2,
			CANVAS_ADDR_NOWRAP, canvas_mode, endian);

}

static void vh264_notify_work(struct work_struct *work)
{
	pr_info("frame duration changed %d\n", frame_dur);
	vf_notify_receiver(PROVIDER_NAME, VFRAME_EVENT_PROVIDER_FR_HINT,
		(void *)((unsigned long)frame_dur));

	return;
}

static void prepare_display_q(void)
{
	unsigned long flags;
	int count;

	spin_lock_irqsave(&prepare_lock, flags);

	if (block_display_q) {
		spin_unlock_irqrestore(&prepare_lock, flags);
		return;
	}

	spin_unlock_irqrestore(&prepare_lock, flags);

	count  = (int)VF_POOL_SIZE -
		kfifo_len(&delay_display_q) -
		kfifo_len(&display_q) -
		kfifo_len(&recycle_q) -
		kfifo_len(&newframe_q);

	if ((vh264_stream_switching_state != SWITCHING_STATE_OFF)
		|| !EN_SWITCH_FENCE())
		count = 0;
	else
		count = (count < 2) ? 0 : 2;

	while (kfifo_len(&delay_display_q) > count) {
		struct vframe_s *vf;

		if (kfifo_get(&delay_display_q, &vf)) {
			kfifo_put(&display_q,
				(const struct vframe_s *)vf);
			ATRACE_COUNTER(MODULE_NAME, vf->pts);
			vf_notify_receiver(PROVIDER_NAME,
				VFRAME_EVENT_PROVIDER_VFRAME_READY, NULL);
		}
	}
}

static struct vframe_s *vh264_vf_peek(void *op_arg)
{
	struct vframe_s *vf;

	if (kfifo_peek(&display_q, &vf))
		return vf;

	return NULL;
}

static struct vframe_s *vh264_vf_get(void *op_arg)
{
	struct vframe_s *vf;

	if (kfifo_get(&display_q, &vf))
		return vf;

	return NULL;
}
static bool vf_valid_check(struct vframe_s *vf) {
	int i;
	for (i = 0; i < VF_POOL_SIZE; i++) {
		if (vf == &vfpool[i])
			return true;
	}
	pr_info(" invalid vf been put, vf = %p\n", vf);
	for (i = 0; i < VF_POOL_SIZE; i++) {
		pr_info("www valid vf[%d]= %p \n", i, &vfpool[i]);
	}
	return false;
}

static void vh264_vf_put(struct vframe_s *vf, void *op_arg)
{
	unsigned long flags;

	spin_lock_irqsave(&recycle_lock, flags);

	if ((vf != &fense_vf[0]) && (vf != &fense_vf[1])) {
		if (vf && (vf_valid_check(vf) == true))
			kfifo_put(&recycle_q, (const struct vframe_s *)vf);
	}
	spin_unlock_irqrestore(&recycle_lock, flags);
}

static int vh264_event_cb(int type, void *data, void *private_data)
{
	if (type & VFRAME_EVENT_RECEIVER_RESET) {
		unsigned long flags;

		amvdec_stop();
#ifndef CONFIG_AMLOGIC_POST_PROCESS_MANAGER
		vf_light_unreg_provider(&vh264_vf_prov);
#endif
		spin_lock_irqsave(&lock, flags);
		vh264_local_init();
		vh264_prot_init();
		spin_unlock_irqrestore(&lock, flags);
#ifndef CONFIG_AMLOGIC_POST_PROCESS_MANAGER
		vf_reg_provider(&vh264_vf_prov);
#endif
		amvdec_start();
	}
	return 0;
}

static int vh264_vf_states(struct vframe_states *states, void *op_arg)
{
	unsigned long flags;

	spin_lock_irqsave(&lock, flags);

	states->vf_pool_size = VF_POOL_SIZE;
	states->buf_free_num = kfifo_len(&newframe_q);
	states->buf_avail_num = kfifo_len(&display_q) +
				kfifo_len(&delay_display_q);
	states->buf_recycle_num = kfifo_len(&recycle_q);

	spin_unlock_irqrestore(&lock, flags);

	return 0;
}

#if 0
static tvin_trans_fmt_t convert_3d_format(u32 type)
{
	const tvin_trans_fmt_t conv_tab[] = {
		0,		/* checkerboard */
		0,		/* column alternation */
		TVIN_TFMT_3D_LA,	/* row alternation */
		TVIN_TFMT_3D_LRH_OLER,	/* side by side */
		TVIN_TFMT_3D_FA	/* top bottom */
	};

	return (type <= 4) ? conv_tab[type] : 0;
}
#endif


#define DUMP_CC_AS_ASCII

#ifdef DUMP_CC_AS_ASCII
static int vbi_to_ascii(int c)
{
	if (c < 0)
		return '?';

	c &= 0x7F;

	if (c < 0x20 || c >= 0x7F)
		return '.';

	return c;
}

static void dump_cc_ascii(const uint8_t *buf, unsigned int vpts, int poc)
{
	int cc_flag;
	int cc_count;
	int i;
	int szAscii[32];
	int index = 0;

	cc_flag = buf[1] & 0x40;
	if (!cc_flag) {
		pr_info("### cc_flag is invalid\n");
		return;
	}
	cc_count = buf[1] & 0x1f;

	for (i = 0; i < cc_count; ++i) {
		unsigned int b0;
		unsigned int cc_valid;
		unsigned int cc_type;
		unsigned char cc_data1;
		unsigned char cc_data2;

		b0 = buf[3 + i * 3];
		cc_valid = b0 & 4;
		cc_type = b0 & 3;
		cc_data1 = buf[4 + i * 3];
		cc_data2 = buf[5 + i * 3];


		if (cc_type == 0) {
			/* NTSC pair, Line 21 */
			szAscii[index++] = vbi_to_ascii(cc_data1);
			szAscii[index++] = vbi_to_ascii(cc_data2);
			if ((!cc_valid) || (i >= 3))
				break;
		}
	}

	if (index > 0 && index <= 8) {
		char pr_buf[128];
		int len;

		sprintf(pr_buf, "push vpts:0x%x, poc:%d :", vpts, poc);
		len = strlen(pr_buf);
		for (i=0;i<index;i++)
			sprintf(pr_buf + len + i*2, "%c ", szAscii[i]);
		pr_info("%s\n", pr_buf);
	}

}
#endif

/*
#define DUMP_USER_DATA_HEX
*/
#ifdef DUMP_USER_DATA_HEX
static void print_data(unsigned char *pdata, int len)
{
	int nLeft;
	char buf[128];

	nLeft = len;
	while (nLeft >= 16) {
		int i;

		for (i=0;i<16;i++)
			sprintf(buf+i*3, "%02x ", pdata[i]);

		pr_info("%s\n", buf);
		nLeft -= 16;
		pdata += 16;
	}

	while (nLeft >= 8) {
		int i;
		for (i=0;i<nLeft;i++)
			sprintf(buf+i*3, "%02x ", pdata[i]);

		pr_info("%s\n", buf);
		nLeft -= 8;
		pdata += 8;
	}
}
#endif


static void aml_swap_data(uint8_t *user_data, int ud_size)
{
	int swap_blocks, i, j, k, m;
	unsigned char c_temp;

	/* swap byte order */
	swap_blocks = ud_size / 8;
	for (i = 0; i < swap_blocks; i++) {
		j = i * 8;
		k = j + 7;
		for (m = 0; m < 4; m++) {
			c_temp = user_data[j];
			user_data[j++] = user_data[k];
			user_data[k--] = c_temp;
		}
	}
}


static void udr_dump_data(unsigned int user_data_wp,
						unsigned int user_data_length,
						unsigned int pts,
						int poc)
{
	unsigned char *pdata;
	int user_data_len;
	int wp_start;
	int nLeft;
	unsigned char szBuf[256];
	int nOffset;

	dma_sync_single_for_cpu(amports_get_dma_device(),
			sei_data_buffer_phys, USER_DATA_SIZE,
			DMA_FROM_DEVICE);

	if (user_data_length & 0x07)
		user_data_len = (user_data_length + 8) & 0xFFFFFFF8;
	else
		user_data_len = user_data_length;

	if (user_data_wp >= user_data_len) {
		wp_start = user_data_wp - user_data_len;

		pdata = (unsigned char *)sei_data_buffer;
		pdata += wp_start;
		nLeft = user_data_len;

		memset(szBuf, 0, 256);
		memcpy(szBuf, pdata, user_data_len);
	} else {
		wp_start = user_data_wp +
			USER_DATA_SIZE - user_data_len;

		pdata = (unsigned char *)sei_data_buffer;
		pdata += wp_start;
		nLeft = USER_DATA_SIZE - wp_start;

		memset(szBuf, 0, 256);
		memcpy(szBuf, pdata, nLeft);
		nOffset = nLeft;

		pdata = (unsigned char *)sei_data_buffer;
		nLeft = user_data_wp;
		memcpy(szBuf+nOffset, pdata, nLeft);
	}

	aml_swap_data(szBuf, user_data_len);

#ifdef DUMP_USER_DATA_HEX
	print_data(szBuf, user_data_len);
#endif

#ifdef DUMP_CC_AS_ASCII
	dump_cc_ascii(szBuf+7, pts, poc);
#endif
}


struct vh264_userdata_recored_t {
	struct userdata_meta_info_t meta_info;
	u32 rec_start;
	u32 rec_len;
};

#define USERDATA_FIFO_NUM    256

struct vh264_userdata_info_t {
	struct vh264_userdata_recored_t records[USERDATA_FIFO_NUM];
	u8 *data_buf;
	u8 *data_buf_end;
	u32 buf_len;
	u32 read_index;
	u32 write_index;
	u32 last_wp;
};

static struct vh264_userdata_info_t *p_userdata_mgr;

static DEFINE_MUTEX(userdata_mutex);


void vh264_crate_userdata_manager(u8 *userdata_buf, int buf_len)
{
	p_userdata_mgr = (struct vh264_userdata_info_t *)
		vmalloc(sizeof(struct vh264_userdata_info_t));
	if (p_userdata_mgr) {
		memset(p_userdata_mgr, 0,
			sizeof(struct vh264_userdata_info_t));
		p_userdata_mgr->data_buf = userdata_buf;
		p_userdata_mgr->buf_len = buf_len;
		p_userdata_mgr->data_buf_end = userdata_buf + buf_len;
	}
}

void vh264_destroy_userdata_manager(void)
{
	if (p_userdata_mgr) {
		vfree(p_userdata_mgr);
		p_userdata_mgr = NULL;
	}
}

/*
#define DUMP_USER_DATA
*/
#ifdef DUMP_USER_DATA

#define MAX_USER_DATA_SIZE		3145728
static void *user_data_buf;
static unsigned char *pbuf_start;
static int total_len;
static int bskip;
static int n_userdata_id;


static void print_mem_data(unsigned char *pdata,
						int len,
						unsigned int flag,
						unsigned int duration,
						unsigned int vpts,
						unsigned int vpts_valid,
						int rec_id)
{
	int nLeft;

	nLeft = len;
#if 0
	pr_info("%d len = %d, flag = %d, duration = %d, vpts = 0x%x, vpts_valid = %d\n",
				rec_id,	len, flag,
				duration, vpts, vpts_valid);
#endif
	pr_info("%d len = %d, flag = %d, vpts = 0x%x\n",
				rec_id,	len, flag, vpts);


	while (nLeft >= 16) {
		pr_info("%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
			pdata[0], pdata[1], pdata[2], pdata[3],
			pdata[4], pdata[5], pdata[6], pdata[7],
			pdata[8], pdata[9], pdata[10], pdata[11],
			pdata[12], pdata[13], pdata[14], pdata[15]);
		nLeft -= 16;
		pdata += 16;
	}


	while (nLeft > 0) {
		pr_info("%02x %02x %02x %02x %02x %02x %02x %02x\n",
			pdata[0], pdata[1], pdata[2], pdata[3],
			pdata[4], pdata[5], pdata[6], pdata[7]);
		nLeft -= 8;
		pdata += 8;
	}
}


static void dump_data(u8 *pdata,
						unsigned int user_data_length,
						unsigned int flag,
						unsigned int duration,
						unsigned int vpts,
						unsigned int vpts_valid,
						int rec_id)
{
	unsigned char szBuf[256];


	memset(szBuf, 0, 256);
	memcpy(szBuf, pdata, user_data_length);
/*
	aml_swap_data(szBuf, user_data_length);
*/

	print_mem_data(szBuf, user_data_length,
				flag, duration, vpts,
				vpts_valid, rec_id);

#ifdef DEBUG_CC_DUMP_ASCII
	dump_cc_ascii(szBuf+7);
#endif
}

static void push_to_buf(u8 *pdata, int len, struct userdata_meta_info_t *pmeta)
{
	u32 *pLen;
	int info_cnt;
	u8 *pbuf_end;

	if (!user_data_buf)
		return;

	if (bskip) {
		pr_info("over size, skip\n");
		return;
	}
	info_cnt = 0;
	pLen = (u32 *)pbuf_start;

	*pLen = len;
	pbuf_start += sizeof(u32);
	info_cnt++;
	pLen++;

	*pLen = pmeta->duration;
	pbuf_start += sizeof(u32);
	info_cnt++;
	pLen++;

	*pLen = pmeta->flags;
	pbuf_start += sizeof(u32);
	info_cnt++;
	pLen++;

	*pLen = pmeta->vpts;
	pbuf_start += sizeof(u32);
	info_cnt++;
	pLen++;

	*pLen = pmeta->vpts_valid;
	pbuf_start += sizeof(u32);
	info_cnt++;
	pLen++;


	*pLen = n_userdata_id;
	pbuf_start += sizeof(u32);
	info_cnt++;
	pLen++;


	pbuf_end = (u8 *)sei_data_buffer + USER_DATA_SIZE;
	if (pdata + len > pbuf_end) {
		int first_section_len;

		first_section_len = pbuf_end - pdata;
		memcpy(pbuf_start, pdata, first_section_len);
		pdata = (u8 *)sei_data_buffer;
		pbuf_start += first_section_len;
		memcpy(pbuf_start, pdata, len - first_section_len);
		pbuf_start += len - first_section_len;
	} else {
		memcpy(pbuf_start, pdata, len);
		pbuf_start += len;
	}

	total_len += len + info_cnt * sizeof(u32);
	if (total_len >= MAX_USER_DATA_SIZE-4096)
		bskip = 1;
}


static void dump_userdata_info(
					void *puser_data,
					int len,
					struct userdata_meta_info_t *pmeta)
{
	u8 *pstart;

	pstart = (u8 *)puser_data;


	push_to_buf(pstart, len, pmeta);
}

static void show_user_data_buf(void)
{
	u8 *pbuf;
	int len;
	unsigned int flag;
	unsigned int duration;
	unsigned int vpts;
	unsigned int vpts_valid;
	int rec_id;

	pr_info("show user data buf\n");
	pbuf = user_data_buf;

	while (pbuf < pbuf_start) {
		u32 *pLen;

		pLen = (u32 *)pbuf;

		len = *pLen;
		pLen++;
		pbuf += sizeof(u32);

		duration = *pLen;
		pLen++;
		pbuf += sizeof(u32);

		flag = *pLen;
		pLen++;
		pbuf += sizeof(u32);

		vpts = *pLen;
		pLen++;
		pbuf += sizeof(u32);

		vpts_valid = *pLen;
		pLen++;
		pbuf += sizeof(u32);

		rec_id = *pLen;
		pLen++;
		pbuf += sizeof(u32);

		dump_data(pbuf, len, flag, duration, vpts, vpts_valid, rec_id);
		pbuf += len;
		msleep(30);
	}
}

static int vh264_init_userdata_dump(void)
{
	user_data_buf = kmalloc(MAX_USER_DATA_SIZE, GFP_KERNEL);
	if (user_data_buf)
		return 1;
	else
		return 0;
}

static void vh264_dump_userdata(void)
{
	if (user_data_buf) {
		show_user_data_buf();
		kfree(user_data_buf);
		user_data_buf = NULL;
	}
}

static void vh264_reset_user_data_buf(void)
{
	total_len = 0;
	pbuf_start = user_data_buf;
	bskip = 0;
	n_userdata_id = 0;
}
#endif

static void vh264_add_userdata(struct userdata_meta_info_t meta_info, int wp)
{
	struct vh264_userdata_recored_t *p_userdata_rec;
	int data_length;

	mutex_lock(&userdata_mutex);

	if (p_userdata_mgr) {
		if (wp > p_userdata_mgr->last_wp)
			data_length = wp - p_userdata_mgr->last_wp;
		else
			data_length = wp + p_userdata_mgr->buf_len -
				p_userdata_mgr->last_wp;

		if (data_length & 0x7)
			data_length = (((data_length + 8) >> 3) << 3);
#if 0
		pr_info("wakeup_push: ri:%d, wi:%d, data_len:%d, last_wp:%d, wp:%d, id = %d\n",
			p_userdata_mgr->read_index,
			p_userdata_mgr->write_index,
			data_length,
			p_userdata_mgr->last_wp,
			wp,
			n_userdata_id);
#endif
		p_userdata_rec = p_userdata_mgr->records +
			p_userdata_mgr->write_index;
		p_userdata_rec->meta_info = meta_info;
		p_userdata_rec->rec_start = p_userdata_mgr->last_wp;
		p_userdata_rec->rec_len = data_length;
		p_userdata_mgr->last_wp = wp;

#ifdef DUMP_USER_DATA
		dump_userdata_info(p_userdata_mgr->data_buf +
			p_userdata_rec->rec_start,
			data_length,
			&meta_info);
		n_userdata_id++;
#endif

		p_userdata_mgr->write_index++;
		if (p_userdata_mgr->write_index >= USERDATA_FIFO_NUM)
			p_userdata_mgr->write_index = 0;
	}
	mutex_unlock(&userdata_mutex);

	vdec_wakeup_userdata_poll(vdec_h264);
}

static int vh264_user_data_read(struct vdec_s *vdec,
				struct userdata_param_t *puserdata_para)
{
	int rec_ri, rec_wi;
	int rec_len;
	u8 *rec_data_start;
	u8 *pdest_buf;
	struct vh264_userdata_recored_t *p_userdata_rec;
	u32 data_size;
	u32 res;
	int copy_ok = 1;


	pdest_buf = puserdata_para->pbuf_addr;


	mutex_lock(&userdata_mutex);

	if (!p_userdata_mgr) {
		mutex_unlock(&userdata_mutex);
		return 0;
	}
/*
	pr_info("ri = %d, wi = %d\n",
		p_userdata_mgr->read_index,
		p_userdata_mgr->write_index);
*/
	rec_ri = p_userdata_mgr->read_index;
	rec_wi = p_userdata_mgr->write_index;

	if (rec_ri == rec_wi) {
		mutex_unlock(&userdata_mutex);
		return 0;
	}

	p_userdata_rec = p_userdata_mgr->records + rec_ri;

	rec_len = p_userdata_rec->rec_len;
	rec_data_start = p_userdata_rec->rec_start + p_userdata_mgr->data_buf;
/*
	pr_info("rec_len:%d, rec_start:%d, buf_len:%d\n",
		p_userdata_rec->rec_len,
		p_userdata_rec->rec_start,
		puserdata_para->buf_len);
*/
	if (rec_len <= puserdata_para->buf_len) {
		/* dvb user data buffer is enought to copy the whole recored. */
		data_size = rec_len;
		if (rec_data_start + data_size
			> p_userdata_mgr->data_buf_end) {
			int first_section_len;

			first_section_len = p_userdata_mgr->buf_len -
				p_userdata_rec->rec_start;
			res = (u32)copy_to_user((void *)pdest_buf,
							(void *)rec_data_start,
							first_section_len);
			if (res) {
				pr_info("p1 read not end res=%d, request=%d\n",
					res, first_section_len);
				copy_ok = 0;

				p_userdata_rec->rec_len -=
					first_section_len - res;
				p_userdata_rec->rec_start +=
					first_section_len - res;
				puserdata_para->data_size =
					first_section_len - res;
			} else {
				res = (u32)copy_to_user(
					(void *)(pdest_buf+first_section_len),
					(void *)p_userdata_mgr->data_buf,
					data_size - first_section_len);
				if (res) {
					pr_info("p2 read not end res=%d, request=%d\n",
						res, data_size);
					copy_ok = 0;
				}
				p_userdata_rec->rec_len -=
					data_size - res;
				p_userdata_rec->rec_start =
					data_size - first_section_len - res;
				puserdata_para->data_size =
					data_size - res;
			}
		} else {
			res = (u32)copy_to_user((void *)pdest_buf,
						(void *)rec_data_start,
						data_size);
			if (res) {
				pr_info("p3 read not end res=%d, request=%d\n",
					res, data_size);
				copy_ok = 0;
			}
			p_userdata_rec->rec_len -= data_size - res;
			p_userdata_rec->rec_start += data_size - res;
			puserdata_para->data_size = data_size - res;
		}

		if (copy_ok) {
			p_userdata_mgr->read_index++;
			if (p_userdata_mgr->read_index >= USERDATA_FIFO_NUM)
				p_userdata_mgr->read_index = 0;
		}
	} else {
		/* dvb user data buffer is not enought
		to copy the whole recored. */
		data_size = puserdata_para->buf_len;
		if (rec_data_start + data_size
			> p_userdata_mgr->data_buf_end) {
			int first_section_len;

			first_section_len = p_userdata_mgr->buf_len
						- p_userdata_rec->rec_start;
			res = (u32)copy_to_user((void *)pdest_buf,
						(void *)rec_data_start,
						first_section_len);
			if (res) {
				pr_info("p4 read not end res=%d, request=%d\n",
					res, first_section_len);
				copy_ok = 0;
				p_userdata_rec->rec_len -=
					first_section_len - res;
				p_userdata_rec->rec_start +=
					first_section_len - res;
				puserdata_para->data_size =
					first_section_len - res;
			} else {
				/* first secton copy is ok*/
				res = (u32)copy_to_user(
					(void *)(pdest_buf+first_section_len),
					(void *)p_userdata_mgr->data_buf,
					data_size - first_section_len);
				if (res) {
					pr_info("p5 read not end res=%d, request=%d\n",
						res,
						data_size - first_section_len);
					copy_ok = 0;
				}

				p_userdata_rec->rec_len -= data_size - res;
				p_userdata_rec->rec_start =
					data_size - first_section_len - res;
				puserdata_para->data_size = data_size - res;
			}
		} else {
			res = (u32)copy_to_user((void *)pdest_buf,
							(void *)rec_data_start,
							data_size);
			if (res) {
				pr_info("p6 read not end res=%d, request=%d\n",
					res, data_size);
				copy_ok = 0;
			}

			p_userdata_rec->rec_len -= data_size - res;
			p_userdata_rec->rec_start += data_size - res;
			puserdata_para->data_size = data_size - res;
		}

		if (copy_ok) {
			p_userdata_mgr->read_index++;
			if (p_userdata_mgr->read_index
				>= USERDATA_FIFO_NUM)
				p_userdata_mgr->read_index = 0;
		}

	}
	puserdata_para->meta_info = p_userdata_rec->meta_info;

	if (p_userdata_mgr->read_index <= p_userdata_mgr->write_index)
		puserdata_para->meta_info.records_in_que =
			p_userdata_mgr->write_index -
			p_userdata_mgr->read_index;
	else
		puserdata_para->meta_info.records_in_que =
			p_userdata_mgr->write_index +
			USERDATA_FIFO_NUM -
			p_userdata_mgr->read_index;

	puserdata_para->version = (0<<24|0<<16|0<<8|1);

	mutex_unlock(&userdata_mutex);

	return 1;
}

static void vh264_wakeup_userdata_poll(struct vdec_s *vdec)
{
	amstream_wakeup_userdata_poll(vdec);
}

static void vh264_reset_userdata_fifo(struct vdec_s *vdec, int bInit)
{
	mutex_lock(&userdata_mutex);

	if (p_userdata_mgr) {
		pr_info("h264_reset_userdata_fifo: bInit: %d, ri: %d, wi: %d\n",
			bInit, p_userdata_mgr->read_index,
			p_userdata_mgr->write_index);
		p_userdata_mgr->read_index = 0;
		p_userdata_mgr->write_index = 0;

		if (bInit)
			p_userdata_mgr->last_wp = 0;
	}

	mutex_unlock(&userdata_mutex);
}

static void h264_reset_qos_mgr(void)
{
	int i;

	pr_info("h264_reset_qos_mgr\n");

	INIT_LIST_HEAD(&free_qos_nodes_list);
	INIT_LIST_HEAD(&picture_qos_list);

	for (i = 0; i < MAX_FREE_QOS_NODES; i++) {
		free_nodes[i].b_offset = 0xFFFFFFFF;

		list_add_tail(&free_nodes[i].list,
				&free_qos_nodes_list);
	}
}


static void load_qos_data(int pic_number, uint32_t b_offset)
{
	uint32_t blk88_y_count;
	uint32_t blk88_c_count;
	uint32_t blk22_mv_count;
	uint32_t rdata32;
	int32_t mv_hi;
	int32_t mv_lo;
	uint32_t rdata32_l;
	uint32_t mvx_L0_hi;
	uint32_t mvy_L0_hi;
	uint32_t mvx_L1_hi;
	uint32_t mvy_L1_hi;
	int64_t value;
	uint64_t temp_value;
/*
#define DEBUG_QOS
*/
#define SUPPORT_NODE

#ifdef SUPPORT_NODE
	struct h264_qos_data_node_t *node;
	struct h264_qos_data_node_t *tmp;
	int bFoundNode = 0;

	node = NULL;
	if (!list_empty(&picture_qos_list)) {
		list_for_each_entry_safe(node, tmp, &picture_qos_list, list) {
			if (node->b_offset == b_offset) {
				bFoundNode = 1;
				break;
			}
		}
	}
	/*
	pr_info("bFoundNode = %d, node:0x%p\n", bFoundNode, node);
	*/
	if (!bFoundNode) {
		if (!list_empty(&free_qos_nodes_list)) {
			node = list_entry(
					free_qos_nodes_list.next,
					struct h264_qos_data_node_t,
					list);
			/*
			pr_info("get a node:0x%p\n", node);
			*/
		} else {
			pr_info("there is no qos data node avaible\n");

			return;
		}
	}

	node->b_offset = b_offset;
	node->poc = pic_number;

	node->max_mv = 0;
	node->avg_mv = 0;
	node->min_mv = 0;

	node->max_skip = 0;
	node->avg_skip = 0;
	node->min_skip = 0;

	node->max_qp = 0;
	node->avg_qp = 0;
	node->min_qp = 0;
#endif


	/* set rd_idx to 0 */
	WRITE_VREG(VDEC_PIC_QUALITY_CTRL, 0);
	blk88_y_count = READ_VREG(VDEC_PIC_QUALITY_DATA);
	if (blk88_y_count == 0) {
#ifdef DEBUG_QOS
		pr_info(" [Picture %d Quality] NO Data yet.\n",
			pic_number);
#endif
		/* reset all counts */
		WRITE_VREG(VDEC_PIC_QUALITY_CTRL, (1<<8));

#ifdef SUPPORT_NODE
		list_move(&node->list, &picture_qos_list);
#endif
		return;
	}
	/* qp_y_sum */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] Y QP AVG : %d (%d/%d)\n",
		pic_number, rdata32/blk88_y_count,
		rdata32, blk88_y_count);
#endif
#ifdef SUPPORT_NODE
	node->avg_qp = rdata32/blk88_y_count;
#endif

	/* intra_y_count */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] Y intra rate : %d%c (%d)\n",
		pic_number, rdata32*100/blk88_y_count,
		'%', rdata32);
#endif
	/* skipped_y_count */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] Y skipped rate : %d%c (%d)\n",
		pic_number, rdata32*100/blk88_y_count,
		'%', rdata32);
#endif
#ifdef SUPPORT_NODE
	node->avg_skip = rdata32*100/blk88_y_count;
#endif
	/* coeff_non_zero_y_count */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] Y ZERO_Coeff rate : %d%c (%d)\n",
		pic_number, (100 - rdata32*100/(blk88_y_count*1)),
		'%', rdata32);
#endif
	/* blk66_c_count */
	blk88_c_count = READ_VREG(VDEC_PIC_QUALITY_DATA);
	if (blk88_c_count == 0) {
#ifdef DEBUG_QOS
		pr_info(" [Picture %d Quality] NO Data yet.\n",
			pic_number);
#endif
		/* reset all counts */
		WRITE_VREG(VDEC_PIC_QUALITY_CTRL, (1<<8));

#ifdef SUPPORT_NODE
		list_move(&node->list, &picture_qos_list);
#endif
		return;
	}
	/* qp_c_sum */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] C QP AVG : %d (%d/%d)\n",
		pic_number, rdata32/blk88_c_count,
		rdata32, blk88_c_count);
#endif
	/* intra_c_count */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] C intra rate : %d%c (%d)\n",
		pic_number, rdata32*100/blk88_c_count,
		'%', rdata32);
#endif
	/* skipped_cu_c_count */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] C skipped rate : %d%c (%d)\n",
		pic_number, rdata32*100/blk88_c_count,
		'%', rdata32);
#endif
	/* coeff_non_zero_c_count */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] C ZERO_Coeff rate : %d%c (%d)\n",
		pic_number, (100 - rdata32*100/(blk88_c_count*1)),
		'%', rdata32);
#endif

	/* 1'h0, qp_c_max[6:0], 1'h0, qp_c_min[6:0],
	1'h0, qp_y_max[6:0], 1'h0, qp_y_min[6:0] */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] Y QP min : %d\n",
		pic_number, (rdata32>>0)&0xff);
#endif
#ifdef SUPPORT_NODE
	node->min_qp = (rdata32>>0)&0xff;
#endif

#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] Y QP max : %d\n",
		pic_number, (rdata32>>8)&0xff);
#endif
#ifdef SUPPORT_NODE
	node->max_qp = (rdata32>>8)&0xff;
#endif

#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] C QP min : %d\n",
		pic_number, (rdata32>>16)&0xff);
	pr_info(" [Picture %d Quality] C QP max : %d\n",
		pic_number, (rdata32>>24)&0xff);
#endif

	/* blk22_mv_count */
	blk22_mv_count = READ_VREG(VDEC_PIC_QUALITY_DATA);
	if (blk22_mv_count == 0) {
#ifdef DEBUG_QOS
		pr_info(" [Picture %d Quality] NO MV Data yet.\n",
			pic_number);
#endif
		/* reset all counts */
		WRITE_VREG(VDEC_PIC_QUALITY_CTRL, (1<<8));
#ifdef SUPPORT_NODE
		list_move(&node->list, &picture_qos_list);
#endif
		return;
	}
	/* mvy_L1_count[39:32], mvx_L1_count[39:32],
	mvy_L0_count[39:32], mvx_L0_count[39:32] */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
	/* should all be 0x00 or 0xff */
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] MV AVG High Bits: 0x%X\n",
		pic_number, rdata32);
#endif
	mvx_L0_hi = ((rdata32>>0)&0xff);
	mvy_L0_hi = ((rdata32>>8)&0xff);
	mvx_L1_hi = ((rdata32>>16)&0xff);
	mvy_L1_hi = ((rdata32>>24)&0xff);

	/* mvx_L0_count[31:0] */
	rdata32_l = READ_VREG(VDEC_PIC_QUALITY_DATA);
	temp_value = mvx_L0_hi;
	temp_value = (temp_value << 32) | rdata32_l;

	if (mvx_L0_hi & 0x80)
		value = 0xFFFFFFF000000000 | temp_value;
	else
		value = temp_value;
	value = div_s64(value, blk22_mv_count);
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] MVX_L0 AVG : %d (%lld/%d)\n",
		pic_number, (int)(value),
		value, blk22_mv_count);
#endif
#ifdef SUPPORT_NODE
	node->avg_mv = value;
#endif

	/* mvy_L0_count[31:0] */
	rdata32_l = READ_VREG(VDEC_PIC_QUALITY_DATA);
	temp_value = mvy_L0_hi;
	temp_value = (temp_value << 32) | rdata32_l;

	if (mvy_L0_hi & 0x80)
		value = 0xFFFFFFF000000000 | temp_value;
	else
		value = temp_value;
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] MVY_L0 AVG : %d (%lld/%d)\n",
		pic_number, rdata32_l/blk22_mv_count,
		value, blk22_mv_count);
#endif

	/* mvx_L1_count[31:0] */
	rdata32_l = READ_VREG(VDEC_PIC_QUALITY_DATA);
	temp_value = mvx_L1_hi;
	temp_value = (temp_value << 32) | rdata32_l;
	if (mvx_L1_hi & 0x80)
		value = 0xFFFFFFF000000000 | temp_value;
	else
		value = temp_value;
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] MVX_L1 AVG : %d (%lld/%d)\n",
		pic_number, rdata32_l/blk22_mv_count,
		value, blk22_mv_count);
#endif

	/* mvy_L1_count[31:0] */
	rdata32_l = READ_VREG(VDEC_PIC_QUALITY_DATA);
	temp_value = mvy_L1_hi;
	temp_value = (temp_value << 32) | rdata32_l;
	if (mvy_L1_hi & 0x80)
		value = 0xFFFFFFF000000000 | temp_value;
	else
		value = temp_value;
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] MVY_L1 AVG : %d (%lld/%d)\n",
		pic_number, rdata32_l/blk22_mv_count,
		value, blk22_mv_count);
#endif

	/* {mvx_L0_max, mvx_L0_min} // format : {sign, abs[14:0]}  */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
	mv_hi = (rdata32>>16)&0xffff;
	if (mv_hi & 0x8000)
		mv_hi = 0x8000 - mv_hi;
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] MVX_L0 MAX : %d\n",
		pic_number, mv_hi);
#endif
#ifdef SUPPORT_NODE
	node->max_mv = mv_hi;
#endif

	mv_lo = (rdata32>>0)&0xffff;
	if (mv_lo & 0x8000)
		mv_lo = 0x8000 - mv_lo;
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] MVX_L0 MIN : %d\n",
		pic_number, mv_lo);
#endif
#ifdef SUPPORT_NODE
	node->min_mv = mv_lo;
#endif

#ifdef DEBUG_QOS
	/* {mvy_L0_max, mvy_L0_min} */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
	mv_hi = (rdata32>>16)&0xffff;
	if (mv_hi & 0x8000)
		mv_hi = 0x8000 - mv_hi;
	pr_info(" [Picture %d Quality] MVY_L0 MAX : %d\n",
		pic_number, mv_hi);


	mv_lo = (rdata32>>0)&0xffff;
	if (mv_lo & 0x8000)
		mv_lo = 0x8000 - mv_lo;

	pr_info(" [Picture %d Quality] MVY_L0 MIN : %d\n",
		pic_number, mv_lo);


	/* {mvx_L1_max, mvx_L1_min} */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
	mv_hi = (rdata32>>16)&0xffff;
	if (mv_hi & 0x8000)
		mv_hi = 0x8000 - mv_hi;

	pr_info(" [Picture %d Quality] MVX_L1 MAX : %d\n",
		pic_number, mv_hi);


	mv_lo = (rdata32>>0)&0xffff;
	if (mv_lo & 0x8000)
		mv_lo = 0x8000 - mv_lo;

	pr_info(" [Picture %d Quality] MVX_L1 MIN : %d\n",
		pic_number, mv_lo);


	/* {mvy_L1_max, mvy_L1_min} */
	rdata32 = READ_VREG(VDEC_PIC_QUALITY_DATA);
	mv_hi = (rdata32>>16)&0xffff;
	if (mv_hi & 0x8000)
		mv_hi = 0x8000 - mv_hi;

	pr_info(" [Picture %d Quality] MVY_L1 MAX : %d\n",
		pic_number, mv_hi);

	mv_lo = (rdata32>>0)&0xffff;
	if (mv_lo & 0x8000)
		mv_lo = 0x8000 - mv_lo;

	pr_info(" [Picture %d Quality] MVY_L1 MIN : %d\n",
		pic_number, mv_lo);
#endif

	rdata32 = READ_VREG(VDEC_PIC_QUALITY_CTRL);
#ifdef DEBUG_QOS
	pr_info(" [Picture %d Quality] After Read : VDEC_PIC_QUALITY_CTRL : 0x%x\n",
		pic_number, rdata32);
#endif
	/* reset all counts */
	WRITE_VREG(VDEC_PIC_QUALITY_CTRL, (1<<8));
#ifdef SUPPORT_NODE
	list_move(&node->list, &picture_qos_list);
#endif
}

void search_qos_node(struct vframe_qos_s *picture_qos, uint32_t b_offset)
{
	struct h264_qos_data_node_t *node;
	struct h264_qos_data_node_t *tmp;

	if (!list_empty(&picture_qos_list)) {
		list_for_each_entry_safe(node, tmp, &picture_qos_list, list) {
			if (node->b_offset == b_offset) {

				picture_qos->avg_mv = node->avg_mv;
				picture_qos->min_mv = node->min_mv;
				picture_qos->max_mv = node->max_mv;

				picture_qos->avg_skip = node->avg_skip;
				picture_qos->min_skip = node->min_skip;
				picture_qos->max_skip = node->max_skip;

				picture_qos->avg_qp = node->avg_qp;
				picture_qos->min_qp = node->min_qp;
				picture_qos->max_qp = node->max_qp;

#if 0
				pr_info("POC:%d, mv: max:%d,  avg:%d, min:%d\n"
					"qp: max:%d,  avg:%d, min:%d\n"
					"skip: max:%d,  avg:%d, min:%d\n",
					node->poc,
					picture_qos->max_mv,
					picture_qos->avg_mv,
					picture_qos->min_mv,
					picture_qos->max_qp,
					picture_qos->avg_qp,
					picture_qos->min_qp,
					picture_qos->max_skip,
					picture_qos->avg_skip,
					picture_qos->min_skip);
#endif
				node->b_offset = 0xFFFFFFFF;
				list_move(&node->list, &free_qos_nodes_list);

				break;
			}
		}
	}
}

static void qos_do_work(struct work_struct *work)
{
	uint32_t poc;
	uint32_t bOffset;


	poc = READ_VREG(AV_SCRATCH_M);
	bOffset = READ_VREG(AV_SCRATCH_L);
/*
	pr_info("poc:%d, bOffset:0x%x\n", poc, bOffset);
*/
	load_qos_data(poc, bOffset);


	WRITE_VREG(AV_SCRATCH_0, 0);
}

static void userdata_push_do_work(struct work_struct *work)
{
	unsigned int sei_itu35_flags;
	unsigned int sei_itu35_wp;
	unsigned int sei_itu35_data_length;

	struct userdata_meta_info_t meta_info;
	u32 offset, pts;
	u64 pts_us64 = 0;
	u32 slice_type;
	u32 reg;
	u32 poc_number;
	u32 picture_struct;

	memset(&meta_info, 0, sizeof(meta_info));

	meta_info.duration = frame_dur;

	reg = READ_VREG(AV_SCRATCH_M);
	poc_number = reg & 0x7FFFFFF;
	if ((poc_number >> 16) == 0x7FF)
		poc_number = (reg & 0x7FFFFFF) - 0x8000000;

	slice_type = (reg >> 29) & 0x7;
	switch (slice_type) {
	case SLICE_TYPE_I:
			meta_info.flags |= 1<<7;
			break;
	case SLICE_TYPE_P:
			meta_info.flags |= 3<<7;
			break;
	case SLICE_TYPE_B:
			meta_info.flags |= 2<<7;
			break;
	}
	meta_info.poc_number = poc_number;
	picture_struct = (reg >> 27) & 0x3;

	meta_info.flags |= (VFORMAT_H264 << 3) | (picture_struct << 12);


	offset = READ_VREG(AV_SCRATCH_L);

	if (pts_pickout_offset_us64
			 (PTS_TYPE_VIDEO, offset, &pts, 0, &pts_us64) != 0) {
		pr_info("pts pick outfailed, offset:0x%x\n", offset);
		pts = -1;
		meta_info.vpts_valid = 0;
	} else
		meta_info.vpts_valid = 1;
	meta_info.vpts = pts;
/*
	pr_info("offset:0x%x, vpts:0x%x, slice:%d, poc:%d\n",
		offset, pts, slice_type,
		poc_number);
*/
	sei_itu35_flags = READ_VREG(AV_SCRATCH_J);
	sei_itu35_wp = (sei_itu35_flags >> 16) & 0xffff;
	sei_itu35_data_length = sei_itu35_flags & 0x7fff;

	if (enable_userdata_debug)
		udr_dump_data(sei_itu35_wp,
			sei_itu35_data_length,
			pts, poc_number);


	vh264_add_userdata(meta_info, sei_itu35_wp);

	WRITE_VREG(AV_SCRATCH_J, 0);
}


static void set_frame_info(struct vframe_s *vf)
{
	vf->width = frame_width;
	vf->height = frame_height;
	vf->duration = frame_dur;
	vf->ratio_control =
		(min(h264_ar, (u32) DISP_RATIO_ASPECT_RATIO_MAX)) <<
		DISP_RATIO_ASPECT_RATIO_BIT;
	vf->orientation = vh264_rotation;
	vf->flag = 0;

#ifdef CONFIG_AMLOGIC_POST_PROCESS_MANAGER_3D_PROCESS
	vf->trans_fmt = 0;
	if ((vf->trans_fmt == TVIN_TFMT_3D_LRF) ||
		(vf->trans_fmt == TVIN_TFMT_3D_LA)) {
		vf->left_eye.start_x = 0;
		vf->left_eye.start_y = 0;
		vf->left_eye.width = frame_width / 2;
		vf->left_eye.height = frame_height;

		vf->right_eye.start_x = 0;
		vf->right_eye.start_y = 0;
		vf->right_eye.width = frame_width / 2;
		vf->right_eye.height = frame_height;
	} else if ((vf->trans_fmt == TVIN_TFMT_3D_LRH_OLER) ||
			   (vf->trans_fmt == TVIN_TFMT_3D_TB)) {
		vf->left_eye.start_x = 0;
		vf->left_eye.start_y = 0;
		vf->left_eye.width = frame_width / 2;
		vf->left_eye.height = frame_height;

		vf->right_eye.start_x = 0;
		vf->right_eye.start_y = 0;
		vf->right_eye.width = frame_width / 2;
		vf->right_eye.height = frame_height;
	}
#endif

}

#ifdef CONFIG_AMLOGIC_POST_PROCESS_MANAGER
static void vh264_ppmgr_reset(void)
{
	vf_notify_receiver(PROVIDER_NAME, VFRAME_EVENT_PROVIDER_RESET, NULL);

	vh264_local_init();

	pr_info("vh264dec: vf_ppmgr_reset\n");
}
#endif

static int get_max_dpb_size(int level_idc, int mb_width, int mb_height)
{
	int size, r;

	switch (level_idc) {
	case 10:
		r = 1485;
		break;
	case 11:
		r = 3375;
		break;
	case 12:
	case 13:
	case 20:
		r = 8910;
		break;
	case 21:
		r = 17820;
		break;
	case 22:
	case 30:
		r = 30375;
		break;
	case 31:
		r = 67500;
		break;
	case 32:
		r = 76800;
		break;
	case 40:
	case 41:
	case 42:
		r = 122880;
		break;
	case 50:
		r = 414000;
		break;
	case 51:
	case 52:
		r = 691200;
		break;
	default:
		return 0;
		}
		size = (mb_width * mb_height +
				(mb_width * mb_height / 2)) * 256 * 10;
		r = (r * 1024 + size-1) / size;
		r = min(r, 16);
		/*pr_info("max_dpb %d size:%d\n", r, size);*/
		return r;
}
static void vh264_set_params(struct work_struct *work)
{
	int aspect_ratio_info_present_flag, aspect_ratio_idc;
	int max_dpb_size, actual_dpb_size, max_reference_size;
	int i, mb_mv_byte, ret;
	unsigned long addr;
	unsigned int post_canvas, buf_size, endian;
	unsigned int frame_mbs_only_flag;
	unsigned int chroma_format_idc, chroma444, video_signal;
	unsigned int crop_infor, crop_bottom, crop_right, level_idc;
	if (!atomic_read(&vh264_active))
		return;
	mutex_lock(&vh264_mutex);
	if (vh264_stream_switching_state == SWITCHING_STATE_ON_CMD1)
		vh264_stream_switching_state = SWITCHING_STATE_ON_CMD1_PENDING;
	post_canvas = get_post_canvas();
	clk_adj_frame_count = 0;
	/* set to max decoder clock rate at the beginning */

	if (vdec_is_support_4k())
		vdec_source_changed(VFORMAT_H264, 3840, 2160, 60);
	else
		vdec_source_changed(VFORMAT_H264, 1920, 1080, 29);

	timing_info_present_flag = 0;
	mb_width = READ_VREG(AV_SCRATCH_1);
	seq_info = READ_VREG(AV_SCRATCH_2);
	aspect_ratio_info = READ_VREG(AV_SCRATCH_3);
	num_units_in_tick = READ_VREG(AV_SCRATCH_4);
	time_scale = READ_VREG(AV_SCRATCH_5);
	level_idc = READ_VREG(AV_SCRATCH_A);
	if (level_idc > 0)
		saved_idc_level = level_idc;
	else if (saved_idc_level > 0)
		level_idc = saved_idc_level;
	video_signal = READ_VREG(AV_SCRATCH_H);
	video_signal_from_vui =
				((video_signal & 0xffff) << 8) |
				((video_signal & 0xff0000) >> 16) |
				((video_signal & 0x3f000000));
/*
 *	pr_info("video_signal_type_present_flag 0x%x\n",
 *				(video_signal_from_vui >> 29) & 1);
 *	pr_info("video_format  0x%x\n",
 *				(video_signal_from_vui >> 26) & 7);
 *	pr_info("video_full_range_flag  0x%x\n",
 *				(video_signal_from_vui >> 25) & 1);
 *	pr_info("color_description_present_flag  0x%x\n",
 *				(video_signal_from_vui >> 24) & 1);
 *	pr_info("color_primaries	0x%x\n",
 *				(video_signal_from_vui >> 16) & 0xff);
 *	pr_info("transfer_characteristic	0x%x\n",
 *				(video_signal_from_vui >> 8) & 0xff);
 *	pr_info("matrix_coefficient	0x%x\n",
 *				video_signal_from_vui  & 0xff);
 */

	mb_total = (mb_width >> 8) & 0xffff;
	max_reference_size = (mb_width >> 24) & 0x7f;
	mb_mv_byte = (mb_width & 0x80000000) ? 24 : 96;
	if (ucode_type == UCODE_IP_ONLY_PARAM)
		mb_mv_byte = 96;
	mb_width = mb_width & 0xff;
	if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXTVBB) {
		if (!mb_width && mb_total)
			mb_width = 256;
	}
	if (mb_width)
		mb_height = mb_total / mb_width;
	last_duration = 0;
	/* AV_SCRATCH_2
	 *  bit 15: frame_mbs_only_flag
	 *  bit 13-14: chroma_format_idc
	 */
	frame_mbs_only_flag = (seq_info >> 15) & 0x01;
	chroma_format_idc = (seq_info >> 13) & 0x03;
	chroma444 = (chroma_format_idc == 3) ? 1 : 0;

	/* @AV_SCRATCH_6.31-16 =  (left  << 8 | right ) << 1
	 *   @AV_SCRATCH_6.15-0   =  (top << 8  | bottom ) <<
	 * (2 - frame_mbs_only_flag)
	 */
	crop_infor = READ_VREG(AV_SCRATCH_6);
	crop_bottom = (crop_infor & 0xff) >> (2 - frame_mbs_only_flag);
	crop_right = ((crop_infor >> 16) & 0xff) >> (2 - frame_mbs_only_flag);

	/* if width or height from outside is not equal to mb, then use mb */
	/* add: for seeking stream with other resolution */
	if ((last_mb_width && (last_mb_width != mb_width))
		|| (mb_width != ((frame_width + 15) >> 4)))
		frame_width = 0;
	if ((last_mb_height && (last_mb_height != mb_height))
		|| (mb_height != ((frame_height + 15) >> 4)))
		frame_height = 0;
	last_mb_width = mb_width;
	last_mb_height = mb_height;

	if ((frame_width == 0) || (frame_height == 0) || crop_infor) {
		frame_width = mb_width << 4;
		frame_height = mb_height << 4;
		if (frame_mbs_only_flag) {
			frame_height =
				frame_height - (2 >> chroma444) *
				min(crop_bottom,
					(unsigned int)((8 << chroma444) - 1));
			frame_width =
				frame_width - (2 >> chroma444) * min(crop_right,
						(unsigned
						 int)((8 << chroma444) - 1));
		} else {
			frame_height =
				frame_height - (4 >> chroma444) *
				min(crop_bottom,
					(unsigned int)((8 << chroma444)
							  - 1));
			frame_width =
				frame_width - (4 >> chroma444) * min(crop_right,
						(unsigned
						 int)((8 <<
							   chroma444)
							  - 1));
		}
#if 0
		pr_info
		("frame_mbs_only_flag %d, crop_bottom %d,  frame_height %d, ",
		 frame_mbs_only_flag, crop_bottom, frame_height);
		pr_info
		("mb_height %d,crop_right %d, frame_width %d, mb_width %d\n",
		 mb_height, crop_right, frame_width, mb_width);
#endif
		if (frame_height == 1088)
			frame_height = 1080;
	}

	mb_width = (mb_width + 3) & 0xfffffffc;
	mb_height = (mb_height + 3) & 0xfffffffc;
	mb_total = mb_width * mb_height;

	 /*max_reference_size <= max_dpb_size <= actual_dpb_size*/
	 is_4k = (mb_total > 8160) ? true:false;


	max_dpb_size = get_max_dpb_size(level_idc, mb_width, mb_height);
	if (max_dpb_size < max_reference_size)
		max_dpb_size = max_reference_size;
	if (max_dpb_size > 15
		&& get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXTVBB
		&& (codec_mm_get_total_size() < 80 * SZ_1M)) {
				actual_dpb_size
				= max_reference_size + dpb_size_adj;
			if (actual_dpb_size > VF_BUF_NUM)
				actual_dpb_size = VF_BUF_NUM;
	} else {
		actual_dpb_size = max_dpb_size + dpb_size_adj;
		actual_dpb_size = min(actual_dpb_size, VF_BUF_NUM);
	}
	max_reference_size++;
	pr_info("actual_dpb_size %d max_dpb_size %d max_ref %d\n",
				actual_dpb_size, max_dpb_size,
				max_reference_size);
	buf_size = mb_total * mb_mv_byte * max_reference_size;

	ret = decoder_bmmu_box_alloc_buf_phy(mm_blk_handle, 1,
		buf_size, DRIVER_NAME, &addr);

	if (ret < 0) {
		fatal_error_flag =
			DECODER_FATAL_ERROR_NO_MEM;
		vh264_running = 0;
		mutex_unlock(&vh264_mutex);
		return;
	}

	WRITE_VREG(AV_SCRATCH_1, addr);
	WRITE_VREG(AV_SCRATCH_3, post_canvas);
	WRITE_VREG(AV_SCRATCH_4, addr + buf_size);

	if (!(READ_VREG(AV_SCRATCH_F) & 0x1)) {
		for (i = 0; i < actual_dpb_size; i++) {
#ifdef DOUBLE_WRITE
				int page_count =
				PAGE_ALIGN((mb_total << 8) + (mb_total
						<< 7) +	(mb_total << 6) +
						(mb_total << 5)) / PAGE_SIZE;
#else
				int page_count =
					PAGE_ALIGN((mb_total << 8) +
						(mb_total << 7)) / PAGE_SIZE;
#endif

			ret = decoder_bmmu_box_alloc_buf_phy(mm_blk_handle,
				VF_BUFFER_IDX(i),
				page_count << PAGE_SHIFT,
				DRIVER_NAME, &buffer_spec[i].phy_addr);

			if (ret < 0) {
				buffer_spec[i].alloc_count = 0;
				fatal_error_flag =
				DECODER_FATAL_ERROR_NO_MEM;
				vh264_running = 0;
				mutex_unlock(&vh264_mutex);
				return;
			}

			addr = buffer_spec[i].phy_addr;
			buffer_spec[i].alloc_count = page_count;

			if (i <= 21) {
				buffer_spec[i].y_addr = addr;
				addr += mb_total << 8;
				buffer_spec[i].u_addr = addr;
				buffer_spec[i].v_addr = addr;
				addr += mb_total << 7;
				vfbuf_use[i] = 0;

				buffer_spec[i].y_canvas_index = 128 + i * 2;
				buffer_spec[i].u_canvas_index = 128 + i * 2 + 1;
				buffer_spec[i].v_canvas_index = 128 + i * 2 + 1;

				buffer_spec[i].y_canvas_width = mb_width << 4;
				buffer_spec[i].y_canvas_height = mb_height << 4;
				buffer_spec[i].u_canvas_width = mb_width << 4;
				buffer_spec[i].u_canvas_height = mb_height << 4;
				buffer_spec[i].v_canvas_width = mb_width << 4;
				buffer_spec[i].v_canvas_height = mb_height << 4;

				endian = (canvas_mode == CANVAS_BLKMODE_LINEAR)?7:0;
				canvas_config_ex(128 + i * 2,
						buffer_spec[i].y_addr,
						mb_width << 4, mb_height << 4,
						CANVAS_ADDR_NOWRAP,
						canvas_mode, endian);
				canvas_config_ex(128 + i * 2 + 1,
						buffer_spec[i].u_addr,
						mb_width << 4, mb_height << 3,
						CANVAS_ADDR_NOWRAP,
						canvas_mode, endian);
				WRITE_VREG(ANC0_CANVAS_ADDR + i,
						spec2canvas(&buffer_spec[i]));
				} else {
				buffer_spec[i].y_canvas_index =
					2 * (i - 21) + 4;
				buffer_spec[i].y_addr = addr;
				addr += mb_total << 8;
				buffer_spec[i].u_canvas_index =
					2 * (i - 21) + 5;
				buffer_spec[i].v_canvas_index =
					2 * (i - 21) + 5;
				buffer_spec[i].u_addr = addr;
				addr += mb_total << 7;
				vfbuf_use[i] = 0;

				buffer_spec[i].y_canvas_width = mb_width << 4;
				buffer_spec[i].y_canvas_height = mb_height << 4;
				buffer_spec[i].u_canvas_width = mb_width << 4;
				buffer_spec[i].u_canvas_height = mb_height << 4;
				buffer_spec[i].v_canvas_width = mb_width << 4;
				buffer_spec[i].v_canvas_height = mb_height << 4;

				spec_set_canvas(&buffer_spec[i]
					, mb_width << 4, mb_height << 4);
				WRITE_VREG(ANC0_CANVAS_ADDR + i
					, spec2canvas(&buffer_spec[i]));
			}
		}
		} else {
			fatal_error_flag =
					DECODER_FATAL_ERROR_NO_MEM;
			vh264_running = 0;
			mutex_unlock(&vh264_mutex);
			pr_err("never be here!!\n");
			return;
		}

	timing_info_present_flag = seq_info & 0x2;
	fixed_frame_rate_flag = 0;
	aspect_ratio_info_present_flag = seq_info & 0x1;
	aspect_ratio_idc = (seq_info >> 16) & 0xff;

	if (timing_info_present_flag) {
		fixed_frame_rate_flag = seq_info & 0x40;

		if (((num_units_in_tick * 120) >= time_scale
			 && ((!sync_outside) || (!frame_dur))) &&
				num_units_in_tick
			&& time_scale) {
			if (use_idr_framerate || !frame_dur
				|| !duration_from_pts_done || vh264_running) {
				u32 frame_dur_es =
					div_u64(96000ULL * 2 *
							num_units_in_tick,
							time_scale);

				/* hack to avoid use ES frame duration
				 *   when it's half of the rate from
				 *  system info
				 */
				/* sometimes the encoder is given a wrong
				 * frame rate but the system side information
				 *is more reliable
				 */
				if ((frame_dur * 2) != frame_dur_es) {
					frame_dur = frame_dur_es;
					if (fr_hint_status == VDEC_NEED_HINT) {
						schedule_work(&notify_work);
						fr_hint_status = VDEC_HINTED;
					}
				}
			}
		}
	} else
		pr_info("H.264: timing_info not present\n");

	if (aspect_ratio_info_present_flag) {
		if (aspect_ratio_idc == EXTEND_SAR) {
			h264_ar =
				div_u64(256ULL * (aspect_ratio_info >> 16) *
						frame_height,
						(aspect_ratio_info & 0xffff) *
						frame_width);
		} else {
			/* pr_info("v264dec: aspect_ratio_idc = %d\n",
			 *  aspect_ratio_idc);
			 */

			switch (aspect_ratio_idc) {
			case 1:
				h264_ar = 0x100 * frame_height / frame_width;
				break;
			case 2:
				h264_ar = 0x100 * frame_height * 11 /
					(frame_width * 12);
				break;
			case 3:
				h264_ar = 0x100 * frame_height * 11 /
					(frame_width * 10);
				break;
			case 4:
				h264_ar = 0x100 * frame_height * 11 /
					(frame_width * 16);
				break;
			case 5:
				h264_ar = 0x100 * frame_height * 33 /
					(frame_width * 40);
				break;
			case 6:
				h264_ar = 0x100 * frame_height * 11 /
					(frame_width * 24);
				break;
			case 7:
				h264_ar = 0x100 * frame_height * 11 /
					(frame_width * 20);
				break;
			case 8:
				h264_ar = 0x100 * frame_height * 11 /
					(frame_width * 32);
				break;
			case 9:
				h264_ar = 0x100 * frame_height * 33 /
					(frame_width * 80);
				break;
			case 10:
				h264_ar = 0x100 * frame_height * 11 /
					(frame_width * 18);
				break;
			case 11:
				h264_ar = 0x100 * frame_height * 11 /
					(frame_width * 15);
				break;
			case 12:
				h264_ar = 0x100 * frame_height * 33 /
					(frame_width * 64);
				break;
			case 13:
				h264_ar = 0x100 * frame_height * 99 /
					(frame_width * 160);
				break;
			case 14:
				h264_ar = 0x100 * frame_height * 3 /
					(frame_width * 4);
				break;
			case 15:
				h264_ar = 0x100 * frame_height * 2 /
					(frame_width * 3);
				break;
			case 16:
				h264_ar = 0x100 * frame_height * 1 /
					(frame_width * 2);
				break;
			default:
				if (vh264_ratio >> 16) {
					h264_ar = (frame_height *
							(vh264_ratio & 0xffff) *
							0x100 +
							((vh264_ratio >> 16) *
							 frame_width / 2)) /
						((vh264_ratio >> 16) *
						 frame_width);
				} else {
					h264_ar = frame_height * 0x100 /
						frame_width;
				}
				break;
			}
		}
	} else {
		pr_info("v264dec: aspect_ratio not available from source\n");
		if (vh264_ratio >> 16) {
			/* high 16 bit is width, low 16 bit is height */
			h264_ar =
				((vh264_ratio & 0xffff) * frame_height * 0x100 +
				 (vh264_ratio >> 16) * frame_width / 2) /
				((vh264_ratio >> 16) * frame_width);
		} else
			h264_ar = frame_height * 0x100 / frame_width;
	}

	WRITE_VREG(AV_SCRATCH_0,
			(max_reference_size << 24) | (actual_dpb_size << 16) |
			(max_dpb_size << 8));
	if (vh264_stream_switching_state != SWITCHING_STATE_OFF) {
		vh264_stream_switching_state = SWITCHING_STATE_OFF;
		pr_info("Leaving switching mode.\n");
	}
	mutex_unlock(&vh264_mutex);
}

static unsigned int pts_inc_by_duration(
		unsigned int *new_pts, unsigned int *new_pts_rem)
{
	unsigned int r, rem;

	r = last_pts + DUR2PTS(frame_dur);
	rem = last_pts_remainder + DUR2PTS_REM(frame_dur);

	if (rem >= 96) {
		r++;
		rem -= 96;
	}

	if (new_pts)
		*new_pts = r;
	if (new_pts_rem)
		*new_pts_rem = rem;

	return r;
}
static inline bool vh264_isr_parser(struct vframe_s *vf,
		unsigned int  pts_valid, unsigned int buffer_index,
		unsigned int pts)
{
	unsigned int pts_duration = 0;

	if (h264_first_pts_ready == 0) {
		if (pts_valid == 0) {
			vfbuf_use[buffer_index]++;
			vf->index = buffer_index;
			kfifo_put(&recycle_q,
					(const struct vframe_s *)vf);
			return false;
		}

		h264pts1 = pts;
		h264_pts_count = 0;
		h264_first_pts_ready = 1;
	} else {
		if (pts < h264pts1) {
			if (h264_pts_count > 24) {
				pr_info("invalid h264pts1, reset\n");
				h264pts1 = pts;
				h264_pts_count = 0;
			}
		}
		if (pts_valid && (pts > h264pts1) && (h264_pts_count > 24)
				&& (duration_from_pts_done == 0)) {
			unsigned int
				old_duration = frame_dur;
			h264pts2 = pts;

			pts_duration = (h264pts2 - h264pts1) * 16 /
				(h264_pts_count * 15);

			if ((pts_duration != frame_dur)
					&& (!pts_outside)) {
				if (use_idr_framerate) {
					bool pts_c_24 = close_to(pts_duration,
						RATE_24_FPS,
						RATE_CORRECTION_THRESHOLD);
					bool frm_c_25 = close_to(frame_dur,
						RATE_25_FPS,
						RATE_CORRECTION_THRESHOLD);
					bool pts_c_25 = close_to(pts_duration,
						  RATE_25_FPS,
						  RATE_CORRECTION_THRESHOLD);
					bool frm_c_24 = close_to(frame_dur,
						  RATE_24_FPS,
						  RATE_CORRECTION_THRESHOLD);
					if ((pts_c_24 && frm_c_25)
						|| (pts_c_25 && frm_c_24)) {
						pr_info
						("H.264:Correct frame dur ");
						pr_info
						(" from %d to duration based ",
							 frame_dur);
						pr_info
						("on PTS %d ---\n",
							 pts_duration);
						frame_dur = pts_duration;
						duration_from_pts_done = 1;
					} else if (((frame_dur < 96000 / 240)
						&& (pts_duration > 96000 / 240))
						|| (!duration_on_correcting &&
						!frm_c_25 && !frm_c_24)) {
						/* fft: if the frame rate is
						 *  not regular, use the
						 * calculate rate insteadof.
						 */
						pr_info
						("H.264:Correct frame dur ");
						pr_info
						(" from %d to duration based ",
							 frame_dur);
						pr_info
						("on PTS %d ---\n",
							 pts_duration);
						frame_dur = pts_duration;
						duration_on_correcting = 1;
					}
				} else {
					if (close_to(pts_duration,
							frame_dur, 2000)) {
						frame_dur = pts_duration;
						pr_info
						("used calculate frame rate,");
						pr_info("on duration =%d\n",
							 frame_dur);
					} else {
						pr_info
						("don't use calculate frame ");
						pr_info
						("rate pts_duration =%d\n",
							 pts_duration);
					}
				}
			}

			if (duration_from_pts_done == 0) {
				if (close_to
						(pts_duration,
						 old_duration,
						 RATE_CORRECTION_THRESHOLD)) {
					pr_info
					("finished correct frame dur");
					pr_info
					(" new=%d,old_duration=%d,cnt=%d\n",
						 pts_duration,
						 old_duration,
						 h264_pts_count);
					duration_from_pts_done = 1;
				} else {	/*not the same,redo it. */
					if (!close_to(pts_duration,
						 old_duration, 1000) &&
						!close_to(pts_duration,
						frame_dur, 1000) &&
						close_to(pts_duration,
						last_duration, 200)) {
						/* yangle: frame_dur must
						 *  wrong,recover it.
						 */
						frame_dur = pts_duration;
					}

					pr_info
					("restart correct frame duration ");
					pr_info
					("new=%d,old_duration=%d,cnt=%d\n",
						 pts_duration,
						 old_duration,
						 h264_pts_count);
					h264pts1 = h264pts2;
					h264_pts_count = 0;
					duration_from_pts_done = 0;
			}
		}
		    last_duration = pts_duration;
		}
	}
	return true;
}

static inline void h264_update_gvs(void)
{
	u32 ratio_control;
	u32 ar;

	if (gvs->frame_height != frame_height) {
		gvs->frame_width = frame_width;
		gvs->frame_height = frame_height;
	}
	if (gvs->frame_dur != frame_dur) {
		gvs->frame_dur = frame_dur;
		if (frame_dur != 0)
			gvs->frame_rate = 96000 / frame_dur;
		else
			gvs->frame_rate = -1;
	}
	gvs->error_count = READ_VREG(AV_SCRATCH_D);
	gvs->status = stat;
	if (fatal_error_reset)
		gvs->status |= fatal_error_flag;
	ar = min_t(u32,
			h264_ar,
			DISP_RATIO_ASPECT_RATIO_MAX);
	ratio_control =
		ar << DISP_RATIO_ASPECT_RATIO_BIT;
	gvs->ratio_control = ratio_control;
}


#ifdef HANDLE_H264_IRQ
static irqreturn_t vh264_isr(int irq, void *dev_id)
#else
static void vh264_isr(void)
#endif
{
	unsigned int buffer_index;
	struct vframe_s *vf;
	unsigned int cpu_cmd;
	unsigned int pts, pts_lookup_save, pts_valid_save, pts_valid = 0;
	unsigned int pts_us64_valid = 0;
	unsigned int  framesize;
	u64 pts_us64;
	bool force_interlaced_frame = false;
	unsigned int sei_itu35_flags;

	static const unsigned int idr_num =
		FIX_FRAME_RATE_CHECK_IDRFRAME_NUM;
	static const unsigned int flg_1080_itl =
		DEC_CONTROL_FLAG_FORCE_2997_1080P_INTERLACE;
	static const unsigned int flg_576_itl =
		DEC_CONTROL_FLAG_FORCE_2500_576P_INTERLACE;

	WRITE_VREG(ASSIST_MBOX1_CLR_REG, 1);

	if (0 == (stat & STAT_VDEC_RUN)) {
		pr_info("decoder is not running\n");
#ifdef HANDLE_H264_IRQ
		return IRQ_HANDLED;
#else
		return;
#endif
	}

	cpu_cmd = READ_VREG(AV_SCRATCH_0);

#ifdef DROP_B_FRAME_FOR_1080P_50_60FPS
	if ((frame_dur < 2004) &&
		(frame_width >= 1400) &&
		(frame_height >= 1000) && (last_interlaced == 0))
		SET_VREG_MASK(AV_SCRATCH_F, 0x8);
#endif
	if ((decoder_force_reset == 1)
			|| ((error_recovery_mode != 1)
			&& (no_idr_error_count >= no_idr_error_max)
			&& (ucode_type != UCODE_IP_ONLY_PARAM))) {
		vh264_running = 0;
		pr_info("force reset decoder  %d!!!\n", no_idr_error_count);
		schedule_work(&error_wd_work);
		decoder_force_reset = 0;
		no_idr_error_count = 0;
	} else if ((cpu_cmd & 0xff) == 1) {
		if (unlikely
			(vh264_running
			 && (kfifo_len(&newframe_q) != VF_POOL_SIZE))) {
			/* a cmd 1 sent during decoding w/o getting a cmd 3. */
			/* should not happen but the original code has such
			 *  case, do the same process
			 */
			if ((READ_VREG(AV_SCRATCH_1) & 0xff)
				== 1) {/*invalid mb_width*/
				vh264_running = 0;
				fatal_error_flag = DECODER_FATAL_ERROR_UNKNOWN;
			/* this is fatal error, need restart */
				pr_info("cmd 1 fatal error happened\n");
				schedule_work(&error_wd_work);
			} else {
			vh264_stream_switching_state = SWITCHING_STATE_ON_CMD1;
			pr_info("Enter switching mode cmd1.\n");
			schedule_work(&stream_switching_work);
			}
			return IRQ_HANDLED;
		}
		pr_info("Enter set parameter cmd1.\n");
		schedule_work(&set_parameter_work);
		return IRQ_HANDLED;
	} else if ((cpu_cmd & 0xff) == 2) {
		int frame_mb_only, pic_struct_present, pic_struct, prog_frame,
			poc_sel, idr_flag, eos, error;
		int i, status, num_frame, b_offset;
		int current_error_count, slice_type;

		vh264_running = 1;
		vh264_no_disp_count = 0;
		num_frame = (cpu_cmd >> 8) & 0xff;
		frame_mb_only = seq_info & 0x8000;
		pic_struct_present = seq_info & 0x10;

		current_error_count = READ_VREG(AV_SCRATCH_D);
		if (vh264_error_count != current_error_count) {
			/* pr_info("decoder error happened, count %d\n",
			 *   current_error_count);
			 */
			vh264_error_count = current_error_count;
		}

		for (i = 0; (i < num_frame) && (!vh264_eos); i++) {
			status = READ_VREG(AV_SCRATCH_1 + i);
			buffer_index = status & 0x1f;
			error = status & 0x200;
			slice_type = (READ_VREG(AV_SCRATCH_H) >> (i * 4)) & 0xf;

			if ((error_recovery_mode_use & 2) && error)
				check_pts_discontinue = true;
			if (ucode_type == UCODE_IP_ONLY_PARAM
				&& iponly_early_mode)
				continue;
			if ((p_last_vf != NULL)
				&& (p_last_vf->index == buffer_index))
				continue;

			if (buffer_index >= VF_BUF_NUM)
				continue;

			pic_struct = (status >> 5) & 0x7;
			prog_frame = status & 0x100;
			poc_sel = status & 0x200;
			idr_flag = status & 0x400;
			frame_packing_type = (status >> 12) & 0x7;
			eos = (status >> 15) & 1;

			if (eos)
				vh264_eos = 1;

			b_offset = (status >> 16) & 0xffff;

			if (error)
				no_idr_error_count++;
			if (idr_flag ||
				(!error && (slice_type != SLICE_TYPE_I)))
				no_idr_error_count = 0;

			if (decoder_debug_flag) {
				pr_info
				("slice_type %x idr %x error %x count %d",
					slice_type, idr_flag, error,
					no_idr_error_count);
				pr_info(" prog %x pic_struct %x offset %x\n",
				prog_frame, pic_struct,	b_offset);
			}
#ifdef DROP_B_FRAME_FOR_1080P_50_60FPS
			last_interlaced = prog_frame ? 0 : 1;
#endif
			if (kfifo_get(&newframe_q, &vf) == 0) {
				pr_info
				("fatal error, no available buffer slot.");
				return IRQ_HANDLED;
			}

			if (clk_adj_frame_count < (VDEC_CLOCK_ADJUST_FRAME + 1))
				clk_adj_frame_count++;

			set_frame_info(vf);

			switch (i) {
			case 0:
				b_offset |=
					(READ_VREG(AV_SCRATCH_A) & 0xffff)
					<< 16;
				break;
			case 1:
				b_offset |=
					READ_VREG(AV_SCRATCH_A) & 0xffff0000;
				break;
			case 2:
				b_offset |=
					(READ_VREG(AV_SCRATCH_B) & 0xffff)
					<< 16;
				break;
			case 3:
				b_offset |=
					READ_VREG(AV_SCRATCH_B) & 0xffff0000;
				break;
			case 4:
				b_offset |=
					(READ_VREG(AV_SCRATCH_C) & 0xffff)
					<< 16;
				break;
			case 5:
				b_offset |=
					READ_VREG(AV_SCRATCH_C) & 0xffff0000;
				break;
			default:
				break;
			}

			if (error)
				gvs->drop_frame_count++;

			/* add 64bit pts us ; */
			if (unlikely
				((b_offset == first_offset)
				 && (first_pts_cached))) {
				pts = first_pts;
				pts_us64 = first_pts64;
				framesize = first_frame_size;
				first_pts_cached = false;
				pts_valid = 1;
				pts_us64_valid = 1;
#ifdef DEBUG_PTS
				pts_hit++;
#endif
			} else if (pts_lookup_offset_us64
					(PTS_TYPE_VIDEO, b_offset, &pts,
					&framesize, 0, &pts_us64) == 0) {
				pts_valid = 1;
				pts_us64_valid = 1;
#ifdef DEBUG_PTS
				pts_hit++;
#endif
			} else {
				pts_valid = 0;
				pts_us64_valid = 0;
				framesize = 0;
#ifdef DEBUG_PTS
				pts_missed++;
#endif
			}

			if (idr_flag)
				s_vframe_qos.type = 4;
			else if (slice_type == SLICE_TYPE_I)
				s_vframe_qos.type = 1;
			else if (slice_type == SLICE_TYPE_P)
				s_vframe_qos.type = 2;
			else if (slice_type == SLICE_TYPE_B || slice_type == 8)
				s_vframe_qos.type = 3;

			s_vframe_qos.size = framesize;

			if (pts_valid)
				s_vframe_qos.pts = pts;
			else
				s_vframe_qos.pts = last_pts + DUR2PTS(frame_dur);
#ifndef ENABLE_SEI_ITU_T35
			if (get_cpu_major_id() < AM_MESON_CPU_MAJOR_ID_G12A) {
				u32 reg_data;
				if (i) {
					reg_data = READ_VREG(AV_SCRATCH_N);
					s_vframe_qos.max_mv
						= (reg_data >> 16) & 0xffff;
					s_vframe_qos.avg_mv
						= (reg_data >> 8) & 0xff;
					s_vframe_qos.min_mv
						=  reg_data & 0xff;
					reg_data = READ_VREG(AV_SCRATCH_L);
					s_vframe_qos.max_qp
						= (reg_data >> 16) & 0xff;
					s_vframe_qos.avg_qp
						= (reg_data >> 8) & 0xff;
					s_vframe_qos.min_qp
						=  reg_data & 0xff;
					reg_data = READ_VREG(AV_SCRATCH_M);
					s_vframe_qos.max_skip
						= (reg_data >> 16) & 0xff;
					s_vframe_qos.avg_skip
						= (reg_data >> 8) & 0xff;
					s_vframe_qos.min_skip
						=  reg_data & 0xff;
				} else {
					reg_data = READ_VREG(AV_SCRATCH_J);
					s_vframe_qos.max_mv
						= (reg_data >> 16) & 0xffff;
					s_vframe_qos.avg_mv
						= (reg_data >> 8) & 0xff;
					s_vframe_qos.min_mv
						=  reg_data & 0xff;
					reg_data = READ_VREG(AV_SCRATCH_I);
					s_vframe_qos.max_qp
						= (reg_data >> 16) & 0xff;
					s_vframe_qos.avg_qp
						= (reg_data >> 8) & 0xff;
					s_vframe_qos.min_qp
						=  reg_data & 0xff;
					reg_data = READ_VREG(AV_SCRATCH_K);
					s_vframe_qos.max_skip
						= (reg_data >> 16) & 0xff;
					s_vframe_qos.avg_skip
						= (reg_data >> 8) & 0xff;
					s_vframe_qos.min_skip
						=  reg_data & 0xff;
				}
				if (decoder_debug_flag&0x2) {
					pr_info("max_mv %d    avg_mv %d  min_mv %d slice_type %d offset %x   i =  %d\n",
						s_vframe_qos.max_mv,
						s_vframe_qos.avg_mv,
						s_vframe_qos.min_mv,
						slice_type,
						b_offset,
						i);
					pr_info("max_qp %d    avg_qp %d  min_qp %d\n",
						s_vframe_qos.max_qp,
						s_vframe_qos.avg_qp,
						s_vframe_qos.min_qp);
					pr_info("max_skip %d  avg_skip %d  min_skip %d\n",
						s_vframe_qos.max_skip,
						s_vframe_qos.avg_skip,
						s_vframe_qos.min_skip);
				}
			} else
				search_qos_node(&s_vframe_qos, b_offset);
#endif
			frame_count++;

			s_vframe_qos.num = frame_count;
			//vdec_fill_frame_info(&s_vframe_qos, 1);

			/* on second IDR frame,check the diff between pts
			 *  compute from duration and pts from lookup ,
			 * if large than frame_dur,we think it is uncorrect.
			 */
			pts_lookup_save = pts;
			pts_valid_save = pts_valid;
			if (fixed_frame_rate_flag
				&& (fixed_frame_rate_check_count <=
					idr_num)) {
				if (idr_flag && pts_valid) {
					fixed_frame_rate_check_count++;
					/* pr_info("diff:%d\n",
					 *   last_pts - pts_lookup_save);
					 */
					if ((fixed_frame_rate_check_count ==
						idr_num) &&
						(abs(pts - (last_pts +
							 DUR2PTS(frame_dur))) >
							 DUR2PTS(frame_dur))) {
						fixed_frame_rate_flag = 0;
						pr_info("pts sync mode play\n");
					}

					if (fixed_frame_rate_flag
						&& (fixed_frame_rate_check_count
							> idr_num)) {
						pr_info
						("fix_frame_rate mode play\n");
					}
				}
			}

			if (READ_VREG(AV_SCRATCH_F) & 2) {
				/* for I only mode, ignore the PTS information
				 *   and only uses frame duration for each I
				 *  frame decoded
				 */
				if (p_last_vf)
					pts_valid = 0;
				/* also skip frame duration calculation
				 *  based on PTS
				 */
				duration_from_pts_done = 1;
				/* and add a default duration for 1/30 second
				 *  if there is no valid frame
				 * duration available
				 */
				if (frame_dur == 0)
					frame_dur = 96000 / 30;
			}

			if (sync_outside == 0) {
				if (!vh264_isr_parser(vf,
						pts_valid, buffer_index, pts))
					continue;

				h264_pts_count++;
			} else {
				if (!idr_flag)
					pts_valid = 0;
			}

			if (pts_valid && !pts_discontinue) {
				pts_discontinue =
					(abs(last_pts - pts) >=
					 tsync_vpts_discontinuity_margin());
			}
			/* if use_idr_framerate or fixed frame rate, only
			 *  use PTS for IDR frames except for pts discontinue
			 */
			if (timing_info_present_flag &&
				frame_dur &&
				(use_idr_framerate ||
				 (fixed_frame_rate_flag != 0))
				&& pts_valid && h264_first_valid_pts_ready
				&& (!pts_discontinue)) {
				pts_valid =
					(slice_type == SLICE_TYPE_I) ? 1 : 0;
			}

			if (!h264_first_valid_pts_ready && pts_valid) {
				h264_first_valid_pts_ready = true;
				last_pts = pts - DUR2PTS(frame_dur);
				last_pts_remainder = 0;
			}
			/* calculate PTS of next frame and smooth
			 *  PTS for fixed rate source
			 */
			if (pts_valid) {
				if ((fixed_frame_rate_flag) &&
					(!pts_discontinue) &&
					(abs(pts_inc_by_duration(NULL, NULL)
					     - pts)
					 < DUR2PTS(frame_dur))) {
					pts = pts_inc_by_duration(&pts,
							&last_pts_remainder);
				} else
					last_pts_remainder = 0;

			} else {
				if (fixed_frame_rate_flag && !pts_discontinue &&
				(fixed_frame_rate_check_count > idr_num) &&
				pts_valid_save && (sync_outside == 0) &&
				(abs(pts_inc_by_duration(NULL, NULL) - pts)
				 > DUR2PTS(frame_dur))) {
					duration_from_pts_done = 0;
					pr_info("recalc frame_dur\n");
				} else
					pts = pts_inc_by_duration(&pts,
						&last_pts_remainder);
				pts_valid = 1;
			}

			if ((dec_control &
				 flg_1080_itl)
				&& (frame_width == 1920)
				&& (frame_height >= 1080)
				&& (vf->duration == 3203))
				force_interlaced_frame = true;
			else if ((dec_control &
					  flg_576_itl)
					 && (frame_width == 720)
					 && (frame_height == 576)
					 && (vf->duration == 3840))
				force_interlaced_frame = true;

			/* for frames with PTS, check if there is PTS
			 *  discontinue based on previous frames
			 * (including error frames),
			 * force no VPTS discontinue reporting if we saw
			 *errors earlier but only once.
			 */

			/*count info*/
			h264_update_gvs();
			vdec_count_info(gvs, error, b_offset);
			vdec_fill_vdec_frame(vdec_h264, &s_vframe_qos, gvs, vf, 0);

			if ((pts_valid) && (check_pts_discontinue)
					&& (!error)) {
				if (pts_discontinue) {
					vf->flag = 0;
					check_pts_discontinue = false;
				} else if ((pts - last_pts) < 90000) {
					vf->flag = VFRAME_FLAG_NO_DISCONTINUE;
					check_pts_discontinue = false;
				}
			}

			last_pts = pts;

			if (fixed_frame_rate_flag
				&& (fixed_frame_rate_check_count <=
					idr_num)
				&& (sync_outside == 0)
				&& pts_valid_save)
				pts = pts_lookup_save;

			if (pic_struct_present) {
				if ((pic_struct == PIC_TOP_BOT)
					|| (pic_struct == PIC_BOT_TOP))
					prog_frame = 0;
			}

			if ((!force_interlaced_frame)
				&& (prog_frame
					|| (pic_struct_present
						&& pic_struct
						<= PIC_TRIPLE_FRAME))) {
				if (pic_struct_present) {
					if (pic_struct == PIC_TOP_BOT_TOP
						|| pic_struct
						== PIC_BOT_TOP_BOT) {
						vf->duration +=
							vf->duration >> 1;
					} else if (pic_struct ==
							   PIC_DOUBLE_FRAME)
						vf->duration += vf->duration;
					else if (pic_struct ==
							 PIC_TRIPLE_FRAME) {
						vf->duration +=
							vf->duration << 1;
					}
				}

				last_pts =
					last_pts + DUR2PTS(vf->duration -
							frame_dur);

				vf->index = buffer_index;
				vf->type =
					VIDTYPE_PROGRESSIVE |
					VIDTYPE_VIU_FIELD |
					VIDTYPE_VIU_NV21;
				vf->duration_pulldown = 0;
				vf->signal_type = video_signal_from_vui;
				vf->index = buffer_index;
				vf->pts = (pts_valid) ? pts : 0;
				if (pts_us64_valid == 1)
					vf->pts_us64 = pts_us64;
				else
				vf->pts_us64 = div64_u64(((u64)vf->pts)*100, 9);
				vf->canvas0Addr = vf->canvas1Addr =
					spec2canvas(&buffer_spec[buffer_index]);
				vf->type_original = vf->type;
				vfbuf_use[buffer_index]++;
				vf->mem_handle =
					decoder_bmmu_box_get_mem_handle(
						mm_blk_handle,
						VF_BUFFER_IDX(buffer_index));
				decoder_do_frame_check(NULL, vf);
				if ((error_recovery_mode_use & 2) && error) {
					kfifo_put(&recycle_q,
						(const struct vframe_s *)vf);
				} else {
					p_last_vf = vf;
					pts_discontinue = false;
					kfifo_put(&delay_display_q,
						  (const struct vframe_s *)vf);
				}
			} else {
				if (pic_struct_present
					&& pic_struct == PIC_TOP_BOT)
					vf->type = VIDTYPE_INTERLACE_TOP;
				else if (pic_struct_present
						 && pic_struct == PIC_BOT_TOP)
					vf->type = VIDTYPE_INTERLACE_BOTTOM;
				else {
					vf->type =
						poc_sel ?
						VIDTYPE_INTERLACE_BOTTOM :
						VIDTYPE_INTERLACE_TOP;
				}
				vf->type |= VIDTYPE_VIU_NV21;
				vf->type |= VIDTYPE_INTERLACE_FIRST;

				high_bandwidth |=
				((codec_mm_get_total_size() < 80 * SZ_1M)
				& ((READ_VREG(AV_SCRATCH_N) & 0xf) == 3)
				& ((frame_width * frame_height) >= 1920*1080));
				if (high_bandwidth)
					vf->flag |= VFRAME_FLAG_HIGH_BANDWIDTH;

				vf->duration >>= 1;
				vf->duration_pulldown = 0;
				vf->signal_type = video_signal_from_vui;
				vf->index = buffer_index;
				vf->pts = (pts_valid) ? pts : 0;
				if (pts_us64_valid == 1)
					vf->pts_us64 = pts_us64;
				else
				vf->pts_us64 = div64_u64(((u64)vf->pts)*100, 9);
				vf->canvas0Addr = vf->canvas1Addr =
					spec2canvas(&buffer_spec[buffer_index]);
				vf->type_original = vf->type;
				vfbuf_use[buffer_index]++;
				vf->ready_jiffies64 = jiffies_64;
				vf->mem_handle =
					decoder_bmmu_box_get_mem_handle(
						mm_blk_handle,
						VF_BUFFER_IDX(buffer_index));
				decoder_do_frame_check(NULL, vf);
				if ((error_recovery_mode_use & 2) && error) {
					kfifo_put(&recycle_q,
						(const struct vframe_s *)vf);
					continue;
				} else {
					pts_discontinue = false;
					kfifo_put(&delay_display_q,
						(const struct vframe_s *)vf);
				}

				if (READ_VREG(AV_SCRATCH_F) & 2)
					continue;

				if (kfifo_get(&newframe_q, &vf) == 0) {
					pr_info
					("fatal error, no avail buffer slot.");
					return IRQ_HANDLED;
				}

				set_frame_info(vf);

				if (pic_struct_present
					&& pic_struct == PIC_TOP_BOT)
					vf->type = VIDTYPE_INTERLACE_BOTTOM;
				else if (pic_struct_present
						 && pic_struct == PIC_BOT_TOP)
					vf->type = VIDTYPE_INTERLACE_TOP;
				else {
					vf->type =
						poc_sel ?
						VIDTYPE_INTERLACE_TOP :
						VIDTYPE_INTERLACE_BOTTOM;
				}

				vf->type |= VIDTYPE_VIU_NV21;
				vf->duration >>= 1;
				vf->duration_pulldown = 0;
				vf->signal_type = video_signal_from_vui;
				vf->index = buffer_index;
				vf->pts = 0;
				vf->pts_us64 = 0;
				vf->canvas0Addr = vf->canvas1Addr =
					spec2canvas(&buffer_spec[buffer_index]);
				vf->type_original = vf->type;
				vfbuf_use[buffer_index]++;
				if (high_bandwidth)
					vf->flag |= VFRAME_FLAG_HIGH_BANDWIDTH;

				p_last_vf = vf;
				vf->ready_jiffies64 = jiffies_64;
				vf->mem_handle =
					decoder_bmmu_box_get_mem_handle(
						mm_blk_handle,
						VF_BUFFER_IDX(buffer_index));
				kfifo_put(&delay_display_q,
						(const struct vframe_s *)vf);
			}
		}

		WRITE_VREG(AV_SCRATCH_0, 0);
	} else if ((cpu_cmd & 0xff) == 3) {
		vh264_running = 1;
		vh264_stream_switching_state = SWITCHING_STATE_ON_CMD3;

		pr_info("Enter switching mode cmd3.\n");
		schedule_work(&stream_switching_work);

	} else if ((cpu_cmd & 0xff) == 4) {
		vh264_running = 1;
		/* reserved for slice group */
		WRITE_VREG(AV_SCRATCH_0, 0);
	} else if ((cpu_cmd & 0xff) == 5) {
		vh264_running = 1;
		/* reserved for slice group */
		WRITE_VREG(AV_SCRATCH_0, 0);
	} else if ((cpu_cmd & 0xff) == 6) {
		vh264_running = 0;
		fatal_error_flag = DECODER_FATAL_ERROR_UNKNOWN;
		/* this is fatal error, need restart */
		pr_info("fatal error happend\n");
		amvdec_stop();
		if (!fatal_error_reset)
			schedule_work(&error_wd_work);
	} else if ((cpu_cmd & 0xff) == 7) {
		vh264_running = 0;
		frame_width = (READ_VREG(AV_SCRATCH_1) + 1) * 16;
		pr_info("Over decoder supported size, width = %d\n",
			   frame_width);
		fatal_error_flag = DECODER_FATAL_ERROR_SIZE_OVERFLOW;
	} else if ((cpu_cmd & 0xff) == 8) {
		vh264_running = 0;
		frame_height = (READ_VREG(AV_SCRATCH_1) + 1) * 16;
		pr_info("Over decoder supported size, height = %d\n",
			   frame_height);
		fatal_error_flag = DECODER_FATAL_ERROR_SIZE_OVERFLOW;
	} else if ((cpu_cmd & 0xff) == 9) {
		first_offset = READ_VREG(AV_SCRATCH_1);
		if (pts_lookup_offset_us64
			(PTS_TYPE_VIDEO, first_offset, &first_pts,
			&first_frame_size, 0,
			 &first_pts64) == 0)
			first_pts_cached = true;
		WRITE_VREG(AV_SCRATCH_0, 0);
	} else if ((cpu_cmd & 0xff) == 0xa) {
		int b_offset;
		unsigned int frame_size;

		b_offset = READ_VREG(AV_SCRATCH_2);
		buffer_index = READ_VREG(AV_SCRATCH_1);
		/*pr_info("iponly output %d  b_offset %x\n",
		 *	buffer_index,b_offset);
		 */
		if (kfifo_get(&newframe_q, &vf) == 0) {
			WRITE_VREG(AV_SCRATCH_0, 0);
			pr_info
			("fatal error, no available buffer slot.");
			return IRQ_HANDLED;
		}
		if (pts_lookup_offset_us64 (PTS_TYPE_VIDEO, b_offset,
				&pts, &frame_size,
				0, &pts_us64) != 0)
			vf->pts_us64 = vf->pts = 0;
		else {
			vf->pts_us64 = pts_us64;
			vf->pts = pts;
		}
		set_frame_info(vf);
		vf->type = VIDTYPE_PROGRESSIVE |
				VIDTYPE_VIU_FIELD |
				VIDTYPE_VIU_NV21;
		vf->duration_pulldown = 0;
		vf->signal_type = video_signal_from_vui;
		vf->index = buffer_index;
		vf->canvas0Addr = vf->canvas1Addr =
				spec2canvas(&buffer_spec[buffer_index]);
		vf->type_original = vf->type;
		vf->mem_handle = decoder_bmmu_box_get_mem_handle(
			mm_blk_handle,
					VF_BUFFER_IDX(buffer_index));
		vfbuf_use[buffer_index]++;
		p_last_vf = vf;
		pts_discontinue = false;
		iponly_early_mode = 1;
		decoder_do_frame_check(NULL, vf);
		kfifo_put(&delay_display_q,
			(const struct vframe_s *)vf);
		WRITE_VREG(AV_SCRATCH_0, 0);
	} else if ((cpu_cmd & 0xff) == 0xB) {
		schedule_work(&qos_work);
	}

	sei_itu35_flags = READ_VREG(AV_SCRATCH_J);
	if (sei_itu35_flags & (1 << 15)) {	/* data ready */
#ifdef ENABLE_SEI_ITU_T35
		schedule_work(&userdata_push_work);
#else
		/* necessary if enabled itu_t35 in ucode*/
		WRITE_VREG(AV_SCRATCH_J, 0);
#endif
	}

#ifdef HANDLE_H264_IRQ
	return IRQ_HANDLED;
#else
	return;
#endif
}

static void vh264_set_clk(struct work_struct *work)
{
		int fps = 96000 / frame_dur;

		if (frame_dur < 10) /*dur is too small ,think it errors fps*/
			fps = 60;
		saved_resolution = frame_width * frame_height * fps;
		vdec_source_changed(VFORMAT_H264,
			frame_width, frame_height, fps);
}

static void vh264_put_timer_func(unsigned long arg)
{
	struct timer_list *timer = (struct timer_list *)arg;
	unsigned int wait_buffer_status;
	unsigned int wait_i_pass_frames;
	unsigned int reg_val;

	enum receviver_start_e state = RECEIVER_INACTIVE;

	if (vh264_reset) {
		pr_info("operation forbidden in timer !\n");
		goto exit;
	}

	prepare_display_q();

	if (vf_get_receiver(PROVIDER_NAME)) {
		state =
			vf_notify_receiver(PROVIDER_NAME,
					VFRAME_EVENT_PROVIDER_QUREY_STATE,
					NULL);
		if ((state == RECEIVER_STATE_NULL)
			|| (state == RECEIVER_STATE_NONE)) {
			/* receiver has no event_cb or receiver's
			 *  event_cb does not process this event
			 */
			state = RECEIVER_INACTIVE;
		}
	} else
		state = RECEIVER_INACTIVE;
#ifndef HANDLE_H264_IRQ
	vh264_isr();
#endif

	if (vh264_stream_switching_state != SWITCHING_STATE_OFF)
		wait_buffer_counter = 0;
	else {
		reg_val = READ_VREG(AV_SCRATCH_9);
		wait_buffer_status = reg_val & (1 << 31);
		wait_i_pass_frames = reg_val & 0xff;
		if (wait_buffer_status) {
			if (kfifo_is_empty(&display_q) &&
				kfifo_is_empty(&delay_display_q) &&
				kfifo_is_empty(&recycle_q) &&
				(state == RECEIVER_INACTIVE)) {
				pr_info("$$$$decoder is waiting for buffer\n");
				if (++wait_buffer_counter > 4) {
					amvdec_stop();
					schedule_work(&error_wd_work);
				}
			} else
				wait_buffer_counter = 0;
		} else if (wait_i_pass_frames > 1000) {
			pr_info("i passed frames > 1000\n");
			amvdec_stop();
			schedule_work(&error_wd_work);
		}
	}

#if 0
	if (!wait_buffer_status) {
		if (vh264_no_disp_count++ > NO_DISP_WD_COUNT) {
			pr_info("$$$decoder did not send frame out\n");
			amvdec_stop();
#ifdef CONFIG_AMLOGIC_POST_PROCESS_MANAGER
			vh264_ppmgr_reset();
#else
			vf_light_unreg_provider(PROVIDER_NAME);
			vh264_local_init();
			vf_reg_provider(vh264_vf_prov);
#endif
			vh264_prot_init();
			amvdec_start();

			vh264_no_disp_count = 0;
			vh264_no_disp_wd_count++;
		}
	}
#endif

	while (!kfifo_is_empty(&recycle_q) &&
		   ((READ_VREG(AV_SCRATCH_7) == 0)
			|| (READ_VREG(AV_SCRATCH_8) == 0))
		   && (vh264_stream_switching_state == SWITCHING_STATE_OFF)) {
		struct vframe_s *vf;

		if (kfifo_get(&recycle_q, &vf)) {
			if (vf->index < VF_BUF_NUM) {
				if (--vfbuf_use[vf->index] == 0) {
					if (READ_VREG(AV_SCRATCH_7) == 0) {
						WRITE_VREG(AV_SCRATCH_7,
								vf->index + 1);
					} else {
						WRITE_VREG(AV_SCRATCH_8,
								vf->index + 1);
					}
				}

				vf->index = VF_BUF_NUM;
				kfifo_put(&newframe_q,
						(const struct vframe_s *)vf);
			}
		}
	}

	if (vh264_stream_switching_state != SWITCHING_STATE_OFF) {
		while (!kfifo_is_empty(&recycle_q)) {
			struct vframe_s *vf;

			if (kfifo_get(&recycle_q, &vf)) {
				if (vf->index < VF_BUF_NUM) {
					vf->index = VF_BUF_NUM;
					kfifo_put(&newframe_q,
						(const struct vframe_s *)vf);
				}
			}
		}

		WRITE_VREG(AV_SCRATCH_7, 0);
		WRITE_VREG(AV_SCRATCH_8, 0);

		if (kfifo_len(&newframe_q) == VF_POOL_SIZE)
			stream_switching_done();
	}

	if (ucode_type != UCODE_IP_ONLY_PARAM &&
		(clk_adj_frame_count > VDEC_CLOCK_ADJUST_FRAME) &&
		frame_dur > 0 && saved_resolution !=
		frame_width * frame_height * (96000 / frame_dur))
		schedule_work(&set_clk_work);

exit:
	timer->expires = jiffies + PUT_INTERVAL;

	add_timer(timer);
}

int vh264_dec_status(struct vdec_s *vdec, struct vdec_info *vstatus)
{
	u32 ratio_control;
	u32 ar;

	if (!(stat & STAT_VDEC_RUN))
		return -1;

	vstatus->frame_width = frame_width;
	vstatus->frame_height = frame_height;
	if (frame_dur != 0)
		vstatus->frame_rate = 96000 / frame_dur;
	else
		vstatus->frame_rate = -1;
	vstatus->error_count = READ_VREG(AV_SCRATCH_D);
	vstatus->status = stat;
	if (fatal_error_reset)
		vstatus->status |= fatal_error_flag;
	vstatus->bit_rate = gvs->bit_rate;
	vstatus->frame_dur = frame_dur;
	vstatus->frame_data = gvs->frame_data;
	vstatus->total_data = gvs->total_data;
	vstatus->frame_count = gvs->frame_count;
	vstatus->error_frame_count = gvs->error_frame_count;
	vstatus->drop_frame_count = gvs->drop_frame_count;
	vstatus->total_data = gvs->total_data;
	vstatus->samp_cnt = gvs->samp_cnt;
	vstatus->offset = gvs->offset;
	ar = min_t(u32,
			h264_ar,
			DISP_RATIO_ASPECT_RATIO_MAX);
	ratio_control =
		ar << DISP_RATIO_ASPECT_RATIO_BIT;
	vstatus->ratio_control = ratio_control;

	snprintf(vstatus->vdec_name, sizeof(vstatus->vdec_name),
		"%s", DRIVER_NAME);

	return 0;
}

static int vh264_vdec_info_init(void)
{
	gvs = kzalloc(sizeof(struct vdec_info), GFP_KERNEL);
	if (NULL == gvs) {
		pr_info("the struct of vdec status malloc failed.\n");
		return -ENOMEM;
	}
	return 0;
}

int vh264_set_trickmode(struct vdec_s *vdec, unsigned long trickmode)
{
	if (trickmode == TRICKMODE_I) {
		WRITE_VREG(AV_SCRATCH_F,
				   (READ_VREG(AV_SCRATCH_F) & 0xfffffffc) | 2);
		trickmode_i = 1;
	} else if (trickmode == TRICKMODE_NONE) {
		WRITE_VREG(AV_SCRATCH_F, READ_VREG(AV_SCRATCH_F) & 0xfffffffc);
		trickmode_i = 0;
	}

	return 0;
}

int vh264_set_isreset(struct vdec_s *vdec, int isreset)
{
	is_reset = isreset;
	return 0;
}

static void vh264_prot_init(void)
{
	ulong timeout = jiffies + HZ;

	while (READ_VREG(DCAC_DMA_CTRL) & 0x8000) {
		if (time_after(jiffies, timeout)) {
			pr_info("%s DCAC_DMA_CTRL time out\n", __func__);
			break;
		}
	}

	timeout = jiffies + HZ;
	while (READ_VREG(LMEM_DMA_CTRL) & 0x8000) {
		if (time_after(jiffies, timeout)) {
			pr_info("%s LMEM_DMA_CTRL time out\n", __func__);
			break;
		}
	}

#if 1				/* MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON6 */
	WRITE_VREG(DOS_SW_RESET0, (1 << 7) | (1 << 6) | (1 << 4));
	WRITE_VREG(DOS_SW_RESET0, 0);

	READ_VREG(DOS_SW_RESET0);
	READ_VREG(DOS_SW_RESET0);
	READ_VREG(DOS_SW_RESET0);

	WRITE_VREG(DOS_SW_RESET0, (1 << 7) | (1 << 6) | (1 << 4));
	WRITE_VREG(DOS_SW_RESET0, 0);

	WRITE_VREG(DOS_SW_RESET0, (1 << 9) | (1 << 8));
	WRITE_VREG(DOS_SW_RESET0, 0);

	READ_VREG(DOS_SW_RESET0);
	READ_VREG(DOS_SW_RESET0);
	READ_VREG(DOS_SW_RESET0);

#else
	WRITE_RESET_REG(RESET0_REGISTER,
				   RESET_IQIDCT | RESET_MC | RESET_VLD_PART);
	READ_RESET_REG(RESET0_REGISTER);
	WRITE_RESET_REG(RESET0_REGISTER,
				   RESET_IQIDCT | RESET_MC | RESET_VLD_PART);

	WRITE_RESET_REG(RESET2_REGISTER, RESET_PIC_DC | RESET_DBLK);
#endif

	WRITE_VREG(POWER_CTL_VLD,
			   READ_VREG(POWER_CTL_VLD) |
			   (0 << 10) | (1 << 9) | (1 << 6));

	/* disable PSCALE for hardware sharing */
	WRITE_VREG(PSCALE_CTRL, 0);

	WRITE_VREG(AV_SCRATCH_0, 0);
	WRITE_VREG(AV_SCRATCH_1, buf_offset);
	if (!tee_enabled())
		WRITE_VREG(AV_SCRATCH_G, mc_dma_handle);
	WRITE_VREG(AV_SCRATCH_7, 0);
	WRITE_VREG(AV_SCRATCH_8, 0);
	WRITE_VREG(AV_SCRATCH_9, 0);
	WRITE_VREG(AV_SCRATCH_N, 0);

#ifdef SUPPORT_BAD_MACRO_BLOCK_REDUNDANCY
	if (bad_block_scale > 128)
		bad_block_scale = 128;
	WRITE_VREG(AV_SCRATCH_A, bad_block_scale);
#endif

	error_recovery_mode_use =
		(error_recovery_mode !=
		 0) ? error_recovery_mode : error_recovery_mode_in;
	WRITE_VREG(AV_SCRATCH_F,
			   (READ_VREG(AV_SCRATCH_F) & 0xffffffc3) |
			   (READ_VREG(AV_SCRATCH_F) & 0xffffff43) |
			   ((error_recovery_mode_use & 0x1) << 4));
	if (dec_control & DEC_CONTROL_FLAG_DISABLE_FAST_POC)
		SET_VREG_MASK(AV_SCRATCH_F, 1 << 7);
	/* clear mailbox interrupt */
	WRITE_VREG(ASSIST_MBOX1_CLR_REG, 1);

	/* enable mailbox interrupt */
	WRITE_VREG(ASSIST_MBOX1_MASK, 1);

	SET_VREG_MASK(MDEC_PIC_DC_CTRL, 1 << 17);
	if (ucode_type == UCODE_IP_ONLY_PARAM)
		SET_VREG_MASK(AV_SCRATCH_F, 1 << 6);
	else
		CLEAR_VREG_MASK(AV_SCRATCH_F, 1 << 6);

	WRITE_VREG(AV_SCRATCH_I, (u32)(sei_data_buffer_phys - buf_offset));
	WRITE_VREG(AV_SCRATCH_J, 0);
	/* #if MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON8 */
	if ((get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_M8) && !is_meson_mtvd_cpu()) {
		/* pr_info("vh264 meson8 prot init\n"); */
		WRITE_VREG(MDEC_PIC_DC_THRESH, 0x404038aa);
	}
	/* #endif */
}

static int vh264_local_init(void)
{
	int i, ret;
	u32 size;
	unsigned long buf_start;
	vh264_ratio = vh264_amstream_dec_info.ratio;
	/* vh264_ratio = 0x100; */

	vh264_rotation = (((unsigned long) vh264_amstream_dec_info.param)
				>> 16) & 0xffff;

	frame_prog = 0;
	frame_width = vh264_amstream_dec_info.width;
	frame_height = vh264_amstream_dec_info.height;
	frame_dur = vh264_amstream_dec_info.rate;
	pts_outside = ((unsigned long) vh264_amstream_dec_info.param) & 0x01;
	sync_outside = ((unsigned long) vh264_amstream_dec_info.param & 0x02)
			>> 1;
	use_idr_framerate = ((unsigned long) vh264_amstream_dec_info.param
				& 0x04) >> 2;
	max_refer_buf = !(((unsigned long) vh264_amstream_dec_info.param
				& 0x10) >> 4);
	if (!vh264_reset) {
		if (mm_blk_handle) {
			decoder_bmmu_box_free(mm_blk_handle);
			mm_blk_handle = NULL;
		}

		mm_blk_handle = decoder_bmmu_box_alloc_box(
			DRIVER_NAME,
			0,
			MAX_BLK_BUFFERS,
			4 + PAGE_SHIFT,
			CODEC_MM_FLAGS_CMA_CLEAR |
			CODEC_MM_FLAGS_FOR_VDECODER |
			tvp_flag);
	}
	pr_info
	("H264 sysinfo: %dx%d duration=%d, pts_outside=%d \n",
	 frame_width, frame_height, frame_dur, pts_outside);
	pr_debug("sync_outside=%d, use_idr_framerate=%d\n",
	 sync_outside, use_idr_framerate);

	if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXTVBB)
		size = V_BUF_ADDR_OFFSET_NEW;
	else
		size = V_BUF_ADDR_OFFSET;

	ret = decoder_bmmu_box_alloc_buf_phy(mm_blk_handle, 0,
		size, DRIVER_NAME, &buf_start);
	if (ret < 0)
		return ret;

	buf_offset = buf_start - DEF_BUF_START_ADDR;

	if ((unsigned long) vh264_amstream_dec_info.param & 0x08)
		ucode_type = UCODE_IP_ONLY_PARAM;
	else
		ucode_type = 0;

	if ((unsigned long) vh264_amstream_dec_info.param & 0x20)
		error_recovery_mode_in = 1;
	else
		error_recovery_mode_in = 3;

	if (!vh264_running) {
		last_mb_width = 0;
		last_mb_height = 0;
	}

	for (i = 0; i < VF_BUF_NUM; i++)
		vfbuf_use[i] = 0;

	INIT_KFIFO(display_q);
	INIT_KFIFO(delay_display_q);
	INIT_KFIFO(recycle_q);
	INIT_KFIFO(newframe_q);

	for (i = 0; i < VF_POOL_SIZE; i++) {
		const struct vframe_s *vf = &vfpool[i];

		vfpool[i].index = VF_BUF_NUM;
		vfpool[i].bufWidth = 1920;
		kfifo_put(&newframe_q, vf);
	}

#ifdef DROP_B_FRAME_FOR_1080P_50_60FPS
	last_interlaced = 1;
#endif
	h264_first_pts_ready = 0;
	h264_first_valid_pts_ready = false;
	h264pts1 = 0;
	h264pts2 = 0;
	h264_pts_count = 0;
	duration_from_pts_done = 0;
	vh264_error_count = READ_VREG(AV_SCRATCH_D);

	p_last_vf = NULL;
	check_pts_discontinue = false;
	last_pts = 0;
	wait_buffer_counter = 0;
	vh264_no_disp_count = 0;
	fatal_error_flag = 0;
	high_bandwidth = 0;
	vh264_stream_switching_state = SWITCHING_STATE_OFF;
#ifdef DEBUG_PTS
	pts_missed = 0;
	pts_hit = 0;
#endif
	pts_discontinue = false;
	no_idr_error_count = 0;

	vh264_reset_userdata_fifo(vdec_h264, 1);
	h264_reset_qos_mgr();

	if (enable_switch_fense) {
		for (i = 0; i < ARRAY_SIZE(fense_buffer_spec); i++) {
			struct buffer_spec_s *s = &fense_buffer_spec[i];
			s->alloc_count = 3 * SZ_1M / PAGE_SIZE;
			ret = decoder_bmmu_box_alloc_buf_phy(mm_blk_handle,
				FENSE_BUFFER_IDX(i),
				3 * SZ_1M, DRIVER_NAME, &s->phy_addr);

			if (ret < 0) {
				fatal_error_flag =
				DECODER_FATAL_ERROR_NO_MEM;
				vh264_running = 0;
				return ret;
			}
			s->y_canvas_index = 2 * i;
			s->u_canvas_index = 2 * i + 1;
			s->v_canvas_index = 2 * i + 1;
		}
	}
	return 0;
}

static s32 vh264_init(void)
{
	int ret = 0;
	int trickmode_fffb = 0;
	int firmwareloaded = 0;

	/* pr_info("\nvh264_init\n"); */
	init_timer(&recycle_timer);

	stat |= STAT_TIMER_INIT;

	vh264_running = 0;/* init here to reset last_mb_width&last_mb_height */
	vh264_eos = 0;
	duration_on_correcting = 0;
	first_pts = 0;
	first_pts64 = 0;
	first_offset = 0;
	first_pts_cached = false;
	fixed_frame_rate_check_count = 0;
	fr_hint_status = VDEC_NO_NEED_HINT;
	saved_resolution = 0;
	iponly_early_mode = 0;
	saved_idc_level = 0;

	frame_count = 0;
	memset(&s_vframe_qos, 0, sizeof(s_vframe_qos));
	/*init vdec status*/
	ret = vh264_vdec_info_init();
	if (0 != ret)
		return -ret;

	ret = vh264_local_init();
	if (ret < 0)
		return ret;
	query_video_status(0, &trickmode_fffb);

	amvdec_enable();
	if (!firmwareloaded && tee_enabled()) {
		ret = amvdec_loadmc_ex(VFORMAT_H264, NULL, NULL);
		if (ret < 0) {
			amvdec_disable();
			pr_err("H264: the %s fw loading failed, err: %x\n",
				tee_enabled() ? "TEE" : "local", ret);
			return ret;
		}
	} else {
	/* -- ucode loading (amrisc and swap code) */
	mc_cpu_addr =
		dma_alloc_coherent(amports_get_dma_device(), MC_TOTAL_SIZE,
				&mc_dma_handle, GFP_KERNEL);
	if (!mc_cpu_addr) {
		amvdec_disable();
		del_timer_sync(&recycle_timer);
		pr_err("vh264_init: Can not allocate mc memory.\n");
		return -ENOMEM;
	}

	pr_debug("264 ucode swap area: phyaddr %p, cpu vaddr %p\n",
		(void *)mc_dma_handle, mc_cpu_addr);
	if (debugfirmware) {
		int r0, r1, r2, r3, r4, r5;
		char firmwarename[32];

		pr_debug("start load debug %d firmware ...\n", debugfirmware);

		snprintf(firmwarename, 32, "%s%d", "vh264_mc", debugfirmware);
		r0 = amvdec_loadmc_ex(VFORMAT_H264, firmwarename, NULL);

#define DEBUGGET_FW(t, name, buf, size, ret)\
		do {\
			snprintf(firmwarename, 32, "%s%d", name,\
				debugfirmware);\
			ret = get_decoder_firmware_data(t,\
				firmwarename, buf, size);\
		} while (0)
		/*memcpy((u8 *) mc_cpu_addr + MC_OFFSET_HEADER, vh264_header_mc,
		 *MC_SWAP_SIZE);
		 */
		DEBUGGET_FW(VFORMAT_H264, "vh264_header_mc",
			(u8 *) mc_cpu_addr + MC_OFFSET_HEADER,
			MC_SWAP_SIZE, r1);

		/*memcpy((u8 *) mc_cpu_addr + MC_OFFSET_DATA, vh264_data_mc,
		 *MC_SWAP_SIZE);
		 */
		DEBUGGET_FW(VFORMAT_H264, "vh264_data_mc",
			(u8 *) mc_cpu_addr + MC_OFFSET_DATA, MC_SWAP_SIZE, r2);
		/*memcpy((u8 *) mc_cpu_addr + MC_OFFSET_MMCO, vh264_mmco_mc,
		 *MC_SWAP_SIZE);
		 */
		DEBUGGET_FW(VFORMAT_H264, "vh264_mmco_mc",
			(u8 *) mc_cpu_addr + MC_OFFSET_MMCO, MC_SWAP_SIZE, r3);
		/*memcpy((u8 *) mc_cpu_addr + MC_OFFSET_LIST, vh264_list_mc,
		 *MC_SWAP_SIZE);
		 */
		DEBUGGET_FW(VFORMAT_H264, "vh264_list_mc",
			(u8 *) mc_cpu_addr + MC_OFFSET_LIST, MC_SWAP_SIZE, r4);
		/*memcpy((u8 *) mc_cpu_addr + MC_OFFSET_SLICE, vh264_slice_mc,
		 *MC_SWAP_SIZE);
		 */
		DEBUGGET_FW(VFORMAT_H264, "vh264_slice_mc",
			(u8 *) mc_cpu_addr + MC_OFFSET_SLICE, MC_SWAP_SIZE, r5);

		if (r0 < 0 || r1 < 0 || r2 < 0 || r3 < 0 || r4 < 0 || r5 < 0) {
			pr_err("264 load debugfirmware err %d,%d,%d,%d,%d,%d\n",
			r0, r1, r2, r3, r4, r5);
			amvdec_disable();
			if (mc_cpu_addr) {
				dma_free_coherent(amports_get_dma_device(),
					MC_TOTAL_SIZE, mc_cpu_addr,
					mc_dma_handle);
				mc_cpu_addr = NULL;
			}
			return -EBUSY;
		}
		firmwareloaded = 1;
	} else {
		int ret = -1;
		char *buf = vmalloc(0x1000 * 16);

		if (IS_ERR_OR_NULL(buf))
			return -ENOMEM;

		if (get_firmware_data(VIDEO_DEC_H264, buf) < 0) {
			pr_err("get firmware fail.");
			vfree(buf);
			return -1;
		}

		ret = amvdec_loadmc_ex(VFORMAT_H264, NULL, buf);
		memcpy((u8 *) mc_cpu_addr + MC_OFFSET_HEADER,
			buf + 0x4000, MC_SWAP_SIZE);
		memcpy((u8 *) mc_cpu_addr + MC_OFFSET_DATA,
			buf + 0x2000, MC_SWAP_SIZE);
		memcpy((u8 *) mc_cpu_addr + MC_OFFSET_MMCO,
			buf + 0x6000, MC_SWAP_SIZE);
		memcpy((u8 *) mc_cpu_addr + MC_OFFSET_LIST,
			buf + 0x3000, MC_SWAP_SIZE);
		memcpy((u8 *) mc_cpu_addr + MC_OFFSET_SLICE,
			buf + 0x5000, MC_SWAP_SIZE);

		vfree(buf);

		if (ret < 0) {
			amvdec_disable();
			if (mc_cpu_addr) {
				dma_free_coherent(amports_get_dma_device(),
					MC_TOTAL_SIZE, mc_cpu_addr,
					mc_dma_handle);
				mc_cpu_addr = NULL;
			}
			pr_err("H264: the %s fw loading failed, err: %x\n",
				tee_enabled() ? "TEE" : "local", ret);
			return -EBUSY;
		}
	}
	}

	stat |= STAT_MC_LOAD;

	/* enable AMRISC side protocol */
	vh264_prot_init();

#ifdef HANDLE_H264_IRQ
	/*TODO irq */

	if (vdec_request_irq(VDEC_IRQ_1, vh264_isr,
			"vh264-irq", (void *)vh264_dec_id)) {
		pr_err("vh264 irq register error.\n");
		amvdec_disable();
		return -ENOENT;
	}
#endif

	stat |= STAT_ISR_REG;

#ifdef CONFIG_AMLOGIC_POST_PROCESS_MANAGER
	vf_provider_init(&vh264_vf_prov, PROVIDER_NAME, &vh264_vf_provider_ops,
					 NULL);
	vf_reg_provider(&vh264_vf_prov);
	vf_notify_receiver(PROVIDER_NAME, VFRAME_EVENT_PROVIDER_START, NULL);
#else
	vf_provider_init(&vh264_vf_prov, PROVIDER_NAME, &vh264_vf_provider_ops,
					 NULL);
	vf_reg_provider(&vh264_vf_prov);
#endif

	if (frame_dur != 0) {
		if (!is_reset) {
			vf_notify_receiver(PROVIDER_NAME,
					VFRAME_EVENT_PROVIDER_FR_HINT,
					(void *)((unsigned long)frame_dur));
			fr_hint_status = VDEC_HINTED;
		}
	} else
		fr_hint_status = VDEC_NEED_HINT;

	stat |= STAT_VF_HOOK;

	recycle_timer.data = (ulong) &recycle_timer;
	recycle_timer.function = vh264_put_timer_func;
	recycle_timer.expires = jiffies + PUT_INTERVAL;

	add_timer(&recycle_timer);

	stat |= STAT_TIMER_ARM;

	vh264_stream_switching_state = SWITCHING_STATE_OFF;

	stat |= STAT_VDEC_RUN;
	wmb();			/* Ensure fetchbuf  contents visible */

	/* -- start decoder */
	amvdec_start();

	init_userdata_fifo();

	return 0;
}

static int vh264_stop(int mode)
{


	if (stat & STAT_VDEC_RUN) {
		amvdec_stop();
		stat &= ~STAT_VDEC_RUN;
	}

	if (stat & STAT_ISR_REG) {
		WRITE_VREG(ASSIST_MBOX1_MASK, 0);
		/*TODO irq */

		vdec_free_irq(VDEC_IRQ_1, (void *)vh264_dec_id);

		stat &= ~STAT_ISR_REG;
	}

	if (stat & STAT_TIMER_ARM) {
		del_timer_sync(&recycle_timer);
		stat &= ~STAT_TIMER_ARM;
	}

	if (stat & STAT_VF_HOOK) {
		if (mode == MODE_FULL) {
			if (fr_hint_status == VDEC_HINTED)
				vf_notify_receiver(PROVIDER_NAME,
					VFRAME_EVENT_PROVIDER_FR_END_HINT,
					NULL);
			fr_hint_status = VDEC_NO_NEED_HINT;
		}

		vf_unreg_provider(&vh264_vf_prov);
		stat &= ~STAT_VF_HOOK;
	}

	if (stat & STAT_MC_LOAD) {
		if (mc_cpu_addr != NULL) {
			dma_free_coherent(amports_get_dma_device(),
					MC_TOTAL_SIZE, mc_cpu_addr,
					mc_dma_handle);
			mc_cpu_addr = NULL;
		}
	}
	if (sei_data_buffer != NULL) {
		dma_free_coherent(
			amports_get_dma_device(),
			USER_DATA_RUND_SIZE,
			sei_data_buffer,
			sei_data_buffer_phys);
		sei_data_buffer = NULL;
		sei_data_buffer_phys = 0;
	}
	amvdec_disable();
	if (mm_blk_handle) {
		decoder_bmmu_box_free(mm_blk_handle);
		mm_blk_handle = NULL;
	}
	memset(&fense_buffer_spec, 0, sizeof(fense_buffer_spec));
	memset(&buffer_spec, 0, sizeof(buffer_spec));
	return 0;
}

static void wait_vh264_search_done(void)
{
	u32 vld_rp = READ_VREG(VLD_MEM_VIFIFO_RP);
	int count = 0;
	do {
		usleep_range(100, 500);
		if (vld_rp == READ_VREG(VLD_MEM_VIFIFO_RP))
			break;
		if (count > 2000) {
			pr_info("%s, timeout  count %d vld_rp 0x%x VLD_MEM_VIFIFO_RP 0x%x\n",
					__func__, count, vld_rp, READ_VREG(VLD_MEM_VIFIFO_RP));
			break;
		} else
			vld_rp = READ_VREG(VLD_MEM_VIFIFO_RP);
		count++;
	} while (1);
}


static void error_do_work(struct work_struct *work)
{

	/*
	 * we need to lock vh264_stop/vh264_init.
	 * because we will call amvdec_h264_remove on this step;
	 * then we may call more than once on
	 * free_irq/deltimer/..and some other.
	 */
	if (atomic_read(&vh264_active)) {
		amvdec_stop();
		do {
			msleep(50);
		} while (vh264_stream_switching_state != SWITCHING_STATE_OFF);
		wait_vh264_search_done();
		vh264_reset  = 1;
#ifdef CONFIG_AMLOGIC_POST_PROCESS_MANAGER
		vh264_ppmgr_reset();
#else
		vf_light_unreg_provider(&vh264_vf_prov);

		vh264_local_init();

		vf_reg_provider(&vh264_vf_prov);
#endif
		vh264_prot_init();
		amvdec_start();
		vh264_reset  = 0;
	}
}

static void stream_switching_done(void)
{
	int state = vh264_stream_switching_state;

	WRITE_VREG(AV_SCRATCH_7, 0);
	WRITE_VREG(AV_SCRATCH_8, 0);
	WRITE_VREG(AV_SCRATCH_9, 0);

	if (state == SWITCHING_STATE_ON_CMD1) {
		pr_info("Enter set parameter cmd1 switching_state %x.\n",
					vh264_stream_switching_state);
		schedule_work(&set_parameter_work);
		return;
	} else if (state == SWITCHING_STATE_ON_CMD1_PENDING)
		return;

	vh264_stream_switching_state = SWITCHING_STATE_OFF;

	wmb();			/* Ensure fetchbuf  contents visible */

	if (state == SWITCHING_STATE_ON_CMD3)
		WRITE_VREG(AV_SCRATCH_0, 0);

	pr_info("Leaving switching mode.\n");
}

/* construt a new frame as a copy of last frame so frame receiver can
 * release all buffer resources to decoder.
 */
static void stream_switching_do(struct work_struct *work)
{
	int mb_total_num, mb_width_num, mb_height_num, i = 0;
	struct vframe_s *vf = NULL;
	u32 y_index, u_index, src_index, des_index, y_desindex, u_desindex;
	struct canvas_s csy, csu, cyd;
	unsigned long flags;
	bool delay = true;

	if (!atomic_read(&vh264_active))
		return;

	if (vh264_stream_switching_state == SWITCHING_STATE_OFF)
		return;

	spin_lock_irqsave(&prepare_lock, flags);

	block_display_q = true;

	spin_unlock_irqrestore(&prepare_lock, flags);

	mb_total_num = mb_total;
	mb_width_num = mb_width;
	mb_height_num = mb_height;

	while (is_4k || kfifo_len(&delay_display_q) > 2) {
		if (kfifo_get(&delay_display_q, &vf)) {
			kfifo_put(&display_q,
				(const struct vframe_s *)vf);
			ATRACE_COUNTER(MODULE_NAME, vf->pts);
			vf_notify_receiver(PROVIDER_NAME,
				VFRAME_EVENT_PROVIDER_VFRAME_READY, NULL);
		} else
			break;
	}

	if (!kfifo_get(&delay_display_q, &vf)) {
		vf = p_last_vf;
		delay = false;
	}

	while (vf) {
		int buffer_index;

		buffer_index = vf->index & 0xff;

		/* construct a clone of the frame from last frame */

#if 0

		pr_info("src yaddr[0x%x] index[%d] width[%d] heigth[%d]\n",
			buffer_spec[buffer_index].y_addr,
			buffer_spec[buffer_index].y_canvas_index,
			buffer_spec[buffer_index].y_canvas_width,
			buffer_spec[buffer_index].y_canvas_height);

		pr_info("src uaddr[0x%x] index[%d] width[%d] heigth[%d]\n",
			buffer_spec[buffer_index].u_addr,
			buffer_spec[buffer_index].u_canvas_index,
			buffer_spec[buffer_index].u_canvas_width,
			buffer_spec[buffer_index].u_canvas_height);
#endif
		if (EN_SWITCH_FENCE()) {
			y_index = buffer_spec[buffer_index].y_canvas_index;
			u_index = buffer_spec[buffer_index].u_canvas_index;

			canvas_read(y_index, &csy);
			canvas_read(u_index, &csu);

			canvas_config(fense_buffer_spec[i].y_canvas_index,
				fense_buffer_spec[i].phy_addr,
				mb_width_num << 4, mb_height_num << 4,
				CANVAS_ADDR_NOWRAP,
				CANVAS_BLKMODE_LINEAR);
			canvas_config(fense_buffer_spec[i].u_canvas_index,
				fense_buffer_spec[i].phy_addr +
				(mb_total_num << 8),
				mb_width_num << 4, mb_height_num << 3,
				CANVAS_ADDR_NOWRAP,
				CANVAS_BLKMODE_LINEAR);

			y_desindex = fense_buffer_spec[i].y_canvas_index;
			u_desindex = fense_buffer_spec[i].u_canvas_index;

			canvas_read(y_desindex, &cyd);

			src_index = ((y_index & 0xff) |
				((u_index << 8) & 0x0000ff00));
			des_index = ((y_desindex & 0xff) |
				((u_desindex << 8) & 0x0000ff00));

			ge2d_canvas_dup(&csy, &csu, &cyd,
				GE2D_FORMAT_M24_NV21,
				src_index,
				des_index);
		}
		vf->mem_handle = decoder_bmmu_box_get_mem_handle(
			mm_blk_handle,
			FENSE_BUFFER_IDX(i));
		fense_vf[i] = *vf;
		fense_vf[i].index = -1;

		if (EN_SWITCH_FENCE())
			fense_vf[i].canvas0Addr =
				spec2canvas(&fense_buffer_spec[i]);
		else
			fense_vf[i].flag |= VFRAME_FLAG_SWITCHING_FENSE;

		/* send clone to receiver */
		kfifo_put(&display_q,
			(const struct vframe_s *)&fense_vf[i]);
		ATRACE_COUNTER(MODULE_NAME, fense_vf[i].pts);
		/* early recycle frames for last session */
		if (delay)
			vh264_vf_put(vf, NULL);

		vf_notify_receiver(PROVIDER_NAME,
			VFRAME_EVENT_PROVIDER_VFRAME_READY, NULL);

		i++;

		if (!kfifo_get(&delay_display_q, &vf))
			break;
	}

	block_display_q = false;

	pr_info("Switching fense frame post\n");
}

static int amvdec_h264_probe(struct platform_device *pdev)
{
	struct vdec_s *pdata = *(struct vdec_s **)pdev->dev.platform_data;

	mutex_lock(&vh264_mutex);

	if (pdata == NULL) {
		pr_info("\namvdec_h264 memory resource undefined.\n");
		mutex_unlock(&vh264_mutex);
		return -EFAULT;
	}
	canvas_mode = pdata->canvas_mode;
	tvp_flag = vdec_secure(pdata) ? CODEC_MM_FLAGS_TVP : 0;
	if (pdata->sys_info)
		vh264_amstream_dec_info = *pdata->sys_info;
	if (sei_data_buffer == NULL) {
		sei_data_buffer =
			dma_alloc_coherent(amports_get_dma_device(),
				USER_DATA_RUND_SIZE,
				&sei_data_buffer_phys, GFP_KERNEL);
		if (!sei_data_buffer) {
			pr_info("%s: Can not allocate sei_data_buffer\n",
				   __func__);
			mutex_unlock(&vh264_mutex);
			return -ENOMEM;
		}
		/* pr_info("buffer 0x%x, phys 0x%x, remap 0x%x\n",
		 *   sei_data_buffer, sei_data_buffer_phys,
		 * (u32)sei_data_buffer_remap);
		 */
	}
	pdata->dec_status = vh264_dec_status;
	pdata->set_trickmode = vh264_set_trickmode;
	pdata->set_isreset = vh264_set_isreset;

	pdata->user_data_read = vh264_user_data_read;
	pdata->reset_userdata_fifo = vh264_reset_userdata_fifo;
	pdata->wakeup_userdata_poll = vh264_wakeup_userdata_poll;

	is_reset = 0;
	clk_adj_frame_count = 0;
	if (vh264_init() < 0) {
		pr_info("\namvdec_h264 init failed.\n");
		kfree(gvs);
		gvs = NULL;
		pdata->dec_status = NULL;
		mutex_unlock(&vh264_mutex);
		return -ENODEV;
	}
	vdec_h264 = pdata;
	vh264_crate_userdata_manager(sei_data_buffer, USER_DATA_SIZE);
	vh264_reset_userdata_fifo(vdec_h264, 1);

#ifdef DUMP_USER_DATA
	vh264_init_userdata_dump();
	vh264_reset_user_data_buf();
#endif

	INIT_WORK(&error_wd_work, error_do_work);
	INIT_WORK(&stream_switching_work, stream_switching_do);
	INIT_WORK(&set_parameter_work, vh264_set_params);
	INIT_WORK(&notify_work, vh264_notify_work);
	INIT_WORK(&set_clk_work, vh264_set_clk);
	INIT_WORK(&userdata_push_work, userdata_push_do_work);
	INIT_WORK(&qos_work, qos_do_work);


	atomic_set(&vh264_active, 1);

	mutex_unlock(&vh264_mutex);
	vdec_set_vframe_comm(pdata, DRIVER_NAME);

	return 0;
}

static int amvdec_h264_remove(struct platform_device *pdev)
{
	atomic_set(&vh264_active, 0);
	cancel_work_sync(&set_parameter_work);
	cancel_work_sync(&error_wd_work);
	cancel_work_sync(&stream_switching_work);
	cancel_work_sync(&notify_work);
	cancel_work_sync(&userdata_push_work);
	cancel_work_sync(&qos_work);


	vh264_stop(MODE_FULL);
	wait_vh264_search_done();
	vdec_source_changed(VFORMAT_H264, 0, 0, 0);
#ifdef DUMP_USER_DATA
	vh264_dump_userdata();
#endif
	vh264_destroy_userdata_manager();
	atomic_set(&vh264_active, 0);
#ifdef DEBUG_PTS
	pr_info
	("pts missed %ld, pts hit %ld, pts_outside %d, duration %d, ",
	 pts_missed, pts_hit, pts_outside, frame_dur);
	pr_info("sync_outside %d, use_idr_framerate %d\n",
			sync_outside, use_idr_framerate);
#endif
	kfree(gvs);
	gvs = NULL;
	cancel_work_sync(&set_clk_work);
	mutex_unlock(&vh264_mutex);
	return 0;
}

/****************************************/
#ifdef CONFIG_PM
static int h264_suspend(struct device *dev)
{
	amvdec_suspend(to_platform_device(dev), dev->power.power_state);
	return 0;
}

static int h264_resume(struct device *dev)
{
	amvdec_resume(to_platform_device(dev));
	return 0;
}

static const struct dev_pm_ops h264_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(h264_suspend, h264_resume)
};
#endif

static struct platform_driver amvdec_h264_driver = {
	.probe = amvdec_h264_probe,
	.remove = amvdec_h264_remove,
	.driver = {
		.name = DRIVER_NAME,
#ifdef CONFIG_PM
		.pm = &h264_pm_ops,
#endif
	}
};

static struct codec_profile_t amvdec_h264_profile = {
	.name = "h264",
	.profile = ""
};


static struct mconfig h264_configs[] = {
	MC_PU32("stat", &stat),
	MC_PU32("error_recovery_mode", &error_recovery_mode),
	MC_PU32("sync_outside", &sync_outside),
	MC_PU32("dec_control", &dec_control),
	MC_PU32("fatal_error_reset", &fatal_error_reset),
	MC_PU32("max_refer_buf", &max_refer_buf),
	MC_PU32("ucode_type", &ucode_type),
	MC_PU32("debugfirmware", &debugfirmware),
	MC_PU32("fixed_frame_rate_flag", &fixed_frame_rate_flag),
	MC_PU32("decoder_debug_flag", &decoder_debug_flag),
	MC_PU32("dpb_size_adj", &dpb_size_adj),
	MC_PU32("decoder_force_reset", &decoder_force_reset),
	MC_PU32("no_idr_error_max", &no_idr_error_max),
	MC_PU32("enable_switch_fense", &enable_switch_fense),
};
static struct mconfig_node h264_node;


static int __init amvdec_h264_driver_init_module(void)
{
	pr_debug("amvdec_h264 module init\n");

	ge2d_videoh264task_init();

	if (platform_driver_register(&amvdec_h264_driver)) {
		pr_err("failed to register amvdec_h264 driver\n");
		return -ENODEV;
	}
	if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXTVBB
		&& (codec_mm_get_total_size() > 80 * SZ_1M)) {
		amvdec_h264_profile.profile = "4k";
	}
	vcodec_profile_register(&amvdec_h264_profile);
	INIT_REG_NODE_CONFIGS("media.decoder", &h264_node,
		"h264", h264_configs, CONFIG_FOR_RW);
	return 0;
}

static void __exit amvdec_h264_driver_remove_module(void)
{
	pr_debug("amvdec_h264 module remove.\n");

	platform_driver_unregister(&amvdec_h264_driver);

	ge2d_videoh264task_release();
}

/****************************************/

module_param(stat, uint, 0664);
MODULE_PARM_DESC(stat, "\n amvdec_h264 stat\n");
module_param(error_recovery_mode, uint, 0664);
MODULE_PARM_DESC(error_recovery_mode, "\n amvdec_h264 error_recovery_mode\n");
module_param(sync_outside, uint, 0664);
MODULE_PARM_DESC(sync_outside, "\n amvdec_h264 sync_outside\n");
module_param(dec_control, uint, 0664);
MODULE_PARM_DESC(dec_control, "\n amvdec_h264 decoder control\n");
module_param(frame_count, uint, 0664);
MODULE_PARM_DESC(frame_count,
       "\n amvdec_h264 decoded total count\n");
module_param(fatal_error_reset, uint, 0664);
MODULE_PARM_DESC(fatal_error_reset,
		"\n amvdec_h264 decoder reset when fatal error happens\n");
module_param(max_refer_buf, uint, 0664);
MODULE_PARM_DESC(max_refer_buf,
		"\n amvdec_h264 dec buffering or not for reference frame\n");
module_param(ucode_type, uint, 0664);
MODULE_PARM_DESC(ucode_type,
		"\n amvdec_h264 dec buffering or not for reference frame\n");
module_param(debugfirmware, uint, 0664);
MODULE_PARM_DESC(debugfirmware, "\n amvdec_h264 debug load firmware\n");
module_param(fixed_frame_rate_flag, uint, 0664);
MODULE_PARM_DESC(fixed_frame_rate_flag,
				 "\n amvdec_h264 fixed_frame_rate_flag\n");
module_param(decoder_debug_flag, uint, 0664);
MODULE_PARM_DESC(decoder_debug_flag,
				 "\n amvdec_h264 decoder_debug_flag\n");

module_param(dpb_size_adj, uint, 0664);
MODULE_PARM_DESC(dpb_size_adj,
				 "\n amvdec_h264 dpb_size_adj\n");


module_param(decoder_force_reset, uint, 0664);
MODULE_PARM_DESC(decoder_force_reset,
		"\n amvdec_h264 decoder force reset\n");
module_param(no_idr_error_max, uint, 0664);
MODULE_PARM_DESC(no_idr_error_max,
		"\n print no_idr_error_max\n");
module_param(enable_switch_fense, uint, 0664);
MODULE_PARM_DESC(enable_switch_fense,
		"\n enable switch fense\n");

#ifdef SUPPORT_BAD_MACRO_BLOCK_REDUNDANCY
module_param(bad_block_scale, uint, 0664);
MODULE_PARM_DESC(bad_block_scale,
				"\n print bad_block_scale\n");
#endif

module_param(enable_userdata_debug, uint, 0664);
MODULE_PARM_DESC(enable_userdata_debug,
		"\n enable_userdata_debug\n");


module_init(amvdec_h264_driver_init_module);
module_exit(amvdec_h264_driver_remove_module);

MODULE_DESCRIPTION("AMLOGIC H264 Video Decoder Driver");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Chen Zhang <chen.zhang@amlogic.com>");