/*
 * Allwinner SoCs display driver.
 *
 * Copyright (C) 2016 Allwinner.
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2.  This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

/**
 *All Winner Tech, All Right Reserved. 2014-2015 Copyright (c)
 *
 *File name   :de_rtmx.c
 *
 *Description :display engine 2.0 realtime mixer
 *             processing base functions implement
 *
 *History     :2014/02/08  iptang  v0.1  Initial version
 *
*/

#include "de_rtmx.h"
#include "de_rtmx_type.h"
#include "de_scaler.h"

static struct __rtmx_reg_t de200_rtmx[DE_NUM];

static struct de_reg_blocks glb_ctl_block[DE_NUM];

static struct de_reg_blocks
	vi_attr_block[DE_NUM][VI_CHN_NUM][LAYER_MAX_NUM_PER_CHN];
static struct de_reg_blocks vi_fc_block[DE_NUM][VI_CHN_NUM];
static struct de_reg_blocks vi_haddr_block[DE_NUM][VI_CHN_NUM];
static struct de_reg_blocks vi_size_block[DE_NUM][VI_CHN_NUM];

static struct de_reg_blocks
	ui_attr_block[DE_NUM][CHN_NUM - VI_CHN_NUM][LAYER_MAX_NUM_PER_CHN];
static struct de_reg_blocks ui_haddr_block[DE_NUM][CHN_NUM - VI_CHN_NUM];
static struct de_reg_blocks ui_size_block[DE_NUM][CHN_NUM - VI_CHN_NUM];

static struct de_reg_blocks bld_attr_block[DE_NUM];
static struct de_reg_blocks bld_ctl_block[DE_NUM];
static struct de_reg_blocks bld_ck_block[DE_NUM];
static struct de_reg_blocks bld_out_block[DE_NUM];
/* static uintptr_t de_base = 0; */
static uintptr_t de_base;

int de_rtmx_update_regs(unsigned int sel)
{
	int i, j, ui_chno, vi_chno, layno;

	vi_chno = de_feat_get_num_vi_chns(sel);
	ui_chno = de_feat_get_num_ui_chns(sel);
	layno = LAYER_MAX_NUM_PER_CHN;

	if (glb_ctl_block[sel].dirty == 0x1) {
		memcpy((void *)glb_ctl_block[sel].off, glb_ctl_block[sel].val,
		       glb_ctl_block[sel].size);
		glb_ctl_block[sel].dirty = 0;
	}

	for (j = 0; j < vi_chno; j++) {
		for (i = 0; i < layno; i++) {
			if (vi_attr_block[sel][j][i].dirty == 0x1) {
				memcpy((void *)vi_attr_block[sel][j][i].off,
				       vi_attr_block[sel][j][i].val,
				       vi_attr_block[sel][j][i].size);
				vi_attr_block[sel][j][i].dirty = 0;
			}
		}

		if (vi_fc_block[sel][j].dirty == 0x1) {
			memcpy((void *)vi_fc_block[sel][j].off,
			       vi_fc_block[sel][j].val,
			       vi_fc_block[sel][j].size);
			vi_fc_block[sel][j].dirty = 0;
		}

		if (vi_haddr_block[sel][j].dirty == 0x1) {
			memcpy((void *)vi_haddr_block[sel][j].off,
			       vi_haddr_block[sel][j].val,
			       vi_haddr_block[sel][j].size);
			vi_haddr_block[sel][j].dirty = 0;
		}

		if (vi_size_block[sel][j].dirty == 0x1) {
			memcpy((void *)vi_size_block[sel][j].off,
			       vi_size_block[sel][j].val,
			       vi_size_block[sel][j].size);
			vi_size_block[sel][j].dirty = 0;
		}
	}

	for (j = 0; j < ui_chno; j++) {
		for (i = 0; i < layno; i++) {
			if (ui_attr_block[sel][j][i].dirty == 0x1) {
				memcpy((void *)ui_attr_block[sel][j][i].off,
				       ui_attr_block[sel][j][i].val,
				       ui_attr_block[sel][j][i].size);
				ui_attr_block[sel][j][i].dirty = 0;
			}
		}

		if (ui_haddr_block[sel][j].dirty == 0x1) {
			memcpy((void *)ui_haddr_block[sel][j].off,
			       ui_haddr_block[sel][j].val,
			       ui_haddr_block[sel][j].size);
			ui_haddr_block[sel][j].dirty = 0;
		}

		if (ui_size_block[sel][j].dirty == 0x1) {
			memcpy((void *)ui_size_block[sel][j].off,
			       ui_size_block[sel][j].val,
			       ui_size_block[sel][j].size);
			ui_size_block[sel][j].dirty = 0;
		}
	}

	if (bld_attr_block[sel].dirty == 0x1) {
		memcpy((void *)bld_attr_block[sel].off, bld_attr_block[sel].val,
		       bld_attr_block[sel].size);
		bld_attr_block[sel].dirty = 0;
	}

	if (bld_ctl_block[sel].dirty == 0x1) {
		memcpy((void *)bld_ctl_block[sel].off, bld_ctl_block[sel].val,
		       bld_ctl_block[sel].size);
		bld_ctl_block[sel].dirty = 0;
	}

	if (bld_ck_block[sel].dirty == 0x1) {
		memcpy((void *)bld_ck_block[sel].off, bld_ck_block[sel].val,
		       bld_ck_block[sel].size);
		bld_ck_block[sel].dirty = 0;
	}

	if (bld_out_block[sel].dirty == 0x1) {
		memcpy((void *)bld_out_block[sel].off, bld_out_block[sel].val,
		       bld_out_block[sel].size);
		bld_out_block[sel].dirty = 0;
	}

	return 0;
}

static int de_rtmx_force_dirty(unsigned int sel)
{
	int i, j, ui_chno, vi_chno, layno;

	vi_chno = de_feat_get_num_vi_chns(sel);
	ui_chno = de_feat_get_num_ui_chns(sel);
	layno = LAYER_MAX_NUM_PER_CHN;

	glb_ctl_block[sel].dirty = 1;
	for (j = 0; j < vi_chno; j++) {
		for (i = 0; i < layno; i++)
			vi_attr_block[sel][j][i].dirty = 1;
		vi_fc_block[sel][j].dirty = 1;
		vi_haddr_block[sel][j].dirty = 1;
		vi_size_block[sel][j].dirty = 1;
	}

	for (j = 0; j < ui_chno; j++) {
		for (i = 0; i < layno; i++)
			ui_attr_block[sel][j][i].dirty = 1;
		ui_haddr_block[sel][j].dirty = 1;
		ui_size_block[sel][j].dirty = 1;
	}

	bld_attr_block[sel].dirty = 1;
	bld_ctl_block[sel].dirty = 1;
	bld_ck_block[sel].dirty = 1;
	bld_out_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_init(unsigned int sel, uintptr_t reg_base)
{
	void *memory;
	int i, j, vi_chno, ui_chno, layno;
	uintptr_t glb_base, apb_base, ovl_base;
	int ch_index = 0;

	de_base = reg_base;

	if (sel > de_feat_get_num_screens())
		__wrn("sel %d out of range\n", sel);

	vi_chno = de_feat_get_num_vi_chns(sel);
	ui_chno = de_feat_get_num_ui_chns(sel);
	layno = LAYER_MAX_NUM_PER_CHN;

	glb_base = reg_base + 0x00100000;
	apb_base = reg_base + 0x00101000;
	ovl_base = reg_base + 0x00102000;

	if (sel) {
		glb_base = reg_base + 0x00200000;
		apb_base = reg_base + 0x00201000;
		ovl_base = reg_base + 0x00202000;
	}
#if defined(CONFIG_INDEPENDENT_DE)
	if (sel) {
		glb_base = glb_base - 0x00100000;
		apb_base = apb_base - 0x00100000;
		ovl_base = ovl_base - 0x00100000;

	}
#endif
	memory = kmalloc(sizeof(struct __glb_reg_t), GFP_KERNEL | __GFP_ZERO);
	if (memory == NULL) {
		__wrn("malloc rtmx global memory fail! size=0x%x\n",
		      (unsigned int)sizeof(struct __glb_reg_t));
		return -1;
	}

	glb_ctl_block[sel].off = glb_base;
	glb_ctl_block[sel].val = memory;
	glb_ctl_block[sel].size = 0x10;
	glb_ctl_block[sel].dirty = 1;

	de_rtmx_set_gld_reg_base(sel, memory);

	for (j = 0; j < vi_chno; j++) {
		memory =
			kmalloc(sizeof(struct __vi_ovl_reg_t),
			GFP_KERNEL | __GFP_ZERO);
		if (memory == NULL) {
			__wrn("malloc video overlay memory fail! size=0x%x\n",
			      (unsigned int)sizeof(struct __vi_ovl_reg_t));
			return -1;
		}
		__inf("malloc memory ok(0x%p) for video channel\n",
		    (void *)memory);

		for (i = 0; i < layno; i++) {
			vi_attr_block[sel][j][i].off =
			    ovl_base + ch_index * 0x00001000 + i * 0x30;
			vi_attr_block[sel][j][i].val = (memory + i * 0x30);
			vi_attr_block[sel][j][i].size = 0x30;
			vi_attr_block[sel][j][i].dirty = 1;
		}

		vi_fc_block[sel][j].off =
		    ovl_base + ch_index * 0x00001000 + 0xc0;
		vi_fc_block[sel][j].val = (memory + 0xc0);
		vi_fc_block[sel][j].size = 0x10;
		vi_fc_block[sel][j].dirty = 1;

		vi_haddr_block[sel][j].off =
		    ovl_base + ch_index * 0x00001000 + 0xd0;
		vi_haddr_block[sel][j].val = (memory + 0xd0);
		vi_haddr_block[sel][j].size = 0x18;
		vi_haddr_block[sel][j].dirty = 1;

		vi_size_block[sel][j].off =
		    ovl_base + ch_index * 0x00001000 + 0xe8;
		vi_size_block[sel][j].val = (memory + 0xe8);
		vi_size_block[sel][j].size = 0x18;
		vi_size_block[sel][j].dirty = 1;
		de_rtmx_set_overlay_reg_base(sel, j, memory);

		ch_index++;
	}

	for (j = 0; j < ui_chno; j++) {

		memory =
			kmalloc(sizeof(struct __ui_ovl_reg_t),
			GFP_KERNEL | __GFP_ZERO);
		if (memory == NULL) {
			__wrn("malloc ui overlay memory fail! size=0x%x\n",
			      (unsigned int)sizeof(struct __ui_ovl_reg_t));
			return -1;
		}

		for (i = 0; i < layno; i++) {
			ui_attr_block[sel][j][i].off =
			    ovl_base + ch_index * 0x00001000 + i * 0x20;
			ui_attr_block[sel][j][i].val = (memory + i * 0x20);
			ui_attr_block[sel][j][i].size = 0x20;
			ui_attr_block[sel][j][i].dirty = 1;
		}

		ui_haddr_block[sel][j].off =
		    ovl_base + ch_index * 0x00001000 + 0x80;
		ui_haddr_block[sel][j].val = (memory + 0x80);
		ui_haddr_block[sel][j].size = 0x8;
		ui_haddr_block[sel][j].dirty = 1;

		ui_size_block[sel][j].off =
		    ovl_base + ch_index * 0x00001000 + 0x88;
		ui_size_block[sel][j].val = (memory + 0x88);
		ui_size_block[sel][j].size = 0x4;
		ui_size_block[sel][j].dirty = 1;

		de_rtmx_set_overlay_reg_base(sel, j + vi_chno, memory);

		ch_index++;
	}

	memory = kmalloc(sizeof(struct __bld_reg_t), GFP_KERNEL | __GFP_ZERO);
	if (memory == NULL) {
		__wrn("malloc blending memory fail! size=0x%x\n",
		      (unsigned int)sizeof(struct __bld_reg_t));
		return -1;
	}

	bld_attr_block[sel].off = apb_base;
	bld_attr_block[sel].val = memory;
	bld_attr_block[sel].size = 0x44;
	bld_attr_block[sel].dirty = 1;

	bld_ctl_block[sel].off = apb_base + 0x80;
	bld_ctl_block[sel].val = (memory + 0x80);
	bld_ctl_block[sel].size = 0x20;
	bld_ctl_block[sel].dirty = 1;

	bld_ck_block[sel].off = apb_base + 0xb0;
	bld_ck_block[sel].val = (memory + 0xb0);
	bld_ck_block[sel].size = 0x4c;
	bld_ck_block[sel].dirty = 1;

	bld_out_block[sel].off = apb_base + 0xfc;
	bld_out_block[sel].val = (memory + 0xfc);
	bld_out_block[sel].size = 0x4;
	bld_out_block[sel].dirty = 1;

	de_rtmx_set_bld_reg_base(sel, memory);

	return 0;
}

int de_rtmx_exit(unsigned int sel)
{
	int j, vi_chno, ui_chno;
	int ch_index = 0;

	if (sel > de_feat_get_num_screens())
		__wrn("sel %d out of range\n", sel);

	vi_chno = de_feat_get_num_vi_chns(sel);
	ui_chno = de_feat_get_num_ui_chns(sel);

	kfree(glb_ctl_block[sel].val);

	for (j = 0; j < vi_chno; j++) {
		kfree(vi_attr_block[sel][j][0].val);
		ch_index++;
	}

	for (j = 0; j < ui_chno; j++) {
		kfree(ui_attr_block[sel][j][0].val);
		ch_index++;
	}

	kfree(bld_attr_block[sel].val);

	return 0;
}

/**
 *function    : de_rtmx_set_gld_reg_base(unsigned int sel, unsigned int base)
 *description : set de reg base
 *parameters  :
 *              sel         <rtmx select>
 *              base        <reg base>
 *return      :
 *              success
 */
int de_rtmx_set_gld_reg_base(unsigned int sel, void *base)
{
	__inf("sel=0x%x, addr=0x%p\n", sel, base);
	de200_rtmx[sel].glb_ctl = (struct __glb_reg_t *)base;

	return 0;
}

/**
 *function    : de_rtmx_set_bld_reg_base(unsigned int sel, unsigned int base)
 *description : set de reg base
 *parameters  :
 *              sel         <rtmx select>
 *              base        <reg base>
 *return      :
 *              success
 */
int de_rtmx_set_bld_reg_base(unsigned int sel, void *base)
{
	__inf("sel=%d, base=0x%p\n", sel, base);
	de200_rtmx[sel].bld_ctl = (struct __bld_reg_t *) base;

	return 0;
}

/**
 *function   : de_rtmx_set_overlay_reg_base(unsigned int sel,
 *                      unsigned int chno, unsigned int base)
 *description: set de reg base
 *parameters :
 *             sel         <rtmx select>
 *             chno        <overlay select>
 *             base        <reg base>
 *return     :
 *             success
 */
int de_rtmx_set_overlay_reg_base(unsigned int sel, unsigned int chno,
				 void *base)
{
	int vi_chno = de_feat_get_num_vi_chns(sel);

	__inf("sel=0x%x, overlayer %d, addr=0x%p\n", sel, chno, base);

	if (chno < vi_chno) {
		de200_rtmx[sel].vi_ovl[chno] = (struct __vi_ovl_reg_t *) base;
	} else {
		de200_rtmx[sel].ui_ovl[chno - vi_chno] =
		    (struct __ui_ovl_reg_t *) base;
	}

	return 0;
}

int de_rtmx_set_display_size(unsigned int sel, unsigned int width,
			     unsigned int height)
{
	de200_rtmx[sel].glb_ctl->glb_size.bits.width =
	    width == 0 ? 0 : width - 1;
	de200_rtmx[sel].glb_ctl->glb_size.bits.height =
	    height == 0 ? 0 : height - 1;

	glb_ctl_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_set_dbuff_rdy(unsigned int sel)
{
	de200_rtmx[sel].glb_ctl->glb_dbuff.dwval = 0x1;

	glb_ctl_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_set_enable(unsigned int sel, unsigned int en)
{
	/* de200_rtmx[sel].glb_ctl->glb_ctl.bits.finish_irq_en = en&0x1; */

	/* 0:write back fetch data after dep;
	 * 1:write back fetch data before dep
	 */
	de200_rtmx[sel].glb_ctl->glb_ctl.bits.rtwb_port = 0x1;
	de200_rtmx[sel].glb_ctl->glb_ctl.bits.rt_en = en & 0x1;

	/* glb_ctl_block[sel].dirty      = 1;  */
	if (en)
		de_rtmx_force_dirty(sel);

	return 0;
}

int de_rtmx_query_irq(unsigned int sel)
{
	unsigned int irq_flag;
	uintptr_t base = glb_ctl_block[sel].off;

	irq_flag = readl((void __iomem *)(base + 0x04));
	if (irq_flag & 0x1) {
		writel(irq_flag, (void __iomem *)(base + 0x04));
		return 1;
	}

	return 0;
}

int de_rtmx_enable_irq(unsigned int sel, unsigned int en)
{
	unsigned int irq_flag;
	uintptr_t base = glb_ctl_block[sel].off;

	irq_flag = readl((void __iomem *)(base + 0x0));
	irq_flag &= (~(0x1 << 4));
	irq_flag |= (en & 0x1) << 4;
	writel(irq_flag, (void __iomem *)(base + 0x0));

	return 0;
}

/**
 *function       : de_rtmx_set_lay_cfg(unsigned int sel,
 *              unsigned int chno, unsigned int layno, struct __lay_para_t *cfg)
 *description    : set de layer config
 *parameters     :
 *                 sel         <rtmx select>
 *                 chno        <overlay channel number>
 *                 layno       <layer number>
 *                 cfg         <layer config data>
 *return         :
 *                 success
 */
int de_rtmx_set_lay_cfg(unsigned int sel, unsigned int chno, unsigned int layno,
			struct __lay_para_t *cfg)
{
	int fmt, ui_sel;
	int vi_chno = de_feat_get_num_vi_chns(sel);

	if (chno >= vi_chno) {
		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_lay_cfg[layno].lay_attr.
		    bits.lay_en = cfg->en;
		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_lay_cfg[layno].lay_attr.
		    bits.lay_alpmod = cfg->alpha_mode;
		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_lay_cfg[layno].lay_attr.
		    bits.lay_fcolor_en = cfg->fcolor_en;
		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_lay_cfg[layno].lay_attr.
		    bits.lay_fmt = cfg->fmt;
		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_lay_cfg[layno].lay_attr.
		    bits.lay_alpctl = cfg->premul_ctl;
		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_lay_cfg[layno].lay_attr.
		    bits.lay_top_down = cfg->top_bot_en;
		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_lay_cfg[layno].lay_attr.
		    bits.lay_alpha = cfg->alpha;

		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_lay_cfg[layno].lay_size.
		    bits.lay_width = cfg->layer.w == 0 ? 0 : cfg->layer.w - 1;
		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_lay_cfg[layno].lay_size.
		    bits.lay_height = cfg->layer.h == 0 ? 0 : cfg->layer.h - 1;

		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_lay_cfg[layno].lay_coor.
		    bits.lay_coorx = cfg->layer.x;
		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_lay_cfg[layno].lay_coor.
		    bits.lay_coory = cfg->layer.y;

		ui_attr_block[sel][chno - vi_chno][layno].dirty = 1;
	} else {
		if (cfg->fmt == DE_FORMAT_YUV422_I_VYUY) {
			ui_sel = 0x0;
			fmt = 0x0;
		} else if (cfg->fmt == DE_FORMAT_YUV422_I_YVYU) {
			ui_sel = 0x0;
			fmt = 0x1;
		} else if (cfg->fmt == DE_FORMAT_YUV422_I_UYVY) {
			ui_sel = 0x0;
			fmt = 0x2;
		} else if (cfg->fmt == DE_FORMAT_YUV422_I_YUYV) {
			ui_sel = 0x0;
			fmt = 0x3;
		} else if (cfg->fmt == DE_FORMAT_YUV422_SP_VUVU) {
			ui_sel = 0x0;
			fmt = 0x5;
		} else if (cfg->fmt == DE_FORMAT_YUV422_SP_UVUV) {
			ui_sel = 0x0;
			fmt = 0x4;
		} else if (cfg->fmt == DE_FORMAT_YUV422_P) {
			ui_sel = 0x0;
			fmt = 0x6;
		} else if (cfg->fmt == DE_FORMAT_YUV420_SP_VUVU) {
			ui_sel = 0x0;
			fmt = 0x9;
		} else if (cfg->fmt == DE_FORMAT_YUV420_SP_UVUV) {
			ui_sel = 0x0;
			fmt = 0x8;
		} else if (cfg->fmt == DE_FORMAT_YUV420_P) {
			ui_sel = 0x0;
			fmt = 0xa;
		} else if (cfg->fmt == DE_FORMAT_YUV411_SP_VUVU) {
			ui_sel = 0x0;
			fmt = 0xd;
		} else if (cfg->fmt == DE_FORMAT_YUV411_SP_UVUV) {
			ui_sel = 0x0;
			fmt = 0xc;
		} else if (cfg->fmt == DE_FORMAT_YUV411_P) {
			ui_sel = 0x0;
			fmt = 0xe;
		} else {
			ui_sel = 0x1;
			fmt = cfg->fmt;
		}

		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_attr.bits.
		    lay_en = cfg->en;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_attr.bits.
		    alpmode = cfg->alpha_mode;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_attr.bits.
		    alpctl = cfg->premul_ctl;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_attr.bits.
		    alpha = cfg->alpha;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_attr.bits.
		    lay_fcolor_en = cfg->fcolor_en;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_attr.bits.
		    lay_fmt = fmt;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_attr.bits.
		    ui_sel = ui_sel;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_attr.bits.
		    lay_top_down = cfg->top_bot_en;

		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_size.bits.
		    lay_width = cfg->layer.w == 0 ? 0 : cfg->layer.w - 1;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_size.bits.
		    lay_height = cfg->layer.h == 0 ? 0 : cfg->layer.h - 1;

		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_coor.bits.
		    lay_coorx = cfg->layer.x;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_coor.bits.
		    lay_coory = cfg->layer.y;

		vi_attr_block[sel][chno][layno].dirty = 1;
	}

	return 0;
}

/*
 *function       : de_rtmx_set_lay_haddr(unsigned int sel, unsigned int chno,
 *                     unsigned int layno, unsigned char top_bot_en,
 *                     unsigned char *haddr_t, unsigned char *haddr_b)
 *description    : set de high address for layers
 *parameters     :
 *                 sel         <rtmx select>
 *                 chno        <overlay channel number>
 *                 haddr_t     <layer high top address data>
 *                 haddr_b     <layer high bottom address data>
 *return         :
 *                 success
 */
int de_rtmx_set_lay_haddr(unsigned int sel, unsigned int chno,
			  unsigned int layno, unsigned char top_bot_en,
			  unsigned char *haddr_t, unsigned char *haddr_b)
{
	unsigned int haddr, mask;
	int vi_chno = de_feat_get_num_vi_chns(sel);

	switch (layno) {
	case 0:
		mask = 0xffffff00;
		break;
	case 1:
		mask = 0xffff00ff;
		break;
	case 2:
		mask = 0xff00ffff;
		break;
	default:
		mask = 0x00ffffff;
		break;
	}

	if (chno >= vi_chno) {

		haddr =
		    de200_rtmx[sel].ui_ovl[chno -
		    vi_chno]->ui_lay_top_haddr.dwval & mask;
		de200_rtmx[sel].ui_ovl[chno - vi_chno]->ui_lay_top_haddr.dwval =
		    haddr + (haddr_t[0] << layno);

		if (top_bot_en) {
			haddr =
			    de200_rtmx[sel].ui_ovl[chno - vi_chno]
			    ->ui_lay_bot_haddr.dwval & mask;
			de200_rtmx[sel].ui_ovl[chno - vi_chno]
			    ->ui_lay_bot_haddr.dwval =
			    haddr + (haddr_b[0] << layno);
		}

		ui_haddr_block[sel][chno - vi_chno].dirty = 1;
	} else {
		haddr =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_top_haddr[0].dwval
		    & mask;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_top_haddr[0].dwval =
		    haddr + (haddr_t[0] << layno);
		haddr =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_top_haddr[1].dwval
		    & mask;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_top_haddr[1].dwval =
		    haddr + (haddr_t[1] << layno);
		haddr =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_top_haddr[2].dwval
		    & mask;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_top_haddr[2].dwval =
		    haddr + (haddr_t[2] << layno);

		if (top_bot_en) {
			haddr =
			    de200_rtmx[sel].vi_ovl[chno]->vi_lay_bot_haddr[0].
			    dwval & mask;
			de200_rtmx[sel].vi_ovl[chno]->vi_lay_bot_haddr[0].dwval
			    = haddr + (haddr_b[0] << layno);
			haddr =
			    de200_rtmx[sel].vi_ovl[chno]->vi_lay_bot_haddr[1].
			    dwval & mask;
			de200_rtmx[sel].vi_ovl[chno]->vi_lay_bot_haddr[1].dwval
			    = haddr + (haddr_b[1] << layno);
			haddr =
			    de200_rtmx[sel].vi_ovl[chno]->vi_lay_bot_haddr[2].
			    dwval & mask;
			de200_rtmx[sel].vi_ovl[chno]->vi_lay_bot_haddr[2].dwval
			    = haddr + (haddr_b[2] << layno);
		}

		vi_haddr_block[sel][chno].dirty = 1;
	}

	return 0;
}

/**
 *function       : de_rtmx_set_lay_laddr(unsigned int sel, unsigned int chno,
 *                 unsigned int layno, unsigned char fmt,struct de_rect crop,
 *                 unsigned int *size, enum de_3d_in_mode trdinmode,
 *                  unsigned int *addr,unsigned char *haddr)
 *description    : set de low address for layer
 *parameters     :
 *                 sel         <rtmx select>
 *                 chno        <overlay channel number>
 *                 layno       <layer number>
 *                 fmt         <layer data data format>
 *return         :
 *                 success
 */
int de_rtmx_set_lay_laddr(unsigned int sel, unsigned int chno,
			unsigned int layno, unsigned char fmt,
			struct de_rect crop, unsigned int *size,
			unsigned int *align, enum de_3d_in_mode trdinmode,
			unsigned int *addr, unsigned char *haddr)
{
	long long addr_off[3];
	unsigned int pitch[3];
	unsigned int x0, x1, y0, y1, ycnt, ucnt;
	int vi_chno = de_feat_get_num_vi_chns(sel);

	x0 = crop.x;
	y0 = crop.y;
	x1 = y1 = 0;
	ycnt = ucnt = 0;

	if (fmt <= DE_FORMAT_BGRX_8888) {
		ycnt = 4;
	} else if (fmt <= DE_FORMAT_BGR_888) {
		ycnt = 3;
	} else if (fmt <= DE_FORMAT_BGRA_5551) {
		ycnt = 2;
	} else if (fmt <= DE_FORMAT_YUV422_I_VYUY) {
		ycnt = 2;
		ucnt = 0;
	} else if (fmt == DE_FORMAT_YUV422_P) {
		ycnt = 1;
		ucnt = 1;
		x1 = x0 / 2;
		y1 = y0;
	}
	/* YUV422 */
	else if (fmt == DE_FORMAT_YUV420_P) {
		ycnt = 1;
		ucnt = 1;
		x1 = x0 / 2;
		y1 = y0 / 2;
	}
	/* YUV420 */
	else if (fmt == DE_FORMAT_YUV411_P) {
		ycnt = 1;
		ucnt = 1;
		x1 = x0 / 4;
		y1 = y0;
	}
	/* YUV411 */
	else if (fmt <= DE_FORMAT_YUV422_SP_VUVU) {
		ycnt = 1;
		ucnt = 2;
		x1 = x0 / 2;
		y1 = y0;
	} else if (fmt <= DE_FORMAT_YUV420_SP_VUVU) {
		ycnt = 1;
		ucnt = 2;
		x1 = x0 / 2;
		y1 = y0 / 2;
	} else if (fmt <= DE_FORMAT_YUV411_SP_VUVU) {
		ycnt = 1;
		ucnt = 2;
		x1 = x0 / 4;
		y1 = y0;
	} else {
		ycnt = 4;
	}

	pitch[0] = DISPALIGN(size[0] * ycnt, align[0]);
	pitch[1] = DISPALIGN(size[1] * ucnt, align[1]);
	pitch[2] = DISPALIGN(size[2] * ucnt, align[2]);

	if (trdinmode == DE_3D_SRC_MODE_LI)
		addr_off[0] =
		    addr[0] + de_rtmx_get_li_addr_offset(size[0], align[0], x0,
			    y0, ycnt);
	else
		addr_off[0] = addr[0] + pitch[0] * y0 + x0 * ycnt;
		/* Y/ARGB */

	haddr[0] = (addr_off[0] >> 32) & 0xff;
	if (chno >= vi_chno) {
		de200_rtmx[sel].ui_ovl[chno - vi_chno]
		    ->ui_lay_cfg[layno].lay_pitch.dwval = pitch[0];
		de200_rtmx[sel].ui_ovl[chno - vi_chno]->ui_lay_cfg[layno].
		    lay_top_laddr.dwval = (addr_off[0] & 0xffffffff);
		de200_rtmx[sel].ui_ovl[chno - vi_chno]->
		    ui_lay_cfg[layno].lay_bot_laddr.dwval = 0x0;

		ui_attr_block[sel][chno - vi_chno][layno].dirty = 1;
	} else {
		if (trdinmode == DE_3D_SRC_MODE_LI) {
			addr_off[1] =
			    addr[1] + de_rtmx_get_li_addr_offset(size[1],
								 align[1], x1,
								 y1, ucnt);
			addr_off[2] =
			    addr[2] + de_rtmx_get_li_addr_offset(size[2],
								 align[2], x1,
								 y1, ucnt);
		} else {
			addr_off[1] = addr[1] + pitch[1] * y1 + x1 * ucnt;
			/* UV/U */
			addr_off[2] = addr[2] + pitch[2] * y1 + x1 * ucnt;
			/* V */
		}

		haddr[1] = (addr_off[1] >> 32) & 0xff;
		haddr[2] = (addr_off[2] >> 32) & 0xff;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_pitch[0].
		    dwval = pitch[0];
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_pitch[1].
		    dwval = pitch[1];
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_pitch[2].
		    dwval = pitch[2];

		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_top_laddr[0].dwval = (addr_off[0] & 0xffffffff);
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_top_laddr[1].dwval = (addr_off[1] & 0xffffffff);
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_top_laddr[2].dwval = (addr_off[2] & 0xffffffff);

		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_bot_laddr[0].dwval = 0x0;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_bot_laddr[1].dwval = 0x0;
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_bot_laddr[2].dwval = 0x0;

		vi_attr_block[sel][chno][layno].dirty = 1;
	}

	return 0;
}

int de_rtmx_get_3d_in_single_size(enum de_3d_in_mode inmode,
	struct de_rect64 *size)
{

	switch (inmode) {
	case DE_3D_SRC_MODE_TB:
		/*size->w = size->w;*/
		size->h = size->h >> 1;
		/*size->x = size->x;
		size->y = size->y;*/
		break;
	case DE_3D_SRC_MODE_SSF:
	case DE_3D_SRC_MODE_SSH:
		size->w = size->w >> 1;
		/*size->h = size->h;
		size->x = size->x;
		size->y = size->y;*/
		break;
	case DE_3D_SRC_MODE_LI:
		/*size->w = size->w;*/
		size->h = size->h >> 1;
		/*size->x = size->x;*/
		size->y = size->y >> 1;
		break;
	case DE_3D_SRC_MODE_FP:
		/*size->w = size->w;
		size->h = size->h;
		size->x = size->x;
		size->y = size->y;*/
		break;
	default:
		/* undefine input mode */
		break;
	}

	return 0;
}

int de_rtmx_get_3d_in(unsigned char fmt, struct de_rect crop,
			struct de_fb *size, unsigned int *align,
			enum de_3d_in_mode trdinmode, unsigned int *addr,
			unsigned int *trd_addr, unsigned int *pitch,
			unsigned int *pitchr, unsigned int *lay_laddr)
{
	unsigned int ycnt, ucnt, data_type;
	unsigned int image_w0, image_w1, image_w2, image_h0, image_h1, image_h2;

	ycnt = ucnt = 0;
	if (trdinmode == DE_3D_SRC_NORMAL)
		return -1;

	if (fmt <= DE_FORMAT_BGRX_8888) {
		ycnt = 4;
		data_type = 0x0;
	} else if (fmt <= DE_FORMAT_BGR_888) {
		ycnt = 3;
		data_type = 0x0;
	} else if (fmt <= DE_FORMAT_BGRA_5551) {
		ycnt = 2;
		data_type = 0x0;
	} else if (fmt <= DE_FORMAT_YUV422_I_VYUY) {
		ycnt = 2;
		data_type = 0x0;
		ucnt = 0;
	} else if (fmt == DE_FORMAT_YUV422_P) {
		ycnt = 1;
		data_type = 0x2;
		ucnt = 1;
	}
	/* YUV422 */
	else if (fmt == DE_FORMAT_YUV420_P) {
		ycnt = 1;
		data_type = 0x2;
		ucnt = 1;
	}
	/* YUV420 */
	else if (fmt == DE_FORMAT_YUV411_P) {
		ycnt = 1;
		data_type = 0x2;
		ucnt = 1;
	}
	/* YUV411 */
	else if (fmt <= DE_FORMAT_YUV422_SP_VUVU) {
		ycnt = 1;
		data_type = 0x1;
		ucnt = 2;
	} else if (fmt <= DE_FORMAT_YUV420_SP_VUVU) {
		ycnt = 1;
		data_type = 0x1;
		ucnt = 2;
	} else if (fmt <= DE_FORMAT_YUV411_SP_VUVU) {
		ycnt = 1;
		data_type = 0x1;
		ucnt = 2;
	} else {
		ycnt = 4;
		data_type = 0x0;
	}

	switch (fmt) {
	case DE_FORMAT_YUV420_P:
	case DE_FORMAT_YUV420_SP_VUVU:
	case DE_FORMAT_YUV420_SP_UVUV:
		image_w0 = crop.w;
		image_w2 = image_w1 = crop.w >> 1;
		image_h0 = crop.h;
		image_h2 = image_h1 = crop.h >> 1;
		break;
	case DE_FORMAT_YUV422_P:
	case DE_FORMAT_YUV422_SP_VUVU:
	case DE_FORMAT_YUV422_SP_UVUV:
		image_w0 = crop.w;
		image_w2 = image_w1 = crop.w >> 1;
		image_h0 = crop.h;
		image_h2 = image_h1 = image_h0;
		break;
	case DE_FORMAT_YUV411_P:
	case DE_FORMAT_YUV411_SP_VUVU:
	case DE_FORMAT_YUV411_SP_UVUV:
		image_w0 = crop.w;
		image_w2 = image_w1 = crop.w >> 2;
		image_h0 = crop.h;
		image_h2 = image_h1 = image_h0;
		break;
	default:
		image_w0 = crop.w;
		image_w2 = image_w1 = image_w0;
		image_h0 = crop.h;
		image_h2 = image_h1 = image_h0;
		break;
	}
	/* planar */
	if (data_type == 0x2) {
		if (trdinmode == DE_3D_SRC_MODE_TB) {
			pitchr[0] = pitch[0] = DISPALIGN(size[0].w, align[0]);
			pitchr[1] = pitch[1] = DISPALIGN(size[1].w, align[1]);
			pitchr[2] = pitch[2] = DISPALIGN(size[2].w, align[2]);

			lay_laddr[0] = pitch[0] * image_h0 + addr[0];
			lay_laddr[1] = pitch[1] * image_h1 + addr[1];
			lay_laddr[2] = pitch[2] * image_h2 + addr[2];

		} else if (trdinmode == DE_3D_SRC_MODE_FP) {
			pitchr[0] = pitch[0] = DISPALIGN(size[0].w, align[0]);
			pitchr[1] = pitch[1] = DISPALIGN(size[1].w, align[1]);
			pitchr[2] = pitch[2] = DISPALIGN(size[2].w, align[2]);

			lay_laddr[0] = trd_addr[0];
			lay_laddr[1] = trd_addr[1];
			lay_laddr[2] = trd_addr[2];

		} else if ((trdinmode == DE_3D_SRC_MODE_SSF)
			   || (trdinmode == DE_3D_SRC_MODE_SSH)) {
			pitchr[0] = pitch[0] = DISPALIGN(size[0].w, align[0]);
			pitchr[1] = pitch[1] = DISPALIGN(size[1].w, align[1]);
			pitchr[2] = pitch[2] = DISPALIGN(size[2].w, align[2]);

			lay_laddr[0] = image_w0 + addr[0];
			lay_laddr[1] = image_w1 + addr[1];
			lay_laddr[2] = image_w2 + addr[2];
		} else if (trdinmode == DE_3D_SRC_MODE_LI) {
			pitchr[0] = pitch[0] =
			    (DISPALIGN(size[0].w, align[0])) << 1;
			pitchr[1] = pitch[1] =
			    (DISPALIGN(size[1].w, align[1])) << 1;
			pitchr[2] = pitch[2] =
			    (DISPALIGN(size[2].w, align[2])) << 1;

			lay_laddr[0] = DISPALIGN(size[0].w, align[0]) + addr[0];
			lay_laddr[1] = DISPALIGN(size[1].w, align[1]) + addr[1];
			lay_laddr[2] = DISPALIGN(size[2].w, align[2]) + addr[2];
		}
	} else if (data_type == 0x0)
		/* interleaved */
	{
		if (trdinmode == DE_3D_SRC_MODE_FP) {
			pitchr[0] = pitch[0] =
			    DISPALIGN(size[0].w * ycnt, align[0]) / ycnt;
			pitchr[1] = pitch[1] = 0;
			pitchr[2] = pitch[2] = 0;

			lay_laddr[0] = trd_addr[0];
			lay_laddr[1] = 0;
			lay_laddr[2] = 0;
		} else if (trdinmode == DE_3D_SRC_MODE_TB) {
			pitchr[0] = pitch[0] =
			    DISPALIGN(size[0].w * ycnt, align[0]) / ycnt;
			pitchr[1] = pitch[1] = 0;
			pitchr[2] = pitch[2] = 0;

			lay_laddr[0] = pitch[0] * image_h0 * ycnt + addr[0];
			lay_laddr[1] = 0;
			lay_laddr[2] = 0;
		} else if ((trdinmode == DE_3D_SRC_MODE_SSF)
			   || (trdinmode == DE_3D_SRC_MODE_SSH)) {

			pitchr[0] = pitch[0] =
			    DISPALIGN(size[0].w * ycnt, align[0]) / ycnt;
			pitchr[1] = pitch[1] = 0;
			pitchr[2] = pitch[2] = 0;

			lay_laddr[0] = image_w0 * ycnt + addr[0];
			lay_laddr[1] = 0;
			lay_laddr[2] = 0;
		} else if (trdinmode == DE_3D_SRC_MODE_LI) {
			pitchr[0] = pitch[0] =
			    (DISPALIGN(size[0].w, align[0])) << 1;
			pitchr[1] = pitch[1] = 0;
			pitchr[2] = pitch[2] = 0;

			lay_laddr[0] =
			    (DISPALIGN(size[0].w, align[0])) * ycnt + addr[0];
			lay_laddr[1] = 0;
			lay_laddr[2] = 0;
		}
	} else if (data_type == 0x1)
		/* semi-planar */
	{
		if ((trdinmode == DE_3D_SRC_MODE_SSF)
		    || (trdinmode == DE_3D_SRC_MODE_SSH)) {
			pitchr[0] = pitch[0] = DISPALIGN(size[0].w, align[0]);
			pitchr[1] = pitch[1] = DISPALIGN(size[1].w, align[1]);
			pitchr[2] = pitch[2] = 0;

			lay_laddr[0] = image_w0 + addr[0];
			lay_laddr[1] = (image_w1 * ucnt) + addr[1];
			lay_laddr[2] = 0;
		} else if (trdinmode == DE_3D_SRC_MODE_TB) {
			pitchr[0] = pitch[0] = DISPALIGN(size[0].w, align[0]);
			pitchr[1] = pitch[1] = DISPALIGN(size[1].w, align[1]);
			pitchr[2] = pitch[2] = 0;

			lay_laddr[0] = pitch[0] * image_h0 + addr[0];
			lay_laddr[1] = pitch[1] * image_h1 * ucnt + addr[1];
			lay_laddr[2] = 0;
		} else if (trdinmode == DE_3D_SRC_MODE_FP) {
			pitchr[0] = pitch[0] = DISPALIGN(size[0].w, align[0]);
			pitchr[1] = pitch[1] = DISPALIGN(size[1].w, align[1]);
			pitchr[2] = pitch[2] = 0;

			lay_laddr[0] = trd_addr[0];
			lay_laddr[1] = trd_addr[1];
			lay_laddr[2] = 0;
		} else if (trdinmode == DE_3D_SRC_MODE_LI) {
			pitchr[0] = pitch[0] =
			    (DISPALIGN(size[0].w, align[0])) << 1;
			pitchr[1] = pitch[1] =
			    (DISPALIGN(size[1].w, align[1])) << 1;
			pitchr[2] = pitch[2] = 0;

			lay_laddr[0] = addr[0] + DISPALIGN(size[1].w, align[1]);
			lay_laddr[1] =
			    addr[1] + (DISPALIGN(size[1].w, align[1])) * ucnt;
			lay_laddr[2] = 0;
		}
	}

	return 0;
}

int de_rtmx_get_li_addr_offset(unsigned int size, unsigned int align,
			       unsigned int x, unsigned int y, unsigned int cnt)
{
	unsigned int offset;

	offset = DISPALIGN(size, align) * (y >> 1) + x * cnt;

	return offset;
}

int de_rtmx_get_3d_out(struct de_rect frame0, unsigned int scn_w,
			unsigned int scn_h, enum de_3d_out_mode trdoutmode,
			struct de_rect *frame1)
{
	switch (trdoutmode) {
	case DE_3D_OUT_MODE_CI_1:
	case DE_3D_OUT_MODE_CI_2:
	case DE_3D_OUT_MODE_CI_3:
	case DE_3D_OUT_MODE_CI_4:
	case DE_3D_OUT_MODE_SSF:
	case DE_3D_OUT_MODE_SSH:
		{
			frame1->x = frame0.x + scn_w;
			frame1->y = frame0.y;
			frame1->w = frame0.w;
			frame1->h = frame0.h;
			break;
		}
	case DE_3D_OUT_MODE_TB:
	case DE_3D_OUT_MODE_FP:
		{
			frame1->x = frame0.x;
			frame1->y = frame0.y + (scn_h >> 1);
			frame1->w = frame0.w;
			frame1->h = frame0.h;
			break;
		}
	case DE_3D_OUT_MODE_LI:
		/* enable remapping */
		{
			frame1->x = frame0.x + scn_w;
			frame1->y = frame0.y;
			frame1->w = frame0.w;
			frame1->h = frame0.h;
			break;
		}
	case DE_3D_OUT_MODE_LIRGB:
		/* enable remapp */
		{
			frame1->x = frame0.x;
			frame1->y = frame0.y + scn_h;
			frame1->w = frame0.w;
			frame1->h = frame0.h;
			break;
		}
	default:
		break;
	}
	__inf("frame0=<%d,%d,%d,%d>\n", frame0.x, frame0.y, frame0.w, frame0.h);
	__inf("frame1=<%d,%d,%d,%d>\n", frame1->x, frame1->y, frame1->w,
	      frame1->h);

	return 0;
}

int de_rtmx_set_lay_fcolor(unsigned int sel, unsigned int chno,
			   unsigned int layno, unsigned char en,
			   unsigned char fmt, unsigned int color)
{
	unsigned int Y, U, V;
	int vi_chno = de_feat_get_num_vi_chns(sel);

	if (chno >= vi_chno) {
		de200_rtmx[sel].ui_ovl[chno - vi_chno]
		    ->ui_lay_cfg[layno].lay_fcolor.dwval = en ? color : 0;

		ui_attr_block[sel][chno - vi_chno][layno].dirty = 1;
	} else {
		Y = color & 0xff0000;
		switch (fmt) {
		case DE_FORMAT_YUV422_I_UYVY:
		case DE_FORMAT_YUV422_I_YUYV:
		case DE_FORMAT_YUV422_SP_UVUV:
		case DE_FORMAT_YUV420_SP_UVUV:
		case DE_FORMAT_YUV411_SP_UVUV:
			U = (color & 0xff) << 8;
			V = (color & 0xff00) >> 8;
			break;
		default:
			U = (color & 0xff00);
			V = (color & 0xff);
			break;
		}
		de200_rtmx[sel].vi_ovl[chno]->vi_lay_fcolor[layno].dwval = en ?
		    ((0xFF << 24) | Y | U | V) : 0;

		vi_fc_block[sel][chno].dirty = 1;
	}

	return 0;
}

int de_rtmx_set_overlay_size(unsigned int sel, unsigned int chno,
			     unsigned int w, unsigned int h)
{
	int vi_chno = de_feat_get_num_vi_chns(sel);

	if (chno >= vi_chno) {
		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_ovl_size.bits.ovl_width =
		    w == 0 ? 0 : w - 1;
		de200_rtmx[sel].ui_ovl[chno -
				       vi_chno]->ui_ovl_size.bits.ovl_height =
		    h == 0 ? 0 : h - 1;

		ui_size_block[sel][chno - vi_chno].dirty = 1;
	} else {
		de200_rtmx[sel].vi_ovl[chno]->vi_ovl_size[0].bits.ovl_width =
		    w == 0 ? 0 : w - 1;
		de200_rtmx[sel].vi_ovl[chno]->vi_ovl_size[0].bits.ovl_height =
		    h == 0 ? 0 : h - 1;

		vi_size_block[sel][chno].dirty = 1;
	}

	return 0;
}

static int de_rtmx_get_coarse_fac(unsigned int sel, unsigned int ovl_w,
				  unsigned int ovl_h, unsigned int vsu_outw,
				  unsigned int vsu_outh, unsigned int fmt,
				  unsigned int lcd_fps, unsigned int lcd_height,
				  unsigned int de_freq_mhz, unsigned int *yhm,
				  unsigned int *yhn, unsigned int *yvm,
				  unsigned int *yvn, unsigned int *chm,
				  unsigned int *chn, unsigned int *cvm,
				  unsigned int *cvn, unsigned int *midyw,
				  unsigned int *midyh, unsigned int *midcw,
				  unsigned int *midch)
{
	unsigned int format, wshift, hshift, status;
	unsigned int tmpyhm, tmpyhn, tmpyvm, tmpyvn;
	unsigned int tmp, required_speed_ability;
	unsigned long long update_speed_ability;
	unsigned int linebuf = 2048;

	/* 0-422, 1-420, 2-411, 3-no mean */
	switch (fmt) {
	case DE_FORMAT_YUV422_I_YVYU:
	case DE_FORMAT_YUV422_I_YUYV:
	case DE_FORMAT_YUV422_I_UYVY:
	case DE_FORMAT_YUV422_I_VYUY:
	case DE_FORMAT_YUV422_P:
	case DE_FORMAT_YUV422_SP_UVUV:
	case DE_FORMAT_YUV422_SP_VUVU:
		format = 0;
		break;
	case DE_FORMAT_YUV420_P:
	case DE_FORMAT_YUV420_SP_UVUV:
	case DE_FORMAT_YUV420_SP_VUVU:
		format = 1;
		break;
	case DE_FORMAT_YUV411_P:
	case DE_FORMAT_YUV411_SP_UVUV:
	case DE_FORMAT_YUV411_SP_VUVU:
		format = 2;
		break;
	default:
		format = 3;
		break;
	}

	if (format == 0) {
		wshift = 1;
		hshift = 0;
	} else if (format == 1) {
		wshift = 1;
		hshift = 1;
	} else if (format == 2) {
		wshift = 2;
		hshift = 0;
	} else {
		wshift = 0;
		hshift = 0;
	}

	/* floor Y channel size */
	ovl_w = ovl_w & (~((1 << wshift) - 1));
	ovl_h = ovl_h & (~((1 << hshift) - 1));

	status = 0x0;
	*yhm = 0;
	*yhn = 0;
	*chm = 0;
	*chn = 0;
	*midyw = ovl_w;
	*midcw = ovl_w >> wshift;
	/* add for UI size not scaler */
	if ((format > 2) && (ovl_w == vsu_outw) && (ovl_h == vsu_outh)) {
		*yvm = 0;
		*yvn = 0;
		*cvm = 0;
		*cvn = 0;
		*midyh = ovl_h;
		*midch = ovl_h >> hshift;
		return status;
	}

	linebuf = de_feat_get_scale_linebuf(sel);
	if ((ovl_w > linebuf)
	    && (ovl_w > 8 * vsu_outw)) {
		tmpyhn = (linebuf < (8 * vsu_outw)) ?
		    linebuf : (8 * vsu_outw);
		status = 0x1;
	/* horizontal Y channel */
	} else if (ovl_w > linebuf) {
		tmpyhn = linebuf;
		status = 0x1;
	} else if (ovl_w > 8 * vsu_outw) {
		tmpyhn = 8 * vsu_outw;
		status = 0x1;
	}

	if (status == 0x1) {
		tmpyhn = tmpyhn & (~((1 << wshift) - 1));
		tmpyhm = ovl_w;
		*yhm = tmpyhm;
		*yhn = tmpyhn;
		*chm = *yhm;
		*chn = *yhn;

		/* actually fetch horizontal pixel Y channel */
		*midyw = tmpyhn;

		/* actually fetch horizontal pixel C channel */
		*midcw = tmpyhn >> wshift;
	}

/*lcd_freq_MHz = lcd_width*lcd_height*lcd_fps/1000000;
 *
 *how many overlay line can be fetched during scanning
 *  one lcd line(consider 80% dram efficiency)
 *update_speed_ability = lcd_width*de_freq_mhz*125/(ovl_w*lcd_freq_MHz);
 */
/* how many overlay line can be fetched
 * during scanning one lcd line(consider 80% dram efficiency)
 */
	tmp = lcd_height * lcd_fps * (ovl_w > vsu_outw ? ovl_w : vsu_outw);
	if (tmp != 0) {
		update_speed_ability =
		    ((unsigned long long)de_freq_mhz * 80000000);
		do_div(update_speed_ability, tmp);
	} else
		update_speed_ability = 0;

/* how many overlay line need to fetch during scanning one lcd line */
	required_speed_ability = vsu_outh == 0 ? 0 : ovl_h * 100 / vsu_outh;

	__inf("%d,%d,%d,%d\n", de_freq_mhz, tmp, vsu_outh, ovl_h);
	__inf("%lld,%d\n", update_speed_ability, required_speed_ability);

	/* vertical Y channel */
	if (update_speed_ability < required_speed_ability) {
		/* if ability < required, use coarse scale */
		unsigned long long tmp2 = update_speed_ability * vsu_outh;

		do_div(tmp2, 100);
		tmpyvn = tmp == 0 ? 0 : (unsigned int)tmp2;
		tmpyvn = tmpyvn & (~((1 << hshift) - 1));
		tmpyvm = ovl_h;
		*yvm = tmpyvm;
		*yvn = tmpyvn;
		*cvm = *yvm;
		*cvn = *yvn;

		/* actually fetch vertical pixel Y channel */
		*midyh = tmpyvn;

		/* actually fetch vertical pixel C channel */
		*midch = tmpyvn >> hshift;
		status |= (0x1 << 1);
	} else if (ovl_h > 4 * vsu_outh) {
		/* to save dram bandwidth when scale down factor more than 4. */
		tmpyvn = 4 * vsu_outh;
		tmpyvn = tmpyvn & (~((1 << hshift) - 1));
		tmpyvm = ovl_h;
		*yvm = tmpyvm;
		*yvn = tmpyvn;
		*cvm = *yvm;
		*cvn = *yvn;

		/* actually fetch vertical pixel Y channel */
		*midyh = tmpyvn;

		/* actually fetch vertical pixel C channel */
		*midch = tmpyvn >> hshift;
		status |= (0x1 << 1);
	} else {
		*yvm = 0;
		*yvn = 0;
		*cvm = 0;
		*cvn = 0;
		*midyh = ovl_h;
		*midch = ovl_h >> hshift;
	}

	return status;
}

/**
 *function   : de_rtmx_set_coarse_fac(unsigned int sel, unsigned int fmt,
 *             unsigned int ovl_w, unsigned int ovl_h,unsigned int vsu_outw,
 *             unsigned int vsu_outh, unsigned int *midyw, unsigned int *midyh,
 *             unsigned int *midcw, unsigned int *midch)
 *description: set de reg base
 *parameters :
 *             sel                                 <rtmx select>
 *             fmt                                 <layer data format>
 *             ovl_w,ovl_h                 <overlay output size>
 *             vsu_outw,vsu_outh   <vsu output size>
 *             *midyw,*midyh               <vsu inputput y size>
 *             *midcw,*midch               <vsu inputput cbcr size>
 *return     :
 *             success
 */
int de_rtmx_set_coarse_fac(unsigned int sel, unsigned char chno,
			   unsigned int fmt, unsigned int lcd_fps,
			   unsigned int lcd_height, unsigned int de_freq_mhz,
			   unsigned int ovl_w, unsigned int ovl_h,
			   unsigned int vsu_outw, unsigned int vsu_outh,
			   unsigned int *midyw, unsigned int *midyh,
			   unsigned int *midcw, unsigned int *midch)
{
	unsigned int yhm, yhn, yvm, yvn, chm, chn, cvm, cvn;
	int status;

	status =
	    de_rtmx_get_coarse_fac(sel, ovl_w, ovl_h, vsu_outw, vsu_outh, fmt,
				   lcd_fps, lcd_height, de_freq_mhz, &yhm, &yhn,
				   &yvm, &yvn, &chm, &chn, &cvm, &cvn, midyw,
				   midyh, midcw, midch);

	de200_rtmx[sel].vi_ovl[chno]->vi_hori_ds[0].bits.m = yhm;
	de200_rtmx[sel].vi_ovl[chno]->vi_hori_ds[0].bits.n = yhn;

	de200_rtmx[sel].vi_ovl[chno]->vi_hori_ds[1].bits.m = chm;
	de200_rtmx[sel].vi_ovl[chno]->vi_hori_ds[1].bits.n = chn;

	de200_rtmx[sel].vi_ovl[chno]->vi_vert_ds[0].bits.m = yvm;
	de200_rtmx[sel].vi_ovl[chno]->vi_vert_ds[0].bits.n = yvn;

	de200_rtmx[sel].vi_ovl[chno]->vi_vert_ds[1].bits.m = cvm;
	de200_rtmx[sel].vi_ovl[chno]->vi_vert_ds[1].bits.n = cvn;

	vi_size_block[sel][chno].dirty = 1;

	return status;
}

int de_rtmx_set_pf_en(unsigned int sel, unsigned char *pen)
{
	unsigned char fen[4] = { 1, 0, 0, 0 };

	de200_rtmx[sel].bld_ctl->bld_fcolor_ctl.bits.p0_en = pen[0];
	de200_rtmx[sel].bld_ctl->bld_fcolor_ctl.bits.p1_en = pen[1];
	de200_rtmx[sel].bld_ctl->bld_fcolor_ctl.bits.p2_en = pen[2];
	de200_rtmx[sel].bld_ctl->bld_fcolor_ctl.bits.p3_en = pen[3];

	de200_rtmx[sel].bld_ctl->bld_fcolor_ctl.bits.p0_fcolor_en = fen[0];
	de200_rtmx[sel].bld_ctl->bld_fcolor_ctl.bits.p1_fcolor_en = fen[1];
	de200_rtmx[sel].bld_ctl->bld_fcolor_ctl.bits.p2_fcolor_en = fen[2];
	de200_rtmx[sel].bld_ctl->bld_fcolor_ctl.bits.p3_fcolor_en = fen[3];

	bld_attr_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_set_pipe_cfg(unsigned int sel, unsigned char pno,
			 unsigned int color, struct de_rect bldrc)
{
	/* fix the pipe fill color to 0xff000000(alpha=1)
	 * actually, we just want to fix the fill color of the bottom pipe
	 * so only the fill color function of the bottom pipe is enabled
	 * cause:
	 * co = cs + cb * (1 - as),
	 * ao = as + ab * (1 - as),
	 * Co(result) = co / ao
	 * when ab = 0, the result is   ( Cs );
	 *  when 1, the result is ( Cs * as ), this is what we want.
	 */
	de200_rtmx[sel].bld_ctl->bld_pipe_attr[pno].fcolor.dwval =
	    0xff000000 | color;
	de200_rtmx[sel].bld_ctl->bld_pipe_attr[pno].insize.bits.width =
	    bldrc.w == 0 ? 0 : bldrc.w - 1;
	de200_rtmx[sel].bld_ctl->bld_pipe_attr[pno].insize.bits.height =
	    bldrc.h == 0 ? 0 : bldrc.h - 1;
	de200_rtmx[sel].bld_ctl->bld_pipe_attr[pno].offset.bits.coorx = bldrc.x;
	de200_rtmx[sel].bld_ctl->bld_pipe_attr[pno].offset.bits.coory = bldrc.y;

	bld_attr_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_set_route(unsigned int sel, unsigned char pno, unsigned int zoder)
{
	unsigned int route;

	route =
	    de200_rtmx[sel].bld_ctl->bld_route_ctl.dwval
	    & (~(0xf << (pno << 2)));
	__inf("sel%d, pno%d, zorder%d, route:0x%x\n", sel, pno, zoder, route);
	de200_rtmx[sel].bld_ctl->bld_route_ctl.dwval =
	    route | (zoder << (pno << 2));
	__inf("addr=0x%p, reg=0x%x\n", &de200_rtmx[sel].bld_ctl->bld_route_ctl,
	      de200_rtmx[sel].bld_ctl->bld_route_ctl.dwval);

	bld_ctl_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_set_premul(unsigned int sel, unsigned char pno,
		       unsigned int pre_mul)
{
	unsigned int pre_mode;

	pre_mode =
	    de200_rtmx[sel].bld_ctl->bld_premultiply_ctl.dwval
	    & (~(0x1 << pno));
	de200_rtmx[sel].bld_ctl->bld_premultiply_ctl.dwval =
	    pre_mode | (pre_mul << pno);

	bld_ctl_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_set_background_color(unsigned int sel, unsigned int color)
{

	de200_rtmx[sel].bld_ctl->bld_bkcolor.dwval =
	    (0xff << 24) | (color & 0xffffff);

	bld_ctl_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_set_blend_size(unsigned int sel, unsigned int w, unsigned int h)
{
	de200_rtmx[sel].bld_ctl->bld_output_size.bits.width =
	    w == 0 ? 0 : w - 1;
	de200_rtmx[sel].bld_ctl->bld_output_size.bits.height =
	    h == 0 ? 0 : h - 1;

	bld_ctl_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_set_blend_mode(unsigned int sel, unsigned int bldno,
			   unsigned char mode)
{
	unsigned int bld_mode;

	if (mode == DE_BLD_CLEAR)
		bld_mode = 0x00000000;
	else if (mode == DE_BLD_SRC)
		bld_mode = 0x00010001;
	else if (mode == DE_BLD_DST)
		bld_mode = 0x01000100;
	else if (mode == DE_BLD_SRCOVER)
		bld_mode = 0x03010301;
	else if (mode == DE_BLD_DSTOVER)
		bld_mode = 0x01030103;
	else if (mode == DE_BLD_SRCIN)
		bld_mode = 0x00020002;
	else if (mode == DE_BLD_DSTIN)
		bld_mode = 0x02000200;
	else if (mode == DE_BLD_SRCOUT)
		bld_mode = 0x00030003;
	else if (mode == DE_BLD_DSTOUT)
		bld_mode = 0x03000300;
	else if (mode == DE_BLD_SRCATOP)
		bld_mode = 0x03020302;
	else if (mode == DE_BLD_DSTATOP)
		bld_mode = 0x02030203;
	else if (mode == DE_BLD_XOR)
		bld_mode = 0x03030303;
	else
		bld_mode = 0x03010301;

	de200_rtmx[sel].bld_ctl->bld_mode[bldno].dwval = bld_mode;

	bld_ctl_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_set_blend_color(unsigned int sel, unsigned int bldno,
			    unsigned int color)
{
	de200_rtmx[sel].bld_ctl->bld_pipe_attr[bldno].fcolor.dwval =
	    (0xff << 24) | (color & 0xffffff);
	bld_attr_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_set_outitl(unsigned int sel, unsigned char interlace_en)
{

	de200_rtmx[sel].bld_ctl->bld_out_ctl.bits.interlace_en =
	    interlace_en & 0x1;
	de200_rtmx[sel].bld_ctl->bld_out_ctl.bits.premultiply_en = 0x0;

	bld_out_block[sel].dirty = 1;

	return 0;
}

int de_rtmx_set_colorkey(unsigned int sel, unsigned char ck_no,
			 unsigned char ck_mode, unsigned char ck_red_match,
			 unsigned char ck_green_match,
			 unsigned char ck_blue_match, unsigned int ck_max,
			 unsigned int ck_min)
{
	unsigned int tmp, ck_match;

	tmp =
	    de200_rtmx[sel].bld_ctl->bld_ck_ctl.
	    dwval & (~(0x6 << (0x2 << ck_no)));
	de200_rtmx[sel].bld_ctl->bld_ck_ctl.dwval =
	    tmp | (ck_mode << (0x2 << (ck_no + 0x1)));

	ck_match = (ck_red_match << 2) | (ck_green_match << 1) | ck_blue_match;
	tmp =
	    de200_rtmx[sel].bld_ctl->bld_ck_cfg.
	    dwval & (~(0x7 << (ck_no << 8)));
	de200_rtmx[sel].bld_ctl->bld_ck_ctl.dwval =
	    tmp | (ck_match << (ck_no << 8));

	de200_rtmx[sel].bld_ctl->bld_ck_max[ck_no].dwval = ck_max & 0xffffff;
	de200_rtmx[sel].bld_ctl->bld_ck_min[ck_no].dwval = ck_min & 0xffffff;

	bld_ck_block[sel].dirty = 1;

	return 0;
}

struct de_rect de_rtmx_extend_rect(struct de_rect rc1, struct de_rect rc2)
{
	struct de_rect rc;
	int xmax, ymax;

	if ((rc1.w == 0) || (rc1.h == 0))
		return rc2;
	rc.x = min2(rc1.x, rc2.x);
	rc.y = min2(rc1.y, rc2.y);

	xmax = max2(rc1.x + rc1.w, rc2.x + rc2.w);
	ymax = max2(rc1.y + rc1.h, rc2.y + rc2.h);

	rc.w = xmax - rc.x;
	rc.h = ymax - rc.y;

	return rc;
}

int de_rtmx_calc_chnrect(unsigned char *lay_en, int laynum,
	struct de_rect *frame, struct de_rect *crop, int gsu_sel,
	struct scaler_para *step, struct de_rect *layer,
	struct de_rect *bld_rect, unsigned int *ovlw, unsigned int *ovlh)
{
	unsigned int i, minx, miny, pipe_en;
	struct de_rect RCOVL = { 0, 0, 0, 0 };
	struct de_rect RCBLD = { 0, 0, 0, 0 };

	minx = 0xffffffff;
	miny = 0xffffffff;

	/* find min cord */
	for (i = 0; i < laynum; i++) {
		if (lay_en[i]) {
			minx = min2(frame[i].x, minx);
			miny = min2(frame[i].y, miny);
		}
	}

	/* recall the layer cord by sub */
	for (i = 0; i < laynum; i++) {
		if (lay_en[i]) {
			layer[i].x =
			    de_calc_ovl_coord(frame[i].x - minx, step[i].hstep,
				      gsu_sel);
			layer[i].y =
			    de_calc_ovl_coord(frame[i].y - miny, step[i].vstep,
				      gsu_sel);
			layer[i].w = crop[i].w;
			layer[i].h = crop[i].h;
			__inf("layernum=%d, i=%d\n", laynum, i);
			__inf("crop=<%d,%d,%d,%d>\n", crop[i].x, crop[i].y,
			      crop[i].w, crop[i].h);
			__inf("layer=<%d,%d,%d,%d>\n", layer[i].x, layer[i].y,
			      layer[i].w, layer[i].h);
		}
	}

	for (i = 0; i < laynum; i++) {
		if (lay_en[i]) {
			RCOVL = de_rtmx_extend_rect(RCOVL, layer[i]);
			RCBLD = de_rtmx_extend_rect(RCBLD, frame[i]);
			__inf("ovl_rect=<%d,%d,%d,%d>\n", RCOVL.x, RCOVL.y,
			      RCOVL.w, RCOVL.h);
			__inf("bld_rect=<%d,%d,%d,%d>\n", RCBLD.x, RCBLD.y,
			      RCBLD.w, RCBLD.h);
		}
	}

	*ovlw = RCOVL.w;
	*ovlh = RCOVL.h;

	bld_rect->x = RCBLD.x;
	bld_rect->y = RCBLD.y;
	bld_rect->w = RCBLD.w;
	bld_rect->h = RCBLD.h;

	pipe_en = 1;
	if ((RCBLD.w == 0) || (RCBLD.h == 0))
		pipe_en = 0;

	return pipe_en;
}

/* ycbcr odd/even */
int de_rtmx_trimcoord(struct de_rect *frame, struct de_rect *crop,
		unsigned int outw, unsigned int outh, int xratio, int yratio)
{
	int left, right, up, down;
	int cut_up, cut_down, cut_left, cut_right;
	int hstep, vstep, hphase, vphase;

	if ((frame->w == 0) || (frame->h == 0)) {
		hstep = vstep = 0;
		hphase = vphase = 0;
		xratio = hstep;
		yratio = vstep;

		return 0;
	}
	/* calculate scaler step size */
	hstep = (crop->w << 18) / frame->w;
	vstep = (crop->h << 18) / frame->h;

	/* calculate scaling ratio */
	xratio = hstep;
	yratio = vstep;

	/* assume only frame coordinate has negative value */
	left = up = 0;
	cut_left = cut_right = cut_up = cut_down = 0;
	if (((frame->x + (int)frame->w) < 0) || ((frame->x - outw) > 0)) {
		/* out of screen */
		frame->w = frame->x = 0;
	} else if (frame->x < 0) {
		/* cut left */
		left = (((-frame->x) * crop->w) << 18) / frame->w;
		cut_left = (int)(left >> 18);

		frame->w += frame->x;
		frame->x = 0;
	} else if ((frame->x + frame->w) > outw) {
		/* cut right */
		right =
		    (((frame->x + frame->w - outw) * crop->h) << 18) / frame->h;
		cut_right = (int)(right >> 18);

		frame->w = outw - frame->x;
	}
	crop->x += cut_left;
	crop->w -= (cut_left + cut_right);
	hphase = (int)(left & 0x3ffff);

	if (((frame->y + (int)frame->h) < 0) || ((frame->y - outh) > 0)) {
		/* out of screen */
		frame->h = frame->y = 0;
	} else if (frame->y < 0) {
		/* cut up */
		up = (((-frame->y) * crop->h) << 18) / frame->h;
		cut_up = (int)(up >> 18);

		frame->h += frame->y;
		frame->y = 0;
	} else if ((frame->y + frame->h) > outh) {
		/* cut down */
		down =
		    (((frame->y + frame->h - outh) * crop->h) << 18) / frame->h;
		cut_down = (int)(down >> 18);

		frame->h = outh - frame->y;
	}
	crop->y += cut_up;
	crop->h -= (cut_up + cut_down);
	vphase = (int)(up & 0x3ffff);

	return 0;
}

int de_rtmx_get_premul_ctl(int laynum, unsigned char *premul)
{
	int i, same, pipe_mode;

	same = 0;
	pipe_mode = 1;
	for (i = 0; i < laynum; i++)
		same += premul[i];

	for (i = 0; i < laynum; i++) {
		if (premul[i]) {
			premul[i] = 2;
		} else if (same == 0)
			/* all zero */
		{
			pipe_mode = 0;
			premul[i] = 0;
		} else {
			premul[i] = 1;
		}
	}

	return pipe_mode;
}

int de_rtmx_mux(unsigned int sel, unsigned int tcon_index)
{
	u32 reg_val;

	if (sel == tcon_index) {
		reg_val = readl((void __iomem *)(de_base + 0x10));
		reg_val &= ~0x1;
		writel(reg_val, (void __iomem *)(de_base + 0x10));
	} else {
		reg_val = readl((void __iomem *)(de_base + 0x10));
		reg_val |= 0x1;
		writel(reg_val, (void __iomem *)(de_base + 0x10));
	}

	return 0;
}

int de_rtmx_get_mux(unsigned int sel)
{
	u32 reg_val;

	reg_val = readl((void __iomem *)(de_base + 0x10));
	reg_val &= 0x1;

	return (reg_val == 0) ? (sel) : (1 - sel);
}

int de_rtmx_sync_hw(unsigned int sel)
{
	int i, j, ui_chno, vi_chno, layno;

	vi_chno = de_feat_get_num_vi_chns(sel);
	ui_chno = de_feat_get_num_ui_chns(sel);
	layno = LAYER_MAX_NUM_PER_CHN;

	memcpy(glb_ctl_block[sel].val, (void *)glb_ctl_block[sel].off,
	       glb_ctl_block[sel].size);

	for (j = 0; j < vi_chno; j++) {
		for (i = 0; i < layno; i++) {
			memcpy(vi_attr_block[sel][j][i].val,
			       (void *)vi_attr_block[sel][j][i].off,
			       vi_attr_block[sel][j][i].size);
		}

		memcpy(vi_fc_block[sel][j].val,
		    (void *)vi_fc_block[sel][j].off,
		    vi_fc_block[sel][j].size);

		memcpy(vi_haddr_block[sel][j].val,
		    (void *)vi_haddr_block[sel][j].off,
		    vi_haddr_block[sel][j].size);

		memcpy(vi_size_block[sel][j].val,
		    (void *)vi_size_block[sel][j].off,
		    vi_size_block[sel][j].size);
	}

	for (j = 0; j < ui_chno; j++) {
		for (i = 0; i < layno; i++) {
			memcpy(ui_attr_block[sel][j][i].val,
			    (void *)ui_attr_block[sel][j][i].off,
			    ui_attr_block[sel][j][i].size);
		}

		memcpy(ui_haddr_block[sel][j].val,
		    (void *)ui_haddr_block[sel][j].off,
		    ui_haddr_block[sel][j].size);

		memcpy(ui_size_block[sel][j].val,
		    (void *)ui_size_block[sel][j].off,
		    ui_size_block[sel][j].size);
	}

	memcpy(bld_attr_block[sel].val,
	    (void *)bld_attr_block[sel].off,
	    bld_attr_block[sel].size);

	memcpy(bld_ctl_block[sel].val,
	    (void *)bld_ctl_block[sel].off,
	    bld_ctl_block[sel].size);

	memcpy(bld_ck_block[sel].val,
	    (void *)bld_ck_block[sel].off,
	    bld_ck_block[sel].size);

	memcpy(bld_out_block[sel].val,
	    (void *)bld_out_block[sel].off,
	    bld_out_block[sel].size);

	return 0;
}

int de_rtmx_get_lay_enabled(unsigned int sel, unsigned int chno,
			    unsigned int layno)
{
	int vi_chno = de_feat_get_num_vi_chns(sel);
	int ret = 0;

	if (chno >= vi_chno) {
		ret =
		    de200_rtmx[sel].ui_ovl[chno - vi_chno]
		    ->ui_lay_cfg[layno].lay_attr.bits.lay_en;
	} else {
		ret =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno]
		    .lay_attr.bits.lay_en;
	}

	return ret;
}

int de_rtmx_get_lay_address(unsigned int sel, unsigned int chno,
			    unsigned int layno, unsigned long long *addr)
{
	int vi_chno = de_feat_get_num_vi_chns(sel);
	int ret = 0;
	unsigned long long tmp;

	if (chno >= vi_chno) {
		addr[0] = de200_rtmx[sel].ui_ovl[chno - vi_chno]->
		ui_lay_cfg[layno].lay_top_laddr.dwval;
		/* low address */
		tmp = de200_rtmx[sel].ui_ovl[chno - vi_chno]
		->ui_lay_top_haddr.dwval & (0xff << layno);
		/* high address */
		addr[0] |= tmp << 32;
		addr[1] = 0;
		addr[2] = 0;
	} else {
		addr[0] =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_top_laddr[0].dwval;
		addr[1] =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_top_laddr[1].dwval;
		addr[2] =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_top_laddr[2].dwval;

		tmp = de200_rtmx[sel].vi_ovl[chno]->vi_lay_top_haddr[0].dwval
		& (0xff << layno);
		/* high address */
		addr[0] |= tmp << 32;
		tmp =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_top_haddr[1].dwval
		    & (0xff << layno);
		addr[1] |= tmp << 32;
		tmp =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_top_haddr[2].dwval
		    & (0xff << layno);
		addr[2] |= tmp << 32;
	}

	return ret;
}

int de_rtmx_get_lay_size(unsigned int sel, unsigned int chno,
			 unsigned int layno, struct disp_rectsz *size)
{
	int vi_chno = de_feat_get_num_vi_chns(sel);
	int ret = 0;
	int fmt, ycnt = 4, ucnt = 2;

	if (chno >= vi_chno) {
		fmt =
		    de200_rtmx[sel].ui_ovl[chno -
					   vi_chno]->ui_lay_cfg[layno].lay_attr.
		    bits.lay_fmt;
		if (fmt <= DE_FORMAT_BGRX_8888)
			ycnt = 4;
		else if (fmt <= DE_FORMAT_BGR_888)
			ycnt = 3;
		else if (fmt <= DE_FORMAT_BGRA_5551)
			ycnt = 2;
		else
			ycnt = 4;

		size[0].width = de200_rtmx[sel].ui_ovl[chno - vi_chno]->
		ui_lay_cfg[layno].lay_pitch.dwval / ycnt;
		/* fixme,according to format */
		size[0].height =
		    de200_rtmx[sel].ui_ovl[chno - vi_chno]
		    ->ui_lay_cfg[layno].lay_size.bits.lay_height;
	} else {
		fmt =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_attr.
		    bits.lay_fmt;
		if (fmt <= DE_FORMAT_BGRX_8888) {
			ycnt = 4;
		} else if (fmt <= DE_FORMAT_BGR_888) {
			ycnt = 3;
		} else if (fmt <= DE_FORMAT_BGRA_5551) {
			ycnt = 2;
		} else if (fmt <= DE_FORMAT_YUV422_I_VYUY) {
			ycnt = 2;
		} else if (fmt == DE_FORMAT_YUV422_P) {
			ycnt = 1;
			ucnt = 1;
		}
		/* YUV422 */
		else if (fmt == DE_FORMAT_YUV420_P) {
			ycnt = 1;
			ucnt = 1;
		}
		/* YUV420 */
		else if (fmt == DE_FORMAT_YUV411_P) {
			ycnt = 1;
			ucnt = 1;
		}
		/* YUV411 */
		else if (fmt <= DE_FORMAT_YUV422_SP_VUVU) {
			ycnt = 1;
			ucnt = 2;
		} else if (fmt <= DE_FORMAT_YUV420_SP_VUVU) {
			ycnt = 1;
			ucnt = 2;
		} else if (fmt <= DE_FORMAT_YUV411_SP_VUVU) {
			ycnt = 1;
			ucnt = 2;
		} else {
			ycnt = 4;
		}
		size[0].width =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_pitch[0].dwval / ycnt;
		size[1].width =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_pitch[1].dwval / ucnt;
		size[2].width =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].
		    lay_pitch[2].dwval / ucnt;
		size[0].height =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_size.
		    bits.lay_height;
		size[2].height = size[1].height = size[0].height;
	}

	return ret;
}

int de_rtmx_get_lay_win(unsigned int sel, unsigned int chno, unsigned int layno,
			struct disp_rect *win)
{
	int vi_chno = de_feat_get_num_vi_chns(sel);
	int ret = 0;

	if (chno >= vi_chno) {
		win->width =
		    de200_rtmx[sel].ui_ovl[chno - vi_chno]->ui_lay_cfg[layno].
		    lay_size.bits.lay_width + 1;
		win->height =
		    de200_rtmx[sel].ui_ovl[chno - vi_chno]->ui_lay_cfg[layno].
		    lay_size.bits.lay_height + 1;
	} else {
		win->width =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_size.
		    bits.lay_width + 1;
		win->height =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_size.
		    bits.lay_height + 1;
	}

	return ret;
}

int de_rtmx_get_display_size(unsigned int sel, unsigned int *width,
			     unsigned int *height)
{
	*width = de200_rtmx[sel].glb_ctl->glb_size.bits.width + 1;
	*height = de200_rtmx[sel].glb_ctl->glb_size.bits.height + 1;

	return 0;
}

int de_rtmx_get_lay_format(unsigned int sel, unsigned int chno,
			   unsigned int layno)
{
	int vi_chno = de_feat_get_num_vi_chns(sel);
	int fmt = 0;

	if (chno >= vi_chno) {
		fmt =
		    de200_rtmx[sel].ui_ovl[chno - vi_chno]->ui_lay_cfg[layno].
		    lay_attr.bits.lay_fmt;
	} else {
		fmt =
		    de200_rtmx[sel].vi_ovl[chno]->vi_lay_cfg[layno].lay_attr.
		    bits.lay_fmt;

		if (fmt == 0)
			fmt = DE_FORMAT_YUV422_I_VYUY;
		else if (fmt == 1)
			fmt = DE_FORMAT_YUV422_I_YVYU;
		else if (fmt == 2)
			fmt = DE_FORMAT_YUV422_I_UYVY;
		else if (fmt == 3)
			fmt = DE_FORMAT_YUV422_I_YUYV;
		else if (fmt == 4)
			fmt = DE_FORMAT_YUV422_SP_UVUV;
		else if (fmt == 5)
			fmt = DE_FORMAT_YUV422_SP_VUVU;
		else if (fmt == 6)
			fmt = DE_FORMAT_YUV422_P;
		else if (fmt == 8)
			fmt = DE_FORMAT_YUV420_SP_UVUV;
		else if (fmt == 9)
			fmt = DE_FORMAT_YUV420_SP_VUVU;
		else if (fmt == 0xa)
			fmt = DE_FORMAT_YUV420_P;
		else if (fmt == 0xc)
			fmt = DE_FORMAT_YUV411_SP_UVUV;
		else if (fmt == 0xd)
			fmt = DE_FORMAT_YUV411_SP_VUVU;
		else if (fmt == 0xe)
			fmt = DE_FORMAT_YUV411_P;
	}

	return fmt;
}