Initial file dump from open source releaseHEADmaster

1 files changed, 770 insertions, 0 deletions

diff --git a/drivers/media/sprd_scale/scale_drv.c b/drivers/media/sprd_scale/scale_drv.c
new file mode 100755
index 00000000..c1a4002a
--- /dev/null
+++ b/drivers/media/sprd_scale/scale_drv.c
@@ -0,0 +1,770 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/bitops.h>
+#include <linux/semaphore.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+#ifndef CONFIG_64BIT
+#include <soc/sprd/hardware.h>
+#endif
+#include "scale_drv.h"
+#include "gen_scale_coef.h"
+#include "dcam_drv.h"
+
+#define SCALE_LOWEST_ADDR 0x800
+#define SCALE_ADDR_INVALIDE(addr) ((addr) < SCALE_LOWEST_ADDR)
+#define SCALE_YUV_ADDR_INVALIDE(y,u,v) \
+	(SCALE_ADDR_INVALIDE(y) && \
+	SCALE_ADDR_INVALIDE(u) && \
+	SCALE_ADDR_INVALIDE(v))
+#define SC_COEFF_H_TAB_OFFSET 0x1400
+#define SC_COEFF_V_TAB_OFFSET 0x14F0
+#define SC_COEFF_V_CHROMA_TAB_OFFSET 0x18F0
+#define SC_COEFF_COEF_SIZE (1 << 10)
+#define SC_COEFF_TMP_SIZE (21 << 10)
+#define SC_H_COEF_SIZE (0xC0)
+#define SC_V_COEF_SIZE (0x210)
+#define SC_V_CHROM_COEF_SIZE (0x210)
+#define SC_COEFF_H_NUM (SC_H_COEF_SIZE / 4)
+#define SC_COEFF_V_NUM (SC_V_COEF_SIZE / 4)
+#define SC_COEFF_V_CHROMA_NUM (SC_V_CHROM_COEF_SIZE / 4)
+#define SCALE_PIXEL_ALIGNED 4
+#define SCALE_SLICE_HEIGHT_ALIGNED 4
+
+int scale_k_module_en(struct device_node *dn)
+{
+	int ret = 0;
+
+	ret = dcam_get_resizer(DCAM_WAIT_FOREVER);
+	if (ret) {
+		printk("scale_module_en, failed to get review path %d \n", ret);
+		goto get_resizer_fail;
+	}
+
+	ret = dcam_module_en(dn);
+	if (ret) {
+		printk("scale_module_en, failed to enable scale module %d \n", ret);
+		goto dcam_eb_fail;
+	}
+
+	return ret;
+
+dcam_eb_fail:
+	dcam_rel_resizer();
+get_resizer_fail:
+	return ret;
+}
+
+int scale_k_module_dis(struct device_node *dn)
+{
+	int ret = 0;
+
+	ret = dcam_module_dis(dn);
+	if (ret) {
+		printk("scale_module_dis, failed to disable scale module %d \n", ret);
+	}
+
+	ret = dcam_rel_resizer();
+	if (ret) {
+		printk("scale_module_dis, failed to free review path %d \n", ret);
+	}
+
+	return ret;
+}
+
+static int scale_k_check_deci_slice_mode(uint32_t deci_val, uint32_t slice_h)
+{
+	int rtn = 0;
+
+	if (deci_val > 0) {
+		if ((slice_h >= deci_val) && (0 == (slice_h % deci_val))) {
+			rtn = 0;
+		} else {
+			rtn = -1;
+		}
+	}
+	return rtn;
+}
+
+static int scale_k_set_sc_coeff(struct scale_path_info *path_info_ptr)
+{
+	uint32_t i = 0;
+	unsigned long h_coeff_addr = SCALE_BASE;
+	unsigned long v_coeff_addr = SCALE_BASE;
+	unsigned long v_chroma_coeff_addr = SCALE_BASE;
+	uint32_t *tmp_buf = NULL;
+	uint32_t *h_coeff = NULL;
+	uint32_t *v_coeff = NULL;
+	uint32_t *v_chroma_coeff = NULL;
+	uint32_t scale2yuv420 = 0;
+	uint8_t y_tap = 0;
+	uint8_t uv_tap = 0;
+
+	if (!path_info_ptr) {
+		printk("scale_k_set_sc_coeff error: path_info_ptr null \n");
+		return -1;
+	}
+
+	tmp_buf = (uint32_t *)path_info_ptr->coeff_addr;
+	if (NULL == tmp_buf) {
+		printk("scale_k_set_sc_coeff error: coeff mem null \n");
+		return -1;;
+	}
+
+	h_coeff_addr += SC_COEFF_H_TAB_OFFSET;
+	v_coeff_addr += SC_COEFF_V_TAB_OFFSET;
+	v_chroma_coeff_addr += SC_COEFF_V_CHROMA_TAB_OFFSET;
+
+	if (SCALE_YUV420 == path_info_ptr->output_format)
+		scale2yuv420 = 1;
+
+	h_coeff = tmp_buf;
+	v_coeff = tmp_buf + (SC_COEFF_COEF_SIZE/4);
+	v_chroma_coeff = v_coeff + (SC_COEFF_COEF_SIZE/4);
+
+	if (!(GenScaleCoeff((int16_t)path_info_ptr->sc_input_size.w,
+		(int16_t)path_info_ptr->sc_input_size.h,
+		(int16_t)path_info_ptr->output_size.w,
+		(int16_t)path_info_ptr->output_size.h,
+		h_coeff,
+		v_coeff,
+		v_chroma_coeff,
+		scale2yuv420,
+		&y_tap,
+		&uv_tap,
+		tmp_buf + (SC_COEFF_COEF_SIZE*3/4),
+		SC_COEFF_TMP_SIZE))) {
+		printk("scale_k_set_sc_coeff error: gen scale coeff \n");
+		return -1;
+	}
+
+	for (i = 0; i < SC_COEFF_H_NUM; i++) {
+		REG_WR(h_coeff_addr, *h_coeff);
+		h_coeff_addr += 4;
+		h_coeff++;
+	}
+
+	for (i = 0; i < SC_COEFF_V_NUM; i++) {
+		REG_WR(v_coeff_addr, *v_coeff);
+		v_coeff_addr += 4;
+		v_coeff++;
+	}
+
+	for (i = 0; i < SC_COEFF_V_CHROMA_NUM; i++) {
+		REG_WR(v_chroma_coeff_addr, *v_chroma_coeff);
+		v_chroma_coeff_addr += 4;
+		v_chroma_coeff++;
+	}
+
+	REG_MWR(SCALE_CFG, (BIT_19 | BIT_18 | BIT_17 | BIT_16), ((y_tap & 0x0F) << 16));
+	REG_MWR(SCALE_CFG, (BIT_15 | BIT_14 | BIT_13 | BIT_12 | BIT_11), ((uv_tap & 0x1F) << 11));
+
+	return 0;
+}
+
+static int scale_k_calc_sc_size(struct scale_path_info *path_info_ptr)
+{
+	int rtn = 0;
+	uint32_t reg_val = 0;
+	uint32_t div_factor = 1;
+	uint32_t i = 0, pixel_aligned_num = 0;
+
+	if (!path_info_ptr) {
+		printk("scale_k_calc_sc_size error: path_info_ptr null \n");
+		return -1;
+	}
+
+	if (path_info_ptr->input_rect.w > (path_info_ptr->output_size.w * SCALE_SC_COEFF_MAX * (1 << SCALE_DECI_FAC_MAX)) ||
+		path_info_ptr->input_rect.h > (path_info_ptr->output_size.h * SCALE_SC_COEFF_MAX * (1 << SCALE_DECI_FAC_MAX)) ||
+		path_info_ptr->input_rect.w * SCALE_SC_COEFF_MAX < path_info_ptr->output_size.w ||
+		path_info_ptr->input_rect.h * SCALE_SC_COEFF_MAX < path_info_ptr->output_size.h) {
+		printk("scale_k_calc_sc_size error: input{%d %d}, output{%d %d}\n",
+			path_info_ptr->input_rect.w, path_info_ptr->input_rect.h,
+			path_info_ptr->output_size.w, path_info_ptr->output_size.h);
+		rtn = -1;
+	} else {
+		path_info_ptr->sc_input_size.w = path_info_ptr->input_rect.w;
+		path_info_ptr->sc_input_size.h = path_info_ptr->input_rect.h;
+		if (path_info_ptr->input_rect.w > path_info_ptr->output_size.w * SCALE_SC_COEFF_MAX ||
+			path_info_ptr->input_rect.h > path_info_ptr->output_size.h * SCALE_SC_COEFF_MAX) {
+			for (i = 0; i < SCALE_DECI_FAC_MAX; i++) {
+				div_factor = (uint32_t)(SCALE_SC_COEFF_MAX * (1 << (1 + i)));
+				if (path_info_ptr->input_rect.w <= (path_info_ptr->output_size.w * div_factor) &&
+					path_info_ptr->input_rect.h <= (path_info_ptr->output_size.h * div_factor)) {
+					break;
+				}
+			}
+			path_info_ptr->sc_deci_val = (1 << (1 + i));
+			pixel_aligned_num = (path_info_ptr->sc_deci_val >= SCALE_PIXEL_ALIGNED) ? path_info_ptr->sc_deci_val : SCALE_PIXEL_ALIGNED;
+			path_info_ptr->sc_input_size.w = path_info_ptr->input_rect.w >> (1 + i);
+			path_info_ptr->sc_input_size.h = path_info_ptr->input_rect.h >> (1 + i);
+			if ((path_info_ptr->sc_input_size.w % pixel_aligned_num) ||
+				(path_info_ptr->sc_input_size.h % pixel_aligned_num)) {
+				path_info_ptr->sc_input_size.w = path_info_ptr->sc_input_size.w / pixel_aligned_num * pixel_aligned_num;
+				path_info_ptr->sc_input_size.h = path_info_ptr->sc_input_size.h / pixel_aligned_num * pixel_aligned_num;
+				path_info_ptr->input_rect.w = path_info_ptr->sc_input_size.w << (1 + i);
+				path_info_ptr->input_rect.h = path_info_ptr->sc_input_size.h << (1 + i);
+			}
+
+			REG_WR(SCALE_TRIM_START, 0);
+			reg_val = path_info_ptr->sc_input_size.w | (path_info_ptr->sc_input_size.h << 16);
+			REG_WR(SCALE_TRIM_SIZE, reg_val);
+			REG_WR(SCALE_SRC_SIZE, reg_val);
+
+			REG_OWR(SCALE_REV_BURST_IN_CFG, SCALE_BURST_SUB_EB_BIT);
+			REG_MWR(SCALE_REV_BURST_IN_CFG, SCALE_BURST_SUB_SAMPLE_MASK, (i << 13));
+			REG_MWR(SCALE_REV_BURST_IN_CFG, SCALE_BURST_SRC_WIDTH_MASK, path_info_ptr->input_size.w);
+			reg_val = path_info_ptr->input_rect.x | (path_info_ptr->input_rect.y << 16);
+			REG_WR(SCALE_REV_BURST_IN_TRIM_START, reg_val);
+			reg_val = path_info_ptr->input_rect.w | (path_info_ptr->input_rect.h << 16);
+			REG_WR(SCALE_REV_BURST_IN_TRIM_SIZE, reg_val);
+		}
+
+	}
+
+	return rtn;
+}
+
+static int scale_k_cfg_scaler(struct scale_path_info *path_info_ptr)
+{
+	int rtn = 0;
+
+	if (!path_info_ptr) {
+		printk("scale_k_cfg_scaler error: path_info_ptr null \n");
+		return -1;
+	}
+
+	rtn = scale_k_calc_sc_size(path_info_ptr);
+	if (rtn) {
+		printk("scale_k_cfg_scaler error: calc \n");
+		return rtn;
+	}
+
+	if (path_info_ptr->sc_input_size.w != path_info_ptr->output_size.w ||
+		path_info_ptr->sc_input_size.h != path_info_ptr->output_size.h ||
+		SCALE_YUV420 == path_info_ptr->input_format) {
+		REG_MWR(SCALE_CFG, SCALE_BYPASS_BIT, 0);
+		rtn = scale_k_set_sc_coeff(path_info_ptr);
+		if (rtn) {
+			printk("scale_k_cfg_scaler error: coeff \n");
+		}
+	} else {
+		REG_OWR(SCALE_CFG, SCALE_BYPASS_BIT);
+	}
+
+	return rtn;
+}
+
+int scale_k_slice_cfg(struct scale_slice_param_t *cfg_ptr, struct scale_path_info *path_info_ptr)
+{
+	int rtn = 0;
+	uint32_t reg_val = 0;
+
+	if (!cfg_ptr || !path_info_ptr) {
+		printk("scale_k_io_cfg error: cfg_ptr=%p path_info_ptr=%p",
+			cfg_ptr, path_info_ptr);
+		return -1;
+	}
+
+	/*set slice scale height*/
+	if (cfg_ptr->slice_height > SCALE_FRAME_HEIGHT_MAX
+		|| (cfg_ptr->slice_height  % SCALE_SLICE_HEIGHT_ALIGNED)) {
+		printk("scale_k_io_cfg error: slice_height:%d \n",
+			cfg_ptr->slice_height);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		REG_MWR(SCALE_REV_SLICE_CFG, SCALE_INPUT_SLICE_HEIGHT_MASK, cfg_ptr->slice_height);
+		path_info_ptr->slice_height = cfg_ptr->slice_height;
+	}
+
+	/*set input rect*/
+	if (cfg_ptr->input_rect.x > SCALE_FRAME_WIDTH_MAX
+		|| cfg_ptr->input_rect.y > SCALE_FRAME_HEIGHT_MAX
+		|| cfg_ptr->input_rect.w > SCALE_FRAME_WIDTH_MAX
+		|| cfg_ptr->input_rect.h > SCALE_FRAME_HEIGHT_MAX) {
+		printk("scale_k_io_cfg error: input_rect {%d %d %d %d} \n",
+			cfg_ptr->input_rect.x, cfg_ptr->input_rect.y,
+			cfg_ptr->input_rect.w, cfg_ptr->input_rect.h);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		reg_val = cfg_ptr->input_rect.x | (cfg_ptr->input_rect.y << 16);
+		REG_WR(SCALE_REV_BURST_IN_TRIM_START, reg_val);
+		REG_WR(SCALE_TRIM_START, 0);
+		reg_val = cfg_ptr->input_rect.w | (cfg_ptr->input_rect.h << 16);
+		REG_WR(SCALE_REV_BURST_IN_TRIM_SIZE, reg_val);
+		REG_WR(SCALE_TRIM_SIZE, reg_val);
+		REG_WR(SCALE_SRC_SIZE, reg_val);
+		memcpy((void*)&path_info_ptr->input_rect, (void*)&cfg_ptr->input_rect,
+			sizeof(struct scale_rect_t ));
+	}
+
+	/*set input address*/
+	if (SCALE_YUV_ADDR_INVALIDE(cfg_ptr->input_addr.yaddr,
+		cfg_ptr->input_addr.uaddr, cfg_ptr->input_addr.vaddr)) {
+		printk("scale_k_io_cfg error: input_addr {%x %x %x} \n",
+			cfg_ptr->input_addr.yaddr, cfg_ptr->input_addr.uaddr,
+			cfg_ptr->input_addr.vaddr);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		REG_WR(SCALE_FRM_IN_Y, cfg_ptr->input_addr.yaddr);
+		REG_WR(SCALE_FRM_IN_U, cfg_ptr->input_addr.uaddr);
+		REG_WR(SCALE_FRM_IN_V, cfg_ptr->input_addr.vaddr);
+		path_info_ptr->input_addr.yaddr = cfg_ptr->input_addr.yaddr;
+		path_info_ptr->input_addr.uaddr = cfg_ptr->input_addr.uaddr;
+		path_info_ptr->input_addr.vaddr = cfg_ptr->input_addr.vaddr;
+	}
+
+	/*set output address*/
+	if (SCALE_YUV_ADDR_INVALIDE(cfg_ptr->output_addr.yaddr,
+		cfg_ptr->output_addr.uaddr, cfg_ptr->output_addr.vaddr)) {
+		printk("scale_k_io_cfg error: output_addr {%x %x %x} \n",
+			cfg_ptr->output_addr.yaddr, cfg_ptr->output_addr.uaddr,
+			cfg_ptr->output_addr.vaddr);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		REG_WR(SCALE_FRM_OUT_Y, cfg_ptr->output_addr.yaddr);
+		REG_WR(SCALE_FRM_OUT_U, cfg_ptr->output_addr.uaddr);
+		REG_WR(SCALE_FRM_OUT_V, cfg_ptr->output_addr.vaddr);
+		path_info_ptr->output_addr.yaddr = cfg_ptr->output_addr.yaddr;
+		path_info_ptr->output_addr.uaddr = cfg_ptr->output_addr.uaddr;
+		path_info_ptr->output_addr.vaddr = cfg_ptr->output_addr.vaddr;
+	}
+
+cfg_exit:
+	return rtn;
+}
+
+int scale_k_frame_cfg(struct scale_frame_param_t *cfg_ptr, struct scale_path_info *path_info_ptr)
+{
+	int rtn = 0;
+	uint32_t reg_val = 0;
+
+	if (!cfg_ptr || !path_info_ptr) {
+		printk("scale_k_io_cfg error: cfg_ptr=%p path_info_ptr=%p",
+			cfg_ptr, path_info_ptr);
+		return -1;
+	}
+
+	SCALE_TRACE("scale_k_io_cfg :  input_size {%d %d} \n",
+		cfg_ptr->input_size.w, cfg_ptr->input_size.h);
+	/*set input size*/
+	if (cfg_ptr->input_size.w > SCALE_FRAME_WIDTH_MAX
+		|| cfg_ptr->input_size.h > SCALE_FRAME_HEIGHT_MAX) {
+		printk("scale_k_io_cfg error:  input_size {%d %d} \n",
+			cfg_ptr->input_size.w, cfg_ptr->input_size.h);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		REG_MWR(SCALE_REV_BURST_IN_CFG, SCALE_BURST_SUB_EB_BIT, 0);
+		REG_MWR(SCALE_REV_BURST_IN_CFG, SCALE_BURST_SUB_SAMPLE_MASK, 0);
+		REG_MWR(SCALE_REV_BURST_IN_CFG, SCALE_BURST_SRC_WIDTH_MASK, cfg_ptr->input_size.w);
+		path_info_ptr->input_size.w = cfg_ptr->input_size.w;
+		path_info_ptr->input_size.h= cfg_ptr->input_size.h;
+	}
+
+	SCALE_TRACE("scale_k_io_cfg : input_rect {%d %d %d %d} \n",
+		cfg_ptr->input_rect.x, cfg_ptr->input_rect.y,
+		cfg_ptr->input_rect.w, cfg_ptr->input_rect.h);
+	/*set input rect*/
+	if (cfg_ptr->input_rect.x > SCALE_FRAME_WIDTH_MAX
+		|| cfg_ptr->input_rect.x > SCALE_FRAME_HEIGHT_MAX
+		|| cfg_ptr->input_rect.w > SCALE_FRAME_WIDTH_MAX
+		|| cfg_ptr->input_rect.h > SCALE_FRAME_HEIGHT_MAX) {
+		printk("scale_k_io_cfg error: input_rect {%d %d %d %d} \n",
+			cfg_ptr->input_rect.x, cfg_ptr->input_rect.y,
+			cfg_ptr->input_rect.w, cfg_ptr->input_rect.h);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		reg_val = cfg_ptr->input_rect.x | (cfg_ptr->input_rect.y << 16);
+		REG_WR(SCALE_REV_BURST_IN_TRIM_START, reg_val);
+		REG_WR(SCALE_TRIM_START, 0);
+		reg_val = cfg_ptr->input_rect.w | (cfg_ptr->input_rect.h << 16);
+		REG_WR(SCALE_REV_BURST_IN_TRIM_SIZE, reg_val);
+		REG_WR(SCALE_TRIM_SIZE, reg_val);
+		REG_WR(SCALE_SRC_SIZE, reg_val);
+		memcpy((void*)&path_info_ptr->input_rect, (void*)&cfg_ptr->input_rect,
+			sizeof(struct scale_rect_t ));
+	}
+
+	SCALE_TRACE("scale_k_io_cfg : input_format:%d \n",
+		cfg_ptr->input_format);
+	/*set input foramt*/
+	path_info_ptr->input_format = cfg_ptr->input_format;
+	if (SCALE_YUV422 == cfg_ptr->input_format
+		|| SCALE_YUV420 == cfg_ptr->input_format ||
+		SCALE_YUV420_3FRAME == cfg_ptr->input_format) {
+		REG_MWR(SCALE_REV_BURST_IN_CFG, SCALE_BURST_INPUT_MODE_MASK, (cfg_ptr->input_format << 16));
+	} else {
+		printk("scale_k_io_cfg error: input_format:%d \n",
+			cfg_ptr->input_format);
+		rtn = -1;
+		goto cfg_exit;
+	}
+
+	SCALE_TRACE("scale_k_io_cfg : input_addr {%x %x %x} \n",
+		cfg_ptr->input_addr.yaddr, cfg_ptr->input_addr.uaddr,
+		cfg_ptr->input_addr.vaddr);
+	/*set input address*/
+	if (SCALE_YUV_ADDR_INVALIDE(cfg_ptr->input_addr.yaddr,
+		cfg_ptr->input_addr.uaddr, cfg_ptr->input_addr.vaddr)) {
+		printk("scale_k_io_cfg error: input_addr {%x %x %x} \n",
+			cfg_ptr->input_addr.yaddr, cfg_ptr->input_addr.uaddr,
+			cfg_ptr->input_addr.vaddr);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		REG_WR(SCALE_FRM_IN_Y, cfg_ptr->input_addr.yaddr);
+		REG_WR(SCALE_FRM_IN_U, cfg_ptr->input_addr.uaddr);
+		REG_WR(SCALE_FRM_IN_V, cfg_ptr->input_addr.vaddr);
+		path_info_ptr->input_addr.yaddr = cfg_ptr->input_addr.yaddr;
+		path_info_ptr->input_addr.uaddr = cfg_ptr->input_addr.uaddr;
+		path_info_ptr->input_addr.vaddr = cfg_ptr->input_addr.vaddr;
+	}
+
+	SCALE_TRACE("scale_k_io_cfg : input_endian {%d %d} \n",
+		cfg_ptr->input_endian.y_endian, cfg_ptr->input_endian.uv_endian);
+	/*set input endian*/
+	if (cfg_ptr->input_endian.y_endian >= SCALE_ENDIAN_MAX
+		||cfg_ptr->input_endian.uv_endian >= SCALE_ENDIAN_MAX) {
+		printk("scale_k_io_cfg error: input_endian {%d %d} \n",
+			cfg_ptr->input_endian.y_endian, cfg_ptr->input_endian.uv_endian);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		cfg_ptr->input_endian.uv_endian = cfg_ptr->input_endian.y_endian;
+		dcam_glb_reg_owr(SCALE_ENDIAN_SEL,(SCALE_AXI_RD_ENDIAN_BIT | SCALE_AXI_WR_ENDIAN_BIT), DCAM_ENDIAN_REG);
+		dcam_glb_reg_mwr(SCALE_ENDIAN_SEL, SCALE_INPUT_Y_ENDIAN_MASK, cfg_ptr->input_endian.y_endian, DCAM_ENDIAN_REG);
+		dcam_glb_reg_mwr(SCALE_ENDIAN_SEL, SCALE_INPUT_UV_ENDIAN_MASK, (cfg_ptr->input_endian.uv_endian << 2), DCAM_ENDIAN_REG);
+		SCALE_TRACE("scale_k_io_cfg: output_endian {%d %d} 0x%x \n",
+			cfg_ptr->input_endian.y_endian, cfg_ptr->input_endian.uv_endian, REG_RD(SCALE_ENDIAN_SEL));
+	}
+
+	SCALE_TRACE("scale_k_io_cfg: output_size {%d %d} \n",
+		cfg_ptr->output_size.w, cfg_ptr->output_size.h);
+
+	/*set output size*/
+	if (cfg_ptr->output_size.w > SCALE_FRAME_WIDTH_MAX ||
+		cfg_ptr->output_size.h > SCALE_FRAME_HEIGHT_MAX) {
+		printk("scale_k_io_cfg error: output_size {%d %d} \n",
+			cfg_ptr->output_size.w, cfg_ptr->output_size.h);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		reg_val = cfg_ptr->output_size.w | (cfg_ptr->output_size.h << 16);
+		REG_WR(SCALE_DST_SIZE, reg_val);
+		path_info_ptr->output_size.w = cfg_ptr->output_size.w;
+		path_info_ptr->output_size.h = cfg_ptr->output_size.h;
+	}
+
+	SCALE_TRACE("scale_k_io_cfg: output_format:%d \n",
+		cfg_ptr->output_format);
+
+	/*set output format*/
+	path_info_ptr->output_format = cfg_ptr->output_format;
+	if (SCALE_YUV422 == cfg_ptr->output_format) {
+		REG_MWR(SCALE_CFG, SCALE_OUTPUT_MODE_MASK, (0 << 6));
+	} else if (SCALE_YUV420 == cfg_ptr->output_format) {
+		REG_MWR(SCALE_CFG, SCALE_OUTPUT_MODE_MASK, (1 << 6));
+	} else if (SCALE_YUV420_3FRAME == cfg_ptr->output_format) {
+		REG_MWR(SCALE_CFG, SCALE_OUTPUT_MODE_MASK, (3 << 6));
+	} else {
+		printk("scale_k_io_cfg error: output_format:%d \n",
+			cfg_ptr->output_format);
+		rtn = -1;
+		goto cfg_exit;
+	}
+
+	SCALE_TRACE("scale_k_io_cfg : output_addr {%x %x %x} \n",
+		cfg_ptr->output_addr.yaddr, cfg_ptr->output_addr.uaddr,
+		cfg_ptr->output_addr.vaddr);
+
+	/*set output address*/
+	if (SCALE_YUV_ADDR_INVALIDE(cfg_ptr->output_addr.yaddr,
+		cfg_ptr->output_addr.uaddr, cfg_ptr->output_addr.vaddr)) {
+		printk("scale_k_io_cfg error: output_addr {%x %x %x} \n",
+			cfg_ptr->output_addr.yaddr, cfg_ptr->output_addr.uaddr,
+			cfg_ptr->output_addr.vaddr);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		REG_WR(SCALE_FRM_OUT_Y, cfg_ptr->output_addr.yaddr);
+		REG_WR(SCALE_FRM_OUT_U, cfg_ptr->output_addr.uaddr);
+		REG_WR(SCALE_FRM_OUT_V, cfg_ptr->output_addr.vaddr);
+		path_info_ptr->output_addr.yaddr = cfg_ptr->output_addr.yaddr;
+		path_info_ptr->output_addr.uaddr = cfg_ptr->output_addr.uaddr;
+		path_info_ptr->output_addr.vaddr = cfg_ptr->output_addr.vaddr;
+	}
+
+	SCALE_TRACE("scale_k_io_cfg: output_endian {%d %d} \n",
+		cfg_ptr->output_endian.y_endian, cfg_ptr->output_endian.uv_endian);
+
+	/*set output endian*/
+	if (cfg_ptr->output_endian.y_endian >= SCALE_ENDIAN_MAX ||
+		cfg_ptr->output_endian.uv_endian >= SCALE_ENDIAN_MAX) {
+		printk("scale_k_io_cfg error: output_endian {%d %d} \n",
+			cfg_ptr->output_endian.y_endian, cfg_ptr->output_endian.uv_endian);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		cfg_ptr->output_endian.uv_endian = cfg_ptr->output_endian.y_endian;
+		dcam_glb_reg_owr(SCALE_ENDIAN_SEL,(SCALE_AXI_RD_ENDIAN_BIT|SCALE_AXI_WR_ENDIAN_BIT), DCAM_ENDIAN_REG);
+		dcam_glb_reg_mwr(SCALE_ENDIAN_SEL, SCALE_OUTPUT_Y_ENDIAN_MASK, (cfg_ptr->output_endian.y_endian << 10), DCAM_ENDIAN_REG);
+		dcam_glb_reg_mwr(SCALE_ENDIAN_SEL, SCALE_OUTPUT_UV_ENDIAN_MASK, (cfg_ptr->output_endian.uv_endian<< 12), DCAM_ENDIAN_REG);
+		SCALE_TRACE("scale_k_io_cfg: output_endian {%d %d} 0x%x \n",
+			cfg_ptr->output_endian.y_endian, cfg_ptr->output_endian.uv_endian, REG_RD(SCALE_ENDIAN_SEL));
+	}
+
+	SCALE_TRACE("scale_k_io_cfg: scale_mode:%d \n",
+		cfg_ptr->scale_mode);
+
+	/*set scale mode*/
+	if (cfg_ptr->scale_mode >= SCALE_MODE_MAX) {
+		printk("scale_k_io_cfg error: scale_mode:%d \n",
+			cfg_ptr->scale_mode);
+		rtn = -1;
+		goto cfg_exit;
+	} else {
+		if (SCALE_MODE_NORMAL == cfg_ptr->scale_mode) {
+			REG_MWR(SCALE_CFG, SCALE_MODE_MASK, SCALE_MODE_NORMAL_TYPE);
+		} else if(SCALE_MODE_SLICE == cfg_ptr->scale_mode) {
+			REG_MWR(SCALE_CFG, SCALE_MODE_MASK, SCALE_MODE_SLICE_TYPE);
+			REG_MWR(SCALE_REV_SLICE_CFG, SCALE_SLICE_TYPE_BIT, 0);
+		}else{
+			REG_MWR(SCALE_CFG, SCALE_MODE_MASK, SCALE_MODE_SLICE_TYPE);
+			REG_OWR(SCALE_REV_SLICE_CFG, SCALE_SLICE_TYPE_BIT);
+		}
+		path_info_ptr->scale_mode = cfg_ptr->scale_mode;
+	}
+
+	/*set slice scale height*/
+	if (SCALE_MODE_SLICE == cfg_ptr->scale_mode
+		|| SCALE_MODE_SLICE_READDR ==cfg_ptr->scale_mode) {
+		if (cfg_ptr->slice_height > SCALE_FRAME_HEIGHT_MAX
+			|| (cfg_ptr->slice_height  % SCALE_SLICE_HEIGHT_ALIGNED)) {
+			printk("scale_k_io_cfg error: slice_height:%d \n",
+				cfg_ptr->slice_height);
+			rtn = -1;
+			goto cfg_exit;
+		} else {
+			REG_MWR(SCALE_REV_SLICE_CFG, SCALE_INPUT_SLICE_HEIGHT_MASK, cfg_ptr->slice_height);
+			path_info_ptr->slice_height = cfg_ptr->slice_height;
+		}
+	}
+
+cfg_exit:
+	return rtn;
+}
+
+int scale_k_start(struct scale_frame_param_t *cfg_ptr, struct scale_path_info *path_info_ptr)
+{
+	int rtn = 0;
+
+	if (!path_info_ptr) {
+		printk("scale_k_start error: path_info_ptr null \n");
+		return -1;
+	}
+
+	dcam_resize_start();
+
+	rtn = scale_k_frame_cfg(cfg_ptr, path_info_ptr);
+	if (rtn) {
+		printk("scale_k_start error: frame cfg \n");
+		goto start_exit;
+	}
+
+	if (SCALE_MODE_NORMAL == path_info_ptr->scale_mode) {
+		if (path_info_ptr->output_size.w > SCALE_FRAME_WIDTH_MAX) {
+			rtn = -1;
+			printk("scale_k_start error: frame output_size_w=%d \n",
+				path_info_ptr->output_size.w);
+			goto start_exit;
+		}
+	} else {
+		if (path_info_ptr->output_size.w > SCALE_LINE_BUF_LENGTH) {
+			rtn = -1;
+			printk("scale_k_start error: frame output_size_w=%d \n",
+				path_info_ptr->output_size.w);
+			goto start_exit;
+		}
+	}
+
+	path_info_ptr->slice_in_height = 0;
+	path_info_ptr->slice_out_height = 0;
+	path_info_ptr->is_last_slice = 0;
+	path_info_ptr->sc_deci_val = 0;
+
+	REG_MWR(SCALE_CFG, (SCALE_DEC_X_EB_BIT|SCALE_DEC_Y_EB_BIT), 0);
+
+	rtn = scale_k_cfg_scaler(path_info_ptr);
+	if (rtn) {
+		printk("scale_k_start error: cfg \n");
+		goto start_exit;
+	}
+
+	if (SCALE_MODE_NORMAL != path_info_ptr->scale_mode) {
+		path_info_ptr->slice_in_height += path_info_ptr->slice_height;
+		rtn = scale_k_check_deci_slice_mode(path_info_ptr->sc_deci_val, path_info_ptr->slice_height);
+		if (rtn) goto start_exit;
+	}
+	dcam_glb_reg_mwr(SCALE_BASE, SCALE_PATH_MASK, SCALE_PATH_SELECT, DCAM_CFG_REG);
+	dcam_glb_reg_owr(SCALE_BASE, SCALE_PATH_EB_BIT, DCAM_CFG_REG);
+
+	dcam_glb_reg_owr(SCALE_CTRL, (SCALE_FRC_COPY_BIT|SCALE_COEFF_FRC_COPY_BIT), DCAM_CONTROL_REG);
+	REG_OWR(SCALE_REV_BURST_IN_CFG, SCALE_START_BIT);
+	REG_WR(SCALE_BURST_GAP, 0x100000);
+	printk("scale_k_start\n");
+	return rtn;
+
+start_exit:
+	dcam_resize_end();
+	SCALE_TRACE("scale_k_start error: ret=%d \n", rtn);
+	return rtn;
+}
+
+int scale_k_continue(struct scale_slice_param_t *cfg_ptr, struct scale_path_info *path_info_ptr)
+{
+	int rtn = 0;
+	uint32_t slice_h = 0;
+
+	if (!path_info_ptr) {
+		printk("scale_k_continue error: path_info_ptr null \n");
+		return -1;
+	}
+
+	rtn = scale_k_slice_cfg(cfg_ptr, path_info_ptr);
+	if (rtn) {
+		printk("rot_k_ioctl error: slice cfg \n");
+		return -1;
+	}
+
+
+	SCALE_TRACE("scale_k_continue: { %d, %d, %d} \n",
+		path_info_ptr->slice_height, path_info_ptr->slice_in_height, path_info_ptr->scale_mode);
+
+	if (SCALE_MODE_NORMAL != path_info_ptr->scale_mode) {
+		if (path_info_ptr->slice_in_height + path_info_ptr->slice_height >= path_info_ptr->input_rect.h) {
+			slice_h = path_info_ptr->input_rect.h - path_info_ptr->slice_in_height;
+			if (scale_k_check_deci_slice_mode(path_info_ptr->sc_deci_val, slice_h)) {
+				printk("scale_k_continue error: check deci \n");
+				return -1;
+			}
+			path_info_ptr->is_last_slice = 1;
+			REG_MWR(SCALE_REV_SLICE_CFG, SCALE_INPUT_SLICE_HEIGHT_MASK, slice_h);
+			REG_OWR(SCALE_REV_SLICE_CFG, SCALE_IS_LAST_SLICE_BIT);
+		} else {
+			path_info_ptr->is_last_slice = 0;
+			REG_MWR(SCALE_REV_SLICE_CFG, SCALE_IS_LAST_SLICE_BIT, 0);
+		}
+		path_info_ptr->slice_in_height += path_info_ptr->slice_height;
+	}
+
+	dcam_glb_reg_owr(SCALE_CTRL, SCALE_START_BIT, DCAM_CONTROL_REG);
+
+	return rtn;
+}
+
+int scale_k_stop(void)
+{
+	int rtn = 0;
+
+	dcam_glb_reg_mwr(SCALE_BASE, SCALE_PATH_EB_BIT, 0, DCAM_CFG_REG);
+
+	return rtn;
+}
+
+int scale_k_isr(struct dcam_frame* dcam_frm, void* u_data)
+{
+	unsigned long flag;
+	scale_isr_func user_isr_func;
+	struct scale_drv_private *private = (struct scale_drv_private *)u_data;
+	struct scale_path_info *path_info_ptr;
+	struct scale_frame_info_t *frm_info_ptr;
+
+	if (!private) {
+		printk("scale_k_isr error: private null \n");
+		goto isr_exit;
+	}
+
+	user_isr_func = private->user_isr_func;
+	if (!user_isr_func) {
+		printk("scale_k_isr error: user_isr_func null \n");
+		goto isr_exit;
+	}
+	path_info_ptr = &private->path_info;
+	frm_info_ptr = &private->frm_info;
+
+	spin_lock_irqsave(&private->scale_drv_lock, flag);
+
+	memset(frm_info_ptr, 0, sizeof(struct scale_frame_info_t));
+	frm_info_ptr->yaddr = path_info_ptr->output_addr.yaddr;
+	frm_info_ptr->uaddr = path_info_ptr->output_addr.uaddr;
+	frm_info_ptr->vaddr = path_info_ptr->output_addr.vaddr;
+	frm_info_ptr->width = path_info_ptr->output_size.w;
+	if (SCALE_MODE_NORMAL != path_info_ptr->scale_mode) {
+		frm_info_ptr->height_uv = REG_RD(SCALE_REV_SLICE_O_VCNT);
+		frm_info_ptr->height_uv = (frm_info_ptr->height_uv >> 16) & SCALE_OUTPUT_SLICE_HEIGHT_MASK;
+		frm_info_ptr->height = REG_RD(SCALE_REV_SLICE_O_VCNT);
+		frm_info_ptr->height = frm_info_ptr->height & SCALE_OUTPUT_SLICE_HEIGHT_MASK;
+		path_info_ptr->slice_out_height += frm_info_ptr->height;
+	} else {
+		frm_info_ptr->height = path_info_ptr->output_size.h;
+	}
+
+	if (path_info_ptr->is_wait_stop) {
+		up(&path_info_ptr->done_sem);
+		path_info_ptr->is_wait_stop = 0;
+	}
+	if (SCALE_MODE_NORMAL == path_info_ptr->scale_mode ||
+		(SCALE_MODE_NORMAL != path_info_ptr->scale_mode && path_info_ptr->output_size.h == path_info_ptr->slice_out_height)) {
+		printk("begin to dcam_resize_end\n");
+		dcam_resize_end();
+	}
+	user_isr_func(private->scale_fd);
+	spin_unlock_irqrestore(&private->scale_drv_lock, flag);
+
+isr_exit:
+	return 0;
+}
+
+int scale_k_isr_reg(scale_isr_func user_func, struct scale_drv_private *drv_private)
+{
+	int rtn = 0;
+	unsigned long flag;
+
+	if (user_func) {
+		if (!drv_private) {
+			rtn = -1;
+			printk("scale_reg_isr Failed \n");
+			goto reg_exit;
+		}
+
+		spin_lock_irqsave(&drv_private->scale_drv_lock, flag);
+		drv_private->user_isr_func = user_func;
+		spin_unlock_irqrestore(&drv_private->scale_drv_lock, flag);
+
+		dcam_reg_isr(DCAM_PATH2_DONE, scale_k_isr, (void *)drv_private);
+	} else {
+		dcam_reg_isr(DCAM_PATH2_DONE, NULL, NULL);
+	}
+
+reg_exit:
+	return rtn;
+}