[WIP,2/7] drm/exynos: Add Exynosautov9 decon

diff --git a/drivers/gpu/drm/exynos/exynos9_decon.c b/drivers/gpu/drm/exynos/exynos9_decon.c
new file mode 100644
index 000000000000..d51922eeeabd
--- /dev/null
+++ b/drivers/gpu/drm/exynos/exynos9_decon.c
@@ -0,0 +1,1765 @@ 
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <linux/clk.h>
+#include <linux/component.h>
+#include <linux/console.h>
+#include <linux/kernel.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
+#include <linux/of_graph.h>
+#include <linux/platform_device.h>
+#include <linux/irq.h>
+#include <linux/iopoll.h>
+
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_vblank.h>
+#include <drm/drm_mode.h>
+#include <drm/drm_blend.h>
+#include <drm/drm_fourcc.h>
+#include <drm/drm_atomic.h>
+#include <drm/drm_framebuffer.h>
+#include <video/videomode.h>
+
+#include "exynos_drm_fb.h"
+#include "exynos_dpp.h"
+#include "exynos_dpu_dma.h"
+#include "exynos_drm_crtc.h"
+#include "exynos_drm_drv.h"
+#include "exynos_drm_plane.h"
+
+#include "regs-decon9.h"
+
+enum decon_type {
+	EXYNOS9_DECON0 = 0,
+	EXYNOS9_DECON1 = 1,
+	EXYNOS9_DECON2 = 2,
+};
+
+/* PD : Porter-Duff */
+enum decon_blend_pd_func {
+	PD_FUNC_CLEAR = 0x0,
+	PD_FUNC_COPY = 0x1,
+	PD_FUNC_DESTINATION = 0x2,
+	PD_FUNC_SOURCE_OVER = 0x3,
+	PD_FUNC_DESTINATION_OVER = 0x4,
+	PD_FUNC_SOURCE_IN = 0x5,
+	PD_FUNC_DESTINATION_IN = 0x6,
+	PD_FUNC_SOURCE_OUT = 0x7,
+	PD_FUNC_DESTINATION_OUT = 0x8,
+	PD_FUNC_SOURCE_A_TOP = 0x9,
+	PD_FUNC_DESTINATION_A_TOP = 0xa,
+	PD_FUNC_XOR = 0xb,
+	PD_FUNC_PLUS = 0xc,
+	PD_FUNC_USER_DEFINED = 0xd,
+};
+
+/*
+ * ALPHA_MULT_SRC_SEL_ALPHA0 : ALPHA_MULT = WINx_ALPHA_0_F * WINx_ALPHA_0_F
+ * ALPHA_MULT_SRC_SEL_ALPHA1 : ALPHA_MULT = WINx_ALPHA_1_F * WINx_ALPHA_0_F
+ * ALPHA_MULT_SRC_SEL_AF     : ALPHA_MULT = Af (Foreground incoming pixel-alpha) * WINx_ALPHA_0_F
+ * ALPHA_MULT_SRC_SEL_AB     : ALPHA_MULT = Ab (Background incoming pixel-alpha) * WINx_ALPHA_0_F
+ */
+enum decon_blend_alpha_mult_src {
+	ALPHA_MULT_SRC_SEL_ALPHA0 = 0x0,
+	ALPHA_MULT_SRC_SEL_ALPHA1 = 0x1,
+	ALPHA_MULT_SRC_SEL_AF = 0x2,
+	ALPHA_MULT_SRC_SEL_AB = 0x3,
+};
+
+enum decon_blend_mode {
+	DECON_BLENDING_NONE = 0x0,
+	DECON_BLENDING_PREMULT = 0x1,
+	DECON_BLENDING_COVERAGE = 0x2,
+	DECON_BLENDING_MAX = 0x3,
+};
+
+enum decon_win_alpha_coef {
+	BND_COEF_ZERO = 0x0,
+	BND_COEF_ONE = 0x1,
+	BND_COEF_AF = 0x2,
+	BND_COEF_1_M_AF = 0x3,
+	BND_COEF_AB = 0x4,
+	BND_COEF_1_M_AB = 0x5,
+	BND_COEF_PLANE_ALPHA0 = 0x6,
+	BND_COEF_1_M_PLANE_ALPHA0 = 0x7,
+	BND_COEF_PLANE_ALPHA1 = 0x8,
+	BND_COEF_1_M_PLANE_ALPHA1 = 0x9,
+	BND_COEF_ALPHA_MULT = 0xA,
+	BND_COEF_1_M_ALPHA_MULT = 0xB,
+};
+
+enum decon_rgb_order {
+	DECON_RGB = 0x0,
+	DECON_GBR = 0x1,
+	DECON_BRG = 0x2,
+	DECON_BGR = 0x4,
+	DECON_RBG = 0x5,
+	DECON_GRB = 0x6,
+};
+
+enum decon_op_mode {
+	DECON_VIDEO_MODE = 0,
+	DECON_MIPI_COMMAND_MODE = 1,
+	/* TODO: ADD DP command mode */
+};
+
+enum decon_te_mode { DECON_HW_TRIG = 0, DECON_SW_TRIG };
+
+enum decon_set_trig { DECON_TRIG_MASK = 0, DECON_TRIG_UNMASK };
+
+enum decon_te_from {
+	DECON_TE_FROM_DDI0 = 0,
+	DECON_TE_FROM_DDI1 = 1,
+	DECON_TE_FROM_DDI2 = 2,
+	MAX_DECON_TE_FROM_DDI = 3,
+};
+
+enum decon_out_type {
+	DECON_OUT_DSI0 = 1 << 0,
+	DECON_OUT_DSI1 = 1 << 1,
+	DECON_OUT_DSI = DECON_OUT_DSI0 | DECON_OUT_DSI1,
+	DECON_OUT_DP0_SST1 = 1 << 4,
+	DECON_OUT_DP0_SST2 = 1 << 5,
+	DECON_OUT_DP0_SST3 = 1 << 6,
+	DECON_OUT_DP0_SST4 = 1 << 7,
+	DECON_OUT_DP1_SST1 = 1 << 8,
+	DECON_OUT_DP1_SST2 = 1 << 9,
+	DECON_OUT_DP1_SST3 = 1 << 10,
+	DECON_OUT_DP1_SST4 = 1 << 11,
+	DECON_OUT_DP0 = DECON_OUT_DP0_SST1 | DECON_OUT_DP0_SST2 |
+			DECON_OUT_DP0_SST3 | DECON_OUT_DP0_SST4,
+	DECON_OUT_DP1 = DECON_OUT_DP1_SST1 | DECON_OUT_DP1_SST2 |
+			DECON_OUT_DP1_SST3 | DECON_OUT_DP1_SST4,
+	DECON_OUT_DP = DECON_OUT_DP0 | DECON_OUT_DP1,
+
+	DECON_OUT_WB = 1 << 12,
+};
+
+enum decon_dsi_mode {
+	DSI_MODE_SINGLE = 0,
+	DSI_MODE_DUAL_DSI,
+	DSI_MODE_DUAL_DISPLAY,
+	DSI_MODE_NONE
+};
+
+enum decon_irq {
+	DECON_IRQ_FS = 0,
+	DECON_IRQ_FD,
+	DECON_IRQ_EXT,
+	DECON_IRQ_DQE_DIM_S,
+	DECON_IRQ_DQE_DIM_E,
+};
+
+struct decon_mode {
+	enum decon_op_mode op_mode;
+	enum decon_dsi_mode dsi_mode;
+	enum decon_te_mode te_mode;
+};
+
+struct decon_urgent {
+	u32 rd_en;
+	u32 rd_hi_thres;
+	u32 rd_lo_thres;
+	u32 rd_wait_cycle;
+	u32 wr_en;
+	u32 wr_hi_thres;
+	u32 wr_lo_thres;
+	bool dta_en;
+	u32 dta_hi_thres;
+	u32 dta_lo_thres;
+};
+
+struct decon_vendor_pps {
+	unsigned int initial_xmit_delay;
+	unsigned int initial_dec_delay;
+	unsigned int scale_increment_interval;
+	unsigned int final_offset;
+};
+
+struct decon_config {
+	enum decon_out_type out_type;
+	unsigned int image_height;
+	unsigned int image_width;
+	unsigned int out_bpc;
+	struct decon_mode mode;
+	unsigned int fps;
+};
+
+struct win_color_map {
+	bool en;
+	u32 val;
+};
+
+struct decon_win_config {
+	u32 x, y, w, h;
+	u32 start_time;
+	u32 alpha;
+	enum decon_blend_mode blend_mode;
+	struct win_color_map color_map;
+	u32 dpp_type;
+};
+
+#define IS_DECON0(decon_idx) ((decon_idx) & 1 ? 0 : 1)
+#define IS_DSC0(dsc_idx) ((dsc_idx) & 1 ? 0 : 1)
+
+struct decon_cal_info {
+	u32 id;
+	const char *name;
+};
+
+#define DECON_CAL_INFO(_type) [(_type)] = { .id = (_type), .name = #_type }
+
+#define DECON_VIDEO_MODE_WIDTH_MIN 160
+#define DECON_COMMAND_MODE_WIDTH_MIN 16
+#define DECON_WIDTH_MAX 8192
+#define DECON_HEIGHT_MIN 8
+#define DECON_HEIGHT_MAX 8192
+
+struct decon_win {
+	u32 idx;
+	struct decon_win_config config;
+	struct exynos_dpp_context *dpp;
+	struct exynos_drm_plane plane;
+	struct exynos_drm_plane_config plane_config;
+};
+
+struct decon_context {
+	u32 idx;
+	u32 plane_mask;
+	enum decon_type type;
+	struct device *dev;
+	struct drm_device *drm_dev;
+	struct exynos_drm_crtc *crtc;
+	struct decon_win *win;
+	u32 win_cnt;
+	u32 win_max;
+	u32 disable_mask;
+	struct videomode v_mode;
+	struct decon_config config;
+
+	struct clk *aclk;
+
+	u32 irq_fd; /* frame done */
+
+	/* device ops */
+	const struct decon_cal_ops *cal_ops;
+
+	bool is_colormap;
+
+	bool fake_vblank;
+	struct delayed_work dwork;
+	void __iomem *regs[3]; /* main, sub0, sub1*/
+};
+
+#ifndef MSEC
+#define MSEC (1000)
+#endif
+
+#define MAX_WIN_PER_DECON 8
+
+enum {
+	DPUM_DECON0 = 0,
+	DPUM_DECON1,
+
+	DPUS0_DECON0,
+	DPUS0_DECON1,
+
+	DPUS1_DECON0,
+	DPUS1_DECON1,
+
+	MAX_EXYNOS910_DECON,
+};
+
+enum decon_idma_type {
+	IDMA_GF0 = 0,
+	IDMA_G0,
+	IDMA_VG0,
+	IDMA_G1,
+	IDMA_GF1,
+	IDMA_G2 = 5,
+	IDMA_VG1,
+	IDMA_G3,
+	IOTF0,
+	IOTF1,
+	IDMA_NONE,
+};
+
+enum decon_fifo_mode {
+	DECON_FIFO_00K = 0,
+	DECON_FIFO_04K,
+	DECON_FIFO_08K,
+	DECON_FIFO_12K,
+	DECON_FIFO_16K,
+	DECON_FIFO_20K,
+	DECON_FIFO_24K,
+	DECON_FIFO_28K,
+};
+
+enum decon_dsc_path {
+	DECON_DSC_NONE = 0x0,
+	DECON0_DSC_ENC0 = 0x1,
+	DECON1_DSC_ENC1 = 0x2,
+	DECON0_DSCC_DSC_ENC01 = 0xB,
+};
+
+enum decon_outif_path {
+	DECON0_OUTFIFO0_DSIMIF0 = 0x1,
+	DECON0_OUTFIFO0_DSIMIF1 = 0x2,
+	DECON0_SPLITTER_OUTFIFO01_DSIMIF01 = 0x3,
+	DECON0_OUTFIFO0_DPIF = 0x8,
+	DECON1_OUTFIFO0_DSIMIF = 0x1,
+	DECON1_OUTFIFO0_DPIF = 0x8,
+};
+
+enum decon_connection {
+	DECON0_OUT0_TO_DSIM0 = 0,
+	DECON0_OUT1_TO_DSIM0 = 1,
+	DECON1_OUT0_TO_DSIM0 = 2,
+
+	DECON0_OUT0_TO_DSIM1 = 0,
+	DECON0_OUT1_TO_DSIM1 = 1,
+	DECON1_OUT0_TO_DSIM1 = 2,
+
+	DECON0_OUT0_TO_DP = 0,
+	DECON1_OUT0_TO_DP = 1,
+};
+
+static void __iomem *regs_decon[MAX_EXYNOS910_DECON];
+static inline uint32_t decon_read(u32 idx, u32 offset)
+{
+	return readl(regs_decon[idx] + offset);
+}
+static inline void decon_write(u32 idx, u32 offset, u32 val)
+{
+	writel(val, regs_decon[idx] + offset);
+}
+static inline void decon_write_mask(u32 idx, u32 offset, u32 val, u32 mask)
+{
+	uint32_t old = decon_read(idx, offset);
+	val = (val & mask) | (old & ~mask);
+	decon_write(idx, offset, val);
+}
+
+static void __iomem *regs_decon_con[MAX_EXYNOS910_DECON];
+static inline uint32_t decon_con_read(u32 idx, u32 offset)
+{
+	return readl(regs_decon_con[idx] + offset);
+}
+static inline void decon_con_write(u32 idx, u32 offset, u32 val)
+{
+	writel(val, regs_decon_con[idx] + offset);
+}
+static inline void decon_con_write_mask(u32 idx, u32 offset, u32 val, u32 mask)
+{
+	uint32_t old = decon_con_read(idx, offset);
+	val = (val & mask) | (old & ~mask);
+	decon_con_write(idx, offset, val);
+}
+static void __iomem *regs_decon_global[MAX_EXYNOS910_DECON];
+static inline uint32_t decon_global_read(u32 idx, u32 offset)
+{
+	return readl(regs_decon_global[idx] + offset);
+}
+static inline void decon_global_write(u32 idx, u32 offset, u32 val)
+{
+	writel(val, regs_decon_global[idx] + offset);
+}
+static inline void decon_global_write_mask(u32 idx, u32 offset, u32 val,
+					   u32 mask)
+{
+	uint32_t old = decon_global_read(idx, offset);
+	val = (val & mask) | (old & ~mask);
+	decon_global_write(idx, offset, val);
+}
+static void __iomem *regs_win[MAX_EXYNOS910_DECON * 8];
+static inline uint32_t win_read(u32 idx, u32 offset)
+{
+	return readl(regs_win[idx] + offset);
+}
+static inline void win_write(u32 idx, u32 offset, u32 val)
+{
+	writel(val, regs_win[idx] + offset);
+}
+static inline void win_write_mask(u32 idx, u32 offset, u32 val, u32 mask)
+{
+	uint32_t old = win_read(idx, offset);
+	val = (val & mask) | (old & ~mask);
+	win_write(idx, offset, val);
+}
+static void __iomem *regs_winctrl[MAX_EXYNOS910_DECON * 8];
+static inline uint32_t winctrl_read(u32 idx, u32 offset)
+{
+	return readl(regs_winctrl[idx] + offset);
+}
+static inline uint32_t winctrl_read_mask(u32 idx, u32 offset, u32 mask)
+{
+	uint32_t val = winctrl_read(idx, offset);
+	val &= (mask);
+	return val;
+}
+static inline void winctrl_write(u32 idx, u32 offset, u32 val)
+{
+	writel(val, regs_winctrl[idx] + offset);
+}
+static inline void winctrl_write_mask(u32 idx, u32 offset, u32 val, u32 mask)
+{
+	uint32_t old = winctrl_read(idx, offset);
+	val = (val & mask) | (old & ~mask);
+	winctrl_write(idx, offset, val);
+}
+
+#define to_regwin_idx(decon_idx, win_idx) \
+	((decon_idx) * MAX_WIN_PER_DECON + (win_idx))
+
+static inline u32 decon_reg_dmaid2chmap(u32 dma_id)
+{
+	switch (dma_id) {
+	case 0:
+		return IDMA_GF0;
+	case 1:
+		return IDMA_G0;
+	case 2:
+		return IDMA_G1;
+	case 3:
+		return IDMA_GF1;
+	case 4:
+		return IDMA_VG0;
+	case 5:
+		return IDMA_G2;
+	case 6:
+		return IDMA_VG1;
+	case 7:
+		return IDMA_G3;
+	default:
+		return IDMA_NONE;
+	}
+}
+
+static void decon_reg_set_window_channel(u32 decon_idx, u32 win_idx, u32 dma_id)
+{
+	u32 val, mask;
+	u32 ch_type = decon_reg_dmaid2chmap(dma_id);
+
+	val = WIN_CHMAP_F(1, ch_type);
+	mask = WIN_CHMAP_MASK(1);
+	winctrl_write_mask(to_regwin_idx(decon_idx, win_idx),
+			   DATA_PATH_CONTROL_WIN, val, mask);
+}
+
+/*
+ * argb_color : 32-bit
+ * A[31:24] - R[23:16] - G[15:8] - B[7:0]
+ */
+static void decon_reg_set_window_colormap(u32 decon_idx, u32 win_idx,
+					  u32 argb_color)
+{
+	u32 val, mask;
+	u32 mc_alpha = 0, mc_red = 0;
+	u32 mc_green = 0, mc_blue = 0;
+
+	mc_alpha = (argb_color >> 24) & 0xFF;
+	mc_red = (argb_color >> 16) & 0xFF;
+	mc_green = (argb_color >> 8) & 0xFF;
+	mc_blue = (argb_color >> 0) & 0xFF;
+
+	val = WIN_MAPCOLOR_A_F(mc_alpha) | WIN_MAPCOLOR_R_F(mc_red);
+	mask = WIN_MAPCOLOR_A_MASK | WIN_MAPCOLOR_R_MASK;
+	win_write_mask(to_regwin_idx(decon_idx, win_idx), WIN_COLORMAP_0, val,
+		       mask);
+
+	val = WIN_MAPCOLOR_G_F(mc_green) | WIN_MAPCOLOR_B_F(mc_blue);
+	mask = WIN_MAPCOLOR_G_MASK | WIN_MAPCOLOR_B_MASK;
+	win_write_mask(to_regwin_idx(decon_idx, win_idx), WIN_COLORMAP_1, val,
+		       mask);
+}
+
+/* ALPHA_MULT selection used in (a',b',c',d') coefficient */
+static void decon_reg_set_win_alpha_mult(u32 decon_idx, u32 win_idx,
+					 enum decon_blend_alpha_mult_src a_sel)
+{
+	u32 val, mask;
+
+	val = WIN_ALPHA_MULT_SRC_SEL_F(a_sel);
+	mask = WIN_ALPHA_MULT_SRC_SEL_MASK;
+	win_write_mask(to_regwin_idx(decon_idx, win_idx), WIN_CONTROL_0, val,
+		       mask);
+}
+
+static void decon_reg_set_win_func(u32 decon_idx, u32 win_idx,
+				   enum decon_blend_pd_func pd_func)
+{
+	u32 val, mask;
+
+	val = WIN_FUNC_F(pd_func);
+	mask = WIN_FUNC_MASK;
+	win_write_mask(to_regwin_idx(decon_idx, win_idx), WIN_CONTROL_0, val,
+		       mask);
+}
+
+static void decon_reg_set_win_sub_coeff(u32 decon_idx, u32 win_idx, u32 fgd,
+					u32 bgd, u32 fga, u32 bga)
+{
+	u32 val, mask;
+
+	/*
+	 * [ Blending Equation ]
+	 * Color : Cr = (a x Cf) + (b x Cb)  <Cf=FG pxl_C, Cb=BG pxl_C>
+	 * Alpha : Ar = (c x Af) + (d x Ab)  <Af=FG pxl_A, Ab=BG pxl_A>
+	 *
+	 * [ User-defined ]
+	 * a' = WINx_FG_ALPHA_D_SEL : Af' that is multiplied by FG Pixel Color
+	 * b' = WINx_BG_ALPHA_D_SEL : Ab' that is multiplied by BG Pixel Color
+	 * c' = WINx_FG_ALPHA_A_SEL : Af' that is multiplied by FG Pixel Alpha
+	 * d' = WINx_BG_ALPHA_A_SEL : Ab' that is multiplied by BG Pixel Alpha
+	 */
+
+	val = (WIN_FG_ALPHA_D_SEL_F(fgd) | WIN_BG_ALPHA_D_SEL_F(bgd) |
+	       WIN_FG_ALPHA_A_SEL_F(fga) | WIN_BG_ALPHA_A_SEL_F(bga));
+	mask = (WIN_FG_ALPHA_D_SEL_MASK | WIN_BG_ALPHA_D_SEL_MASK |
+		WIN_FG_ALPHA_A_SEL_MASK | WIN_BG_ALPHA_A_SEL_MASK);
+	win_write_mask(to_regwin_idx(decon_idx, win_idx), WIN_CONTROL_1, val,
+		       mask);
+}
+
+static void decon_reg_set_win_plane_alpha(u32 decon_idx, u32 win_idx, u32 a0,
+					  u32 a1)
+{
+	u32 val, mask;
+
+	val = WIN_ALPHA1_F(a1) | WIN_ALPHA0_F(a0);
+	mask = WIN_ALPHA1_MASK | WIN_ALPHA0_MASK;
+	win_write_mask(to_regwin_idx(decon_idx, win_idx), WIN_CONTROL_0, val,
+		       mask);
+}
+
+static void decon_reg_set_win_blend_config(u32 decon_idx, u32 win_idx,
+					   struct decon_win_config *config)
+{
+	enum decon_blend_pd_func pd_func = PD_FUNC_USER_DEFINED;
+	u32 af_d = BND_COEF_ONE, ab_d = BND_COEF_ZERO, af_a = BND_COEF_ONE,
+	    ab_a = BND_COEF_ZERO;
+
+	switch (config->blend_mode) {
+	case DECON_BLENDING_COVERAGE:
+		af_d = BND_COEF_ALPHA_MULT;
+		ab_d = BND_COEF_1_M_ALPHA_MULT;
+		af_a = BND_COEF_ALPHA_MULT;
+		ab_a = BND_COEF_1_M_ALPHA_MULT;
+		break;
+	case DECON_BLENDING_PREMULT:
+		af_d = BND_COEF_PLANE_ALPHA0;
+		ab_d = BND_COEF_1_M_ALPHA_MULT;
+		af_a = BND_COEF_PLANE_ALPHA0;
+		ab_a = BND_COEF_1_M_ALPHA_MULT;
+		break;
+	case DECON_BLENDING_NONE:
+		pd_func = PD_FUNC_COPY;
+		pr_debug("%s:%d none blending mode\n", __func__, __LINE__);
+		break;
+	default:
+		pr_warn("%s:%d undefined blending mode\n", __func__, __LINE__);
+		break;
+	}
+
+	/* We use 'ALPHA_MULT_SRC_SEL_AF' alpha mode only */
+	decon_reg_set_win_alpha_mult(decon_idx, win_idx, ALPHA_MULT_SRC_SEL_AF);
+	decon_reg_set_win_plane_alpha(decon_idx, win_idx, config->alpha, 0x00);
+	decon_reg_set_win_func(decon_idx, win_idx, pd_func);
+	if (pd_func == PD_FUNC_USER_DEFINED)
+		decon_reg_set_win_sub_coeff(decon_idx, win_idx, af_d, ab_d,
+					    af_a, ab_a);
+}
+
+static inline u32 win_start_pos(int x, int y)
+{
+	return (WIN_STRPTR_Y_F(y) | WIN_STRPTR_X_F(x));
+}
+
+static inline u32 win_end_pos(int x, int y, u32 w, u32 h)
+{
+	return (WIN_ENDPTR_Y_F(y + h - 1) | WIN_ENDPTR_X_F(x + w - 1));
+}
+
+static void decon_reg_set_window_enable_colormap(u32 decon_idx, u32 win_idx,
+						 u32 en)
+{
+	u32 val, mask;
+
+	val = en ? ~0 : 0;
+	mask = WIN_MAPCOLOR_EN_F(0);
+	winctrl_write_mask(to_regwin_idx(decon_idx, win_idx),
+			   DATA_PATH_CONTROL_WIN, val, mask);
+}
+
+/* Decon window setting procedure
+ *
+ * 1. decon_reg_clear_window_update_req()
+ * 2. decon_reg_set_window_config()
+ * 3. decon_reg_set_window_enable()
+ * 4. decon_reg_set_window_update_req()
+ */
+
+static void decon_reg_set_window_enable(u32 decon_idx, u32 win_idx, u32 dma_id)
+{
+	u32 mask;
+
+	decon_reg_set_window_channel(decon_idx, win_idx, dma_id);
+	mask = WIN_EN_F(0);
+	winctrl_write_mask(to_regwin_idx(decon_idx, win_idx),
+			   DATA_PATH_CONTROL_WIN, ~0, mask);
+}
+
+static void decon_reg_set_window_disable(u32 decon_idx, u32 win_idx)
+{
+	u32 mask;
+
+	mask = WIN_EN_F(0);
+	winctrl_write_mask(to_regwin_idx(decon_idx, win_idx),
+			   DATA_PATH_CONTROL_WIN, 0, mask);
+	decon_reg_set_window_channel(decon_idx, win_idx, IDMA_GF0);
+}
+
+static void decon_reg_set_window_config(u32 decon_idx, u32 win_idx,
+					struct decon_win_config *config)
+{
+	u32 start_pos = win_start_pos(config->x, config->y);
+	u32 end_pos = win_end_pos(config->x, config->y, config->w, config->h);
+
+	win_write(to_regwin_idx(decon_idx, win_idx), WIN_START_POSITION,
+		  start_pos);
+	win_write(to_regwin_idx(decon_idx, win_idx), WIN_END_POSITION, end_pos);
+	win_write(to_regwin_idx(decon_idx, win_idx), WIN_START_TIME_CONTROL,
+		  config->start_time);
+
+	decon_reg_set_window_enable_colormap(decon_idx, win_idx,
+					     config->color_map.en);
+	decon_reg_set_window_colormap(decon_idx, win_idx,
+				      config->color_map.val);
+
+	decon_reg_set_win_blend_config(decon_idx, win_idx, config);
+}
+
+static void decon_reg_clear_window_config(u32 decon_idx, u32 win_idx)
+{
+	win_write(to_regwin_idx(decon_idx, win_idx), WIN_CONTROL_0, 0);
+	win_write(to_regwin_idx(decon_idx, win_idx), WIN_CONTROL_1, 0);
+
+	win_write(to_regwin_idx(decon_idx, win_idx), WIN_START_POSITION, 0);
+	win_write(to_regwin_idx(decon_idx, win_idx), WIN_END_POSITION, 0);
+	win_write(to_regwin_idx(decon_idx, win_idx), WIN_START_TIME_CONTROL, 0);
+}
+
+static void decon_reg_set_window_update_req(u32 decon_idx, u32 win_idx)
+{
+	u32 mask;
+
+	mask = SHD_UP_REQ;
+	winctrl_write_mask(to_regwin_idx(decon_idx, win_idx), UPDATE_REQ_WIN,
+			   ~0, mask);
+}
+
+static u32 decon_reg_get_window_status(u32 decon_idx, u32 win_idx)
+{
+	/* FIXME: Due to HW restrictions, cannot use to the shadow register
+	 * of winctrl(WINx_EN_F bit) in auto9. As an alternative, use the
+	 * WIN_END_POSITION value to check the status.
+	 */
+	return win_read(to_regwin_idx(decon_idx, win_idx),
+			WIN_END_POSITION + WIN_SHD_OFFSET) ?
+		       1 :
+		       0;
+}
+
+static int decon_reg_reset(u32 decon_idx)
+{
+	int tries;
+
+	decon_write_mask(decon_idx, GLOBAL_CONTROL, ~0, GLOBAL_CONTROL_SRESET);
+	for (tries = 2000; tries; --tries) {
+		if (~decon_read(decon_idx,
+				GLOBAL_CONTROL & GLOBAL_CONTROL_SRESET))
+			break;
+		udelay(10);
+	}
+
+	if (!tries) {
+		pr_err("failed to reset Decon\n");
+		return -EBUSY;
+	}
+
+	return 0;
+}
+
+static void __decon_reg_set_enable(u32 decon_idx)
+{
+	u32 val, mask;
+
+	val = ~0;
+	mask = (GLOBAL_CONTROL_DECON_EN | GLOBAL_CONTROL_DECON_EN_F);
+	decon_write_mask(decon_idx, GLOBAL_CONTROL, val, mask);
+}
+
+static void __decon_reg_set_disable(u32 decon_idx)
+{
+	u32 val, mask;
+
+	val = 0;
+	mask = (GLOBAL_CONTROL_DECON_EN | GLOBAL_CONTROL_DECON_EN_F);
+	decon_write_mask(decon_idx, GLOBAL_CONTROL, val, mask);
+}
+
+static void decon_reg_set_disable_per_frame(u32 decon_idx)
+{
+	decon_write_mask(decon_idx, GLOBAL_CONTROL, 0,
+			 GLOBAL_CONTROL_DECON_EN_F);
+}
+
+static void decon_reg_set_operation_mode(u32 decon_idx, enum decon_op_mode mode)
+{
+	u32 val, mask;
+
+	mask = GLOBAL_CONTROL_OPERATION_MODE_F;
+
+	if (mode == DECON_MIPI_COMMAND_MODE)
+		val = GLOBAL_CONTROL_OPERATION_MODE_CMD_F;
+	else
+		val = GLOBAL_CONTROL_OPERATION_MODE_VIDEO_F;
+
+	decon_write_mask(decon_idx, GLOBAL_CONTROL, val, mask);
+}
+
+static void decon_reg_set_blender_bg_image_size(u32 decon_idx, u32 width,
+						u32 height)
+{
+	u32 val, mask;
+
+	val = BLENDER_BG_HEIGHT_F(height) | BLENDER_BG_WIDTH_F(width);
+	mask = BLENDER_BG_HEIGHT_MASK | BLENDER_BG_WIDTH_MASK;
+	decon_write_mask(decon_idx, BLENDER_BG_IMAGE_SIZE_0, val, mask);
+}
+
+static u32 decon_reg_get_run_status(u32 decon_idx)
+{
+	u32 val;
+
+	val = decon_read(decon_idx, GLOBAL_CONTROL);
+	if (val & GLOBAL_CONTROL_RUN_STATUS)
+		return 1;
+
+	return 0;
+}
+
+static int decon_reg_wait_run_status_timeout(u32 decon_idx,
+					     unsigned long timeout)
+{
+	u32 val;
+	int ret;
+
+	ret = read_poll_timeout_atomic(decon_reg_get_run_status, val, val, 100,
+				       timeout, false, decon_idx);
+	if (ret)
+		pr_err("decon%u wait timeout decon run status(%u)\n", decon_idx,
+		       val);
+
+	return ret;
+}
+
+/* Determine that DECON is perfectly shuttled off through
+ * checking this function
+ */
+static int decon_reg_wait_run_is_off_timeout(u32 decon_idx,
+					     unsigned long timeout)
+{
+	u32 val;
+	int ret;
+
+	ret = read_poll_timeout_atomic(decon_reg_get_run_status, val, !val, 100,
+				       timeout, false, decon_idx);
+	if (ret)
+		pr_err("decon%u wait timeout decon run is shut-off(%u)\n",
+		       decon_idx, val);
+
+	return ret;
+}
+
+/*
+ * API is considering real possible Display Scenario
+ * such as following examples
+ *  < Single display >
+ *  < Dual/Triple display >
+ *  < Dual display + DP >
+ *
+ * Modify/add configuration cases if necessary
+ * "Resource Confliction" will happen if enabled simultaneously
+ *
+ * it's in EVT1
+ * Total of SRAM = 28k (4k * 7ea)
+ *  DECON0 + DECON1 <= under 28k
+ * The SRAM should be combinated in accordance with the scenario
+ * without "resource conflicts"
+ *
+ * DECON0 : ~5k (DSC supported dual DSI and dual DSC)
+ * DECON1 : ~3k (not supported dual DSI and      DSC)
+ *
+ *   OF0    OF1    CAPA
+ *  SRAM0  SRAM0    2K (Shared)
+ *  SRAM1  SRAM4    4K
+ *  SRAM2  SRAM5    4K
+ *  SRAM3  SRAM6    4K
+ */
+static void decon_reg_set_sram_share(u32 decon_idx,
+				     enum decon_fifo_mode fifo_mode)
+{
+	u32 val = 0;
+	u32 id = IS_DECON0(decon_idx) ? 0 : 1;
+
+	switch (fifo_mode) {
+	case DECON_FIFO_04K:
+		if (id == 0)
+			val = SRAM0_SHARE_ENABLE_F;
+		else
+			val = SRAM1_SHARE_ENABLE_F;
+		break;
+	case DECON_FIFO_08K:
+		if (id == 0)
+			val = SRAM1_SHARE_ENABLE_F | SRAM4_SHARE_ENABLE_F;
+		else
+			val = SRAM2_SHARE_ENABLE_F | SRAM5_SHARE_ENABLE_F;
+		break;
+	case DECON_FIFO_12K:
+		if (id == 0)
+			val = SRAM1_SHARE_ENABLE_F | SRAM4_SHARE_ENABLE_F |
+			      SRAM0_SHARE_ENABLE_F;
+		else
+			val = SRAM3_SHARE_ENABLE_F | SRAM6_SHARE_ENABLE_F |
+			      SRAM0_SHARE_ENABLE_F;
+		break;
+	case DECON_FIFO_16K:
+		if (id == 0)
+			val = SRAM1_SHARE_ENABLE_F | SRAM4_SHARE_ENABLE_F |
+			      SRAM2_SHARE_ENABLE_F | SRAM5_SHARE_ENABLE_F;
+		else
+			val = SRAM2_SHARE_ENABLE_F | SRAM5_SHARE_ENABLE_F |
+			      SRAM3_SHARE_ENABLE_F | SRAM6_SHARE_ENABLE_F;
+		break;
+	case DECON_FIFO_20K:
+		if (id == 0)
+			val = SRAM1_SHARE_ENABLE_F | SRAM4_SHARE_ENABLE_F |
+			      SRAM3_SHARE_ENABLE_F | SRAM6_SHARE_ENABLE_F |
+			      SRAM0_SHARE_ENABLE_F;
+		else
+			val = SRAM2_SHARE_ENABLE_F | SRAM5_SHARE_ENABLE_F |
+			      SRAM3_SHARE_ENABLE_F | SRAM6_SHARE_ENABLE_F |
+			      SRAM0_SHARE_ENABLE_F;
+		break;
+	case DECON_FIFO_24K:
+		if (id == 0)
+			val = SRAM0_SHARE_ENABLE_F | SRAM4_SHARE_ENABLE_F |
+			      SRAM2_SHARE_ENABLE_F | SRAM5_SHARE_ENABLE_F |
+			      SRAM3_SHARE_ENABLE_F | SRAM6_SHARE_ENABLE_F;
+		else
+			val = SRAM1_SHARE_ENABLE_F | SRAM4_SHARE_ENABLE_F |
+			      SRAM2_SHARE_ENABLE_F | SRAM5_SHARE_ENABLE_F |
+			      SRAM3_SHARE_ENABLE_F | SRAM6_SHARE_ENABLE_F;
+		break;
+	case DECON_FIFO_28K:
+		val = ALL_SRAM_SHARE_ENABLE;
+		break;
+	case DECON_FIFO_00K:
+		val = ALL_SRAM_SHARE_DISABLE;
+		break;
+	default:
+		break;
+	}
+
+	decon_write(decon_idx, SRAM_SHARE_ENABLE, val);
+}
+
+static void decon_reg_set_outfifo_size_ctl0(u32 decon_idx, u32 width,
+					    u32 height)
+{
+	u32 val;
+	u32 th, mask;
+
+	/* OUTFIFO_0 */
+	val = OUTFIFO_HEIGHT_F(height) | OUTFIFO_WIDTH_F(width);
+	mask = OUTFIFO_HEIGHT_MASK | OUTFIFO_WIDTH_MASK;
+	decon_write(decon_idx, OUTFIFO_SIZE_CONTROL_0, val);
+
+	/* may be implemented later by considering 1/2H transfer */
+	th = OUTFIFO_TH_1H_F; /* 1H transfer */
+	mask = OUTFIFO_TH_MASK;
+	decon_write_mask(decon_idx, OUTFIFO_TH_CONTROL_0, th, mask);
+}
+
+static void decon_reg_set_outfifo_rgb_order(u32 decon_idx,
+					    enum decon_rgb_order order)
+{
+	u32 val, mask;
+
+	val = OUTFIFO_PIXEL_ORDER_SWAP_F(order);
+	mask = OUTFIFO_PIXEL_ORDER_SWAP_MASK;
+	decon_write_mask(decon_idx, OUTFIFO_DATA_ORDER_CONTROL, val, mask);
+}
+
+static void decon_reg_clear_interrupt_all(u32 decon_idx)
+{
+	u32 mask;
+
+	mask = (DPU_FRAME_DONE_INT_EN | DPU_FRAME_START_INT_EN);
+	decon_write_mask(decon_idx, INTERRUPT_PENDING, ~0, mask);
+
+	mask = (DPU_RESOURCE_CONFLICT_INT_EN | DPU_TIME_OUT_INT_EN);
+	decon_write_mask(decon_idx, EXTRA_INTERRUPT_PENDING, ~0, mask);
+}
+
+static void decon_reg_set_dsc_path(u32 decon_idx, enum decon_dsc_path dpath)
+{
+	u32 mask;
+
+	mask = DSC_PATH_MASK;
+
+	decon_write_mask(decon_idx, DATA_PATH_CONTROL_2, DSC_PATH_F(dpath),
+			 mask);
+}
+
+static void decon_reg_set_outif_path(u32 decon_idx, enum decon_outif_path opath)
+{
+	u32 mask;
+
+	mask = OUTIF_PATH_MASK;
+
+	decon_write_mask(decon_idx, DATA_PATH_CONTROL_2, OUTIF_PATH_F(opath),
+			 mask);
+}
+
+/*  <SEL_ATB relation between DECON and DPTX>
+DPUM ATB0 DP0_SST1
+     ATB1 DP0_SST2
+     ATB2 X(non wired)
+     ATB3 X(non wired)
+DPUS0 ATB0 DP0_SST3
+      ATB1 DP0_SST4
+      ATB2 DP1_SST1
+      ATB3 DP1_SST2
+DPUS1 ATB0 DP1_SST3
+      ATB1 DP1_SST4
+      ATB2 X(non wired)
+      ATB3 X(non wired) */
+static u32 decon_reg_get_sel_atb(u32 decon_idx, enum decon_out_type out_type)
+{
+	u32 sel_atb =
+		0x4; /* The ATB reset value is 0x4.(DP does not drive any ATB path) */
+
+	switch (out_type) {
+	case DECON_OUT_DP0_SST1:
+	case DECON_OUT_DP0_SST3:
+	case DECON_OUT_DP1_SST3:
+		sel_atb = 0x0;
+		break;
+	case DECON_OUT_DP0_SST2:
+	case DECON_OUT_DP0_SST4:
+	case DECON_OUT_DP1_SST4:
+		sel_atb = 0x1;
+		break;
+	case DECON_OUT_DP1_SST1:
+		sel_atb = 0x2;
+		break;
+	case DECON_OUT_DP1_SST2:
+		sel_atb = 0x3;
+		break;
+	default:
+		pr_err("decon %u, invalid out_type = %#x\n", decon_idx,
+		       out_type);
+		break;
+	}
+
+	return DP_CONNECTION_SEL_ATB_F(sel_atb);
+}
+
+static void decon_reg_set_output(u32 decon_idx, enum decon_out_type out_type)
+{
+	u32 con_ctrl, out_if, sel_if, sel_atb = 0x4; /* IF: Interface */
+
+	if (out_type & DECON_OUT_DSI) {
+		if (decon_idx > DPUM_DECON1)
+			return;
+
+		if (out_type & DECON_OUT_DSI0) {
+			if (IS_DECON0(decon_idx)) {
+				/*
+				 * DSIM can be connected with any DSIMIF.
+				 * Below two combinations are possible.
+				 * 1. OUT0 + OUTFIFO0_DSIMIF0
+				 * 2. OUT1 + OUTFIFO0_DSIMIF1
+				 */
+				out_if = DECON0_OUTFIFO0_DSIMIF0;
+				sel_if = DECON0_OUT0_TO_DSIM0;
+			} else {
+				out_if = DECON1_OUTFIFO0_DSIMIF;
+				sel_if = DECON1_OUT0_TO_DSIM0;
+			}
+			con_ctrl = DSIM0_CONNECTION_CONTROL;
+
+			decon_reg_set_outif_path(decon_idx, out_if);
+			decon_con_write_mask(decon_idx, con_ctrl, sel_if,
+					     DSIM_CONNECTION_DSIM_MASK);
+		}
+		if (out_type & DECON_OUT_DSI1) {
+			if (IS_DECON0(decon_idx)) {
+				/*
+				 * DSIM can be connected with any DSIMIF.
+				 * Below two combinations are possible.
+				 * 1. OUT0 + OUTFIFO0_DSIMIF0
+				 * 2. OUT1 + OUTFIFO0_DSIMIF1
+				 */
+				out_if = DECON0_OUTFIFO0_DSIMIF1;
+				sel_if = DECON0_OUT1_TO_DSIM1;
+			} else {
+				out_if = DECON1_OUTFIFO0_DSIMIF;
+				sel_if = DECON1_OUT0_TO_DSIM1;
+			}
+			con_ctrl = DSIM1_CONNECTION_CONTROL;
+
+			decon_reg_set_outif_path(decon_idx, out_if);
+			decon_con_write_mask(decon_idx, con_ctrl, sel_if,
+					     DSIM_CONNECTION_DSIM_MASK);
+		}
+	}
+
+	if (out_type & DECON_OUT_DP) {
+		sel_atb = decon_reg_get_sel_atb(decon_idx, out_type);
+
+		if (IS_DECON0(decon_idx)) {
+			out_if = DECON0_OUTFIFO0_DPIF;
+			sel_if = DP_CONNECTION_SEL_F(DECON0_OUT0_TO_DP) |
+				 sel_atb;
+			con_ctrl = DP0_CONNECTION_CONTROL_0;
+		} else {
+			out_if = DECON1_OUTFIFO0_DPIF;
+			sel_if = DP_CONNECTION_SEL_F(DECON1_OUT0_TO_DP) |
+				 sel_atb;
+			con_ctrl = DP1_CONNECTION_CONTROL_0;
+		}
+
+		decon_reg_set_outif_path(decon_idx, out_if);
+		decon_con_write_mask(decon_idx, con_ctrl, sel_if,
+				     DP_CONNECTION_SEL_MASK |
+					     DP_CONNECTION_SEL_ATB_MASK);
+	}
+}
+
+static void decon_reg_set_te(u32 decon_idx, struct decon_mode mode,
+			     enum decon_set_trig trig)
+{
+	u32 val, mask;
+
+	if (mode.op_mode == DECON_VIDEO_MODE)
+		return;
+
+	if (mode.te_mode == DECON_SW_TRIG) {
+		val = (trig == DECON_TRIG_UNMASK) ? SW_TRIG_EN : 0;
+		mask = HW_TRIG_EN | SW_TRIG_EN;
+	} else { /* DECON_HW_TRIG */
+		val = (trig == DECON_TRIG_UNMASK) ? HW_TRIG_EN :
+						    HW_TRIG_MASK_DECON;
+		mask = HW_TRIG_EN | HW_TRIG_MASK_DECON;
+	}
+
+	decon_write_mask(decon_idx, HW_SW_TRIG_CONTROL, val, mask);
+}
+
+static void decon_reg_set_update_req_global(u32 decon_idx)
+{
+	decon_global_write_mask(decon_idx, SHADOW_REG_UPDATE_REQ, ~0,
+				SHADOW_REG_UPDATE_REQ_GLOBAL);
+}
+
+static void decon_reg_set_interrupt(u32 decon_idx, u32 en)
+{
+	u32 val, mask;
+
+	decon_reg_clear_interrupt_all(decon_idx);
+
+	if (en) {
+		val = (DPU_FRAME_DONE_INT_EN | DPU_FRAME_START_INT_EN |
+		       DPU_EXTRA_INT_EN | DPU_INT_EN);
+
+		decon_write_mask(decon_idx, INTERRUPT_ENABLE, val,
+				 INTERRUPT_ENABLE_MASK);
+		pr_debug("decon %u, interrupt val = %x\n", decon_idx, val);
+
+		val = (DPU_RESOURCE_CONFLICT_INT_EN | DPU_TIME_OUT_INT_EN);
+		decon_write(decon_idx, EXTRA_INTERRUPT_ENABLE, val);
+	} else {
+		mask = (DPU_EXTRA_INT_EN | DPU_INT_EN);
+		decon_write_mask(decon_idx, INTERRUPT_ENABLE, 0, mask);
+	}
+}
+
+static u32 decon_reg_clear_extra_interrupt(u32 decon_idx)
+{
+	u32 reg = EXTRA_INTERRUPT_PENDING;
+	u32 val = decon_read(decon_idx, reg);
+
+	if (val & DPU_RESOURCE_CONFLICT_INT_PEND) {
+		decon_write(decon_idx, reg, DPU_RESOURCE_CONFLICT_INT_PEND);
+		pr_warn("decon%u INFO0: SRAM_RSC & DSC = 0x%x\n", decon_idx,
+			decon_read(decon_idx, RESOURCE_OCCUPANCY_INFO_0));
+		pr_warn("decon%u INFO1: DMA_CH_RSC= 0x%x\n", decon_idx,
+			decon_read(decon_idx, RESOURCE_OCCUPANCY_INFO_1));
+		pr_warn("decon%u INFO2: WIN_RSC= 0x%x\n", decon_idx,
+			decon_read(decon_idx, RESOURCE_OCCUPANCY_INFO_2));
+	}
+
+	/*
+	 * Timeout interrupt is occurred when aclk counter is over
+	 * 'DECONx_TIME_OUT_VALUE'.
+	 * This counter value is reset by FRAME_DONE signal
+	 */
+	if (val & DPU_TIME_OUT_INT_PEND) {
+		decon_write(decon_idx, reg, DPU_TIME_OUT_INT_PEND);
+		pr_warn("decon%u time out interrupt occured!\n", decon_idx);
+		pr_warn("decon%u maybe stuck now!\n", decon_idx);
+	}
+
+	return val;
+}
+
+static u32 decon_reg_clear_interrupt(u32 decon_idx, enum decon_irq irq)
+{
+	u32 pending_val = decon_read(decon_idx, INTERRUPT_PENDING);
+
+	if (irq == DECON_IRQ_FS && (pending_val & DPU_FRAME_START_INT_PEND)) {
+		/* Clear Interrupt */
+		decon_write(decon_idx, INTERRUPT_PENDING,
+			    DPU_FRAME_START_INT_PEND);
+	}
+
+	if (irq == DECON_IRQ_FD && (pending_val & DPU_FRAME_DONE_INT_PEND)) {
+		/* Clear Interrupt */
+		decon_write(decon_idx, INTERRUPT_PENDING,
+			    DPU_FRAME_DONE_INT_PEND);
+	}
+
+	if (irq == DECON_IRQ_EXT && (pending_val & DPU_EXTRA_INT_PEND)) {
+		/* Clear Interrupt */
+		decon_write(decon_idx, INTERRUPT_PENDING, DPU_EXTRA_INT_PEND);
+		decon_reg_clear_extra_interrupt(decon_idx);
+	}
+
+	return pending_val;
+}
+
+#define SHADOW_UPDATE_TIMEOUT (50 * 1000)
+
+static u32 decon_reg_get_window_update_req(u32 decon_idx, u32 win_idx)
+{
+	return winctrl_read_mask(to_regwin_idx(decon_idx, win_idx),
+				 UPDATE_REQ_WIN, SHD_UP_REQ);
+}
+
+static u32 decon_reg_get_shadow_update_req(u32 decon_idx)
+{
+	return decon_global_read(decon_idx, SHADOW_REG_UPDATE_REQ);
+}
+
+static void decon_reg_set_bpc(u32 decon_idx, u32 bpc)
+{
+	u32 val;
+
+	val = (bpc == 10) ? GLOBAL_CONTROL_TEN_BPC_MODE_F : 0;
+
+	decon_write_mask(decon_idx, GLOBAL_CONTROL, val,
+			 GLOBAL_CONTROL_TEN_BPC_MODE_MASK);
+}
+
+static int decon_reg_set_config(u32 decon_idx, struct decon_config config)
+{
+	enum decon_rgb_order rgb_order = DECON_RGB;
+
+	/* OUTFIFO_PIXEL_ORDER_SWAP_F
+	  * Use DECON_BGR at raw image transfer to DSIM.
+	  * Use DECON_RGB at compressed stream tranfer to DSIM.
+	  * Use DECON_RGB at DP connection.
+	  *
+	  * TODO : if DSC feature added, code must be modified like this.
+	  * if((config->out_type & DECON_OUT_DSI) && (DSC==DISABLE))
+	  * 	rgb_order = DECON_BGR;
+	  * else
+	  * 	rgb_order = DECON_RGB;
+	 */
+	if (config.out_type & DECON_OUT_DSI)
+		rgb_order = DECON_BGR;
+
+	decon_reg_set_operation_mode(decon_idx, config.mode.op_mode);
+	decon_reg_set_blender_bg_image_size(decon_idx,
+					    (config.mode.dsi_mode ==
+					     DSI_MODE_DUAL_DSI) ?
+						    (config.image_width * 2) :
+						    config.image_width,
+					    config.image_height);
+	decon_reg_set_bpc(decon_idx, config.out_bpc);
+	decon_reg_clear_interrupt_all(decon_idx);
+	decon_reg_set_outfifo_size_ctl0(decon_idx, config.image_width,
+					config.image_height);
+	decon_reg_set_sram_share(decon_idx, DECON_FIFO_08K);
+
+	decon_reg_set_outfifo_rgb_order(decon_idx, rgb_order);
+	decon_reg_set_output(decon_idx, config.out_type);
+
+	return 0;
+}
+
+static int decon_reg_set_enable(u32 decon_idx, struct decon_config config)
+{
+	int ret = 0;
+
+	decon_reg_set_config(decon_idx, config);
+	// if (config.dsc.enable)
+	// 	decon_reg_set_dsc(decon_idx, config.dsc);
+	// else
+	decon_reg_set_dsc_path(decon_idx, DECON_DSC_NONE);
+	__decon_reg_set_enable(decon_idx);
+	decon_reg_set_update_req_global(decon_idx);
+	decon_reg_wait_run_status_timeout(decon_idx, 20 * 1000);
+	decon_reg_set_te(decon_idx, config.mode, DECON_TRIG_UNMASK);
+
+	return ret;
+}
+
+static int decon_reg_set_disable(u32 decon_idx, struct decon_mode mode)
+{
+	int ret = 0;
+	const int timeout_value = 1000 / 60 * 12 / 10 + 5;
+
+	if (!decon_reg_get_run_status(decon_idx)) {
+		pr_info("already IDLE status\n");
+		return 0;
+	}
+
+	decon_reg_set_te(decon_idx, mode, DECON_TRIG_MASK);
+
+	decon_reg_set_disable_per_frame(decon_idx);
+	decon_reg_set_update_req_global(decon_idx);
+
+	ret = decon_reg_wait_run_is_off_timeout(decon_idx,
+						timeout_value * MSEC);
+	if (!ret) {
+		decon_reg_reset(decon_idx);
+		return 0;
+	} else {
+		__decon_reg_set_disable(decon_idx);
+		decon_reg_set_update_req_global(decon_idx);
+
+		ret = decon_reg_wait_run_is_off_timeout(decon_idx,
+							timeout_value * MSEC);
+		decon_reg_clear_interrupt_all(decon_idx);
+	}
+
+	return ret;
+}
+
+static void decon_reg_enable_window(u32 decon_idx, u32 win_idx,
+				    struct decon_win_config *config)
+{
+	if (!config) {
+		pr_err("window%d config is NULL\n", win_idx);
+		return;
+	}
+
+	decon_reg_set_window_config(decon_idx, win_idx, config);
+	decon_reg_set_window_enable(decon_idx, win_idx, config->dpp_type);
+}
+
+static void decon_reg_disable_window(u32 decon_idx, u32 win_idx)
+{
+	decon_reg_clear_window_config(decon_idx, win_idx);
+	decon_reg_set_window_disable(decon_idx, win_idx);
+}
+
+static int decon_reg_enable(u32 decon_idx, struct decon_config config)
+{
+	int ret = 0;
+
+	ret = decon_reg_set_enable(decon_idx, config);
+	if (ret)
+		return ret;
+
+	decon_reg_set_interrupt(decon_idx, 1);
+
+	return ret;
+}
+
+static int decon_reg_disable(u32 decon_idx, struct decon_config config)
+{
+	int ret = 0;
+
+	decon_reg_set_interrupt(decon_idx, 0);
+
+	ret = decon_reg_set_disable(decon_idx, config.mode);
+	if (ret)
+		return ret;
+
+	return ret;
+}
+
+struct decon_dev_data {
+	const u32 nr_decon;
+	const u32 nr_win;
+	const struct decon_cal_ops *cal_ops;
+};
+
+static const struct decon_dev_data exynos910_decon = {
+	.nr_decon = 2,
+	.nr_win = 8,
+};
+
+static const struct of_device_id decon_driver_dt_match[] = {
+	{ .compatible = "samsung,exynos910-decon",
+	  .data = (void *)&exynos910_decon },
+	{},
+};
+
+MODULE_DEVICE_TABLE(of, decon_driver_dt_match);
+
+static struct decon_win *plane_to_decon_win(struct drm_plane *e)
+{
+	return container_of(to_exynos_plane(e), struct decon_win, plane);
+}
+
+/* ARGB value */
+#define COLOR_MAP_VALUE 0x00ff0000
+
+static void decon_set_win_color_map(struct decon_win *window, bool en)
+{
+	struct decon_win_config *config = &window->config;
+
+	config->color_map.en = en;
+	config->color_map.val = COLOR_MAP_VALUE;
+}
+
+static enum drm_mode_status
+decon_mode_valid(struct exynos_drm_crtc *crtc,
+		 const struct drm_display_mode *mode)
+{
+	struct decon_context *ctx = crtc->ctx;
+
+	/* DECON use only video mode */
+	if ((mode->hdisplay < DECON_VIDEO_MODE_WIDTH_MIN) ||
+	    (mode->hdisplay > DECON_WIDTH_MAX) || (mode->hdisplay % 2)) {
+		drm_err(ctx->drm_dev, "mode hdisplay(%d) is bad\n",
+			mode->hdisplay);
+		return MODE_BAD_HVALUE;
+	}
+
+	if ((mode->vdisplay < DECON_HEIGHT_MIN) ||
+	    (mode->vdisplay > DECON_WIDTH_MAX)) {
+		drm_err(ctx->drm_dev, "mode vdisplay(%d) is bad\n",
+			mode->vdisplay);
+		return MODE_BAD_VVALUE;
+	}
+
+	return MODE_OK;
+}
+
+static void decon_atomic_begin(struct exynos_drm_crtc *crtc)
+{
+	struct decon_context *ctx = crtc->ctx;
+
+	decon_reg_set_te(ctx->idx, ctx->config.mode, DECON_TRIG_MASK);
+}
+
+static enum decon_blend_mode to_decon_blend_mode(u16 drm_blend_mode)
+{
+	switch (drm_blend_mode) {
+	case DRM_MODE_BLEND_PIXEL_NONE:
+		return DECON_BLENDING_NONE;
+
+	case DRM_MODE_BLEND_COVERAGE:
+		return DECON_BLENDING_COVERAGE;
+
+	case DRM_MODE_BLEND_PREMULTI:
+	default:
+		return DECON_BLENDING_PREMULT;
+	}
+}
+
+static void decon_update_plane(struct exynos_drm_crtc *crtc,
+			       struct exynos_drm_plane *plane)
+{
+	struct exynos_drm_plane_state *state =
+		to_exynos_plane_state(plane->base.state);
+	struct decon_context *ctx = crtc->ctx;
+	struct decon_win *window = plane_to_decon_win(&plane->base);
+	struct decon_win_config *config = &window->config;
+	struct exynos_drm_rect *rect = &state->crtc;
+	struct drm_device *drm_dev = ctx->drm_dev;
+	struct exynos_drm_private *priv = drm_dev->dev_private;
+	struct exynos_dpu_dma_context *dma_ctx = dev_get_drvdata(priv->dma_dev);
+
+	ctx->plane_mask |= drm_plane_mask(&plane->base);
+
+	config->x = state->crtc.x;
+	config->y = state->crtc.y;
+	config->w = state->crtc.w;
+	config->h = state->crtc.h;
+	config->start_time = 0;
+	config->alpha = state->base.alpha >> 8;
+	config->blend_mode = to_decon_blend_mode(state->base.pixel_blend_mode);
+	config->dpp_type = window->dpp->type;
+
+	decon_set_win_color_map(window, ctx->is_colormap);
+
+	dpp_update(window->dpp, 0, state);
+	dpu_dma_update(dma_ctx, 0, state);
+
+	decon_reg_enable_window(ctx->idx, window->idx, config);
+
+	drm_dbg(ctx->drm_dev, "WINDOW-%d(%s)(%4d, %4d, %4d, %4d)", window->idx,
+		dev_name(window->dpp->dev), rect->x, rect->y, rect->w, rect->h);
+}
+
+static void decon_disable_plane(struct exynos_drm_crtc *crtc,
+				struct exynos_drm_plane *plane)
+{
+	struct decon_context *ctx = crtc->ctx;
+	struct decon_win *window = plane_to_decon_win(&plane->base);
+
+	ctx->plane_mask |= drm_plane_mask(&plane->base);
+
+	decon_reg_disable_window(ctx->idx, window->idx);
+
+	ctx->disable_mask |= (1 << window->idx);
+
+	drm_dbg(ctx->drm_dev, "WINDOW-%d(%s)\n", window->idx,
+		dev_name(window->dpp->dev));
+}
+
+static void decon_atomic_flush(struct exynos_drm_crtc *crtc)
+{
+	struct decon_context *ctx = crtc->ctx;
+	struct drm_crtc_state *state = crtc->base.state;
+	struct drm_plane *plane;
+	bool req_global = true;
+
+	synchronize_irq(ctx->irq_fd);
+
+	drm_for_each_plane_mask(plane, ctx->drm_dev, ctx->plane_mask) {
+		struct decon_win *window = plane_to_decon_win(plane);
+
+		/* window update first to guarantee dma stop during dpp_disable */
+		decon_reg_set_window_update_req(ctx->idx, window->idx);
+
+		// if (ctx->disable_mask & (1 << window->idx))
+		// 	dpp_disable(window->dpp);
+
+		/* If at least one window is running, there is no need to set
+		 * global update
+		 */
+		if (req_global &&
+		    decon_reg_get_window_status(ctx->idx, window->idx))
+			req_global = false;
+	}
+	ctx->disable_mask = 0;
+
+	if (drm_atomic_crtc_needs_modeset(state) || req_global)
+		decon_reg_set_update_req_global(ctx->idx);
+
+	/* In case of fake vblank, it make vblank after 1 vsync time(16ms) */
+	// if (ctx->fake_vblank)
+	// 	drm_crtc_handle_vblank(&crtc->base);
+	// schedule_delayed_work(&ctx->dwork, msecs_to_jiffies(16));
+
+	decon_reg_set_te(ctx->idx, ctx->config.mode, DECON_TRIG_UNMASK);
+	exynos_crtc_handle_event(crtc);
+
+	drm_dbg(ctx->drm_dev, "flushed\n");
+}
+
+static void decon_config_print(struct decon_config *config)
+{
+	struct decon_context *ctx =
+		container_of(config, struct decon_context, config);
+	char *str_output = NULL;
+
+	drm_dbg(ctx->drm_dev, "Operation Mode: %s\n",
+		config->mode.op_mode ? "MIPI Command" : "Video");
+	if (config->mode.op_mode == DECON_MIPI_COMMAND_MODE)
+		drm_info(ctx->drm_dev, "Trigger Mode: %s\n",
+			 config->mode.te_mode ? "SW" : "HW");
+
+	if (config->out_type & DECON_OUT_DSI0)
+		str_output = "DSI0";
+	else if (config->out_type & DECON_OUT_DSI1)
+		str_output = "DSI1";
+	else if (config->out_type & DECON_OUT_DP0)
+		str_output = "DP0";
+	else if (config->out_type & DECON_OUT_DP1)
+		str_output = "DP1";
+
+	drm_info(ctx->drm_dev, "Output: %s\n", str_output);
+}
+
+static void decon_set_mode(struct exynos_drm_crtc *crtc)
+{
+	struct decon_context *ctx = crtc->ctx;
+	struct decon_mode *mode = &(ctx->config.mode);
+	enum decon_out_type out_type = 0;
+	struct drm_encoder *encoder;
+
+	drm_for_each_encoder_mask(encoder, crtc->base.dev,
+				  crtc->base.state->encoder_mask)
+		// TODO: make read port number and get it.
+		out_type = DECON_OUT_DP0_SST1;
+
+	if (out_type & DECON_OUT_DP)
+		mode->op_mode = DECON_VIDEO_MODE;
+
+	ctx->config.out_type = out_type;
+}
+
+static void decon_enable(struct exynos_drm_crtc *crtc)
+{
+	struct decon_context *ctx = crtc->ctx;
+
+	drm_display_mode_to_videomode(&crtc->base.mode, &ctx->v_mode);
+
+	ctx->config.image_width = ctx->v_mode.hactive;
+	ctx->config.image_height = ctx->v_mode.vactive;
+	ctx->config.fps = drm_mode_vrefresh(&crtc->base.mode);
+
+	decon_set_mode(crtc);
+
+	decon_reg_enable(ctx->idx, ctx->config);
+
+	enable_irq(ctx->irq_fd);
+
+	decon_config_print(&ctx->config);
+	drm_info(ctx->drm_dev, "enabled! crtc[%d] = %dx%d-%dHz (%d out_bpc)\n",
+		 crtc->base.base.id, ctx->config.image_width,
+		 ctx->config.image_height, ctx->config.fps,
+		 ctx->config.out_bpc);
+}
+
+static void decon_disable(struct exynos_drm_crtc *crtc)
+{
+	struct decon_context *ctx = crtc->ctx;
+
+	disable_irq(ctx->irq_fd);
+}
+
+static const struct exynos_drm_crtc_ops decon_crtc_ops = {
+	.atomic_enable = decon_enable,
+	.atomic_disable = decon_disable,
+	.mode_valid = decon_mode_valid,
+	.atomic_begin = decon_atomic_begin,
+	.update_plane = decon_update_plane,
+	.disable_plane = decon_disable_plane,
+	.atomic_flush = decon_atomic_flush,
+};
+
+/* H/W goes to stop or reset state when OS restarting during h/w operation */
+static void decon_reset(struct decon_context *ctx, int rpm_req)
+{
+	int ret;
+	struct decon_config config = { 0 };
+
+	ret = decon_reg_disable(ctx->idx, config);
+	if (ret) {
+		drm_err(ctx->drm_dev, "failed to try job_abort\n");
+	}
+}
+
+static enum drm_plane_type decon_get_win_type(int win_idx, int last_idx)
+{
+	if (win_idx == 0)
+		return DRM_PLANE_TYPE_PRIMARY;
+	else if (win_idx == last_idx)
+		return DRM_PLANE_TYPE_CURSOR;
+	else
+		return DRM_PLANE_TYPE_OVERLAY;
+};
+
+static const u32 dpp_gf_formats[] = {
+	DRM_FORMAT_ARGB8888,	DRM_FORMAT_ABGR8888,	DRM_FORMAT_RGBA8888,
+	DRM_FORMAT_BGRA8888,	DRM_FORMAT_XRGB8888,	DRM_FORMAT_XBGR8888,
+	DRM_FORMAT_RGBX8888,	DRM_FORMAT_BGRX8888,	DRM_FORMAT_RGB565,
+	DRM_FORMAT_BGR565,	DRM_FORMAT_ARGB2101010, DRM_FORMAT_ABGR2101010,
+	DRM_FORMAT_RGBA1010102, DRM_FORMAT_BGRA1010102,
+};
+
+static bool exynos_crtc_handle_vblank(struct exynos_drm_crtc *exynos_crtc)
+{
+	return drm_crtc_handle_vblank(&exynos_crtc->base);
+}
+
+static void exynos_crtc_delayed_vblank(struct work_struct *work)
+{
+	struct delayed_work *delayed_work =
+		container_of(work, struct delayed_work, work);
+	struct decon_context *ctx =
+		container_of(delayed_work, struct decon_context, dwork);
+
+	exynos_crtc_handle_vblank(ctx->crtc);
+}
+
+static int decon_bind(struct device *dev, struct device *master, void *data)
+{
+	struct decon_context *ctx = dev_get_drvdata(dev);
+	struct drm_device *drm_dev = data;
+	struct drm_plane *primary_plane = NULL;
+	struct exynos_drm_private *priv = drm_dev->dev_private;
+
+	int i, ret = 0;
+
+	/* Release a pm_runtime opposite to xxx_reset */
+	decon_reset(ctx, RPM_REQ_SUSPEND);
+
+	ctx->drm_dev = drm_dev;
+
+	for (i = 0; i < ctx->win_cnt; i++) {
+		struct decon_win *win = &ctx->win[i];
+		struct exynos_dpp_context *dpp = dev_get_drvdata(priv->dpp_dev);
+		ctx->win[i].dpp = dpp;
+
+		if (!dpp)
+			continue;
+
+		win->plane_config.pixel_formats = dpp_gf_formats;
+		win->plane_config.num_pixel_formats = 14;
+		win->plane_config.zpos = i;
+		win->plane_config.type =
+			decon_get_win_type(i, ctx->win_cnt - 1);
+
+		ret = exynos_plane_init(drm_dev, &win->plane, i,
+					&win->plane_config);
+		if (ret)
+			return ret;
+
+		if (win->plane_config.type == DRM_PLANE_TYPE_PRIMARY)
+			primary_plane = &win->plane.base;
+		// if (win->plane_config.type == DRM_PLANE_TYPE_CURSOR)
+		// 	cursor_plane = &win->plane.base;
+	}
+
+	ctx->crtc = exynos_drm_crtc_create(drm_dev, primary_plane, 0,
+					   &decon_crtc_ops, ctx);
+
+	INIT_DELAYED_WORK(&ctx->dwork, exynos_crtc_delayed_vblank);
+
+	if (IS_ERR(ctx->crtc))
+		return PTR_ERR(ctx->crtc);
+
+	//encoder, connector init. not this way
+	ctx->crtc->base.port = of_graph_get_port_by_id(dev->of_node, 0);
+
+	return 0;
+}
+
+static void decon_unbind(struct device *dev, struct device *master, void *data)
+{
+	struct decon_context *ctx = dev_get_drvdata(dev);
+	decon_disable(ctx->crtc);
+}
+
+static const struct component_ops decon_component_ops = {
+	.bind = decon_bind,
+	.unbind = decon_unbind,
+};
+
+static bool decon_get_window_update_req(struct exynos_drm_crtc *crtc)
+{
+	struct decon_context *ctx = crtc->ctx;
+	struct drm_plane *plane;
+
+	drm_for_each_plane_mask(plane, ctx->drm_dev, ctx->plane_mask) {
+		u32 win_idx = plane_to_decon_win(plane)->idx;
+
+		if (decon_reg_get_window_update_req(ctx->idx, win_idx))
+			return true;
+	}
+
+	return false;
+}
+
+static irqreturn_t decon_irq_handler(int irq, void *dev_id)
+{
+	struct decon_context *ctx = dev_id;
+
+	// decon_reg_clear_interrupt(ctx->idx, DECON_IRQ_FS);
+	decon_reg_clear_interrupt(ctx->idx, DECON_IRQ_FD);
+
+	decon_reg_get_shadow_update_req(ctx->idx);
+
+	if (ctx->config.mode.op_mode == DECON_VIDEO_MODE ||
+	    !decon_get_window_update_req(ctx->crtc)) {
+		drm_crtc_handle_vblank(&ctx->crtc->base);
+	}
+
+	return IRQ_HANDLED;
+}
+
+static int decon_probe(struct platform_device *pdev)
+{
+	int ret;
+	struct decon_context *ctx;
+	struct device *dev = &pdev->dev;
+	struct resource *res;
+
+	ctx = devm_kzalloc(dev, sizeof(struct decon_context), GFP_KERNEL);
+	if (!ctx)
+		return -ENOMEM;
+
+	ctx->dev = dev;
+	ctx->aclk = devm_clk_get_enabled(dev, "aclk");
+	if (IS_ERR(ctx->aclk))
+		return dev_err_probe(dev, PTR_ERR(ctx->aclk),
+				     "Cannot get aclk\n");
+
+	ctx->irq_fd = platform_get_irq(pdev, 0);
+	irq_set_status_flags(ctx->irq_fd, IRQ_NOAUTOEN);
+	ret = devm_request_irq(dev, ctx->irq_fd, decon_irq_handler,
+			       IRQF_ONESHOT, dev_name(dev), ctx);
+	if (ret)
+		return dev_err_probe(&pdev->dev, ret,
+				     "Failed to register interrupt handler\n");
+
+	ctx->type = 0;
+	ctx->win_max = 8;
+
+	ctx->win_cnt = 1;
+
+	ctx->win = devm_kzalloc(ctx->dev, sizeof(struct decon_win) * 8,
+				GFP_KERNEL);
+	if (!ctx->win)
+		return -ENOMEM;
+
+	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "main");
+	ctx->regs[0] = devm_ioremap_resource(dev, res);
+	regs_win[0] = ctx->regs[0];
+
+	regs_decon[0] = ctx->regs[0] + 0x8000;
+	regs_decon_con[0] = ctx->regs[0] + 0xc000;
+
+	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "sub0");
+	ctx->regs[1] = devm_ioremap_resource(dev, res);
+	regs_decon_global[0] = ctx->regs[1] + 0xa000;
+
+	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "sub1");
+	ctx->regs[2] = devm_ioremap_resource(dev, res);
+	regs_winctrl[0] = ctx->regs[2];
+
+	platform_set_drvdata(pdev, ctx);
+
+	return component_add(dev, &decon_component_ops);
+}
+
+struct platform_driver decon_driver = {
+	.probe		= decon_probe,
+	.driver		= {
+		.name	= "exynos9-decon",
+		.of_match_table = decon_driver_dt_match,
+	},
+};
diff --git a/drivers/gpu/drm/exynos/regs-decon9.h b/drivers/gpu/drm/exynos/regs-decon9.h
new file mode 100644
index 000000000000..e45ee71676cb
--- /dev/null
+++ b/drivers/gpu/drm/exynos/regs-decon9.h
@@ -0,0 +1,1244 @@ 
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#ifndef _REGS_DECON_H
+#define _REGS_DECON_H
+
+#define CHK_DPU_ID(_decon_idx) (_decon_idx >> 1)
+#define CHK_DECON_ID(_decon_idx) (_decon_idx & 0x1)
+#define SYSREG_DPUM 0x18C20000
+#define SYSREG_DPUS(_v) (0x1AA10000 + ((0x2 * (_v - 1)) << 20))
+#define SYSREG_DPU(_dpu_id) \
+	((_dpu_id == 0) ? SYSREG_DPUM : SYSREG_DPUS(_dpu_id))
+
+#define DISP_DPU_MIPI_PHY_CON 0x0008
+/* _v : [0,1] */
+#define SEL_RESET_DPHY_MASK(_v) (0x1 << (4 + (_v)))
+#define M_RESETN_M4S4_MODULE_MASK (0x1 << 1)
+#define M_RESETN_M4S4_TOP_MASK (0x1 << 0)
+
+#define DISP_DPU_TE_QACTIVE_PLL_EN 0x1010
+#define TE_QACTIVE_PLL_EN (0x1 << 0)
+
+/*
+ * [ BLK_DPU BASE ADDRESS ]
+ *
+ * - CMU_DPUM			0x18C0_0000
+ * - CMU_DPUS0 			0x1AA0_0000
+ * - CMU_DPUS1 			0x1AC0_0000
+ * - SYSREG_DPUM 		0x18C1_0000
+ * - SYSREG_DPUS0 		0x1AA1_0000
+ * - SYSREG_DPUS1 		0x1AC1_0000
+ * - DPP_DPUM 			0x18C2_0000
+ * - DPP_DPUS0 			0x1AA2_0000
+ * - DPP_DPUS1 			0x1AC2_0000
+ * - DECON0_DPUM 		0x18C3_0000
+ * - DECON1_DPUM 		0x18C4_0000
+ * - DECON0_DPUS0 		0x1AA3_0000
+ * - DECON1_DPUS0 		0x1AA4_0000
+ * - DECON0_DPUS1 		0x1AC3_0000
+ * - DECON1_DPUS1 		0x1AC4_0000
+ * - DPUM_DMA 			0x18C5_0000
+ * - DPUS0_DMA 			0x1AA5_0000
+ * - DPUS1_DMA 			0x1AC5_0000
+ * - MIPI_DSIM0 		0x18C6_0000
+ * - MIPI_DSIM1 		0x18C7_0000
+ * - MIPI_DPHY 			0x18D8_0000
+ * - SYSMMU_D0_DPUM 		0x18C8_0000
+ * - SYSMMU_D1_DPUM 		0x18C9_0000
+ * - SYSMMU_D2_DPUM 		0x18CA_0000
+ * - SYSMMU_D3_DPUM 		0x18CB_0000
+ * - SYSMMU_D0_DPUM_S 		0x18CC_0000
+ * - SYSMMU_D1_DPUM_S 		0x18CD_0000
+ * - SYSMMU_D2_DPUM_S 		0x18CE_0000
+ * - SYSMMU_D3_DPUM_S 		0x18CF_0000
+ * - SYSMMU_D0_DPUS0 		0x1AA8_0000
+ * - SYSMMU_D1_DPUS0 		0x1AA9_0000
+ * - SYSMMU_D2_DPUS0 		0x1AAA_0000
+ * - SYSMMU_D3_DPUS0 		0x1AAB_0000
+ * - SYSMMU_D0_DPUS0_S 		0x1AAC_0000
+ * - SYSMMU_D1_DPUS0_S 		0x1AAD_0000
+ * - SYSMMU_D2_DPUS0_S 		0x1AAE_0000
+ * - SYSMMU_D3_DPUS0_S 		0x1AAF_0000
+ * - SYSMMU_D0_DPUS1 		0x1AC8_0000
+ * - SYSMMU_D1_DPUS1 		0x1AC9_0000
+ * - SYSMMU_D2_DPUS1 		0x1ACA_0000
+ * - SYSMMU_D3_DPUS1 		0x1ACB_0000
+ * - SYSMMU_D0_DPUS1_S 		0x1ACC_0000
+ * - SYSMMU_D1_DPUS1_S 		0x1ACD_0000
+ * - SYSMMU_D2_DPUS1_S 		0x1ACE_0000
+ * - SYSMMU_D3_DPUS1_S 		0x1ACF_0000
+ * - PPMU_D0_DPUM 		0x18D0_0000
+ * - PPMU_D1_DPUM 		0x18D1_0000
+ * - PPMU_D2_DPUM 		0x18D2_0000
+ * - PPMU_D3_DPUM 		0x18D3_0000
+ * - PPMU_D0_DPUS0 		0x1AB0_0000
+ * - PPMU_D1_DPUS0 		0x1AB1_0000
+ * - PPMU_D2_DPUS0 		0x1AB2_0000
+ * - PPMU_D3_DPUS0 		0x1AB3_0000
+ * - PPMU_D0_DPUS1 		0x1AD0_0000
+ * - PPMU_D1_DPUS1 		0x1AD1_0000
+ * - PPMU_D2_DPUS1 		0x1AD2_0000
+ * - PPMU_D3_DPUS1 		0x1AD3_0000
+ * - BTM_D0_DPUM 		0x18D4_0000
+ * - BTM_D1_DPUM 		0x18D5_0000
+ * - BTM_D2_DPUM 		0x18D6_0000
+ * - BTM_D3_DPUM 		0x18D7_0000
+ * - BTM_D0_DPUS0 		0x1AB4_0000
+ * - BTM_D1_DPUS0 		0x1AB5_0000
+ * - BTM_D2_DPUS0 		0x1AB6_0000
+ * - BTM_D3_DPUS0 		0x1AB7_0000
+ * - BTM_D0_DPUS1 		0x1AD4_0000
+ * - BTM_D1_DPUS1 		0x1AD5_0000
+ * - BTM_D2_DPUS1 		0x1AD6_0000
+ * - BTM_D3_DPUS1 		0x1AD7_0000
+ * - VGEN_DPUM 			0x18DA_0000
+ * - VGEN_DPUS0 		0x1ABA_0000
+ * - VGEN_DPUS1 		0x1ADA_0000
+ * - D_TZPC_DPUM 		0x18DB_0000
+ * - D_TZPC_DPUS0 		0x1ABB_0000
+ * - D_TZPC_DPUS1 		0x1ADB_0000
+ */
+
+/*
+ *	IP			start_offset	end_offset
+ *=================================================
+ *	DECON0			0x8000		0x82A4
+ * 	DECON1			0x9000 		0x92A4
+ *	BLENDER			0x0004		0x701C
+ *-------------------------------------------------
+ *	DSC0			0x2000		0x2fff
+ *	DSC1			0x3000		0x3fff
+ *-------------------------------------------------
+ */
+
+/*
+ * DECON registers
+ * ->
+ * updated by
+ * SHADOW_REG_UPDATE_REQ[31] 		: 0x0000~0x0FFF
+ * SHADOW_REG_UPDATE_REQ_WIN5[0] 	: 0x10E0~0x110C (0x0218[22:20],0x0214[21:20])
+ * SHADOW_REG_UPDATE_REQ_WIN4[4] 	: 0x10B0~0x10DC (0x0218[18:16],0x0214[17:16])
+ * SHADOW_REG_UPDATE_REQ_WIN3[3] 	: 0x1090~0x10AC (0x0218[14:12],0x0214[13:12])
+ * SHADOW_REG_UPDATE_REQ_WIN2[2] 	: 0x1060~0x108C (0x0218[10:8] ,0x0214[9:8]  )
+ * SHADOW_REG_UPDATE_REQ_WIN1[1] 	: 0x1030~0x105C (0x0218[6:4]  ,0x0214[5:4]  )
+ * SHADOW_REG_UPDATE_REQ_WIN0[0] 	: 0x0004~0x001C (0x0218[2:0]  ,0x0214[1:0]  )
+ */
+
+/*
+ * DECON0 : Base Address + 0x8xxx
+ * DECON1 : Base Address + 0x9xxx
+ * Base Addr was defined by DT.
+ * DPUx_DECON0 : 0x****_8000
+ * DPUx_DECON1 : 0x****_9000
+ * ex) DPUM_DECON0 : 0x18C3_8000
+ */
+
+#define BASED_DECON0 0
+#define BASED_DECON1 1
+
+#define GLOBAL_CONTROL 0x0000
+#define GLOBAL_CONTROL_SRESET (1 << 28)
+#define GLOBAL_CONTROL_PSLVERR_EN (1 << 24)
+#define GLOBAL_CONTROL_TEN_BPC_MODE_F (1 << 20)
+#define GLOBAL_CONTROL_TEN_BPC_MODE_MASK (1 << 20)
+#define GLOBAL_CONTROL_STANDALONE_MODE_F (0x0 << 12)
+#define GLOBAL_CONTROL_OPERATION_MODE_VIDEO_BY_TE_F (1 << 9)
+#define GLOBAL_CONTROL_OPERATION_MODE_F (1 << 8)
+#define GLOBAL_CONTROL_OPERATION_MODE_VIDEO_F (0 << 8)
+#define GLOBAL_CONTROL_OPERATION_MODE_CMD_F (1 << 8)
+#define GLOBAL_CONTROL_IDLE_STATUS (1 << 5)
+#define GLOBAL_CONTROL_RUN_STATUS (1 << 4)
+#define GLOBAL_CONTROL_DECON_EN (1 << 1)
+#define GLOBAL_CONTROL_DECON_EN_F (1 << 0)
+
+#define RESOURCE_OCCUPANCY_INFO_0 0x0010
+#define RESOURCE_OCCUPANCY_INFO_1 0x0014
+#define RESOURCE_OCCUPANCY_INFO_2 0x0018
+
+#define SRAM_SHARE_ENABLE 0x0030
+#define SRAM0_SHARE_ENABLE_F (1 << 0)
+#define SRAM1_SHARE_ENABLE_F (1 << 4)
+#define SRAM2_SHARE_ENABLE_F (1 << 8)
+#define SRAM3_SHARE_ENABLE_F (1 << 12)
+#define SRAM4_SHARE_ENABLE_F (1 << 16)
+#define SRAM5_SHARE_ENABLE_F (1 << 20)
+#define SRAM6_SHARE_ENABLE_F (1 << 24)
+#define ALL_SRAM_SHARE_ENABLE (0x1111111 << 0)
+#define ALL_SRAM_SHARE_DISABLE (0x0)
+
+#define INTERRUPT_ENABLE 0x0040
+#define DPU_DQE_DIMMING_END_INT_EN (1 << 21)
+#define DPU_DQE_DIMMING_START_INT_EN (1 << 20)
+#define DPU_FRAME_DONE_INT_EN (1 << 13)
+#define DPU_FRAME_START_INT_EN (1 << 12)
+#define DPU_EXTRA_INT_EN (1 << 4)
+#define DPU_INT_EN (1 << 0)
+#define INTERRUPT_ENABLE_MASK 0x3011
+
+#define EXTRA_INTERRUPT_ENABLE 0x0044
+#define DPU_RESOURCE_CONFLICT_INT_EN (1 << 8)
+#define DPU_TIME_OUT_INT_EN (1 << 4)
+
+#define TIME_OUT_VALUE 0x0048
+
+#define INTERRUPT_PENDING 0x004C
+#define DPU_DQE_DIMMING_END_INT_PEND (1 << 21)
+#define DPU_DQE_DIMMING_START_INT_PEND (1 << 20)
+#define DPU_FRAME_DONE_INT_PEND (1 << 13)
+#define DPU_FRAME_START_INT_PEND (1 << 12)
+#define DPU_EXTRA_INT_PEND (1 << 4)
+
+#define EXTRA_INTERRUPT_PENDING 0x0050
+#define DPU_RESOURCE_CONFLICT_INT_PEND (1 << 8)
+#define DPU_TIME_OUT_INT_PEND (1 << 4)
+
+#define INTERRUPT_ENABLE_SFI 0x0054
+#define DPU_ECC_ERROR_SFI_INT_EN (1 << 5)
+#define DPU_FRAME_DONE_SFI_INT_EN (1 << 4)
+#define DPU_INT_EN_SFI (1 << 0)
+
+#define INTERRUPT_PENDING_SFI 0x0058
+#define DPU_ECC_ERROR_SFI_INT_PEND (1 << 5)
+#define DPU_FRAME_DONE_SFI_INT_PEND (1 << 4)
+
+#define HW_SW_TRIG_CONTROL 0x0070
+#define HW_SW_TRIG_HS_STATUS (1 << 28)
+#define HW_TRIG_SEL(_v) ((_v) << 24)
+#define HW_TRIG_SEL_MASK (0x3 << 24)
+#define HW_TRIG_SEL_FROM_DDI1 (1 << 24)
+#define HW_TRIG_SEL_FROM_DDI0 (0 << 24)
+#define HW_TRIG_SKIP(_v) ((_v) << 16)
+#define HW_TRIG_SKIP_MASK (0xff << 16)
+#define HW_TRIG_ACTIVE_VALUE (1 << 13)
+#define HW_TRIG_EDGE_POLARITY (1 << 12)
+#define SW_TRIG_EN (1 << 8)
+#define HW_TRIG_MASK_DECON (1 << 4)
+#define HW_SW_TRIG_TIMER_CLEAR (1 << 3)
+#define HW_SW_TRIG_TIMER_EN (1 << 2)
+#define HW_TRIG_EN (1 << 0)
+
+#define HW_SW_TRIG_TIMER 0x0074
+
+#define HW_TE_CNT 0x0078
+#define HW_TRIG_CNT_B_GET(_v) (((_v) >> 16) & 0xffff)
+#define HW_TRIG_CNT_A_GET(_v) (((_v) >> 0) & 0xffff)
+
+#define OTF_FRAME_START_SEL 0x0080
+#define OTF_FS_SEL_OTF(_v) ((_v) << 0)
+
+#define CLOCK_CONTROL_0 0x00F0
+/*
+ * [28] QACTIVE_PLL_VALUE = 0
+ * [24] QACTIVE_VALUE = 0
+ *   0: QACTIVE is dynamically changed by DECON h/w,
+ *   1: QACTIVE is stuck to 1'b1
+ * [16][12][8][4][0] AUTO_CG_EN_xxx
+ */
+/* clock gating is disabled on bringup */
+#define CLOCK_CONTROL_0_CG_MASK (0x11111 << 0)
+#define CLOCK_CONTROL_0_QACTIVE_MASK ((0x1 << 24) | (0x1 << 28))
+#define CLOCK_CONTROL_0_TE_QACTIVE_PLL_ON (0x1 << 28)
+
+#define SPLITTER_SIZE_CONTROL_0 0x0100
+#define SPLITTER_HEIGHT_F(_v) ((_v) << 16)
+#define SPLITTER_HEIGHT_MASK (0x3fff << 16)
+#define SPLITTER_HEIGHT_GET(_v) (((_v) >> 16) & 0x3fff)
+#define SPLITTER_WIDTH_F(_v) ((_v) << 0)
+#define SPLITTER_WIDTH_MASK (0x3fff << 0)
+#define SPLITTER_WIDTH_GET(_v) (((_v) >> 0) & 0x3fff)
+
+#define SPLITTER_SPLIT_IDX_CONTROL 0x0104
+#define SPLITTER_SPLIT_IDX_F(_v) ((_v) << 0)
+#define SPLITTER_SPLIT_IDX_MASK (0x3fff << 0)
+#define SPLITTER_OVERLAP_F(_v) ((_v) << 16)
+#define SPLITTER_OVERLAP_MASK (0x7f << 16)
+
+#define OUTFIFO_SIZE_CONTROL_0 0x0120
+#define OUTFIFO_HEIGHT_F(_v) ((_v) << 16)
+#define OUTFIFO_HEIGHT_MASK (0x3fff << 16)
+#define OUTFIFO_HEIGHT_GET(_v) (((_v) >> 16) & 0x3fff)
+#define OUTFIFO_WIDTH_F(_v) ((_v) << 0)
+#define OUTFIFO_WIDTH_MASK (0x3fff << 0)
+#define OUTFIFO_WIDTH_GET(_v) (((_v) >> 0) & 0x3fff)
+
+#define OUTFIFO_SIZE_CONTROL_1 0x0124
+#define OUTFIFO_1_WIDTH_F(_v) ((_v) << 0)
+#define OUTFIFO_1_WIDTH_MASK (0x3fff << 0)
+#define OUTFIFO_1_WIDTH_GET(_v) (((_v) >> 0) & 0x3fff)
+
+#define OUTFIFO_SIZE_CONTROL_2 0x0128
+#define OUTFIFO_COMPRESSED_SLICE_HEIGHT_F(_v) ((_v) << 16)
+#define OUTFIFO_COMPRESSED_SLICE_HEIGHT_MASK (0x3fff << 16)
+#define OUTFIFO_COMPRESSED_SLICE_HEIGHT_GET(_v) (((_v) >> 16) & 0x3fff)
+#define OUTFIFO_COMPRESSED_SLICE_WIDTH_F(_v) ((_v) << 0)
+#define OUTFIFO_COMPRESSED_SLICE_WIDTH_MASK (0x3fff << 0)
+#define OUTFIFO_COMPRESSED_SLICE_WIDTH_GET(_v) (((_v) >> 0) & 0x3fff)
+
+#define OUTFIFO_TH_CONTROL_0 0x012C
+#define OUTFIFO_TH_1H_F (0x5 << 0)
+#define OUTFIFO_TH_2H_F (0x6 << 0)
+#define OUTFIFO_TH_F(_v) ((_v) << 0)
+#define OUTFIFO_TH_MASK (0x7 << 0)
+#define OUTFIFO_TH_GET(_v) ((_v) >> 0 & 0x7)
+
+#define OUTFIFO_DATA_ORDER_CONTROL 0x0130
+#define OUTFIFO_PIXEL_ORDER_SWAP_F(_v) ((_v) << 4)
+#define OUTFIFO_PIXEL_ORDER_SWAP_MASK (0x7 << 4)
+#define OUTFIFO_PIXEL_ORDER_SWAP_GET(_v) (((_v) >> 4) & 0x7)
+
+#define OUTFIFO_LEVEL 0x0134
+#define OUTFIFO_FIFO_LEVEL_F(_v) (((_v) & 0xffff) << 0)
+
+#define READ_URGENT_CONTROL_0 0x0140
+#define READ_URGETN_GENERATION_EN_F (0x1 << 0)
+
+#define READ_URGENT_CONTROL_1 0x0144
+#define READ_URGENT_HIGH_THRESHOLD_F(_v) ((_v) << 16)
+#define READ_URGENT_HIGH_THRESHOLD_MASK (0xffff << 16)
+#define READ_URGENT_HIGH_THRESHOLD_GET(_v) (((_v) >> 16) & 0xffff)
+#define READ_URGENT_LOW_THRESHOLD_F(_v) ((_v) << 0)
+#define READ_URGENT_LOW_THRESHOLD_MASK (0xffff << 0)
+#define READ_URGENT_LOW_THRESHOLD_GET(_v) (((_v) >> 0) & 0xffff)
+
+#define READ_URGENT_CONTROL_2 0x0148
+#define READ_URGENT_WAIT_CYCLE_F(_v) ((_v) << 0)
+#define READ_URGENT_WAIT_CYCLE_GET(_v) ((_v) >> 0)
+
+#define DTA_CONTROL 0x0180
+#define DTA_EN_F (1 << 0)
+
+#define DTA_THRESHOLD 0x0184
+#define DTA_HIGH_TH_F(_v) ((_v) << 16)
+#define DTA_HIGH_TH_MASK (0xffff << 16)
+#define DTA_HIGH_TH_GET(_v) (((_v) >> 16) & 0xffff)
+#define DTA_LOW_TH_F(_v) ((_v) << 0)
+#define DTA_LOW_TH_MASK (0xffff << 0)
+#define DTA_LOW_TH_GET(_v) (((_v) >> 0) & 0xffff)
+
+#define BLENDER_BG_IMAGE_SIZE_0 0x0200
+#define BLENDER_BG_HEIGHT_F(_v) ((_v) << 16)
+#define BLENDER_BG_HEIGHT_MASK (0x3fff << 16)
+#define BLENDER_BG_HEIGHT_GET(_v) (((_v) >> 16) & 0x3fff)
+#define BLENDER_BG_WIDTH_F(_v) ((_v) << 0)
+#define BLENDER_BG_WIDTH_MASK (0x3fff << 0)
+#define BLENDER_BG_WIDTH_GET(_v) (((_v) >> 0) & 0x3fff)
+
+#define BLENDER_BG_IMAGE_COLOR_0 0x0208
+#define BLENDER_BG_A_F(_v) ((_v) << 16)
+#define BLENDER_BG_A_MASK (0xff << 16)
+#define BLENDER_BG_A_GET(_v) (((_v) >> 16) & 0xff)
+#define BLENDER_BG_R_F(_v) ((_v) << 0)
+#define BLENDER_BG_R_MASK (0x3ff << 0)
+#define BLENDER_BG_R_GET(_v) (((_v) >> 0) & 0x3ff)
+
+#define BLENDER_BG_IMAGE_COLOR_1 0x020C
+#define BLENDER_BG_G_F(_v) ((_v) << 16)
+#define BLENDER_BG_G_MASK (0x3ff << 16)
+#define BLENDER_BG_G_GET(_v) (((_v) >> 16) & 0x3ff)
+#define BLENDER_BG_B_F(_v) ((_v) << 0)
+#define BLENDER_BG_B_MASK (0x3ff << 0)
+#define BLENDER_BG_B_GET(_v) (((_v) >> 0) & 0x3ff)
+
+#define LRMERGER_MODE_CONTROL 0x0210
+#define LRM23_MODE_F(_v) ((_v) << 16)
+#define LRM23_MODE_MASK (0x7 << 16)
+#define LRM01_MODE_F(_v) ((_v) << 0)
+#define LRM01_MODE_MASK (0x7 << 0)
+
+#define DATA_PATH_CONTROL_0 0x0214
+#define WIN_MAPCOLOR_EN_F(_win) (1 << (4 * _win + 1))
+#define WIN_EN_F(_win) (1 << (4 * _win + 0))
+
+#define DATA_PATH_CONTROL_1 0x0218
+#define WIN_CHMAP_F(_win, _ch) (((_ch) & 0xf) << (4 * _win))
+#define WIN_CHMAP_MASK(_win) (0xf << (4 * _win))
+
+#define DATA_PATH_CONTROL_2 0x0230
+#define EHNANCE_PATH_F(_v) ((_v) << 12)
+#define EHNANCE_PATH_MASK (0x7 << 12)
+#define EHNANCE_PATH_GET(_v) (((_v) >> 12) & 0x7)
+
+#define DSC_PATH_F(_v) ((_v) << 4)
+#define DSC_PATH_MASK (0xF << 4)
+#define DSC_PATH_GET(_v) (((_v) >> 4) & 0xF)
+
+#define OUTIF_PATH_F(_v) ((_v) << 0)
+#define OUTIF_PATH_MASK (0xF << 0)
+#define OUTIF_PATH_GET(_v) (((_v) >> 0) & 0xF)
+
+#define COMP_OUTIF_PATH_F(_v) ((_v) << 0)
+#define COMP_OUTIF_PATH_MASK (0xff << 0)
+#define COMP_OUTIF_PATH_GET(_v) (((_v) >> 0) & 0xff)
+
+#define OTF_DITH_CONTROL 0x0270
+#define DITH_MASK_SEL_F (1 << 1)
+#define DITH_MASK_SPIN_F (1 << 0)
+
+/* DECON CRC for ASB */
+#define CRC_LINKIF_DATA_0 0x0280
+#define CRC_DATA_DSIMIF1_GET(_v) (((_v) >> 16) & 0xffff)
+#define CRC_DATA_DSIMIF0_GET(_v) (((_v) >> 0) & 0xffff)
+
+#define CRC_LINKIF_DATA_2 0x0288
+#define CRC_DATA_DP1_GET(_v) (((_v) >> 16) & 0xffff)
+#define CRC_DATA_DP0_GET(_v) (((_v) >> 0) & 0xffff)
+
+#define CRC_LINKIF_CONTROL 0x028C
+#define CRC_COLOR_SEL(_v) ((_v) << 16)
+#define CRC_COLOR_SEL_MASK (0x3 << 16)
+#define CRC_START (1 << 0)
+
+#define FRAME_COUNT 0x02A0
+
+/* WAIT_CYCLE_AFTER_SFR_UPDATE register is hidden for customer. */
+#define WAIT_CYCLE_AFTER_SFR_UPDATE 0x02A4
+#define WAIT_CYCLE_AFTER_SFR_UPDATE_F(_v) (((_v) & 0x1f) << 0)
+
+/* DECON DEBUG guided from SoC Team */
+#define DECON_DEBUG_SFR_START 0x0400
+#define DECON_DEBUG_SFR_END 0x05FC
+
+/* COMMON SFR DECON0 AND DECON1 */
+#define DECON_CONIF_BASE 0x0000
+#define DSIM0_CONIF_BASE (DECON_CONIF_BASE + 0x0000)
+#define DSIM1_CONIF_BASE (DECON_CONIF_BASE + 0x1000)
+#define DP0_CONIF_BASE (DECON_CONIF_BASE + 0x2000)
+#define DP1_CONIF_BASE (DECON_CONIF_BASE + 0x3000)
+
+#define DSIM0_CONNECTION_CONTROL (DSIM0_CONIF_BASE + 0x0000)
+#define DSIM1_CONNECTION_CONTROL (DSIM1_CONIF_BASE + 0x0000)
+#define DSIM_CONNECTION_DSIM_F(_v) (((_v) & 0x3) << 0)
+#define DSIM_CONNECTION_DSIM_GET(_v) (((_v) >> 0) & 0x3)
+#define DSIM_CONNECTION_DSIM_MASK (0x7 << 0)
+
+#define DSIM0_TE_TIMEOUT_CONTROL (DSIM0_CONIF_BASE + 0x0004)
+#define DSIM1_TE_TIMEOUT_CONTROL (DSIM1_CONIF_BASE + 0x0004)
+#define DSIM_TE_TIMEOUT_CNT(_v) ((_v) << 0)
+#define DSIM_TE_TIMEOUT_CNT_MASK (0xffff << 0)
+#define DSIM_TE_TIMEOUT_CNT_GET(_v) (((_v) >> 0) & 0xffff)
+
+#define DSIM0_START_TIME_CONTROL (DSIM0_CONIF_BASE + 0x0008)
+#define DSIM0_START_TIME(_v) ((_v) << 0)
+
+#define DSIM1_START_TIME_CONTROL (DSIM1_CONIF_BASE + 0x0008)
+#define DSIM1_START_TIME(_v) ((_v) << 0)
+
+#define DP0_CONNECTION_CONTROL_0 DP0_CONIF_BASE
+#define DP1_CONNECTION_CONTROL_0 DP1_CONIF_BASE
+#define DP_CONNECTION_SEL_ATB_F(_v) (((_v) & 0x7) << 4)
+#define DP_CONNECTION_SEL_F(_v) (((_v) & 0x7) << 0)
+#define DP_CONNECTION_SEL_ATB_MASK (0x7 << 4)
+#define DP_CONNECTION_SEL_MASK (0x7 << 0)
+#define DP_CONNECTION_SEL_GET(_v) (((_v) >> 0) & 0x7)
+
+/* DECON GLOBAL */
+#define SHADOW_REG_UPDATE_REQ 0x0000
+#define SHADOW_REG_UPDATE_REQ_GLOBAL (1 << 31)
+#define SHADOW_REG_UPDATE_REQ_DQE (1 << 28)
+#define SHADOW_REG_UPDATE_REQ_WIN(_win) (1 << (_win))
+#define SHADOW_REG_UPDATE_REQ_FOR_DECON (0xff)
+
+#define HW_TRIG_MASK 0x0030
+#define HW_TRIG_MASK_SECURE 0x0034
+
+/* BLENDER */
+
+#define WIN_SHD_OFFSET 0x0800
+
+#define WIN_SECURE_CONTROL 0x0000
+
+#define WIN_CONTROL_0 0x0004
+#define WIN_ALPHA1_F(_v) (((_v) & 0xFF) << 24)
+#define WIN_ALPHA1_MASK (0xFF << 24)
+#define WIN_ALPHA0_F(_v) (((_v) & 0xFF) << 16)
+#define WIN_ALPHA0_MASK (0xFF << 16)
+#define WIN_ALPHA_GET(_v, _n) (((_v) >> (16 + 8 * (_n))) & 0xFF)
+#define WIN_FUNC_F(_v) (((_v) & 0xF) << 8)
+#define WIN_FUNC_MASK (0xF << 8)
+#define WIN_FUNC_GET(_v) (((_v) >> 8) & 0xf)
+#define WIN_SRESET (1 << 4)
+#define WIN_ALPHA_MULT_SRC_SEL_F(_v) (((_v) & 0x3) << 0)
+#define WIN_ALPHA_MULT_SRC_SEL_MASK (0x3 << 0)
+
+#define WIN_CONTROL_1 0x0008
+#define WIN_FG_ALPHA_D_SEL_F(_v) (((_v) & 0xF) << 24)
+#define WIN_FG_ALPHA_D_SEL_MASK (0xF << 24)
+#define WIN_BG_ALPHA_D_SEL_F(_v) (((_v) & 0xF) << 16)
+#define WIN_BG_ALPHA_D_SEL_MASK (0xF << 16)
+#define WIN_FG_ALPHA_A_SEL_F(_v) (((_v) & 0xF) << 8)
+#define WIN_FG_ALPHA_A_SEL_MASK (0xF << 8)
+#define WIN_BG_ALPHA_A_SEL_F(_v) (((_v) & 0xF) << 0)
+#define WIN_BG_ALPHA_A_SEL_MASK (0xF << 0)
+
+#define WIN_START_POSITION 0x000C
+#define WIN_STRPTR_Y_F(_v) (((_v) & 0x3FFF) << 16)
+#define WIN_STRPTR_X_F(_v) (((_v) & 0x3FFF) << 0)
+
+#define WIN_END_POSITION 0x0010
+#define WIN_ENDPTR_Y_F(_v) (((_v) & 0x3FFF) << 16)
+#define WIN_ENDPTR_X_F(_v) (((_v) & 0x3FFF) << 0)
+
+#define WIN_COLORMAP_0 0x0014
+#define WIN_MAPCOLOR_A_F(_v) ((_v) << 16)
+#define WIN_MAPCOLOR_A_MASK (0xff << 16)
+#define WIN_MAPCOLOR_R_F(_v) ((_v) << 0)
+#define WIN_MAPCOLOR_R_MASK (0x3ff << 0)
+
+#define WIN_COLORMAP_1 0x0018
+#define WIN_MAPCOLOR_G_F(_v) ((_v) << 16)
+#define WIN_MAPCOLOR_G_MASK (0x3ff << 16)
+#define WIN_MAPCOLOR_B_F(_v) ((_v) << 0)
+#define WIN_MAPCOLOR_B_MASK (0x3ff << 0)
+
+#define WIN_START_TIME_CONTROL 0x001C
+#define WIN_START_TIME_CONTROL_F(_v) ((_v) << 0)
+#define WIN_START_TIME_CONTROL_MASK (0x3fff << 0)
+
+/*
+ * DSC registers (Base Addr = DECON_SUB0 + 0x2000)
+ * ->
+ * 0x2000 ~
+ * DSC 0 : 0x0000
+ * DSC 1 : 0x1000
+ *
+ * <-
+ * DSC registers
+ */
+
+#define DSC0_OFFSET 0x0000
+#define DSC1_OFFSET 0x1000
+
+#define DSC_CONTROL0 0x0000
+#define DSC_SW_RESET (0x1 << 28)
+#define DSC_DCG_EN_REF(_v) ((_v) << 19)
+#define DSC_DCG_EN_SSM(_v) ((_v) << 18)
+#define DSC_DCG_EN_ICH(_v) ((_v) << 17)
+#define DSC_DCG_EN_ALL_OFF (0x0 << 17)
+#define DSC_DCG_EN_ALL_MASK (0x7 << 17)
+#define DSC_BIT_SWAP(_v) ((_v) << 10)
+#define DSC_BYTE_SWAP(_v) ((_v) << 9)
+#define DSC_WORD_SWAP(_v) ((_v) << 8)
+#define DSC_SWAP(_b, _c, _w) ((_b << 10) | (_c << 9) | (_w << 8))
+#define DSC_SWAP_MASK ((1 << 10) | (1 << 9) | (1 << 8))
+#define DSC_FLATNESS_DET_TH_MASK (0xf << 4)
+#define DSC_FLATNESS_DET_TH_F(_v) ((_v) << 4)
+#define DSC_SLICE_MODE_CH_MASK (0x1 << 3)
+#define DSC_SLICE_MODE_CH_F(_v) ((_v) << 3)
+#define DSC_CG_EN_MASK (0x1 << 1)
+#define DSC_CG_EN_F(_v) ((_v) << 1)
+#define DSC_DUAL_SLICE_EN_MASK (0x1 << 0)
+#define DSC_DUAL_SLICE_EN_F(_v) ((_v) << 0)
+
+#define DSC_CONTROL3 0x000C
+#define DSC_REMAINDER_F(_v) ((_v) << 12)
+#define DSC_REMAINDER_MASK (0x3 << 12)
+#define DSC_REMAINDER_GET(_v) (((_v) >> 12) & 0x3)
+#define DSC_GRPCNTLINE_F(_v) ((_v) << 0)
+#define DSC_GRPCNTLINE_MASK (0x7ff << 0)
+#define DSC_GRPCNTLINE_GET(_v) (((_v) >> 0) & 0x7ff)
+
+#define DSC_CRC_0 0x0010
+#define DSC_CRC_EN_MASK (0x1 << 16)
+#define DSC_CRC_EN_F(_v) ((_v) << 16)
+#define DSC_CRC_CODE_MASK (0xffff << 0)
+#define DSC_CRC_CODE_F(_v) ((_v) << 0)
+
+#define DSC_CRC_1 0x0014
+#define DSC_CRC_Y_S0_MASK (0xffff << 16)
+#define DSC_CRC_Y_S0_F(_v) ((_v) << 16)
+#define DSC_CRC_CO_S0_MASK (0xffff << 0)
+#define DSC_CRC_CO_S0_F(_v) ((_v) << 0)
+
+#define DSC_CRC_2 0x0018
+#define DSC_CRC_CG_S0_MASK (0xffff << 16)
+#define DSC_CRC_CG_S0_F(_v) ((_v) << 16)
+#define DSC_CRC_Y_S1_MASK (0xffff << 0)
+#define DSC_CRC_Y_S1_F(_v) ((_v) << 0)
+
+#define DSC_CRC_3 0x001C
+#define DSC_CRC_CO_S1_MASK (0xffff << 16)
+#define DSC_CRC_CO_S1_F(_v) ((_v) << 16)
+#define DSC_CRC_CG_S1_MASK (0xffff << 0)
+#define DSC_CRC_CG_S1_F(_v) ((_v) << 0)
+
+#define DSC_PPS00_03 0x0020
+#define PPS00_VER(_v) ((_v) << 24)
+#define PPS00_VER_MASK (0xff << 24)
+#define PPS01_ID(_v) (_v << 16)
+#define PPS01_ID_MASK (0xff << 16)
+#define PPS03_BPC_MASK (0x00f0 << 0)
+#define PPS03_LBD_MASK (0x000f << 0)
+#define PPS03_BPC_LBD(_v) (_v << 0)
+
+#define DSC_PPS04_07 0x0024
+#define PPS04_COMP_CFG(_v) ((_v) << 24)
+#define PPS04_COMP_CFG_MASK (0x3f << 24)
+#define PPS05_BPP(_v) (_v << 16)
+#define PPS05_BPP_MASK (0xff << 16)
+#define PPS06_07_PIC_HEIGHT_MASK (0xffff << 0)
+#define PPS06_07_PIC_HEIGHT(_v) (_v << 0)
+
+#define DSC_PPS08_11 0x0028
+#define PPS08_09_PIC_WIDHT_MASK (0xffff << 16)
+#define PPS08_09_PIC_WIDHT(_v) ((_v) << 16)
+#define PPS10_11_SLICE_HEIGHT_MASK (0xffff << 0)
+#define PPS10_11_SLICE_HEIGHT(_v) (_v << 0)
+
+#define DSC_PPS12_15 0x002C
+#define PPS12_13_SLICE_WIDTH_MASK (0xffff << 16)
+#define PPS12_13_SLICE_WIDTH(_v) ((_v) << 16)
+#define PPS14_15_CHUNK_SIZE_MASK (0xffff << 0)
+#define PPS14_15_CHUNK_SIZE(_v) (_v << 0)
+
+#define DSC_PPS16_19 0x0030
+#define PPS16_17_INIT_XMIT_DELAY_MASK (0x3ff << 16)
+#define PPS16_17_INIT_XMIT_DELAY(_v) ((_v) << 16)
+#define PPS18_19_INIT_DEC_DELAY_MASK (0xffff << 0)
+#define PPS18_19_INIT_DEC_DELAY(_v) ((_v) << 0)
+
+#define DSC_PPS20_23 0x0034
+#define PPS21_INIT_SCALE_VALUE_MASK (0x3f << 16)
+#define PPS21_INIT_SCALE_VALUE(_v) ((_v) << 16)
+#define PPS22_23_SCALE_INC_INTERVAL_MASK (0xffff << 0)
+#define PPS22_23_SCALE_INC_INTERVAL(_v) (_v << 0)
+
+#define DSC_PPS24_27 0x0038
+#define PPS24_25_SCALE_DEC_INTERVAL_MASK (0xfff << 16)
+#define PPS24_25_SCALE_DEC_INTERVAL(_v) ((_v) << 16)
+/* FL : First Line */
+#define PPS27_FL_BPG_OFFSET_MASK (0x1f << 0)
+#define PPS27_FL_BPG_OFFSET(_v) (_v << 0)
+
+#define DSC_PPS28_31 0x003C
+/* NFL : Not First Line */
+#define PPS28_29_NFL_BPG_OFFSET_MASK (0xffff << 16)
+#define PPS28_29_NFL_BPG_OFFSET(_v) ((_v) << 16)
+#define PPS30_31_SLICE_BPG_OFFSET_MASK (0xffff << 0)
+#define PPS30_31_SLICE_BPG_OFFSET(_v) (_v << 0)
+
+#define DSC_PPS32_35 0x0040
+#define PPS32_33_INIT_OFFSET_MASK (0xffff << 16)
+#define PPS32_33_INIT_OFFSET(_v) ((_v) << 16)
+#define PPS34_35_FINAL_OFFSET_MASK (0xffff << 0)
+#define PPS34_35_FINAL_OFFSET(_v) (_v << 0)
+
+#define DSC_PPS36_39 0x0044
+#define PPS36_FLATNESS_MIN_QP_MASK (0xff << 24)
+#define PPS36_FLATNESS_MIN_QP(_v) ((_v) << 24)
+#define PPS37_FLATNESS_MAX_QP_MASK (0xff << 16)
+#define PPS37_FLATNESS_MAX_QP(_v) ((_v) << 16)
+#define PPS38_39_RC_MODEL_SIZE_MASK (0xffff << 0)
+#define PPS38_39_RC_MODEL_SIZE(_v) (_v << 0)
+
+#define DSC_PPS40_43 0x0048
+#define PPS40_RC_EDGE_FACTOR_MASK (0xff << 24)
+#define PPS40_RC_EDGE_FACTOR(_v) ((_v) << 24)
+#define PPS41_RC_QUANT_INCR_LIMIT0_MASK (0xff << 16)
+#define PPS41_RC_QUANT_INCR_LIMIT0(_v) ((_v) << 16)
+#define PPS42_RC_QUANT_INCR_LIMIT1_MASK (0xff << 8)
+#define PPS42_RC_QUANT_INCR_LIMIT1(_v) ((_v) << 8)
+#define PPS44_RC_TGT_OFFSET_HI_MASK (0xf << 4)
+#define PPS44_RC_TGT_OFFSET_HI(_v) ((_v) << 4)
+#define PPS44_RC_TGT_OFFSET_LO_MASK (0xf << 0)
+#define PPS44_RC_TGT_OFFSET_LO(_v) ((_v) << 0)
+
+#define DSC_PPS44_47 0x004C
+#define PPS44_RC_BUF_THRESH_0_MASK (0xff << 24)
+#define PPS44_RC_BUF_THRESH_0(_v) ((_v) << 24)
+#define PPS45_RC_BUF_THRESH_1_MASK (0xff << 16)
+#define PPS45_RC_BUF_THRESH_1(_v) ((_v) << 16)
+#define PPS46_RC_BUF_THRESH_2_MASK (0xff << 8)
+#define PPS46_RC_BUF_THRESH_3(_v) ((_v) << 8)
+#define PPS47_RC_BUF_THRESH_3_MASK (0xff << 0)
+#define PPS47_RC_BUF_THRESH_3(_v) ((_v) << 0)
+
+#define DSC_PPS48_51 0x0050
+#define PPS48_RC_BUF_THRESH_4_MASK (0xff << 24)
+#define PPS48_RC_BUF_THRESH_4(_v) ((_v) << 24)
+#define PPS49_RC_BUF_THRESH_5_MASK (0xff << 16)
+#define PPS49_RC_BUF_THRESH_5(_v) ((_v) << 16)
+#define PPS50_RC_BUF_THRESH_6_MASK (0xff << 8)
+#define PPS50_RC_BUF_THRESH_6(_v) ((_v) << 8)
+#define PPS51_RC_BUF_THRESH_7_MASK (0xff << 0)
+#define PPS51_RC_BUF_THRESH_7(_v) ((_v) << 0)
+
+#define DSC_PPS52_55 0x0054
+#define PPS52_RC_BUF_THRESH_8_MASK (0xff << 24)
+#define PPS52_RC_BUF_THRESH_8(_v) ((_v) << 24)
+#define PPS53_RC_BUF_THRESH_9_MASK (0xff << 16)
+#define PPS53_RC_BUF_THRESH_9(_v) ((_v) << 16)
+#define PPS54_RC_BUF_THRESH_A_MASK (0xff << 8)
+#define PPS54_RC_BUF_THRESH_A(_v) ((_v) << 8)
+#define PPS55_RC_BUF_THRESH_B_MASK (0xff << 0)
+#define PPS55_RC_BUF_THRESH_B(_v) ((_v) << 0)
+
+#define DSC_PPS56_59 0x0058
+#define PPS56_RC_BUF_THRESH_C_MASK (0xff << 24)
+#define PPS56_RC_BUF_THRESH_C(_v) ((_v) << 24)
+#define PPS57_RC_BUF_THRESH_D_MASK (0xff << 16)
+#define PPS57_RC_BUF_THRESH_D(_v) ((_v) << 16)
+#define PPS58_RC_RANGE_PARAM_MASK (0xff << 8)
+#define PPS58_RC_RANGE_PARAM(_v) (_v << 8)
+#define PPS59_RC_RANGE_PARAM_MASK (0xff << 0)
+#define PPS59_RC_RANGE_PARAM(_v) (_v << 0)
+#define PPS58_59_RC_RANGE_PARAM_MASK (0xFFFF << 0)
+#define PPS58_59_RC_RANGE_PARAM(_v) (_v << 0)
+
+#define DSC_PPS60_63 0x005C
+#define DSC_PPS64_67 0x0060
+#define DSC_PPS68_71 0x0064
+#define DSC_PPS72_75 0x0068
+#define DSC_PPS76_79 0x006C
+#define DSC_PPS80_83 0x0070
+#define DSC_PPS84_87 0x0074
+
+#define DSC_DEBUG_EN 0x0078
+#define DSC_DBG_EN_MASK (1 << 31)
+#define DSC_DBG_EN(_v) ((_v) << 31)
+#define DSC_DBG_SEL_MASK (0xffff << 0)
+#define DSC_DBG_SEL(_v) ((_v) << 0)
+
+#define DSC_DEBUG_DATA 0x007C
+
+#define DSCC_DEBUG_EN 0x0080
+#define DSCC_DBG_EN_MASK (1 << 31)
+#define DSCC_DBG_EN(_v) ((_v) << 31)
+#define DSCC_DBG_SEL_MASK (0xffff << 0)
+#define DSCC_DBG_SEL(_v) ((_v) << 0)
+
+#define DSCC_DEBUG_DATA 0x0084
+
+/*
+ * DQE registers (Base Addr : DECON1)
+ * ->
+ * 0x0000 ~
+ * DQE 0 : 0x0000
+ * DQE 1 : 0x1000
+ *
+ * <-
+ * DQE registers
+ */
+
+#define DQE0_OFFSET 0x0000
+#define DQE1_OFFSET 0x1000
+#define DQE_OFFSET(_id) ((_id == 0) ? DQE0_OFFSET : DQE1_OFFSET)
+
+#define DQE_CON(_id) (0x0000 + DQE_OFFSET(_id))
+#define DQE_LPD_MODE_EXIT(_v) ((_v) << 24)
+#define DQE_LPD_MODE_EXIT_MASK (1 << 24)
+#define DQE_APS_SW_RESET(_v) ((_v) << 18)
+#define DQE_APD_SW_RESET_MASK (1 << 18)
+#define DQE_APD_SW_RESET_CLEAR (0 << 18)
+#define DQE_HSC_SW_RESET(_v) ((_v) << 16)
+#define DQE_HSC_SW_RESET_MASK (1 << 16)
+#define DQE_HSC_SW_RESET_CLEAR (0 << 16)
+#define PN_NEXT_CALC(_v) ((_v) << 7)
+#define PN_NEXT_CALC_NEW (0 << 7)
+#define PN_NEXT_CALC_OLD (1 << 7)
+#define APS_UPGRADE_ON(_v) ((_v) << 6)
+#define APS_UPGRADE_ON_MASK (1 << 6)
+#define DQE_APS_ON(_v) ((_v) << 4)
+#define DQE_APS_ON_MASK (1 << 4)
+#define DQE_HSC_ON(_v) ((_v) << 3)
+#define DQE_HSC_ON_MASK (1 << 3)
+#define DQE_GAMMA_ON(_v) ((_v) << 2)
+#define DQE_GAMMA_ON_MASK (1 << 2)
+#define DQE_CGC_ON(_v) ((_v) << 1)
+#define DQE_CGC_ON_MASK (1 << 1)
+
+#define DQE_IMG_SIZESET_0(_id) (0x0004 + DQE_OFFSET(_id))
+#define DQE_IMG_VSIZE_0(_v) (((_v) & 0x3fff) << 16)
+#define DQE_IMG_VSIZE_0_MASK (0x3fff << 16)
+#define DQE_IMG_HSIZE_0(_v) (((_v) & 0x3fff) << 0)
+#define DQE_IMG_HSIZE_0_MASK (0x3fff << 0)
+
+#define DQE_CGC1_RED(_id) (0x0010 + DQE_OFFSET(_id))
+#define DQE_CGC2_RED(_id) (0x0410 + DQE_OFFSET(_id))
+#define CGC_R_R(_v) (((_v) & 0x3ff) << 20)
+#define CGC_R_R_MASK (0x3ff << 20)
+#define CGC_R_G(_v) (((_v) & 0x3ff) << 10)
+#define CGC_R_G_MASK (0x3ff << 10)
+#define CGC_R_B(_v) (((_v) & 0x3ff) << 0)
+#define CGC_R_B_MASK (0x3ff << 0)
+
+#define DQE_CGC1_GREEN(_id) (0x0014 + DQE_OFFSET(_id))
+#define DQE_CGC2_GREEN(_id) (0x0414 + DQE_OFFSET(_id))
+#define CGC_G_R(_v) (((_v) & 0x3ff) << 20)
+#define CGC_G_R_MASK (0x3ff << 20)
+#define CGC_G_G(_v) (((_v) & 0x3ff) << 10)
+#define CGC_G_G_MASK (0x3ff << 10)
+#define CGC_G_B(_v) (((_v) & 0x3ff) << 0)
+#define CGC_G_B_MASK (0x3ff << 0)
+
+#define DQE_CGC1_BLUE(_id) (0x0018 + DQE_OFFSET(_id))
+#define DQE_CGC2_BLUE(_id) (0x0418 + DQE_OFFSET(_id))
+#define CGC_B_R(_v) (((_v) & 0x3ff) << 20)
+#define CGC_B_R_MASK (0x3ff << 20)
+#define CGC_B_G(_v) (((_v) & 0x3ff) << 10)
+#define CGC_B_G_MASK (0x3ff << 10)
+#define CGC_B_B(_v) (((_v) & 0x3ff) << 0)
+#define CGC_B_B_MASK (0x3ff << 0)
+
+#define DQE_CGC1_CYAN(_id) (0x001C + DQE_OFFSET(_id))
+#define DQE_CGC2_CYAN(_id) (0x041C + DQE_OFFSET(_id))
+#define CGC_C_R(_v) (((_v) & 0x3ff) << 20)
+#define CGC_C_R_MASK (0x3ff << 20)
+#define CGC_C_G(_v) (((_v) & 0x3ff) << 10)
+#define CGC_C_G_MASK (0x3ff << 10)
+#define CGC_C_B(_v) (((_v) & 0x3ff) << 0)
+#define CGC_C_B_MASK (0x3ff << 0)
+
+#define DQE_CGC1_MAGENTA(_id) (0x0020 + DQE_OFFSET(_id))
+#define DQE_CGC2_MAGENTA(_id) (0x0420 + DQE_OFFSET(_id))
+#define CGC_M_R(_v) (((_v) & 0x3ff) << 20)
+#define CGC_M_R_MASK (0x3ff << 20)
+#define CGC_M_G(_v) (((_v) & 0x3ff) << 10)
+#define CGC_M_G_MASK (0x3ff << 10)
+#define CGC_M_B(_v) (((_v) & 0x3ff) << 0)
+#define CGC_M_B_MASK (0x3ff << 0)
+
+#define DQE_CGC1_YELLOW(_id) (0x0024 + DQE_OFFSET(_id))
+#define DQE_CGC2_YELLOW(_id) (0x0424 + DQE_OFFSET(_id))
+#define CGC_Y_R(_v) (((_v) & 0x3ff) << 20)
+#define CGC_Y_R_MASK (0x3ff << 20)
+#define CGC_Y_G(_v) (((_v) & 0x3ff) << 10)
+#define CGC_Y_G_MASK (0x3ff << 10)
+#define CGC_Y_B(_v) (((_v) & 0x3ff) << 0)
+#define CGC_Y_B_MASK (0x3ff << 0)
+
+#define DQE_CGC1_WHITE(_id) (0x0028 + DQE_OFFSET(_id))
+#define DQE_CGC2_WHITE(_id) (0x0428 + DQE_OFFSET(_id))
+#define CGC_W_R(_v) (((_v) & 0x3ff) << 20)
+#define CGC_W_R_MASK (0x3ff << 20)
+#define CGC_W_G(_v) (((_v) & 0x3ff) << 10)
+#define CGC_W_G_MASK (0x3ff << 10)
+#define CGC_W_B(_v) (((_v) & 0x3ff) << 0)
+#define CGC_W_B_MASK (0x3ff << 0)
+
+#define DQE_CGC1_BLACK(_id) (0x002C + DQE_OFFSET(_id))
+#define DQE_CGC2_BLACK(_id) (0x042C + DQE_OFFSET(_id))
+#define CGC_K_R(_v) (((_v) & 0x3ff) << 20)
+#define CGC_K_R_MASK (0x3ff << 20)
+#define CGC_K_G(_v) (((_v) & 0x3ff) << 10)
+#define CGC_K_G_MASK (0x3ff << 10)
+#define CGC_K_B(_v) (((_v) & 0x3ff) << 0)
+#define CGC_K_B_MASK (0x3ff << 0)
+
+#define DQE_CGC_CONTROL(_id) (0x0030 + DQE_OFFSET(_id))
+#define CGC_MC_GAIN(_v) (((_v) & 0xfff) << 4)
+#define CGC_MC_GAIN_MASK (0xfff << 4)
+#define CGC_MC_EN(_v) ((_v) < 0)
+#define CGC_MC_EN_MASK (1 < 0)
+
+#define DQE_GAMMALUT_R_01_00(_id) (0x0034 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_03_02(_id) (0x0038 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_05_04(_id) (0x003C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_07_06(_id) (0x0040 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_09_08(_id) (0x0044 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_11_10(_id) (0x0048 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_13_12(_id) (0x004C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_15_14(_id) (0x0050 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_17_16(_id) (0x0054 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_19_18(_id) (0x0058 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_21_20(_id) (0x005C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_23_22(_id) (0x0060 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_25_24(_id) (0x0064 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_27_26(_id) (0x0068 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_29_28(_id) (0x006C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_31_30(_id) (0x0070 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_33_32(_id) (0x0074 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_35_34(_id) (0x0078 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_37_36(_id) (0x007C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_39_38(_id) (0x0080 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_41_40(_id) (0x0084 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_43_42(_id) (0x0088 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_45_44(_id) (0x008C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_47_46(_id) (0x0090 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_49_48(_id) (0x0094 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_51_50(_id) (0x0098 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_53_52(_id) (0x009C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_55_54(_id) (0x00A0 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_57_56(_id) (0x00A4 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_59_58(_id) (0x00A8 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_61_60(_id) (0x00AC + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_63_62(_id) (0x00B0 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_R_64(_id) (0x00B4 + DQE_OFFSET(_id))
+
+#define DQE_GAMMALUT_G_01_00(_id) (0x00B8 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_03_02(_id) (0x00BC + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_05_04(_id) (0x00C0 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_07_06(_id) (0x00C4 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_09_08(_id) (0x00C8 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_11_10(_id) (0x00CC + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_13_12(_id) (0x00D0 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_15_14(_id) (0x00D4 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_17_16(_id) (0x00D8 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_19_18(_id) (0x00DC + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_21_20(_id) (0x00E0 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_23_22(_id) (0x00E4 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_25_24(_id) (0x00E8 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_27_26(_id) (0x00EC + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_29_28(_id) (0x00F0 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_31_30(_id) (0x00F4 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_33_32(_id) (0x00F8 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_35_34(_id) (0x00FC + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_37_36(_id) (0x0100 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_39_38(_id) (0x0104 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_41_40(_id) (0x0108 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_43_42(_id) (0x010C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_45_44(_id) (0x0110 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_47_46(_id) (0x0114 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_49_48(_id) (0x0118 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_51_50(_id) (0x011C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_53_52(_id) (0x0120 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_55_54(_id) (0x0124 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_57_56(_id) (0x0128 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_59_58(_id) (0x012C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_61_60(_id) (0x0130 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_63_62(_id) (0x0134 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_G_64(_id) (0x0138 + DQE_OFFSET(_id))
+
+#define DQE_GAMMALUT_B_01_00(_id) (0x013C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_03_02(_id) (0x0140 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_05_04(_id) (0x0144 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_07_06(_id) (0x0148 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_09_08(_id) (0x014C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_11_10(_id) (0x0150 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_13_12(_id) (0x0154 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_15_14(_id) (0x0158 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_17_16(_id) (0x015C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_19_18(_id) (0x0160 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_21_20(_id) (0x0164 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_23_22(_id) (0x0168 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_25_24(_id) (0x016C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_27_26(_id) (0x0170 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_29_28(_id) (0x0174 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_31_30(_id) (0x0178 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_33_32(_id) (0x017C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_35_34(_id) (0x0180 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_37_36(_id) (0x0184 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_39_38(_id) (0x0188 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_41_40(_id) (0x018C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_43_42(_id) (0x0190 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_45_44(_id) (0x0194 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_47_46(_id) (0x0198 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_49_48(_id) (0x019C + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_51_50(_id) (0x01A0 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_53_52(_id) (0x01A4 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_55_54(_id) (0x01A8 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_57_56(_id) (0x01AC + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_59_58(_id) (0x01B0 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_61_60(_id) (0x01B4 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_63_62(_id) (0x01B8 + DQE_OFFSET(_id))
+#define DQE_GAMMALUT_B_64(_id) (0x01BC + DQE_OFFSET(_id))
+
+/*
+ * ODD : 1,3,5,7,9,...
+ * EVEN : 0,2,4,6,8,10,...
+	 */
+
+#define GAMMA_R_LUT_ODD(_v) (((_v) & 0x7ff) << 16)
+#define GAMMA_R_LUT_ODD_MASK (0x7ff << 16)
+#define GAMMA_R_LUT_EVEN(_v) (((_v) & 0x7ff) << 0)
+#define GAMMA_R_LUT_EVEN_MASK (0x7ff << 0)
+
+#define DQE_APS_GAIN(_id) (0x01C0 + DQE_OFFSET(_id))
+#define APS_ST(_v) (((_v) & 0xff) << 16)
+#define APS_ST_MASK (0xff << 16)
+#define APS_NS(_v) (((_v) & 0xff) << 8)
+#define APS_NS_MASK (0xff << 8)
+#define APS_LT(_v) (((_v) & 0xff) << 0)
+#define APS_LT_MASK (0xff << 0)
+
+#define DQE_APS_WEIGHT(_id) (0x01C4 + DQE_OFFSET(_id))
+#define APS_PL_W2(_v) (((_v) & 0xf) << 16)
+#define APS_PL_W2_MASK (0xf << 16)
+#define APS_PL_W1(_v) (((_v) & 0xf) << 0)
+#define APS_PL_W1_MASK (0xf << 0)
+
+#define DQE_APS_CTMODE(_id) (0x01C8 + DQE_OFFSET(_id))
+#define APS_CTMODE(_v) (((_v) & 0x3) << 0)
+#define APS_CTMODE_MASK (0x3 << 0)
+
+#define DQE_APS_PPEN(_id) (0x01CC + DQE_OFFSET(_id))
+#define APS_PP_EN(_v) ((_v) << 0)
+#define APS_PP_EN_MASK (1 << 0)
+
+#define DQE_APS_TDRMINMAX(_id) (0x01D0 + DQE_OFFSET(_id))
+#define APS_TDR_MAX(_v) (((_v) & 0x3ff) << 16)
+#define APS_TDR_MAX_MASK (0x3ff << 16)
+#define APS_TDR_MIN(_v) (((_v) & 0x3ff) << 0)
+#define APS_TDR_MIN_MASK (0x3ff << 0)
+
+#define DQE_APS_AMBIENT_LIGHT(_id) (0x01D4 + DQE_OFFSET(_id))
+#define APS_AMBIENT_LIGHT(_v) (((_v) & 0xff) << 0)
+#define APS_AMBIENT_LIGHT_MASK (0xff << 0)
+
+#define DQE_APS_BACK_LIGHT(_id) (0x01D8 + DQE_OFFSET(_id))
+#define APS_BACK_LIGHT(_v) (((_v) & 0xff) << 0)
+#define APS_BACK_LIGHT_MASK (0xff << 0)
+
+#define DQE_APS_DSTEP(_id) (0x01DC + DQE_OFFSET(_id))
+#define APS_DSTEP(_v) (((_v) & 0x3f) << 0)
+#define APS_DSTEP_MASK (0x3f << 0)
+
+#define DQE_APS_THRESHOLD(_id) (0x01E4 + DQE_OFFSET(_id))
+#define APS_THRESHOLD_3(_v) (((_v) & 0x3) << 4)
+#define APS_THRESHOLD_3_MASK (0x3 << 4)
+#define APS_THRESHOLD_2(_v) (((_v) & 0x3) << 2)
+#define APS_THRESHOLD_2_MASK (0x3 << 2)
+#define APS_THRESHOLD_1(_v) (((_v) & 0x3) << 0)
+#define APS_THRESHOLD_1_MASK (0x3 << 0)
+
+#define DQE_APS_GAIN_LIMIT(_id) (0x01E8 + DQE_OFFSET(_id))
+#define APS_GAIN_LIMIT(_v) (((_v) & 0x3ff) << 0)
+#define APS_GAIN_LIMIT_MASK (0x3ff << 0)
+
+#define DQE_APS_DIMMING_DONE_INTR(_id) (0x01EC + DQE_OFFSET(_id))
+#define APS_DIMMING_IN_PROGRESS(_v) ((_v) << 0)
+#define APS_DIMMING_IN_PROGRESS_MASK (1 << 0)
+
+#define DQE_APS_LT_CALC_AB_SHIFT(_id) (0x01F0 + DQE_OFFSET(_id))
+#define APS_LT_CALC_AB_SHIFT(_v) (((_v) & 0x3) << 0)
+#define APS_LT_CALC_AB_SHIFT_MASK (0x3 << 0)
+
+#define DQE_HSC_CONTROL(_id) (0x0204 + DQE_OFFSET(_id))
+#define HSC_PPSC_ON(_v) (((_v) & 0x1) << 5)
+#define HSC_PPSC_ON_MASK (0x1 << 5)
+#define HSC_YCOMP_ON(_v) (((_v) & 0x1) << 4)
+#define HSC_YCOMP_ON_MASK (0x1 << 4)
+#define HSC_TSC_ON(_v) (((_v) & 0x1) << 3)
+#define HSC_TSC_ON_MASK (0x1 << 3)
+#define HSC_DITHER_ON(_v) (((_v) & 0x1) << 2)
+#define HSC_DITHER_ON_MASK (0x1 << 2)
+#define HSC_PPHC_ON(_v) (((_v) & 0x1) << 1)
+#define HSC_PPHC_ON_MASK (0x1 << 1)
+#define HSC_SKIN_ON(_v) (((_v) & 0x1) << 0)
+#define HSC_SKIN_ON_MASK (0x1 << 0)
+
+#define DQE_HSC_PPSCGAIN_RGB(_id) (0x0208 + DQE_OFFSET(_id))
+#define HSC_PPSC_GAIN_B(_v) (((_v) & 0x3ff) << 20)
+#define HSC_PPSC_GAIN_B_MASK (0x3ff << 20)
+#define HSC_PPSC_GAIN_G(_v) (((_v) & 0x3ff) << 10)
+#define HSC_PPSC_GAIN_G_MASK (0x3ff << 10)
+#define HSC_PPSC_GAIN_R(_v) (((_v) & 0x3ff) << 0)
+#define HSC_PPSC_GAIN_R_MASK (0x3ff << 0)
+
+#define DQE_HSC_PPSCGAIN_CMY(_id) (0x020C + DQE_OFFSET(_id))
+#define HSC_PPSC_GAIN_Y(_v) (((_v) & 0x3ff) << 20)
+#define HSC_PPSC_GAIN_Y_MASK (0x3ff << 20)
+#define HSC_PPSC_GAIN_M(_v) (((_v) & 0x3ff) << 10)
+#define HSC_PPSC_GAIN_M_MASK (0x3ff << 10)
+#define HSC_PPSC_GAIN_C(_v) (((_v) & 0x3ff) << 0)
+#define HSC_PPSC_GAIN_C_MASK (0x3ff << 0)
+
+#define DQE_HSC_ALPHASCALE_SHIFT(_id) (0x0210 + DQE_OFFSET(_id))
+#define HSC_ALPHA_SHIFT2(_v) (((_v) & 0x1f) << 20)
+#define HSC_ALPHA_SHIFT2_MASK (0x1f << 20)
+#define HSC_ALPHA_SHIFT1(_v) (((_v) & 0xff) << 8)
+#define HSC_ALPHA_SHIFT1_MASK (0xff << 8)
+#define HSC_ALPHA_SCALE(_v) (((_v) & 0xf) << 0)
+#define HSC_ALPHA_SCALE_MASK (0xf << 0)
+
+#define DQE_HSC_POLY_CURVE0(_id) (0x0214 + DQE_OFFSET(_id))
+#define HSC_POLY_CURVE_3(_v) (((_v) & 0x3ff) << 20)
+#define HSC_POLY_CURVE_3_MASK (0x3ff << 20)
+#define HSC_POLY_CURVE_2(_v) (((_v) & 0x3ff) << 10)
+#define HSC_POLY_CURVE_2_MASK (0x3ff << 10)
+#define HSC_POLY_CURVE_1(_v) (((_v) & 0x3ff) << 0)
+#define HSC_POLY_CURVE_1_MASK (0x3ff << 0)
+
+#define DQE_HSC_POLY_CURVE1(_id) (0x0218 + DQE_OFFSET(_id))
+#define HSC_POLY_CURVE_6(_v) (((_v) & 0x3ff) << 20)
+#define HSC_POLY_CURVE_6_MASK (0x3ff << 20)
+#define HSC_POLY_CURVE_5(_v) (((_v) & 0x3ff) << 10)
+#define HSC_POLY_CURVE_5_MASK (0x3ff << 10)
+#define HSC_POLY_CURVE_4(_v) (((_v) & 0x3ff) << 0)
+#define HSC_POLY_CURVE_4_MASK (0x3ff << 0)
+
+#define DQE_HSC_SKIN_S(_id) (0x021C + DQE_OFFSET(_id))
+#define HSC_SKIN_S2(_v) (((_v) & 0x3ff) << 16)
+#define HSC_SKIN_S2_MASK (0x3ff << 16)
+#define HSC_SKIN_S1(_v) (((_v) & 0x3ff) << 0)
+#define HSC_SKIN_S1_MASK (0x3ff << 0)
+
+#define DQE_HSC_PPHCGAIN_RGB(_id) (0x0220 + DQE_OFFSET(_id))
+#define HSC_PPHC_GAIN_B(_v) (((_v) & 0x3ff) << 20)
+#define HSC_PPHC_GAIN_B_MASK (0x3ff << 20)
+#define HSC_PPHC_GAIN_G(_v) (((_v) & 0x3ff) << 10)
+#define HSC_PPHC_GAIN_G_MASK (0x3ff << 10)
+#define HSC_PPHC_GAIN_R(_v) (((_v) & 0x3ff) << 0)
+#define HSC_PPHC_GAIN_R_MASK (0x3ff << 0)
+
+#define DQE_HSC_PPHCGAIN_CMY(_id) (0x0224 + DQE_OFFSET(_id))
+#define HSC_PPHC_GAIN_Y(_v) (((_v) & 0x3ff) << 20)
+#define HSC_PPHC_GAIN_Y_MASK (0x3ff << 20)
+#define HSC_PPHC_GAIN_M(_v) (((_v) & 0x3ff) << 10)
+#define HSC_PPHC_GAIN_M_MASK (0x3ff << 10)
+#define HSC_PPHC_GAIN_C(_v) (((_v) & 0x3ff) << 0)
+#define HSC_PPHC_GAIN_C_MASK (0x3ff << 0)
+
+#define DQE_HSC_TSC_YCOMP(_id) (0x0228 + DQE_OFFSET(_id))
+#define HSC_Y_COMP_RATIO(_v) (((_v) & 0xf) << 12)
+#define HSC_Y_COMP_RATIO_MASK (0xf << 12)
+#define HSC_TSC_GAIN(_v) (((_v) & 0x3ff) << 0)
+#define HSC_TSC_GAIN_MASK (0x3ff << 0)
+
+#define DQE_HSC_POLY_CURVE2(_id) (0x022C + DQE_OFFSET(_id))
+#define HSC_POLY_CURVE_8(_v) (((_v) & 0x3ff) << 10)
+#define HSC_POLY_CURVE_8_MASK (0x3ff << 10)
+#define HSC_POLY_CURVE_7(_v) (((_v) & 0x3ff) << 0)
+#define HSC_POLY_CURVE_7_MASK (0x3ff << 0)
+
+#define DQE_HSC_PARTIAL_CON(_id) (0x0230 + DQE_OFFSET(_id))
+#define HSC_ROI_SAME(_v) (((_v) & 0x1) << 2)
+#define HSC_ROI_SAME_MASK (0x1 << 2)
+#define HSC_PARTIAL_UPDATE_METHOD(_v) (((_v) & 0x1) << 1)
+#define HSC_PARTIAL_UPDATE_METHOD_MASK (0x1 << 1)
+#define HSC_IMG_PARTIAL_FRAME(_v) (((_v) & 0x1) << 0)
+#define HSC_IMG_PARTIAL_FRAME_MASK (0x1 << 0)
+
+#define DQE_APS_PARTIAL_CON(_id) (0x0234 + DQE_OFFSET(_id))
+#define APS_ROI_SAME(_v) (((_v) & 0x1) << 2)
+#define APS_ROI_SAME_MASK (0x1 << 2)
+#define APS_PARTIAL_UPDATE_METHOD(_v) (((_v) & 0x1) << 1)
+#define APS_PARTIAL_UPDATE_METHOD_MASK (0x1 << 1)
+#define APS_IMG_PARTIAL_FRAME(_v) (((_v) & 0x1) << 0)
+#define APS_IMG_PARTIAL_FRAME_MASK (0x1 << 0)
+
+#define DQE_APS_FULL_IMG_SIZESET(_id) (0x0238 + DQE_OFFSET(_id))
+#define APS_FULL_IMG_VSIZE(_v) (((_v) & 0x3fff) << 16)
+#define APS_FULL_IMG_VSIZE_MASK (0x3fff << 16)
+#define APS_FULL_IMG_HSIZE(_v) (((_v) & 0x3fff) << 0)
+#define APS_FULL_IMG_HSIZE_MASK (0x3fff << 0)
+
+#define DQE_APS_PARTIAL_ROI_UP_LEFT_POS(_id) (0x023C + DQE_OFFSET(_id))
+#define APS_ROI_Y1(_v) (((_v) & 0x3fff) << 16)
+#define APS_ROI_Y1_MASK (0x3fff << 16)
+#define APS_ROI_X1(_v) (((_v) & 0x3fff) << 0)
+#define APS_ROI_X1_MASK (0x3fff << 0)
+
+#define DQE_HSC_SKIN_H(_id) (0x0240 + DQE_OFFSET(_id))
+#define HSC_SKIN_H2(_v) (((_v) & 0x3ff) << 16)
+#define HSC_SKIN_H2_MASK (0x3ff << 16)
+#define HSC_SKIN_H1(_v) (((_v) & 0x3ff) << 0)
+#define HSC_SKIN_H1_MASK (0x3ff << 0)
+
+#define DQE_APS_PARTIAL_IBSI_01_00(_id) (0x0308 + DQE_OFFSET(_id))
+#define APS_IBSI_01(_v) (((_v) & 0xffff) << 16)
+#define APS_IBSI_01_MASK (0xffff << 16)
+#define APS_IBSI_00(_v) (((_v) & 0xffff) << 0)
+#define APS_IBSI_00_MASK (0xffff << 0)
+
+#define DQE_APS_PARTIAL_IBSI_11_10(_id) (0x030C + DQE_OFFSET(_id))
+#define APS_IBSI_11(_v) (((_v) & 0xffff) << 16)
+#define APS_IBSI_11_MASK (0xffff << 16)
+#define APS_IBSI_10(_v) (((_v) & 0xffff) << 0)
+#define APS_IBSI_10_MASK (0xffff << 0)
+
+#define DQE_HSC_FULL_PXL_NUM(_id) (0x0310 + DQE_OFFSET(_id))
+#define HSC_FULL_PXL_NUM(_v) (((_v) & 0xfffffff) << 0)
+#define HSC_FULL_PXL_NUM_MASK (0xfffffff << 0)
+
+#define DQE_APS_FULL_PXL_NUM(_id) (0x0320 + DQE_OFFSET(_id))
+#define APS_FULL_PXL_NUM(_v) (((_v) & 0xfffffff) << 0)
+#define APS_FULL_PXL_NUM_MASK (0xfffffff << 0)
+
+#define DQE_LPD_DATA_CONTROL(_id) (0x0400 + DQE_OFFSET(_id))
+#define LPD_WR_OR_RD_DIRECTION(_v) (((_v) & 0x1) << 31)
+#define LPD_WR_OR_RD_DIRECTION_MASK (0x1 << 31)
+#define LPD_ADDR(_v) (((_v) & 0x7f) << 24)
+#define LPD_ADDR_MASK (0x7f << 24)
+#define LPD_DATA(_v) (((_v) & 0xfffff) << 0)
+#define LPD_DATA_MASK (0xfffff << 0)
+
+#define DQE_VER(_id) (0x0500 + DQE_OFFSET(_id))
+#define DQE_VER_F(_v) ((_v) << 0)
+#define SQE_VER_GET(_v) (((_v) >> 0) & 0xffffffff)
+
+/*
+ * TELLTALE registers (Base Addr : DECON1)
+ * ->
+ * 0x4000 ~
+ * TELLTALE0~15 : 0x4100~0x417C
+ * TELLTALE_CRC_DATA0~7 : 0x4200~0x421C
+ * FS_CRC_DATA : 0x4220
+ *
+ * <-
+ * TELLTALE registers
+ */
+
+#define TELLTALE_CON 0x4000
+#define CRC_DATA_SEL_TELLTALE(_v) (((_v) & 0x3) << 20)
+#define CRC_DATA_SEL_TELLTALE_R (0x2 << 20)
+#define CRC_DATA_SEL_TELLTALE_G (0x1 << 20)
+#define CRC_DATA_SEL_TELLTALE_B (0 << 20)
+#define FS_CRC_EN(_v) (((_v) & 0x1) << 16)
+#define FS_CRC_EN_MASK (1 << 16)
+#define ENABLE_TELLTALE_F(_v) (((_v) & 0xffff) << 0)
+
+#define TELLTALE_WIN_RESERVE 0x4004
+#define RESERVE_WIN_DECON0(_win) (0 << ((_win) * 4))
+#define RESERVE_WIN_DECON1(_win) (1 << ((_win) * 4))
+#define RESERVE_WIN_IDLE(_win) (0x3 << ((_win) * 4))
+#define RESERVE_WIN7(_v) (((_v) & 0x3) << 28)
+#define RESERVE_WIN7_DECON0 (0 << 28)
+#define RESERVE_WIN7_DECON1 (1 << 28)
+#define RESERVE_WIN7_IDLE (0x3 << 28)
+#define RESERVE_WIN6(_v) (((_v) & 0x3) << 24)
+#define RESERVE_WIN6_DECON0 (0 << 24)
+#define RESERVE_WIN6_DECON1 (1 << 24)
+#define RESERVE_WIN6_IDLE (0x3 << 24)
+#define RESERVE_WIN5(_v) (((_v) & 0x3) << 20)
+#define RESERVE_WIN5_DECON0 (0 << 20)
+#define RESERVE_WIN5_DECON1 (1 << 20)
+#define RESERVE_WIN5_IDLE (0x3 << 20)
+#define RESERVE_WIN4(_v) (((_v) & 0x3) << 16)
+#define RESERVE_WIN4_DECON0 (0 << 16)
+#define RESERVE_WIN4_DECON1 (1 << 16)
+#define RESERVE_WIN4_IDLE (0x3 << 16)
+#define RESERVE_WIN3(_v) (((_v) & 0x3) << 12)
+#define RESERVE_WIN3_DECON0 (0 << 12)
+#define RESERVE_WIN3_DECON1 (1 << 12)
+#define RESERVE_WIN3_IDLE (0x3 << 12)
+#define RESERVE_WIN2(_v) (((_v) & 0x3) << 8)
+#define RESERVE_WIN2_DECON0 (0 << 8)
+#define RESERVE_WIN2_DECON1 (1 << 8)
+#define RESERVE_WIN2_IDLE (0x3 << 8)
+#define RESERVE_WIN1(_v) (((_v) & 0x3) << 4)
+#define RESERVE_WIN1_DECON0 (0 << 4)
+#define RESERVE_WIN1_DECON1 (1 << 4)
+#define RESERVE_WIN1_IDLE (0x3 << 4)
+#define RESERVE_WIN0(_v) (((_v) & 0x3) << 0)
+#define RESERVE_WIN0_DECON0 (0 << 0)
+#define RESERVE_WIN0_DECON1 (1 << 0)
+#define RESERVE_WIN0_IDLE (0x3 << 0)
+
+#define TELLTALE_START_POSITION(_v) (0x4100 + ((_v) * 8))
+#define TELLTALE_STRPTR_Y_F(_v) (((_v) & 0x3fff) << 16)
+#define TELLTALE_STRPTR_X_F(_v) (((_v) & 0x3fff) << 0)
+
+#define TELLTALE_END_POSITION(_v) (0x4104 + ((_v) * 8))
+#define TELLTALE_ENDPTR_Y_F(_v) (((_v) & 0x3fff) << 16)
+#define TELLTALE_ENDPTR_X_F(_v) (((_v) & 0x3fff) << 0)
+
+#define TELLTALE_CRC_DATA(_v) (0x4200 + ((_v) * 4))
+#define TELLTALE_ODD_CRC_DATA(_v) (((_v) & 0xffff) << 16)
+#define TELLTALE_ODD_DATA_GET(_v) (((_v) >> 16) & 0xffff)
+#define TELLTALE_EVEN_CRC_DATA(_v) (((_v) & 0xffff) << 0)
+#define TELLTALE_EVEN_CRC_DATA_GET(_v) (((_v) >> 0) & 0xffff)
+
+#define FS_CRC_DATA 0x4220
+#define FS_CRC_DATA_F(_v) (((_v) & 0xffff) << 0)
+#define FS_CRC_DATA_GET(_v) (((_v) >> 0) & 0xffff)
+
+#define DATA_PATH_CONTROL_WIN (0x0000)
+
+#define UPDATE_CONTROL_WIN (0x0010)
+#define SHD_UP_REQ_MASK_ALLOW (1 << 0)
+#define SHD_UP_REQ_MASK_BLOCK (1 << 1)
+
+#define UPDATE_REQ_WIN (0x0014)
+#define SHD_UP_REQ (1 << 0)
+
+#endif