Initial file dump from open source releaseHEADmaster

133 files changed, 22917 insertions, 0 deletions

diff --git a/drivers/media/sprd_isp/Kconfig b/drivers/media/sprd_isp/Kconfig
new file mode 100644
index 00000000..92c45005
--- /dev/null
+++ b/drivers/media/sprd_isp/Kconfig
@@ -0,0 +1,10 @@
+menu "SoC Video for the SPREADTRUM SC88XX"
+
+config SND_SC88XX_SOC_SPRDPHONE
+	tristate "sprdphone -- SoC Audio for the SPREADTRUM SC88XX chips with intergrated VBC codec"
+#   depends on ARCH_SC8800S
+    select SND_PCM
+    help
+      Say Y if you want to built in to kernel, Say M for ko module.
+
+endmenu
diff --git a/drivers/media/sprd_isp/Makefile b/drivers/media/sprd_isp/Makefile
new file mode 100644
index 00000000..d9f2fb31
--- /dev/null
+++ b/drivers/media/sprd_isp/Makefile
@@ -0,0 +1,186 @@
+include drivers/media/sprd_dcam/common/Makefile.inc
+#ccflags-y += -Idrivers/media/sprd_dcam/common
+
+tshark2_isp_like:=0
+
+ifeq ($(CONFIG_MACH_SP9830IEA_5M_H100),y)
+tshark2_isp_like=1
+endif
+
+ifeq ($(CONFIG_MACH_SP9830IEB_5M_H100),y)
+tshark2_isp_like=1
+endif
+
+ifeq ($(CONFIG_MACH_SP9830IEC_4M_H100),y)
+tshark2_isp_like=1
+endif
+
+ifeq ($(CONFIG_MACH_SP7720EA),y)
+pike_isp_like=1
+endif
+
+ifeq ($(CONFIG_ARCH_SCX30G2),y)
+tshark2_isp_like=1
+endif
+
+ifeq ($(CONFIG_ARCH_SCX35LT8),y)
+tshark2_isp_like=1
+endif
+
+ifeq ($(CONFIG_MACH_SHARKLS_Z3LTE),y)
+tshark2_isp_like=1
+endif
+
+obj-y += sprd_isp.o
+ccflags-y += -Idrivers/media/sprd_dcam/common
+
+
+ifeq ($(CONFIG_ARCH_SCX35),y)
+
+ifeq ($(CONFIG_ARCH_SCX15),y)
+sprd_isp-objs := isp1.0/isp_drv_null.o
+
+else ifeq ($(strip $(tshark2_isp_like)),1)
+ccflags-y += -Idrivers/media/sprd_isp/isp2.0/tshark2/inc
+
+sprd_isp-objs := isp_drv.o \
+		isp2.0/tshark2/src/isp_cfg_param.o \
+		isp2.0/tshark2/src/isp_k_capability.o \
+		isp2.0/tshark2/src/isp_k_isr.o \
+		isp2.0/tshark2/src/isp_k_pgg.o \
+		isp2.0/tshark2/src/isp_k_blc.o \
+		isp2.0/tshark2/src/isp_k_rgb_gain.o \
+		isp2.0/tshark2/src/isp_k_pwd.o \
+		isp2.0/tshark2/src/isp_k_nlc.o \
+		isp2.0/tshark2/src/isp_k_2d_lsc.o \
+		isp2.0/tshark2/src/isp_k_1d_lsc.o \
+		isp2.0/tshark2/src/isp_k_binning4awb.o \
+		isp2.0/tshark2/src/isp_k_awb.o \
+		isp2.0/tshark2/src/isp_k_raw_aem.o \
+		isp2.0/tshark2/src/isp_k_bpc.o \
+		isp2.0/tshark2/src/isp_k_bdn.o \
+		isp2.0/tshark2/src/isp_k_grgb.o \
+		isp2.0/tshark2/src/isp_k_rgb_gain2.o \
+		isp2.0/tshark2/src/isp_k_nlm.o \
+		isp2.0/tshark2/src/isp_k_cfa.o \
+		isp2.0/tshark2/src/isp_k_cmc10.o \
+		isp2.0/tshark2/src/isp_k_gamma.o \
+		isp2.0/tshark2/src/isp_k_cmc8.o \
+		isp2.0/tshark2/src/isp_k_ct.o \
+		isp2.0/tshark2/src/isp_k_cce.o \
+		isp2.0/tshark2/src/isp_k_hsv.o \
+		isp2.0/tshark2/src/isp_k_csc.o \
+		isp2.0/tshark2/src/isp_k_pre_cdn_rgb.o \
+		isp2.0/tshark2/src/isp_k_pstrz.o \
+		isp2.0/tshark2/src/isp_k_raw_afm.o \
+		isp2.0/tshark2/src/isp_k_yiq_aem.o \
+		isp2.0/tshark2/src/isp_k_anti_flicker.o \
+		isp2.0/tshark2/src/isp_k_yiq_afm.o \
+		isp2.0/tshark2/src/isp_k_pre_cdn.o \
+		isp2.0/tshark2/src/isp_k_prefilter.o \
+		isp2.0/tshark2/src/isp_k_brightness.o \
+		isp2.0/tshark2/src/isp_k_contrast.o \
+		isp2.0/tshark2/src/isp_k_hist.o \
+		isp2.0/tshark2/src/isp_k_hist2.o \
+		isp2.0/tshark2/src/isp_k_aca.o \
+		isp2.0/tshark2/src/isp_k_cdn.o \
+		isp2.0/tshark2/src/isp_k_edge.o \
+		isp2.0/tshark2/src/isp_k_css.o \
+		isp2.0/tshark2/src/isp_k_csa.o \
+		isp2.0/tshark2/src/isp_k_hua.o \
+		isp2.0/tshark2/src/isp_k_post_cdn.o \
+		isp2.0/tshark2/src/isp_k_emboss.o \
+		isp2.0/tshark2/src/isp_k_y_gamma.o \
+		isp2.0/tshark2/src/isp_k_y_delay.o \
+		isp2.0/tshark2/src/isp_k_iircnr.o \
+		isp2.0/tshark2/src/isp_k_fetch.o \
+		isp2.0/tshark2/src/isp_k_store.o \
+		isp2.0/tshark2/src/isp_k_dispatch.o \
+		isp2.0/tshark2/src/isp_k_arbiter.o \
+		isp2.0/tshark2/src/isp_k_raw_sizer.o \
+		isp2.0/tshark2/src/isp_k_common.o
+
+ifeq ($(CONFIG_64BIT),y)
+sprd_isp-objs += compat_isp_drv.o
+endif
+
+else ifeq ($(strip $(pike_isp_like)),1)
+ccflags-y += -Idrivers/media/sprd_isp/isp2.0/pike/inc
+
+sprd_isp-objs := isp_drv.o \
+		isp2.0/pike/src/isp_cfg_param.o \
+		isp2.0/pike/src/isp_k_capability.o \
+		isp2.0/pike/src/isp_k_isr.o \
+		isp2.0/pike/src/isp_k_pgg.o \
+		isp2.0/pike/src/isp_k_blc.o \
+		isp2.0/pike/src/isp_k_rgb_gain.o \
+		isp2.0/pike/src/isp_k_pwd.o \
+		isp2.0/pike/src/isp_k_nlc.o \
+		isp2.0/pike/src/isp_k_2d_lsc.o \
+		isp2.0/pike/src/isp_k_1d_lsc.o \
+		isp2.0/pike/src/isp_k_binning4awb.o \
+		isp2.0/pike/src/isp_k_awb.o \
+		isp2.0/pike/src/isp_k_raw_aem.o \
+		isp2.0/pike/src/isp_k_bpc.o \
+		isp2.0/pike/src/isp_k_bdn.o \
+		isp2.0/pike/src/isp_k_grgb.o \
+		isp2.0/pike/src/isp_k_rgb_gain2.o \
+		isp2.0/pike/src/isp_k_nlm.o \
+		isp2.0/pike/src/isp_k_cfa.o \
+		isp2.0/pike/src/isp_k_cmc10.o \
+		isp2.0/pike/src/isp_k_gamma.o \
+		isp2.0/pike/src/isp_k_cmc8.o \
+		isp2.0/pike/src/isp_k_ct.o \
+		isp2.0/pike/src/isp_k_cce.o \
+		isp2.0/pike/src/isp_k_hsv.o \
+		isp2.0/pike/src/isp_k_csc.o \
+		isp2.0/pike/src/isp_k_pre_cdn_rgb.o \
+		isp2.0/pike/src/isp_k_pstrz.o \
+		isp2.0/pike/src/isp_k_raw_afm.o \
+		isp2.0/pike/src/isp_k_yiq_aem.o \
+		isp2.0/pike/src/isp_k_anti_flicker.o \
+		isp2.0/pike/src/isp_k_yiq_afm.o \
+		isp2.0/pike/src/isp_k_pre_cdn.o \
+		isp2.0/pike/src/isp_k_prefilter.o \
+		isp2.0/pike/src/isp_k_brightness.o \
+		isp2.0/pike/src/isp_k_contrast.o \
+		isp2.0/pike/src/isp_k_hist.o \
+		isp2.0/pike/src/isp_k_hist2.o \
+		isp2.0/pike/src/isp_k_aca.o \
+		isp2.0/pike/src/isp_k_cdn.o \
+		isp2.0/pike/src/isp_k_edge.o \
+		isp2.0/pike/src/isp_k_css.o \
+		isp2.0/pike/src/isp_k_csa.o \
+		isp2.0/pike/src/isp_k_hua.o \
+		isp2.0/pike/src/isp_k_post_cdn.o \
+		isp2.0/pike/src/isp_k_emboss.o \
+		isp2.0/pike/src/isp_k_y_gamma.o \
+		isp2.0/pike/src/isp_k_y_delay.o \
+		isp2.0/pike/src/isp_k_fetch.o \
+		isp2.0/pike/src/isp_k_store.o \
+		isp2.0/pike/src/isp_k_dispatch.o \
+		isp2.0/pike/src/isp_k_arbiter.o \
+		isp2.0/pike/src/isp_k_hdr.o \
+		isp2.0/pike/src/isp_k_rgb2y.o \
+		isp2.0/pike/src/isp_k_uv_prefilter.o \
+		isp2.0/pike/src/isp_k_yuv_nlm.o \
+		isp2.0/pike/src/isp_k_common.o
+
+else
+ccflags-y += -Idrivers/media/sprd_isp/isp1.0
+sprd_isp-objs := isp1.0/isp_drv_kernel.o
+ifeq ($(CONFIG_64BIT),y)
+sprd_isp-objs += isp1.0/compat_isp_drv_kernel.o
+endif
+endif
+
+endif
+
+ifeq ($(CONFIG_ARCH_SC8825),y)
+ccflags-y += -Idrivers/media/sprd_isp/isp1.0
+sprd_isp-objs := isp1.0/isp_drv_kernel.o
+endif
+
+obj-y += sprd_isp.o
+
+
diff --git a/drivers/media/sprd_isp/Shark_reg_isp.h b/drivers/media/sprd_isp/Shark_reg_isp.h
new file mode 100644
index 00000000..6b99f9ea
--- /dev/null
+++ b/drivers/media/sprd_isp/Shark_reg_isp.h
@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+#ifndef _TIGER_REG_ISP_H_
+#define _TIGER_REG_ISP_H_
+#ifndef CONFIG_64BIT
+#include <soc/sprd/globalregs.h>
+#else
+#include <soc/sprd/irqs.h>
+#endif
+
+#ifdef   __cplusplus
+extern   "C"
+{
+#endif
+
+
+
+
+#define ISP_DCAM_BASE		DCAM_BASE
+#define ISP_DCAM_INT_STS		(ISP_DCAM_BASE + 0x003CUL)
+#define ISP_DCAM_INT_CLR		(ISP_DCAM_BASE + 0x0044UL)
+
+#define ISP_BASE_ADDR		ISP_BASE
+#define ISP_LNC_STATUS		(ISP_BASE_ADDR+0x0200UL)
+#define ISP_LNC_LOAD		(ISP_BASE_ADDR+0x0220UL)
+#define ISP_AXI_MASTER		(ISP_BASE_ADDR+0x2000UL)
+#define ISP_INT_RAW		(ISP_BASE_ADDR+0x2080UL)
+#define ISP_INT_STATUS		(ISP_BASE_ADDR+0x2084UL)
+#define ISP_INT_EN		(ISP_BASE_ADDR+0x2078UL)
+#define ISP_INT_CLEAR		(ISP_BASE_ADDR+0x207cUL)
+#define ISP_REG_MAX_SIZE		SPRD_ISP_SIZE
+#define ISP_AXI_MASTER_STOP	(ISP_BASE_ADDR + 0X2054UL)
+
+#define ISP_AHB_BASE		SPRD_MMAHB_BASE
+#define ISP_MODULE_EB		(ISP_AHB_BASE + 0x0000UL)
+#define ISP_MODULE_RESET	(ISP_AHB_BASE + 0x0004UL)
+#define ISP_CORE_CLK_EB		(ISP_AHB_BASE + 0x0008UL)
+
+#define ISP_CLOCK_BASE		SPRD_MMCKG_BASE
+#define ISP_CLOCK			(ISP_CLOCK_BASE + 0X34)
+
+
+/*irq line number in system*/
+#define ISP_IRQ				IRQ_ISP_INT
+
+#define ISP_EB_BIT		BIT_2
+#define ISP_RST_LOG_BIT	BIT_2
+#define ISP_RST_CFG_BIT	BIT_3
+#define ISP_CORE_CLK_EB_BIT	BIT_4
+#define ISP_AXI_MASTER_STOP_BIT BIT_0
+
+#define ISP_IRQ_HW_MASK_V0001 (0x1fffffff)
+#define ISP_IRQ_NUM_V0001 (29)
+#define ISP_TMP_BUF_SIZE_MAX_V0001 (32 * 1024)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_TIGER_REG_ISP_H_
diff --git a/drivers/media/sprd_isp/compat_isp_drv.c b/drivers/media/sprd_isp/compat_isp_drv.c
new file mode 100755
index 00000000..497ae777
--- /dev/null
+++ b/drivers/media/sprd_isp/compat_isp_drv.c
@@ -0,0 +1,356 @@
+/*
+ * 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/compat.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <video/sprd_isp.h>
+#include "compat_isp_drv.h"
+
+
+struct compat_isp_capability {
+	uint32_t isp_id;
+	uint32_t index;
+	compat_uptr_t property_param;
+};
+
+struct compat_isp_io_param {
+	uint32_t isp_id;
+	uint32_t sub_block;
+	uint32_t property;
+	compat_uptr_t property_param;
+};
+
+struct compat_isp_reg_param {
+	compat_ulong_t reg_param;
+	uint32_t counts;
+};
+
+struct compat_isp_reg_bits {
+	compat_ulong_t reg_addr;
+	compat_ulong_t reg_value;
+};
+
+
+#define COMPAT_ISP_IO_CAPABILITY     _IOR(ISP_IO_MAGIC, 0, struct compat_isp_capability)
+#define COMPAT_ISP_IO_READ           _IOR(ISP_IO_MAGIC, 2, struct compat_isp_reg_param)
+#define COMPAT_ISP_IO_WRITE          _IOW(ISP_IO_MAGIC, 3, struct compat_isp_reg_param)
+#define CAMPAT_ISP_IO_CFG_PARAM      _IOWR(ISP_IO_MAGIC, 7, struct compat_isp_io_param)
+#define CAMPAT_ISP_REG_READ     	 _IOR(ISP_IO_MAGIC, 8, struct compat_isp_reg_bits)
+
+
+static int compat_get_capability_param(
+			struct compat_isp_capability __user *data32,
+			struct isp_capability __user *data)
+{
+	int err = 0;
+	uint32_t tmp;
+	compat_uptr_t parm;
+
+	err = get_user(tmp, &data32->isp_id);
+	err |= put_user(tmp, &data->isp_id);
+	err |= get_user(tmp, &data32->index);
+	err |= put_user(tmp, &data->index);
+	err |= get_user(parm, &data32->property_param);
+	err |= put_user(parm, &data->property_param);
+
+	return err;
+}
+
+static int compat_get_cfg_param(
+			struct compat_isp_io_param __user *data32,
+			struct isp_io_param __user *data)
+{
+	int err  =0;
+	uint32_t tmp;
+	compat_uptr_t parm;
+
+	err = get_user(tmp, &data32->isp_id);
+	err |= put_user(tmp, &data->isp_id);
+	err |= get_user(tmp, &data32->sub_block);
+	err |= put_user(tmp, &data->sub_block);
+	err |= get_user(tmp, &data32->property);
+	err |= put_user(tmp, &data->property);
+	err |= get_user(parm, &data32->property_param);
+	err |= put_user(parm, &data->property_param);
+
+	return err;
+}
+
+static int compat_get_rw_param(
+			struct compat_isp_reg_param __user *data32,
+			struct isp_reg_param __user *data)
+{
+	int err = 0;
+	compat_ulong_t addr;
+	uint32_t cnt;
+
+	err = get_user(addr, &data32->reg_param);
+	err |= put_user(addr, &data->reg_param);
+	err |= get_user(cnt, &data32->counts);
+	err |= put_user(cnt, &data->counts);
+
+	return err;
+}
+
+static int compat_get_rw_param_detail(
+			struct isp_reg_param __user *data)
+
+{
+	int err = 0;
+	int i;
+	int cnt;
+	compat_ulong_t addr;
+	compat_ulong_t val;
+	struct compat_isp_reg_bits __user *data32;
+	struct isp_reg_bits __user *reg_data;
+	struct isp_reg_bits __user *data_tmp;
+
+	if (NULL == data) {
+		printk("compat_get_rw_param_detail: data is NULL.\n");
+		return -EFAULT;
+	}
+
+	cnt = data->counts;
+	data32 = compat_ptr(data->reg_param);
+	reg_data = (struct isp_reg_bits __user *)((unsigned long)data + sizeof(struct isp_reg_param));
+	data->reg_param = reg_data;
+	if (NULL == reg_data) {
+		printk("compat_get_rw_param_detail: reg_data is NULL.\n");
+		return -EFAULT;
+	}
+
+	data_tmp = reg_data;
+	for (i = 0; i < cnt; i++) {
+		err = get_user(addr, &data32->reg_addr);
+		err |= put_user(addr, &data_tmp->reg_addr);
+		err |= get_user(val, &data32->reg_value);
+		err |= put_user(val, &data_tmp->reg_value);
+		if (err) {
+			printk("compat_get_rw_param_detail: failed to get register addr&val cnt %d err %d\n", cnt, err);
+			break;
+		}
+		data32++;
+		data_tmp++;
+	}
+
+	return err;
+}
+
+static int compat_put_read_param(
+			struct compat_isp_reg_param __user *data32,
+			struct isp_reg_param __user *data)
+
+{
+	int err = 0;
+	int i;
+	int cnt;
+	compat_ulong_t val;
+	struct compat_isp_reg_bits __user *reg_data32;
+	struct isp_reg_bits __user *reg_data;
+
+	cnt = data->counts;
+	reg_data32 = (struct compat_isp_reg_bits __user *)data32->reg_param;
+	reg_data = (struct isp_reg_bits __user *)data->reg_param;
+	for (i = 0; i < cnt; i++) {
+		err = get_user(val, &reg_data->reg_value);
+		err |= put_user(val, &reg_data32->reg_value);
+		if (err) {
+			printk("compat_put_read_param: failed to get register val err %d\n", err);
+			break;
+		}
+		reg_data32++;
+		reg_data++;
+	}
+
+	return err;
+}
+
+long compat_isp_ioctl(struct file *file, unsigned int cmd, unsigned long param)
+{
+	long ret;
+	int err = 0;
+	void __user *up = compat_ptr(param);
+
+	if (!file->f_op || !file->f_op->unlocked_ioctl)
+		return -ENOTTY;
+
+	switch (cmd) {
+	case ISP_IO_IRQ:
+	case ISP_IO_RST:
+	case ISP_IO_STOP:
+	case ISP_IO_INT:
+		ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)up);
+		break;
+
+	case COMPAT_ISP_IO_CAPABILITY:
+	{
+		struct compat_isp_capability __user *data32;
+		struct isp_capability __user *data;
+
+		data32 = compat_ptr(param);
+		data = compat_alloc_user_space(sizeof(*data));
+		if (NULL == data) {
+			printk("compat_isp_ioctl: failed to compat_alloc_user_space.\n");
+			return -EFAULT;
+		}
+
+		err = compat_get_capability_param(data32, data);
+		if (err) {
+			printk("compat_isp_ioctl: failed to get capability param.\n");
+			return err;
+		}
+
+		ret = file->f_op->unlocked_ioctl(file, ISP_IO_CAPABILITY, (unsigned long)data);
+		break;
+	}
+
+	case COMPAT_ISP_IO_READ:
+	{
+		struct compat_isp_reg_param __user *data32;
+		struct isp_reg_param __user *data;
+		uint32_t cnt;
+
+		data32 = compat_ptr(param);
+		err = get_user(cnt, &data32->counts);
+
+		data = compat_alloc_user_space(sizeof(struct isp_reg_param) + cnt*sizeof(struct isp_reg_bits));
+		if (NULL == data) {
+			printk("compat_isp_ioctl: failed to compat_alloc_user_space.\n");
+			return -EFAULT;
+		}
+
+		err = compat_get_rw_param(data32, data);
+		if (err) {
+			printk("compat_isp_ioctl: failed to get isp_reg_param.\n");
+			return err;
+		}
+
+		err = compat_get_rw_param_detail(data);
+		if (err) {
+			printk("compat_isp_ioctl: failed to get isp_reg_param detail.\n");
+			return err;
+		}
+
+		ret = file->f_op->unlocked_ioctl(file, ISP_IO_READ, (unsigned long)data);
+		err = compat_put_read_param(data32, data);
+		ret = ret ? ret : err;
+		break;
+	}
+
+	case CAMPAT_ISP_REG_READ:
+	{
+		struct compat_isp_reg_bits __user *data32;
+		struct isp_reg_bits __user *data;
+		unsigned long reg_cnt = 20467;
+		compat_ulong_t addr;
+		compat_ulong_t val;
+		int i;
+		int err = 0;
+
+		data32 = compat_ptr(param);
+		data = compat_alloc_user_space(reg_cnt * sizeof(struct isp_reg_bits));
+		if (NULL == data) {
+			printk("compat_isp_ioctl: CAMPAT_ISP_REG_READ:failed to compat_alloc_user_space.\n");
+			return -EFAULT;
+		}
+
+		ret = file->f_op->unlocked_ioctl(file, ISP_REG_READ, (unsigned long)data);
+		for (i = 0; i < reg_cnt; i++) {
+			err = get_user(val, &data->reg_value);
+			err |= put_user(val, &data32->reg_value);
+			if (err) {
+				printk("compat_put_read_param: CAMPAT_ISP_REG_READ:failed to get reg_value%d\n", err);
+				break;
+			}
+
+			err = get_user(val, &data->reg_addr);
+			err |= put_user(val, &data32->reg_addr);
+			if (err) {
+				printk("compat_put_read_param: CAMPAT_ISP_REG_READ:failed to get reg_addr%d\n", err);
+				break;
+			}
+
+			data32++;
+			data++;
+		}
+		ret = ret ? ret : err;
+		break;
+	}
+
+	case COMPAT_ISP_IO_WRITE:
+	{
+		struct compat_isp_reg_param __user *data32;
+		struct isp_reg_param __user *data;
+		uint32_t cnt;
+
+		data32 = compat_ptr(param);
+		err = get_user(cnt, &data32->counts);
+		if (err) {
+			printk("compat_isp_ioctl: failed to get register count.\n");
+			return err;
+		}
+
+		data = compat_alloc_user_space(sizeof(struct isp_reg_param) + cnt*sizeof(struct isp_reg_bits));
+		if (NULL == data) {
+			printk("compat_isp_ioctl: failed to compat_alloc_user_space.\n");
+			return -EFAULT;
+		}
+
+		err = compat_get_rw_param(data32, data);
+		if (err) {
+			printk("compat_isp_ioctl: failed to get isp_reg_param.\n");
+			return err;
+		}
+
+		err = compat_get_rw_param_detail(data);
+		if (err) {
+			printk("compat_isp_ioctl: failed to get isp_reg_param detail.\n");
+			return err;
+		}
+
+		ret = file->f_op->unlocked_ioctl(file, ISP_IO_WRITE, (unsigned long)data);
+		break;
+	}
+
+	case CAMPAT_ISP_IO_CFG_PARAM:
+	{
+		struct compat_isp_io_param __user *data32;
+		struct isp_io_param __user *data;
+
+		data32 = compat_ptr(param);
+		data = compat_alloc_user_space(sizeof(*data));
+		if (NULL == data) {
+			printk("compat_isp_ioctl: failed to compat_alloc_user_space.\n");
+			return -EFAULT;
+		}
+
+		err = compat_get_cfg_param(data32, data);
+		if (err) {
+			printk("compat_isp_ioctl: failed to get cfg param.\n");
+			return err;
+		}
+
+		ret = file->f_op->unlocked_ioctl(file, ISP_IO_CFG_PARAM, (unsigned long)data);
+		break;
+	}
+
+	default:
+		printk("compat_isp_ioctl, don't support cmd 0x%x", cmd);
+		break;
+	}
+
+exit:
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/compat_isp_drv.h b/drivers/media/sprd_isp/compat_isp_drv.h
new file mode 100644
index 00000000..cda56912
--- /dev/null
+++ b/drivers/media/sprd_isp/compat_isp_drv.h
@@ -0,0 +1,23 @@
+/*
+ * 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.
+ */
+
+#ifndef _COMPAT_ISP_DRV_H_
+#define _COMPAT_ISP_DRV_H_
+
+#if IS_ENABLED(CONFIG_COMPAT)
+long compat_isp_ioctl(struct file *file, unsigned int cmd, unsigned long param);
+#else
+#define compat_isp_ioctl  NULL
+#endif /* CONFIG_COMPAT */
+
+#endif
diff --git a/drivers/media/sprd_isp/compat_isp_drv_kernel.c b/drivers/media/sprd_isp/compat_isp_drv_kernel.c
new file mode 100644
index 00000000..ae0ad4f0
--- /dev/null
+++ b/drivers/media/sprd_isp/compat_isp_drv_kernel.c
@@ -0,0 +1,327 @@
+#include <linux/compat.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <video/isp_drv_kernel.h>
+#include "compat_isp_drv_kernel.h"
+
+struct compat_isp_irq_param {
+	compat_uint_t  isp_irq_val;
+	compat_uint_t  dcam_irq_val;
+	compat_uint_t  irq_val;
+	compat_int_t   ret_val;
+};
+
+struct compat_isp_reg_bits {
+	compat_ulong_t reg_addr;
+	compat_ulong_t reg_value;
+} ;
+
+struct compat_isp_reg_param {
+	compat_ulong_t reg_param;
+	uint32_t       counts;
+} ;
+
+
+#define COMPAT_ISP_IO_READ       _IOR(ISP_IO_MAGIC, 1, struct compat_isp_reg_param)
+#define COMPAT_ISP_IO_WRITE      _IOW(ISP_IO_MAGIC, 2, struct compat_isp_reg_param)
+#define COMPAT_ISP_IO_LNC_PARAM  _IOW(ISP_IO_MAGIC, 8, struct compat_isp_reg_param)
+#define COMPAT_ISP_IO_LNC        _IOW(ISP_IO_MAGIC, 9, struct compat_isp_reg_param)
+#define COMPAT_ISP_IO_ALLOC      _IOW(ISP_IO_MAGIC, 10, struct compat_isp_reg_param)
+
+
+static int compat_get_rw_param(
+			struct compat_isp_reg_param __user *data32,
+			struct isp_reg_param __user *data)
+{
+	int                               err = 0;
+	compat_ulong_t                    addr;
+	uint32_t                          cnt;
+
+	err = get_user(addr, &data32->reg_param);
+	err |= put_user(addr, &data->reg_param);
+	err |= get_user(cnt, &data32->counts);
+	err |= put_user(cnt, &data->counts);
+
+	//printk("compat_get_rw_param, addr: 0x%x data32->reg_param: 0x%x data->reg_param: 0x%lx cnt: %d\n",
+	//	addr, data32->reg_param, data->reg_param, cnt);
+
+	return err;
+}
+
+static int compat_get_rw_param_detail(struct isp_reg_param __user *data)
+{
+	struct compat_isp_reg_bits __user *data32;
+	struct isp_reg_bits __user	*reg_data;
+	int            err = 0;
+	int            i = 0;
+	int            cnt = data->counts;
+	compat_ulong_t addr;
+	compat_ulong_t val;
+	struct isp_reg_bits __user *data_tmp;
+
+	data32 = compat_ptr(data->reg_param);
+//	printk("compat_get_rw_param_detail param: %p cnt %d\n", data32, cnt);
+	reg_data = (struct isp_reg_bits __user*)((unsigned long)data + sizeof(struct isp_reg_param));
+	data->reg_param = reg_data;
+	if (reg_data == NULL) {
+		printk("compat_isp_k failed to compat_alloc_user_space \n");
+		return -EFAULT;
+	}
+//	printk("compat_get_rw_param_detail param: data %p \n", reg_data);
+	data_tmp = reg_data;
+	for (i=0 ; i< cnt; i++) {
+		err = get_user(addr, &data32->reg_addr);
+		err |= put_user(addr, &data_tmp->reg_addr);
+		err |= get_user(val, &data32->reg_value);
+		err |= put_user(val, &data_tmp->reg_value);
+		if (err) {
+			printk("compat_isp_k, read_param_detail failed cnt %d ret %d\n", cnt, err);
+			break;
+		}
+		data32++;
+		data_tmp++;
+	}
+	return err;
+}
+
+static int compat_put_read_param(
+			struct compat_isp_reg_param __user *data32,
+			struct isp_reg_param __user *data)
+
+{
+	int                               err = 0;
+	compat_ulong_t                    val;
+	uint32_t                          cnt;
+	int                               i = 0;
+	struct compat_isp_reg_bits __user *reg_data32;
+	struct isp_reg_bits __user        *reg_data;
+
+	cnt = data->counts;
+	reg_data32 = (struct compat_isp_reg_bits __user *)data32->reg_param;
+	reg_data = (struct isp_reg_bits __user *)data->reg_param;
+	for (i=0 ; i<cnt; i++) {
+		err = get_user(val, &reg_data->reg_value);
+		err |= put_user(val, &reg_data32->reg_value);
+		if (err) {
+			printk("compat_isp_k, compat_put_read_param ret %d\n", err);
+			break;
+		}
+		reg_data32++;
+		reg_data++;
+	}
+
+	return err;
+}
+
+static int compat_get_alloc_param(
+			struct compat_isp_reg_param __user *data32,
+			struct isp_reg_param __user *data)
+{
+	int                               err = 0;
+	compat_ulong_t                    addr;
+	uint32_t                          cnt;
+	struct compat_isp_reg_bits __user *reg_data32;
+	struct isp_reg_bits __user        *reg_data;
+
+	err = get_user(addr, &data32->reg_param);
+	err |= put_user(addr, &data->reg_param);
+	err |= get_user(cnt, &data32->counts);
+	err |= put_user(cnt, &data->counts);
+
+	return err;
+}
+
+static int compat_put_alloc(
+			struct compat_isp_reg_param __user *data32,
+			struct isp_reg_param __user *data)
+
+{
+	int                               err = 0;
+	compat_ulong_t                    addr;
+	uint32_t                          cnt;
+	struct compat_isp_reg_bits __user *reg_data32;
+	struct isp_reg_bits __user        *reg_data;
+
+	err = get_user(addr, &data->reg_param);
+	err |= put_user(addr, &data32->reg_param);
+	err |= get_user(cnt, &data->counts);
+	err |= put_user(cnt, &data32->counts);
+
+	return err;
+}
+
+
+
+
+long compat_isp_kernel_ioctl( struct file *fl, unsigned int cmd, unsigned long param)
+{
+	long        ret;
+	int         err = 0;
+	void __user *up = compat_ptr(param);
+
+	if(ISP_IO_IRQ == cmd) {
+		ret = fl->f_op->unlocked_ioctl(fl, cmd, (unsigned long)up);
+	} else {
+		switch (cmd) {
+		case COMPAT_ISP_IO_READ:
+		{
+			struct compat_isp_reg_param __user *data32;
+			struct isp_reg_param __user *data;
+			uint32_t cnt;
+
+
+			data32 = compat_ptr(param);
+			err = get_user(cnt, &data32->counts);
+
+//			printk("COMPAT_ISP_IO_WRITE param: %p \n", data32);
+			data = compat_alloc_user_space(sizeof(struct isp_reg_param)+cnt*sizeof(struct isp_reg_bits));
+			if (data == NULL) {
+				printk("compat_isp_k failed to compat_alloc_user_space \n");
+				return -EFAULT;
+			}
+//			printk("@@1 %p", data);
+			err = compat_get_rw_param(data32, data);
+			if (err) {
+				return err;
+			}
+			err = compat_get_rw_param_detail(data);
+			if (err) {
+				printk("compat_isp_k error %d\n", err);
+				return err;
+			}
+			err = fl->f_op->unlocked_ioctl(fl, ISP_IO_READ, (unsigned long)data);
+			err = compat_put_read_param(data32, data);
+			ret = ret ? ret : err;
+			break;
+		}
+		case COMPAT_ISP_IO_WRITE:
+		{
+			struct compat_isp_reg_param __user *data32;
+			struct isp_reg_param __user *data;
+			uint32_t cnt;
+
+
+			data32 = compat_ptr(param);
+			err = get_user(cnt, &data32->counts);
+
+//			printk("COMPAT_ISP_IO_WRITE param: %p \n", data32);
+			data = compat_alloc_user_space(sizeof(struct isp_reg_param)+cnt*sizeof(struct isp_reg_bits));
+			if (data == NULL) {
+				printk("compat_isp_k failed to compat_alloc_user_space \n");
+				return -EFAULT;
+			}
+//			printk("@@1 %p", data);
+			err = compat_get_rw_param(data32, data);
+			if (err) {
+				return err;
+			}
+			err = compat_get_rw_param_detail(data);
+			if (err) {
+				printk("compat_isp_k error %d\n", err);
+				return err;
+			}
+			err = fl->f_op->unlocked_ioctl(fl, ISP_IO_WRITE, (unsigned long)data);
+			break;
+		}
+		case COMPAT_ISP_IO_LNC_PARAM:
+		{
+			struct compat_isp_reg_param __user *data32;
+			struct isp_reg_param __user *data;
+			char __user  *lnc_data;
+
+
+			data32 = compat_ptr(param);
+			data = compat_alloc_user_space(sizeof(*data));
+			if (data == NULL) {
+				printk("compat_isp_k failed to compat_alloc_user_space \n");
+				return -EFAULT;
+			}
+			err = compat_get_rw_param(data32, data);
+			if (err) {
+				printk("compat_isp_k COMPAT_ISP_IO_LNC_PARAM error\n");
+				return err;
+			}
+			/*lnc_data = compat_alloc_user_space(sizeof(*lnc_data)*data->counts);
+			data->reg_param = (unsigned long)lnc_data;
+			ret = copy_from_user((void*)data->reg_param, (void*)data32->reg_param, data->counts);
+			if (ret) {
+				return ret;
+			}*/
+//			printk("test 123\n");
+			ret = fl->f_op->unlocked_ioctl(fl, ISP_IO_LNC_PARAM, (unsigned long)data);
+//			printk("test 123 end\n");
+			break;
+		}
+		case COMPAT_ISP_IO_LNC:
+		{
+			struct compat_isp_reg_param __user *data32;
+			struct isp_reg_param __user *data;
+			uint32_t cnt;
+
+
+			data32 = compat_ptr(param);
+			err = get_user(cnt, &data32->counts);
+
+//			printk("COMPAT_ISP_IO_WRITE param: %p \n", data32);
+			data = compat_alloc_user_space(sizeof(struct isp_reg_param)+cnt*sizeof(struct isp_reg_bits));
+			if (data == NULL) {
+				printk("compat_isp_k failed to compat_alloc_user_space \n");
+				return -EFAULT;
+			}
+//			printk("@@1 %p", data);
+			err = compat_get_rw_param(data32, data);
+			if (err) {
+				return err;
+			}
+			err = compat_get_rw_param_detail(data);
+			if (err) {
+				printk("compat_isp_k error %d\n", err);
+				return err;
+			}
+	//		printk("test ISP_IO_LNC\n");
+			err = fl->f_op->unlocked_ioctl(fl, ISP_IO_LNC, (unsigned long)data);
+	//		printk("test ISP_IO_LNC end\n");
+			break;
+		}
+		case COMPAT_ISP_IO_ALLOC:
+		{
+			struct compat_isp_reg_param __user *data32;
+			struct isp_reg_param __user *data;
+
+			data32 = compat_ptr(param);
+			data = compat_alloc_user_space(sizeof(*data));
+			if (data == NULL) {
+				printk("compat_isp_k failed to compat_alloc_user_space \n");
+				return -EFAULT;
+			}
+			err = compat_get_alloc_param(data32, data);
+			if (err) {
+				return err;
+			}
+			ret = fl->f_op->unlocked_ioctl(fl, ISP_IO_ALLOC, (unsigned long)data);
+			if (ret) {
+				printk("compat_isp_k,failed to ISP_IO_ALLOC %ld", ret);
+				goto exit;
+			}
+			err = compat_put_alloc(data32, data);
+			ret = err;
+			break;
+		}
+
+		case ISP_IO_RST:
+		case ISP_IO_SETCLK:
+		case ISP_IO_STOP:
+		case ISP_IO_INT:
+		case ISP_IO_DCAM_INT:
+		{
+			ret = fl->f_op->unlocked_ioctl(fl, cmd, (unsigned long)up);
+			break;
+		}
+		default:
+			printk("compat_isp_k, don't support cmd 0x%x", cmd);
+			break;
+		}
+	}
+exit:
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/compat_isp_drv_kernel.h b/drivers/media/sprd_isp/compat_isp_drv_kernel.h
new file mode 100644
index 00000000..a24cce52
--- /dev/null
+++ b/drivers/media/sprd_isp/compat_isp_drv_kernel.h
@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+#ifndef _COMPAT_ISP_DRV_KERNEL_H_
+#define _COMPAT_ISP_DRV_KERNEL_H_
+
+#if IS_ENABLED(CONFIG_COMPAT)
+
+long compat_isp_kernel_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
+
+#else
+
+#define compat_isp_kernel_ioctl  NULL
+
+#endif /* CONFIG_COMPAT */
+
+#endif
diff --git a/drivers/media/sprd_isp/isp1.0/Shark_reg_isp.h b/drivers/media/sprd_isp/isp1.0/Shark_reg_isp.h
new file mode 100644
index 00000000..6b99f9ea
--- /dev/null
+++ b/drivers/media/sprd_isp/isp1.0/Shark_reg_isp.h
@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+#ifndef _TIGER_REG_ISP_H_
+#define _TIGER_REG_ISP_H_
+#ifndef CONFIG_64BIT
+#include <soc/sprd/globalregs.h>
+#else
+#include <soc/sprd/irqs.h>
+#endif
+
+#ifdef   __cplusplus
+extern   "C"
+{
+#endif
+
+
+
+
+#define ISP_DCAM_BASE		DCAM_BASE
+#define ISP_DCAM_INT_STS		(ISP_DCAM_BASE + 0x003CUL)
+#define ISP_DCAM_INT_CLR		(ISP_DCAM_BASE + 0x0044UL)
+
+#define ISP_BASE_ADDR		ISP_BASE
+#define ISP_LNC_STATUS		(ISP_BASE_ADDR+0x0200UL)
+#define ISP_LNC_LOAD		(ISP_BASE_ADDR+0x0220UL)
+#define ISP_AXI_MASTER		(ISP_BASE_ADDR+0x2000UL)
+#define ISP_INT_RAW		(ISP_BASE_ADDR+0x2080UL)
+#define ISP_INT_STATUS		(ISP_BASE_ADDR+0x2084UL)
+#define ISP_INT_EN		(ISP_BASE_ADDR+0x2078UL)
+#define ISP_INT_CLEAR		(ISP_BASE_ADDR+0x207cUL)
+#define ISP_REG_MAX_SIZE		SPRD_ISP_SIZE
+#define ISP_AXI_MASTER_STOP	(ISP_BASE_ADDR + 0X2054UL)
+
+#define ISP_AHB_BASE		SPRD_MMAHB_BASE
+#define ISP_MODULE_EB		(ISP_AHB_BASE + 0x0000UL)
+#define ISP_MODULE_RESET	(ISP_AHB_BASE + 0x0004UL)
+#define ISP_CORE_CLK_EB		(ISP_AHB_BASE + 0x0008UL)
+
+#define ISP_CLOCK_BASE		SPRD_MMCKG_BASE
+#define ISP_CLOCK			(ISP_CLOCK_BASE + 0X34)
+
+
+/*irq line number in system*/
+#define ISP_IRQ				IRQ_ISP_INT
+
+#define ISP_EB_BIT		BIT_2
+#define ISP_RST_LOG_BIT	BIT_2
+#define ISP_RST_CFG_BIT	BIT_3
+#define ISP_CORE_CLK_EB_BIT	BIT_4
+#define ISP_AXI_MASTER_STOP_BIT BIT_0
+
+#define ISP_IRQ_HW_MASK_V0001 (0x1fffffff)
+#define ISP_IRQ_NUM_V0001 (29)
+#define ISP_TMP_BUF_SIZE_MAX_V0001 (32 * 1024)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_TIGER_REG_ISP_H_
diff --git a/drivers/media/sprd_isp/isp1.0/Tiger_reg_isp.h b/drivers/media/sprd_isp/isp1.0/Tiger_reg_isp.h
new file mode 100644
index 00000000..d68a8ff9
--- /dev/null
+++ b/drivers/media/sprd_isp/isp1.0/Tiger_reg_isp.h
@@ -0,0 +1,91 @@
+/*
+ * 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.
+ */
+#ifndef _TIGER_REG_ISP_H_
+#define _TIGER_REG_ISP_H_
+#include <mach/globalregs.h>
+
+#ifdef   __cplusplus
+extern   "C"
+{
+#endif
+
+#define BIT_0                                          0x01
+#define BIT_1                                          0x02
+#define BIT_2                                          0x04
+#define BIT_3                                          0x08
+#define BIT_4                                          0x10
+#define BIT_5                                          0x20
+#define BIT_6                                          0x40
+#define BIT_7                                          0x80
+#define BIT_8                                          0x0100
+#define BIT_9                                          0x0200
+#define BIT_10                                         0x0400
+#define BIT_11                                         0x0800
+#define BIT_12                                         0x1000
+#define BIT_13                                         0x2000
+#define BIT_14                                         0x4000
+#define BIT_15                                         0x8000
+#define BIT_16                                         0x010000
+#define BIT_17                                         0x020000
+#define BIT_18                                         0x040000
+#define BIT_19                                         0x080000
+#define BIT_20                                         0x100000
+#define BIT_21                                         0x200000
+#define BIT_22                                         0x400000
+#define BIT_23                                         0x800000
+#define BIT_24                                         0x01000000
+#define BIT_25                                         0x02000000
+#define BIT_26                                         0x04000000
+#define BIT_27                                         0x08000000
+#define BIT_28                                         0x10000000
+#define BIT_29                                         0x20000000
+#define BIT_30                                         0x40000000
+#define BIT_31                                         0x80000000
+
+
+#define ISP_DCAM_BASE		DCAM_BASE
+#define ISP_DCAM_INT_STS		(ISP_DCAM_BASE + 0x0030UL)
+#define ISP_DCAM_INT_CLR		(ISP_DCAM_BASE + 0x0038UL)
+
+#define ISP_BASE_ADDR		ISP_BASE
+#define ISP_LNC_LOAD		(ISP_BASE_ADDR+0x0220UL)
+#define ISP_AXI_MASTER		(ISP_BASE_ADDR+0x2000UL)
+#define ISP_INT_RAW		(ISP_BASE_ADDR+0x2080UL)
+#define ISP_INT_STATUS		(ISP_BASE_ADDR+0x2084UL)
+#define ISP_INT_EN		(ISP_BASE_ADDR+0x2078UL)
+#define ISP_INT_CLEAR		(ISP_BASE_ADDR+0x207cUL)
+#define ISP_REG_MAX_SIZE		SPRD_ISP_SIZE
+
+#define ISP_AHB_BASE		SPRD_AHB_BASE
+#define ISP_AHB_CTL0		(ISP_AHB_BASE + 0x0200UL)
+#define ISP_MODULE_EB		(ISP_AHB_CTL0 + 0x0000UL)
+#define ISP_MODULE_RESET		(ISP_AHB_CTL0 + 0x0010UL)
+
+#define ISP_CORE_CLK_EB		(ISP_AHB_BASE + 0x0208UL)
+
+/*irq line number in system*/
+#define ISP_IRQ			IRQ_ISP_INT
+#define DCAM_IRQ			IRQ_DCAM_INT
+
+#define ISP_EB_BIT		BIT_12
+#define ISP_RST_BIT		BIT_8
+#define ISP_CORE_CLK_EB_BIT	BIT_7
+#define ISP_IRQ_HW_MASK_V0000 (0xfff)
+#define ISP_IRQ_NUM_V0000 (12)
+#define ISP_TMP_BUF_SIZE_MAX_V0000 (36 * 1024)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_TIGER_REG_ISP_H_
\ No newline at end of file
diff --git a/drivers/media/sprd_isp/isp1.0/compat_isp_drv_kernel.c b/drivers/media/sprd_isp/isp1.0/compat_isp_drv_kernel.c
new file mode 100644
index 00000000..ae0ad4f0
--- /dev/null
+++ b/drivers/media/sprd_isp/isp1.0/compat_isp_drv_kernel.c
@@ -0,0 +1,327 @@
+#include <linux/compat.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <video/isp_drv_kernel.h>
+#include "compat_isp_drv_kernel.h"
+
+struct compat_isp_irq_param {
+	compat_uint_t  isp_irq_val;
+	compat_uint_t  dcam_irq_val;
+	compat_uint_t  irq_val;
+	compat_int_t   ret_val;
+};
+
+struct compat_isp_reg_bits {
+	compat_ulong_t reg_addr;
+	compat_ulong_t reg_value;
+} ;
+
+struct compat_isp_reg_param {
+	compat_ulong_t reg_param;
+	uint32_t       counts;
+} ;
+
+
+#define COMPAT_ISP_IO_READ       _IOR(ISP_IO_MAGIC, 1, struct compat_isp_reg_param)
+#define COMPAT_ISP_IO_WRITE      _IOW(ISP_IO_MAGIC, 2, struct compat_isp_reg_param)
+#define COMPAT_ISP_IO_LNC_PARAM  _IOW(ISP_IO_MAGIC, 8, struct compat_isp_reg_param)
+#define COMPAT_ISP_IO_LNC        _IOW(ISP_IO_MAGIC, 9, struct compat_isp_reg_param)
+#define COMPAT_ISP_IO_ALLOC      _IOW(ISP_IO_MAGIC, 10, struct compat_isp_reg_param)
+
+
+static int compat_get_rw_param(
+			struct compat_isp_reg_param __user *data32,
+			struct isp_reg_param __user *data)
+{
+	int                               err = 0;
+	compat_ulong_t                    addr;
+	uint32_t                          cnt;
+
+	err = get_user(addr, &data32->reg_param);
+	err |= put_user(addr, &data->reg_param);
+	err |= get_user(cnt, &data32->counts);
+	err |= put_user(cnt, &data->counts);
+
+	//printk("compat_get_rw_param, addr: 0x%x data32->reg_param: 0x%x data->reg_param: 0x%lx cnt: %d\n",
+	//	addr, data32->reg_param, data->reg_param, cnt);
+
+	return err;
+}
+
+static int compat_get_rw_param_detail(struct isp_reg_param __user *data)
+{
+	struct compat_isp_reg_bits __user *data32;
+	struct isp_reg_bits __user	*reg_data;
+	int            err = 0;
+	int            i = 0;
+	int            cnt = data->counts;
+	compat_ulong_t addr;
+	compat_ulong_t val;
+	struct isp_reg_bits __user *data_tmp;
+
+	data32 = compat_ptr(data->reg_param);
+//	printk("compat_get_rw_param_detail param: %p cnt %d\n", data32, cnt);
+	reg_data = (struct isp_reg_bits __user*)((unsigned long)data + sizeof(struct isp_reg_param));
+	data->reg_param = reg_data;
+	if (reg_data == NULL) {
+		printk("compat_isp_k failed to compat_alloc_user_space \n");
+		return -EFAULT;
+	}
+//	printk("compat_get_rw_param_detail param: data %p \n", reg_data);
+	data_tmp = reg_data;
+	for (i=0 ; i< cnt; i++) {
+		err = get_user(addr, &data32->reg_addr);
+		err |= put_user(addr, &data_tmp->reg_addr);
+		err |= get_user(val, &data32->reg_value);
+		err |= put_user(val, &data_tmp->reg_value);
+		if (err) {
+			printk("compat_isp_k, read_param_detail failed cnt %d ret %d\n", cnt, err);
+			break;
+		}
+		data32++;
+		data_tmp++;
+	}
+	return err;
+}
+
+static int compat_put_read_param(
+			struct compat_isp_reg_param __user *data32,
+			struct isp_reg_param __user *data)
+
+{
+	int                               err = 0;
+	compat_ulong_t                    val;
+	uint32_t                          cnt;
+	int                               i = 0;
+	struct compat_isp_reg_bits __user *reg_data32;
+	struct isp_reg_bits __user        *reg_data;
+
+	cnt = data->counts;
+	reg_data32 = (struct compat_isp_reg_bits __user *)data32->reg_param;
+	reg_data = (struct isp_reg_bits __user *)data->reg_param;
+	for (i=0 ; i<cnt; i++) {
+		err = get_user(val, &reg_data->reg_value);
+		err |= put_user(val, &reg_data32->reg_value);
+		if (err) {
+			printk("compat_isp_k, compat_put_read_param ret %d\n", err);
+			break;
+		}
+		reg_data32++;
+		reg_data++;
+	}
+
+	return err;
+}
+
+static int compat_get_alloc_param(
+			struct compat_isp_reg_param __user *data32,
+			struct isp_reg_param __user *data)
+{
+	int                               err = 0;
+	compat_ulong_t                    addr;
+	uint32_t                          cnt;
+	struct compat_isp_reg_bits __user *reg_data32;
+	struct isp_reg_bits __user        *reg_data;
+
+	err = get_user(addr, &data32->reg_param);
+	err |= put_user(addr, &data->reg_param);
+	err |= get_user(cnt, &data32->counts);
+	err |= put_user(cnt, &data->counts);
+
+	return err;
+}
+
+static int compat_put_alloc(
+			struct compat_isp_reg_param __user *data32,
+			struct isp_reg_param __user *data)
+
+{
+	int                               err = 0;
+	compat_ulong_t                    addr;
+	uint32_t                          cnt;
+	struct compat_isp_reg_bits __user *reg_data32;
+	struct isp_reg_bits __user        *reg_data;
+
+	err = get_user(addr, &data->reg_param);
+	err |= put_user(addr, &data32->reg_param);
+	err |= get_user(cnt, &data->counts);
+	err |= put_user(cnt, &data32->counts);
+
+	return err;
+}
+
+
+
+
+long compat_isp_kernel_ioctl( struct file *fl, unsigned int cmd, unsigned long param)
+{
+	long        ret;
+	int         err = 0;
+	void __user *up = compat_ptr(param);
+
+	if(ISP_IO_IRQ == cmd) {
+		ret = fl->f_op->unlocked_ioctl(fl, cmd, (unsigned long)up);
+	} else {
+		switch (cmd) {
+		case COMPAT_ISP_IO_READ:
+		{
+			struct compat_isp_reg_param __user *data32;
+			struct isp_reg_param __user *data;
+			uint32_t cnt;
+
+
+			data32 = compat_ptr(param);
+			err = get_user(cnt, &data32->counts);
+
+//			printk("COMPAT_ISP_IO_WRITE param: %p \n", data32);
+			data = compat_alloc_user_space(sizeof(struct isp_reg_param)+cnt*sizeof(struct isp_reg_bits));
+			if (data == NULL) {
+				printk("compat_isp_k failed to compat_alloc_user_space \n");
+				return -EFAULT;
+			}
+//			printk("@@1 %p", data);
+			err = compat_get_rw_param(data32, data);
+			if (err) {
+				return err;
+			}
+			err = compat_get_rw_param_detail(data);
+			if (err) {
+				printk("compat_isp_k error %d\n", err);
+				return err;
+			}
+			err = fl->f_op->unlocked_ioctl(fl, ISP_IO_READ, (unsigned long)data);
+			err = compat_put_read_param(data32, data);
+			ret = ret ? ret : err;
+			break;
+		}
+		case COMPAT_ISP_IO_WRITE:
+		{
+			struct compat_isp_reg_param __user *data32;
+			struct isp_reg_param __user *data;
+			uint32_t cnt;
+
+
+			data32 = compat_ptr(param);
+			err = get_user(cnt, &data32->counts);
+
+//			printk("COMPAT_ISP_IO_WRITE param: %p \n", data32);
+			data = compat_alloc_user_space(sizeof(struct isp_reg_param)+cnt*sizeof(struct isp_reg_bits));
+			if (data == NULL) {
+				printk("compat_isp_k failed to compat_alloc_user_space \n");
+				return -EFAULT;
+			}
+//			printk("@@1 %p", data);
+			err = compat_get_rw_param(data32, data);
+			if (err) {
+				return err;
+			}
+			err = compat_get_rw_param_detail(data);
+			if (err) {
+				printk("compat_isp_k error %d\n", err);
+				return err;
+			}
+			err = fl->f_op->unlocked_ioctl(fl, ISP_IO_WRITE, (unsigned long)data);
+			break;
+		}
+		case COMPAT_ISP_IO_LNC_PARAM:
+		{
+			struct compat_isp_reg_param __user *data32;
+			struct isp_reg_param __user *data;
+			char __user  *lnc_data;
+
+
+			data32 = compat_ptr(param);
+			data = compat_alloc_user_space(sizeof(*data));
+			if (data == NULL) {
+				printk("compat_isp_k failed to compat_alloc_user_space \n");
+				return -EFAULT;
+			}
+			err = compat_get_rw_param(data32, data);
+			if (err) {
+				printk("compat_isp_k COMPAT_ISP_IO_LNC_PARAM error\n");
+				return err;
+			}
+			/*lnc_data = compat_alloc_user_space(sizeof(*lnc_data)*data->counts);
+			data->reg_param = (unsigned long)lnc_data;
+			ret = copy_from_user((void*)data->reg_param, (void*)data32->reg_param, data->counts);
+			if (ret) {
+				return ret;
+			}*/
+//			printk("test 123\n");
+			ret = fl->f_op->unlocked_ioctl(fl, ISP_IO_LNC_PARAM, (unsigned long)data);
+//			printk("test 123 end\n");
+			break;
+		}
+		case COMPAT_ISP_IO_LNC:
+		{
+			struct compat_isp_reg_param __user *data32;
+			struct isp_reg_param __user *data;
+			uint32_t cnt;
+
+
+			data32 = compat_ptr(param);
+			err = get_user(cnt, &data32->counts);
+
+//			printk("COMPAT_ISP_IO_WRITE param: %p \n", data32);
+			data = compat_alloc_user_space(sizeof(struct isp_reg_param)+cnt*sizeof(struct isp_reg_bits));
+			if (data == NULL) {
+				printk("compat_isp_k failed to compat_alloc_user_space \n");
+				return -EFAULT;
+			}
+//			printk("@@1 %p", data);
+			err = compat_get_rw_param(data32, data);
+			if (err) {
+				return err;
+			}
+			err = compat_get_rw_param_detail(data);
+			if (err) {
+				printk("compat_isp_k error %d\n", err);
+				return err;
+			}
+	//		printk("test ISP_IO_LNC\n");
+			err = fl->f_op->unlocked_ioctl(fl, ISP_IO_LNC, (unsigned long)data);
+	//		printk("test ISP_IO_LNC end\n");
+			break;
+		}
+		case COMPAT_ISP_IO_ALLOC:
+		{
+			struct compat_isp_reg_param __user *data32;
+			struct isp_reg_param __user *data;
+
+			data32 = compat_ptr(param);
+			data = compat_alloc_user_space(sizeof(*data));
+			if (data == NULL) {
+				printk("compat_isp_k failed to compat_alloc_user_space \n");
+				return -EFAULT;
+			}
+			err = compat_get_alloc_param(data32, data);
+			if (err) {
+				return err;
+			}
+			ret = fl->f_op->unlocked_ioctl(fl, ISP_IO_ALLOC, (unsigned long)data);
+			if (ret) {
+				printk("compat_isp_k,failed to ISP_IO_ALLOC %ld", ret);
+				goto exit;
+			}
+			err = compat_put_alloc(data32, data);
+			ret = err;
+			break;
+		}
+
+		case ISP_IO_RST:
+		case ISP_IO_SETCLK:
+		case ISP_IO_STOP:
+		case ISP_IO_INT:
+		case ISP_IO_DCAM_INT:
+		{
+			ret = fl->f_op->unlocked_ioctl(fl, cmd, (unsigned long)up);
+			break;
+		}
+		default:
+			printk("compat_isp_k, don't support cmd 0x%x", cmd);
+			break;
+		}
+	}
+exit:
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp1.0/compat_isp_drv_kernel.h b/drivers/media/sprd_isp/isp1.0/compat_isp_drv_kernel.h
new file mode 100644
index 00000000..a24cce52
--- /dev/null
+++ b/drivers/media/sprd_isp/isp1.0/compat_isp_drv_kernel.h
@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+#ifndef _COMPAT_ISP_DRV_KERNEL_H_
+#define _COMPAT_ISP_DRV_KERNEL_H_
+
+#if IS_ENABLED(CONFIG_COMPAT)
+
+long compat_isp_kernel_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
+
+#else
+
+#define compat_isp_kernel_ioctl  NULL
+
+#endif /* CONFIG_COMPAT */
+
+#endif
diff --git a/drivers/media/sprd_isp/isp1.0/isp_drv_kernel.c b/drivers/media/sprd_isp/isp1.0/isp_drv_kernel.c
new file mode 100644
index 00000000..9a6acbef
--- /dev/null
+++ b/drivers/media/sprd_isp/isp1.0/isp_drv_kernel.c
@@ -0,0 +1,1494 @@
+/*
+ * 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/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/poll.h>
+#include <linux/fs.h>
+#include <linux/irq.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/miscdevice.h>
+#include <asm/io.h>
+#include <linux/file.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/spinlock_types.h>
+#include <linux/semaphore.h>
+#include <linux/delay.h>
+#include <linux/proc_fs.h>
+#include <video/isp_drv_kernel.h>
+#include <soc/sprd/sci.h>
+#include <linux/clk.h>
+#include <asm/cacheflush.h>
+#ifndef CONFIG_64BIT
+#include <soc/sprd/hardware.h>
+#endif
+#include "compat_isp_drv_kernel.h"
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/vmalloc.h>
+#include <linux/kthread.h>
+
+#include "Shark_reg_isp.h"
+#include "parse_hwinfo.h"
+
+
+#define DEBUG_ISP_DRV
+#ifdef DEBUG_ISP_DRV
+#define ISP_PRINT   printk
+#else
+#define ISP_PRINT(...)
+#endif
+
+#define ISP_QUEUE_LENGTH 16
+#define SA_SHIRQ	IRQF_SHARED
+static uint32_t                    g_isp_irq = 0x12345678;/*for share irq handler function*/
+//static uint32_t                    g_dcam_irq = 0x12345678;/*for share irq handler function*/
+
+#define ISP_MINOR		MISC_DYNAMIC_MINOR/*isp minor number*/
+#define init_MUTEX(sem)		sema_init(sem, 1)
+#define init_MUTEX_LOCKED(sem)	sema_init(sem, 0)
+#define IO_PTR          volatile void __iomem *
+#define ISP_READL(a)	__raw_readl((IO_PTR)a)
+#define ISP_WRITEL(a,v)	__raw_writel(v,(IO_PTR)a)
+#define ISP_OWR(a,v)	__raw_writel((__raw_readl((IO_PTR)a) | v), (IO_PTR)a)
+#define ISP_AWR(a,v)	__raw_writel((__raw_readl((IO_PTR)a) & v), (IO_PTR)a)
+#define ISP_NAWR(a,v)	__raw_writel((__raw_readl((IO_PTR)a) & ~v), (IO_PTR)a)
+#define ISP_REG_RD(a)	ISP_READL(((IO_PTR)a))
+#define DEBUG_STR                         "Error L %d, %s \n"
+#define DEBUG_ARGS                        __LINE__,__FUNCTION__
+#define ISP_LOWEST_ADDR                0x800
+#define ISP_ADDR_INVALID(addr)         ((unsigned long)(addr) < (unsigned long)ISP_LOWEST_ADDR)
+#define ISP_CHECK_ZERO(a)                                      \
+	do {                                                       \
+		if (ISP_ADDR_INVALID(a)) {                       \
+			printk("isp_k, zero pointer \n");           \
+			printk(DEBUG_STR, DEBUG_ARGS);               \
+			return -EFAULT;                              \
+		}                                                   \
+	} while(0)
+
+#define ISP_CHECK_ZERO_VOID(a)                                 \
+	do {                                                       \
+		if (ISP_ADDR_INVALID(a)) {                       \
+			printk("isp_k, zero pointer \n");           \
+			printk(DEBUG_STR, DEBUG_ARGS);               \
+			return;                                      \
+		}                                                   \
+	} while(0)
+
+#define ISP_DCAM_IRQ_MASK	0x03
+#define ISP_DCAM_IRQ_NUM	0x02
+#define ISP_BUF_MAX_SIZE ISP_TMP_BUF_SIZE_MAX_V0001
+#define ISP_IRQ_NUM ISP_IRQ_NUM_V0001
+#define ISP_IRQ_HW_MASK ISP_IRQ_HW_MASK_V0001
+#define ISP_TIME_OUT_MAX (500)
+
+struct isp_node {
+	uint32_t	isp_irq_val;
+	uint32_t	dcam_irq_val;
+	uint64_t	system_time;
+};
+
+struct isp_queue {
+	struct isp_node 	node[ISP_QUEUE_LENGTH];
+	struct isp_node 	*write;
+	struct isp_node 	*read;
+};
+
+struct isp_lnc_load {
+	uint8_t   load_lnc_flag;
+	uint8_t   cap_eof_flag;
+	uint32_t param_counts;
+	unsigned long load_buf;
+	struct semaphore  load_done_sem;
+};
+struct isp_device_t
+{
+	unsigned long reg_base_addr;/*the pointer of isp register context*/
+	uint32_t size;/* struct size*/
+	unsigned long buf_addr;
+	uint32_t buf_len;
+	struct isp_queue queue;
+	struct semaphore sem_isr;/*for interrupts*/
+	struct semaphore sem_isp;/*for the isp device, protect the isp hardware; protect  only  one caller use the oi*/
+				/*controll/read/write functions*/
+	struct clk* s_isp_clk_mm_i;
+	struct clk              *s_isp_clk;
+	struct semaphore  kernel_sem;
+	struct task_struct*  kernel_thread;
+	struct isp_lnc_load lnc_load;
+	uint32_t is_kernel_thread_stop;
+};
+enum dcam_irq_id {
+	DCAM_SN_SOF = 0,
+	DCAM_SN_EOF,
+	DCAM_CAP_SOF,
+	DCAM_CAP_EOF,
+	DCAM_PATH0_DONE,
+	DCAM_PATH0_OV,
+	DCAM_PATH1_DONE,
+	DCAM_PATH1_OV,
+	DCAM_PATH2_DONE,
+	DCAM_PATH2_OV,
+	DCAM_SN_LINE_ERR,
+	DCAM_SN_FRAME_ERR,
+	DCAM_JPEG_BUF_OV,
+	DCAM_ISP_OV,
+	DCAM_MIPI_OV,
+	DCAM_ROT_DONE,
+	DCAM_PATH1_SLICE_DONE,
+	DCAM_PATH2_SLICE_DONE,
+	DCAM_RAW_SLICE_DONE,
+	DCAM_PATH1_SOF,
+	DCAM_PATH2_SOF,
+	DCAM_IRQ_NUMBER
+};
+struct dcam_frame {
+	uint32_t               type;
+	uint32_t               lock;
+	uint32_t               flags;
+	uint32_t               fid;
+	uint32_t               width;
+	uint32_t               height;
+	uint32_t               yaddr;
+	uint32_t               uaddr;
+	uint32_t               vaddr;
+	struct dcam_frame      *prev;
+	struct dcam_frame      *next;
+};
+typedef int (*dcam_isr_func)(struct dcam_frame* frame, void* u_data);
+extern int32_t dcam_reg_isr(enum dcam_irq_id id, dcam_isr_func user_func, void* user_data);
+
+static atomic_t s_isp_users = ATOMIC_INIT(0);
+static struct mutex s_isp_lock;	/*for the isp driver, protect the isp module; protect only one user open this module*/
+static struct proc_dir_entry*  isp_proc_file;
+static struct isp_device_t *g_isp_dev_ptr = NULL;
+
+uint32_t s_dcam_int_eb = 0x00;
+unsigned long s_isp_alloc_addr = 0x00;
+uint32_t s_isp_alloc_order = 0x00;
+uint32_t s_isp_alloc_len = 0x00;
+
+static DEFINE_SPINLOCK(isp_spin_lock);
+static int32_t _isp_set_clk(enum isp_clk_sel clk_sel);
+static int32_t _isp_module_eb(void);
+static int32_t _isp_module_dis(void);
+static int  _isp_registerirq(void);
+static void _isp_unregisterirq(void);
+static irqreturn_t _isp_irq_root(int irq, void *dev_id);
+void _dcam_isp_root(void);
+static int _isp_queue_init(struct isp_queue *queue);
+static int _isp_queue_write(struct isp_queue *queue, struct isp_node *node);
+static int _isp_queue_read(struct isp_queue *queue, struct isp_node *node);
+static inline void _isp_regread(char *dst,  char *src, size_t n);
+static inline void  _isp_regwrite(char *dst,  char *src, size_t n);
+static void _read_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts);
+static void _write_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts);
+
+/**file operation functions declare**/
+static int32_t _isp_kernel_open(struct inode *node, struct file *filp);
+static int32_t _isp_kernel_release(struct inode *node, struct file *filp);
+static long _isp_kernel_ioctl( struct file *fl, unsigned int cmd, unsigned long param);
+/**driver'  functions declare**/
+static int32_t _isp_probe(struct platform_device *pdev);
+static int32_t _isp_remove(struct platform_device *dev);
+/**module'  functions declare**/
+static int32_t __init isp_kernel_init(void);
+static void isp_kernel_exit(void);
+static int32_t _isp_lnc_param_load_ex(struct isp_reg_bits *reg_bits_ptr, uint32_t counts);
+static int _isp_stop_kernel_thread(void* param);
+
+static struct file_operations isp_fops = {
+	.owner	= THIS_MODULE,
+	.open	= _isp_kernel_open,
+	.unlocked_ioctl	= _isp_kernel_ioctl,
+	.compat_ioctl = compat_isp_kernel_ioctl,
+	.release	= _isp_kernel_release,
+};
+
+static struct miscdevice isp_dev = {
+	.minor	= ISP_MINOR,
+	.name	= "sprd_isp",
+	.fops	= &isp_fops,
+};
+
+static const struct of_device_id of_match_table_isp[] = {
+	{ .compatible = "sprd,sprd_isp", },
+	{ },
+};
+
+static struct platform_driver isp_driver = {
+	.probe	= _isp_probe,
+	.remove	= _isp_remove,
+	.driver	= {
+		.owner = THIS_MODULE,
+		.name = "sprd_isp",
+		.of_match_table = of_match_ptr(of_match_table_isp),
+	},
+};
+
+static int32_t _isp_get_systemtime(struct timeval *tv)
+{
+	struct timespec ts;
+
+	ktime_get_ts(&ts);
+	tv->tv_sec = ts.tv_sec;
+	tv->tv_usec = ts.tv_nsec / NSEC_PER_USEC;
+	return 0;
+}
+
+static int32_t _isp_module_eb(void)
+{
+	int32_t ret = 0;
+
+	if (0x01 == atomic_inc_return(&s_isp_users)) {
+
+		ret = clk_mm_i_eb(isp_dev.this_device->of_node,1);
+		ret = _isp_set_clk(ISP_CLK_312M);
+		if (unlikely(0 != ret)) {
+			ISP_PRINT("isp_k: set clock error\n");
+			ret = -EIO;
+		}
+	}
+
+	ISP_PRINT("_isp_module_eb: end\n");
+
+	return ret;
+}
+
+static int32_t _isp_module_dis(void)
+{
+	int32_t	ret = 0;
+
+	if (0x00 == atomic_dec_return(&s_isp_users)) {
+
+		ret = _isp_set_clk(ISP_CLK_NONE);
+		if (unlikely(0 != ret)) {
+			ISP_PRINT("isp_k: close clock error\n");
+			ret = -EFAULT;
+			return ret;
+		}
+		ret =  clk_mm_i_eb(isp_dev.this_device->of_node,0);
+	}
+	return ret;
+}
+
+static int32_t _isp_module_rst(void)
+{
+	int32_t ret = 0;
+	uint32_t reg_value=0x00;
+	int32_t time_out_cnt = 0;
+
+	if (0x00 != atomic_read(&s_isp_users)) {
+
+		ISP_OWR(ISP_AXI_MASTER_STOP, BIT_0);
+
+		reg_value=ISP_READL(ISP_AXI_MASTER);
+		while((0x00==(reg_value&0x08)) && (time_out_cnt < (ISP_TIME_OUT_MAX * 2)))
+		{
+			time_out_cnt++;
+			udelay(50);
+			reg_value=ISP_READL(ISP_AXI_MASTER);
+		}
+		if (time_out_cnt >= ISP_TIME_OUT_MAX) {
+			ret = -1;
+			ISP_PRINT("_isp_module_rst: time out\n");
+		}
+
+		ISP_WRITEL(ISP_INT_CLEAR, ISP_IRQ_HW_MASK);
+
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+
+		sci_glb_clr(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+		sci_glb_clr(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+	}
+
+	ISP_PRINT("_isp_module_rst: exit\n");
+
+	return 0;
+}
+
+void* _isp_cap_eof(struct dcam_frame* frame, void* u_data)
+{
+	struct isp_device_t * p_isp = (struct isp_device_t *)u_data;
+	if (p_isp) {
+		p_isp->lnc_load.cap_eof_flag = 1;
+		if (p_isp->lnc_load.load_lnc_flag) {
+			up(&p_isp->kernel_sem);
+			p_isp->lnc_load.load_lnc_flag = 0;
+		} else {
+		}
+	}
+}
+int _isp_kernel_proc(void *arg)
+{
+	struct isp_device_t          *dev = (struct isp_device_t*)arg;
+	int32_t                      time_out_cnt = 0;
+	uint32_t                     reg_value=0x00;
+	int                          ret = 0;
+	struct isp_reg_bits *reg_bits_ptr;
+	uint32_t counts;
+	while(1) {
+		if (0 == down_interruptible(&dev->kernel_sem)) {
+			if (dev->is_kernel_thread_stop) {
+				printk("isp_k: _isp_kernel_proc stop \n");
+				break;
+			}
+			reg_bits_ptr = (struct isp_reg_bits*) g_isp_dev_ptr->lnc_load.load_buf;
+			counts = g_isp_dev_ptr->lnc_load.param_counts;
+			ret = _isp_lnc_param_load_ex(reg_bits_ptr, counts);
+			memset((void *)g_isp_dev_ptr->lnc_load.load_buf, 0x00, ISP_BUF_MAX_SIZE);
+		}
+	}
+	dev->is_kernel_thread_stop = 0;
+	return 0;
+}
+int _isp_kernel_thread(void* param)
+{
+	struct isp_device_t          *dev = (struct isp_device_t*)param;
+	if (dev == NULL) {
+		printk("isp_k: _isp_kernel_thread, dev is NULL \n");
+		return -1;
+	}
+	dev->lnc_load.load_lnc_flag = 0;
+	dev->lnc_load.cap_eof_flag = 0;
+	dev->is_kernel_thread_stop = 0;
+	sema_init(&dev->kernel_sem, 0);
+	sema_init(&dev->lnc_load.load_done_sem, 0);
+	dev->kernel_thread = kthread_run(_isp_kernel_proc, param, "isp_kernel_proc_thread");
+	if (IS_ERR(dev->kernel_thread)) {
+		printk("isp_k: _isp_kernel_thread error!\n");
+		return -1;
+	}
+	return 0;
+}
+static int _isp_stop_kernel_thread(void* param)
+{
+	struct isp_device_t          *dev = (struct isp_device_t*)param;
+	int cnt = 0;
+	if (dev == NULL) {
+		printk("SPRD_IMG: sprd_img_opt_flash, dev is NULL \n");
+		return -1;
+	}
+	if (dev->kernel_thread) {
+		dev->is_kernel_thread_stop = 1;
+		up(&dev->kernel_sem);
+		if (0 != dev->is_kernel_thread_stop) {
+			while (cnt < 500) {
+				cnt++;
+				if (0 == dev->is_kernel_thread_stop)
+					break;
+				msleep(1);
+			}
+		}
+		dev->kernel_thread = NULL;
+	}
+	return 0;
+}
+static int32_t _isp_lnc_param_load_ex(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
+{
+	int32_t ret = 0;
+	int32_t time_out_cnt = 0;
+	volatile uint32_t reg_value=0x00;
+
+	if((0x00!=s_isp_alloc_addr)
+		&&(0x00!=s_isp_alloc_len)) {
+
+		void *ptr = (void*)s_isp_alloc_addr;
+		uint32_t len=s_isp_alloc_len;
+
+		#ifndef CONFIG_64BIT
+		dmac_flush_range(ptr, ptr + len);
+		outer_flush_range(__pa(ptr), __pa(ptr) + len);
+		#endif
+
+		reg_bits_ptr->reg_value=(uint32_t)__pa(reg_bits_ptr->reg_value);
+//#if defined(CONFIG_MACH_CORE3)
+
+
+			reg_value=ISP_READL(ISP_LNC_STATUS);
+			while((0x00==(reg_value&ISP_LNC_STATUS_OK)) && (time_out_cnt < (ISP_TIME_OUT_MAX*1000))) {
+				udelay(1);
+				reg_value=ISP_READL(ISP_LNC_STATUS);
+				time_out_cnt++;
+			}
+			if (time_out_cnt >= (ISP_TIME_OUT_MAX*1000)) {
+				ret = -1;
+				ISP_PRINT("isp_k: isp lnc status time out\n");
+			}
+		ISP_OWR(ISP_INT_EN, ISP_INT_LENS_LOAD);
+			_write_reg(reg_bits_ptr, counts);
+	}else {
+		ISP_PRINT("isp_k: isp load lnc param error\n");
+	}
+	return ret;
+}
+static int32_t _isp_lnc_param_load(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
+{
+	int32_t ret = 0;
+	int32_t time_out_cnt = 0;
+	uint32_t reg_value=0x00;
+	printk("isp_k: _isp_lnc_param_load \n");
+	if((0x00!=s_isp_alloc_addr)
+		&&(0x00!=s_isp_alloc_len)) {
+		void *ptr = (void*)s_isp_alloc_addr;
+		uint32_t len=s_isp_alloc_len;
+		#ifndef CONFIG_64BIT
+		dmac_flush_range(ptr, ptr + len);
+		outer_flush_range(__pa(ptr), __pa(ptr) + len);
+		#endif
+		reg_bits_ptr->reg_value=(uint32_t)__pa(reg_bits_ptr->reg_value);
+               {
+                       unsigned long flags;
+                       reg_value=ISP_READL(ISP_LNC_STATUS);
+                       while((0x00==(reg_value&ISP_LNC_STATUS_OK)) && (time_out_cnt < (ISP_TIME_OUT_MAX*1000))) {
+                               udelay(1);
+                               reg_value=ISP_READL(ISP_LNC_STATUS);
+                               time_out_cnt++;
+		}
+                       if (time_out_cnt >= (ISP_TIME_OUT_MAX*1000)) {
+                               ret = -1;
+                               ISP_PRINT("isp_k: isp lnc status time out\n");
+                       }
+		_write_reg(reg_bits_ptr, counts);
+			printk("isp_k: load, 0x%x: 0x%x, 0x%x, counts %d \n", reg_bits_ptr, reg_bits_ptr->reg_addr, reg_bits_ptr->reg_value, counts);
+               }
+
+		time_out_cnt = 0;
+		reg_value=ISP_READL(ISP_INT_RAW);
+
+		while ((0x00 == (reg_value&ISP_INT_LENS_LOAD)) && (time_out_cnt < ISP_TIME_OUT_MAX)) {
+			udelay(1);
+			reg_value=ISP_READL(ISP_INT_RAW);
+			time_out_cnt++;
+		}
+		if (time_out_cnt >= ISP_TIME_OUT_MAX) {
+			ret = -1;
+			ISP_PRINT("isp_k: isp load lnc param time out\n");
+		}
+		ISP_OWR(ISP_INT_CLEAR, ISP_INT_LENS_LOAD);
+	}else {
+		ISP_PRINT("isp_k: isp load lnc param error\n");
+	}
+
+	return ret;
+}
+
+static int32_t _isp_lnc_param_set(uint32_t* addr, uint32_t len)
+{
+	int32_t ret = 0;
+
+	if((0x00!=s_isp_alloc_addr)
+		&&(0x00!=addr)) {
+		memcpy((void*)s_isp_alloc_addr, (void*)addr, len);
+	}
+
+	return ret;
+}
+
+static int32_t _isp_free(void)
+{
+	int32_t ret = 0;
+
+	if((0x00!=s_isp_alloc_addr)
+		&&(0x00!=s_isp_alloc_order)) {
+		free_pages(s_isp_alloc_addr, s_isp_alloc_order);
+		s_isp_alloc_order = 0x00;
+		s_isp_alloc_addr = 0x00;
+		s_isp_alloc_len=0x00;
+	}
+
+	return ret;
+}
+
+static int32_t _isp_alloc(unsigned long* addr, uint32_t len)
+{
+	int32_t ret = 0x00;
+	unsigned long buf=0x00;
+	void *ptr = 0x00;
+
+	if((0x00!=s_isp_alloc_addr)
+		&&(len<=s_isp_alloc_len)) {
+		*addr = s_isp_alloc_addr;
+	} else {
+		_isp_free();
+	}
+
+	if(0x00==s_isp_alloc_addr) {
+		s_isp_alloc_len=len;
+		s_isp_alloc_order = get_order(len);
+		s_isp_alloc_addr = __get_free_pages(GFP_KERNEL | __GFP_COMP, s_isp_alloc_order);
+		if (NULL == (void*)s_isp_alloc_addr) {
+			ISP_PRINT("ISP_RAW:_isp_alloc order:0x%x, addr:0x%lx, len:0x%x error\n", s_isp_alloc_order, s_isp_alloc_addr, s_isp_alloc_len);
+			return 1;
+		}
+		ptr = (void*)s_isp_alloc_addr;
+		*addr = s_isp_alloc_addr;
+		buf = virt_to_phys((volatile void *)s_isp_alloc_addr);
+
+		#ifndef CONFIG_64BIT
+		dmac_flush_range(ptr, ptr + len);
+		outer_flush_range(__pa(ptr), __pa(ptr) + len);
+		#endif
+	}
+
+	return ret;
+}
+
+static int32_t _isp_set_clk(enum isp_clk_sel clk_sel)
+{
+	struct clk              *clk_parent;
+	char                    *parent = "clk_256m";
+	int32_t       rtn = 0;
+
+	ISP_CHECK_ZERO(g_isp_dev_ptr);
+
+#ifdef CONFIG_SC_FPGA
+	return 0;
+#endif
+
+	switch (clk_sel) {
+	case ISP_CLK_312M:
+		parent = "clk_312m";
+		break;
+	case ISP_CLK_256M:
+		parent = "clk_256m";
+		break;
+	case ISP_CLK_128M:
+		parent = "clk_128m";
+		break;
+	case ISP_CLK_48M:
+		parent = "clk_48m";
+		break;
+	case ISP_CLK_76M8:
+		parent = "clk_76p8m";
+		break;
+
+	case ISP_CLK_NONE:
+		ISP_PRINT("isp_k: ISP close CLK %d \n", (int)clk_get_rate(g_isp_dev_ptr->s_isp_clk));
+		if (g_isp_dev_ptr->s_isp_clk) {
+			clk_disable(g_isp_dev_ptr->s_isp_clk);
+			clk_put(g_isp_dev_ptr->s_isp_clk);
+			g_isp_dev_ptr->s_isp_clk = NULL;
+		}
+		return 0;
+	default:
+		parent = "clk_128m";
+		break;
+	}
+
+	if (NULL == g_isp_dev_ptr->s_isp_clk) {
+		g_isp_dev_ptr->s_isp_clk = parse_clk(isp_dev.this_device->of_node, "clk_isp");
+		if (IS_ERR(g_isp_dev_ptr->s_isp_clk)) {
+			ISP_PRINT("isp_k: parse_clk fail, %p \n", (int)g_isp_dev_ptr->s_isp_clk);
+			return -1;
+		} else {
+			ISP_PRINT("isp_k: get clk_parent ok \n");
+		}
+	} else {
+		clk_disable(g_isp_dev_ptr->s_isp_clk);
+	}
+
+	clk_parent = clk_get(NULL, parent);
+	if (IS_ERR(clk_parent)) {
+		ISP_PRINT("isp_k: dcam_set_clk fail, %p \n", clk_parent);
+		return -1;
+	} else {
+		ISP_PRINT("isp_k: get clk_parent ok \n");
+	}
+
+	rtn = clk_set_parent(g_isp_dev_ptr->s_isp_clk, clk_parent);
+	if(rtn){
+		ISP_PRINT("isp_k: clk_set_parent fail, %d \n", rtn);
+	}
+
+	rtn = clk_enable(g_isp_dev_ptr->s_isp_clk);
+	if (rtn) {
+		ISP_PRINT("isp_k: enable isp clk error.\n");
+		return -1;
+	}
+
+	return rtn;
+}
+
+static int _isp_queue_init(struct isp_queue *queue)
+{
+	if (NULL == queue)
+		return -EINVAL;
+
+	memset(queue, 0x00, sizeof(*queue));
+	queue->write = &queue->node[0];
+	queue->read  = &queue->node[0];
+
+	return 0;
+}
+
+static int _isp_queue_write(struct isp_queue *queue, struct isp_node *node)
+{
+	struct isp_node 	*ori_node;
+
+	if (NULL == queue || NULL == node)
+	return -EINVAL;
+
+	ori_node = queue->write;
+
+	//ISP_PRINT("_isp_queue_write called!\n");
+	*queue->write++ = *node;
+	if (queue->write > &queue->node[ISP_QUEUE_LENGTH-1]) {
+		queue->write = &queue->node[0];
+	}
+
+	if (queue->write == queue->read) {
+	queue->write = ori_node;
+	}
+
+	//ISP_PRINT("_isp_queue_write finished!\n");
+	return 0;
+}
+
+static int _isp_queue_read(struct isp_queue *queue, struct isp_node *node)
+{
+	int ret = 0;
+
+	if (NULL == queue || NULL == node)
+		return -EINVAL;
+	//ISP_PRINT("_isp_queue_read called!\n");
+	if (queue->read != queue->write) {
+		*node = *queue->read++;
+		if (queue->read > &queue->node[ISP_QUEUE_LENGTH-1]) {
+			queue->read = &queue->node[0];
+		}
+	}
+	//ISP_PRINT("_isp_queue_read finished!\n");
+	return ret;
+}
+
+static inline void _isp_regread(char *dst,  char *src, size_t n)
+{
+	char tmp  = 0;
+	uint32_t tmp2 = 0;
+	char *char_src = 0,*d = 0;
+	uint32_t *d2 = (uint32_t*) dst;
+	uint32_t *int_src =  (uint32_t*) src;
+	uint32_t counts = (n>>2)<<2;
+	uint32_t res_counts = n -counts;
+	counts = counts>>2;
+
+	while (counts--) {
+		tmp2 = ISP_READL(int_src);
+		*d2++ = tmp2;
+		int_src++;
+	}
+
+	if(res_counts) {
+		d = (char*) d2;
+		char_src = (char*) int_src;
+		while(res_counts--) {
+			tmp = __raw_readb(char_src);
+			*d = tmp;
+			char_src++;
+		}
+	}
+}
+
+static inline void _isp_regwrite(char *dst,  char *src, size_t n)
+{
+	uint32_t tmp2 = 0;
+	char *char_src = 0, *d = 0;
+	uint32_t *int_src = 0, *d2 = 0;
+	uint32_t counts = 0, res_counts = 0;
+
+	int_src = (uint32_t*) src;
+	d2 = (uint32_t*) dst;
+	counts = (n>>2)<<2;
+	res_counts = n - counts;
+	counts = counts>>2;
+
+	while (counts--) {
+		tmp2 = *int_src++;
+		ISP_WRITEL(d2, tmp2);
+		d2++;
+	}
+
+	if(res_counts) {
+		d = (char*) d2;
+		char_src = (char*) int_src;
+
+		while(res_counts--) {
+			tmp2 = *char_src++;
+			 __raw_writeb(tmp2, d);
+			d++;
+		}
+	}
+
+}
+static int32_t _isp_get_ctlr(void *param)
+{
+	struct isp_device_t *dev_ptr = (struct isp_device_t *) param;
+
+	down(&dev_ptr->sem_isp);
+
+	return 0;
+}
+static int32_t _isp_put_ctlr(void *param)
+{
+	struct isp_device_t *dev_ptr = (struct isp_device_t *) param;
+
+	up(&dev_ptr->sem_isp);
+
+	return 0;
+}
+
+static int _isp_en_irq(unsigned long int_num)
+{
+	uint32_t ret = 0;
+
+	ISP_WRITEL(ISP_INT_CLEAR, ISP_IRQ_HW_MASK);
+	ISP_WRITEL(ISP_INT_EN, int_num);
+
+	return ret;
+}
+
+static int _isp_registerirq(void)
+{
+	uint32_t ret = 0;
+
+	ret = request_irq(ISP_IRQ, _isp_irq_root, IRQF_SHARED, "ISP", &g_isp_irq);
+
+	return ret;
+}
+static void _isp_unregisterirq(void)
+{
+	free_irq (ISP_IRQ, &g_isp_irq);
+}
+
+static int _isp_cfg_dcam_int(uint32_t param)
+{
+	uint32_t ret = 0;
+
+	s_dcam_int_eb = param;
+
+	return ret;
+}
+
+static void _read_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
+{
+	uint32_t i = 0;
+	unsigned long reg_val = 0;
+	unsigned long reg_addr = 0;
+
+	for (i = 0; i<counts; ++i) {
+		//reg_addr = reg_bits_ptr[i].reg_addr;
+		reg_addr = ISP_BASE_ADDR + reg_bits_ptr[i].reg_addr;
+		reg_val = ISP_READL(reg_addr);
+		reg_bits_ptr[i].reg_value = reg_val;
+	}
+
+}
+
+static void _write_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
+{
+	uint32_t i = 0;
+	unsigned long reg_val = 0;
+	unsigned long reg_addr = 0;
+
+	for (i = 0; i<counts; ++i) {
+		reg_addr = reg_bits_ptr[i].reg_addr+ISP_BASE_ADDR;
+		reg_val = reg_bits_ptr[i].reg_value;
+		ISP_WRITEL(reg_addr, reg_val);
+	}
+}
+
+/**********************************************************
+*open the device
+*
+***********************************************************/
+static int32_t _isp_kernel_open (struct inode *node, struct file *pf)
+{
+	int32_t ret = 0;
+	ISP_PRINT ("isp_k: open start \n");
+
+	ISP_CHECK_ZERO(g_isp_dev_ptr);
+
+	ret =  _isp_get_ctlr(g_isp_dev_ptr);
+	if (unlikely(ret)) {
+		ISP_PRINT ("isp_k: get control error \n");
+		ret = -EFAULT;
+		return ret;
+	}
+
+	g_isp_dev_ptr->reg_base_addr = (unsigned long)ISP_BASE_ADDR;
+	g_isp_dev_ptr->size = ISP_REG_MAX_SIZE;
+
+	ret = _isp_queue_init(&(g_isp_dev_ptr->queue));
+	if (unlikely(0 != ret)) {
+		ISP_PRINT("isp_k: queue init error\n");
+		ret = -EIO;
+		goto ISP_K_OPEN_ERROR_EXIT;
+	}
+
+	ret = _isp_module_eb();
+	if (unlikely(0 != ret)) {
+		ISP_PRINT("isp_k: enable isp module error\n");
+		ret = -EIO;
+		goto ISP_K_OPEN_ERROR_EXIT;
+	}
+
+	ret = _isp_module_rst();
+	if (unlikely(0 != ret)) {
+		ISP_PRINT("isp_k: reset isp module error \n");
+		ret = -EIO;
+		_isp_module_dis();
+		goto ISP_K_OPEN_ERROR_EXIT;
+	}
+
+	dcam_reg_isr(DCAM_CAP_EOF, _isp_cap_eof, g_isp_dev_ptr);
+	ret = _isp_kernel_thread(g_isp_dev_ptr);
+	if (unlikely(0 != ret)) {
+		ISP_PRINT("isp_k: create isp_kernel_thread fail \n");
+		ret = -EIO;
+		_isp_module_dis();
+		goto ISP_K_OPEN_ERROR_EXIT;
+	}
+
+	ret = _isp_registerirq();
+	if (unlikely(0 != ret)) {
+		ISP_PRINT("isp_k: reg irq fail \n");
+		ret = -EIO;
+		_isp_stop_kernel_thread(g_isp_dev_ptr);
+		_isp_module_dis();
+		goto ISP_K_OPEN_ERROR_EXIT;
+	}
+
+	ISP_PRINT ("isp_k: open end \n");
+	return ret;
+
+ISP_K_OPEN_ERROR_EXIT:
+	ret =  _isp_put_ctlr(g_isp_dev_ptr);
+	if (unlikely(ret)) {
+		ISP_PRINT ("isp_k: get control error \n");
+		ret = -EFAULT;
+	}
+	ISP_PRINT ("isp_k: open error \n");
+	return -EIO;
+}
+
+static irqreturn_t _isp_irq_root(int irq, void *dev_id)
+{
+	int32_t	    ret = 0;
+	uint32_t	status = 0;
+	uint32_t	irq_line = 0;
+	uint32_t	irq_status = 0;
+	unsigned long flag = 0;
+	int32_t     i = 0;
+	struct isp_node    node = { 0 };
+	struct timeval system_time;
+
+	status = ISP_REG_RD(ISP_INT_STATUS);
+	irq_line = status&ISP_IRQ_HW_MASK;
+	//ISP_PRINT("ISP_RAW:isp_k: isp irq: 0x%x\n", irq_line);
+	if ( 0 == irq_line ) {
+		return IRQ_NONE;
+	}
+
+	spin_lock_irqsave(&isp_spin_lock,flag);
+	if ((ISP_INT_LENS_LOAD & irq_line) == ISP_INT_LENS_LOAD) {
+		irq_line &= ~ISP_INT_LENS_LOAD;
+		ISP_OWR(ISP_INT_CLEAR, ISP_INT_LENS_LOAD);
+		up(&g_isp_dev_ptr->lnc_load.load_done_sem);
+		if (!irq_line) {
+			spin_unlock_irqrestore(&isp_spin_lock, flag);
+			return IRQ_HANDLED;
+		}
+	}
+	for (i = ISP_IRQ_NUM- 1; i >= 0; i--) {
+		if (irq_line & (1 << (uint32_t)i)) {
+		irq_status |= 1 << (uint32_t)i;
+		}
+		irq_line &= ~(uint32_t)(1 << (uint32_t)i); //clear the interrupt flag
+		if(!irq_line) //no interrupt source left
+		break;
+	}
+
+	ISP_WRITEL(ISP_INT_CLEAR, irq_status);
+	node.isp_irq_val = irq_status;
+	_isp_get_systemtime(&system_time);
+	system_time.tv_sec = system_time.tv_sec * 1000000;
+	node.system_time = (uint64_t)(system_time.tv_sec+system_time.tv_usec);
+	ret = _isp_queue_write((struct isp_queue *)&g_isp_dev_ptr->queue, (struct isp_node*)&node);
+	spin_unlock_irqrestore(&isp_spin_lock, flag);
+	up(&g_isp_dev_ptr->sem_isr);
+
+	return IRQ_HANDLED;
+}
+//static irqreturn_t _dcam_irq_root(int irq, void *dev_id)
+void _dcam_isp_root(void)
+{
+	int32_t	ret = 0;
+	unsigned long flag = 0;
+	struct isp_node node = { 0 };
+	struct timeval system_time;
+
+	//ISP_PRINT ("ISP_RAW: isp_k: _dcam_isp_root %d \n", s_dcam_int_eb);
+
+	if(0x00 !=s_dcam_int_eb)
+	{
+		spin_lock_irqsave(&isp_spin_lock,flag);
+		#if defined(CONFIG_MACH_CORE3)
+		node.dcam_irq_val = ISP_INT_FETCH_EOF;
+		#else
+		node.dcam_irq_val = ISP_INT_FETCH_SOF;
+		#endif
+
+		//ISP_PRINT("isp_k: dcam sof irq :0x%x\n", node.dcam_irq_val);
+		_isp_get_systemtime(&system_time);
+		system_time.tv_sec = system_time.tv_sec * 1000000;
+		node.system_time = (uint64_t)(system_time.tv_sec+system_time.tv_usec);
+		ret = _isp_queue_write((struct isp_queue *)&g_isp_dev_ptr->queue, (struct isp_node*)&node);
+		spin_unlock_irqrestore(&isp_spin_lock, flag);
+		up(&g_isp_dev_ptr->sem_isr);
+	}
+
+	//return IRQ_HANDLED;
+}
+
+/**********************************************************
+*release the device
+*
+***********************************************************/
+static int32_t _isp_kernel_release (struct inode *node, struct file *pf)
+{
+	int ret = 0;
+	ISP_PRINT ("isp_k: release start \n");
+
+	mutex_lock(&s_isp_lock);
+
+	_isp_unregisterirq();
+	ret = _isp_module_dis();
+
+	mutex_unlock(&s_isp_lock);
+
+	_isp_stop_kernel_thread(g_isp_dev_ptr);
+	ISP_CHECK_ZERO(g_isp_dev_ptr);
+	ret = _isp_put_ctlr(g_isp_dev_ptr);
+	if (unlikely (ret) ) {
+		ISP_PRINT ("isp_k: release control error \n");
+		return -EFAULT;
+	}
+	ISP_PRINT ("isp_k: release end \n");
+	return ret;
+}
+/**********************************************************
+*read info from  file
+*size_t size:
+*loff_t p:
+***********************************************************/
+#if 0
+static int32_t _isp_kernel_proc_read (char *page, char **start, off_t off, int count, int *eof, void *data)
+{
+	int	 len = 0;
+	uint32_t	 reg_buf_len = 200;
+	uint32_t	 print_len = 0, print_cnt = 0;
+	uint32_t	*reg_ptr = 0;
+
+	ISP_PRINT ("isp_k: _isp_kernel_proc_read 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x \n", (uint32_t)page, (uint32_t)start, (uint32_t)off, (uint32_t)count, (uint32_t)eof, (uint32_t)data);
+
+	(void)start; (void)off; (void)count; (void)eof;
+
+	if(0x00==g_isp_device.reg_base_addr)
+	{
+		return 0x00;
+	}
+
+	reg_ptr = (uint32_t*)g_isp_device.reg_base_addr;
+	len += sprintf(page + len, "Context for ISP device \n");
+	len += sprintf(page + len, "********************************************* \n");
+	while (print_len < reg_buf_len) {
+	len += sprintf(page + len, "offset 0x%x : 0x%x, 0x%x, 0x%x, 0x%x \n",
+		print_len,
+		reg_ptr[print_cnt],
+		reg_ptr[print_cnt+1],
+		reg_ptr[print_cnt+2],
+		reg_ptr[print_cnt+3]);
+	print_cnt += 4;
+	print_len += 16;
+	}
+	len += sprintf(page + len, "********************************************* \n");
+	len += sprintf(page + len, "The end of ISP device \n");
+	return len;
+}
+#endif
+/**********************************************************
+*the io controller of isp
+*unsigned int cmd:
+*unsigned long param:
+***********************************************************/
+static long _isp_kernel_ioctl( struct file *fl, unsigned int cmd, unsigned long param)
+{
+	long ret = 0;
+	uint32_t isp_irq, dcam_irq;
+	struct isp_irq_param irq_param = { 0 };
+	struct isp_node isp_node = { 0 };
+	struct isp_reg_param reg_param = { 0 };
+	struct isp_reg_bits *reg_bits_ptr = 0;
+
+	//ISP_PRINT("isp_k:_ioctl called, cmd: %x\n", cmd);
+
+	if (!fl) {
+		return -EINVAL;
+	}
+
+	ISP_CHECK_ZERO(g_isp_dev_ptr);
+
+	if(ISP_IO_IRQ==cmd)
+	{
+		ret = down_interruptible(&g_isp_dev_ptr->sem_isr);
+		if (ret) {
+			ISP_PRINT("isp_k: ioctl irq: down failed ret = %ld",ret);
+			memset(&irq_param, 0, sizeof(irq_param));
+			irq_param.ret_val = ret;
+			ret = copy_to_user ((void*) param, (void*)&irq_param, sizeof(irq_param));
+			if ( 0 != ret) {
+				ISP_PRINT("isp_k: ioctl irq: copy_to_user failed ret = %ld", ret);
+			}
+			ret = -ERESTARTSYS;
+			goto ISP_IOCTL_EXIT;
+		}
+		ret=_isp_queue_read(&g_isp_dev_ptr->queue, &isp_node);
+		if ( 0 != ret) {
+
+			ISP_PRINT("isp_k: ioctl irq: _isp_queue_read error, ret = 0x%x", (uint32_t)ret);
+			ret = -EFAULT;
+			goto ISP_IOCTL_EXIT;
+		}
+
+		irq_param.dcam_irq_val = isp_node.dcam_irq_val;
+		irq_param.isp_irq_val = isp_node.isp_irq_val;
+		isp_irq = isp_node.isp_irq_val;
+		dcam_irq = isp_node.dcam_irq_val;
+		irq_param.irq_val = dcam_irq|isp_irq;
+		irq_param.system_time = isp_node.system_time;
+		ret = copy_to_user ((void*) param, (void*)&irq_param, sizeof(struct isp_irq_param));
+		if ( 0 != ret) {
+
+			ISP_PRINT("isp_k: ioctl irq: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+			ret = -EFAULT;
+		}
+
+	} else {
+
+		mutex_lock(&s_isp_lock);
+
+		switch (cmd)
+		{
+			case ISP_IO_READ: {
+			uint32_t buf_size = 0;
+			//ISP_PRINT("  isp_k:_ioctl read called \n");
+			ret = copy_from_user((void*)&reg_param, (void*)param, sizeof(struct isp_reg_param));
+			if ( 0 != ret) {
+
+				ISP_PRINT("isp_k: ioctl read: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+				ret = -EFAULT;
+				goto IO_READ_EXIT;
+			}
+			buf_size = reg_param.counts*sizeof(struct isp_reg_bits);
+			if (buf_size > g_isp_dev_ptr->buf_len) {
+				ret  =-EFAULT;
+				goto IO_READ_EXIT;
+			}
+			reg_bits_ptr = (struct isp_reg_bits*) g_isp_dev_ptr->buf_addr;
+			ret = copy_from_user((void*)reg_bits_ptr, (void*)reg_param.reg_param, buf_size);
+			if ( 0 != ret) {
+
+				ISP_PRINT("isp_k: ioctl read: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+				ret  =-EFAULT;
+				goto IO_READ_EXIT;
+			}
+			_read_reg(reg_bits_ptr, reg_param.counts);
+
+			ret = copy_to_user((void*)reg_param.reg_param, (void*)reg_bits_ptr, buf_size);
+			if ( 0 != ret) {
+
+				ISP_PRINT("isp_k: ioctl read: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+				ret = -EFAULT;
+				goto IO_READ_EXIT;
+			}
+			IO_READ_EXIT:
+			if(reg_bits_ptr) {
+				memset((void *)g_isp_dev_ptr->buf_addr, 0x00, buf_size);
+				reg_bits_ptr = NULL;
+			}
+			}
+			break;
+
+			case ISP_IO_WRITE: {
+			uint32_t buf_size = 0;
+			//ISP_PRINT(" isp_k:_ioctl write called \n");
+			ret = copy_from_user((void*)&reg_param, (void*)param, sizeof(struct isp_reg_param));
+			if ( 0 != ret) {
+
+				ISP_PRINT("isp_k: ioctl write: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+				ret = -EFAULT;
+				goto IO_WRITE_EXIT;
+			}
+			buf_size = reg_param.counts*sizeof(struct isp_reg_bits);
+			if(buf_size > g_isp_dev_ptr->buf_len)
+			{
+				ret = -EFAULT;
+				goto IO_WRITE_EXIT;
+			}
+			reg_bits_ptr = (struct isp_reg_bits*) g_isp_dev_ptr->buf_addr;
+
+			ret = copy_from_user((void*)reg_bits_ptr, (void*)reg_param.reg_param, buf_size);
+			if ( 0 != ret) {
+
+				ISP_PRINT("isp_k: ioctl write: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+				ret = -EFAULT;
+				goto IO_WRITE_EXIT;
+			}
+			_write_reg(reg_bits_ptr, reg_param.counts);
+
+			IO_WRITE_EXIT:
+			if(reg_bits_ptr) {
+				memset((void *)g_isp_dev_ptr->buf_addr, 0x00, buf_size);
+				reg_bits_ptr = NULL;
+			}
+
+			}
+			break;
+
+			case ISP_IO_RST: {
+			ISP_PRINT(" isp_k:ioctl restet start \n");
+			g_isp_dev_ptr->lnc_load.cap_eof_flag = 0;
+			ret = _isp_module_rst();
+			if (ret) {
+
+				ISP_PRINT("isp_k: ioctl restet error!\n");
+				ret = -EFAULT;
+			}
+			}
+			break;
+
+			case ISP_IO_SETCLK: {
+			ISP_PRINT(" isp_k:ioctl set clock start \n");
+			}
+			break;
+
+			case ISP_IO_STOP: {
+			unsigned long flag = 0;
+			struct isp_node node = { 0 };
+			ret = _isp_en_irq(0);//dis-enable the interrupt
+			ISP_PRINT("isp_k: ioctl  stop start !\n");
+			spin_lock_irqsave(&isp_spin_lock,flag);
+			node.dcam_irq_val = ISP_INT_STOP;
+			ret = _isp_queue_write((struct isp_queue *)&g_isp_dev_ptr->queue, (struct isp_node*)&node);
+			spin_unlock_irqrestore(&isp_spin_lock, flag);
+			up(&g_isp_dev_ptr->sem_isr);
+			}
+			break;
+
+			case ISP_IO_INT: {
+				unsigned long int_num;
+				ret = copy_from_user((void*)&int_num, (void*)param, 0x04);
+				if (ret) {
+					ISP_PRINT ("isp_k:io int copy param error, ret = %d \n", (uint32_t)ret);
+					ret = -EFAULT;
+					goto ISP_IOCTL_LOCKED_CMD_EXIT;
+				}
+				ret = _isp_en_irq(int_num);
+				//ret = _isp_registerirq();
+				if (unlikely(ret)) {
+					ISP_PRINT ("isp_k:enable  interrupt error \n");
+					ret = -EFAULT;
+				}
+			}
+			break;
+
+			case ISP_IO_DCAM_INT: {
+				unsigned long int_param;
+				ret = copy_from_user((void*)&int_param, (void*)param, 0x04);
+				if (ret) {
+					ISP_PRINT ("isp_k:dcam int copy params error, ret = %d \n", (uint32_t)ret);
+					ret = -EFAULT;
+					goto ISP_IOCTL_LOCKED_CMD_EXIT;
+				}
+				ret = _isp_cfg_dcam_int(int_param);
+				if (unlikely(ret)) {
+					ISP_PRINT ("isp_k:cfg dcam interrupt error \n");
+					ret = -EFAULT;
+				}
+			}
+			break;
+
+			case ISP_IO_LNC_PARAM: {
+				uint32_t buf_size = 0;
+				uint32_t* addr = 0;
+				ret = copy_from_user((void*)&reg_param, (void*)param, sizeof(struct isp_reg_param));
+				if ( 0 != ret) {
+
+					ISP_PRINT("isp_k: ioctl lnc param: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					goto IO_LNC_PARAM_EXIT;
+				}
+				buf_size = reg_param.counts;
+				if(buf_size > g_isp_dev_ptr->buf_len){
+
+					ret = -EFAULT;
+					goto IO_LNC_PARAM_EXIT;
+				}
+				addr = (uint32_t*) g_isp_dev_ptr->buf_addr;
+				ret = copy_from_user((void*)addr, (void*)reg_param.reg_param, buf_size);
+				if ( 0 != ret) {
+
+					ISP_PRINT("isp_k: ioctl lnc param: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					goto IO_LNC_PARAM_EXIT;
+				}
+				ret = _isp_lnc_param_set(addr, buf_size);
+				if ( 0 != ret) {
+					ISP_PRINT("isp_k: ioctl lnc param error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					goto IO_LNC_PARAM_EXIT;
+				}
+
+				IO_LNC_PARAM_EXIT:
+				if(addr) {
+					memset((void *)g_isp_dev_ptr->buf_addr, 0x00, buf_size);
+					addr = NULL;
+				}
+			}
+			break;
+
+			case ISP_IO_LNC: {
+				uint32_t buf_size = 0;
+				ret = copy_from_user((void*)&reg_param, (void*)param, sizeof(struct isp_reg_param));
+				if ( 0 != ret) {
+					ISP_PRINT("isp_k: ioctl lnc: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					goto IO_LNC_EXIT;
+				}
+				buf_size = reg_param.counts*sizeof(struct isp_reg_bits);
+				if(buf_size > g_isp_dev_ptr->buf_len)
+				{
+					ret = -EFAULT;
+					ISP_PRINT("isp_k: isp_io_lnc: buf len failed\n");
+					goto IO_LNC_EXIT;
+				}
+				reg_bits_ptr = (struct isp_reg_bits*) g_isp_dev_ptr->buf_addr;
+				ret = copy_from_user((void*)reg_bits_ptr, (void*)reg_param.reg_param, buf_size);
+				if ( 0 != ret) {
+					ISP_PRINT("isp_k: ioctl lnc: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					goto IO_LNC_EXIT;
+				}
+
+				if (g_isp_dev_ptr->lnc_load.cap_eof_flag == 0) {
+				ret = _isp_lnc_param_load(reg_bits_ptr, reg_param.counts);
+				} else {
+					memcpy((void *)g_isp_dev_ptr->lnc_load.load_buf, (void *)reg_bits_ptr, buf_size);
+					g_isp_dev_ptr->lnc_load.param_counts = reg_param.counts;
+					g_isp_dev_ptr->lnc_load.load_lnc_flag = 1;
+					ret = down_timeout(&g_isp_dev_ptr->lnc_load.load_done_sem,  msecs_to_jiffies(500));
+				}
+				if (unlikely(ret)) {
+					ISP_PRINT ("isp_k:load lnc error \n");
+					ret = -EFAULT;
+				}
+				IO_LNC_EXIT:
+				if(reg_bits_ptr) {
+					memset((void *)g_isp_dev_ptr->buf_addr, 0x00, buf_size);
+					reg_bits_ptr = NULL;
+				}
+			}
+			break;
+
+			case ISP_IO_ALLOC: {
+
+				ret = copy_from_user((void*)&reg_param, (void*)param, sizeof(struct isp_reg_param));
+				if ( 0 != ret) {
+					ISP_PRINT("isp_k: ioctl write: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					break;
+				}
+				ret = _isp_alloc(&reg_param.reg_param, reg_param.counts);
+				if ( 0 == ret) {
+					ret = copy_to_user((void*)param, (void*)&reg_param, sizeof(struct isp_reg_param));
+				} else {
+					ISP_PRINT("isp_k: ioctl alloc error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+				}
+			}
+			break;
+
+			default:
+			mutex_unlock(&s_isp_lock);
+			ISP_PRINT("isp_k:_ioctl cmd is unsupported, cmd = %x\n", (int32_t)cmd);
+			return -EFAULT;
+		}
+
+		ISP_IOCTL_LOCKED_CMD_EXIT:
+		mutex_unlock(&s_isp_lock);
+	}
+
+	//ISP_PRINT("isp_k:_ioctl finished\n");
+	ISP_IOCTL_EXIT:
+	return ret;
+}
+
+static int _isp_probe(struct platform_device *pdev)
+{
+	int ret = 0;
+	ISP_PRINT ("isp_k:probe start\n");
+
+	ret = misc_register(&isp_dev);
+	if (ret) {
+		ISP_PRINT ( "isp_k:probe cannot register miscdev on minor=%d (%d)\n",(int32_t)ISP_MINOR, (int32_t)ret);
+		return ret;
+	}
+	mutex_init(&s_isp_lock);
+/*
+	isp_proc_file = create_proc_read_entry("driver/sprd_isp" ,
+					0444,
+					NULL,
+					_isp_kernel_proc_read,
+					NULL);
+	if (unlikely(NULL == isp_proc_file)) {
+		ISP_PRINT("isp_k:probe Can't create an entry for isp in /proc \n");
+		ret = ENOMEM;
+		return ret;
+	}
+*/
+	isp_dev.this_device->of_node = pdev->dev.of_node;
+	parse_baseaddress(pdev->dev.of_node);
+	ISP_PRINT (" isp_k:probe end\n");
+	return 0;
+}
+
+static int _isp_remove(struct platform_device * dev)
+{
+	ISP_PRINT ("isp_k: remove start \n");
+
+	misc_deregister(&isp_dev);
+
+	if (isp_proc_file) {
+		remove_proc_entry("driver/sprd_isp", NULL);
+	}
+
+	ISP_PRINT ("isp_k: remove end !\n");
+
+	return 0;
+}
+
+static int32_t __init isp_kernel_init(void)
+{
+	int32_t ret = 0;
+	unsigned long addr = 0;
+	ISP_PRINT ("isp_k: init start \n");
+	if (platform_driver_register(&isp_driver) != 0) {
+		ISP_PRINT ("isp_kernel_init: platform device register error \n");
+		return -1;
+	}
+
+	g_isp_dev_ptr = (struct isp_device_t*)vzalloc(sizeof(struct isp_device_t));
+	ISP_CHECK_ZERO(g_isp_dev_ptr);
+	init_MUTEX(&g_isp_dev_ptr->sem_isp);
+	init_MUTEX_LOCKED(&g_isp_dev_ptr->sem_isr); /*for interrupt */
+	g_isp_dev_ptr->s_isp_clk = NULL;
+	g_isp_dev_ptr->s_isp_clk_mm_i = NULL;
+	g_isp_dev_ptr->buf_addr = 0;
+	g_isp_dev_ptr->buf_len = 0;
+
+	g_isp_dev_ptr->buf_addr = (unsigned long)vzalloc(ISP_BUF_MAX_SIZE);
+	if (0 == g_isp_dev_ptr->buf_addr) {
+		ret = -1;
+		ISP_PRINT ("isp_kernel_init 1: alloc  error \n");
+		goto ISP_K_INIT_EXIT;
+	}
+	g_isp_dev_ptr->buf_len = ISP_BUF_MAX_SIZE;
+
+	g_isp_dev_ptr->lnc_load.load_buf = (unsigned long)vzalloc(ISP_BUF_MAX_SIZE);
+	if (0 == g_isp_dev_ptr->lnc_load.load_buf) {
+		ret = -1;
+		ISP_PRINT ("isp_kernel_init 3: alloc  error \n");
+		goto ISP_K_INIT_EXIT;
+	}
+	ret = _isp_alloc(&addr, ISP_BUF_MAX_SIZE);
+	if (ret) {
+		ret = -1;
+		ISP_PRINT ("isp_kernel_init 2: alloc  error \n");
+		goto ISP_K_INIT_EXIT;
+	}
+
+	ISP_PRINT ("isp_k: init end\n");
+
+	return ret;
+
+ISP_K_INIT_EXIT:
+	_isp_free();
+	if (g_isp_dev_ptr->buf_addr) {
+		vfree((void *)g_isp_dev_ptr->buf_addr);
+		g_isp_dev_ptr->buf_addr = 0;
+		g_isp_dev_ptr->buf_len = 0;
+	}
+	if (g_isp_dev_ptr->lnc_load.load_buf) {
+		vfree((void *)g_isp_dev_ptr->lnc_load.load_buf);
+		g_isp_dev_ptr->lnc_load.load_buf = 0;
+	}
+	if (g_isp_dev_ptr) {
+		vfree(g_isp_dev_ptr);
+		g_isp_dev_ptr = 0;
+	}
+
+	return ret;
+}
+
+static void isp_kernel_exit(void)
+{
+	ISP_PRINT ("isp_k: exit start \n");
+
+	platform_driver_unregister(&isp_driver);
+	mutex_destroy(&s_isp_lock);
+	_isp_free();
+	ISP_CHECK_ZERO_VOID(g_isp_dev_ptr);
+	if (g_isp_dev_ptr->buf_addr) {
+		vfree((void *)g_isp_dev_ptr->buf_addr);
+		g_isp_dev_ptr->buf_addr = 0;
+		g_isp_dev_ptr->buf_len = 0;
+	}
+	if(g_isp_dev_ptr->lnc_load.load_buf) {
+		vfree((void *)g_isp_dev_ptr->lnc_load.load_buf);
+		g_isp_dev_ptr->lnc_load.load_buf = 0;
+	}
+	vfree(g_isp_dev_ptr);
+	g_isp_dev_ptr = NULL;
+
+	ISP_PRINT ("isp_k: exit end \n");
+}
+
+module_init(isp_kernel_init);
+module_exit(isp_kernel_exit);
+
+MODULE_DESCRIPTION("Isp Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/sprd_isp/isp1.0/isp_drv_null.c b/drivers/media/sprd_isp/isp1.0/isp_drv_null.c
new file mode 100644
index 00000000..4e8b84e0
--- /dev/null
+++ b/drivers/media/sprd_isp/isp1.0/isp_drv_null.c
@@ -0,0 +1,305 @@
+/*
+ * 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/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/poll.h>
+#include <linux/fs.h>
+#include <linux/irq.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/miscdevice.h>
+#include <asm/io.h>
+#include <linux/file.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/spinlock_types.h>
+#include <linux/semaphore.h>
+#include <linux/delay.h>
+#include <linux/proc_fs.h>
+#include <video/isp_drv_kernel.h>
+
+#include <linux/clk.h>
+#include <asm/cacheflush.h>
+
+#include <linux/of.h>
+#include <linux/of_device.h>
+
+#include "Shark_reg_isp.h"
+
+
+#define DEBUG_ISP_DRV
+#ifdef DEBUG_ISP_DRV
+#define ISP_PRINT   printk
+#else
+#define ISP_PRINT(...)
+#endif
+#define ISP_MINOR		MISC_DYNAMIC_MINOR/*isp minor number*/
+static struct proc_dir_entry*  isp_proc_file;
+
+/**file operation functions declare**/
+static int32_t _isp_kernel_open(struct inode *node, struct file *filp);
+static int32_t _isp_kernel_release(struct inode *node, struct file *filp);
+static long _isp_kernel_ioctl( struct file *fl, unsigned int cmd, unsigned long param);
+/**driver'  functions declare**/
+static int32_t _isp_probe(struct platform_device *pdev);
+static int32_t _isp_remove(struct platform_device *dev);
+/**module'  functions declare**/
+static int32_t __init isp_kernel_init(void);
+static void isp_kernel_exit(void);
+
+static struct file_operations isp_fops = {
+	.owner	= THIS_MODULE,
+	.open	= _isp_kernel_open,
+	.unlocked_ioctl	= _isp_kernel_ioctl,
+	.release	= _isp_kernel_release,
+};
+
+static struct miscdevice isp_dev = {
+	.minor	= ISP_MINOR,
+	.name	= "sprd_isp",
+	.fops	= &isp_fops,
+};
+
+static const struct of_device_id of_match_table_isp[] = {
+	{ .compatible = "sprd,sprd_isp", },
+	{ },
+};
+
+static struct platform_driver isp_driver = {
+	.probe	= _isp_probe,
+	.remove	= _isp_remove,
+	.driver	= {
+		.owner = THIS_MODULE,
+		.name = "sprd_isp",
+		.of_match_table = of_match_ptr(of_match_table_isp),
+	},
+};
+
+/**********************************************************
+*open the device
+*
+***********************************************************/
+static int32_t _isp_kernel_open (struct inode *node, struct file *pf)
+{
+	int32_t ret = 0;
+	ISP_PRINT ("isp_k: open start \n");
+
+	return ret;
+}
+
+//static irqreturn_t _dcam_irq_root(int irq, void *dev_id)
+void _dcam_isp_root(void)
+{
+	int32_t	ret = 0;
+
+	return IRQ_HANDLED;
+}
+
+/**********************************************************
+*release the device
+*
+***********************************************************/
+static int32_t _isp_kernel_release (struct inode *node, struct file *pf)
+{
+	int ret = 0;
+	ISP_PRINT ("isp_k: release start \n");
+
+	ISP_PRINT ("isp_k: release end \n");
+	return ret;
+}
+/**********************************************************
+*read info from  file
+*size_t size:
+*loff_t p:
+***********************************************************/
+static int32_t _isp_kernel_proc_read (char *page, char **start, off_t off, int count, int *eof, void *data)
+{
+	int	 len = 0;
+#if 0
+	uint32_t	 reg_buf_len = 200;
+	uint32_t	 print_len = 0, print_cnt = 0;
+	uint32_t	*reg_ptr = 0;
+
+	ISP_PRINT ("isp_k: _isp_kernel_proc_read 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x \n", (uint32_t)page, (uint32_t)start, (uint32_t)off, (uint32_t)count, (uint32_t)eof, (uint32_t)data);
+
+	(void)start; (void)off; (void)count; (void)eof;
+
+	if(0x00==g_isp_device.reg_base_addr)
+	{
+		return 0x00;
+	}
+
+	reg_ptr = (uint32_t*)g_isp_device.reg_base_addr;
+	len += sprintf(page + len, "Context for ISP device \n");
+	len += sprintf(page + len, "********************************************* \n");
+	while (print_len < reg_buf_len) {
+	len += sprintf(page + len, "offset 0x%x : 0x%x, 0x%x, 0x%x, 0x%x \n",
+		print_len,
+		reg_ptr[print_cnt],
+		reg_ptr[print_cnt+1],
+		reg_ptr[print_cnt+2],
+		reg_ptr[print_cnt+3]);
+	print_cnt += 4;
+	print_len += 16;
+	}
+	len += sprintf(page + len, "********************************************* \n");
+	len += sprintf(page + len, "The end of ISP device \n");
+#endif
+	return len;
+}
+
+/**********************************************************
+*the io controller of isp
+*unsigned int cmd:
+*unsigned long param:
+***********************************************************/
+static long _isp_kernel_ioctl( struct file *fl, unsigned int cmd, unsigned long param)
+{
+	long ret = 0;
+
+	if(ISP_IO_IRQ==cmd)
+	{
+	} else {
+
+		switch (cmd)
+		{
+			case ISP_IO_READ: {
+			}
+			break;
+
+			case ISP_IO_WRITE: {
+			}
+			break;
+
+			case ISP_IO_RST: {
+			ISP_PRINT(" isp_k:ioctl restet start \n");
+			}
+			break;
+
+			case ISP_IO_SETCLK:
+			ISP_PRINT(" isp_k:ioctl set clock start \n");
+			break;
+
+			case ISP_IO_STOP: {
+			}
+			break;
+
+			case ISP_IO_INT: {
+			}
+			break;
+
+			case ISP_IO_DCAM_INT: {
+			}
+			break;
+
+			case ISP_IO_LNC_PARAM: {
+			}
+			break;
+
+			case ISP_IO_LNC: {
+			}
+			break;
+
+			case ISP_IO_ALLOC: {
+			}
+			break;
+
+			default:
+			ISP_PRINT("isp_k:_ioctl cmd is unsupported, cmd = %x\n", (int32_t)cmd);
+			return -EFAULT;
+		}
+
+	}
+
+	//ISP_PRINT("isp_k:_ioctl finished\n");
+	ISP_IOCTL_EXIT:
+	return ret;
+}
+
+static int _isp_probe(struct platform_device *pdev)
+{
+	int ret = 0;
+	ISP_PRINT ("isp_k:probe start\n");
+
+	ret = misc_register(&isp_dev);
+	if (ret) {
+		ISP_PRINT ( "isp_k:probe cannot register miscdev on minor=%d (%d)\n",(int32_t)ISP_MINOR, (int32_t)ret);
+		return ret;
+	}
+/*
+	isp_proc_file = create_proc_read_entry("driver/sprd_isp" ,
+					0444,
+					NULL,
+					_isp_kernel_proc_read,
+					NULL);
+	if (unlikely(NULL == isp_proc_file)) {
+		ISP_PRINT("isp_k:probe Can't create an entry for isp in /proc \n");
+		ret = ENOMEM;
+		return ret;
+	}
+*/
+	isp_dev.this_device->of_node = pdev->dev.of_node;
+	ISP_PRINT (" isp_k:probe end\n");
+	return 0;
+}
+
+static int _isp_remove(struct platform_device * dev)
+{
+	ISP_PRINT ("isp_k: remove start \n");
+
+	misc_deregister(&isp_dev);
+
+	if (isp_proc_file) {
+		remove_proc_entry("driver/sprd_isp", NULL);
+	}
+
+	ISP_PRINT ("isp_k: remove end !\n");
+
+	return 0;
+}
+
+static int32_t __init isp_kernel_init(void)
+{
+	int32_t ret = 0;
+	uint32_t addr = 0;
+	ISP_PRINT ("isp_k: init start \n");
+	if (platform_driver_register(&isp_driver) != 0) {
+		ISP_PRINT ("isp_kernel_init: platform device register error \n");
+		return -1;
+	}
+
+	ISP_PRINT ("isp_k: init end\n");
+
+	return ret;
+}
+
+static void isp_kernel_exit(void)
+{
+	ISP_PRINT ("isp_k: exit start \n");
+
+	platform_driver_unregister(&isp_driver);
+
+	ISP_PRINT ("isp_k: exit end \n");
+}
+
+module_init(isp_kernel_init);
+module_exit(isp_kernel_exit);
+
+MODULE_DESCRIPTION("Isp Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/sprd_isp/isp2.0/pike/inc/isp_block.h b/drivers/media/sprd_isp/isp2.0/pike/inc/isp_block.h
new file mode 100644
index 00000000..63103ea0
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/inc/isp_block.h
@@ -0,0 +1,72 @@
+/*
+ * 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 "isp_drv.h"
+
+int32_t isp_k_cfg_pgg(struct isp_io_param *param);
+int32_t isp_k_cfg_blc(struct isp_io_param *param);
+int32_t isp_k_cfg_rgb_gain(struct isp_io_param *param);
+int32_t isp_k_cfg_pwd(struct isp_io_param *param);
+int32_t isp_k_cfg_nlc(struct isp_io_param *param);
+int32_t isp_k_cfg_2d_lsc(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_1d_lsc(struct isp_io_param *param);
+int32_t isp_k_cfg_binning(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_awb(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_raw_aem(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_bpc(struct isp_io_param *param);
+int32_t isp_k_cfg_bdn(struct isp_io_param *param);
+int32_t isp_k_cfg_grgb(struct isp_io_param *param);
+int32_t isp_k_cfg_rgb_gain2(struct isp_io_param *param);
+int32_t isp_k_cfg_nlm(struct isp_io_param *param);
+int32_t isp_k_cfg_cfa(struct isp_io_param *param);
+int32_t isp_k_cfg_cmc10(struct isp_io_param *param);
+int32_t isp_k_cfg_hdr(struct isp_io_param *param);
+int32_t isp_k_cfg_gamma(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_cmc8(struct isp_io_param *param);
+int32_t isp_k_cfg_ct(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_hsv(struct isp_io_param *param);
+int32_t isp_k_cfg_rgb_afm(struct isp_io_param *param);
+int32_t isp_k_cfg_cce(struct isp_io_param *param);
+int32_t isp_k_cfg_pre_cdn_rgb(struct isp_io_param *param);
+int32_t isp_k_cfg_yuv_precdn(struct isp_io_param *param);
+int32_t isp_k_cfg_posterize(struct isp_io_param *param);
+int32_t isp_k_cfg_csc(struct isp_io_param *param);
+int32_t isp_k_cfg_yiq_aem(struct isp_io_param *param);
+int32_t isp_k_cfg_anti_flicker(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_yiq_afm(struct isp_io_param *param);
+int32_t isp_k_cfg_prefilter(struct isp_io_param *param);
+int32_t isp_k_cfg_brightness(struct isp_io_param *param);
+int32_t isp_k_cfg_contrast(struct isp_io_param *param);
+int32_t isp_k_cfg_hist(struct isp_io_param *param);
+int32_t isp_k_cfg_hist2(struct isp_io_param *param);
+int32_t isp_k_cfg_aca(struct isp_io_param *param);
+int32_t isp_k_cfg_yuv_cdn(struct isp_io_param *param);
+int32_t isp_k_cfg_edge(struct isp_io_param *param);
+int32_t isp_k_cfg_css(struct isp_io_param *param);
+int32_t isp_k_cfg_csa(struct isp_io_param *param);
+int32_t isp_k_cfg_post_cdn(struct isp_io_param *param);
+int32_t isp_k_cfg_hue(struct isp_io_param *param);
+int32_t isp_k_cfg_emboss(struct isp_io_param *param);
+int32_t isp_k_cfg_ydelay(struct isp_io_param *param);
+int32_t isp_k_cfg_ygamma(struct isp_io_param *param, struct isp_k_private *isp_private);;
+int32_t isp_k_cfg_iircnr(struct isp_io_param *param);
+int32_t isp_k_cfg_fetch(struct isp_io_param *param);
+int32_t isp_k_cfg_store(struct isp_io_param *param);
+int32_t isp_k_cfg_dispatch(struct isp_io_param *param);
+int32_t isp_k_cfg_arbiter(struct isp_io_param *param);
+int32_t isp_k_cfg_common(struct isp_io_param *param);
+int32_t isp_k_cfg_raw_sizer(struct isp_io_param *param);
+//pike add
+int32_t isp_k_cfg_yuv_nlm(struct isp_io_param *param);
+int32_t isp_k_cfg_uv_prefilter(struct isp_io_param *param);
+int32_t isp_k_cfg_rgb2y(struct isp_io_param *param);
\ No newline at end of file
diff --git a/drivers/media/sprd_isp/isp2.0/pike/inc/isp_drv.h b/drivers/media/sprd_isp/isp2.0/pike/inc/isp_drv.h
new file mode 100644
index 00000000..d27f4e40
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/inc/isp_drv.h
@@ -0,0 +1,94 @@
+/*
+ * 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.
+ */
+
+#ifndef _ISP_DRV_HEADER_
+#define _ISP_DRV_HEADER_
+
+#include <linux/semaphore.h>
+#include <linux/spinlock_types.h>
+
+#define ISP_QUEUE_LENGTH 16
+#define ISP_BING4AWB_NUM 2
+
+struct isp_node {
+	uint32_t irq_val0;
+	uint32_t irq_val1;
+	uint32_t irq_val2;
+	uint32_t irq_val3;
+	uint32_t reserved;
+	struct isp_time time;
+};
+
+struct isp_queue {
+	struct isp_node node[ISP_QUEUE_LENGTH];
+	struct isp_node *write;
+	struct isp_node *read;
+};
+
+struct isp_b4awb_buf {
+	uint32_t buf_id;
+	uint32_t buf_flag;
+	unsigned long buf_phys_addr;
+};
+
+struct isp_k_private {
+	atomic_t users;
+	struct device_node *dn;
+	struct clk *clock;
+	struct semaphore device_lock;
+	struct semaphore ioctl_lock;
+	unsigned long block_buf_addr;
+	uint32_t block_buf_len;
+	unsigned long reg_buf_addr;
+	uint32_t reg_buf_len;
+	uint32_t lsc_load_buf_id;
+	uint32_t lsc_update_buf_id;
+	unsigned long raw_aem_buf_addr;
+	uint32_t raw_aem_buf_len;
+	uint32_t ct_load_buf_id;
+	unsigned long full_gamma_buf_addr;
+	uint32_t full_gamma_buf_len;
+	uint32_t full_gamma_buf_id;
+	unsigned long yuv_ygamma_buf_addr;
+	uint32_t yuv_ygamma_buf_len;
+	uint32_t yuv_ygamma_buf_id;
+	unsigned long raw_awbm_buf_addr;
+	uint32_t raw_awbm_buf_len;
+	struct isp_b4awb_buf b4awb_buf[ISP_BING4AWB_NUM];
+	uint32_t lsc_buf_phys_addr;
+	unsigned long yiq_antiflicker_buf_addr;
+	uint32_t yiq_antiflicker_len;
+	uint32_t yiq_antiflicker_order;
+	unsigned long yiq_aem_buf_addr;
+	uint32_t yiq_aem_buf_len;
+};
+
+struct isp_drv_private {
+	spinlock_t isr_lock;
+	struct semaphore isr_done_lock;
+	struct isp_queue queue;
+};
+
+struct isp_k_file {
+	struct isp_k_private *isp_private;
+	struct isp_drv_private drv_private;
+};
+
+int32_t isp_get_int_num(struct isp_node *node);
+void isp_clr_int(void);
+void isp_en_irq(uint32_t irq_mode);
+int32_t isp_axi_bus_waiting(void);
+int32_t isp_capability(void *param);
+int32_t isp_cfg_param(void  *param, struct isp_k_private *isp_private);
+
+#endif
diff --git a/drivers/media/sprd_isp/isp2.0/pike/inc/isp_reg.h b/drivers/media/sprd_isp/isp2.0/pike/inc/isp_reg.h
new file mode 100644
index 00000000..48e9b4fe
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/inc/isp_reg.h
@@ -0,0 +1,801 @@
+/*
+ * 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 <mach/hardware.h>
+#ifndef CONFIG_64BIT
+#include <soc/sprd/hardware.h>
+#endif
+#include "parse_hwinfo_tshark2.h"
+
+#define ISP_BASE_ADDR                      ISP_BASE//SPRD_ISP_BASE
+
+/*isp sub block: Interrupt*/
+#define ISP_INT_STATUS                     (ISP_BASE_ADDR+0x0000UL)
+#define ISP_INT_EN0                        (ISP_BASE_ADDR+0x0014UL)
+#define ISP_INT_CLR0                       (ISP_BASE_ADDR+0x0018UL)
+#define ISP_INT_RAW0                       (ISP_BASE_ADDR+0x001CUL)
+#define ISP_INT_INT0                       (ISP_BASE_ADDR+0x0020UL)
+#define ISP_INT_EN1                        (ISP_BASE_ADDR+0x0024UL)
+#define ISP_INT_CLR1                       (ISP_BASE_ADDR+0x0028UL)
+#define ISP_INT_RAW1                       (ISP_BASE_ADDR+0x002CUL)
+#define ISP_INT_INT1                       (ISP_BASE_ADDR+0x0030UL)
+#define ISP_INT_EN2                        (ISP_BASE_ADDR+0x0034UL)
+#define ISP_INT_CLR2                       (ISP_BASE_ADDR+0x0038UL)
+#define ISP_INT_RAW2                       (ISP_BASE_ADDR+0x003CUL)
+#define ISP_INT_INT2                       (ISP_BASE_ADDR+0x0040UL)
+#define ISP_INT_EN3                        (ISP_BASE_ADDR+0x0044UL)
+#define ISP_INT_CLR3                       (ISP_BASE_ADDR+0x0048UL)
+#define ISP_INT_RAW3                       (ISP_BASE_ADDR+0x004CUL)
+#define ISP_INT_INT3                       (ISP_BASE_ADDR+0x0050UL)
+#define ISP_INT_ALL_DONE_CTRL              (ISP_BASE_ADDR+0x0054UL)
+
+/*isp sub block: Fetch*/
+#define ISP_FETCH_MEM_STATUS0              (ISP_BASE_ADDR+0x0100UL)
+#define ISP_FETCH_MEM_STATUS1              (ISP_BASE_ADDR+0x0104UL)
+#define ISP_FETCH_DCAM_STATUS0             (ISP_BASE_ADDR+0x0108UL)
+#define ISP_FETCH_DCAM_STATUS1             (ISP_BASE_ADDR+0x010CUL)
+#define ISP_FETCH_PARAM                    (ISP_BASE_ADDR+0x0114UL)
+#define ISP_FETCH_START                    (ISP_BASE_ADDR+0x0118UL)
+#define ISP_FETCH_SLICE_SIZE               (ISP_BASE_ADDR+0x0120UL)
+#define ISP_FETCH_SLICE_Y_ADDR             (ISP_BASE_ADDR+0x0124UL)
+#define ISP_FETCH_SLICE_Y_PITCH            (ISP_BASE_ADDR+0x0128UL)
+#define ISP_FETCH_SLICE_U_ADDR             (ISP_BASE_ADDR+0x012CUL)
+#define ISP_FETCH_SLICE_U_PITCH            (ISP_BASE_ADDR+0x0130UL)
+#define ISP_FETCH_SLICE_V_ADDR             (ISP_BASE_ADDR+0x0134UL)
+#define ISP_FETCH_SLICE_V_PITCH            (ISP_BASE_ADDR+0x0138UL)
+#define ISP_FETCH_MIPI_WORD_INFO           (ISP_BASE_ADDR+0x013CUL)
+#define ISP_FETCH_MIPI_BYTE_INFO           (ISP_BASE_ADDR+0x0140UL)
+#define ISP_FETCH_BAYER_MODE               (ISP_BASE_ADDR+0x0144UL)
+
+/*isp sub block: Store*/
+#define ISP_STORE_STATUS_MEM0              (ISP_BASE_ADDR+0x0200UL)
+#define ISP_STORE_STATUS_MEM1              (ISP_BASE_ADDR+0x0204UL)
+#define ISP_STORE_STATUS_DCAM0             (ISP_BASE_ADDR+0x0208UL)
+#define ISP_STORE_STATUS_DCAM1             (ISP_BASE_ADDR+0x020CUL)
+#define ISP_STORE_PARAM                    (ISP_BASE_ADDR+0x0214UL)
+#define ISP_STORE_SLICE_SIZE               (ISP_BASE_ADDR+0x0218UL)
+#define ISP_STORE_BORDER                   (ISP_BASE_ADDR+0x021CUL)
+#define ISP_STORE_Y_ADDR                   (ISP_BASE_ADDR+0x0220UL)
+#define ISP_STORE_Y_PITCH                  (ISP_BASE_ADDR+0x0224UL)
+#define ISP_STORE_U_ADDR                   (ISP_BASE_ADDR+0x0228UL)
+#define ISP_STORE_U_PITCH                  (ISP_BASE_ADDR+0x022CUL)
+#define ISP_STORE_V_ADDR                   (ISP_BASE_ADDR+0x0230UL)
+#define ISP_STORE_V_PITCH                  (ISP_BASE_ADDR+0x0234UL)
+#define ISP_STORE_SHADOW_CLR               (ISP_BASE_ADDR+0x0238UL)
+
+/*isp sub block: dispatch(pike different from tshark2)*/
+#define ISP_DISPATCH_STATUS_CH0            (ISP_BASE_ADDR+0x0300UL)
+#define ISP_DISPATCH_STATUS_CH1            (ISP_BASE_ADDR+0x0304UL)
+//#define ISP_DISPATCH_STATUS_COMM            (ISP_BASE_ADDR+0x0308UL)
+//#define ISP_DISPATCH_STATUS1_CH0             (ISP_BASE_ADDR+0x030CUL)
+//#define ISP_DISPATCH_STATUS1_CH1             (ISP_BASE_ADDR+0x0310UL)
+#define ISP_DISPATCH_CH0_BAYER             (ISP_BASE_ADDR+0x0314UL)
+#define ISP_DISPATCH_CH0_SIZE              (ISP_BASE_ADDR+0x0318UL)
+#define ISP_DISPATCH_CH1_SIZE              (ISP_BASE_ADDR+0x031CUL)
+//#define ISP_DISPATCH_DLY                                (ISP_BASE_ADDR+0x0320UL)
+//#define ISP_DISPATCH_CH1_BAYER                    (ISP_BASE_ADDR+0x0324UL)
+//#define ISP_DISPATCH_HW_CTRL_CH0               (ISP_BASE_ADDR+0x0328UL)
+//#define ISP_DISPATCH_HW_CTRL_CH1               (ISP_BASE_ADDR+0x032CUL)
+
+/*isp sub block: arbiter*/
+#define ISP_ARBITER_WR_STATUS              (ISP_BASE_ADDR+0x0400UL)
+#define ISP_ARBITER_RD_STATUS              (ISP_BASE_ADDR+0x0404UL)
+#define ISP_ARBITER_PARAM                  (ISP_BASE_ADDR+0x0414UL)
+#define ISP_ARBITER_ENDIAN_CH0             (ISP_BASE_ADDR+0x0418UL)
+#define ISP_ARBITER_ENDIAN_CH1             (ISP_BASE_ADDR+0x041CUL)
+//#define ISP_ARBITER_CTRL                                 (ISP_BASE_ADDR+0x0420UL)//pike has no this register
+
+/*isp sub block: axi*/
+#define ISP_AXI_WR_MASTER_STATUS           (ISP_BASE_ADDR+0x0500UL)
+#define ISP_AXI_RD_MASTER_STATUS           (ISP_BASE_ADDR+0x0504UL)
+#define ISP_AXI_ITI2AXIM_CTRL              (ISP_BASE_ADDR+0x0514UL)
+//#define ISP_AXI_CONVERT_WR_CTRL            (ISP_BASE_ADDR+0x0518UL)//pike has no this register
+
+/*isp sub block:  raw sizer(pike has no this module)*/
+/*#define ISP_RAW_SIZER_STATUS0              (ISP_BASE_ADDR+0x0600UL)
+#define ISP_RAW_SIZER_PARAM                (ISP_BASE_ADDR+0x0614UL)
+#define ISP_RAW_SIZER_CROP_SRC             (ISP_BASE_ADDR+0x0618UL)
+#define ISP_RAW_SIZER_CROP_DST             (ISP_BASE_ADDR+0x061CUL)
+#define ISP_RAW_SIZER_CROP_START           (ISP_BASE_ADDR+0x0620UL)
+#define ISP_RAW_SIZER_DST                  (ISP_BASE_ADDR+0x0624UL)
+#define ISP_RAW_SIZER_BPC                  (ISP_BASE_ADDR+0x0628UL)
+#define ISP_RAW_SIZER_HCOEFF0              (ISP_BASE_ADDR+0x062CUL)
+#define ISP_RAW_SIZER_VCOEFF0              (ISP_BASE_ADDR+0x0684UL)
+#define ISP_RAW_SIZER_INIT_HOR0            (ISP_BASE_ADDR+0x06B0UL)
+#define ISP_RAW_SIZER_INIT_HOR1            (ISP_BASE_ADDR+0x06B4UL)
+#define ISP_RAW_SIZER_INIT_HOR2            (ISP_BASE_ADDR+0x06B8UL)
+#define ISP_RAW_SIZER_INIT_VER0            (ISP_BASE_ADDR+0x06BCUL)
+#define ISP_RAW_SIZER_INIT_VER1            (ISP_BASE_ADDR+0x06C0UL)
+#define ISP_RAW_SIZER_INIT_VER2            (ISP_BASE_ADDR+0x06C4UL)*/
+
+/*isp sub block: common*/
+#define ISP_COMMON_VERSION                 (ISP_BASE_ADDR+0x0700UL)
+#define ISP_COMMON_STATUS0                 (ISP_BASE_ADDR+0x0704UL)
+#define ISP_COMMON_STATUS1                 (ISP_BASE_ADDR+0x0708UL)
+#define ISP_COMMON_CTRL_CH0                (ISP_BASE_ADDR+0x0714UL)
+#define ISP_COMMON_SPACE_SEL               (ISP_BASE_ADDR+0x0718UL)
+//#define ISP_COMMON_CTRL_CH1                (ISP_BASE_ADDR+0x071CUL)
+//#define ISP_COMMON_CTRL_AWBM               (ISP_BASE_ADDR+0x0720UL)
+#define ISP_COMMON_PMU_RAW_MASK            (ISP_BASE_ADDR+0x0724UL)
+#define ISP_COMMON_PMU_HW_MASK             (ISP_BASE_ADDR+0x0728UL)
+#define ISP_COMMON_PMU_HW_ENABLE           (ISP_BASE_ADDR+0x072CUL)
+#define ISP_COMMON_PMU_SW_SWITCH           (ISP_BASE_ADDR+0x0730UL)
+#define ISP_COMMON_PMU_SW_TOGGLE           (ISP_BASE_ADDR+0x0734UL)
+#define ISP_COMMON_LBUF_OFFSET            (ISP_BASE_ADDR+0x0738UL)
+#define ISP_SHADOW_CTRL_CH0                (ISP_BASE_ADDR+0x073CUL)
+#define ISP_SHADOW_CTRL_CH1                (ISP_BASE_ADDR+0x0740UL)
+//#define ISP_COMMON_3A_CTRL0                (ISP_BASE_ADDR+0x0744UL)
+//#define ISP_COMMON_LBUF_OFFSET1            (ISP_BASE_ADDR+0x0748UL)
+//#define ISP_COMMON_3A_CTRL1                (ISP_BASE_ADDR+0x074CUL)
+#define ISP_COMMON_RESERVED0               (ISP_BASE_ADDR+0x0750UL)
+#define ISP_COMMON_RESERVED1               (ISP_BASE_ADDR+0x0754UL)
+
+/*isp sub block: Pre Global Gain*/
+#define ISP_PGG_STATUS                     (ISP_BASE_ADDR+0x1000UL)
+#define ISP_PGG_PARAM                      (ISP_BASE_ADDR+0x1014UL)
+
+/*isp sub block: BLC: back level calibration*/
+#define ISP_BLC_STATUS                     (ISP_BASE_ADDR+0x1100UL)
+#define ISP_BLC_PARAM                      (ISP_BASE_ADDR+0x1114UL)
+#define ISP_BLC_B_PARAM_R_B                (ISP_BASE_ADDR+0x1118UL)
+#define ISP_BLC_B_PARAM_G                  (ISP_BASE_ADDR+0x111CUL)
+
+/*isp sub block: RGBG*/
+#define ISP_RGBG_STATUS                    (ISP_BASE_ADDR+0x1200UL)
+#define ISP_RGBG_PARAM                     (ISP_BASE_ADDR+0x1214UL)
+#define ISP_RGBG_RB                        (ISP_BASE_ADDR+0x1218UL)
+#define ISP_RGBG_G                         (ISP_BASE_ADDR+0x121CUL)
+
+/*isp sub block: PWD*/
+#define ISP_PWD_STATUS0                    (ISP_BASE_ADDR+0x1300UL)
+#define ISP_PWD_STATUS1                    (ISP_BASE_ADDR+0x1304UL)
+#define ISP_PWD_PARAM                      (ISP_BASE_ADDR+0x1314UL)
+#define ISP_PWD_PARAM1                     (ISP_BASE_ADDR+0x1318UL)
+#define ISP_PWD_PARAM2                     (ISP_BASE_ADDR+0x131CUL)
+#define ISP_PWD_PARAM3                     (ISP_BASE_ADDR+0x1320UL)
+#define ISP_PWD_PARAM4                     (ISP_BASE_ADDR+0x1324UL)
+#define ISP_PWD_PARAM5                     (ISP_BASE_ADDR+0x1328UL)
+#define ISP_PWD_PARAM6                     (ISP_BASE_ADDR+0x132CUL)
+#define ISP_PWD_PARAM7                     (ISP_BASE_ADDR+0x1330UL)
+#define ISP_PWD_PARAM8                     (ISP_BASE_ADDR+0x1334UL)
+#define ISP_PWD_PARAM9                     (ISP_BASE_ADDR+0x1338UL)
+#define ISP_PWD_PARAM10                    (ISP_BASE_ADDR+0x133CUL)
+
+/*isp sub block: NLC*/
+#define ISP_NLC_STATUS                     (ISP_BASE_ADDR+0x1400UL)
+#define ISP_NLC_PARA                       (ISP_BASE_ADDR+0x1414UL)
+#define ISP_NLC_PARA_R0                    (ISP_BASE_ADDR+0x1418UL)
+#define ISP_NLC_PARA_R9                    (ISP_BASE_ADDR+0x143CUL)
+#define ISP_NLC_PARA_G0                    (ISP_BASE_ADDR+0x1440UL)
+#define ISP_NLC_PARA_G9                    (ISP_BASE_ADDR+0x1464UL)
+#define ISP_NLC_PARA_B0                    (ISP_BASE_ADDR+0x1468UL)
+#define ISP_NLC_PARA_B9                    (ISP_BASE_ADDR+0x148CUL)
+#define ISP_NLC_PARA_L0                    (ISP_BASE_ADDR+0x1490UL)
+
+/*isp sub block: lens shading calibration*/
+#define ISP_LENS_STATUS                    (ISP_BASE_ADDR+0x1500UL)
+#define ISP_LENS_PARAM                     (ISP_BASE_ADDR+0x1514UL)
+#define ISP_LENS_PARAM_ADDR                (ISP_BASE_ADDR+0x1518UL)
+#define ISP_LENS_SLICE_POS                 (ISP_BASE_ADDR+0x151CUL)
+#define ISP_LENS_LOAD_EB                   (ISP_BASE_ADDR+0x1520UL)
+#define ISP_LENS_GRID_PITCH                (ISP_BASE_ADDR+0x1524UL)
+#define ISP_LENS_GRID_SIZE                 (ISP_BASE_ADDR+0x1528UL)
+#define ISP_LENS_LOAD_BUF                  (ISP_BASE_ADDR+0x152CUL)
+#define ISP_LENS_MISC                      (ISP_BASE_ADDR+0x1530UL)
+#define ISP_LENS_SLICE_SIZE                (ISP_BASE_ADDR+0x1534UL)
+#define ISP_LENS_INIT_COOR                 (ISP_BASE_ADDR+0x1538UL)
+#define ISP_LENS_Q0_VALUE                  (ISP_BASE_ADDR+0x153CUL)
+
+/*isp sub block: binning*/
+#define ISP_BINNING_STATUS                 (ISP_BASE_ADDR+0x1600UL)
+#define ISP_BINNING_PARAM                  (ISP_BASE_ADDR+0x1614UL)
+#define ISP_BINNING_MEM_ADDR               (ISP_BASE_ADDR+0x1618UL)
+#define ISP_BINNING_PITCH                  (ISP_BASE_ADDR+0x161CUL)
+
+/*isp sub block: AWBM*/
+#define ISP_AWBM_STATUS                    (ISP_BASE_ADDR+0x1700UL)
+#define ISP_AWBM_PARAM                     (ISP_BASE_ADDR+0x1714UL)
+#define ISP_AWBM_BLOCK_OFFSET              (ISP_BASE_ADDR+0x1718UL)
+#define ISP_AWBM_BLOCK_SIZE                (ISP_BASE_ADDR+0x171CUL)
+#define ISP_AWBM_WR_0_S                    (ISP_BASE_ADDR+0x1720UL)
+#define ISP_AWBM_WR_0_E                    (ISP_BASE_ADDR+0x1724UL)
+#define ISP_AWBM_NW_0_XYR                  (ISP_BASE_ADDR+0x1748UL)
+#define ISP_AWBM_CLCTOR_0_S                (ISP_BASE_ADDR+0x175CUL)
+#define ISP_AWBM_CLCTOR_0_E                (ISP_BASE_ADDR+0x1760UL)
+#define ISP_AWBM_CLCTR_0_PIXEL_NUM         (ISP_BASE_ADDR+0x1784UL)
+#define ISP_AWBM_MEM_ADDR                  (ISP_BASE_ADDR+0x1798UL)
+#define ISP_AWBM_POSITION_SEL              (ISP_BASE_ADDR+0x179CUL)
+#define ISP_AWBM_THR_VALUE1                (ISP_BASE_ADDR+0x17A0UL)
+#define ISP_AWBM_THR_VALUE2                (ISP_BASE_ADDR+0x17A4UL)
+
+/*isp sub block: AWBC*/
+#define ISP_AWBC_STATUS                    (ISP_BASE_ADDR+0x1800UL)
+#define ISP_AWBC_PARAM                     (ISP_BASE_ADDR+0x1814UL)
+#define ISP_AWBC_GAIN0                     (ISP_BASE_ADDR+0x1818UL)
+#define ISP_AWBC_GAIN1                     (ISP_BASE_ADDR+0x181CUL)
+#define ISP_AWBC_THRD                      (ISP_BASE_ADDR+0x1820UL)
+#define ISP_AWBC_OFFSET0                   (ISP_BASE_ADDR+0x1824UL)
+#define ISP_AWBC_OFFSET1                   (ISP_BASE_ADDR+0x1828UL)
+#define ISP_AWBC_GAIN0_BUF                 (ISP_BASE_ADDR+0x182CUL)
+#define ISP_AWBC_GAIN1_BUF                 (ISP_BASE_ADDR+0x1830UL)
+#define ISP_AWBC_OFFSET0_BUF               (ISP_BASE_ADDR+0x1834UL)
+#define ISP_AWBC_OFFSET1_BUF               (ISP_BASE_ADDR+0x1838UL)
+#define ISP_AWBC_GAIN0_READ                (ISP_BASE_ADDR+0x183CUL)
+#define ISP_AWBC_GAIN1_READ                (ISP_BASE_ADDR+0x1840UL)
+#define ISP_AWBC_OFFSET0_READ              (ISP_BASE_ADDR+0x1844UL)
+#define ISP_AWBC_OFFSET1_READ              (ISP_BASE_ADDR+0x1848UL)
+
+/*isp sub block: AEM*/
+#define ISP_AEM_STATUS                     (ISP_BASE_ADDR+0x1900UL)
+#define ISP_AEM_PARAM                      (ISP_BASE_ADDR+0x1914UL)
+#define ISP_AEM_OFFSET                     (ISP_BASE_ADDR+0x1918UL)
+#define ISP_AEM_BLK_SIZE                   (ISP_BASE_ADDR+0x191CUL)
+#define ISP_AEM_SLICE_SIZE                 (ISP_BASE_ADDR+0x1920UL)
+
+/*isp sub block: BPC: bad pixel correction*/
+#define ISP_BPC_STATUS                     (ISP_BASE_ADDR+0x1A00UL)
+#define ISP_BPC_PARAM                      (ISP_BASE_ADDR+0x1A14UL)
+#define ISP_BPC_CFG                        (ISP_BASE_ADDR+0x1A18UL)
+#define ISP_BPC_FACTOR                     (ISP_BASE_ADDR+0x1A1CUL)
+#define ISP_BPC_COEFF                      (ISP_BASE_ADDR+0x1A20UL)
+#define ISP_BPC_LUTWORD0                   (ISP_BASE_ADDR+0x1A24UL)
+#define ISP_BPC_NEW_OLD_SEL                (ISP_BASE_ADDR+0x1A44UL)
+#define ISP_BPC_MAP_ADDR                   (ISP_BASE_ADDR+0x1A48UL)
+
+/*isp sub block: GRGB*/
+#define ISP_GRGB_STATUS                    (ISP_BASE_ADDR+0x1B00UL)
+#define ISP_GRGB_PARAM                     (ISP_BASE_ADDR+0x1B14UL)
+#define ISP_GRGB_GRID                      (ISP_BASE_ADDR+0x1B18UL)
+
+/*isp sub block: BDN*/
+#define ISP_BDN_STATUS                     (ISP_BASE_ADDR+0x1C00UL)
+#define ISP_BDN_PARAM                      (ISP_BASE_ADDR+0x1C14UL)
+#define ISP_BDN_DISWEI0_0                  (ISP_BASE_ADDR+0x1C18UL)
+#define ISP_BDN_DISWEI0_1                  (ISP_BASE_ADDR+0x1C1CUL)
+#define ISP_BDN_RANWEI0_0                  (ISP_BASE_ADDR+0x1C20UL)
+#define ISP_BDN_RANWEI0_7                  (ISP_BASE_ADDR+0x1C3CUL)
+#define ISP_BDN_1DLNC_CENTER               (ISP_BASE_ADDR+0x1DA8UL)
+#define ISP_BDN_1DLNC_SQUARE_X             (ISP_BASE_ADDR+0x1DACUL)
+#define ISP_BDN_1DLNC_SQUARE_Y             (ISP_BASE_ADDR+0x1DB0UL)
+#define ISP_BDN_1DLNC_P                    (ISP_BASE_ADDR+0x1DB4UL)
+#define ISP_BDN_1DLNC_SIZE                 (ISP_BASE_ADDR+0x1DB8UL)
+#define ISP_BDN_1DLNC_POS                  (ISP_BASE_ADDR+0x1DBCUL)
+#define	ISP_BDN_1DLNC_OFFSET               (ISP_BASE_ADDR+0x1DC0UL)
+
+/*isp sub block: RGBG2*/
+#define ISP_RGBG2_STATUS                   (ISP_BASE_ADDR+0x1E00UL)
+#define ISP_RGBG2_PARAM                    (ISP_BASE_ADDR+0x1E14UL)
+#define ISP_RGBG2_OFFSET                   (ISP_BASE_ADDR+0x1E18UL)
+
+/*isp sub block: 1d lnc*/
+#define ISP_1D_LNC_STATUS                  (ISP_BASE_ADDR+0x1F00UL)
+#define ISP_1D_LNC_PARAM                   (ISP_BASE_ADDR+0x1F14UL)
+#define ISP_1D_LNC_PARAM1                  (ISP_BASE_ADDR+0x1F18UL)
+#define ISP_1D_LNC_PARAM2                  (ISP_BASE_ADDR+0x1F1CUL)
+#define ISP_1D_LNC_PARAM3                  (ISP_BASE_ADDR+0x1F20UL)
+#define ISP_1D_LNC_PARAM4                  (ISP_BASE_ADDR+0x1F24UL)
+#define ISP_1D_LNC_PARAM5                  (ISP_BASE_ADDR+0x1F28UL)
+#define ISP_1D_LNC_PARAM6                  (ISP_BASE_ADDR+0x1F2CUL)
+#define ISP_1D_LNC_PARAM7                  (ISP_BASE_ADDR+0x1F30UL)
+#define ISP_1D_LNC_PARAM8                  (ISP_BASE_ADDR+0x1F34UL)
+#define ISP_1D_LNC_PARAM9                  (ISP_BASE_ADDR+0x1F38UL)
+#define ISP_1D_LNC_PARAM10                 (ISP_BASE_ADDR+0x1F3CUL)
+#define ISP_1D_LNC_PARAM11                 (ISP_BASE_ADDR+0x1F40UL)
+#define ISP_1D_LNC_PARAM12                 (ISP_BASE_ADDR+0x1F44UL)
+#define ISP_1D_LNC_PARAM13                 (ISP_BASE_ADDR+0x1F48UL)
+#define ISP_1D_LNC_PARAM14                 (ISP_BASE_ADDR+0x1F4CUL)
+#define ISP_1D_LNC_PARAM15                 (ISP_BASE_ADDR+0x1F50UL)
+#define ISP_1D_LNC_PARAM16                 (ISP_BASE_ADDR+0x1F54UL)
+#define ISP_1D_LNC_PARAM17                 (ISP_BASE_ADDR+0x1F58UL)
+#define ISP_1D_LNC_PARAM18                 (ISP_BASE_ADDR+0x1F5CUL)
+
+/*isp sub block: NLM VST IVST*/
+#define ISP_VST_PARA                       (ISP_BASE_ADDR+0x2014UL)
+#define ISP_IVST_PARA                      (ISP_BASE_ADDR+0x2214UL)
+#define ISP_NLM_LB_STATUS0                 (ISP_BASE_ADDR+0x2100UL)
+#define ISP_NLM_LB_STATUS1                 (ISP_BASE_ADDR+0x2104UL)
+#define ISP_NLM_STATUS                     (ISP_BASE_ADDR+0x2108UL)
+#define ISP_NLM_PARA                       (ISP_BASE_ADDR+0x2114UL)
+#define ISP_NLM_FLAT_PARA_0                (ISP_BASE_ADDR+0x2118UL)
+#define	ISP_NLM_STERNGTH                   (ISP_BASE_ADDR+0x212CUL)
+#define ISP_NLM_IS_FLAT                    (ISP_BASE_ADDR+0x2130UL)
+#define ISP_NLM_ADD_BACK                   (ISP_BASE_ADDR+0x2134UL)
+//#define ISP_NLM_DIRECTION_0                (ISP_BASE_ADDR+0x2138UL)
+//#define ISP_NLM_DIRECTION_1                (ISP_BASE_ADDR+0x213CUL)
+#define ISP_NLM_LUT_W_0                    (ISP_BASE_ADDR+0x2140UL)
+
+/*isp sub block: CFA: clolor filter array*/
+#define ISP_CFAE_STATUS                    (ISP_BASE_ADDR+0x3000UL)
+#define ISP_CFAE_EE_CFG0                   (ISP_BASE_ADDR+0x3014UL)
+#define ISP_CFAE_THRD_0                    (ISP_BASE_ADDR+0x3018UL)
+#define ISP_CFAE_THRD_1                    (ISP_BASE_ADDR+0x301CUL)
+#define ISP_CFAE_THRD_2                    (ISP_BASE_ADDR+0x3020UL)
+#define ISP_CFAE_THRD_3                    (ISP_BASE_ADDR+0x3024UL)
+#define ISP_CFAE_THRD_4                    (ISP_BASE_ADDR+0x3028UL)
+#define ISP_CFAE_EE_CFG1                   (ISP_BASE_ADDR+0x302CUL)
+
+/*isp sub block:CMC: Color matrix correction for 10 bit   */
+#define ISP_CMC10_STATUS0                  (ISP_BASE_ADDR+0x3100UL)
+#define ISP_CMC10_STATUS1                  (ISP_BASE_ADDR+0x3104UL)
+#define ISP_CMC10_PARAM                    (ISP_BASE_ADDR+0x3114UL)
+#define ISP_CMC10_MATRIX0                  (ISP_BASE_ADDR+0x3118UL)
+#define ISP_CMC10_MATRIX0_BUF              (ISP_BASE_ADDR+0x312CUL)
+
+/*isp sub block: FRGB WDR */
+#define ISP_HDR_STATUS                (ISP_BASE_ADDR+0x3200UL)
+#define ISP_HDR_PARAM                 (ISP_BASE_ADDR+0x3214UL)
+
+//#define ISP_HDR_STATUS              (ISP_BASE_ADDR+0x1A00UL)
+//#define ISP_HDR_PARAM               (ISP_BASE_ADDR+0x1A14UL)
+//#define ISP_HDR_INDEX               (ISP_BASE_ADDR+0x1A18UL)
+
+/*isp sub block: GAMMA */
+#define ISP_GAMMA_STATUS                   (ISP_BASE_ADDR+0x3300UL)
+#define ISP_GAMMA_PARAM                    (ISP_BASE_ADDR+0x3314UL)
+
+/*isp sub block:CMC: Color matrix correction for 8 bit  */
+#define ISP_CMC8_STATUS0                   (ISP_BASE_ADDR+0x3500UL)
+#define ISP_CMC8_STATUS1                   (ISP_BASE_ADDR+0x3504UL)
+#define ISP_CMC8_PARAM                     (ISP_BASE_ADDR+0x3514UL)
+#define ISP_CMC8_MATRIX0                   (ISP_BASE_ADDR+0x3518UL)
+#define ISP_CMC8_MATRIX0_BUF               (ISP_BASE_ADDR+0x352CUL)
+
+/*CT: Color transformation*/
+#define ISP_CT_STATUS0                     (ISP_BASE_ADDR+0x3600UL)
+#define ISP_CT_STATUS1                     (ISP_BASE_ADDR+0x3604UL)
+#define ISP_CT_PARAM                       (ISP_BASE_ADDR+0x3614UL)
+
+/*isp sub block: CCE: clolor conversion enhancement*/
+#define ISP_CCE_STATUS0                    (ISP_BASE_ADDR+0x3700UL)
+#define ISP_CCE_STATUS1                    (ISP_BASE_ADDR+0x3704UL)
+#define ISP_CCE_PARAM                      (ISP_BASE_ADDR+0x3714UL)
+#define ISP_CCE_MATRIX0                    (ISP_BASE_ADDR+0x3718UL)
+#define ISP_CCE_MATRIX1                    (ISP_BASE_ADDR+0x371CUL)
+#define ISP_CCE_MATRIX2                    (ISP_BASE_ADDR+0x3720UL)
+#define ISP_CCE_MATRIX3                    (ISP_BASE_ADDR+0x3724UL)
+#define ISP_CCE_MATRIX4                    (ISP_BASE_ADDR+0x3728UL)
+#define ISP_CCE_SHIFT                      (ISP_BASE_ADDR+0x372CUL)
+#define ISP_CCE_UVD_PARAM0                 (ISP_BASE_ADDR+0x3730UL)
+#define ISP_CCE_UVD_PARAM1                 (ISP_BASE_ADDR+0x3734UL)
+#define ISP_CCE_UVD_PARAM2                 (ISP_BASE_ADDR+0x3738UL)
+#define ISP_CCE_UVD_PARAM3                 (ISP_BASE_ADDR+0x373CUL)
+#define ISP_CCE_UVD_PARAM4                 (ISP_BASE_ADDR+0x3740UL)
+#define ISP_CCE_UVD_PARAM5                 (ISP_BASE_ADDR+0x3744UL)
+
+/*isp sub block:HSV*/
+#define ISP_HSV_STATUS                     (ISP_BASE_ADDR+0x3800UL)
+#define ISP_HSV_PARAM                      (ISP_BASE_ADDR+0x3814UL)
+
+/*isp sub block:Radial CSC*/
+#define ISP_CSC_STATUS                     (ISP_BASE_ADDR + 0x3900UL)
+#define ISP_CSC_CTRL                       (ISP_BASE_ADDR + 0x3914UL)
+#define ISP_CSC_RCC                        (ISP_BASE_ADDR + 0x3918UL)
+#define ISP_CSC_BCC                        (ISP_BASE_ADDR + 0x391CUL)
+#define ISP_CSC_REDX2INIT                  (ISP_BASE_ADDR + 0x3920UL)
+#define ISP_CSC_REDY2INIT                  (ISP_BASE_ADDR + 0x3924UL)
+#define ISP_CSC_BLUEX2INIT                 (ISP_BASE_ADDR + 0x3928UL)
+#define ISP_CSC_BLUEY2INIT                 (ISP_BASE_ADDR + 0x392CUL)
+#define ISP_CSC_REDTHR                     (ISP_BASE_ADDR + 0x3930UL)
+#define ISP_CSC_BLUETHR                    (ISP_BASE_ADDR + 0x3934UL)
+#define ISP_CSC_REDPOLY                    (ISP_BASE_ADDR + 0x3938UL)
+#define ISP_CSC_BLUEPOLY                   (ISP_BASE_ADDR + 0x393CUL)
+#define ISP_CSC_MAXGAIN                    (ISP_BASE_ADDR + 0x3940UL)
+#define ISP_CSC_PICSIZE                    (ISP_BASE_ADDR + 0x3944UL)
+#define ISP_CSC_START_ROW_COL              (ISP_BASE_ADDR + 0x3948UL)
+
+/*isp sub block:ISP_PRECNRNEW*/
+#define ISP_PRECNRNEW_STATUS0              (ISP_BASE_ADDR+0x3A00UL)
+#define ISP_PRECNRNEW_STATUS1              (ISP_BASE_ADDR+0x3A04UL)
+#define ISP_PRECNRNEW_CFG                  (ISP_BASE_ADDR+0x3A14UL)
+#define ISP_PRECNRNEW_MEDIAN_THR           (ISP_BASE_ADDR+0x3A18UL)
+#define ISP_PRECNRNEW_THRU                 (ISP_BASE_ADDR+0x3A1CUL)
+#define ISP_PRECNRNEW_THRV                 (ISP_BASE_ADDR+0x3A20UL)
+
+/*isp sub block:ISP_PSTRZ*/
+#define ISP_PSTRZ_STATUS                   (ISP_BASE_ADDR+0x3B00UL)
+#define ISP_PSTRZ_PARAM                    (ISP_BASE_ADDR+0x3B14UL)
+#define ISP_PSTRZ_LEVEL0                   (ISP_BASE_ADDR+0x3B18UL)
+#define ISP_PSTRZ_LEVEL1                   (ISP_BASE_ADDR+0x3B1CUL)
+#define ISP_PSTRZ_LEVEL2                   (ISP_BASE_ADDR+0x3B20UL)
+#define ISP_PSTRZ_LEVEL3                   (ISP_BASE_ADDR+0x3B24UL)
+#define ISP_PSTRZ_LEVEL4                   (ISP_BASE_ADDR+0x3B28UL)
+#define ISP_PSTRZ_LEVEL5                   (ISP_BASE_ADDR+0x3B2CUL)
+#define ISP_PSTRZ_LEVEL6                   (ISP_BASE_ADDR+0x3B30UL)
+#define ISP_PSTRZ_LEVEL7                   (ISP_BASE_ADDR+0x3B34UL)
+
+/*isp sub block: AFM : auto focus monitor*/
+#define ISP_RGB_AFM_STATUS0                (ISP_BASE_ADDR+0x3C00UL)
+#define ISP_RGB_AFM_STATUS1                (ISP_BASE_ADDR+0x3C04UL)
+#define ISP_RGB_AFM_PARAM                  (ISP_BASE_ADDR+0x3C14UL)
+#define ISP_RGB_AFM_FRAME_RANGE            (ISP_BASE_ADDR+0x3C18UL)
+#define ISP_RGB_AFM_SOBEL_THRESHOLD        (ISP_BASE_ADDR+0x3C1CUL)
+#define ISP_RGB_AFM_SPSMD_THRESHOLD_MAX    (ISP_BASE_ADDR+0x3C20UL)
+#define ISP_RGB_AFM_WIN_RANGE0             (ISP_BASE_ADDR+0x3C24UL)
+#define ISP_RGB_AFM_TYPE1_VAL00            (ISP_BASE_ADDR+0x3CECUL)
+#define ISP_RGB_AFM_TYPE2_VAL00            (ISP_BASE_ADDR+0x3D50UL)
+#define ISP_RGB_AFM_SPSMD_THRESHOLD_MIN    (ISP_BASE_ADDR+0x3DB4UL)
+
+/*isp sub block:RGB2Y*/
+#define ISP_Y_RGB2Y_STATUS0                (ISP_BASE_ADDR+0x4000UL)
+#define ISP_Y_RGB2Y_STATUS1                (ISP_BASE_ADDR+0x4004UL)
+#define ISP_Y_RGB2Y_PARAM                  (ISP_BASE_ADDR+0x4014UL)
+
+/*isp sub block:YIQ AEM*/
+#define ISP_YIQ_AEM_STATUS                 (ISP_BASE_ADDR + 0x4100UL)
+#define ISP_YIQ_AEM_PARAM                  (ISP_BASE_ADDR + 0x4114UL)
+#define ISP_YIQ_YGAMMA_NODE_X0             (ISP_BASE_ADDR + 0x4118UL)
+#define ISP_YIQ_YGAMMA_NODE_X1             (ISP_BASE_ADDR + 0x411CUL)
+#define ISP_YIQ_YGAMMA_NODE_Y0             (ISP_BASE_ADDR + 0x4120UL)
+#define ISP_YIQ_YGAMMA_NODE_Y1             (ISP_BASE_ADDR + 0x4124UL)
+#define ISP_YIQ_YGAMMA_NODE_Y2             (ISP_BASE_ADDR + 0x4128UL)
+#define ISP_YIQ_YGAMMA_NODE_IDX            (ISP_BASE_ADDR + 0x412CUL)
+#define ISP_YIQ_AEM_OFFSET                 (ISP_BASE_ADDR + 0x4130UL)
+#define ISP_YIQ_AEM_BLK_SIZE               (ISP_BASE_ADDR + 0x4134UL)
+#define ISP_YIQ_AEM_SLICE_SIZE             (ISP_BASE_ADDR + 0x4138UL)
+
+/*isp sub block:ANTI FLICKER*/
+#define ISP_ANTI_FLICKER_STATUS0           (ISP_BASE_ADDR + 0x4200UL)
+#define ISP_ANTI_FLICKER_STATUS1           (ISP_BASE_ADDR + 0x4204UL)
+#define ISP_ANTI_FLICKER_PARAM0            (ISP_BASE_ADDR + 0x4214UL)
+#define ISP_ANTI_FLICKER_PARAM1            (ISP_BASE_ADDR + 0x4218UL)
+#define ISP_ANTI_FLICKER_COL_POS           (ISP_BASE_ADDR + 0x421CUL)
+#define ISP_ANTI_FLICKER_DDR_INIT_ADDR     (ISP_BASE_ADDR + 0x4220UL)
+
+/*isp sub block:YIQ AFM*/
+#define ISP_YIQ_AFM_STATUS0                (ISP_BASE_ADDR + 0x4300UL)
+#define ISP_YIQ_AFM_STATUS1                (ISP_BASE_ADDR + 0x4304UL)
+#define ISP_YIQ_AFM_PARAM                  (ISP_BASE_ADDR + 0x4314UL)
+#define ISP_YIQ_AFM_WIN_RANGE0             (ISP_BASE_ADDR + 0x4318UL)
+#define ISP_YIQ_AFM_COEF0_1                (ISP_BASE_ADDR + 0x43E0UL)
+#define ISP_YIQ_AFM_COEF2_3                (ISP_BASE_ADDR + 0x43E4UL)
+#define ISP_YIQ_AFM_COEF4_5                (ISP_BASE_ADDR + 0x43E8UL)
+#define ISP_YIQ_AFM_COEF6_7                (ISP_BASE_ADDR + 0x43ECUL)
+#define ISP_YIQ_AFM_COEF8_9                (ISP_BASE_ADDR + 0x43F0UL)
+#define ISP_YIQ_AFM_COEF10                 (ISP_BASE_ADDR + 0x43F4UL)
+#define ISP_YIQ_AFM_LAPLACE0               (ISP_BASE_ADDR + 0x43F8UL)
+#define ISP_YIQ_AFM_SLICE_SIZE             (ISP_BASE_ADDR + 0x4588UL)
+
+/*isp sub block: Pre-CDN*/
+#define ISP_PRECDN_STATUS0                 (ISP_BASE_ADDR+0x5000UL)
+#define ISP_PRECDN_STATUS1                 (ISP_BASE_ADDR+0x5004UL)
+#define ISP_PRECDN_PARAM                   (ISP_BASE_ADDR+0x5014UL)
+#define ISP_PRECDN_MEDIAN_THRUV01          (ISP_BASE_ADDR+0x5018UL)
+#define ISP_PRECDN_THRYUV                  (ISP_BASE_ADDR+0x501CUL)
+#define ISP_PRECDN_SEGU_0                  (ISP_BASE_ADDR+0x5020UL)
+#define ISP_PRECDN_SEGU_3                  (ISP_BASE_ADDR+0x502CUL)
+#define ISP_PRECDN_SEGV_0                  (ISP_BASE_ADDR+0x5030UL)
+#define ISP_PRECDN_SEGV_3                  (ISP_BASE_ADDR+0x503CUL)
+#define ISP_PRECDN_SEGY_0                  (ISP_BASE_ADDR+0x5040UL)
+#define ISP_PRECDN_SEGY_3                  (ISP_BASE_ADDR+0x504CUL)
+#define ISP_PRECDN_DISTW0                  (ISP_BASE_ADDR+0x5050UL)
+#define ISP_PRECDN_DISTW3                  (ISP_BASE_ADDR+0x505CUL)
+
+/*isp sub block: Pre-Filter*/
+#define ISP_PREF_STATUS0                   (ISP_BASE_ADDR+0x5100UL)
+#define ISP_PREF_STATUS1                   (ISP_BASE_ADDR+0x5104UL)
+#define ISP_PREF_PARAM                     (ISP_BASE_ADDR+0x5114UL)
+#define ISP_PREF_THRD                      (ISP_BASE_ADDR+0x5118UL)
+
+/*isp sub block: UV Pre-Filter*/
+#define ISP_UV_PREF_STATUS0                (ISP_BASE_ADDR+0x5200UL)
+#define ISP_UV_PREF_STATUS1                (ISP_BASE_ADDR+0x5204UL)
+#define ISP_UV_PREF_PARAM                  (ISP_BASE_ADDR+0x5214UL)
+#define ISP_UV_PREF_THRD                   (ISP_BASE_ADDR+0x5218UL)
+
+/*isp sub block: Brightness*/
+#define ISP_BRIGHT_STATUS                  (ISP_BASE_ADDR+0x5300UL)
+#define ISP_BRIGHT_PARAM                   (ISP_BASE_ADDR+0x5314UL)
+
+/*isp sub block: Contrast*/
+#define ISP_CONTRAST_STATUS                (ISP_BASE_ADDR+0x5400UL)
+#define ISP_CONTRAST_PARAM                 (ISP_BASE_ADDR+0x5414UL)
+
+/*isp sub block: HIST : histogram*/
+#define ISP_HIST_STATUS                    (ISP_BASE_ADDR+0x5500UL)
+#define ISP_HIST_PARAM                     (ISP_BASE_ADDR+0x5514UL)
+#define ISP_HIST_RATIO                     (ISP_BASE_ADDR+0x5518UL)
+#define ISP_HIST_MAX_MIN                   (ISP_BASE_ADDR+0x551CUL)
+#define ISP_HIST_SLICE_SIZE                (ISP_BASE_ADDR+0x5520UL)
+#define ISP_HIST_ADJUST                    (ISP_BASE_ADDR+0x5524UL)
+
+/*isp sub block: HIST2*/
+#define ISP_HIST2_STATUS                   (ISP_BASE_ADDR+0x5600UL)
+#define ISP_HIST2_PARAM                    (ISP_BASE_ADDR+0x5614UL)
+#define ISP_HIST2_ROI_S0                   (ISP_BASE_ADDR+0x5618UL)
+#define ISP_HIST2_ROI_E0                   (ISP_BASE_ADDR+0x561CUL)
+
+/*isp sub block: AUTOCONT : auto contrast adjustment*/
+#define ISP_AUTOCONT_STATUS                (ISP_BASE_ADDR+0x5700UL)
+#define ISP_AUTOCONT_PARAM                 (ISP_BASE_ADDR+0x5714UL)
+#define ISP_AUTOCONT_MAX_MIN               (ISP_BASE_ADDR+0x5718UL)
+
+/*isp sub block: cdn*/
+#define ISP_CDN_STATUS0                    (ISP_BASE_ADDR+0x5800UL)
+#define ISP_CDN_STATUS1                    (ISP_BASE_ADDR+0x5804UL)
+#define ISP_CDN_PARAM                      (ISP_BASE_ADDR+0x5814UL)
+#define ISP_CDN_THRUV                      (ISP_BASE_ADDR+0x5818UL)
+#define ISP_CDN_U_RANWEI_0                 (ISP_BASE_ADDR+0x581CUL)
+#define ISP_CDN_U_RANWEI_7                 (ISP_BASE_ADDR+0x5838UL)
+#define ISP_CDN_V_RANWEI_0                 (ISP_BASE_ADDR+0x583CUL)
+#define ISP_CDN_V_RANWEI_7                 (ISP_BASE_ADDR+0x5858UL)
+
+/*isp sub block: edge*/
+#define ISP_EE_STATUS                      (ISP_BASE_ADDR+0x5900UL)
+#define ISP_EE_PARAM                       (ISP_BASE_ADDR+0x5914UL)
+#define ISP_EE_CFG0                        (ISP_BASE_ADDR+0x5918UL)
+#define ISP_EE_CFG1                        (ISP_BASE_ADDR+0x591CUL)
+#define ISP_EE_CFG2                        (ISP_BASE_ADDR+0x5920UL)
+#define ISP_EE_CFG3                        (ISP_BASE_ADDR+0x5924UL)
+#define ISP_EE_CFG4                        (ISP_BASE_ADDR+0x5928UL)
+#define ISP_EE_CFG5                        (ISP_BASE_ADDR+0x592CUL)
+#define ISP_EE_CFG6                        (ISP_BASE_ADDR+0x5930UL)
+#define ISP_EE_CFG7                        (ISP_BASE_ADDR+0x5934UL)
+//pike has no registers ISP_EE_ADP_CFG0 ~ ISP_EE_ADP_CFG2
+//#define ISP_EE_ADP_CFG0                    (ISP_BASE_ADDR+0x5938UL)
+//#define ISP_EE_ADP_CFG1                    (ISP_BASE_ADDR+0x593CUL)
+//#define ISP_EE_ADP_CFG2                    (ISP_BASE_ADDR+0x5940UL)
+
+/*isp sub block: emboss(pike has no this module)*/
+#define ISP_EMBOSS_Y_STATUS                (ISP_BASE_ADDR+0x5A00UL)
+#define ISP_EMBOSS_Y_PARAM                 (ISP_BASE_ADDR+0x5A14UL)
+#define ISP_EMBOSS_UV_STATUS               (ISP_BASE_ADDR+0x5F00UL)
+#define ISP_EMBOSS_UV_PARAM                (ISP_BASE_ADDR+0x5F14UL)
+
+/*isp sub block: CSS*/
+#define ISP_CSS_STATUS                     (ISP_BASE_ADDR+0x5B00UL)
+#define ISP_CSS_PARAM                      (ISP_BASE_ADDR+0x5B14UL)
+#define ISP_CSS_THRD0                      (ISP_BASE_ADDR+0x5B18UL)
+#define ISP_CSS_LH_RATIO                   (ISP_BASE_ADDR+0x5B1CUL)
+#define ISP_CSS_EX_TH_0                    (ISP_BASE_ADDR+0x5B20UL)
+#define ISP_CSS_EX_TH_1                    (ISP_BASE_ADDR+0x5B24UL)
+#define ISP_CSS_CHROM_L_TH_0               (ISP_BASE_ADDR+0x5B28UL)
+#define ISP_CSS_CHROM_L_TH_1               (ISP_BASE_ADDR+0x5B2CUL)
+#define ISP_CSS_CHROM_H_TH_0               (ISP_BASE_ADDR+0x5B30UL)
+#define ISP_CSS_CHROM_H_TH_1               (ISP_BASE_ADDR+0x5B34UL)
+#define ISP_CSS_RATIO                      (ISP_BASE_ADDR+0x5B38UL)
+
+/*isp sub block: csa*/
+#define ISP_CSA_STATUS                     (ISP_BASE_ADDR+0x5C00UL)
+#define ISP_CSA_PARAM                      (ISP_BASE_ADDR+0x5C14UL)
+
+/*isp sub block: hua*/
+#define ISP_HUA_STATUS                     (ISP_BASE_ADDR+0x5D00UL)
+#define ISP_HUA_PARAM                      (ISP_BASE_ADDR+0x5D14UL)
+
+/*isp sub block: post-cdn*/
+#define ISP_POSTCDN_STATUS                 (ISP_BASE_ADDR+0x5E00UL)
+#define ISP_POSTCDN_COMMON_CTRL            (ISP_BASE_ADDR+0x5E14UL)
+#define ISP_POSTCDN_ADPT_THR               (ISP_BASE_ADDR+0x5E18UL)
+#define ISP_POSTCDN_UVTHR                  (ISP_BASE_ADDR+0x5E1CUL)
+#define ISP_POSTCDN_THRU                   (ISP_BASE_ADDR+0x5E20UL)
+#define ISP_POSTCDN_THRV                   (ISP_BASE_ADDR+0x5E24UL)
+#define ISP_POSTCDN_RSEGU01                (ISP_BASE_ADDR+0x5E28UL)
+#define ISP_POSTCDN_RSEGU23                (ISP_BASE_ADDR+0x5E2CUL)
+#define ISP_POSTCDN_RSEGU45                (ISP_BASE_ADDR+0x5E30UL)
+#define ISP_POSTCDN_RSEGU6                 (ISP_BASE_ADDR+0x5E34UL)
+#define ISP_POSTCDN_RSEGV01                (ISP_BASE_ADDR+0x5E38UL)
+#define ISP_POSTCDN_RSEGV23                (ISP_BASE_ADDR+0x5E3CUL)
+#define ISP_POSTCDN_RSEGV45                (ISP_BASE_ADDR+0x5E40UL)
+#define ISP_POSTCDN_RSEGV6                 (ISP_BASE_ADDR+0x5E44UL)
+#define ISP_POSTCDN_R_DISTW0               (ISP_BASE_ADDR+0x5E48UL)
+//pike has no this register ISP_POSTCDN_START_ROW_MOD4
+//#define ISP_POSTCDN_START_ROW_MOD4         (ISP_BASE_ADDR+0x5E84UL)
+
+/*isp sub block: ygamma*/
+#define ISP_YGAMMA_STATUS                  (ISP_BASE_ADDR+0x6000UL)
+#define ISP_YGAMMA_PARAM                   (ISP_BASE_ADDR+0x6014UL)
+
+/*isp sub block: ydelay*/
+#define ISP_YDELAY_STATUS                  (ISP_BASE_ADDR+0x6100UL)
+#define ISP_YDELAY_PARAM                   (ISP_BASE_ADDR+0x6114UL)
+
+/*isp sub block: yuv nlm*/
+#define ISP_YNLM_STATUS0                   (ISP_BASE_ADDR+0x6200UL)
+#define ISP_YNLM_STATUS1                   (ISP_BASE_ADDR+0x6204UL)
+#define ISP_YNLM_PARAM                     (ISP_BASE_ADDR+0x6214UL)
+#define ISP_YNLM_ADAPT_PARAM1              (ISP_BASE_ADDR+0x6218UL)
+#define ISP_YNLM_ADAPT_PARAM2              (ISP_BASE_ADDR+0x621CUL)
+#define ISP_YNLM_ADAPT_PARAM3              (ISP_BASE_ADDR+0x6220UL)
+#define ISP_YNLM_ADAPT_PARAM4              (ISP_BASE_ADDR+0x6224UL)
+#define ISP_YNLM_ADAPT_PARAM5              (ISP_BASE_ADDR+0x6228UL)
+#define ISP_YNLM_ADAPT_PARAM6              (ISP_BASE_ADDR+0x622CUL)
+#define ISP_YNLM_ADAPT_PARAM7              (ISP_BASE_ADDR+0x6230UL)
+#define ISP_YNLM_ADAPT_PARAM8              (ISP_BASE_ADDR+0x6234UL)
+#define ISP_YNLM_DEN_STERNGTH              (ISP_BASE_ADDR+0x6238UL)
+#define ISP_YNLM_CENTER                    (ISP_BASE_ADDR+0x623CUL)
+#define ISP_YNLM_CENTER_X2                 (ISP_BASE_ADDR+0x6240UL)
+#define ISP_YNLM_CENTER_Y2                 (ISP_BASE_ADDR+0x6244UL)
+#define ISP_YNLM_RADIUS                    (ISP_BASE_ADDR+0x6248UL)
+#define ISP_YNLM_RADIUS_RANGE              (ISP_BASE_ADDR+0x624CUL)
+#define ISP_YNLM_GAIN_MAX                  (ISP_BASE_ADDR+0x6250UL)
+#define ISP_YNLM_IMG_PARAM0                (ISP_BASE_ADDR+0x6254UL)
+#define ISP_YNLM_IMG_PARAM1                (ISP_BASE_ADDR+0x6258UL)
+#define ISP_YNLM_ADD_BACK                  (ISP_BASE_ADDR+0x625CUL)
+#define ISP_YNLM_LUT_W_0                   (ISP_BASE_ADDR+0x6260UL)
+#define ISP_YNLM_LUT_W_1                   (ISP_BASE_ADDR+0x6264UL)
+#define ISP_YNLM_LUT_W_2                   (ISP_BASE_ADDR+0x6268UL)
+#define ISP_YNLM_LUT_W_3                   (ISP_BASE_ADDR+0x626CUL)
+#define ISP_YNLM_LUT_W_4                   (ISP_BASE_ADDR+0x6270UL)
+#define ISP_YNLM_LUT_W_5                   (ISP_BASE_ADDR+0x6274UL)
+#define ISP_YNLM_LUT_W_6                   (ISP_BASE_ADDR+0x6278UL)
+#define ISP_YNLM_LUT_W_7                   (ISP_BASE_ADDR+0x627CUL)
+#define ISP_YNLM_LUT_W_8                   (ISP_BASE_ADDR+0x6280UL)
+#define ISP_YNLM_LUT_W_9                   (ISP_BASE_ADDR+0x6284UL)
+#define ISP_YNLM_LUT_W_10                  (ISP_BASE_ADDR+0x6288UL)
+#define ISP_YNLM_LUT_W_11                  (ISP_BASE_ADDR+0x628CUL)
+#define ISP_YNLM_LUT_W_12                  (ISP_BASE_ADDR+0x6290UL)
+#define ISP_YNLM_LUT_W_13                  (ISP_BASE_ADDR+0x6294UL)
+#define ISP_YNLM_LUT_W_14                  (ISP_BASE_ADDR+0x6298UL)
+#define ISP_YNLM_LUT_W_15                  (ISP_BASE_ADDR+0x629CUL)
+#define ISP_YNLM_LUT_W_16                  (ISP_BASE_ADDR+0x62A0UL)
+#define ISP_YNLM_LUT_W_17                  (ISP_BASE_ADDR+0x62A4UL)
+#define ISP_YNLM_LUT_W_18                  (ISP_BASE_ADDR+0x62A8UL)
+#define ISP_YNLM_LUT_W_19                  (ISP_BASE_ADDR+0x62ACUL)
+#define ISP_YNLM_LUT_W_20                  (ISP_BASE_ADDR+0x62B0UL)
+#define ISP_YNLM_LUT_W_21                  (ISP_BASE_ADDR+0x62B4UL)
+#define ISP_YNLM_LUT_W_22                  (ISP_BASE_ADDR+0x62B8UL)
+#define ISP_YNLM_LUT_W_23                  (ISP_BASE_ADDR+0x62BCUL)
+#define ISP_YNLM_LUT_VS_0                  (ISP_BASE_ADDR+0x6300UL)
+#define ISP_YNLM_LUT_VS_1                  (ISP_BASE_ADDR+0x6304UL)
+#define ISP_YNLM_LUT_VS_2                  (ISP_BASE_ADDR+0x6308UL)
+#define ISP_YNLM_LUT_VS_3                  (ISP_BASE_ADDR+0x630CUL)
+#define ISP_YNLM_LUT_VS_4                  (ISP_BASE_ADDR+0x6310UL)
+#define ISP_YNLM_LUT_VS_5                  (ISP_BASE_ADDR+0x6314UL)
+#define ISP_YNLM_LUT_VS_6                  (ISP_BASE_ADDR+0x6318UL)
+#define ISP_YNLM_LUT_VS_7                  (ISP_BASE_ADDR+0x631CUL)
+#define ISP_YNLM_LUT_VS_8                  (ISP_BASE_ADDR+0x6320UL)
+#define ISP_YNLM_LUT_VS_9                  (ISP_BASE_ADDR+0x6324UL)
+#define ISP_YNLM_LUT_VS_10                 (ISP_BASE_ADDR+0x6328UL)
+#define ISP_YNLM_LUT_VS_11                 (ISP_BASE_ADDR+0x632CUL)
+#define ISP_YNLM_LUT_VS_12                 (ISP_BASE_ADDR+0x6330UL)
+#define ISP_YNLM_LUT_VS_13                 (ISP_BASE_ADDR+0x6334UL)
+#define ISP_YNLM_LUT_VS_14                 (ISP_BASE_ADDR+0x6338UL)
+#define ISP_YNLM_LUT_VS_15                 (ISP_BASE_ADDR+0x633CUL)
+#define ISP_YNLM_LUT_VS_16                 (ISP_BASE_ADDR+0x6340UL)
+#define ISP_YNLM_LUT_VS_17                 (ISP_BASE_ADDR+0x6344UL)
+#define ISP_YNLM_LUT_VS_18                 (ISP_BASE_ADDR+0x6348UL)
+#define ISP_YNLM_LUT_VS_19                 (ISP_BASE_ADDR+0x634CUL)
+#define ISP_YNLM_LUT_VS_20                 (ISP_BASE_ADDR+0x6350UL)
+#define ISP_YNLM_LUT_VS_21                 (ISP_BASE_ADDR+0x6354UL)
+#define ISP_YNLM_LUT_VS_22                 (ISP_BASE_ADDR+0x6358UL)
+#define ISP_YNLM_LUT_VS_23                 (ISP_BASE_ADDR+0x635CUL)
+#define ISP_YNLM_LUT_VS_24                 (ISP_BASE_ADDR+0x6360UL)
+#define ISP_YNLM_LUT_VS_25                 (ISP_BASE_ADDR+0x6364UL)
+#define ISP_YNLM_LUT_VS_26                 (ISP_BASE_ADDR+0x6368UL)
+#define ISP_YNLM_LUT_VS_27                 (ISP_BASE_ADDR+0x636CUL)
+#define ISP_YNLM_LUT_VS_28                 (ISP_BASE_ADDR+0x6370UL)
+#define ISP_YNLM_LUT_VS_29                 (ISP_BASE_ADDR+0x6374UL)
+#define ISP_YNLM_LUT_VS_30                 (ISP_BASE_ADDR+0x6378UL)
+#define ISP_YNLM_LUT_VS_31                 (ISP_BASE_ADDR+0x637CUL)
+#define ISP_YNLM_LUT_VS_32                 (ISP_BASE_ADDR+0x6380UL)
+#define ISP_YNLM_LUT_VS_33                 (ISP_BASE_ADDR+0x6384UL)
+#define ISP_YNLM_LUT_VS_34                 (ISP_BASE_ADDR+0x6388UL)
+#define ISP_YNLM_LUT_VS_35                 (ISP_BASE_ADDR+0x638CUL)
+#define ISP_YNLM_LUT_VS_36                 (ISP_BASE_ADDR+0x6390UL)
+#define ISP_YNLM_LUT_VS_37                 (ISP_BASE_ADDR+0x6394UL)
+#define ISP_YNLM_LUT_VS_38                 (ISP_BASE_ADDR+0x6398UL)
+#define ISP_YNLM_LUT_VS_39                 (ISP_BASE_ADDR+0x639CUL)
+#define ISP_YNLM_LUT_VS_40                 (ISP_BASE_ADDR+0x63A0UL)
+#define ISP_YNLM_LUT_VS_41                 (ISP_BASE_ADDR+0x63A4UL)
+#define ISP_YNLM_LUT_VS_42                 (ISP_BASE_ADDR+0x63A8UL)
+#define ISP_YNLM_LUT_VS_43                 (ISP_BASE_ADDR+0x63ACUL)
+#define ISP_YNLM_LUT_VS_44                 (ISP_BASE_ADDR+0x63B0UL)
+#define ISP_YNLM_LUT_VS_45                 (ISP_BASE_ADDR+0x63B4UL)
+#define ISP_YNLM_LUT_VS_46                 (ISP_BASE_ADDR+0x63B8UL)
+#define ISP_YNLM_LUT_VS_47                 (ISP_BASE_ADDR+0x63BCUL)
+#define ISP_YNLM_LUT_VS_48                 (ISP_BASE_ADDR+0x63C0UL)
+#define ISP_YNLM_LUT_VS_49                 (ISP_BASE_ADDR+0x63C4UL)
+#define ISP_YNLM_LUT_VS_50                 (ISP_BASE_ADDR+0x63C8UL)
+#define ISP_YNLM_LUT_VS_51                 (ISP_BASE_ADDR+0x63CCUL)
+#define ISP_YNLM_LUT_VS_52                 (ISP_BASE_ADDR+0x63D0UL)
+#define ISP_YNLM_LUT_VS_53                 (ISP_BASE_ADDR+0x63D4UL)
+#define ISP_YNLM_LUT_VS_54                 (ISP_BASE_ADDR+0x63D8UL)
+#define ISP_YNLM_LUT_VS_55                 (ISP_BASE_ADDR+0x63DCUL)
+#define ISP_YNLM_LUT_VS_56                 (ISP_BASE_ADDR+0x63E0UL)
+#define ISP_YNLM_LUT_VS_57                 (ISP_BASE_ADDR+0x63E4UL)
+#define ISP_YNLM_LUT_VS_58                 (ISP_BASE_ADDR+0x63E8UL)
+#define ISP_YNLM_LUT_VS_59                 (ISP_BASE_ADDR+0x63ECUL)
+#define ISP_YNLM_LUT_VS_60                 (ISP_BASE_ADDR+0x63F0UL)
+#define ISP_YNLM_LUT_VS_61                 (ISP_BASE_ADDR+0x63F4UL)
+#define ISP_YNLM_LUT_VS_62                 (ISP_BASE_ADDR+0x63F8UL)
+#define ISP_YNLM_LUT_VS_63                 (ISP_BASE_ADDR+0x63FCUL)
+
+
+
+/*isp sub block: iircnr(pike has no this module)*/
+/*#define ISP_IIRCNR_STATUS0                 (ISP_BASE_ADDR+0x6400UL)
+#define ISP_IIRCNR_STATUS1                 (ISP_BASE_ADDR+0x6404UL)
+#define ISP_IIRCNR_PARAM                   (ISP_BASE_ADDR+0x6414UL)
+#define ISP_IIRCNR_PARAM1                  (ISP_BASE_ADDR+0x6418UL)
+#define ISP_IIRCNR_PARAM2                  (ISP_BASE_ADDR+0x641CUL)
+#define ISP_IIRCNR_PARAM3                  (ISP_BASE_ADDR+0x6420UL)
+#define ISP_IIRCNR_PARAM4                  (ISP_BASE_ADDR+0x6424UL)
+#define ISP_IIRCNR_PARAM5                  (ISP_BASE_ADDR+0x6428UL)
+#define ISP_IIRCNR_PARAM6                  (ISP_BASE_ADDR+0x642CUL)
+#define ISP_IIRCNR_PARAM7                  (ISP_BASE_ADDR+0x6430UL)
+#define ISP_IIRCNR_PARAM8                  (ISP_BASE_ADDR+0x6434UL)
+#define ISP_IIRCNR_PARAM9                  (ISP_BASE_ADDR+0x6438UL)
+#define ISP_YRANDOM_PARAM0                 (ISP_BASE_ADDR+0x643CUL)
+#define ISP_YRANDOM_PARAM1                 (ISP_BASE_ADDR+0x6440UL)
+#define ISP_YRANDOM_PARAM2                 (ISP_BASE_ADDR+0x6444UL)
+#define ISP_YRANDOM_STATUS0                (ISP_BASE_ADDR+0x6448UL)
+#define ISP_YRANDOM_STATUS1                (ISP_BASE_ADDR+0x644CUL)
+#define ISP_YRANDOM_STATUS2                (ISP_BASE_ADDR+0x6450UL)*/
+
+/*pingpang buffer*/
+#define ISP_3D_LUT_BUF0_CH0                (ISP_BASE_ADDR+0x17000UL)
+#define ISP_HSV_BUF0_CH0                   (ISP_BASE_ADDR+0x18000UL)
+#define ISP_VST_BUF0_CH0                   (ISP_BASE_ADDR+0x19000UL)
+#define ISP_IVST_BUF0_CH0                  (ISP_BASE_ADDR+0x1A000UL)
+#define ISP_FGAMMA_R_BUF0_CH0              (ISP_BASE_ADDR+0x1B000UL)
+#define ISP_FGAMMA_G_BUF0_CH0              (ISP_BASE_ADDR+0x1C000UL)
+#define ISP_FGAMMA_B_BUF0_CH0              (ISP_BASE_ADDR+0x1D000UL)
+#define ISP_YGAMMA_BUF0_CH0                (ISP_BASE_ADDR+0x1E000UL)
+//#define ISP_NLM_BUF0_CH0                   (ISP_BASE_ADDR+0x1F000UL)
+//#define ISP_3D_LUT_BUF1_CH0                (ISP_BASE_ADDR+0x20000UL)
+#define ISP_HSV_BUF1_CH0                   (ISP_BASE_ADDR+0x1F000UL)
+//#define ISP_VST_BUF1_CH0                   (ISP_BASE_ADDR+0x22000UL)
+//#define ISP_IVST_BUF1_CH0                  (ISP_BASE_ADDR+0x23000UL)
+//#define ISP_FGAMMA_R_BUF1_CH0              (ISP_BASE_ADDR+0x24000UL)
+//#define ISP_FGAMMA_G_BUF1_CH0              (ISP_BASE_ADDR+0x25000UL)
+//#define ISP_FGAMMA_B_BUF1_CH0              (ISP_BASE_ADDR+0x26000UL)
+//#define ISP_YGAMMA_BUF1_CH0                (ISP_BASE_ADDR+0x27000UL)
+//#define ISP_NLM_BUF1_CH0                   (ISP_BASE_ADDR+0x28000UL)
+#define ISP_LEN_BUF0_CH0                   (ISP_BASE_ADDR+0x29000UL)
+#define ISP_LEN_BUF1_CH0                   (ISP_BASE_ADDR+0x2b000UL)
+
+#define ISP_AHB_BASE                       SPRD_MMAHB_BASE
+#define ISP_MODULE_EB                      (ISP_AHB_BASE+0x0000UL)
+#define ISP_MODULE_RESET                   (ISP_AHB_BASE+0x0004UL)
+#define ISP_CORE_CLK_EB                    (ISP_AHB_BASE+0x0008UL)
+
+/*isp v memory1: awbm*/
+#define ISP_RAW_AWBM_OUTPUT                (ISP_BASE_ADDR+0x10000)
+/*#define ISP_RAW_AWBM_ITEM                  256*/
+
+/*isp v memory2: aem*/
+#define ISP_RAW_AEM_OUTPUT                 (ISP_BASE_ADDR+0x12000)
+/*#define ISP_RAW_AEM_ITEM                   1024*/
+
+/*isp v memory11: 3D_LUT0*/
+#define ISP_3D_LUT0_OUTPUT                 (ISP_BASE_ADDR+0x17000)
+/*#define ISP_3D_LUT0_ITEM                    729*/
+
+/*isp v memory12: HSV BUF0*/
+#define ISP_HSV_BUF0_OUTPUT                (ISP_BASE_ADDR+0x18000)
+/*#define ISP_HSV_ITEM                     361*/
+
+/*isp v memory20: 3D_LUT1*/
+//#define ISP_3D_LUT1_OUTPUT                 (ISP_BASE_ADDR+0x20000)
+/*#define ISP_3D_LUT1_ITEM                    729*/
+
+/*isp v memory21: HSV BUF1*/
+#define ISP_HSV_BUF1_OUTPUT                (ISP_BASE_ADDR+0x21000)
+/*#define ISP_HSV_ITEM                     361*/
+
+/*irq line number in system*/
+#define ISP_IRQ                            IRQ_ISP_INT
+
+#define ISP_RST_LOG_BIT                    BIT_2
+#define ISP_RST_CFG_BIT                    BIT_3
+
+#define ISP_IRQ_HW_MASK                    (0xFFFFFFFF)
+#define ISP_IRQ_NUM                        (32)
+#define ISP_REG_BUF_SIZE                   (4 * 1024)
+#define ISP_RAW_AE_BUF_SIZE                (1024 * 4 * 3)
+#define ISP_FRGB_GAMMA_BUF_SIZE                (129 * 4)
+#define ISP_YUV_YGAMMA_BUF_SIZE            (129 * 4 )
+#define ISP_RAW_AWB_BUF_SIZE                (256 * 4 * 9)
+#define ISP_BING4AWB_SIZE                  (640 * 480 * 2)
+#define ISP_YIQ_ANTIFLICKER_SIZE           (1944 * 4 * 16)
+#define ISP_YIQ_AEM_BUF_SIZE               (1024 * 4)
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_cfg_param.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_cfg_param.c
new file mode 100644
index 00000000..e75aec4d
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_cfg_param.c
@@ -0,0 +1,133 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_block.h"
+
+typedef int32_t (*isp_cfg_fun_ptr)(struct isp_io_param *isp_param);
+
+struct isp_cfg_fun {
+	uint32_t sub_block;
+	isp_cfg_fun_ptr cfg_fun;
+};
+
+static struct isp_cfg_fun isp_cfg_fun_tab[] = {
+	{ISP_BLOCK_PRE_GLB_GAIN,           isp_k_cfg_pgg},
+	{ISP_BLOCK_BLC,                    isp_k_cfg_blc},
+	{ISP_BLOCK_RGB_GAIN,               isp_k_cfg_rgb_gain},
+	{ISP_BLOCK_PRE_WAVELET,            isp_k_cfg_pwd},
+	{ISP_BLOCK_NLC,                    isp_k_cfg_nlc},
+	/*{ISP_BLOCK_2D_LSC,                    isp_k_cfg_2d_lsc},*/
+	{ISP_BLOCK_1D_LSC,                 isp_k_cfg_1d_lsc},
+	/*{ISP_BLOCK_BINNING4AWB,                isp_k_cfg_binning},*/
+	/*{ISP_BLOCK_AWB,                    isp_k_cfg_awb},*/
+	/*{ISP_BLOCK_RAW_AEM,                isp_k_cfg_raw_aem},*/
+	{ISP_BLOCK_BPC,                 isp_k_cfg_bpc},
+	{ISP_BLOCK_BDN,               isp_k_cfg_bdn},
+	{ISP_BLOCK_GRGB,                   isp_k_cfg_grgb},
+	{ISP_BLOCK_RGB_GAIN2,              isp_k_cfg_rgb_gain2},
+	{ISP_BLOCK_NLM,                    isp_k_cfg_nlm},
+	{ISP_BLOCK_CFA,                 isp_k_cfg_cfa},
+	{ISP_BLOCK_CMC,                    isp_k_cfg_cmc10},
+	{ISP_BLOCK_HDR,                    isp_k_cfg_hdr},//pike add module,this module is same to sharkl's hdr module
+	/*{ISP_BLOCK_GAMMA,                  isp_k_cfg_gamma},*/
+	{ISP_BLOCK_CMC8,                   isp_k_cfg_cmc8},
+	/*{ISP_BLOCK_CT,                     isp_k_cfg_ct},*/
+	{ISP_BLOCK_CCE,                    isp_k_cfg_cce},
+	{ISP_BLOCK_HSV,                    isp_k_cfg_hsv},
+	{ISP_BLOCK_CSC,                    isp_k_cfg_csc},
+	{ISP_BLOCK_PRE_CDN_RGB,            isp_k_cfg_pre_cdn_rgb},
+	{ISP_BLOCK_POSTERIZE,              isp_k_cfg_posterize},
+	{ISP_BLOCK_AFM_V1,                 isp_k_cfg_rgb_afm},
+	{ISP_BLOCK_RGB2Y,                  isp_k_cfg_rgb2y},//pike add module
+	{ISP_BLOCK_YIQ_AEM,                isp_k_cfg_yiq_aem},
+	/*{ISP_BLOCK_ANTI_FLICKER,           isp_k_cfg_anti_flicker},*/
+	{ISP_BLOCK_YIQ_AFM,                isp_k_cfg_yiq_afm},
+	{ISP_BLOCK_YUV_PRECDN,             isp_k_cfg_yuv_precdn},
+	{ISP_BLOCK_PRE_FILTER,             isp_k_cfg_prefilter},
+	{ISP_BLOCK_UV_PREFILTER,	       isp_k_cfg_uv_prefilter},//pike add module
+	{ISP_BLOCK_BRIGHTNESS,             isp_k_cfg_brightness},
+	{ISP_BLOCK_CONTRAST,               isp_k_cfg_contrast},
+	{ISP_BLOCK_HIST,                   isp_k_cfg_hist},
+	{ISP_BLOCK_HIST2,                  isp_k_cfg_hist2},
+	{ISP_BLOCK_ACA,                    isp_k_cfg_aca},
+	{ISP_BLOCK_YUV_CDN,                isp_k_cfg_yuv_cdn},
+	{ISP_BLOCK_EDGE,                   isp_k_cfg_edge},
+	{ISP_BLOCK_CSS,                    isp_k_cfg_css},
+	{ISP_BLOCK_CSA,                    isp_k_cfg_csa},
+	{ISP_BLOCK_HUE,                    isp_k_cfg_hue},
+	{ISP_BLOCK_POST_CDN,               isp_k_cfg_post_cdn},
+	{ISP_BLOCK_EMBOSS,                 isp_k_cfg_emboss},
+	/*{ISP_BLOCK_YGAMMA,                 isp_k_cfg_ygamma},*/
+	{ISP_BLOCK_YDELAY,                 isp_k_cfg_ydelay},
+	{ISP_BLOCK_YUV_NLM,                isp_k_cfg_yuv_nlm},//pike add module
+	//{ISP_BLOCK_IIRCNR,                 isp_k_cfg_iircnr},//pike has no this module
+	{ISP_BLOCK_FETCH,                  isp_k_cfg_fetch},
+	{ISP_BLOCK_STORE,                  isp_k_cfg_store},
+	{ISP_BLOCK_DISPATCH,               isp_k_cfg_dispatch},
+	{ISP_BLOCK_ARBITER_V1,             isp_k_cfg_arbiter},
+	//{ISP_BLOCK_RAW_SIZER,              isp_k_cfg_raw_sizer},//pike has no this module
+	{ISP_BLOCK_COMMON_V1,              isp_k_cfg_common},
+};
+
+int32_t isp_cfg_param(void  *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t i = 0, cnt = 0;
+	isp_cfg_fun_ptr cfg_fun_ptr = NULL;
+	struct isp_io_param isp_param = {0, 0, 0, NULL};
+
+	if (!param) {
+		printk("isp_cfg_param: param is null error.\n");
+		return -1;
+	}
+
+	ret = copy_from_user((void *)&isp_param, (void *)param, sizeof(isp_param));
+	if ( 0 != ret) {
+		printk("isp_cfg_param: copy error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (ISP_BLOCK_ANTI_FLICKER == isp_param.sub_block) {
+		ret = isp_k_cfg_anti_flicker(&isp_param, isp_private);
+	} else if (ISP_BLOCK_2D_LSC == isp_param.sub_block) {
+		ret = isp_k_cfg_2d_lsc(&isp_param, isp_private);
+	} else if (ISP_BLOCK_RAW_AEM == isp_param.sub_block) {
+		ret = isp_k_cfg_raw_aem(&isp_param, isp_private);
+	} else if (ISP_BLOCK_GAMMA == isp_param.sub_block) {
+		ret = isp_k_cfg_gamma(&isp_param, isp_private);
+	} else if (ISP_BLOCK_CT == isp_param.sub_block) {
+		ret = isp_k_cfg_ct(&isp_param, isp_private);
+	} else if (ISP_BLOCK_YGAMMA == isp_param.sub_block) {
+		ret = isp_k_cfg_ygamma(&isp_param, isp_private);
+	} else if (ISP_BLOCK_AWB == isp_param.sub_block) {
+		ret = isp_k_cfg_awb(&isp_param, isp_private);
+	} else if(ISP_BLOCK_BINNING4AWB == isp_param.sub_block){
+		ret = isp_k_cfg_binning(&isp_param, isp_private);
+	} else {
+		cnt = sizeof(isp_cfg_fun_tab) / sizeof(isp_cfg_fun_tab[0]);
+		for (i = 0; i < cnt; i++) {
+			if (isp_param.sub_block == isp_cfg_fun_tab[i].sub_block) {
+				cfg_fun_ptr = isp_cfg_fun_tab[i].cfg_fun;
+				break;
+			}
+		}
+
+		if (NULL != cfg_fun_ptr)
+			ret = cfg_fun_ptr(&isp_param);
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_1d_lsc.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_1d_lsc.c
new file mode 100644
index 00000000..3daa3ef5
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_1d_lsc.c
@@ -0,0 +1,146 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_1d_lsc_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_1d_lsc_info lnc_info;
+
+	ret = copy_from_user((void *)&lnc_info, param->property_param, sizeof(lnc_info));
+	if (0 != ret) {
+		printk("isp_k_1d_lsc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_1D_LNC_PARAM, BIT_0, lnc_info.bypass);
+
+	val = (lnc_info.gain_max_thr & 0x1FFF) << 1;
+	REG_MWR(ISP_1D_LNC_PARAM, 0x3FFE, val);
+
+	val = ((lnc_info.center_r0c0_col_x & 0x1FFF) << 12) | (lnc_info.center_r0c0_row_y & 0xFFF);
+	REG_WR(ISP_1D_LNC_PARAM1, val);
+	val = ((lnc_info.center_r0c1_col_x & 0x1FFF) << 12) | (lnc_info.center_r0c1_row_y & 0xFFF);
+	REG_WR(ISP_1D_LNC_PARAM2, val);
+	val = ((lnc_info.center_r1c0_col_x & 0x1FFF) << 12) | (lnc_info.center_r1c0_row_y & 0xFFF);
+	REG_WR(ISP_1D_LNC_PARAM3, val);
+	val = ((lnc_info.center_r1c1_col_x & 0x1FFF) << 12) | (lnc_info.center_r1c1_row_y & 0xFFF);
+	REG_WR(ISP_1D_LNC_PARAM4, val);
+
+	val = lnc_info.delta_square_r0c0_x & 0x3FFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM5, val);
+	val = lnc_info.delta_square_r0c1_x & 0x3FFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM7, val);
+	val = lnc_info.delta_square_r1c0_x & 0x3FFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM9, val);
+	val = lnc_info.delta_square_r1c1_x & 0x3FFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM11, val);
+	val = lnc_info.delta_square_r0c0_y & 0xFFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM6, val);
+	val = lnc_info.delta_square_r0c1_y & 0xFFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM8, val);
+	val = lnc_info.delta_square_r1c0_y & 0xFFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM10, val);
+	val = lnc_info.delta_square_r1c1_y & 0xFFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM12, val);
+
+	val = ((lnc_info.coef_r0c0_p1 & 0xFFFF) << 11) | (lnc_info.coef_r0c0_p2 & 0x7FF);
+	REG_WR(ISP_1D_LNC_PARAM13, val);
+	val = ((lnc_info.coef_r0c1_p1 & 0xFFFF) << 11) | (lnc_info.coef_r0c1_p2 & 0x7FF);
+	REG_WR(ISP_1D_LNC_PARAM14, val);
+	val = ((lnc_info.coef_r1c0_p1 & 0xFFFF) << 11) | (lnc_info.coef_r1c0_p2 & 0x7FF);
+	REG_WR(ISP_1D_LNC_PARAM15, val);
+	val = ((lnc_info.coef_r1c1_p1 & 0xFFFF) << 11) | (lnc_info.coef_r1c1_p2 & 0x7FF);
+	REG_WR(ISP_1D_LNC_PARAM16, val);
+
+	val = ((lnc_info.start_pos.x & 0x1FFF) << 12) | (lnc_info.start_pos.y & 0xFFF);
+	REG_WR(ISP_1D_LNC_PARAM18, val);
+
+	return ret;
+}
+
+static int32_t isp_k_1d_lsc_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size;
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_1d_lsc_slice_size: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.width & 0x1FFF) << 12) | (size.height & 0xFFF);
+
+	REG_WR(ISP_1D_LNC_PARAM17, val);
+
+	return ret;
+}
+
+static int32_t isp_k_1d_lsc_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct img_offset pos;
+
+	ret = copy_from_user((void *)&pos, param->property_param, sizeof(struct img_offset));
+	if (0 != ret) {
+		printk("isp_k_1d_lsc_pos: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((pos.x & 0x1FFF) << 12) | (pos.y & 0xFFF);
+
+	REG_WR(ISP_1D_LNC_PARAM18, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_1d_lsc(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_1d_lsc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_1d_lsc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_1D_LSC_BLOCK:
+		ret = isp_k_1d_lsc_block(param);
+		break;
+	case ISP_PRO_1D_LSC_SLICE_SIZE:
+		ret = isp_k_1d_lsc_slice_size(param);
+		break;
+	case ISP_PRO_1D_LSC_POS:
+		ret = isp_k_1d_lsc_pos(param);
+		break;
+	default:
+		printk("isp_k_cfg_1d_lsc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_2d_lsc.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_2d_lsc.c
new file mode 100644
index 00000000..94f1f2c4
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_2d_lsc.c
@@ -0,0 +1,537 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include <asm/cacheflush.h>
+#include <linux/delay.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+
+#define ISP_LSC_TIME_OUT_MAX        500
+#define ISP_LSC_BUF0                0
+#define ISP_LSC_BUF1                1
+
+#if 0
+#define CLIP(input,top, bottom) {if (input>top) input = top; if (input < bottom) input = bottom;}
+#define TABLE_LEN_128	128
+#define TABLE_LEN_96	96
+
+typedef struct lnc_bicubic_weight_t_64_tag
+{
+	int16_t w0;
+	int16_t w1;
+	int16_t w2;
+	int16_t w3;
+}LNC_BICUBIC_WEIGHT_TABLE_T;
+////////10bit precision//////////////////////////////////////
+static LNC_BICUBIC_WEIGHT_TABLE_T lnc_bicubic_weight_t_96_simple[] =
+{
+	{0,	1024,	0},
+	{-5,1024,	6},
+	{-10,1023,	12},
+	{-15,1022,	18},
+	{-20,1020,	25},
+	{-24,1017,	32},
+	{-28,1014,	40},
+	{-32,1011,	48},
+	{-36,1007,	56},
+	{-39,1003,	65},
+	{-43,998,	74},
+	{-46,993,	83},
+	{-49,987,	93},
+	{-52,981,	103},
+	{-54,974,	113},
+	{-57,967,	124},
+	{-59,960,	135},
+	{-61,952,	146},
+	{-63,944,	158},
+	{-65,936,	170},
+	{-67,927,	182},
+	{-68,918,	194},
+	{-70,908,	206},
+	{-71,898,	219},
+	{-72,888,	232},
+	{-73,878,	245},
+	{-74,867,	258},
+	{-74,856,	272},
+	{-75,844,	285},
+	{-75,833,	299},
+	{-76,821,	313},
+	{-76,809,	327},
+	{-76,796,	341},
+	{-76,784,	356},
+	{-76,771,	370},
+	{-75,758,	384},
+	{-75,745,	399},
+	{-75,732,	414},
+	{-74,718,	428},
+	{-73,704,	443},
+	{-73,691,	458},
+	{-72,677,	473},
+	{-71,663,	487},
+	{-70,648,	502},
+	{-69,634,	517},
+	{-68,620,	532},
+	{-67,605,	547},
+	{-65,591,	561},
+	{-64,576,	576},
+};
+
+static LNC_BICUBIC_WEIGHT_TABLE_T lnc_bicubic_weight_t_128_simple[] =
+{
+	 {0,	1024,	0},
+	 {-4,	1024,	4},
+	 {-8,	1023,	8},
+	 {-11,	1023,	13},
+	 {-15,	1022,	18},
+	 {-18,	1020,	23},
+	 {-22,	1019,	28},
+	 {-25,	1017,	34},
+	 {-28,	1014,	40},
+	 {-31,	1012,	46},
+	 {-34,	1009,	52},
+	 {-37,	1006,	58},
+	 {-39,	1003,	65},
+	 {-42,	999,	72},
+	 {-44,	995,	78},
+	 {-47,	991,	86},
+	 {-49,	987,	93},
+	 {-51,	982,	101},
+	 {-53,	978,	108},
+	 {-55,	973,	116},
+	 {-57,	967,	124},
+	 {-59,	962,	132},
+	 {-60,	956,	141},
+	 {-62,	950,	149},
+	 {-63,	944,	158},
+	 {-65,	938,	167},
+	 {-66,	931,	176},
+	 {-67,	925,	185},
+	 {-68,	918,	194},
+	 {-69,	910,	203},
+	 {-70,	903,	213},
+	 {-71,	896,	222},
+	 {-72,	888,	232},
+	 {-73,	880,	242},
+	 {-73,	872,	252},
+	 {-74,	864,	262},
+	 {-74,	856,	272},
+	 {-75,	847,	282},
+	 {-75,	839,	292},
+	 {-75,	830,	303},
+	 {-76,	821,	313},
+	 {-76,	812,	324},
+	 {-76,	803,	334},
+	{-76,	793,	345},
+	{-76,	784,	356},
+	{-76,	774,	366},
+	{-76,	765,	377},
+	{-75,	755,	388},
+	{-75,	745,	399},
+	{-75,	735,	410},
+	{-74,	725,	421},
+	{-74,	715,	432},
+	{-73,	704,	443},
+	{-73,	694,	454},
+	{-72,	684,	465},
+	{-72,	673,	476},
+	{-71,	663,	487},
+	{-70,	652,	498},
+	{-69,	641,	510},
+	{-69,	631,	521},
+	{-68,	620,	532},
+	{-67,	609,	543},
+	{-66,	598,	554},
+	{-65,	587,	565},
+	{-64,	576,	576},
+};
+
+static uint16_t ISP_Cubic1D(uint16_t a, uint16_t b, uint16_t c, uint16_t d, uint16_t u, uint16_t box)
+{
+	int32_t out_value;
+	uint16_t out_value_uint16_t;
+	int16_t w0, w1, w2, w3;
+	uint32_t out_value_tmp;
+	int16_t sub_tmp0;
+	int16_t sub_tmp1;
+	int16_t sub_tmp2;
+
+	if(box ==96)
+	{
+		//use simple table
+		if ( u < (TABLE_LEN_96/2 + 1) )
+		{
+			w0 = lnc_bicubic_weight_t_96_simple[u].w0 ;
+			w1 = lnc_bicubic_weight_t_96_simple[u].w1 ;
+			w2 = lnc_bicubic_weight_t_96_simple[u].w2 ;
+
+			sub_tmp0 = a-d;
+			sub_tmp1 = b-d;
+			sub_tmp2 = c-d;
+			out_value_tmp = ((uint32_t)d)<<10;
+			out_value = out_value_tmp + sub_tmp0 * w0  + sub_tmp1 * w1 + sub_tmp2 * w2;
+		}
+		else
+		{
+			w1 = lnc_bicubic_weight_t_96_simple[TABLE_LEN_96 - u].w2 ;
+			w2 = lnc_bicubic_weight_t_96_simple[TABLE_LEN_96 - u].w1 ;
+			w3 = lnc_bicubic_weight_t_96_simple[TABLE_LEN_96 - u].w0 ;
+
+			sub_tmp0 = b-a;
+			sub_tmp1 = c-a;
+			sub_tmp2 = d-a;
+			out_value_tmp = ((uint32_t)a)<<10;
+			out_value = out_value_tmp + sub_tmp0 * w1  + sub_tmp1 * w2 + sub_tmp2 * w3;
+		}
+
+	}
+	else
+	{
+		u = u * (TABLE_LEN_128 / box);
+
+		//use simple table
+		if ( u < (TABLE_LEN_128/2 + 1) )
+		{
+			w0 = lnc_bicubic_weight_t_128_simple[u].w0 ;
+			w1 = lnc_bicubic_weight_t_128_simple[u].w1 ;
+			w2 = lnc_bicubic_weight_t_128_simple[u].w2 ;
+
+			sub_tmp0 = a-d;
+			sub_tmp1 = b-d;
+			sub_tmp2 = c-d;
+			out_value_tmp = ((uint32_t)d)<<10;
+			out_value = out_value_tmp + sub_tmp0 * w0  + sub_tmp1 * w1 + sub_tmp2 * w2;
+		}
+		else
+		{
+			w1 = lnc_bicubic_weight_t_128_simple[TABLE_LEN_128 - u].w2 ;
+			w2 = lnc_bicubic_weight_t_128_simple[TABLE_LEN_128 - u].w1 ;
+			w3 = lnc_bicubic_weight_t_128_simple[TABLE_LEN_128 - u].w0 ;
+
+			sub_tmp0 = b-a;
+			sub_tmp1 = c-a;
+			sub_tmp2 = d-a;
+			out_value_tmp = ((uint32_t)a)<<10;
+			out_value = out_value_tmp + sub_tmp0 * w1  + sub_tmp1 * w2 + sub_tmp2 * w3;
+		}
+	}
+
+	//CLIP(out_value, 4095*1024*2, 1024*1024);	// for LSC gain, 1024 = 1.0, 4095 = 4.0 ; 4095*2 is for boundary extension.
+	CLIP(out_value, 16383*1024, 1024*1024);	// for LSC gain, 1024 = 1.0, 16383 = 16.0 ; 16383 is for boundary extension, 14 bit parameter is used.
+
+	out_value_uint16_t = (uint16_t)((out_value + 512) >> 10);
+
+	return out_value_uint16_t;
+}
+
+
+static int32_t ISP_GenerateQValues(uint32_t word_endian, uint32_t q_val[][5], unsigned long param_address, uint16_t grid_w, uint16_t grid_num, uint16_t u)
+{
+	uint8_t i;
+	uint16_t A0, B0, C0, D0;
+	uint16_t A1, B1, C1, D1;
+	uint32_t *addr = (uint32_t *)param_address;
+
+	if (param_address == 0x0 || grid_num == 0x0) {
+		printk("ISP_GenerateQValues param_address error addr=0x%lx grid_num=%d \n",param_address, grid_num);
+		return -1;
+	}
+
+	//printk("ISP_GenerateQValues:addr=%x  grid_w=%d  grid_num=%d u=%d \n",param_address,grid_w,grid_num,u);
+	#if 0
+	for (i = 0; i < 5; i++) {
+		A0  = (uint16_t)*(addr + i * 2) & 0xFFFF;
+		B0  = (uint16_t)*(addr + i * 2 + grid_w * 2) & 0xFFFF;
+		C0  = (uint16_t)*(addr + i * 2 + grid_w * 2 * 2) & 0xFFFF;
+		D0  = (uint16_t)*(addr + i * 2 + grid_w * 2 * 3) & 0xFFFF;
+		A1  = (uint16_t)(*(addr + i * 2) >> 16);
+		B1  = (uint16_t)(*(addr + i * 2 + grid_w * 2) >> 16);
+		C1  = (uint16_t)(*(addr + i * 2 + grid_w * 2 * 2) >> 16);
+		D1  = (uint16_t)(*(addr + i * 2 + grid_w * 2 * 3) >> 16);
+		q_val[0][i] = ISP_Cubic1D(A0, B0, C0, D0, u, grid_num);
+		q_val[1][i] = ISP_Cubic1D(A1, B1, C1, D1, u, grid_num);
+	}
+	#endif
+	#if 1
+	for (i = 0; i < 5; i++) {
+		if (1 == word_endian) {	// ABCD = 1 word
+			A0  = *(addr + i * 2) >> 16;					// AB
+			B0  = *(addr + i * 2 + grid_w * 2) >> 16;       // AB
+			C0  = *(addr + i * 2 + grid_w * 2 * 2) >> 16;   // AB
+			D0  = *(addr + i * 2 + grid_w * 2 * 3) >> 16;   // AB
+			A1  = *(addr + i * 2) & 0xFFFF;					// CD
+			B1  = *(addr + i * 2 + grid_w * 2) & 0xFFFF;    // CD
+			C1  = *(addr + i * 2 + grid_w * 2 * 2) & 0xFFFF;// CD
+			D1  = *(addr + i * 2 + grid_w * 2 * 3) & 0xFFFF;// CD
+		} else if (2 == word_endian) { // CDAB = 1 word
+			A0  = *(addr + i * 2) & 0xFFFF;
+			B0  = *(addr + i * 2 + grid_w * 2) & 0xFFFF;
+			C0  = *(addr + i * 2 + grid_w * 2 * 2) & 0xFFFF;
+			D0  = *(addr + i * 2 + grid_w * 2 * 3) & 0xFFFF;
+			A1  = *(addr + i * 2) >> 16;
+			B1  = *(addr + i * 2 + grid_w * 2) >> 16;
+			C1  = *(addr + i * 2 + grid_w * 2 * 2) >> 16;
+			D1  = *(addr + i * 2 + grid_w * 2 * 3) >> 16;
+		} else if (0 == word_endian) { // DCBA = 1 word
+			A0  = ((*(addr + i * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2) >> 8) & 0x000000FF);
+			B0  = ((*(addr + i * 2 + grid_w * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2) >> 8) & 0x000000FF);
+			C0  = ((*(addr + i * 2 + grid_w * 2 * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2 * 2) >> 8) & 0x000000FF);
+			D0  = ((*(addr + i * 2 + grid_w * 2 * 3) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2 * 3) >> 8) & 0x000000FF);
+			A1  = ((*(addr + i * 2) << 8) & 0xFF000000) | ((*(addr + i * 2) >> 8) & 0x00FF0000);
+			B1  = ((*(addr + i * 2 + grid_w * 2) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2) >> 8) & 0x00FF0000);
+			C1  = ((*(addr + i * 2 + grid_w * 2 * 2) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2 * 2) >> 8) & 0x00FF0000);
+			D1  = ((*(addr + i * 2 + grid_w * 2 * 3) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2 * 3) >> 8) & 0x00FF0000);
+		} else if (3 == word_endian) { // BADC = 1 word
+			A0  = ((*(addr + i * 2) << 8) & 0xFF000000) | ((*(addr + i * 2) >> 8) & 0x00FF0000);
+			B0  = ((*(addr + i * 2 + grid_w * 2) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2) >> 8) & 0x00FF0000);
+			C0  = ((*(addr + i * 2 + grid_w * 2 * 2) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2 * 2) >> 8) & 0x00FF0000);
+			D0  = ((*(addr + i * 2 + grid_w * 2 * 3) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2 * 3) >> 8) & 0x00FF0000);
+			A1  = ((*(addr + i * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2) >> 8) & 0x000000FF);
+			B1  = ((*(addr + i * 2 + grid_w * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2) >> 8) & 0x000000FF);
+			C1  = ((*(addr + i * 2 + grid_w * 2 * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2 * 2) >> 8) & 0x000000FF);
+			D1  = ((*(addr + i * 2 + grid_w * 2 * 3) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2 * 3) >> 8) & 0x000000FF);
+		}
+		//printk("ISP_GenerateQValues: A0=%x B0=%x C0=%x D0=%x A1=%x B1=%x C1=%x D1=%x \n",A0,B0,C0,D0,A1,B1,C1,D1);
+		q_val[0][i] = ISP_Cubic1D(A0, B0, C0, D0, u, grid_num);
+		q_val[1][i] = ISP_Cubic1D(A1, B1, C1, D1, u, grid_num);
+		//printk("ISP_GenerateQValues: q_val[0][%d] = %d  q_val[1][%d] = %d \n",i,q_val[0][i],i ,q_val[1][i] );
+	}
+	#endif
+
+	return 0;
+}
+#endif
+
+static int32_t isp_k_2d_lsc_param_load(struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t time_out_cnt = 0;
+	uint32_t addr = 0, reg_value = 0;
+
+	if (ISP_LSC_BUF0 == isp_private->lsc_load_buf_id) {
+		isp_private->lsc_load_buf_id = ISP_LSC_BUF1;
+	} else {
+		isp_private->lsc_load_buf_id = ISP_LSC_BUF0;
+	}
+	REG_MWR(ISP_LENS_LOAD_BUF, BIT_0, isp_private->lsc_load_buf_id);
+	REG_WR(ISP_LENS_PARAM_ADDR, isp_private->lsc_buf_phys_addr);
+	REG_OWR(ISP_LENS_LOAD_EB, BIT_0);
+	REG_MWR(ISP_LENS_PARAM, BIT_1, isp_private->lsc_load_buf_id << 1);
+	isp_private->lsc_update_buf_id = isp_private->lsc_load_buf_id;
+
+	reg_value = REG_RD(ISP_INT_RAW0);
+
+	while ((0x00 == (reg_value & ISP_INT_EVT_LSC_LOAD))
+		&& (time_out_cnt < ISP_LSC_TIME_OUT_MAX)) {
+		udelay(1);
+		reg_value = REG_RD(ISP_INT_RAW0);
+		time_out_cnt++;
+	}
+	if (time_out_cnt >= ISP_LSC_TIME_OUT_MAX) {
+		ret = -1;
+		printk("isp_k_2d_lsc_param_load: lsc load time out error.\n");
+	}
+	REG_OWR(ISP_INT_CLR0, ISP_INT_EVT_LSC_LOAD);
+
+	return ret;
+}
+
+static int32_t isp_k_2d_lsc_block(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	//uint32_t qvalue_addr = ISP_LEN_BUF0_CH0;
+	struct isp_dev_2d_lsc_info lens_info;
+
+	memset(&lens_info, 0x00, sizeof(lens_info));
+
+	ret = copy_from_user((void *)&lens_info, param->property_param, sizeof(lens_info));
+	if (0 != ret) {
+		printk("isp_k_2d_lsc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((lens_info.offset_y & 0xFFFF) << 16) | (lens_info.offset_x & 0xFFFF);
+	REG_WR(ISP_LENS_SLICE_POS, val);
+
+	val = lens_info.grid_pitch & 0x1FF;
+	REG_MWR(ISP_LENS_GRID_PITCH, 0x1FF, val);
+
+	val = (lens_info.grid_width & 0xFF) << 16;
+	REG_MWR(ISP_LENS_GRID_PITCH, 0xFF0000, val);
+
+	val = ((lens_info.grid_num_t & 0xFFFF) << 16) | ((lens_info.grid_y_num & 0xFF) << 8) | (lens_info.grid_x_num & 0xFF);
+	REG_WR(ISP_LENS_GRID_SIZE, val);
+
+	REG_MWR(ISP_LENS_LOAD_BUF, BIT_1, lens_info.load_chn_sel << 1);
+
+	REG_MWR(ISP_LENS_MISC, (BIT_1 | BIT_0), (lens_info.endian & 0x03));
+
+	val = ((lens_info.slice_size.height & 0xFFFF) << 16) | (lens_info.slice_size.width & 0xFFFF);
+	REG_WR(ISP_LENS_SLICE_SIZE, val);
+
+	val = ((lens_info.relative_y & 0xFF) << 8) | (lens_info.relative_x & 0xFF);
+	REG_WR(ISP_LENS_INIT_COOR, val);
+
+	/*ret = isp_k_2d_lsc_param_load(&src_buf, isp_private, &qvalue_addr);
+	REG_WR(ISP_LENS_PARAM_ADDR, qvalue_addr);
+	printk("isp_k_2d_lsc_block:qvalue_addr=%x grid_x_num=%d grid_width=%d  relative_y=%d \n",qvalue_addr,(lens_info.grid_x_num & 0xFF),(lens_info.grid_width & 0xFF), (lens_info.relative_y & 0xFF)>>1);
+
+	ISP_GenerateQValues(1, lens_info.q_value, qvalue_addr, ((uint16_t)lens_info.grid_x_num & 0xFF) + 2,(lens_info.grid_width & 0xFF), (lens_info.relative_y & 0xFF)>>1);
+	*/
+
+	ret = isp_k_2d_lsc_param_load(isp_private);
+	if (0 != ret) {
+		printk("isp_k_2d_lsc_block: lsc load para error, ret=0x%x\n", (uint32_t)ret);
+		REG_MWR(ISP_LENS_PARAM, BIT_0, ISP_BYPASS_EB);
+		return -1;
+	}
+
+	for (i = 0; i < 5; i++) {
+		val = ((lens_info.q_value[0][i] & 0x3FFF) << 16) | (lens_info.q_value[1][i] & 0x3FFF);
+		REG_WR(ISP_LENS_Q0_VALUE + i * 4, val);
+	}
+
+	REG_MWR(ISP_LENS_PARAM, BIT_0, lens_info.bypass);
+
+	return ret;
+
+}
+
+static int32_t isp_k_2d_lsc_param_update(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	REG_MWR(ISP_LENS_PARAM, BIT_1, isp_private->lsc_update_buf_id << 1);
+
+	return ret;
+}
+
+static int32_t isp_k_2d_lsc_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_offset offset = {0, 0};
+
+	ret = copy_from_user((void *)&offset, param->property_param, sizeof(offset));
+	if (0 != ret) {
+		printk("isp_k_lens_pos: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((offset.y & 0xFFFF) << 16) | (offset.x & 0xFFFF);
+
+	REG_WR(ISP_LENS_SLICE_POS, val);
+
+	return ret;
+}
+
+static int32_t isp_k_2d_lsc_grid_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t grid_total = 0;
+	struct isp_img_size size = {0, 0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_2d_lsc_grid_size: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	grid_total = (size.height + 2) * (size.width + 2);
+	val = ((grid_total & 0xFFFF) << 16) | ((size.height & 0xFF) << 8) | (size.width & 0xFF);
+	REG_WR(ISP_LENS_GRID_SIZE, val);
+
+	return ret;
+}
+
+static int32_t isp_k_2d_lsc_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0, 0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_2d_lsc_slice_size: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0xFFFF) << 16) | (size.width & 0xFFFF);
+
+	REG_WR(ISP_LENS_SLICE_SIZE, val);
+
+	return ret;
+}
+
+static int32_t isp_k_2d_lsc_transaddr(struct isp_io_param *param,
+			struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	struct isp_lsc_addr lsc_addr;
+
+	ret = copy_from_user((void *)&lsc_addr, param->property_param, sizeof(struct isp_lsc_addr));
+
+	isp_private->lsc_buf_phys_addr = lsc_addr.phys_addr;
+
+	printk("lsc phys addr 0x%x,\n",isp_private->lsc_buf_phys_addr);
+	return ret;
+}
+
+int32_t isp_k_cfg_2d_lsc(struct isp_io_param *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_2d_lsc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_2d_lsc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_2D_LSC_BLOCK:
+		ret = isp_k_2d_lsc_block(param, isp_private);
+		break;
+	case ISP_PRO_2D_LSC_PARAM_UPDATE:
+		ret = isp_k_2d_lsc_param_update(param, isp_private);
+		break;
+	case ISP_PRO_2D_LSC_POS:
+		ret = isp_k_2d_lsc_pos(param);
+		break;
+	case ISP_PRO_2D_LSC_GRID_SIZE:
+		ret = isp_k_2d_lsc_grid_size(param);
+		break;
+	case ISP_PRO_2D_LSC_SLICE_SIZE:
+		ret = isp_k_2d_lsc_slice_size(param);
+		break;
+	case ISP_PRO_2D_LSC_TRANSADDR:
+		ret = isp_k_2d_lsc_transaddr(param, isp_private);
+		break;
+	default:
+		printk("isp_k_cfg_2d_lsc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_aca.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_aca.c
new file mode 100644
index 00000000..0d784c73
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_aca.c
@@ -0,0 +1,78 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_aca_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_autocont_info_v1 autocont_info;
+	uint32_t val = 0;
+
+	memset(&autocont_info, 0x00, sizeof(autocont_info));
+
+	ret = copy_from_user((void *)&autocont_info, param->property_param, sizeof(autocont_info));
+	if (0 != ret) {
+		printk("isp_k_aca_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((autocont_info.out_max & 0xFF) << 24)
+			| ((autocont_info.out_min & 0xFF) << 16)
+			| ((autocont_info.in_max & 0xFF) << 8)
+			| (autocont_info.in_min & 0xFF);
+
+	REG_WR(ISP_AUTOCONT_MAX_MIN, val);
+
+	if (autocont_info.mode) {
+		REG_OWR(ISP_AUTOCONT_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_AUTOCONT_PARAM, BIT_1, 0);
+	}
+
+	if (autocont_info.bypass) {
+		REG_OWR(ISP_AUTOCONT_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_AUTOCONT_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_aca(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_aca: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_aca: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_ACA_BLOCK:
+		ret = isp_k_aca_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_aca: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_anti_flicker.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_anti_flicker.c
new file mode 100644
index 00000000..cadd5e36
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_anti_flicker.c
@@ -0,0 +1,155 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include <asm/cacheflush.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+static int32_t isp_k_afl_param_update(struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t addr = 0;
+#ifndef CONFIG_64BIT
+	void *buf_ptr = (void *)isp_private->yiq_antiflicker_buf_addr;
+#endif
+	uint32_t buf_len = isp_private->yiq_antiflicker_len;
+
+	if((0x00 != isp_private->yiq_antiflicker_buf_addr) && (0x00 != isp_private->yiq_antiflicker_len)) {
+
+#ifndef CONFIG_64BIT
+		dmac_flush_range(buf_ptr, buf_ptr + buf_len);
+		outer_flush_range(__pa(buf_ptr), __pa(buf_ptr) + buf_len);
+#endif
+		addr = (uint32_t)__pa(isp_private->yiq_antiflicker_buf_addr);
+
+		printk("$$LHC:addr %lp yiq_antiflicker_buf_addr %lp\n", addr, (int *)isp_private->yiq_antiflicker_buf_addr);
+		REG_WR(ISP_ANTI_FLICKER_DDR_INIT_ADDR, addr);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_afl_statistic(struct isp_io_param *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	int32_t i = 0;
+	int32_t *addr = NULL;
+	printk("$$LHC:isp_k_afl_statistic \n");
+	if((0x00 != isp_private->yiq_antiflicker_buf_addr) && (0x00 != param->property_param) \
+		&& (0x00 != isp_private->yiq_antiflicker_len) ) {
+
+		ret = copy_to_user(param->property_param, isp_private->yiq_antiflicker_buf_addr, isp_private->yiq_antiflicker_len);
+		if (0 != ret) {
+			ret = -1;
+			printk("isp_k_afl_statistic: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+		}
+		addr = isp_private->yiq_antiflicker_buf_addr;
+		for(i = 0;i < 20;i++) {
+			printk("$$LHC %p, 0x%x\n", addr, *addr++);
+		}
+	}
+}
+
+static int32_t isp_k_afl_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_afl_bypass: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	printk("$$LHC:bypass %d \n", bypass);
+	if (bypass) {
+		REG_OWR(ISP_ANTI_FLICKER_PARAM0, BIT_0);
+	} else {
+		REG_MWR(ISP_ANTI_FLICKER_PARAM0, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+
+static int32_t isp_k_anti_flicker_block(struct isp_io_param *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	struct isp_dev_anti_flicker_info_v1 afl_info;
+
+	memset(&afl_info, 0x00, sizeof(afl_info));
+
+	ret = copy_from_user((void *)&afl_info, param->property_param, sizeof(afl_info));
+	if (0 != ret) {
+		printk("isp_k_anti_flicker_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM0, BIT_0, afl_info.bypass);
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM0, BIT_1, afl_info.mode << 1);
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM0, 0xF << 2, afl_info.skip_frame_num << 2);
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM1, 0xF , afl_info.line_step);
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM1, 0xFF << 8, afl_info.frame_num << 8);
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM1, 0xFFFF << 16, afl_info.vheight << 16);
+
+	REG_MWR(ISP_ANTI_FLICKER_COL_POS, 0xFFFF , afl_info.start_col);
+
+	REG_MWR(ISP_ANTI_FLICKER_COL_POS,  0xFFFF << 16, afl_info.end_col << 16);
+
+	//config afl DDR initial address
+	isp_k_afl_param_update(isp_private);
+
+	//REG_WR(ISP_ANTI_FLICKER_DDR_INIT_ADDR, afl_info.addr);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_anti_flicker(struct isp_io_param *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_anti_flicker: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_anti_flicker: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_ANTI_FLICKER_BLOCK:
+		ret = isp_k_anti_flicker_block(param, isp_private);
+		break;
+	case ISP_PRO_ANTI_FLICKER_STATISTIC:
+		ret = isp_k_afl_statistic(param, isp_private);
+		break;
+	case ISP_PRO_ANTI_FLICKER_BYPASS:
+		ret = isp_k_afl_bypass(param);
+		break;
+	default:
+		printk("isp_k_cfg_anti_flicker: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_arbiter.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_arbiter.c
new file mode 100644
index 00000000..4031b04e
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_arbiter.c
@@ -0,0 +1,177 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_arbiter_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_arbiter_info_v1 arbiter_info;
+	uint32_t val = 0;
+
+	memset(&arbiter_info, 0x00, sizeof(arbiter_info));
+
+	ret = copy_from_user((void *)&arbiter_info, param->property_param, sizeof(arbiter_info));
+	if (0 != ret) {
+		printk("isp_k_arbiter_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((arbiter_info.endian_ch0.bpc_endian & 0x3) << 8) | ((arbiter_info.endian_ch0.lens_endian & 0x3) << 6)
+		| ((arbiter_info.endian_ch0.store_endian & 0x3) << 4) | ((arbiter_info.endian_ch0.fetch_bit_reorder & 0x1) << 2)
+		| (arbiter_info.endian_ch0.fetch_endian & 0x3);
+	REG_WR(ISP_ARBITER_ENDIAN_CH0, val);
+
+	val = ((arbiter_info.endian_ch1.bpc_endian & 0x3) << 8) | ((arbiter_info.endian_ch1.lens_endian & 0x3) << 6)
+		| ((arbiter_info.endian_ch1.store_endian & 0x3) << 4) | ((arbiter_info.endian_ch1.fetch_bit_reorder & 0x1) << 2)
+		| (arbiter_info.endian_ch1.fetch_endian & 0x3);
+	REG_WR(ISP_ARBITER_ENDIAN_CH1, val);
+
+	val = (arbiter_info.para.pause_cycle & 0xFF) | ((arbiter_info.para.reset & 0x1) << 8);
+	REG_WR(ISP_ARBITER_PARAM, val);
+
+	return ret;
+}
+
+static int32_t isp_k_arbiter_wr_status(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t status = 0;
+
+	status = REG_RD(ISP_PRO_ARBITER_WR_STATUS);
+
+	ret = copy_to_user(param->property_param, (void*)&status, sizeof(status));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_arbiter_wr_status: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_arbiter_rd_status(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t status = 0;
+
+	status = REG_RD(ISP_PRO_ARBITER_RD_STATUS);
+
+	ret = copy_to_user(param->property_param, (void*)&status, sizeof(status));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_arbiter_rd_status: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_arbiter_endian_ch0(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct arbiter_endian_v1 endian = {0};
+
+	ret = copy_from_user((void *)&endian, param->property_param, sizeof(endian));
+	if (0 != ret) {
+		printk("isp_k_arbiter_endian_ch0: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((endian.bpc_endian & 0x3) << 8) | ((endian.lens_endian & 0x3) << 6) | ((endian.store_endian & 0x3) << 4)
+		| ((endian.fetch_bit_reorder & 0x1) << 2) | (endian.fetch_endian & 0x3);
+	REG_WR(ISP_ARBITER_ENDIAN_CH0, val);
+
+	return ret;
+}
+
+static int32_t isp_k_arbiter_endian_ch1(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct arbiter_endian_v1 endian = {0};
+
+	ret = copy_from_user((void *)&endian, param->property_param, sizeof(endian));
+	if (0 != ret) {
+		printk("isp_k_arbiter_endian_ch1: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((endian.bpc_endian & 0x3) << 8) | ((endian.lens_endian & 0x3) << 6) | ((endian.store_endian & 0x3) << 4)
+		| ((endian.fetch_bit_reorder & 0x1) << 2) | (endian.fetch_endian & 0x3);
+	REG_WR(ISP_ARBITER_ENDIAN_CH1, val);
+
+	return ret;
+}
+
+static int32_t isp_k_arbiter_param(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct arbiter_param_v1 para = {0};
+
+	ret = copy_from_user((void *)&para, param->property_param, sizeof(para));
+	if (0 != ret) {
+		printk("isp_k_arbiter_param: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (para.pause_cycle & 0xFF) | ((para.reset & 0x1) << 8);
+	REG_WR(ISP_ARBITER_PARAM, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_arbiter(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_arbiter: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_arbiter: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_ARBITER_BLOCK:
+		ret = isp_k_arbiter_block(param);
+		break;
+	case ISP_PRO_ARBITER_WR_STATUS:
+		ret = isp_k_arbiter_wr_status(param);
+		break;
+	case ISP_PRO_ARBITER_RD_STATUS:
+		ret = isp_k_arbiter_rd_status(param);
+		break;
+	case ISP_PRO_ARBITER_PARAM:
+		ret = isp_k_arbiter_param(param);
+		break;
+	case ISP_PRO_ARBITER_ENDIAN_CH0:
+		ret = isp_k_arbiter_endian_ch0(param);
+		break;
+	case ISP_PRO_ARBITER_ENDIAN_CH1:
+		ret = isp_k_arbiter_endian_ch1(param);
+		break;
+	default:
+		printk("isp_k_cfg_arbiter: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_awb.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_awb.c
new file mode 100644
index 00000000..3d9706b4
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_awb.c
@@ -0,0 +1,191 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+static int32_t isp_k_awb_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	struct isp_dev_awb_info_v2 awb_info;
+
+	ret = copy_from_user((void *)&awb_info, param->property_param, sizeof(awb_info));
+	if (0 != ret) {
+		printk("isp_k_awbm_bypass: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	//printk("isp_k_awb_block: %d  %d  %d  %d \n",awb_info.slice_size.width,awb_info.slice_size.height,awb_info.block_size.width,awb_info.block_size.height);
+	//printk("isp_k_awb_block: gain r=%d  gr=%d  b=%d \n",awb_info.gain.r,awb_info.gain.gr,awb_info.gain.b);
+	//printk("isp_k_awb_block: offset r=%d  gr=%d  b=%d  \n",awb_info.gain_offset.r,awb_info.gain_offset.gr,awb_info.gain_offset.b);
+	/*AWBM*/
+
+	REG_MWR(ISP_AWBM_PARAM, BIT_0, awb_info.awbm_bypass);
+
+	REG_MWR(ISP_AWBM_PARAM, BIT_1, awb_info.mode << 1);
+
+	val = (awb_info.skip_num & 0x0F) << 2;
+	REG_MWR(ISP_AWBM_PARAM, (BIT_5 | BIT_4 | BIT_3 | BIT_2), val);
+
+	val = ((awb_info.block_offset.y & 0xFFFF) << 16) | (awb_info.block_offset.x & 0xFFFF);
+	REG_WR(ISP_AWBM_BLOCK_OFFSET, val);
+
+	val = ((awb_info.block_size.height & 0x1FF) << 9) | (awb_info.block_size.width & 0x1FF);
+	REG_MWR(ISP_AWBM_BLOCK_SIZE, 0x1FFFF, val);
+
+	val = (awb_info.shift & 0x1F) << 18;
+	REG_MWR(ISP_AWBM_BLOCK_SIZE, (0x1F << 18), val);
+
+	REG_MWR(ISP_AWBM_PARAM, BIT_8, awb_info.thr_bypass << 8);
+
+	for (i = 0; i < 5; i++) {
+		val = ((awb_info.rect_pos.start_x[i] & 0x3FF) << 16) | (awb_info.rect_pos.start_y[i] & 0x3FF);
+		REG_WR(ISP_AWBM_WR_0_S + i * 8, val);
+		val = ((awb_info.rect_pos.end_x[i] & 0x3FF) << 16) | (awb_info.rect_pos.end_y[i] & 0x3FF);
+		REG_WR(ISP_AWBM_WR_0_E + i * 8, val);
+	}
+
+	for (i = 0; i < 5; i++) {
+		val = ((awb_info.circle_pos.x[i] & 0x3FF) << 18) | ((awb_info.circle_pos.y[i] & 0x3FF) << 8) | (awb_info.circle_pos.r[i] & 0xFF);
+		REG_WR(ISP_AWBM_NW_0_XYR + i * 4, val);
+	}
+
+	for (i = 0; i < 5; i++) {
+		val = ((awb_info.clctor_pos.start_x[i] & 0x3FF) << 16) | (awb_info.clctor_pos.start_y[i] & 0x3FF);
+		REG_WR(ISP_AWBM_CLCTOR_0_S + i * 8, val);
+		val = ((awb_info.clctor_pos.end_x[i] & 0x3FF) << 16) | (awb_info.clctor_pos.end_y[i] & 0x3FF);
+		REG_WR(ISP_AWBM_CLCTOR_0_E + i * 8, val);
+	}
+
+	val = ((awb_info.thr.g_low & 0x3FF) << 20) | ((awb_info.thr.r_high & 0x3FF) << 10) | (awb_info.thr.r_low & 0x3FF);
+	REG_WR(ISP_AWBM_THR_VALUE1, val);
+	val = ((awb_info.thr.b_high & 0x3FF) << 20) | ((awb_info.thr.b_low & 0x3FF) << 10) | (awb_info.thr.g_high & 0x3FF);
+	REG_WR(ISP_AWBM_THR_VALUE2, val);
+
+//	val = ((awb_info.slice_size.height & 0xFFFF) << 16) | (awb_info.slice_size.width & 0xFFFF);
+//	REG_WR(ISP_AEM_SLICE_SIZE, val);
+
+	REG_MWR(ISP_AWBM_PARAM, BIT_6, awb_info.skip_num_clear << 6);
+	REG_MWR(ISP_AWBM_POSITION_SEL, BIT_0, awb_info.position_sel);
+
+	REG_WR(ISP_AWBM_MEM_ADDR, awb_info.mem_addr);
+
+	/*AWBC*/
+
+	REG_MWR(ISP_AWBC_PARAM, BIT_0, awb_info.awbc_bypass);
+
+	REG_MWR(ISP_AWBC_PARAM, BIT_1, awb_info.alpha_bypass << 1);
+
+	val = (awb_info.alpha_value & 0x3FF) << 4;
+	REG_MWR(ISP_AWBC_PARAM, 0x3FF0, val);
+
+	REG_MWR(ISP_AWBC_PARAM, BIT_3, awb_info.buf_sel << 3);
+
+	val = ((awb_info.gain.b & 0x3FFF) << 16) | (awb_info.gain.r & 0x3FFF);
+	REG_WR(ISP_AWBC_GAIN0, val);
+	val = ((awb_info.gain.gb & 0x3FFF) << 16) | (awb_info.gain.gr & 0x3FFF);
+	REG_WR(ISP_AWBC_GAIN1, val);
+
+	val = ((awb_info.thrd.b & 0x3FF) << 20) | ((awb_info.thrd.g & 0x3FF) << 10) | (awb_info.thrd.r & 0x3FF);
+	REG_WR(ISP_AWBC_THRD, val);
+
+	val = ((awb_info.gain_offset.b & 0xFFFF) << 16) | (awb_info.gain_offset.r & 0xFFFF);
+	REG_WR(ISP_AWBC_OFFSET0, val);
+	val = ((awb_info.gain_offset.gb & 0xFFFF) << 16) | (awb_info.gain_offset.gr & 0xFFFF);
+	REG_WR(ISP_AWBC_OFFSET1, val);
+
+	val = ((awb_info.gain_buff.b & 0x3FFF) << 16) | (awb_info.gain_buff.r & 0x3FFF);
+	REG_WR(ISP_AWBC_GAIN0_BUF, val);
+	val = ((awb_info.gain_buff.gb & 0x3FFF) << 16) | (awb_info.gain_buff.gr & 0x3FFF);
+	REG_WR(ISP_AWBC_GAIN1_BUF, val);
+
+	val = ((awb_info.gain_offset_buff.b & 0xFFFF) << 16) | (awb_info.gain_offset_buff.r & 0xFFFF);
+	REG_WR(ISP_AWBC_OFFSET0_BUF, val);
+	val = ((awb_info.gain_offset_buff.gb & 0xFFFF) << 16) | (awb_info.gain_offset_buff.gr & 0xFFFF);
+	REG_WR(ISP_AWBC_OFFSET1_BUF, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_awb_statistics(struct isp_io_param *param,
+	struct isp_k_private *isp_private)
+{
+	int32_t ret = 0, i = 0;
+	unsigned long addr = 0;
+	struct isp_raw_awbm_statistics *awbm_statistics = NULL;
+
+	awbm_statistics = (struct isp_raw_awbm_statistics *)isp_private->raw_awbm_buf_addr;
+	if (!awbm_statistics) {
+		ret = -1;
+		printk("isp_k_raw_awb_statistics: alloc memory error.\n");
+		return -1;
+	}
+
+	addr = ISP_RAW_AWBM_OUTPUT;
+
+	for (i = 0x00; i < ISP_RAW_AWBM_ITEM; i++) {
+		(awbm_statistics + i)->num4 = REG_RD(addr) >> 16;
+		(awbm_statistics + i)->num_t = REG_RD(addr) & 0xffff;
+		(awbm_statistics + i)->num2 = REG_RD(addr + 4) >> 16;
+		(awbm_statistics + i)->num3 = REG_RD(addr + 4) & 0xffff;
+		(awbm_statistics + i)->num0 = REG_RD(addr + 8) >> 16;
+		(awbm_statistics + i)->num1 = REG_RD(addr + 8) & 0xffff;
+		(awbm_statistics + i)->block_b = REG_RD(addr + 12);
+		(awbm_statistics + i)->block_g = REG_RD(addr + 16);
+		(awbm_statistics + i)->block_r = REG_RD(addr + 20);
+		addr += 32;
+	}
+
+	ret = copy_to_user(param->property_param, (void*)awbm_statistics, sizeof(struct isp_raw_awbm_statistics) * ISP_RAW_AWBM_ITEM);
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_raw_awb_statistics: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_awb(struct isp_io_param *param,
+	struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_awb: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_awb: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_AWB_BLOCK:
+		ret = isp_k_awb_block(param);
+		break;
+	case ISP_PRO_AWBM_STATISTICS:
+		ret = isp_k_raw_awb_statistics(param, isp_private);
+		break;
+	default:
+		printk("isp_k_cfg_awb: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_bdn.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_bdn.c
new file mode 100644
index 00000000..9589b8c3
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_bdn.c
@@ -0,0 +1,121 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_bdn_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	uint32_t j = 0;
+	struct isp_dev_bdn_info_v1 bdn_info;
+
+	memset(&bdn_info, 0x00, sizeof(bdn_info));
+
+	ret = copy_from_user((void *)&bdn_info, param->property_param, sizeof(bdn_info));
+	if (0 != ret) {
+		printk("isp_k_bdn_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_BDN_PARAM, BIT_1, bdn_info.radial_bypass << 1);
+
+	REG_MWR(ISP_BDN_PARAM, 0x7F0, bdn_info.addback << 4);
+
+	for (i = 0; i < 10; i++) {
+		REG_WR(ISP_BDN_DISWEI0_0 + 40 * i, bdn_info.dis[i][0]);
+
+		REG_WR(ISP_BDN_DISWEI0_1 + 40 * i, bdn_info.dis[i][1]);
+	}
+
+	for (i = 0; i < 10; i++) {
+		for (j = 0; j < 7; j++) {
+			REG_WR(ISP_BDN_RANWEI0_0 + i * 40 + j * 4, bdn_info.ran[i][j]);
+		}
+
+		REG_WR(ISP_BDN_RANWEI0_7 + i * 40, bdn_info.ran[i][7]);
+	}
+
+	val = ((bdn_info.offset_x & 0x1FFF) << 12) | (bdn_info.offset_y & 0xFFF);
+	REG_WR(ISP_BDN_1DLNC_CENTER, val);
+
+	val = bdn_info.squ_x2 & 0x3FFFFFF;
+	REG_WR(ISP_BDN_1DLNC_SQUARE_X, val);
+	val = bdn_info.squ_y2 & 0xFFFFFF;
+	REG_WR(ISP_BDN_1DLNC_SQUARE_Y, val);
+
+	val = ((bdn_info.coef2 & 0xFFFF) << 11) | (bdn_info.coef & 0x7FF);
+	REG_WR(ISP_BDN_1DLNC_P, val);
+
+	val = ((bdn_info.start_pos_x & 0x1FFF) << 12) | (bdn_info.start_pos_y & 0xFFF);
+	REG_WR(ISP_BDN_1DLNC_POS, val);
+
+	REG_WR(ISP_BDN_1DLNC_OFFSET, bdn_info.offset & 0x3FFFFFF);
+
+	REG_MWR(ISP_BDN_PARAM, BIT_0, bdn_info.bypass);
+
+	return ret;
+
+}
+
+static int32_t isp_k_bdn_1d_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size = {0, 0};
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_bdn_1d_slice_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.width & 0x1FFF) << 12) | (size.height & 0xFFF);
+	REG_WR(ISP_BDN_1DLNC_SIZE, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_bdn(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_bdn: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_bdn: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_BDN_BLOCK:
+		ret = isp_k_bdn_block(param);
+		break;
+	case ISP_PRO_BDN_SLICE_SIZE:
+		ret = isp_k_bdn_1d_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_bdn: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_binning4awb.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_binning4awb.c
new file mode 100644
index 00000000..86778075
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_binning4awb.c
@@ -0,0 +1,231 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include <asm/cacheflush.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+static int32_t isp_k_binging_param_update(struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	/*config buf_id 0 as default*/
+	isp_private->b4awb_buf[0].buf_flag = 1;
+	REG_WR(ISP_BINNING_MEM_ADDR, isp_private->b4awb_buf[0].buf_phys_addr);
+
+	return ret;
+}
+
+static int32_t isp_k_binning_block(struct isp_io_param *param,
+			struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_binning4awb_info_v1 binning_info;
+
+	ret = copy_from_user((void *)&binning_info, param->property_param, sizeof(binning_info));
+	if (0 != ret) {
+		printk("isp_k_binning_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (isp_private->b4awb_buf[0].buf_phys_addr == 0 || isp_private->b4awb_buf[1].buf_phys_addr == 0) {
+		REG_MWR(ISP_BINNING_PARAM, BIT_0, 0x1);
+		return ret;
+	}
+
+	isp_k_binging_param_update(isp_private);
+
+	val = (binning_info.burst_mode & 0x3) << 2;
+	REG_MWR(ISP_BINNING_PARAM, 0xC, val);
+
+	val = (binning_info.endian & 0x1) << 1;
+	REG_MWR(ISP_BINNING_PARAM, BIT_1, val);
+
+	val = (binning_info.mem_fifo_clr & 0x1) << 7;
+	REG_MWR(ISP_BINNING_PARAM, 0x80, val);
+
+	val = ((binning_info.hx & 0x7) << 4) | ((binning_info.vx & 0x7) << 8);
+	REG_MWR(ISP_BINNING_PARAM, 0x770, val);
+
+	REG_WR(ISP_BINNING_PITCH, binning_info.pitch);
+
+	REG_MWR(ISP_BINNING_PARAM, BIT_0, binning_info.bypass);
+
+	return ret;
+
+}
+
+static int32_t isp_k_binging_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_binning_scaling_ratio: copy_from_user error, ret = 0x%x\n",(uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_BINNING_PARAM, BIT_0, bypass);
+
+	return ret;
+}
+
+static int32_t isp_k_binning_scaling_ratio(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_scaling_ratio scaling_ratio;
+	ret = copy_from_user((void *)&scaling_ratio, param->property_param, sizeof(struct isp_scaling_ratio));
+	if (0 != ret) {
+		printk("isp_k_binning_scaling_ratio: copy_from_user error, ret = 0x%x\n",(uint32_t)ret);
+		return -1;
+	}
+
+	val = ((scaling_ratio.vertical & 0x7)<< 8)| ((scaling_ratio.horizontal & 0x7) << 4);
+	REG_MWR(ISP_BINNING_PARAM, 0x770, val);
+
+	return ret;
+}
+
+static int32_t isp_k_binning_get_scaling_ratio(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_scaling_ratio scaling_ratio;
+
+	val = REG_RD(ISP_BINNING_PARAM);
+
+	scaling_ratio.vertical= (val >> 8) & 0x7;
+	scaling_ratio.horizontal = (val >> 4) & 0x7;
+
+	ret = copy_to_user(param->property_param, (void *)&scaling_ratio, sizeof(struct isp_scaling_ratio));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_binning_get_scaling_ratio: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_binging_mem_addr(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t addr = 0;
+
+	ret = copy_from_user((void *)&addr, param->property_param, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_binning_scaling_ratio: copy_from_user error, ret = 0x%x\n",(uint32_t)ret);
+		return -1;
+	}
+
+	REG_WR(ISP_BINNING_MEM_ADDR, addr);
+
+	return ret;
+}
+
+static int32_t isp_k_binning_statistics_buf(struct isp_io_param *param,
+			struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t buf_id = 0;
+
+	if (isp_private->b4awb_buf[0].buf_flag == 0) {
+		buf_id = isp_private->b4awb_buf[0].buf_id;
+	} else if (isp_private->b4awb_buf[1].buf_flag == 0) {
+		buf_id = isp_private->b4awb_buf[0].buf_id;
+	}
+
+	ret = copy_to_user(param->property_param, (void*)&buf_id, sizeof(uint32_t));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_binning_statistics_buf: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_binning_buffaddr(struct isp_io_param *param,
+			struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	int32_t i = 0;
+	unsigned long phys_addr[2];
+	struct isp_b4awb_phys phy_addr;
+
+	ret = copy_from_user((void *)&phy_addr, param->property_param, sizeof(struct isp_b4awb_phys));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_binning_buffaddr: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	phys_addr[0] = phy_addr.phys0;
+	phys_addr[1] = phy_addr.phys1;
+
+	for (i = 0; i < ISP_BING4AWB_NUM; i++) {
+		isp_private->b4awb_buf[i].buf_id = i;
+		isp_private->b4awb_buf[i].buf_flag = 0;
+		isp_private->b4awb_buf[i].buf_phys_addr = phys_addr[i];
+	}
+
+	printk("phys_addr 0x%lx, 0x%lx\n",phys_addr[0], phys_addr[1]);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_binning(struct isp_io_param *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_binning: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_binning: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_BINNING4AWB_BLOCK:
+		ret = isp_k_binning_block(param, isp_private);
+		break;
+	case ISP_PRO_BINNING4AWB_BYPASS:
+		ret = isp_k_binging_bypass(param);
+		break;
+	case ISP_PRO_BINNING4AWB_SCALING_RATIO:
+		ret = isp_k_binning_scaling_ratio(param);
+		break;
+	case ISP_PRO_BINNING4AWB_GET_SCALING_RATIO:
+		ret = isp_k_binning_get_scaling_ratio(param);
+		break;
+	case ISP_PRO_BINNING4AWB_MEM_ADDR:
+		ret = isp_k_binging_mem_addr(param);
+		break;
+	case ISP_PRO_BINNING4AWB_STATISTICS_BUF:
+		ret = isp_k_binning_statistics_buf(param, isp_private);
+		break;
+	case ISP_PRO_BINNING4AWB_TRANSADDR:
+		ret = isp_k_binning_buffaddr(param, isp_private);
+		break;
+	default:
+		printk("isp_k_cfg_binning: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_blc.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_blc.c
new file mode 100644
index 00000000..af18c2a7
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_blc.c
@@ -0,0 +1,66 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_blc_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_blc_info blc_info;
+
+	ret = copy_from_user((void *)&blc_info, param->property_param, sizeof(blc_info));
+	if (0 != ret) {
+		printk("isp_k_blc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((blc_info.b & 0x3FF) << 10) | (blc_info.r & 0x3FF);
+	REG_WR(ISP_BLC_B_PARAM_R_B, val);
+	val = ((blc_info.gb & 0x3FF) << 10) | (blc_info.gr & 0x3FF);
+	REG_WR(ISP_BLC_B_PARAM_G, val);
+
+	REG_MWR(ISP_BLC_PARAM, BIT_0, blc_info.bypass);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_blc(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_blc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_blc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_BLC_BLOCK:
+		ret = isp_k_blc_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_blc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_bpc.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_bpc.c
new file mode 100644
index 00000000..29248946
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_bpc.c
@@ -0,0 +1,101 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_bpc_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	struct isp_dev_bpc_info_v1 bpc_info;
+
+	memset(&bpc_info, 0x00, sizeof(bpc_info));
+
+	ret = copy_from_user((void *)&bpc_info, param->property_param, sizeof(bpc_info));
+	if (0 != ret) {
+		printk("isp_k_bpc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_BPC_PARAM, BIT_0, bpc_info.bypass);
+
+	REG_MWR(ISP_BPC_PARAM, BIT_1, bpc_info.pvd_bypass << 1);
+
+	REG_MWR(ISP_BPC_PARAM, BIT_4 | BIT_5, bpc_info.bpc_mode << 4);
+
+	REG_MWR(ISP_BPC_PARAM, BIT_10 | BIT_9 | BIT_8, bpc_info.mask_mode << 8);
+
+	val = ((bpc_info.kmax & 0x7) << 20) | ((bpc_info.kmin & 0x7) << 16);
+	REG_MWR(ISP_BPC_PARAM, 0x770000, val);
+
+	REG_MWR(ISP_BPC_NEW_OLD_SEL, BIT_0, bpc_info.new_old_sel);
+
+	REG_MWR(ISP_BPC_NEW_OLD_SEL, BIT_1, bpc_info.map_done_sel << 1);
+
+	val = ((bpc_info.safe_factor & 0x1F) << 4) | (bpc_info.flat_factor & 0x7);
+	REG_WR(ISP_BPC_FACTOR, val);
+
+	val = ((bpc_info.dead_coeff & 0x7) << 4) | (bpc_info.spike_coeff & 0x7);
+	REG_WR(ISP_BPC_COEFF, val);
+
+	for (i = 0; i < 8; i++) {
+		val = ((bpc_info.lut_level[i] & 0x3FF) << 20) | ((bpc_info.slope_k[i] & 0x3FF) << 10) | (bpc_info.intercept_b[i] & 0x3FF);
+		REG_WR(ISP_BPC_LUTWORD0 + i * 4, val);
+	}
+
+	REG_MWR(ISP_BPC_CFG, BIT_10 | BIT_9 | BIT_8, bpc_info.delta << 8);
+
+	REG_MWR(ISP_BPC_CFG, BIT_7, bpc_info.bpc_map_fifo_clr << 7);
+
+	REG_MWR(ISP_BPC_CFG, BIT_6 | BIT_5 | BIT_4, bpc_info.ktimes << 4);
+
+	REG_MWR(ISP_BPC_CFG, 0x7, bpc_info.cntr_threshold);
+
+	REG_MWR(ISP_BPC_CFG, BIT_3, bpc_info.bad_map_hw_fifo_clr_en << 3);
+
+	REG_WR(ISP_BPC_MAP_ADDR, bpc_info.bpc_map_addr_new);
+
+	REG_MWR(ISP_BPC_CFG, 0xFFFF0000, bpc_info.bad_pixel_num << 16);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_bpc(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_bpc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_bpc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_BPC_BLOCK:
+		ret = isp_k_bpc_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_bpc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_brightness.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_brightness.c
new file mode 100644
index 00000000..4c649621
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_brightness.c
@@ -0,0 +1,67 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_brightness_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_brightness_info brightness_info;
+
+	memset(&brightness_info, 0x00, sizeof(brightness_info));
+
+	ret = copy_from_user((void *)&brightness_info, param->property_param, sizeof(brightness_info));
+	if (0 != ret) {
+		printk("isp_k_brightness_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_BRIGHT_PARAM, 0x1FE, ((brightness_info.factor & 0xFF) << 1));
+
+	if (brightness_info.bypass) {
+		REG_OWR(ISP_BRIGHT_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_BRIGHT_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_brightness(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_brightness: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_brightness: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_BRIGHT_BLOCK:
+		ret = isp_k_brightness_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_brightness: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_capability.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_capability.c
new file mode 100644
index 00000000..d5ce492d
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_capability.c
@@ -0,0 +1,195 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+#define ISP_MAX_WIDTH             3280
+#define ISP_MAX_HEIGHT            2464
+#define ISP_MAX_SLICE_WIDTH       3280
+#define ISP_MAX_SLICE_HEIGHT      2464
+#define ISP_AWB_WIN_UNIT          32
+#define ISP_AWB_DEFAULT_GAIN      0x400
+#define ISP_AF_MAX_WIN_NUM        9
+
+static int32_t isp_k_capability_chip_id(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	uint32_t chip_id = 0;
+
+	chip_id = ISP_CHIP_ID_PIKE;
+
+	ret = copy_to_user(param->property_param, (void*)&chip_id, sizeof(chip_id));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_capability_chip_id: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_single_size(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size = {0, 0};
+
+	size.width = ISP_MAX_WIDTH;
+	size.height = ISP_MAX_HEIGHT;
+
+	ret = copy_to_user(param->property_param, (void*)&size, sizeof(size));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_capability_single_size: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_continue_size(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size = {0, 0};
+
+	size.width = ISP_MAX_SLICE_WIDTH;
+	size.height = ISP_MAX_SLICE_HEIGHT;
+
+	ret = copy_to_user(param->property_param, (void*)&size, sizeof(size));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_capability_continue_size: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_awb_win(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size = {0, 0};
+
+	size.width = ISP_AWB_WIN_UNIT;
+	size.height = ISP_AWB_WIN_UNIT;
+
+	ret = copy_to_user(param->property_param, (void*)&size, sizeof(size));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_capability_awb_win: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_awb_default_gain(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	uint32_t gain = 0;
+
+	gain = ISP_AWB_DEFAULT_GAIN;
+
+	ret = copy_to_user(param->property_param, (void*)&gain, sizeof(gain));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_capability_awb_default_gain: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_af_max_win_num(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	uint32_t win_num = 0;
+
+	win_num = ISP_AF_MAX_WIN_NUM;
+
+	ret = copy_to_user(param->property_param, (void*)&win_num, sizeof(win_num));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_capability_af_max_win_num: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_time(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	struct isp_time time;
+	struct timespec ts;
+
+	ktime_get_ts(&ts);
+	time.sec = ts.tv_sec;
+	time.usec = ts.tv_nsec / NSEC_PER_USEC;
+
+	ret = copy_to_user(param->property_param, (void*)&time, sizeof(time));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_capability_time: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+int32_t isp_capability(void *param)
+{
+	int32_t ret = 0;
+	struct isp_capability cap_param = {0, 0, NULL};
+
+	if (!param) {
+		printk("isp_capability: param is null error.\n");
+		return -1;
+	}
+
+	ret = copy_from_user((void *)&cap_param, (void*)param, sizeof(cap_param));
+	if ( 0 != ret) {
+		printk("isp_capability: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (NULL == cap_param.property_param) {
+		printk("isp_capability: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(cap_param.index) {
+	case ISP_CAPABILITY_CHIP_ID:
+		ret = isp_k_capability_chip_id(&cap_param);
+		break;
+	case ISP_CAPABILITY_SINGLE_SIZE:
+		ret = isp_k_capability_single_size(&cap_param);
+		break;
+	case ISP_CAPABILITY_CONTINE_SIZE:
+		ret = isp_k_capability_continue_size(&cap_param);
+		break;
+	case ISP_CAPABILITY_AWB_WIN:
+		ret = isp_k_capability_awb_win(&cap_param);
+		break;
+	case ISP_CAPABILITY_AWB_DEFAULT_GAIN:
+		ret = isp_k_capability_awb_default_gain(&cap_param);
+		break;
+	case ISP_CAPABILITY_AF_MAX_WIN_NUM:
+		ret = isp_k_capability_af_max_win_num(&cap_param);
+		break;
+	case ISP_CAPABILITY_TIME:
+		ret = isp_k_capability_time(&cap_param);
+		break;
+	default:
+		printk("isp_capability: fail cmd id:%d, not supported.\n", cap_param.index);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cce.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cce.c
new file mode 100644
index 00000000..06a84ab9
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cce.c
@@ -0,0 +1,147 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_cce_block_uv(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_cce_uvd_info cce_uvd_info;
+
+	memset(&cce_uvd_info, 0x00, sizeof(cce_uvd_info));
+
+	ret = copy_from_user((void *)&cce_uvd_info, param->property_param, sizeof(cce_uvd_info));
+	if (0 != ret) {
+		printk("isp_k_cce_block_uv: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (cce_uvd_info.lum_th_h_len & 0xF)
+		| ((cce_uvd_info.lum_th_h & 0xFF) << 8)
+		| ((cce_uvd_info.lum_th_l_len & 0xF) << 16)
+		| ((cce_uvd_info.lum_th_l & 0xFF) << 24);
+	REG_WR(ISP_CCE_UVD_PARAM0, val);
+
+	val = (cce_uvd_info.chroma_min_h & 0xFF)
+		| ((cce_uvd_info.chroma_min_l & 0xFF) << 8)
+		| ((cce_uvd_info.chroma_max_h & 0xFF) << 16)
+		| ((cce_uvd_info.chroma_max_l & 0xFF) << 24);
+	REG_WR(ISP_CCE_UVD_PARAM1, val);
+
+	val = (cce_uvd_info.u_th1_h & 0xFF)
+		| ((cce_uvd_info.u_th1_l & 0xFF) << 8)
+		| ((cce_uvd_info.u_th0_h & 0xFF) << 16)
+		| ((cce_uvd_info.u_th0_l & 0xFF) << 24);
+	REG_WR(ISP_CCE_UVD_PARAM2, val);
+
+	val = (cce_uvd_info.v_th1_h & 0xFF)
+		| ((cce_uvd_info.v_th1_l & 0xFF) << 8)
+		| ((cce_uvd_info.v_th0_h & 0xFF) << 16)
+		| ((cce_uvd_info.v_th0_l & 0xFF) << 24);
+	REG_WR(ISP_CCE_UVD_PARAM3, val);
+
+	val = (cce_uvd_info.ratio[7] & 0xF)
+		| ((cce_uvd_info.ratio[6] & 0xF) << 4)
+		| ((cce_uvd_info.ratio[5] & 0xF) << 8)
+		| ((cce_uvd_info.ratio[4] & 0xF) << 12)
+		| ((cce_uvd_info.ratio[3] & 0xF) << 16)
+		| ((cce_uvd_info.ratio[2] & 0xF) << 20)
+		| ((cce_uvd_info.ratio[1] & 0xF) << 24)
+		| ((cce_uvd_info.ratio[0] & 0xF) << 28);
+	REG_WR(ISP_CCE_UVD_PARAM4, val);
+
+	val = (cce_uvd_info.base & 0xF)
+		| ((cce_uvd_info.ratio[8] & 0xF) << 8);
+	REG_WR(ISP_CCE_UVD_PARAM5, val);
+
+	REG_MWR(ISP_CCE_PARAM, BIT_0, cce_uvd_info.uvdiv_bypass);
+
+	return ret;
+}
+
+static int32_t isp_k_cce_block_matrix(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t val1 = 0;
+	struct isp_dev_cce_info_v1 cce_info;
+
+	memset(&cce_info, 0x00, sizeof(cce_info));
+
+	ret = copy_from_user((void *)&cce_info, param->property_param, sizeof(cce_info));
+	if (0 != ret) {
+		printk("isp_k_cce_block_matrix: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((cce_info.matrix[1] & 0x7FF) << 11) | (cce_info.matrix[0] & 0x7FF);
+	val1 = ((cce_info.matrix[3] & 0x7FF) << 11) | (cce_info.matrix[2] & 0x7FF);
+	if ((0 == val)
+		|| (0 == val1)) {
+		printk("isp_k_cce_block_matrix: copy error, 0x%x, 0x%x, 0x%x, 0x%x\n", cce_info.matrix[0], cce_info.matrix[1], cce_info.matrix[2], cce_info.matrix[3]);
+		return ret;
+	}
+
+	REG_MWR(ISP_CCE_PARAM, BIT_1, cce_info.mode << 1);
+
+	val = ((cce_info.matrix[1] & 0x7FF) << 11) | (cce_info.matrix[0] & 0x7FF);
+	REG_WR(ISP_CCE_MATRIX0, val);
+	val = ((cce_info.matrix[3] & 0x7FF) << 11) | (cce_info.matrix[2] & 0x7FF);
+	REG_WR(ISP_CCE_MATRIX1, val);
+	val = ((cce_info.matrix[5] & 0x7FF) << 11) | (cce_info.matrix[4] & 0x7FF);
+	REG_WR(ISP_CCE_MATRIX2, val);
+	val = ((cce_info.matrix[7] & 0x7FF) << 11) | (cce_info.matrix[6] & 0x7FF);
+	REG_WR(ISP_CCE_MATRIX3, val);
+	val = cce_info.matrix[8] & 0x7FF;
+	REG_WR(ISP_CCE_MATRIX4, val);
+
+	val = (cce_info.y_offset & 0x1FF) | ((cce_info.u_offset & 0x1FF) << 9)
+		| ((cce_info.v_offset & 0x1FF) << 18);
+	REG_WR(ISP_CCE_SHIFT, (val & 0x7FFFFFF));
+
+	return ret;
+}
+
+int32_t isp_k_cfg_cce(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_cce: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_cce: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CCE_BLOCK_MATRIX:
+		ret = isp_k_cce_block_matrix(param);
+		break;
+	case ISP_PRO_CCE_BLOCK_UV:
+		ret = isp_k_cce_block_uv(param);
+		break;
+	default:
+		printk("isp_k_cfg_cce: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cdn.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cdn.c
new file mode 100644
index 00000000..e8b8e716
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cdn.c
@@ -0,0 +1,109 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_yuv_cdn_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_yuv_cdn_info cdn_info;
+	uint32_t val = 0;
+	uint32_t i = 0;
+
+	memset(&cdn_info, 0x00, sizeof(cdn_info));
+
+	ret = copy_from_user((void *)&cdn_info, param->property_param, sizeof(cdn_info));
+	if (0 != ret) {
+		printk("isp_k_yuv_cdn_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (cdn_info.median_writeback_en) {
+		REG_OWR(ISP_CDN_PARAM, BIT_2);
+	} else {
+		REG_MWR(ISP_CDN_PARAM, BIT_2, 0);
+	}
+
+	REG_MWR(ISP_CDN_PARAM, 0x38, cdn_info.median_mode << 3);
+
+	REG_MWR(ISP_CDN_PARAM, BIT_7 | BIT_6, cdn_info.gaussian_mode << 6);
+
+	REG_MWR(ISP_CDN_PARAM, 0x3FFF00, cdn_info.median_thr << 8);
+
+	val = (cdn_info.median_thru0 & 0x7F) | ((cdn_info.median_thru1 & 0xFF) << 8)
+		| ((cdn_info.median_thrv0 & 0x7F) << 16) | ((cdn_info.median_thrv1 & 0xFF) << 24);
+	REG_WR(ISP_CDN_THRUV, val);
+
+	for (i = 0; i < 7; i++) {
+		val = (cdn_info.rangewu[i*4] & 0x3F) | ((cdn_info.rangewu[i*4+1] & 0x3F) << 8)
+			| ((cdn_info.rangewu[i*4+2] & 0x3F) << 16) | ((cdn_info.rangewu[i*4+3] & 0x3F) << 24);
+		REG_WR(ISP_CDN_U_RANWEI_0 + i * 4, val);
+	}
+
+	val = (cdn_info.rangewu[28] & 0x3F) | ((cdn_info.rangewu[29] & 0x3F) << 8)
+		| ((cdn_info.rangewu[30] & 0x3F) << 16);
+	REG_WR(ISP_CDN_U_RANWEI_7, val);
+
+	for (i = 0; i < 7; i++) {
+		val = (cdn_info.rangewv[i*4] & 0x3F) | ((cdn_info.rangewv[i*4+1] & 0x3F) << 8)
+			| ((cdn_info.rangewv[i*4+2] & 0x3F) << 16) | ((cdn_info.rangewv[i*4+3] & 0x3F) << 24);
+		REG_WR(ISP_CDN_V_RANWEI_0 + i * 4, val);
+	}
+
+	val = (cdn_info.rangewv[28] & 0x3F) | ((cdn_info.rangewv[29] & 0x3F) << 8)
+		| ((cdn_info.rangewv[30] & 0x3F) << 16);
+	REG_WR(ISP_CDN_V_RANWEI_7, val);
+
+	if (cdn_info.filter_bypass) {
+		REG_OWR(ISP_CDN_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_CDN_PARAM, BIT_1, 0);
+	}
+
+	if (cdn_info.bypass) {
+		REG_OWR(ISP_CDN_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_CDN_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_yuv_cdn(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_yuv_cdn: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_yuv_cdn: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_YUV_CDN_BLOCK:
+		ret = isp_k_yuv_cdn_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_yuv_cdn: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cfa.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cfa.c
new file mode 100644
index 00000000..ceeed46a
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cfa.c
@@ -0,0 +1,90 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_cfa_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_cfa_info_v1 cfa_info;
+
+	memset(&cfa_info, 0x00, sizeof(cfa_info));
+
+	ret = copy_from_user((void *)&cfa_info, param->property_param, sizeof(cfa_info));
+	if (0 != ret) {
+		printk("isp_k_cfa_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_CFAE_EE_CFG0, BIT_0, cfa_info.bypass);
+
+	REG_MWR(ISP_CFAE_EE_CFG0, 0xF<<28, cfa_info.grid_gain << 28);
+
+	REG_MWR(ISP_CFAE_EE_CFG0, 0x3<<24, cfa_info.avg_mode << 24);
+
+	REG_MWR(ISP_CFAE_EE_CFG0, 0xFFF<<12, cfa_info.gbuf_addr_max << 12);
+
+	REG_MWR(ISP_CFAE_EE_CFG0, BIT_1, cfa_info.ee_bypass << 1);
+
+	REG_MWR(ISP_CFAE_EE_CFG0, 0x3F<<4, cfa_info.doee_base << 4);
+
+	REG_MWR(ISP_CFAE_EE_CFG1, 0xF<<16, cfa_info.inter_chl_gain << 16);
+
+	val = (cfa_info.cfa_uni_dir_intplt_tr & 0xFFFF) | ((cfa_info.cfai_ee_uni_dir_tr & 0xFFFF) << 16);
+	REG_WR(ISP_CFAE_THRD_0,val);
+	val = (cfa_info.cfai_ee_edge_tr & 0xFFF) | ((cfa_info.cfai_ee_diagonal_tr & 0xFFF) << 16);
+	REG_WR(ISP_CFAE_THRD_1,val);
+	val =(cfa_info.cfai_ee_grid_tr & 0xFFF) | ((cfa_info.cfai_doee_clip_tr & 0x3F) << 12)
+		| ((cfa_info.cfai_ee_saturation_level & 0x3FF) << 22);
+	REG_WR(ISP_CFAE_THRD_2,val);
+	val = (cfa_info.plt_diff_tr & 0xFFFF) | ((cfa_info.grid_min_tr & 0xFFFF) << 16);
+	REG_WR(ISP_CFAE_THRD_3,val);
+	val = (cfa_info.strength_tr_neg & 0xFFFF) | ((cfa_info.strength_tr_pos & 0xFFFF) << 16);
+	REG_WR(ISP_CFAE_THRD_4,val);
+	REG_MWR(ISP_CFAE_EE_CFG1, 0x3F, cfa_info.ee_strength_neg);
+	REG_MWR(ISP_CFAE_EE_CFG1, 0x3F << 8, cfa_info.ee_strength_pos << 8);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_cfa(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_cfa: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_cfa: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CFA_BLOCK:
+		ret = isp_k_cfa_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_cfa: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cmc10.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cmc10.c
new file mode 100644
index 00000000..8c127c9a
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cmc10.c
@@ -0,0 +1,93 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_cmc10_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_cmc10_info cmc10_info;
+
+	memset(&cmc10_info, 0x00, sizeof(cmc10_info));
+
+	ret = copy_from_user((void *)&cmc10_info, param->property_param, sizeof(cmc10_info));
+	if (0 != ret) {
+		printk("isp_k_cmc10_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_CMC10_PARAM, BIT_0, cmc10_info.bypass);
+
+	REG_MWR(ISP_CMC10_PARAM, BIT_3, cmc10_info.buf_sel << 3);
+
+	REG_MWR(ISP_CMC10_PARAM, 0x3FF << 4, cmc10_info.alpha << 4);
+
+	REG_MWR(ISP_CMC10_PARAM, BIT_1, cmc10_info.alpha_bypass << 1);
+
+	val = ((cmc10_info.matrix.val[1] & 0x3FFF) << 14) | (cmc10_info.matrix.val[0] & 0x3FFF);
+	REG_WR(ISP_CMC10_MATRIX0, val);
+	val = ((cmc10_info.matrix.val[3] & 0x3FFF) << 14) | (cmc10_info.matrix.val[2] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0 + 4), val);
+	val = ((cmc10_info.matrix.val[5] & 0x3FFF) << 14) | (cmc10_info.matrix.val[4] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0 + 8), val);
+	val = ((cmc10_info.matrix.val[7] & 0x3FFF) << 14) | (cmc10_info.matrix.val[6] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0 + 12), val);
+	val = cmc10_info.matrix.val[8] & 0x3FFF;
+	REG_WR((ISP_CMC10_MATRIX0 + 16), val);
+
+	val = ((cmc10_info.matrix_buf.val[1] & 0x3FFF) << 14) | (cmc10_info.matrix_buf.val[0] & 0x3FFF);
+	REG_WR(ISP_CMC10_MATRIX0_BUF, val);
+	val = ((cmc10_info.matrix_buf.val[3] & 0x3FFF) << 14) | (cmc10_info.matrix_buf.val[2] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0_BUF + 4), val);
+	val = ((cmc10_info.matrix_buf.val[5] & 0x3FFF) << 14) | (cmc10_info.matrix_buf.val[4] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0_BUF + 8), val);
+	val = ((cmc10_info.matrix_buf.val[7] & 0x3FFF) << 14) | (cmc10_info.matrix_buf.val[6] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0_BUF + 12), val);
+	val = cmc10_info.matrix_buf.val[8] & 0x3FFF;
+	REG_WR((ISP_CMC10_MATRIX0_BUF + 16), val);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_cmc10(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_cmc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_cmc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CMC_BLOCK:
+		ret = isp_k_cmc10_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_cmc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cmc8.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cmc8.c
new file mode 100644
index 00000000..35121772
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cmc8.c
@@ -0,0 +1,92 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_cmc8_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_cmc8_info_v1 cmc8_info;
+
+	memset(&cmc8_info, 0x00, sizeof(cmc8_info));
+
+	ret = copy_from_user((void *)&cmc8_info, param->property_param, sizeof(cmc8_info));
+	if (0 != ret) {
+		printk("isp_k_cmc8_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_CMC8_PARAM, BIT_0, cmc8_info.bypass);
+
+	REG_MWR(ISP_CMC8_PARAM, BIT_3, cmc8_info.buf_sel << 3);
+
+	REG_MWR(ISP_CMC8_PARAM, 0x3FF << 4, cmc8_info.alpha << 4);
+
+	REG_MWR(ISP_CMC8_PARAM, BIT_1, cmc8_info.alpha_bypass << 1);
+
+	val = ((cmc8_info.matrix.val[1] & 0x3FFF) << 14) | (cmc8_info.matrix.val[0] & 0x3FFF);
+	REG_WR(ISP_CMC8_MATRIX0, val);
+	val = ((cmc8_info.matrix.val[3] & 0x3FFF) << 14) | (cmc8_info.matrix.val[2] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0 + 4), val);
+	val = ((cmc8_info.matrix.val[5] & 0x3FFF) << 14) | (cmc8_info.matrix.val[4] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0 + 8), val);
+	val = ((cmc8_info.matrix.val[7] & 0x3FFF) << 14) | (cmc8_info.matrix.val[6] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0 + 12), val);
+	val = cmc8_info.matrix.val[8] & 0x3FFF;
+	REG_WR((ISP_CMC8_MATRIX0 + 16), val);
+
+	val = ((cmc8_info.matrix_buf.val[1] & 0x3FFF) << 14) | (cmc8_info.matrix_buf.val[0] & 0x3FFF);
+	REG_WR(ISP_CMC8_MATRIX0_BUF, val);
+	val = ((cmc8_info.matrix_buf.val[3] & 0x3FFF) << 14) | (cmc8_info.matrix_buf.val[2] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0_BUF + 4), val);
+	val = ((cmc8_info.matrix_buf.val[5] & 0x3FFF) << 14) | (cmc8_info.matrix_buf.val[4] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0_BUF + 8), val);
+	val = ((cmc8_info.matrix_buf.val[7] & 0x3FFF) << 14) | (cmc8_info.matrix_buf.val[6] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0_BUF + 12), val);
+	val = cmc8_info.matrix_buf.val[8] & 0x3FFF;
+	REG_WR((ISP_CMC8_MATRIX0_BUF + 16), val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_cmc8(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_cmc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_cmc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CMC8_BLOCK:
+		ret = isp_k_cmc8_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_cmc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_common.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_common.c
new file mode 100644
index 00000000..336f173a
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_common.c
@@ -0,0 +1,411 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_common_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_common_info_v2 common_info;
+
+	memset(&common_info, 0x00, sizeof(common_info));
+
+	ret = copy_from_user((void *)&common_info, param->property_param, sizeof(common_info));
+	if (0 != ret) {
+		printk("isp_k_common_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3, common_info.fetch_sel_0);
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 4, common_info.sizer_sel_0  << 4);
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 16, common_info.store_sel_0  << 16);
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 2, common_info.fetch_sel_1);
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 6, common_info.sizer_sel_1);
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 18, common_info.store_sel_1);
+	//REG_MWR(ISP_COMMON_CTRL_CH1, 3, common_info.fetch_sel_1);
+	//REG_MWR(ISP_COMMON_CTRL_CH1, 3 << 4, common_info.sizer_sel_1  << 4);
+	//REG_MWR(ISP_COMMON_CTRL_CH1, 3 << 16, common_info.store_sel_1  << 16);
+	REG_MWR(ISP_COMMON_SPACE_SEL, 3 , common_info.fetch_color_format) ;
+	REG_MWR(ISP_COMMON_SPACE_SEL, 3  << 2, common_info.store_color_format << 2) ;
+	//REG_MWR(ISP_COMMON_CTRL_AWBM, BIT_0 , common_info.awbm_pos) ;
+	//REG_MWR(ISP_COMMON_3A_CTRL0, 3, common_info.y_afm_pos_0);
+	//REG_MWR(ISP_COMMON_3A_CTRL0, 3 << 4, common_info.y_aem_pos_0  << 4);
+	//REG_MWR(ISP_COMMON_3A_CTRL1, 3, common_info.y_afm_pos_1);
+	//REG_MWR(ISP_COMMON_3A_CTRL1, 3 << 4, common_info.y_aem_pos_1  << 4);
+
+	REG_MWR(ISP_COMMON_LBUF_OFFSET, 0xFFFF, 0x460);
+	//REG_WR(ISP_COMMON_LBUF_OFFSET0, ((common_info.lbuf_off.cfae_lbuf_offset & 0xFFFF) << 16 ) | (common_info.lbuf_off.comm_lbuf_offset & 0xFFFF));
+	//REG_WR(ISP_COMMON_LBUF_OFFSET1, ((common_info.lbuf_off.ydly_lbuf_offset& 0xFFFF) << 16 ) | (common_info.lbuf_off.awbm_lbuf_offset & 0xFFFF));
+
+	return ret;
+}
+
+static int32_t isp_k_common_version(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t version = 0;
+
+	version = REG_RD(ISP_COMMON_VERSION);
+
+	ret = copy_to_user(param->property_param, (void*)&version, sizeof(version));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_common_version: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_common_status0(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t status = 0;
+
+	status = REG_RD(ISP_COMMON_STATUS0);
+
+	ret = copy_to_user(param->property_param, (void*)&status, sizeof(status));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_common_status0: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_common_status1(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t status = 0;
+
+	status = REG_RD(ISP_COMMON_STATUS1);
+
+	ret = copy_to_user(param->property_param, (void*)&status, sizeof(status));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_common_status1: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel0_fetch_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t fetch_sel = 0;
+
+	ret = copy_from_user((void *)&fetch_sel, param->property_param, sizeof(fetch_sel));
+	if (0 != ret) {
+		printk("isp_k_channel0_fetch_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3, fetch_sel);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel0_sizer_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t sizer_sel = 0;
+
+	ret = copy_from_user((void *)&sizer_sel, param->property_param, sizeof(sizer_sel));
+	if (0 != ret) {
+		printk("isp_k_channel0_sizer_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 4, sizer_sel  << 4);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel0_store_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t store_sel = 0;
+
+	ret = copy_from_user((void *)&store_sel, param->property_param, sizeof(store_sel));
+	if (0 != ret) {
+		printk("isp_k_common_channel0_store_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 16, store_sel  << 16);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel1_fetch_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t fetch_sel = 0;
+
+	ret = copy_from_user((void *)&fetch_sel, param->property_param, sizeof(fetch_sel));
+	if (0 != ret) {
+		printk("isp_k_channel1_fetch_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 2, fetch_sel << 2);
+
+//	REG_MWR(ISP_COMMON_CTRL_CH1, 3, fetch_sel);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel1_sizer_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t sizer_sel = 0;
+
+	ret = copy_from_user((void *)&sizer_sel, param->property_param, sizeof(sizer_sel));
+	if (0 != ret) {
+		printk("isp_k_common_channel1_sizer_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 6, sizer_sel << 6);
+
+	//REG_MWR(ISP_COMMON_CTRL_CH1, 3 << 4, sizer_sel  << 4);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel1_store_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t store_sel = 0;
+
+	ret = copy_from_user((void *)&store_sel, param->property_param, sizeof(store_sel));
+	if (0 != ret) {
+		printk("isp_k_common_channel1_store_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 18, store_sel << 18);
+
+//	REG_MWR(ISP_COMMON_CTRL_CH1, 3 << 16, store_sel  << 16);
+
+	return ret;
+}
+
+static int32_t isp_k_common_fetch_color_space_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t color_space = 0;
+
+	ret = copy_from_user((void *)&color_space, param->property_param, sizeof(color_space));
+	if (0 != ret) {
+		printk("isp_k_common_fetch_color_space_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_SPACE_SEL, 3 , color_space) ;
+
+	return ret;
+}
+
+static int32_t isp_k_common_store_color_space_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t color_space = 0;
+
+	ret = copy_from_user((void *)&color_space, param->property_param, sizeof(color_space));
+	if (0 != ret) {
+		printk("isp_k_common_store_color_space_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_SPACE_SEL, 3  << 2, color_space << 2) ;
+
+	return ret;
+}
+
+static int32_t isp_k_common_awbm_pos_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t awbm_pos = 0;
+
+	ret = copy_from_user((void *)&awbm_pos, param->property_param, sizeof(awbm_pos));
+	if (0 != ret) {
+		printk("isp_k_common_awbm_pos_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	//REG_MWR(ISP_COMMON_CTRL_AWBM, BIT_0 , awbm_pos) ;
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel0_y_afm_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t position = 0;
+
+	ret = copy_from_user((void *)&position, param->property_param, sizeof(position));
+	if (0 != ret) {
+		printk("isp_k_common_channel0_y_afm_pos: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+//	REG_MWR(ISP_COMMON_3A_CTRL0, 3, position);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel0_y_aem_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t position = 0;
+
+	ret = copy_from_user((void *)&position, param->property_param, sizeof(position));
+	if (0 != ret) {
+		printk("isp_k_common_channel0_y_aem_pos: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+//	REG_MWR(ISP_COMMON_3A_CTRL0, 3 << 4, position  << 4);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel1_y_afm_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t position = 0;
+
+	ret = copy_from_user((void *)&position, param->property_param, sizeof(position));
+	if (0 != ret) {
+		printk("isp_k_common_channel1_y_afm_pos: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+//	REG_MWR(ISP_COMMON_3A_CTRL1, 3, position);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel1_y_aem_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t position = 0;
+
+	ret = copy_from_user((void *)&position, param->property_param, sizeof(position));
+	if (0 != ret) {
+		printk("isp_k_common_channel1_y_aem_pos: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+//	REG_MWR(ISP_COMMON_3A_CTRL1, 3 << 4, position  << 4);
+
+	return ret;
+}
+
+static int32_t isp_k_common_lbuf_offset(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t lbuf_off;
+
+	memset(&lbuf_off, 0x00, sizeof(lbuf_off));
+	ret = copy_from_user((void *)&lbuf_off, param->property_param, sizeof(lbuf_off));
+	if (0 != ret) {
+		printk("isp_k_common_lbuf_offset: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+
+	REG_MWR(ISP_COMMON_LBUF_OFFSET, 0xFFFF, lbuf_off);
+
+//	REG_WR(ISP_COMMON_LBUF_OFFSET0, ((lbuf_off.cfae_lbuf_offset & 0xFFFF) << 16 ) | (lbuf_off.comm_lbuf_offset & 0xFFFF));
+//	REG_WR(ISP_COMMON_LBUF_OFFSET1, ((lbuf_off.ydly_lbuf_offset& 0xFFFF) << 16 ) | (lbuf_off.awbm_lbuf_offset & 0xFFFF));
+
+	return ret;
+}
+
+int32_t isp_k_cfg_common(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_common: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_common: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_COMMON_BLOCK:
+		ret = isp_k_common_block(param);
+		break;
+	case ISP_PRO_COMMON_VERSION:
+		ret = isp_k_common_version(param);
+		break;
+	case ISP_PRO_COMMON_STATUS0:
+		ret = isp_k_common_status0(param);
+		break;
+	case ISP_PRO_COMMON_STATUS1:
+		ret = isp_k_common_status1(param);
+		break;
+	case ISP_PRO_COMMON_CH0_FETCH_SEL:
+		ret = isp_k_common_channel0_fetch_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH0_SIZER_SEL:
+		ret = isp_k_common_channel0_sizer_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH0_STORE_SEL:
+		ret = isp_k_common_channel0_store_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH1_FETCH_SEL:
+		ret = isp_k_common_channel1_fetch_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH1_SIZER_SEL:
+		ret = isp_k_common_channel1_sizer_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH1_STORE_SEL:
+		ret = isp_k_common_channel1_store_sel(param);
+		break;
+	case ISP_PRO_COMMON_FETCH_COLOR_SPACE_SEL:
+		ret = isp_k_common_fetch_color_space_sel(param);
+		break;
+	case ISP_PRO_COMMON_STORE_COLOR_SPACE_SEL:
+		ret = isp_k_common_store_color_space_sel(param);
+		break;
+	case ISP_PRO_COMMON_AWBM_POS_SEL:
+		ret = isp_k_common_awbm_pos_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH0_AEM2_POS:
+		ret = isp_k_common_channel0_y_aem_pos(param);
+		break;
+	case ISP_PRO_COMMON_CH0_Y_AFM_POS:
+		ret = isp_k_common_channel0_y_afm_pos(param);
+		break;
+	case ISP_PRO_COMMON_CH1_AEM2_POS:
+		ret = isp_k_common_channel1_y_aem_pos(param);
+		break;
+	case ISP_PRO_COMMON_CH1_Y_AFM_POS:
+		ret = isp_k_common_channel1_y_afm_pos(param);
+		break;
+	case ISP_PRO_COMMON_LBUF_OFFSET:
+		ret = isp_k_common_lbuf_offset(param);
+		break;
+	default:
+		printk("isp_k_cfg_common: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_contrast.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_contrast.c
new file mode 100644
index 00000000..36f7750d
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_contrast.c
@@ -0,0 +1,67 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_contrast_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_contrast_info contrast_info;
+
+	memset(&contrast_info, 0x00, sizeof(contrast_info));
+
+	ret = copy_from_user((void *)&contrast_info, param->property_param, sizeof(contrast_info));
+	if (0 != ret) {
+		printk("isp_k_contrast_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_CONTRAST_PARAM, 0x1FE, (contrast_info.factor << 1));
+
+	if (contrast_info.bypass) {
+		REG_OWR(ISP_CONTRAST_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_CONTRAST_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_contrast(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_contrast: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_contrast: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CONTRAST_BLOCK:
+		ret = isp_k_contrast_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_contrast: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_csa.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_csa.c
new file mode 100644
index 00000000..1aa7ef49
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_csa.c
@@ -0,0 +1,68 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_csa_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_csa_info_v1 csa_info;
+	uint32_t val = 0;
+
+	memset(&csa_info, 0x00, sizeof(csa_info));
+
+	ret = copy_from_user((void *)&csa_info, param->property_param, sizeof(csa_info));
+	if (0 != ret) {
+		printk("isp_k_csa_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((csa_info.factor_v & 0xFF) << 8) | ((csa_info.factor_u & 0xFF) << 16);
+	REG_MWR(ISP_CSA_PARAM, 0xFFFF00, val);
+
+	if (csa_info.bypass) {
+		REG_OWR(ISP_CSA_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_CSA_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_csa(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_csa: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_csa: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CSA_BLOCK:
+		ret = isp_k_csa_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_csa: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_csc.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_csc.c
new file mode 100644
index 00000000..7612b698
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_csc.c
@@ -0,0 +1,114 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_csc_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_csc_info csc_info;
+
+	memset(&csc_info, 0x00, sizeof(csc_info));
+
+	ret = copy_from_user((void *)&csc_info, param->property_param, sizeof(csc_info));
+	if (0 != ret) {
+		printk("isp_k_csc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_CSC_CTRL, BIT_0, csc_info.bypass);
+
+	val = (csc_info.red_centre_x & 0x1FFF) | ((csc_info.red_centre_y & 0xFFF) << 16);
+	REG_WR(ISP_CSC_RCC, val);
+
+	val = (csc_info.blue_centre_x & 0x1FFF) | ((csc_info.blue_centre_y & 0xFFF) << 16);
+	REG_WR(ISP_CSC_BCC, val);
+
+	REG_WR(ISP_CSC_REDTHR, csc_info.red_threshold & 0x3FFFFFF);
+
+	REG_WR(ISP_CSC_BLUETHR, (csc_info.blue_threshold & 0x3FFFFFF));
+
+	val = (csc_info.red_p1_param & 0x1FFF) | ((csc_info.red_p2_param & 0x7FF) << 16);
+	REG_WR(ISP_CSC_REDPOLY, val);
+
+	val = (csc_info.blue_p1_param & 0x1FFF) | ((csc_info.blue_p2_param & 0x7FF) << 16);
+	REG_WR(ISP_CSC_BLUEPOLY, val);
+
+	REG_WR(ISP_CSC_MAXGAIN, (csc_info.max_gain_thr & 0x1FFF));
+
+	val = (csc_info.start_pos.x & 0xFFF) | ((csc_info.start_pos.y & 0x1FFF) << 12);
+	REG_WR(ISP_CSC_START_ROW_COL, val );
+
+	val = csc_info.red_x2_init;
+	REG_WR( ISP_CSC_REDX2INIT, (val & 0x3FFFFFF));
+	val = csc_info.red_y2_init;
+	REG_WR( ISP_CSC_REDY2INIT, (val & 0x3FFFFFF));
+
+	val = csc_info.blue_x2_init;
+	REG_WR( ISP_CSC_BLUEX2INIT, (val & 0x3FFFFFF));
+	val = csc_info.blue_y2_init;
+	REG_WR( ISP_CSC_BLUEY2INIT, (val & 0x3FFFFFF));
+
+	return ret;
+
+}
+
+static int32_t isp_k_csc_pic_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size pic_size = {0, 0};
+
+	ret = copy_from_user((void *)&pic_size, param->property_param, sizeof(pic_size));
+	if (0 != ret) {
+		printk("isp_k_csc_pic_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	val = (pic_size.width& 0x1FFF) | ((pic_size.height& 0xFFF) << 16);
+	REG_WR(ISP_CSC_PICSIZE, val );
+
+	return ret;
+}
+
+int32_t isp_k_cfg_csc(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_csc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_csc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CSC_BLOCK:
+		ret = isp_k_csc_block(param);
+		break;
+	case ISP_PRO_CSC_PIC_SIZE:
+		ret = isp_k_csc_pic_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_csc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_css.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_css.c
new file mode 100644
index 00000000..2147bd53
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_css.c
@@ -0,0 +1,112 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_css_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_css_info_v1 css_info;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&css_info, param->property_param, sizeof(css_info));
+	if (0 != ret) {
+		printk("isp_k_css_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (css_info.lh_chrom_th & 0x1F) << 24;
+	REG_MWR(ISP_CSS_PARAM, 0x1F000000, val);
+
+	val = ((css_info.chrom_lower_th[0] & 0x1F) << 16) | ((css_info.chrom_lower_th[1] & 0x1F) << 8)
+		| (css_info.chrom_lower_th[2] & 0x1F);
+	REG_MWR(ISP_CSS_CHROM_L_TH_0, 0x1F1F1F, val);
+
+	val = ((css_info.chrom_lower_th[3] & 0x1F) << 24) | ((css_info.chrom_lower_th[4] & 0x1F) << 16)
+		| ((css_info.chrom_lower_th[5] & 0x1F) << 8) | (css_info.chrom_lower_th[6] & 0x1F);
+	REG_WR(ISP_CSS_CHROM_L_TH_1, val);
+
+	val = ((css_info.chrom_high_th[0] & 0x1F) << 16) | ((css_info.chrom_high_th[1] & 0x1F) << 8)
+		| (css_info.chrom_high_th[2] & 0x1F);
+	REG_WR(ISP_CSS_CHROM_H_TH_0, val);
+
+	val = ((css_info.chrom_high_th[3] & 0x1F) << 24) | ((css_info.chrom_high_th[4] & 0x1F) << 16)
+		| ((css_info.chrom_high_th[5] & 0x1F) << 8) | (css_info.chrom_high_th[6] & 0x1F);
+	REG_WR(ISP_CSS_CHROM_H_TH_1, val);
+
+	val = ((css_info.lum_low_shift & 0x7) << 16) | ((css_info.lum_hig_shift & 0x7) << 8);
+	REG_MWR(ISP_CSS_PARAM, 0x70700, val);
+
+	val = (css_info.lh_ratio[7] & 0xF) | ((css_info.lh_ratio[6] & 0xF) << 4)
+		| ((css_info.lh_ratio[5] & 0xF) <<  8) | ((css_info.lh_ratio[4] & 0xF) << 12)
+		| ((css_info.lh_ratio[3] & 0xF) << 16) | ((css_info.lh_ratio[2] & 0xF) << 20)
+		| ((css_info.lh_ratio[1] & 0xF) << 24) | ((css_info.lh_ratio[0] & 0xF) << 28);
+	REG_WR(ISP_CSS_LH_RATIO, val);
+
+	val = (css_info.ratio[7] & 0xF) | ((css_info.ratio[6] & 0xF) << 4)
+		| ((css_info.ratio[5] & 0xF) <<  8) | ((css_info.ratio[4] & 0xF) << 12)
+		| ((css_info.ratio[3] & 0xF) << 16) | ((css_info.ratio[2] & 0xF) << 20)
+		| ((css_info.ratio[1] & 0xF) << 24) | ((css_info.ratio[0] & 0xF) << 28);
+	REG_WR(ISP_CSS_RATIO, val);
+
+	val = (css_info.lum_hh_th & 0xFF) | ((css_info.lum_hig_th & 0xFF) << 8)
+		| ((css_info.lum_ll_th & 0xFF) << 16) | ((css_info.lum_low_th & 0xFF) << 24);
+	REG_WR(ISP_CSS_THRD0, val);
+
+	val = (css_info.v_th_0_h & 0xFF) | ((css_info.v_th_0_l & 0xFF) << 8)
+		| ((css_info.u_th_0_h & 0xFF) << 16) | ((css_info.u_th_0_l & 0xFF) << 24);
+	REG_WR(ISP_CSS_EX_TH_0, val);
+
+	val = (css_info.v_th_1_h & 0xFF) | ((css_info.v_th_1_l & 0xFF) << 8)
+		| ((css_info.u_th_1_h & 0xFF) << 16) | ((css_info.u_th_1_l & 0xFF) << 24);
+	REG_WR(ISP_CSS_EX_TH_1, val);
+
+	REG_MWR(ISP_CSS_CHROM_L_TH_0, 0x1F000000, css_info.cutoff_th << 24);
+
+	if (css_info.bypass) {
+		REG_OWR(ISP_CSS_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_CSS_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_css(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_css: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_css: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CSS_BLOCK:
+		ret = isp_k_css_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_css: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_ct.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_ct.c
new file mode 100644
index 00000000..376b3ce4
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_ct.c
@@ -0,0 +1,92 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+#define ISP_3D_LUT_BUF0                0
+#define ISP_3D_LUT_BUF1                1
+
+static int32_t isp_k_ct_block(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t buf_size = 0;
+	unsigned long dst_buf = 0;
+	struct isp_dev_ct_info ct_info;
+	void *data_ptr = NULL;
+
+	buf_size = ISP_3D_LUT_ITEM * 4;
+	memset(&ct_info, 0x00, sizeof(ct_info));
+
+	ret = copy_from_user((void *)&ct_info, param->property_param, sizeof(ct_info));
+	if (0 != ret) {
+		printk("isp_k_ct_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+#ifdef CONFIG_64BIT
+	data_ptr = (void*)(((unsigned long)ct_info.data_ptr[1] << 32) | ct_info.data_ptr[0]);
+#else
+	data_ptr = (void*)(ct_info.data_ptr[0]);
+#endif
+	if (NULL == data_ptr || ct_info.size > buf_size) {
+		printk("isp_k_ct_block: memory error: %p %x.\n",
+			data_ptr, ct_info.size);
+	}
+
+	dst_buf = ISP_3D_LUT0_OUTPUT;
+	isp_private->ct_load_buf_id = ISP_3D_LUT_BUF0;
+
+	ret = copy_from_user((void *)dst_buf, data_ptr, ct_info.size);
+	if (0 != ret) {
+		printk("isp_k_ct_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	//REG_MWR(ISP_CT_PARAM, BIT_1, (isp_private->ct_load_buf_id << 1));
+
+	REG_MWR(ISP_CT_PARAM, BIT_0, ct_info.bypass);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_ct(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_ct: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_ct: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CT_BLOCK:
+		ret = isp_k_ct_block(param, isp_private);
+		break;
+	default:
+		printk("isp_k_cfg_ct: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_dispatch.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_dispatch.c
new file mode 100644
index 00000000..f998c27d
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_dispatch.c
@@ -0,0 +1,143 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_dispatch_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_dispatch_info_v1 dispatch_info;
+
+	memset(&dispatch_info, 0x00, sizeof(dispatch_info));
+
+	ret = copy_from_user((void *)&dispatch_info, param->property_param, sizeof(dispatch_info));
+	if (0 != ret) {
+		printk("isp_k_dispatch_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_DISPATCH_CH0_BAYER, 0x03, dispatch_info.bayer_ch0);
+	REG_MWR(ISP_DISPATCH_CH0_BAYER, 0x0C, dispatch_info.bayer_ch1);
+
+	return ret;
+}
+
+static int32_t isp_k_dispatch_ch0_bayer(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&val, param->property_param, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_dispatch_ch0_bayer: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_DISPATCH_CH0_BAYER, 0x03, val);
+
+	return ret;
+}
+
+static int32_t isp_k_dispatch_ch1_bayer(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&val, param->property_param, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_dispatch_ch1_bayer: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_DISPATCH_CH0_BAYER, 0x0C, val);
+
+	return ret;
+}
+
+static int32_t isp_k_dispatch_ch0_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_dispatch_ch0_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0xFFFF) << 16) | (size.width & 0xFFFF);
+	REG_WR(ISP_DISPATCH_CH0_SIZE, val);
+
+	return ret;
+}
+
+static int32_t isp_k_dispatch_ch1_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_dispatch_ch1_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0xFFFF) << 16) | (size.width & 0xFFFF);
+	REG_WR(ISP_DISPATCH_CH1_SIZE, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_dispatch(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_dispatch: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_dispatch: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_DISPATCH_BLOCK:
+		ret = isp_k_dispatch_block(param);
+		break;
+	case ISP_PRO_DISPATCH_CH0_BAYER:
+		ret = isp_k_dispatch_ch0_bayer(param);
+		break;
+	case ISP_PRO_DISPATCH_CH1_BAYER:
+		ret = isp_k_dispatch_ch1_bayer(param);
+		break;
+	case ISP_PRO_DISPATCH_CH0_SIZE:
+		ret = isp_k_dispatch_ch0_size(param);
+		break;
+	case ISP_PRO_DISPATCH_CH1_SIZE:
+		ret = isp_k_dispatch_ch1_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_dispatch: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_edge.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_edge.c
new file mode 100644
index 00000000..2c298147
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_edge.c
@@ -0,0 +1,128 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_edge_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_edge_info_v1 edge_info;
+	uint32_t val = 0;
+
+	memset(&edge_info, 0x00, sizeof(edge_info));
+
+	ret = copy_from_user((void *)&edge_info, param->property_param, sizeof(edge_info));
+	if (0 != ret) {
+		printk("isp_k_edge_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_EE_CFG0, BIT_29 | BIT_28, edge_info.mode << 28);
+
+	val = (edge_info.ee_str_m_n & 0x7F) | ((edge_info.ee_str_m_p & 0x7F) << 7)
+		| ((edge_info.ee_str_d_n & 0x7F) << 14) | ((edge_info.ee_str_d_p & 0x7F) << 21);
+	REG_MWR(ISP_EE_CFG0, 0xFFFFFFF, val);
+
+	val = ((edge_info.ee_incr_d_p & 0xFF) << 8) | (edge_info.ee_incr_d_n & 0xFF);
+	REG_MWR(ISP_EE_CFG1, 0xFFFF, val);
+
+	val = ((edge_info.ee_thr_d_n & 0xFF) << 16) | ((edge_info.ee_thr_d_p & 0xFF) << 24);
+	REG_MWR(ISP_EE_CFG1, 0xFFFF0000, val);
+
+	val = (edge_info.ee_flat_thr_1 & 0xFF) | ((edge_info.ee_flat_thr_2 & 0xFF) << 8);
+	REG_MWR(ISP_EE_CFG2, 0xFFFF, val);
+
+	val = ((edge_info.ee_incr_m_n & 0xFF) << 16) | ((edge_info.ee_incr_m_p & 0xFF) << 24);
+	REG_MWR(ISP_EE_CFG2, 0xFFFF0000, val);
+
+	val = (edge_info.ee_txt_thr_1 & 0xFF) | ((edge_info.ee_txt_thr_2 & 0xFF) << 8)
+		| ((edge_info.ee_txt_thr_3 & 0xFF) << 16);
+	REG_WR(ISP_EE_CFG3, val);
+
+	val = ((edge_info.ee_corner_cor & 0x1) << 28) | ((edge_info.ee_corner_th_p & 0x1F) << 23)
+		| ((edge_info.ee_corner_th_n & 0x1F) << 18) | ((edge_info.ee_corner_gain_p & 0x7F) << 11)
+		| ((edge_info.ee_corner_gain_n & 0x7F) << 4) | ((edge_info.ee_corner_sm_p & 0x3) << 2)
+		| (edge_info.ee_corner_sm_n & 0x3);
+	REG_WR(ISP_EE_CFG4, val);
+
+	val = ((edge_info.ee_edge_smooth_mode & 0x3) << 26) | ((edge_info.ee_flat_smooth_mode & 0x3) << 24)
+		| ((edge_info.ee_smooth_thr & 0xFF) << 8) | (edge_info.ee_smooth_strength & 0xFF);
+	REG_MWR(ISP_EE_CFG5, 0xF00FFFF, val);
+
+	val = (edge_info.sigma & 0xFF) << 16;
+	REG_MWR(ISP_EE_CFG5, 0xFF0000, val);
+
+	val = ((edge_info.ee_str_b_p & 0xFF) << 24) | ((edge_info.ee_str_b_n & 0xFF) << 16)
+		| ((edge_info.ee_incr_b_p & 0xFF) << 8) | (edge_info.ee_incr_b_n & 0xFF);
+	REG_WR(ISP_EE_CFG6, val);
+
+	val = ((edge_info.ratio[1] & 0xFF) << 8) | (edge_info.ratio[0] & 0xFF);
+	REG_MWR(ISP_EE_CFG7, 0xFFFF, val);
+
+	val = (edge_info.ee_clip_after_smooth_en & 0x1) << 25;
+	REG_MWR(ISP_EE_CFG7, BIT_25, val);
+
+	val = ((edge_info.ipd_bypass & 0x1) << 24) | ((edge_info.ipd_flat_thr & 0xFF) << 16);
+	REG_MWR(ISP_EE_CFG7, 0x1FF0000, val);
+
+/*pike has no ADP_CFG0 ADP_CFG1 ADP_CFG2 registers*/
+
+/*	val = (edge_info.ee_t1_cfg & 0x3FF) | ((edge_info.ee_t2_cfg & 0x3FF) << 10)
+		| ((edge_info.ee_t3_cfg & 0x3FF) << 20);
+	REG_WR(ISP_EE_ADP_CFG0, val);
+
+	val = (edge_info.ee_t4_cfg & 0x3FF) | ((edge_info.ee_cv_clip_n & 0xFF) << 16)
+		| ((edge_info.ee_cv_clip_p & 0xFF) << 24);
+	REG_WR(ISP_EE_ADP_CFG1, val);
+
+	val = (edge_info.ee_r1_cfg & 0xFF) | ((edge_info.ee_r2_cfg & 0xFF) << 8)
+		| ((edge_info.ee_r3_cfg & 0xFF) << 16);
+	REG_WR(ISP_EE_ADP_CFG2, val);*/
+
+
+	if (edge_info.bypass) {
+		REG_OWR(ISP_EE_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_EE_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_edge(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_edge: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_edge: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_EDGE_BLOCK:
+		ret = isp_k_edge_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_edge: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_emboss.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_emboss.c
new file mode 100644
index 00000000..27319afc
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_emboss.c
@@ -0,0 +1,74 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_emboss_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_emboss_info_v1 emboss_info;
+
+	memset(&emboss_info, 0x00, sizeof(emboss_info));
+
+	ret = copy_from_user((void *)&emboss_info, param->property_param, sizeof(emboss_info));
+	if (0 != ret) {
+		printk("isp_k_emboss_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_EMBOSS_Y_PARAM, 0x7E, (emboss_info.y_step & 0x3F) << 1);
+
+	if (emboss_info.y_bypass) {
+		REG_OWR(ISP_EMBOSS_Y_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_EMBOSS_Y_PARAM, BIT_0, 0);
+	}
+
+	REG_MWR(ISP_EMBOSS_UV_PARAM, 0x7E, (emboss_info.uv_step & 0x3F) << 1);
+
+	if (emboss_info.uv_bypass) {
+		REG_OWR(ISP_EMBOSS_UV_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_EMBOSS_UV_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_emboss(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_emboss: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_emboss: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_EMBOSS_BLOCK:
+		ret = isp_k_emboss_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_emboss: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_fetch.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_fetch.c
new file mode 100644
index 00000000..04df07df
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_fetch.c
@@ -0,0 +1,127 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_fetch_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_fetch_info_v1 fetch_info;
+
+	memset(&fetch_info, 0x00, sizeof(fetch_info));
+
+	ret = copy_from_user((void *)&fetch_info, param->property_param, sizeof(fetch_info));
+	if (0 != ret) {
+		printk("isp_k_fetch_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (fetch_info.substract) {
+		REG_OWR(ISP_FETCH_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_FETCH_PARAM, BIT_1, 0);
+	}
+
+	REG_MWR(ISP_FETCH_PARAM, 0xF0, (fetch_info.color_format << 4));
+
+	REG_WR(ISP_FETCH_SLICE_Y_ADDR, fetch_info.addr.chn0);
+	REG_WR(ISP_FETCH_SLICE_Y_PITCH, fetch_info.pitch.chn0);
+	REG_WR(ISP_FETCH_SLICE_U_ADDR, fetch_info.addr.chn1);
+	REG_WR(ISP_FETCH_SLICE_U_PITCH, fetch_info.pitch.chn1);
+	REG_WR(ISP_FETCH_SLICE_V_ADDR, fetch_info.addr.chn2);
+	REG_WR(ISP_FETCH_SLICE_V_PITCH, fetch_info.pitch.chn2);
+	REG_WR(ISP_FETCH_MIPI_WORD_INFO, (fetch_info.mipi_word_num & 0xFFFF));
+	REG_WR(ISP_FETCH_MIPI_BYTE_INFO, (fetch_info.mipi_byte_rel_pos & 0x0F));
+	REG_WR(ISP_FETCH_BAYER_MODE, 0x2);
+
+	if (fetch_info.bypass) {
+		REG_OWR(ISP_FETCH_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_FETCH_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_fetch_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t size = 0;
+	struct isp_img_size slice_size = {0, 0};
+
+	ret = copy_from_user((void *)&slice_size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_fetch_slice_size: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	size = ((slice_size.height & 0xFFFF) << 16) | (slice_size.width & 0xFFFF);
+
+	REG_WR(ISP_FETCH_SLICE_SIZE, size);
+
+	return ret;
+}
+
+static int32_t isp_k_fetch_start_isp(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t fetch_start = 0;
+
+	ret = copy_from_user((void *)&fetch_start, param->property_param, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_fetch_start_isp: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (fetch_start) {
+		REG_OWR(ISP_FETCH_START, BIT_0);
+	} else {
+		REG_MWR(ISP_FETCH_START, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_fetch(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_fetch: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_fetch: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_FETCH_BLOCK:
+		ret = isp_k_fetch_block(param);
+		break;
+	case ISP_PRO_FETCH_SLICE_SIZE:
+		ret = isp_k_fetch_slice_size(param);
+		break;
+	case ISP_PRO_FETCH_START_ISP:
+		ret = isp_k_fetch_start_isp(param);
+		break;
+	default:
+		printk("isp_k_cfg_fetch: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_gamma.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_gamma.c
new file mode 100644
index 00000000..99b9d1b4
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_gamma.c
@@ -0,0 +1,143 @@
+/*
+ * 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/uaccess.h>
+#include <linux/vmalloc.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+#define ISP_FRGB_GAMC_BUF0                0
+#define ISP_FRGB_GAMC_BUF1                1
+
+static int32_t isp_k_pingpang_frgb_gamc(struct coordinate_xy *nodes,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t i, j;
+	uint32_t val = 0;
+	unsigned long r_buf_addr;
+	unsigned long g_buf_addr;
+	unsigned long b_buf_addr;
+	struct coordinate_xy *p_nodes = NULL;
+
+	if (!nodes) {
+		ret = -1;
+		printk("isp_k_pingpang_frgb_gamc: node is null error .\n");
+		return ret;
+	}
+
+	p_nodes = nodes;
+
+#if 0
+	if (ISP_FRGB_GAMC_BUF0 == isp_private->full_gamma_buf_id) {
+		r_buf_addr = ISP_FGAMMA_R_BUF0_CH0;
+		g_buf_addr = ISP_FGAMMA_G_BUF0_CH0;
+		b_buf_addr = ISP_FGAMMA_B_BUF0_CH0;
+		isp_private->full_gamma_buf_id = ISP_FRGB_GAMC_BUF1;
+	} else {
+		r_buf_addr = ISP_FGAMMA_R_BUF0_CH0;
+		g_buf_addr = ISP_FGAMMA_G_BUF0_CH0;
+		b_buf_addr = ISP_FGAMMA_B_BUF0_CH0;
+		isp_private->full_gamma_buf_id = ISP_FRGB_GAMC_BUF0;
+	}
+#endif
+
+	isp_private->full_gamma_buf_id = ISP_FRGB_GAMC_BUF0;
+	val = ((isp_private->full_gamma_buf_id & 0x1 ) << 1) | ((isp_private->full_gamma_buf_id & 0x1) << 2) | ((isp_private->full_gamma_buf_id & 0x1 ) << 3);
+	REG_MWR(ISP_GAMMA_PARAM, 0x0000000E, val);
+
+	r_buf_addr = ISP_FGAMMA_R_BUF0_CH0;
+	g_buf_addr = ISP_FGAMMA_G_BUF0_CH0;
+	b_buf_addr = ISP_FGAMMA_B_BUF0_CH0;
+
+	for(i = 0,j = 0;i < ISP_PINGPANG_FRGB_GAMC_NUM;i++,j+=4) {
+		REG_WR(r_buf_addr + j, p_nodes[i].node_y & 0xff);
+		REG_WR(g_buf_addr + j, p_nodes[i].node_y & 0xff);
+		REG_WR(b_buf_addr + j, p_nodes[i].node_y & 0xff);
+	}
+
+	isp_private->full_gamma_buf_id = ISP_FRGB_GAMC_BUF1;
+
+	val = ((isp_private->full_gamma_buf_id & 0x1 ) << 1) | ((isp_private->full_gamma_buf_id & 0x1) << 2) | ((isp_private->full_gamma_buf_id & 0x1 ) << 3);
+	REG_MWR(ISP_GAMMA_PARAM, 0x0000000E, val);
+
+	return ret;
+}
+
+static int32_t isp_k_gamma_block(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	uint32_t bypass;
+	struct isp_dev_gamma_info_v1 *param_p= (struct isp_dev_gamma_info_v1 *)param->property_param;
+	struct coordinate_xy *nodes = NULL;
+
+	nodes = (struct coordinate_xy *)isp_private->full_gamma_buf_addr;
+	if (!nodes) {
+		ret = -1;
+		printk("isp_k_gamma_block: alloc memory error.\n");
+		return -1;
+	}
+	ret = copy_from_user((void *)nodes, (void *)param_p->nodes, ISP_FRGB_GAMMA_BUF_SIZE);
+	if (0 != ret) {
+		printk("isp_k_gamma_block: copy nodes error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	ret = isp_k_pingpang_frgb_gamc(nodes, isp_private);
+	if (0 != ret) {
+		printk("isp_k_gamma_block: pingpang error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	ret = copy_from_user((void *)&bypass, (void *)&param_p->bypass, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_gamma_block: copy bypass error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_GAMMA_PARAM, BIT_0, bypass);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_gamma(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_gamma: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_gamma: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_GAMMA_BLOCK:
+		ret = isp_k_gamma_block(param, isp_private);
+		break;
+	default:
+		printk("isp_k_cfg_gamma: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_grgb.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_grgb.c
new file mode 100644
index 00000000..6bf40d2a
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_grgb.c
@@ -0,0 +1,70 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_grgb_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_grgb_info_v1 grgb_info;
+
+	memset(&grgb_info, 0x00, sizeof(grgb_info));
+
+	ret = copy_from_user((void *)&grgb_info, param->property_param, sizeof(grgb_info));
+	if (0 != ret) {
+		printk("isp_k_grgb_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_GRGB_PARAM, BIT_0, grgb_info.bypass);
+
+	val = ((grgb_info.diff & 0x3FF) << 7) | ((grgb_info.edge & 0x3F) << 1);
+	REG_MWR(ISP_GRGB_PARAM, 0x1FFFE, val);
+	val = grgb_info.grid & 0xFFF;
+	REG_MWR(ISP_GRGB_GRID, 0xFFF, val);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_grgb(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_grgb: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_grgb: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_GRGB_BLOCK:
+		ret = isp_k_grgb_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_grgb: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hdr.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hdr.c
new file mode 100755
index 00000000..ba03b911
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hdr.c
@@ -0,0 +1,142 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_hdr_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t i = 0, index = 0, addr = 0, val = 0;
+	struct isp_dev_hdr_info hdr_info;
+
+	ret = copy_from_user((void *)&hdr_info, param->property_param, sizeof(hdr_info));
+	if (0 != ret) {
+		printk("isp_k_hdr_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	printk("$$LHC:isp_k_hdr_block");
+	REG_MWR(ISP_HDR_PARAM, BIT_1, (hdr_info.level << 1));
+
+	val = ((hdr_info.b_index & 0xFF) << 24)
+		| ((hdr_info.g_index & 0xFF) << 16)
+		| ((hdr_info.r_index & 0xFF) << 8);
+	REG_WR(ISP_HDR_PARAM, val);
+
+	if (hdr_info.bypass) {
+		REG_OWR(ISP_HDR_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_HDR_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_hdr_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_hdr_bypass: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (bypass) {
+		REG_OWR(ISP_HDR_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_HDR_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_hdr_level(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t level= 0;
+
+	ret = copy_from_user((void *)&level, param->property_param, sizeof(level));
+	if (0 != ret) {
+		printk("isp_k_hdr_level: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_HDR_PARAM, BIT_1, (level << 1));
+
+	return ret;
+}
+
+static int32_t isp_k_hdr_index(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_hdr_rgb_index index;
+
+	memset(&index, 0x00, sizeof(index));
+
+	ret = copy_from_user((void *)&index, param->property_param, sizeof(index));
+	if (0 != ret) {
+		printk("isp_k_hdr_index: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((index.b & 0xFF) << 24)
+		| ((index.g & 0xFF) << 16)
+		| ((index.r & 0xFF) << 8);
+	REG_WR(ISP_HDR_PARAM, val);
+
+	return ret;
+}
+
+
+int32_t isp_k_cfg_hdr(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_hdr: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_hdr: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_HDR_BLOCK:
+		ret = isp_k_hdr_block(param);
+		break;
+	case ISP_PRO_HDR_BYPASS:
+		ret = isp_k_hdr_bypass(param);
+		break;
+	case ISP_PRO_HDR_LEVEL:
+		ret = isp_k_hdr_level(param);
+		break;
+	case ISP_PRO_HDR_INDEX:
+		ret = isp_k_hdr_index(param);
+		break;
+	case ISP_PRO_HDR_TAB:
+		//ret = isp_k_hdr_tab(param);
+		break;
+	default:
+		printk("isp_k_cfg_hdr: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hist.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hist.c
new file mode 100644
index 00000000..5ab1a8c3
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hist.c
@@ -0,0 +1,131 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_hist_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_hist_info_v1 hist_info;
+	uint32_t val = 0;
+
+	memset(&hist_info, 0x00, sizeof(hist_info));
+
+	ret = copy_from_user((void *)&hist_info, param->property_param, sizeof(hist_info));
+	if (0 != ret) {
+		printk("isp_k_hist_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (hist_info.buf_rst_en) {
+		REG_OWR(ISP_HIST_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_1, 0);
+	}
+//pike has no bit9
+/*	if (hist_info.pof_rst_en) {
+		REG_OWR(ISP_HIST_PARAM, BIT_9);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_9, 0);
+	}*/
+
+	if (hist_info.skip_num_clr) {
+		REG_OWR(ISP_HIST_PARAM, BIT_8);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_8, 0);
+	}
+
+	REG_MWR(ISP_HIST_PARAM, 0xF0, hist_info.skip_num << 4);
+
+	if (hist_info.mode) {
+		REG_OWR(ISP_HIST_PARAM, BIT_3);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_3, 0);
+	}
+
+	val = ((hist_info.high_ratio & 0xFFFF) << 16)
+			| (hist_info.low_ratio & 0xFFFF);
+
+	REG_WR(ISP_HIST_RATIO, val);
+
+	val = (hist_info.dif_adj & 0xFF) | ((hist_info.small_adj & 0xFF) << 8)
+		| ((hist_info.big_adj & 0xFF) << 16);
+
+	REG_WR(ISP_HIST_ADJUST, val);
+
+	if (hist_info.off) {
+		REG_OWR(ISP_HIST_PARAM, BIT_2);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_2, 0);
+	}
+
+	if (hist_info.bypass) {
+		REG_OWR(ISP_HIST_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_hist_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_hist_slice_size: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0xFFFF) << 16)
+			| (size.width & 0xFFFF);
+
+	REG_WR(ISP_HIST_SLICE_SIZE, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_hist(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_hist: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_hist: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_HIST_BLOCK:
+		ret = isp_k_hist_block(param);
+		break;
+	case ISP_PRO_HIST_SLICE_SIZE:
+		ret = isp_k_hist_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_hist: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hist2.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hist2.c
new file mode 100644
index 00000000..7f8c5d05
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hist2.c
@@ -0,0 +1,95 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_hist2_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_hist2_info_v1 hist2_info;
+	uint32_t val = 0;
+	uint32_t i = 0;
+
+	memset(&hist2_info, 0x00, sizeof(hist2_info));
+
+	ret = copy_from_user((void *)&hist2_info, param->property_param, sizeof(hist2_info));
+	if (0 != ret) {
+		printk("isp_k_hist2_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (hist2_info.skip_num_clr) {
+		REG_OWR(ISP_HIST2_PARAM, BIT_8);
+	} else {
+		REG_MWR(ISP_HIST2_PARAM, BIT_8, 0);
+	}
+
+	REG_MWR(ISP_HIST2_PARAM, 0xF0, hist2_info.skip_num << 4);
+
+	if (hist2_info.mode) {
+		REG_OWR(ISP_HIST2_PARAM, BIT_3);
+	} else {
+		REG_MWR(ISP_HIST2_PARAM, BIT_3, 0);
+	}
+
+	for (i = 0; i < 4; i++) {
+		val = (hist2_info.hist_roi_y_s[i] & 0xFFFF) | ((hist2_info.hist_roi_x_s[i] & 0xFFFF) << 16);
+		REG_WR(ISP_HIST2_ROI_S0 + i * 8, val);
+
+		val = (hist2_info.hist_roi_y_e[i] & 0xFFFF) | ((hist2_info.hist_roi_x_e[i] & 0xFFFF) << 16);
+		REG_WR(ISP_HIST2_ROI_E0 + i * 8, val);
+	}
+
+//pike has no bit1 of ISP_HIST2_PARAM
+/*	if (hist2_info.en) {
+		REG_OWR(ISP_HIST2_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_HIST2_PARAM, BIT_1, 0);
+	}*/
+
+	if (hist2_info.bypass) {
+		REG_OWR(ISP_HIST2_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_HIST2_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_hist2(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_hist2: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_hist2: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_HIST2_BLOCK:
+		ret = isp_k_hist2_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_hist2: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hsv.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hsv.c
new file mode 100644
index 00000000..5083242b
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hsv.c
@@ -0,0 +1,95 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_hsv_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int32_t buf_size = 0;
+	unsigned long dst_addr = 0;
+	struct isp_dev_hsv_info_v1 hsv_info;
+	void *data_ptr = NULL;
+
+	memset(&hsv_info, 0x00, sizeof(hsv_info));
+
+	ret = copy_from_user((void *)&hsv_info, param->property_param, sizeof(hsv_info));
+	if (0 != ret) {
+		printk("isp_k_hsv_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+#ifdef CONFIG_64BIT
+	data_ptr = (void*)(((unsigned long)hsv_info.data_ptr[1] << 32) | hsv_info.data_ptr[0]);
+#else
+	data_ptr = (void*)(hsv_info.data_ptr[0]);
+#endif
+
+	buf_size = ISP_HSV_ITEM * 4;
+	if (NULL == data_ptr || hsv_info.size > buf_size) {
+		printk("isp_k_hsv_block : memory error %p %x \n",
+			data_ptr, hsv_info.size);
+		return -1;
+	}
+
+	if (hsv_info.buf_sel << 1 & BIT_1) {
+		dst_addr = ISP_HSV_BUF1_OUTPUT;
+	} else {
+		dst_addr = ISP_HSV_BUF0_OUTPUT;
+	}
+
+	ret = copy_from_user((void *)dst_addr, data_ptr, hsv_info.size);
+	if (0 != ret) {
+		printk("isp_k_hsv_block: copy error 0x%x \n",(uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_HSV_PARAM, BIT_1, hsv_info.buf_sel << 1);
+
+	REG_MWR(ISP_HSV_PARAM, BIT_0, hsv_info.bypass);
+
+	return ret;
+
+}
+
+
+int32_t isp_k_cfg_hsv(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_hsv: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_hsv: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_HSV_BLOCK:
+		ret = isp_k_hsv_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_hsv: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hua.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hua.c
new file mode 100644
index 00000000..f4570330
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hua.c
@@ -0,0 +1,68 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_hue_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_hue_info_v1 hua_info;
+
+	memset(&hua_info, 0x00, sizeof(hua_info));
+
+	ret = copy_from_user((void *)&hua_info, param->property_param, sizeof(hua_info));
+	if (0 != ret) {
+		printk("isp_k_hue_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_HUA_PARAM, 0x1FF0, hua_info.theta << 4);
+
+	if (hua_info.bypass) {
+		REG_OWR(ISP_HUA_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_HUA_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+
+int32_t isp_k_cfg_hue(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_hue: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_hue: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_HUE_BLOCK:
+		ret = isp_k_hue_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_hue: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_isr.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_isr.c
new file mode 100644
index 00000000..bcec6583
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_isr.c
@@ -0,0 +1,101 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include <linux/delay.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+#define ISP_TIME_OUT_MAX (500)
+
+int32_t isp_get_int_num(struct isp_node *node)
+{
+
+	node->irq_val1 = REG_RD(ISP_INT_INT0);
+	node->irq_val2 = REG_RD(ISP_INT_INT1);
+	node->irq_val3 = REG_RD(ISP_INT_INT2);
+
+	if ((0 == node->irq_val1)
+		&& (0 == node->irq_val2)
+		&& (0 == node->irq_val3)) {
+		printk("isp_get_int_num: int error.\n");
+		return -1;
+	}
+
+	REG_WR(ISP_INT_CLR0, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR1, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR2, ISP_IRQ_HW_MASK);
+
+	return 0;
+}
+
+void isp_clr_int(void)
+{
+	REG_WR(ISP_INT_CLR0, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR1, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR2, ISP_IRQ_HW_MASK);
+}
+
+void isp_en_irq(uint32_t irq_mode)
+{
+	REG_WR(ISP_INT_CLR0, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR1, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR2, ISP_IRQ_HW_MASK);
+
+	switch(irq_mode) {
+	case ISP_INT_VIDEO_MODE:
+		REG_WR(ISP_INT_EN0, ISP_INT_DCAMERA_SOF | ISP_INT_AEM_DONE | ISP_INT_AFM_RGB_DONE | ISP_INT_AFL_DONE);
+		REG_WR(ISP_INT_EN1, 0);
+		REG_WR(ISP_INT_EN2, 0);
+		break;
+	case ISP_INT_CAPTURE_MODE:
+		REG_WR(ISP_INT_EN0, ISP_INT_STORE_DONE);
+		REG_WR(ISP_INT_EN1, 0);
+		REG_WR(ISP_INT_EN2, 0);
+		break;
+	case ISP_INT_CLEAR_MODE:
+		REG_WR(ISP_INT_EN0, 0);
+		REG_WR(ISP_INT_EN1, 0);
+		REG_WR(ISP_INT_EN2, 0);
+		break;
+	default:
+		printk("isp_en_irq: irq_mode error.\n");
+		break;
+	}
+}
+
+int32_t isp_axi_bus_waiting(void)
+{
+	int32_t ret = 0;
+	uint32_t reg_value = 0;
+	uint32_t time_out_cnt = 0;
+
+	REG_OWR(ISP_AXI_ITI2AXIM_CTRL, BIT_18);
+
+	reg_value = REG_RD(ISP_INT_STATUS);
+	while ((0x00 == (reg_value & BIT_3))
+		&& (time_out_cnt < ISP_TIME_OUT_MAX)) {
+		time_out_cnt++;
+		udelay(50);
+		reg_value = REG_RD(ISP_INT_STATUS);
+	}
+
+	if (time_out_cnt >= ISP_TIME_OUT_MAX) {
+		ret = -1;
+		printk("isp_axi_bus_waiting: time out.\n");
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_nlc.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_nlc.c
new file mode 100755
index 00000000..1be70137
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_nlc.c
@@ -0,0 +1,83 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_nlc_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	struct isp_dev_nlc_info_v1 nlc_info;
+
+	memset(&nlc_info, 0x00, sizeof(nlc_info));
+
+	ret = copy_from_user((void *)&nlc_info, param->property_param, sizeof(nlc_info));
+	if (0 != ret) {
+		printk("isp_k_nlc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	for (i = 0; i < 9; i++) {
+		val = ((nlc_info.node.r_node[i*3] & 0x3FF) << 20) | ((nlc_info.node.r_node[i*3+1] & 0x3FF) << 10) | (nlc_info.node.r_node[i*3+2] & 0x3FF);
+		REG_WR(ISP_NLC_PARA_R0 + i * 4, val);
+		val = ((nlc_info.node.g_node[i*3] & 0x3FF) << 20) | ((nlc_info.node.g_node[i*3+1] & 0x3FF) << 10) | (nlc_info.node.g_node[i*3+2] & 0x3FF);
+		REG_WR(ISP_NLC_PARA_G0 + i * 4, val);
+		val = ((nlc_info.node.b_node[i*3] & 0x3FF) << 20) | ((nlc_info.node.b_node[i*3+1] & 0x3FF) << 10) | (nlc_info.node.b_node[i*3+2] & 0x3FF);
+		REG_WR(ISP_NLC_PARA_B0 + i * 4, val);
+		val = ((nlc_info.node.l_node[i*3] & 0x3FF) << 20) | ((nlc_info.node.l_node[i*3+1] & 0x3FF) << 10) | (nlc_info.node.l_node[i*3+2] & 0x3FF);
+		REG_WR(ISP_NLC_PARA_L0 + i * 4, val);
+	}
+
+	val = ((nlc_info.node.r_node[27] & 0x3FF) << 20) | ((nlc_info.node.r_node[28] & 0x3FF) << 10);
+	REG_WR(ISP_NLC_PARA_R9, val);
+	val = ((nlc_info.node.g_node[27] & 0x3FF) << 20) | ((nlc_info.node.g_node[28] & 0x3FF) << 10);
+	REG_WR(ISP_NLC_PARA_G9, val);
+	val = ((nlc_info.node.b_node[27] & 0x3FF) << 20) | ((nlc_info.node.b_node[28] & 0x3FF) << 10);
+	REG_WR(ISP_NLC_PARA_B9, val);
+
+	REG_MWR(ISP_NLC_PARA, BIT_0, nlc_info.bypass);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_nlc(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_nlc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_nlc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_NLC_BLOCK:
+		ret = isp_k_nlc_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_nlc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_nlm.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_nlm.c
new file mode 100644
index 00000000..ee4d4076
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_nlm.c
@@ -0,0 +1,202 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include <linux/vmalloc.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_vst_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_vst_info_v1 vst_info;
+
+	ret = copy_from_user((void *)&vst_info, param->property_param, sizeof(vst_info));
+	if (0 != ret) {
+		printk("isp_k_vst_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_VST_PARA, BIT_0, vst_info.bypass);
+
+	REG_MWR(ISP_VST_PARA, BIT_1, vst_info.buf_sel << 1);
+
+	return ret;
+
+}
+
+static int32_t isp_k_nlm_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	struct isp_dev_nlm_info_v2 nlm_info;
+	uint32_t *buff0 = NULL;
+	uint32_t *buff1 = NULL;
+	unsigned long buf_addr = 0;
+	void *vst_addr = NULL;
+	void *ivst_addr = NULL;
+	void *nlm_addr = NULL;
+
+	ret = copy_from_user((void *)&nlm_info, param->property_param, sizeof(nlm_info));
+	if (0 != ret) {
+		printk("isp_k_nlm_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	buff0 = vzalloc(nlm_info.vst_len);
+	if (NULL == buff0) {
+		printk("isp_k_nlm_block:vst kmalloc error\n");
+		return -1;
+	}
+
+	buff1 = vzalloc(nlm_info.ivst_len);
+	if (NULL == buff1) {
+		printk("isp_k_nlm_block:ivst kmalloc error\n");
+		vfree(buff0);
+		return -1;
+	}
+
+#ifdef CONFIG_64BIT
+	vst_addr = (void*)(((unsigned long)nlm_info.vst_addr[1] << 32) | nlm_info.vst_addr[0]);
+#else
+	vst_addr = (void*)(nlm_info.vst_addr[0]);
+#endif
+	ret = copy_from_user((void *)buff0, vst_addr, nlm_info.vst_len);
+	if (0 != ret) {
+		printk("isp_k_nlm_block: vst copy error, ret=0x%x\n", (uint32_t)ret);
+		vfree(buff0);
+		vfree(buff1);
+		return -1;
+	}
+
+#ifdef CONFIG_64BIT
+	ivst_addr = (void*)(((unsigned long)nlm_info.ivst_addr[1] << 32) | nlm_info.ivst_addr[0]);
+#else
+	ivst_addr = (void*)(nlm_info.ivst_addr[0]);
+#endif
+	ret = copy_from_user((void *)buff1, ivst_addr, nlm_info.ivst_len);
+	if (0 != ret) {
+		printk("isp_k_nlm_block: ivst copy error, ret=0x%x\n", (uint32_t)ret);
+		vfree(buff0);
+		vfree(buff1);
+		return -1;
+	}
+
+	REG_MWR(ISP_NLM_PARA, BIT_1, nlm_info.imp_opt_bypass << 1);
+	REG_MWR(ISP_NLM_PARA, BIT_2, nlm_info.flat_opt_bypass << 2);
+
+	for (i = 0; i < 5; i++) {
+		val = (nlm_info.thresh[i] & 0x3FFF) | ((nlm_info.cnt[i] & 0x1F) << 16)
+			| ((nlm_info.strength[i] & 0x7F) << 24);
+		REG_WR(ISP_NLM_FLAT_PARA_0 + i * 4, val);
+	}
+
+	REG_MWR(ISP_NLM_STERNGTH, 0x7F, nlm_info.streng_th);
+
+	REG_MWR(ISP_NLM_STERNGTH, 0x7F80, nlm_info.texture_dec << 7);
+
+	REG_WR(ISP_NLM_IS_FLAT, nlm_info.is_flat & 0xFF);
+
+	REG_MWR(ISP_NLM_ADD_BACK, 0x7F, nlm_info.addback);
+
+
+	for (i = 0; i < 24; i++) {
+		val = (nlm_info.lut_w[i*3+0] & 0x3FF) | ((nlm_info.lut_w[i*3+1] & 0x3FF) << 10)
+			| ((nlm_info.lut_w[i*3+2] & 0x3FF) << 20);
+		REG_WR(ISP_NLM_LUT_W_0 + i * 4, val);
+	}
+
+
+	if (nlm_info.buf_sel ) {
+		//buf_addr = ISP_VST_BUF1_CH0;
+		//memcpy((void *)buf_addr, buff0, ISP_VST_IVST_NUM * sizeof(uint32_t));
+	} else {
+		buf_addr = ISP_VST_BUF0_CH0;
+		memcpy((void *)buf_addr, buff0, ISP_VST_IVST_NUM * sizeof(uint32_t));
+	}
+
+	if (nlm_info.buf_sel ) {
+		//buf_addr = ISP_IVST_BUF1_CH0;
+		//memcpy((void *)buf_addr, buff1, ISP_VST_IVST_NUM * sizeof(uint32_t));
+	} else {
+		buf_addr = ISP_IVST_BUF0_CH0;
+		memcpy((void *)buf_addr, buff1, ISP_VST_IVST_NUM * sizeof(uint32_t));
+	}
+
+	/*vst ivst follow nlm*/
+	REG_MWR(ISP_VST_PARA, BIT_1, nlm_info.buf_sel << 1);
+	REG_MWR(ISP_IVST_PARA, BIT_1, nlm_info.buf_sel << 1);
+
+	REG_MWR(ISP_NLM_PARA, BIT_0, nlm_info.bypass);
+	REG_MWR(ISP_IVST_PARA, BIT_0, nlm_info.bypass);
+	REG_MWR(ISP_VST_PARA, BIT_0, nlm_info.bypass);
+
+	vfree(buff0);
+	vfree(buff1);
+	return ret;
+
+}
+
+static int32_t isp_k_ivst_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	struct isp_dev_ivst_info_v1 ivst_info;
+
+	ret = copy_from_user((void *)&ivst_info, param->property_param, sizeof(ivst_info));
+	if (0 != ret) {
+		printk("isp_k_ivst_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_IVST_PARA, BIT_0, ivst_info.bypass);
+
+	REG_MWR(ISP_IVST_PARA, BIT_1, ivst_info.buf_sel << 1);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_nlm(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_nlm: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_nlm: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_VST_BLOCK:
+		ret = isp_k_vst_block(param);
+		break;
+	case ISP_PRO_NLM_BLOCK:
+		ret = isp_k_nlm_block(param);
+		break;
+	case ISP_PRO_IVST_BLOCK:
+		ret = isp_k_ivst_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_nlm: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pgg.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pgg.c
new file mode 100644
index 00000000..8cdd023d
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pgg.c
@@ -0,0 +1,67 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_pgg_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_pre_glb_gain_info pgg_info;
+
+	memset(&pgg_info, 0x00, sizeof(pgg_info));
+
+	ret = copy_from_user((void *)&pgg_info, param->property_param, sizeof(pgg_info));
+	if (0 != ret) {
+		printk("isp_k_pgg_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_PGG_PARAM, 0xFFFF00, (pgg_info.gain << 8));
+
+	if (pgg_info.bypass) {
+		REG_OWR(ISP_PGG_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_PGG_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_pgg(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_pgg: param is null error.\n");
+		return -1;
+	}
+
+	if (!param->property_param) {
+		printk("isp_k_cfg_pgg: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_PRE_GLB_GAIN_BLOCK:
+		ret = isp_k_pgg_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_pgg: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_post_cdn.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_post_cdn.c
new file mode 100644
index 00000000..e61ad33e
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_post_cdn.c
@@ -0,0 +1,129 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_post_cdn_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_post_cdn_info post_cdn_info;
+	uint32_t val = 0;
+	uint32_t i = 0;
+
+	memset(&post_cdn_info, 0x00, sizeof(post_cdn_info));
+
+	ret = copy_from_user((void *)&post_cdn_info, param->property_param, sizeof(post_cdn_info));
+	if (0 != ret) {
+		printk("isp_k_post_cdn_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+
+	REG_WR(ISP_POSTCDN_ADPT_THR, post_cdn_info.adapt_med_thr & 0x3FFF);
+
+	REG_MWR(ISP_POSTCDN_COMMON_CTRL, 0xE0, post_cdn_info.median_mode << 5);
+
+	if (post_cdn_info.uvjoint) {
+		REG_OWR(ISP_POSTCDN_COMMON_CTRL, BIT_4);
+	} else {
+		REG_MWR(ISP_POSTCDN_COMMON_CTRL, BIT_4, 0);
+	}
+
+	if (post_cdn_info.writeback_en) {
+		REG_OWR(ISP_POSTCDN_COMMON_CTRL, BIT_3);
+	} else {
+		REG_MWR(ISP_POSTCDN_COMMON_CTRL, BIT_3, 0);
+	}
+
+	if (post_cdn_info.mode) {
+		REG_OWR(ISP_POSTCDN_COMMON_CTRL, BIT_2);
+	} else {
+		REG_MWR(ISP_POSTCDN_COMMON_CTRL, BIT_2, 0);
+	}
+
+	val = (post_cdn_info.uvthr0 & 0x1FF) | ((post_cdn_info.uvthr1 & 0x1FF) << 16);
+	REG_WR(ISP_POSTCDN_UVTHR, val);
+	val = (post_cdn_info.thru0 & 0xFF) | ((post_cdn_info.thru1 & 0xFF) << 16);
+	REG_WR(ISP_POSTCDN_THRU, val);
+	val = (post_cdn_info.thrv0 & 0xFF) | ((post_cdn_info.thrv1 & 0xFF) << 16);
+	REG_WR(ISP_POSTCDN_THRV, val);
+
+	for (i = 0; i < 3; i++) {
+		val = (post_cdn_info.r_segu[0][i*2] & 0xFF) | ((post_cdn_info.r_segu[1][i*2] & 0x7) << 8)
+			| ((post_cdn_info.r_segu[0][i*2+1] & 0xFF) << 16) | ((post_cdn_info.r_segu[1][i*2+1] & 0x7) << 24);
+		REG_WR(ISP_POSTCDN_RSEGU01 + i * 4, val);
+	}
+	val = (post_cdn_info.r_segu[0][6] & 0xFF) | ((post_cdn_info.r_segu[1][6] & 0x7) << 8);
+	REG_WR(ISP_POSTCDN_RSEGU6, val);
+	for (i = 0; i < 3; i++) {
+		val = (post_cdn_info.r_segv[0][i*2] & 0xFF) | ((post_cdn_info.r_segv[1][i*2] & 0x7) << 8)
+			| ((post_cdn_info.r_segv[0][i*2+1] & 0xFF) << 16) | ((post_cdn_info.r_segv[1][i*2+1] & 0x7) << 24);
+		REG_WR(ISP_POSTCDN_RSEGV01 + i * 4, val);
+	}
+	val = (post_cdn_info.r_segv[0][6] & 0xFF) | ((post_cdn_info.r_segv[1][6] & 0x7) << 8);
+	REG_WR(ISP_POSTCDN_RSEGV6, val);
+
+
+	for (i = 0; i < 15; i++) {
+		val = (post_cdn_info.r_distw[i][0] & 0x7) | ((post_cdn_info.r_distw[i][1] & 0x7) << 3)
+			| ((post_cdn_info.r_distw[i][2] & 0x7) << 6) | ((post_cdn_info.r_distw[i][3] & 0x7) << 9)
+			| ((post_cdn_info.r_distw[i][4] & 0x7) << 12);
+		REG_WR(ISP_POSTCDN_R_DISTW0 + i * 4, val);
+	}
+
+//pike has no this register
+	//REG_WR(ISP_POSTCDN_START_ROW_MOD4, post_cdn_info.start_row_mod4 & 0x3);
+
+	if (post_cdn_info.downsample_bypass) {
+		REG_OWR(ISP_POSTCDN_COMMON_CTRL, BIT_1);
+	} else {
+		REG_MWR(ISP_POSTCDN_COMMON_CTRL, BIT_1, 0);
+	}
+
+	if (post_cdn_info.bypass) {
+		REG_OWR(ISP_POSTCDN_COMMON_CTRL, BIT_0);
+	} else {
+		REG_MWR(ISP_POSTCDN_COMMON_CTRL, BIT_0, 0);
+	}
+
+
+	return ret;
+}
+
+int32_t isp_k_cfg_post_cdn(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_post_cdn: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_post_cdn: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_POST_CDN_BLOCK:
+		ret = isp_k_post_cdn_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_post_cdn: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pre_cdn.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pre_cdn.c
new file mode 100644
index 00000000..f4be5578
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pre_cdn.c
@@ -0,0 +1,135 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_yuv_precdn_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_yuv_precdn_info pre_cdn_info;
+	uint32_t val = 0;
+	uint32_t i = 0;
+
+	memset(&pre_cdn_info, 0x00, sizeof(pre_cdn_info));
+
+	ret = copy_from_user((void *)&pre_cdn_info, param->property_param, sizeof(pre_cdn_info));
+	if (0 != ret) {
+		printk("isp_k_yuv_precdn_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (pre_cdn_info.mode) {
+		REG_OWR(ISP_PRECDN_PARAM, BIT_4);
+	} else {
+		REG_MWR(ISP_PRECDN_PARAM, BIT_4, 0);
+	}
+
+	if (pre_cdn_info.median_writeback_en) {
+		REG_OWR(ISP_PRECDN_PARAM, BIT_8);
+	} else {
+		REG_MWR(ISP_PRECDN_PARAM, BIT_8, 0);
+	}
+
+	REG_MWR(ISP_PRECDN_PARAM, BIT_13 | BIT_12, pre_cdn_info.median_mode << 12);
+
+	if (pre_cdn_info.uv_joint) {
+		REG_OWR(ISP_PRECDN_PARAM, BIT_20);
+	} else {
+		REG_MWR(ISP_PRECDN_PARAM, BIT_20, 0);
+	}
+
+	REG_MWR(ISP_PRECDN_PARAM, BIT_17 | BIT_16, pre_cdn_info.den_stren << 16);
+
+	val = (pre_cdn_info.median_thr_u[0] & 0x7F) | ((pre_cdn_info.median_thr_u[1] & 0xFF) << 8)
+		| ((pre_cdn_info.median_thr_v[0] & 0x7F) << 16) | ((pre_cdn_info.median_thr_v[1] & 0xFF) << 24);
+	REG_WR(ISP_PRECDN_MEDIAN_THRUV01, val);
+
+	val = (pre_cdn_info.median_thr & 0x1FF) | ((pre_cdn_info.uv_thr & 0xFF) << 16)
+		| ((pre_cdn_info.y_thr & 0xFF) << 24);
+	REG_WR(ISP_PRECDN_THRYUV, val);
+
+	for (i = 0; i < 3; i++) {
+		val = (pre_cdn_info.r_segu[0][i*2] & 0xFF) | ((pre_cdn_info.r_segu[1][i*2] & 0x7) << 8)
+			| ((pre_cdn_info.r_segu[0][i*2+1] & 0xFF) << 16) | ((pre_cdn_info.r_segu[1][i*2+1] & 0x7) << 24);
+		REG_WR(ISP_PRECDN_SEGU_0 + i * 4, val);
+	}
+
+	val = (pre_cdn_info.r_segu[0][6] & 0xFF) | ((pre_cdn_info.r_segu[1][6] & 0x7) << 8);
+	REG_WR(ISP_PRECDN_SEGU_3, val);
+
+	for (i = 0; i < 3; i++) {
+		val = (pre_cdn_info.r_segv[0][i*2] & 0xFF) | ((pre_cdn_info.r_segv[1][i*2] & 0x7) << 8)
+			| ((pre_cdn_info.r_segv[0][i*2+1] & 0xFF) << 16) | ((pre_cdn_info.r_segv[1][i*2+1] & 0x7) << 24);
+		REG_WR(ISP_PRECDN_SEGV_0 + i * 4, val);
+	}
+
+	val = (pre_cdn_info.r_segv[0][6] & 0xFF) | ((pre_cdn_info.r_segv[1][6] & 0x7) << 8);
+	REG_WR(ISP_PRECDN_SEGV_3, val);
+
+	for (i = 0; i < 3; i++) {
+		val = (pre_cdn_info.r_segy[0][i*2] & 0xFF) | ((pre_cdn_info.r_segy[1][i*2] & 0x7) << 8)
+			| ((pre_cdn_info.r_segy[0][i*2+1] & 0xFF) << 16) | ((pre_cdn_info.r_segy[1][i*2+1] & 0x7) << 24);
+		REG_WR(ISP_PRECDN_SEGY_0 + i * 4, val);
+	}
+
+	val = (pre_cdn_info.r_segy[0][6] & 0xFF) | ((pre_cdn_info.r_segy[1][6] & 0x7) << 8);
+	REG_WR(ISP_PRECDN_SEGY_3, val);
+
+	for (i = 0; i < 3; i++) {
+		val = (pre_cdn_info.r_distw[i*8] & 0x7) | ((pre_cdn_info.r_distw[i*8+1] & 0x7) << 4)
+			| ((pre_cdn_info.r_distw[i*8+2] & 0x7) << 8) | ((pre_cdn_info.r_distw[i*8+3] & 0x7) << 12)
+			| ((pre_cdn_info.r_distw[i*8+4] & 0x7) << 16) | ((pre_cdn_info.r_distw[i*8+5] & 0x7) << 20)
+			| ((pre_cdn_info.r_distw[i*8+6] & 0x7) << 24) | ((pre_cdn_info.r_distw[i*8+7] & 0x7) << 28);
+		REG_WR(ISP_PRECDN_DISTW0 + i * 4, val);
+	}
+
+	val = pre_cdn_info.r_distw[24] & 0x7;
+	REG_WR(ISP_PRECDN_DISTW3, val);
+
+	if (pre_cdn_info.bypass) {
+		REG_OWR(ISP_PRECDN_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_PRECDN_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_yuv_precdn(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_yuv_precdn: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_yuv_precdn: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_YUV_PRECDN_BLOCK:
+		ret = isp_k_yuv_precdn_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_yuv_precdn: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pre_cdn_rgb.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pre_cdn_rgb.c
new file mode 100644
index 00000000..d5bde126
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pre_cdn_rgb.c
@@ -0,0 +1,73 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_pre_cdn_rgb_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_pre_cdn_rgb_info pcr_info;
+
+	memset(&pcr_info, 0x00, sizeof(pcr_info));
+
+	ret = copy_from_user((void *)&pcr_info, param->property_param, sizeof(pcr_info));
+	if (0 != ret) {
+		printk("isp_k_pre_cdn_rgb_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_PRECNRNEW_CFG, BIT_0, pcr_info.bypass);
+
+	REG_MWR(ISP_PRECNRNEW_CFG, 0x3 << 1, pcr_info.median_mode << 1);
+
+	val = pcr_info.median_thr & 0xFFFF;
+	REG_WR(ISP_PRECNRNEW_MEDIAN_THR, val);
+	val = (pcr_info.thru0 & 0xFFFF) | ((pcr_info.thru1 & 0xFFFF) << 16);
+	REG_WR(ISP_PRECNRNEW_THRU, val);
+	val = (pcr_info.thrv0 & 0xFFFF) | ((pcr_info.thrv1 & 0xFFFF) << 16);
+	REG_WR(ISP_PRECNRNEW_THRV, val);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_pre_cdn_rgb(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_pre_cdn_rgb: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_pre_cdn_rgb: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_PRE_CDN_RGB_BLOCK:
+		ret = isp_k_pre_cdn_rgb_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_pre_cdn_rgb: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_prefilter.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_prefilter.c
new file mode 100644
index 00000000..ea25ccf1
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_prefilter.c
@@ -0,0 +1,73 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_prefilter_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_prefilter_info_v1 prefilter_info;
+
+	memset(&prefilter_info, 0x00, sizeof(prefilter_info));
+
+	ret = copy_from_user((void *)&prefilter_info, param->property_param, sizeof(prefilter_info));
+	if (0 != ret) {
+		printk("isp_k_prefilter_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (prefilter_info.writeback) {
+		REG_OWR(ISP_PREF_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_PREF_PARAM, BIT_1, 0);
+	}
+
+	REG_WR(ISP_PREF_THRD, prefilter_info.thrd & 0xFF);
+
+	if (prefilter_info.bypass) {
+		REG_OWR(ISP_PREF_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_PREF_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_prefilter(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_prefilter: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_prefilter: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_PREF_BLOCK:
+		ret = isp_k_prefilter_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_prefilter: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pstrz.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pstrz.c
new file mode 100644
index 00000000..0db4e234
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pstrz.c
@@ -0,0 +1,71 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_posterize_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	struct isp_dev_posterize_info pstrz_info;
+
+	memset(&pstrz_info, 0x00, sizeof(pstrz_info));
+
+	ret = copy_from_user((void *)&pstrz_info, param->property_param, sizeof(pstrz_info));
+	if (0 != ret) {
+		printk("isp_k_posterize_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_PSTRZ_PARAM, BIT_0, pstrz_info.bypass);
+
+	for (i = 0; i < 8; i++) {
+		val = (pstrz_info.posterize_level_out[i] & 0xFF) | ((pstrz_info.posterize_level_top[i] & 0xFF) << 8)
+			| ((pstrz_info.posterize_level_bottom[i] & 0xFF) << 16);
+		REG_WR(ISP_PSTRZ_LEVEL0 + i * 4, val);
+	}
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_posterize(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_posterize: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_posterize: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_POSTERIZE_BLOCK:
+		ret = isp_k_posterize_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_posterize: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pwd.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pwd.c
new file mode 100644
index 00000000..88b6355f
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pwd.c
@@ -0,0 +1,123 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_pwd_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_pre_wavelet_info_v1 pwd_info;
+
+	memset(&pwd_info, 0x00, sizeof(pwd_info));
+
+	ret = copy_from_user((void *)&pwd_info, param->property_param, sizeof(pwd_info));
+	if (0 != ret) {
+		printk("isp_k_pwd_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((pwd_info.gain_thrs0 & 0x7FF) << 6) | ((pwd_info.gain_thrs1 & 0x7FF) << 17);
+	REG_MWR(ISP_PWD_PARAM, 0x0FFFFFC0, val);
+
+	val = (pwd_info.bitshift0 & 0x7) | ((pwd_info.bitshift1 & 0xFF) << 3);
+	REG_MWR(ISP_PWD_PARAM1, 0x7FF, val);
+
+	val = (pwd_info.offset & 0xFF) << 11;
+	REG_MWR(ISP_PWD_PARAM1, 0x7F800, val);
+
+	val = (pwd_info.nsr_slope & 0x3FF) << 4;
+	REG_MWR(ISP_PWD_PARAM2, 0x3FF0, val);
+
+	val = pwd_info.lum_ratio & 0xF;
+	REG_MWR(ISP_PWD_PARAM2, 0xF, val);
+
+	val = ((pwd_info.center_pos_x & 0x1FFF) << 12) | (pwd_info.center_pos_y & 0xFFF);
+	REG_WR(ISP_PWD_PARAM3, val);
+
+	val = pwd_info.delta_x2 & 0x3FFFFFF;
+	REG_WR(ISP_PWD_PARAM4, val);
+	val = pwd_info.delta_y2 & 0xFFFFFF;
+	REG_WR(ISP_PWD_PARAM5, val);
+
+	val = pwd_info.r2_thr & 0x3FFFFFF;
+	REG_WR(ISP_PWD_PARAM6, val);
+
+	val = ((pwd_info.p_param1 & 0x1FFF) << 11) | (pwd_info.p_param2 & 0x7FF);
+	REG_WR(ISP_PWD_PARAM7, val);
+
+	val = (pwd_info.addback & 0x7F) << 13;
+	REG_MWR(ISP_PWD_PARAM8, 0xFE000, val);
+
+	val = pwd_info.gain_max_thr & 0x1FFF;
+	REG_MWR(ISP_PWD_PARAM8, 0x1FFF, val);
+
+	val = ((pwd_info.pos_x & 0x1FFF) << 12) | (pwd_info.pos_y & 0xFFF);
+	REG_WR(ISP_PWD_PARAM10, val);
+
+	REG_MWR(ISP_PWD_PARAM, BIT_1, pwd_info.radial_bypass << 1);
+	REG_MWR(ISP_PWD_PARAM, BIT_0, pwd_info.bypass);
+
+	return ret;
+}
+
+static int32_t isp_k_pwd_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0, 0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_pwd_slice_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.width & 0x1FFF) << 12) | (size.height & 0xFFF);
+	REG_WR(ISP_PWD_PARAM9, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_pwd(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_pwd: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_pwd: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_PWD_BLOCK:
+		ret = isp_k_pwd_block(param);
+		break;
+	case ISP_PRO_PWD_SLICE_SIZE:
+		ret = isp_k_pwd_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_pwd: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_raw_aem.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_raw_aem.c
new file mode 100644
index 00000000..5e4509d5
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_raw_aem.c
@@ -0,0 +1,255 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+static int32_t isp_k_raw_aem_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_raw_aem_info aem_info;
+
+	memset(&aem_info, 0x00, sizeof(aem_info));
+
+	ret = copy_from_user((void *)&aem_info, param->property_param, sizeof(aem_info));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_AEM_PARAM, BIT_0, aem_info.bypass);
+
+	val = (aem_info.shift & 0x1F) << 18;
+	if(0 != val) {
+		printk("isp_k_raw_aem_block: shift error, 0x%x\n", val);
+	}
+	REG_MWR(ISP_AEM_BLK_SIZE, 0x7C0000, 0);
+
+	REG_MWR(ISP_AEM_PARAM, BIT_1, aem_info.mode << 1);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_bypass: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_AEM_PARAM, BIT_0, bypass);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_mode(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t mode = 0;
+
+	ret = copy_from_user((void *)&mode, param->property_param, sizeof(mode));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_mode: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_AEM_PARAM, BIT_1, mode << 1);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_statistics(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0, i = 0;
+	uint32_t val0 = 0, val1 = 0;
+	unsigned long addr = 0;
+	struct isp_raw_aem_statistics *aem_statistics = NULL;
+
+	aem_statistics = (struct isp_raw_aem_statistics *)isp_private->raw_aem_buf_addr;
+	if (!aem_statistics) {
+		ret = -1;
+		printk("isp_k_raw_aem_statistics: alloc memory error.\n");
+		return -1;
+	}
+
+	addr = ISP_RAW_AEM_OUTPUT;
+	for (i = 0x00; i < ISP_RAW_AEM_ITEM; i++) {
+		val0 = REG_RD(addr);
+		val1 = REG_RD(addr + 4);
+		aem_statistics->r[i]= (val1 >> 11) & 0x1fffff;
+		aem_statistics->g[i]= val0 & 0x3fffff;
+		aem_statistics->b[i]= ((val1 & 0x7ff) << 10) | ((val0 >> 22) & 0x3ff);
+		addr += 8;
+	}
+
+	ret = copy_to_user(param->property_param, (void*)aem_statistics, sizeof(struct isp_raw_aem_statistics));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_raw_aem_statistics: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_skip_num(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t skip_num;
+
+	ret = copy_from_user((void *)&skip_num, param->property_param, sizeof(skip_num));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_skip_num: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (skip_num & 0xF) << 4;
+	REG_MWR(ISP_AEM_PARAM, 0xF0, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_shift(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t shift = 0;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&shift, param->property_param, sizeof(shift));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_shift: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (shift & 0x1F) << 18;
+	if(0 != val) {
+		printk("isp_k_raw_aem_shift: shift error, 0x%x\n", val);
+	}
+	REG_MWR(ISP_AEM_BLK_SIZE, 0x7C0000, 0);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_offset(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct img_offset offset;
+
+	ret = copy_from_user((void *)&offset, param->property_param, sizeof(struct img_offset));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_offset: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((offset.y & 0xFFFF) << 16) | (offset.x & 0xFFFF);
+	REG_WR(ISP_AEM_OFFSET, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_blk_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_blk_size: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0x1FF) << 9) | (size.width & 0x1FF);
+	REG_MWR(ISP_AEM_BLK_SIZE, 0x3FFFF, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_slice_size: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0xFFFF) << 16) | (size.width & 0xFFFF);
+	REG_WR(ISP_AEM_SLICE_SIZE, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_raw_aem(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_raw_aem: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_raw_aem: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_RAW_AEM_BLOCK:
+		ret = isp_k_raw_aem_block(param);
+		break;
+	case ISP_PRO_RAW_AEM_BYPASS:
+		ret = isp_k_raw_aem_bypass(param);
+		break;
+	case ISP_PRO_RAW_AEM_MODE:
+		ret = isp_k_raw_aem_mode(param);
+		break;
+	case ISP_PRO_RAW_AEM_STATISTICS:
+		ret = isp_k_raw_aem_statistics(param, isp_private);
+		break;
+	case ISP_PRO_RAW_AEM_SKIP_NUM:
+		ret = isp_k_raw_aem_skip_num(param);
+		break;
+	case ISP_PRO_RAW_AEM_SHIFT:
+		ret = isp_k_raw_aem_shift(param);
+		break;
+	case ISP_PRO_RAW_AEM_OFFSET:
+		ret = isp_k_raw_aem_offset(param);
+		break;
+	case ISP_PRO_RAW_AEM_BLK_SIZE:
+		ret = isp_k_raw_aem_blk_size(param);
+		break;
+	case ISP_PRO_RAW_AEM_SLICE_SIZE:
+		ret = isp_k_raw_aem_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_raw_aem: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_raw_afm.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_raw_afm.c
new file mode 100644
index 00000000..b3f97c3f
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_raw_afm.c
@@ -0,0 +1,497 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+#define ISP_AFM_WIN_NUM_V1  25
+static int32_t isp_k_raw_afm_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	int max_num = ISP_AFM_WIN_NUM_V1;
+	struct isp_dev_rgb_afm_info_v1 rafm_info;
+
+	memset(&rafm_info, 0x00, sizeof(rafm_info));
+
+	ret = copy_from_user((void *)&rafm_info, param->property_param, sizeof(rafm_info));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_0, rafm_info.bypass);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_1, rafm_info.mode << 1);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, 0xF<<2, (rafm_info.skip_num << 2));
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_6, rafm_info.skip_num_clear << 6);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_7, rafm_info.spsmd_rtgbot_enable << 7);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_8, rafm_info.spsmd_diagonal_enable << 8);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_9, rafm_info.spsmd_cal_mode << 9);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_10, rafm_info.af_sel_filter1 << 10);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_11, rafm_info.af_sel_filter2 << 11);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_12, rafm_info.sobel_type << 12);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, (BIT_13)|(BIT_14), rafm_info.spsmd_type << 13);
+
+	val = ((rafm_info.sobel_threshold_max << 16) & 0xffff0000)
+			| (rafm_info.sobel_threshold_min & 0xffff);
+	REG_WR(ISP_RGB_AFM_SOBEL_THRESHOLD, val);
+
+	REG_WR(ISP_RGB_AFM_SPSMD_THRESHOLD_MIN, rafm_info.spsmd_threshold_min);
+	REG_WR(ISP_RGB_AFM_SPSMD_THRESHOLD_MAX, rafm_info.spsmd_threshold_max);
+
+	for (i = 0; i < max_num; i++) {
+		val = ((rafm_info.coord[i].start_y <<16) & 0xffff0000)
+				| (rafm_info.coord[i].start_x & 0xffff);
+		REG_WR((ISP_RGB_AFM_WIN_RANGE0 + 4*2*i), val);
+
+		val = ((rafm_info.coord[i].end_y <<16) & 0xffff0000)
+			| (rafm_info.coord[i].end_x & 0xffff);
+		REG_WR((ISP_RGB_AFM_WIN_RANGE0 + 4*(2*i+1)), val);
+	}
+
+	return ret;
+
+}
+
+static int32_t isp_k_raw_afm_frame_range(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size  frame_size = {0, 0};
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&frame_size, param->property_param, sizeof(frame_size));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_frame_range: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (frame_size.height & 0xFFFF) | ((frame_size.width & 0xFFFF) << 16);
+	REG_WR(ISP_RGB_AFM_FRAME_RANGE, val);
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_type1_statistic(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int i = 0;
+	int max_item = ISP_AFM_WIN_NUM_V1;
+	struct isp_raw_afm_statistic item;
+
+	memset(&item, 0, sizeof(struct isp_raw_afm_statistic));
+	for (i = 0; i < max_item; i++) {
+		item.val[i] = REG_RD((ISP_RGB_AFM_TYPE1_VAL00 + 4*i));
+	}
+	ret = copy_to_user(param->property_param, (void*)&item, sizeof(item));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_raw_afm_statistic: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_type2_statistic(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int i = 0;
+	int max_item = ISP_AFM_WIN_NUM_V1;
+	struct isp_raw_afm_statistic item;
+
+	memset(&item, 0, sizeof(struct isp_raw_afm_statistic));
+	for (i = 0; i < max_item; i++) {
+		item.val[i] = REG_RD((ISP_RGB_AFM_TYPE2_VAL00 + 4*i));
+	}
+	ret = copy_to_user(param->property_param, (void*)&item, sizeof(item));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_raw_afm_statistic: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_bypass: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (bypass) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_mode(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t mode = 0;
+
+	ret = copy_from_user((void *)&mode, param->property_param, sizeof(mode));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_mode: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (mode) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_1, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_skip_num(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t skip_num = 0;
+
+	ret = copy_from_user((void *)&skip_num, param->property_param, sizeof(skip_num));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_skip_num: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_RGB_AFM_PARAM, 0xF<<2, (skip_num <<2));
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_skip_num_clr(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t is_clear = 0;
+
+	ret = copy_from_user((void *)&is_clear, param->property_param, sizeof(is_clear));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_skip_num_clr: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (is_clear) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_6);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_6, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_spsmd_rtgbot_enable(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t is_enable = 0;
+
+	ret = copy_from_user((void *)&is_enable, param->property_param, sizeof(is_enable));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_spsmd_rtgbot_enable: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (is_enable) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_7);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_7, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_spsmd_diagonal_enable(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t is_enable = 0;
+
+	ret = copy_from_user((void *)&is_enable, param->property_param, sizeof(is_enable));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_spsmd_diagonal_enable: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (is_enable) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_8);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_8, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_spsmd_cal_mode(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t cal_mode = 0;
+
+	ret = copy_from_user((void *)&cal_mode, param->property_param, sizeof(cal_mode));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_spsmd_cal_mode: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	if (cal_mode) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_9);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_9, 0);
+	}
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_sel_filter1(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t af_sel_filter = 0;
+
+	ret = copy_from_user((void *)&af_sel_filter, param->property_param, sizeof(af_sel_filter));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_sel_filter1: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	if (af_sel_filter) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_10);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_10, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_sel_filter2(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t af_sel_filter = 0;
+
+	ret = copy_from_user((void *)&af_sel_filter, param->property_param, sizeof(af_sel_filter));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	if (af_sel_filter) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_11);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_11, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_sobel_type(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t sobel_type = 0;
+
+	ret = copy_from_user((void *)&sobel_type, param->property_param, sizeof(sobel_type));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (sobel_type) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_12);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_12, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_spsmd_type(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t spsmd_type = 0;
+
+	ret = copy_from_user((void *)&spsmd_type, param->property_param, sizeof(spsmd_type));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_RGB_AFM_PARAM, (BIT_13)|(BIT_14), spsmd_type<<13);
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_sobel_threshold(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct sobel_thrd sobel_threshold = {0, 0};
+
+	ret = copy_from_user((void *)&sobel_threshold, param->property_param, sizeof(sobel_threshold));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	val = ((sobel_threshold.max<<16) & 0xffff0000)
+			| (sobel_threshold.min & 0xffff);
+	REG_WR(ISP_RGB_AFM_SOBEL_THRESHOLD, val);
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_spsmd_threshold(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct spsmd_thrd spsmd_threshold = {0, 0};
+
+	ret = copy_from_user((void *)&spsmd_threshold, param->property_param, sizeof(spsmd_threshold));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_spsmd_threshold: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	REG_WR(ISP_RGB_AFM_SPSMD_THRESHOLD_MIN, spsmd_threshold.min);
+	REG_WR(ISP_RGB_AFM_SPSMD_THRESHOLD_MAX, spsmd_threshold.max);
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_win(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int i = 0;
+	int max_num = ISP_AFM_WIN_NUM_V1;
+	struct isp_coord coord[ISP_AFM_WIN_NUM_V1];
+	uint32_t val = 0;
+
+
+	memset(coord, 0, sizeof(coord));
+	ret = copy_from_user((void *)&coord, param->property_param, sizeof(coord));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_win: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	for (i = 0; i < max_num; i++) {
+		val = ((coord[i].start_y <<16) & 0xffff0000)
+				| (coord[i].start_x & 0xffff);
+		REG_WR((ISP_RGB_AFM_WIN_RANGE0 + 4*2*i), val);
+
+		val = ((coord[i].end_y <<16) & 0xffff0000)
+			| (coord[i].end_x & 0xffff);
+		REG_WR((ISP_RGB_AFM_WIN_RANGE0 + 4*(2*i+1)), val);
+	}
+
+	return ret;
+}
+
+
+static int32_t isp_k_raw_afm_win_num(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t num = ISP_AFM_WIN_NUM_V1;
+
+	ret = copy_to_user(param->property_param, (void*)&num, sizeof(num));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_raw_afm_win_num: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_rgb_afm(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_afm: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_afm: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_RGB_AFM_BLOCK:
+		ret = isp_k_raw_afm_block(param);
+		break;
+	case ISP_PRO_RGB_AFM_FRAME_SIZE:
+		ret = isp_k_raw_afm_frame_range(param);
+		break;
+	case ISP_PRO_RGB_AFM_TYPE1_STATISTIC:
+		ret = isp_k_raw_afm_type1_statistic(param);
+		break;
+	case ISP_PRO_RGB_AFM_TYPE2_STATISTIC:
+		ret = isp_k_raw_afm_type2_statistic(param);
+		break;
+	case ISP_PRO_RGB_AFM_BYPASS:
+		ret = isp_k_raw_afm_bypass(param);
+		break;
+	case ISP_PRO_RGB_AFM_MODE:
+		ret = isp_k_raw_afm_mode(param);
+		break;
+	case ISP_PRO_RGB_AFM_SKIP_NUM:
+		ret = isp_k_raw_afm_skip_num(param);
+		break;
+	case ISP_PRO_RGB_AFM_SKIP_NUM_CLR:
+		ret = isp_k_raw_afm_skip_num_clr(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_RTGBOT_ENABLE:
+		ret = isp_k_raw_afm_spsmd_rtgbot_enable(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_DIAGONAL_ENABLE:
+		ret = isp_k_raw_afm_spsmd_diagonal_enable(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_CAL_MOD:
+		ret = isp_k_raw_afm_spsmd_cal_mode(param);
+		break;
+	case ISP_PRO_RGB_AFM_SEL_FILTER1:
+		ret = isp_k_raw_afm_sel_filter1(param);
+		break;
+	case ISP_PRO_RGB_AFM_SEL_FILTER2:
+		ret = isp_k_raw_afm_sel_filter2(param);
+		break;
+	case ISP_PRO_RGB_AFM_SOBEL_TYPE:
+		ret = isp_k_raw_afm_sobel_type(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_TYPE:
+		ret = isp_k_raw_afm_spsmd_type(param);
+		break;
+	case ISP_PRO_RGB_AFM_SOBEL_THRESHOLD:
+		ret = isp_k_raw_afm_sobel_threshold(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_THRESHOLD:
+		ret = isp_k_raw_afm_spsmd_threshold(param);
+		break;
+	case ISP_PRO_RGB_AFM_WIN:
+		ret = isp_k_raw_afm_win(param);
+		break;
+	case ISP_PRO_RGB_AFM_WIN_NUM:
+		ret = isp_k_raw_afm_win_num(param);
+		break;
+	default:
+		printk("isp_k_cfg_afm: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb2y.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb2y.c
new file mode 100644
index 00000000..3cc48264
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb2y.c
@@ -0,0 +1,62 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_rgb2y_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_rgb2y_info rgb2y_info;
+
+	memset(&rgb2y_info, 0x00, sizeof(rgb2y_info));
+
+	ret = copy_from_user((void *)&rgb2y_info, param->property_param, sizeof(rgb2y_info));
+	if (0 != ret) {
+		printk("isp_k_rgb2y_block: copy error, ret = 0x%x \n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_Y_RGB2Y_PARAM, 0x3, rgb2y_info.signal_sel);
+
+	return -1;
+}
+
+int32_t isp_k_cfg_rgb2y(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_rgb2y: param is null error \n");
+		return -1;
+	}
+
+	if (!param->property_param) {
+		printk("isp_k_cfg_rgb2y: property_param is null error \n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_RGB2Y_BLOCK:
+		ret = isp_k_rgb2y_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_rgb2y: fail cmd id %d, not supported \n", param->property);
+		break;
+	}
+
+	return ret;
+}
\ No newline at end of file
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_afm.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_afm.c
new file mode 100644
index 00000000..25f8326b
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_afm.c
@@ -0,0 +1,415 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+
+#define ISP_AFM_WIN_NUM_V1  25
+
+static int32_t isp_k_rgb_afm_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_bypass: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (bypass) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_mode(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t mode = 0;
+
+	ret = copy_from_user((void *)&mode, param->property_param, sizeof(mode));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_mode: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (mode) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_1, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_skip_num(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t skip_num = 0;
+
+	ret = copy_from_user((void *)&skip_num, param->property_param, sizeof(skip_num));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_skip_num: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_RGB_AFM_PARAM, 0xF<<2, (skip_num <<2));
+
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_skip_num_clr(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t is_clear = 0;
+
+	ret = copy_from_user((void *)&is_clear, param->property_param, sizeof(is_clear));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_skip_num_clr: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (is_clear) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_6);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_6, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_spsmd_rtgbot_enable(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t is_enable = 0;
+
+	ret = copy_from_user((void *)&is_enable, param->property_param, sizeof(is_enable));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_spsmd_rtgbot_enable: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (is_enable) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_7);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_7, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_spsmd_diagonal_enable(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t is_enable = 0;
+
+	ret = copy_from_user((void *)&is_enable, param->property_param, sizeof(is_enable));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_spsmd_diagonal_enable: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (is_enable) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_8);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_8, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_spsmd_cal_mode(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t cal_mode = 0;
+
+	ret = copy_from_user((void *)&cal_mode, param->property_param, sizeof(cal_mode));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_spsmd_cal_mode: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	if (cal_mode) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_9);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_9, 0);
+	}
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_sel_filter1(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t af_sel_filter = 0;
+
+	ret = copy_from_user((void *)&af_sel_filter, param->property_param, sizeof(af_sel_filter));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_sel_filter1: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	if (af_sel_filter) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_10);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_10, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_sel_filter2(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t af_sel_filter = 0;
+
+	ret = copy_from_user((void *)&af_sel_filter, param->property_param, sizeof(af_sel_filter));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	if (af_sel_filter) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_11);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_11, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_sobel_type(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t sobel_type = 0;
+
+	ret = copy_from_user((void *)&sobel_type, param->property_param, sizeof(sobel_type));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (sobel_type) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_12);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_12, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_spsmd_type(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t spsmd_type = 0;
+
+	ret = copy_from_user((void *)&spsmd_type, param->property_param, sizeof(spsmd_type));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_RGB_AFM_PARAM, (BIT_13)|(BIT_14), spsmd_type<<13);
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_sobel_threshold(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct sobel_thrd sobel_threshold = {0, 0};
+
+	ret = copy_from_user((void *)&sobel_threshold, param->property_param, sizeof(sobel_threshold));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	val = ((sobel_threshold.max<<16) & 0xffff0000)
+			| (sobel_threshold.min & 0xffff);
+	REG_WR(ISP_RGB_AFM_SOBEL_THRESHOLD, val);
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_spsmd_threshold(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct spsmd_thrd spsmd_threshold = {0, 0};
+
+	ret = copy_from_user((void *)&spsmd_threshold, param->property_param, sizeof(spsmd_threshold));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_spsmd_threshold: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	REG_WR(ISP_RGB_AFM_SPSMD_THRESHOLD_MIN, spsmd_threshold.min);
+	REG_WR(ISP_RGB_AFM_SPSMD_THRESHOLD_MAX, spsmd_threshold.max);
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_frame_range(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct frm_size  frame_size = {0, 0};
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&frame_size, param->property_param, sizeof(frame_size));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_frame_range: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (frame_size.height & 0xFFFF) | ((frame_size.width & 0xFFFF) << 16);
+	REG_WR(ISP_RGB_AFM_FRAME_RANGE, val);
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_win(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int i = 0;
+	int max_num = ISP_AFM_WIN_NUM_V1;
+	struct isp_coord coord[ISP_AFM_WIN_NUM_V1];
+	uint32_t val = 0;
+
+
+	memset(coord, 0, sizeof(coord));
+	ret = copy_from_user((void *)&coord, param->property_param, sizeof(coord));
+	if (0 != ret) {
+		printk("isp_k_rgb_afm_win: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	for (i = 0; i < max_num; i++) {
+		val = ((coord[i].start_y <<16) & 0xffff0000)
+				| (coord[i].start_x & 0xffff);
+		REG_WR((ISP_RGB_AFM_WIN_RANGE0 + 4*2*i), val);
+
+		val = ((coord[i].end_y <<16) & 0xffff0000)
+			| (coord[i].end_x & 0xffff);
+		REG_WR((ISP_RGB_AFM_WIN_RANGE0 + 4*(2*i+1)), val);
+	}
+
+	return ret;
+}
+
+
+static int32_t isp_k_rgb_afm_statistic(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int i = 0;
+	int max_item = ISP_AFM_WIN_NUM_V1;
+	struct afm_statistic item[ISP_AFM_WIN_NUM_V1];
+	uint32_t val = 0;
+	memset(item, 0, sizeof(item));
+	for (i = 0; i < max_item; i++) {
+		val = REG_RD((ISP_RGB_AFM_TYPE1_VAL00 + 4*i));
+		item[i].val = val;
+	}
+	ret = copy_to_user(param->property_param, (void*)&item, sizeof(item));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_rgb_afm_statistic: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_rgb_afm_win_num(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t num = ISP_AFM_WIN_NUM_V1;
+
+	ret = copy_to_user(param->property_param, (void*)&num, sizeof(num));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_rgb_afm_win_num: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_rgb_afm(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_afm: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_afm: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_RGB_AFM_BYPASS:
+		ret = isp_k_rgb_afm_bypass(param);
+		break;
+	case ISP_PRO_RGB_AFM_MODE:
+		ret = isp_k_rgb_afm_mode(param);
+		break;
+	case ISP_PRO_RGB_AFM_SKIP_NUM:
+		ret = isp_k_rgb_afm_skip_num(param);
+		break;
+	case ISP_PRO_RGB_AFM_SKIP_NUM_CLR:
+		ret = isp_k_rgb_afm_skip_num_clr(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_RTGBOT_ENABLE:
+		ret = isp_k_rgb_afm_spsmd_rtgbot_enable(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_DIAGONAL_ENABLE:
+		ret = isp_k_rgb_afm_spsmd_diagonal_enable(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_CAL_MOD:
+		ret = isp_k_rgb_afm_spsmd_cal_mode(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_SEL_FILTER1:
+		ret = isp_k_rgb_afm_sel_filter1(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_SEL_FILTER2:
+		ret = isp_k_rgb_afm_sel_filter2(param);
+		break;
+	case ISP_PRO_RGB_AFM_SOBEL_TYPE:
+		ret = isp_k_rgb_afm_sobel_type(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_TYPE:
+		ret = isp_k_rgb_afm_spsmd_type(param);
+		break;
+	case ISP_PRO_RGB_AFM_SOBEL_THRESHOLD:
+		ret = isp_k_rgb_afm_sobel_threshold(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_THRESHOLD:
+		ret = isp_k_rgb_afm_spsmd_threshold(param);
+		break;
+	case ISP_PRO_RGB_AFM_FRAME_RANGE:
+		ret = isp_k_rgb_afm_frame_range(param);
+		break;
+	case ISP_PRO_RGB_AFM_WIN:
+		ret = isp_k_rgb_afm_win(param);
+		break;
+	case ISP_PRO_RGB_AFM_STATISTIC:
+		ret = isp_k_rgb_afm_statistic(param);
+		break;
+	case ISP_PRO_RGB_AFM_WIN_NUM:
+		ret = isp_k_rgb_afm_win_num(param);
+		break;
+	default:
+		printk("isp_k_cfg_afm: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_gain.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_gain.c
new file mode 100644
index 00000000..5cc2c554
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_gain.c
@@ -0,0 +1,69 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_rgb_gain_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_rgb_gain_info_v1 gain_info;
+
+	ret = copy_from_user((void *)&gain_info, param->property_param, sizeof(gain_info));
+	if (0 != ret) {
+		printk("isp_k_rgb_gain_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (gain_info.global_gain & 0xFFFF) << 16;
+	REG_MWR(ISP_RGBG_PARAM, 0xFFFF0000, val);
+
+	val = ((gain_info.r_gain & 0xFFFF) << 16) | (gain_info.b_gain & 0xFFFF);
+	REG_WR(ISP_RGBG_RB, val);
+	val = gain_info.g_gain & 0xFFFF;
+	REG_WR(ISP_RGBG_G, val);
+
+	REG_MWR(ISP_RGBG_PARAM, BIT_0, gain_info.bypass);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_rgb_gain(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_rgb_gain: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_rgb_gain: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_RGB_GAIN_BLOCK:
+		ret = isp_k_rgb_gain_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_rgb_gain: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_gain2.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_gain2.c
new file mode 100644
index 00000000..a8b31537
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_gain2.c
@@ -0,0 +1,67 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_rgb_gain2_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_rgb_gain2_info gain_info;
+
+	ret = copy_from_user((void *)&gain_info, param->property_param, sizeof(gain_info));
+	if (0 != ret) {
+		printk("isp_k_rgb_gain2_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((gain_info.r_gain & 0xFF) << 24) | ((gain_info.g_gain & 0xFF) << 16) | ((gain_info.b_gain & 0xFF) << 8);
+	REG_MWR(ISP_RGBG2_PARAM, 0xFFFFFF00, val);
+
+	val = ((gain_info.r_offset & 0x3FF) << 20) | ((gain_info.g_offset & 0x3FF) << 10) | (gain_info.b_offset & 0x3FF);
+	REG_WR(ISP_RGBG2_OFFSET, val);
+
+	REG_MWR(ISP_RGBG2_PARAM, BIT_0, gain_info.bypass);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_rgb_gain2(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_rgb_gain2: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_rgb_gain2: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_RGB_GAIN2_BLOCK:
+		ret = isp_k_rgb_gain2_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_rgb_gain2: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_store.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_store.c
new file mode 100644
index 00000000..2ae73bec
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_store.c
@@ -0,0 +1,101 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_store_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_store_info_v1 store_info;
+
+	memset(&store_info, 0x00, sizeof(store_info));
+
+	ret = copy_from_user((void *)&store_info, param->property_param, sizeof(store_info));
+	if (0 != ret) {
+		printk("isp_k_store_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (store_info.substract) {
+		REG_OWR(ISP_STORE_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_STORE_PARAM, BIT_1, 0);
+	}
+
+	REG_MWR(ISP_STORE_PARAM, 0xF0, (store_info.color_format << 4));
+
+	REG_WR(ISP_STORE_Y_ADDR, store_info.addr.chn0);
+	REG_WR(ISP_STORE_Y_PITCH, store_info.pitch.chn0);
+	REG_WR(ISP_STORE_U_ADDR, store_info.addr.chn1);
+	REG_WR(ISP_STORE_U_PITCH, store_info.pitch.chn1);
+	REG_WR(ISP_STORE_V_ADDR, store_info.addr.chn2);
+	REG_WR(ISP_STORE_V_PITCH, store_info.pitch.chn2);
+
+	if (store_info.bypass) {
+		REG_OWR(ISP_STORE_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_STORE_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_store_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0, 0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_store_slice_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height& 0xFFFF) << 16) | (size.width & 0xFFFF);
+	REG_WR(ISP_STORE_SLICE_SIZE, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_store(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_store: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_store: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_STORE_BLOCK:
+		ret = isp_k_store_block(param);
+		break;
+	case ISP_PRO_STORE_SLICE_SIZE:
+		ret = isp_k_store_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_store: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_uv_prefilter.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_uv_prefilter.c
new file mode 100644
index 00000000..7ee3dc90
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_uv_prefilter.c
@@ -0,0 +1,68 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_uv_prefilter_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_uv_prefilter_info uv_info;
+
+	memset(&uv_info, 0x00, sizeof(uv_info));
+
+	ret = copy_from_user((void *)&uv_info, param->property_param, sizeof(uv_info));
+	if (0 != ret) {
+		printk("isp_k_uv_prefilter_block: copy error, ret = 0x%x \n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_UV_PREF_PARAM, BIT_1, uv_info.writeback << 1);
+
+	val = (uv_info.nr_thr_u & 0xFF) | ((uv_info.nr_thr_v & 0xFF) << 8);
+	REG_WR(ISP_UV_PREF_THRD, val);
+
+	REG_MWR(ISP_UV_PREF_PARAM, BIT_0, uv_info.bypass);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_uv_prefilter(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_uv_prefilter: param is null error \n");
+		return -1;
+	}
+
+	if (!param->property_param) {
+		printk("isp_k_cfg_uv_prefilter: property_param is null error \n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_UV_PREFILTER_BLOCK:
+		ret = isp_k_uv_prefilter_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_uv_prefilter: fail cmd id %d, not supported \n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_y_delay.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_y_delay.c
new file mode 100644
index 00000000..b735c790
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_y_delay.c
@@ -0,0 +1,63 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_ydelay_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_ydelay_info ydelay_info;
+
+	ret = copy_from_user((void *)&ydelay_info, param->property_param, sizeof(ydelay_info));
+	if (0 != ret) {
+		printk("isp_k_ydelay_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (ydelay_info.bypass) {
+		REG_OWR(ISP_YDELAY_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_YDELAY_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_ydelay(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_ydelay: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_ydelay: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_YDELAY_BLOCK:
+		ret = isp_k_ydelay_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_ydelay: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_y_gamma.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_y_gamma.c
new file mode 100644
index 00000000..ea66f99d
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_y_gamma.c
@@ -0,0 +1,133 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+
+#define ISP_YUV_YGAMMA_BUF0      0
+#define ISP_YUV_YGAMMA_BUF1      1
+
+static int32_t isp_k_pingpang_yuv_ygamma(struct coordinate_xy *nodes,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t i = 0, j = 0;
+	unsigned long ybuf_addr = 0;
+	struct coordinate_xy *p_nodes = NULL;
+
+	if (!nodes) {
+		ret = -1;
+		printk("isp_k_pingpang_yuv_ygamma: node is null error .\n");
+		return ret;
+	}
+	p_nodes = nodes;
+
+#if 0
+	if (ISP_YUV_YGAMMA_BUF0 == isp_private->yuv_ygamma_buf_id) {
+		ybuf_addr = ISP_YGAMMA_BUF0_CH0;
+		isp_private->yuv_ygamma_buf_id = ISP_YUV_YGAMMA_BUF1;
+	} else {
+		ybuf_addr = ISP_YGAMMA_BUF0_CH0;
+		isp_private->yuv_ygamma_buf_id = ISP_YUV_YGAMMA_BUF0;
+	}
+#endif
+
+	isp_private->yuv_ygamma_buf_id = ISP_YUV_YGAMMA_BUF0;
+	if (isp_private->yuv_ygamma_buf_id) {
+		REG_OWR(ISP_YGAMMA_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_YGAMMA_PARAM, BIT_1, 0);
+	}
+
+	ybuf_addr = ISP_YGAMMA_BUF0_CH0;
+	isp_private->yuv_ygamma_buf_id = ISP_YUV_YGAMMA_BUF1;
+
+	for (i = 0, j = 0; i < ISP_PINGPANG_YUV_YGAMMA_NUM; i++, j += 4) {
+		REG_WR(ybuf_addr + j, p_nodes[i].node_y & 0xff);
+	}
+
+	if (isp_private->yuv_ygamma_buf_id) {
+		REG_OWR(ISP_YGAMMA_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_YGAMMA_PARAM, BIT_1, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_ygamma_block(struct isp_io_param *param,
+	struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t bypass;
+	struct isp_dev_ygamma_info *ygamma_info = (struct isp_dev_ygamma_info *)param->property_param;
+	struct coordinate_xy *nodes = NULL;
+
+	nodes = (struct coordinate_xy *)isp_private->yuv_ygamma_buf_addr;
+	if (!nodes) {
+		ret = -1;
+		printk("isp_k_ygamma_block: alloc memory error.\n");
+		return -1;
+	}
+
+	ret = copy_from_user((void *)&bypass, (void *)&ygamma_info->bypass, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_ygamma_block: copy bypass error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	ret = copy_from_user((void *)nodes, (void *)ygamma_info->nodes, ISP_YUV_YGAMMA_BUF_SIZE);
+	if (0 != ret) {
+		printk("isp_k_ygamma_block: copy nodes error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	ret = isp_k_pingpang_yuv_ygamma(nodes, isp_private);
+	if (0 != ret) {
+		printk("isp_k_ygamma_block: pingpang error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	REG_MWR(ISP_YGAMMA_PARAM, BIT_0, bypass);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_ygamma(struct isp_io_param *param,
+	struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_ygamma: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_ygamma: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_YGAMMA_BLOCK:
+		ret = isp_k_ygamma_block(param, isp_private);
+		break;
+	default:
+		printk("isp_k_cfg_ygamma: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yiq_aem.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yiq_aem.c
new file mode 100644
index 00000000..fe8710a9
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yiq_aem.c
@@ -0,0 +1,121 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_yiq_aem_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_yiq_aem_info_v2 yaem_info;
+
+	memset(&yaem_info, 0x00, sizeof(yaem_info));
+
+	ret = copy_from_user((void *)&yaem_info, param->property_param, sizeof(yaem_info));
+	if (0 != ret) {
+		printk("isp_k_yiq_aem_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_YIQ_AEM_PARAM, BIT_7, yaem_info.ygamma_bypass << 7);
+
+	val = ((yaem_info.gamma_xnode[0] & 0xFF)<<24) | ((yaem_info.gamma_xnode[1] & 0xFF)<<16)
+		| ((yaem_info.gamma_xnode[2] & 0xFF)<<8) | (yaem_info.gamma_xnode[3] & 0xFF);
+	REG_WR(ISP_YIQ_YGAMMA_NODE_X0 , val);
+	val = ((yaem_info.gamma_xnode[4] & 0xFF)<<24) | ((yaem_info.gamma_xnode[5] & 0xFF)<<16)
+		| ((yaem_info.gamma_xnode[6] & 0xFF)<<8) | (yaem_info.gamma_xnode[7] & 0xFF);
+	REG_WR(ISP_YIQ_YGAMMA_NODE_X1 , val);
+
+	val = ((yaem_info.gamma_ynode[0] & 0xFF)<<24) | ((yaem_info.gamma_ynode[1] & 0xFF)<<16)
+		| ((yaem_info.gamma_ynode[2] & 0xFF)<<8) | (yaem_info.gamma_ynode[3] & 0xFF);
+	REG_WR( ISP_YIQ_YGAMMA_NODE_Y0 , val);
+	val = ((yaem_info.gamma_ynode[4] & 0xFF)<<24) | ((yaem_info.gamma_ynode[5] & 0xFF)<<16)
+		| ((yaem_info.gamma_ynode[6] & 0xFF)<<8) | (yaem_info.gamma_ynode[7] & 0xFF);
+	REG_WR(ISP_YIQ_YGAMMA_NODE_Y1 , val);
+	val = ((yaem_info.gamma_ynode[8] & 0xFF)<<24) | ((yaem_info.gamma_ynode[9] & 0xFF)<<16);
+	REG_WR(ISP_YIQ_YGAMMA_NODE_Y2 , val);
+
+	val = ((yaem_info.gamma_node_idx[1]&0x7) << 24) | ((yaem_info.gamma_node_idx[2]&0x7) << 21) |
+			((yaem_info.gamma_node_idx[3]&0x7) << 18) | ((yaem_info.gamma_node_idx[4]&0x7) << 15) |
+			((yaem_info.gamma_node_idx[5]&0x7) << 12) | ((yaem_info.gamma_node_idx[6]&0x7) <<  9) |
+			((yaem_info.gamma_node_idx[7]&0x7) <<  6) | ((yaem_info.gamma_node_idx[8]&0x7) <<  3) |
+			(yaem_info.gamma_node_idx[9]&0x7);
+	REG_WR( ISP_YIQ_YGAMMA_NODE_IDX, val);
+
+	REG_MWR(ISP_YIQ_AEM_PARAM, BIT_0, yaem_info.aem_bypass);
+
+	REG_MWR(ISP_YIQ_AEM_PARAM, BIT_1, yaem_info.aem_mode << 1);
+
+	REG_MWR(ISP_YIQ_AEM_PARAM, 0xF << 2, yaem_info.aem_skip_num << 2);
+
+	val = (yaem_info.offset_x & 0xFFFF) | ((yaem_info.offset_y & 0xFFFF) << 16);
+	REG_WR( ISP_YIQ_AEM_OFFSET, val);
+
+	val = (yaem_info.width& 0x1FF) | ((yaem_info.height& 0x1FF) << 9) | ((yaem_info.avgshift & 0x1F) << 18);
+	REG_WR( ISP_YIQ_AEM_BLK_SIZE, val);
+
+	return ret;
+
+}
+
+static int32_t isp_k_yiq_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size slice_size= {0, 0};
+
+	ret = copy_from_user((void *)&slice_size, param->property_param, sizeof(slice_size));
+	if (0 != ret) {
+		printk("isp_k_ae_skip_num: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (slice_size.width&  0xFFFF) | ((slice_size.height&  0xFFFF) << 16);
+	REG_WR( ISP_YIQ_AEM_SLICE_SIZE, val);
+
+
+	return ret;
+}
+
+int32_t isp_k_cfg_yiq_aem(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_yiq: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_yiq: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_YIQ_AEM_BLOCK:
+		ret = isp_k_yiq_aem_block(param);
+		break;
+	case ISP_PRO_YIQ_AEM_SLICE_SIZE:
+		ret = isp_k_yiq_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_yiq: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yiq_afm.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yiq_afm.c
new file mode 100644
index 00000000..20df0101
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yiq_afm.c
@@ -0,0 +1,120 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+#define ISP_AFM_WIN_NUM_V1  25
+
+static int32_t isp_k_yiq_afm_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	int max_num = ISP_AFM_WIN_NUM_V1;
+	struct isp_dev_yiq_afm_info_v2 afm_info;
+
+	memset(&afm_info, 0x00, sizeof(afm_info));
+
+	ret = copy_from_user((void *)&afm_info, param->property_param, sizeof(afm_info));
+	if (0 != ret) {
+		printk("isp_k_yiq_afm_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, BIT_6, afm_info.mode << 6);
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, 0x1F<<1, (afm_info.shift << 1));
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, 0xF<<7, (afm_info.skip_num << 7));
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, BIT_11, afm_info.skip_num_clear << 11);
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, BIT_12, afm_info.af_position << 12);
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, 0x7<<13, (afm_info.format << 13));
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, BIT_16, afm_info.iir_bypass << 16);
+
+	for (i = 0; i < max_num; i++) {
+		val = ((afm_info.coord[i].start_y <<16) & 0xffff0000)
+				| (afm_info.coord[i].start_x & 0xffff);
+		REG_WR((ISP_YIQ_AFM_WIN_RANGE0 + 4*2*i), val);
+
+		val = ((afm_info.coord[i].end_y <<16) & 0xffff0000)
+			| (afm_info.coord[i].end_x & 0xffff);
+		REG_WR((ISP_YIQ_AFM_WIN_RANGE0 + 4*(2*i+1)), val);
+	}
+
+	for (i = 0; i < 10; i+= 2) {
+		val = (afm_info.IIR_c[i] & 0xFFF) | ((afm_info.IIR_c[i + 1] & 0xFFF) << 16);
+		REG_WR(ISP_YIQ_AFM_COEF0_1 + (i / 2) * 4, val);
+	}
+	val = afm_info.IIR_c[10] & 0xFFF;
+	REG_WR(ISP_YIQ_AFM_COEF10, val);
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, BIT_0, afm_info.bypass);
+
+	return ret;
+
+}
+
+static int32_t isp_k_yiq_afm_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size slice_size= {0, 0};
+
+	ret = copy_from_user((void *)&slice_size, param->property_param, sizeof(slice_size));
+	if (0 != ret) {
+		printk("isp_k_ae_skip_num: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (slice_size.width&  0xFFFF) | ((slice_size.height&  0xFFFF) << 16);
+	REG_WR( ISP_YIQ_AFM_SLICE_SIZE, val);
+
+
+	return ret;
+}
+
+int32_t isp_k_cfg_yiq_afm(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_afm: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_afm: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_YIQ_AFM_BLOCK:
+		ret = isp_k_yiq_afm_block(param);
+		break;
+	case ISP_PRO_YIQ_AFM_SLICE_SIZE:
+		ret = isp_k_yiq_afm_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_yiq_afm: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yuv_nlm.c b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yuv_nlm.c
new file mode 100644
index 00000000..d0b5d063
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yuv_nlm.c
@@ -0,0 +1,135 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_yuv_nlm_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t i =0;
+	uint32_t val = 0;
+	struct isp_dev_yuv_nlm_info ynlm_info;
+
+	memset(&ynlm_info, 0x00, sizeof(ynlm_info));
+
+	ret = copy_from_user((void *)&ynlm_info, param->property_param, sizeof(ynlm_info));
+	if (0 != ret) {
+		printk("isp_k_yuv_nlm_block: copy error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_YNLM_PARAM, BIT_0, ynlm_info.nlm_bypass);
+	REG_MWR(ISP_YNLM_PARAM, BIT_1, ynlm_info.nlm_radial_bypass << 1);
+	REG_MWR(ISP_YNLM_PARAM, BIT_2, ynlm_info.nlm_adaptive_bypass << 2);
+	REG_MWR(ISP_YNLM_PARAM, BIT_3, ynlm_info.nlm_vst_bypass << 3);
+
+	for (i = 0;i < 7; i++) {
+		val = (ynlm_info.edge_str_cmp[i] & 0x3FF) | ((ynlm_info.edge_str_req[i] & 0x7F) << 10);
+		REG_WR(ISP_YNLM_ADAPT_PARAM1 + i * 4, val);
+	}
+
+	val = (ynlm_info.edge_range_l & 0xFF) | ((ynlm_info.edge_range_h & 0xFF) << 8) |
+		((ynlm_info.edge_time_str & 0x3) << 16) | ((ynlm_info.avg_mode & 0x3) << 18);
+	REG_WR(ISP_YNLM_ADAPT_PARAM8, val);
+
+	REG_MWR(ISP_YNLM_DEN_STERNGTH, 0x7F, ynlm_info.den_strength);
+
+	val = (ynlm_info.center_x & 0x1FFF) | ((ynlm_info.center_y & 0xFFF) << 13);
+	REG_WR(ISP_YNLM_CENTER, val);
+
+	val = ynlm_info.center_x2 & 0x3FFFFFF;
+	REG_WR(ISP_YNLM_CENTER_X2, val);
+
+	val = ynlm_info.center_y2 & 0xFFFFFF;
+	REG_WR(ISP_YNLM_CENTER_Y2, val);
+
+	val = ynlm_info.radius & 0x3FFFFFF;
+	REG_WR(ISP_YNLM_RADIUS, val);
+
+	val = (ynlm_info.radius_p1 & 0x7FF) | ((ynlm_info.radius_p2 & 0x3FFF) << 11);
+	REG_WR(ISP_YNLM_RADIUS_RANGE, val);
+
+	val = ynlm_info.gain_max & 0xFFF;
+	REG_WR(ISP_YNLM_GAIN_MAX, val);
+
+	val = (ynlm_info.start_raw & 0xFFF) | ((ynlm_info.start_col & 0x1FFF) << 12);
+	REG_WR(ISP_YNLM_IMG_PARAM1, val);
+
+	val = ynlm_info.add_back & 0x7F;
+	REG_WR(ISP_YNLM_ADD_BACK, val);
+
+	for (i = 0; i < 24; i++) {
+		val = ynlm_info.lut_w[i] & 0x3FFFFFFF;
+		REG_WR(ISP_YNLM_LUT_W_0 + i * 4, val);
+	}
+
+	for (i = 0; i < 64; i++) {
+		val = ynlm_info.lut_vs[i];
+		REG_WR(ISP_YNLM_LUT_VS_0 + i * 4, val);
+	}
+
+	REG_WR(ISP_YNLM_IMG_PARAM0, (((2592 & 0xFFF) << 12) | (1944 & 0xFFF)));
+
+	return ret;
+
+}
+
+static int32_t isp_k_yuv_nlm_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size slice_size;
+
+	ret = copy_from_user((void *)&slice_size, param->property_param, sizeof(slice_size));
+	if (0 != ret) {
+		printk("isp_k_yuv_nlm_slice_size: copy_from_user error, ret = 0x%x\n",(uint32_t)ret);
+		return -1;
+	}
+
+	val = (slice_size.height & 0xFFF) | ((slice_size.width & 0x1FFF) << 12);
+	REG_WR(ISP_YNLM_IMG_PARAM0, val);
+
+	return -1;
+}
+
+int32_t isp_k_cfg_yuv_nlm(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_yuv_nlm: param is null error \n");
+		return -1;
+	}
+
+	if (!param->property_param) {
+		printk("isp_k_cfg_yuv_nlm: property_param is null error \n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_YUV_NLM_BLOCK:
+		ret = isp_k_yuv_nlm_block(param);
+		break;
+	case ISP_PRO_YUV_NLM_SLICE_SIZE:
+		ret = isp_k_yuv_nlm_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_yuv_nlm: fail cmd id is %d, not supported \n", param->property);
+		break;
+	}
+
+	return ret;
+}
\ No newline at end of file
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/inc/isp_block.h b/drivers/media/sprd_isp/isp2.0/tshark2/inc/isp_block.h
new file mode 100644
index 00000000..0a18650c
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/inc/isp_block.h
@@ -0,0 +1,67 @@
+/*
+ * 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 "isp_drv.h"
+
+int32_t isp_k_cfg_pgg(struct isp_io_param *param);
+int32_t isp_k_cfg_blc(struct isp_io_param *param);
+int32_t isp_k_cfg_rgb_gain(struct isp_io_param *param);
+int32_t isp_k_cfg_pwd(struct isp_io_param *param);
+int32_t isp_k_cfg_nlc(struct isp_io_param *param);
+int32_t isp_k_cfg_2d_lsc(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_1d_lsc(struct isp_io_param *param);
+int32_t isp_k_cfg_binning(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_awb(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_raw_aem(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_bpc(struct isp_io_param *param);
+int32_t isp_k_cfg_bdn(struct isp_io_param *param);
+int32_t isp_k_cfg_grgb(struct isp_io_param *param);
+int32_t isp_k_cfg_rgb_gain2(struct isp_io_param *param);
+int32_t isp_k_cfg_nlm(struct isp_io_param *param);
+int32_t isp_k_cfg_cfa(struct isp_io_param *param);
+int32_t isp_k_cfg_cmc10(struct isp_io_param *param);
+int32_t isp_k_cfg_gamma(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_cmc8(struct isp_io_param *param);
+int32_t isp_k_cfg_ct(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_hsv(struct isp_io_param *param);
+int32_t isp_k_cfg_rgb_afm(struct isp_io_param *param);
+int32_t isp_k_cfg_cce(struct isp_io_param *param);
+int32_t isp_k_cfg_pre_cdn_rgb(struct isp_io_param *param);
+int32_t isp_k_cfg_yuv_precdn(struct isp_io_param *param);
+int32_t isp_k_cfg_posterize(struct isp_io_param *param);
+int32_t isp_k_cfg_csc(struct isp_io_param *param);
+int32_t isp_k_cfg_yiq_aem(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_anti_flicker(struct isp_io_param *param, struct isp_k_private *isp_private);
+int32_t isp_k_cfg_yiq_afm(struct isp_io_param *param);
+int32_t isp_k_cfg_prefilter(struct isp_io_param *param);
+int32_t isp_k_cfg_brightness(struct isp_io_param *param);
+int32_t isp_k_cfg_contrast(struct isp_io_param *param);
+int32_t isp_k_cfg_hist(struct isp_io_param *param);
+int32_t isp_k_cfg_hist2(struct isp_io_param *param);
+int32_t isp_k_cfg_aca(struct isp_io_param *param);
+int32_t isp_k_cfg_yuv_cdn(struct isp_io_param *param);
+int32_t isp_k_cfg_edge(struct isp_io_param *param);
+int32_t isp_k_cfg_css(struct isp_io_param *param);
+int32_t isp_k_cfg_csa(struct isp_io_param *param);
+int32_t isp_k_cfg_post_cdn(struct isp_io_param *param);
+int32_t isp_k_cfg_hue(struct isp_io_param *param);
+int32_t isp_k_cfg_emboss(struct isp_io_param *param);
+int32_t isp_k_cfg_ydelay(struct isp_io_param *param);
+int32_t isp_k_cfg_ygamma(struct isp_io_param *param, struct isp_k_private *isp_private);;
+int32_t isp_k_cfg_iircnr(struct isp_io_param *param);
+int32_t isp_k_cfg_fetch(struct isp_io_param *param);
+int32_t isp_k_cfg_store(struct isp_io_param *param);
+int32_t isp_k_cfg_dispatch(struct isp_io_param *param);
+int32_t isp_k_cfg_arbiter(struct isp_io_param *param);
+int32_t isp_k_cfg_common(struct isp_io_param *param);
+int32_t isp_k_cfg_raw_sizer(struct isp_io_param *param);
\ No newline at end of file
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/inc/isp_drv.h b/drivers/media/sprd_isp/isp2.0/tshark2/inc/isp_drv.h
new file mode 100644
index 00000000..444a1b27
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/inc/isp_drv.h
@@ -0,0 +1,95 @@
+/*
+ * 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.
+ */
+
+#ifndef _ISP_DRV_HEADER_
+#define _ISP_DRV_HEADER_
+
+#include <linux/semaphore.h>
+#include <linux/spinlock_types.h>
+
+#define ISP_QUEUE_LENGTH 16
+#define ISP_BING4AWB_NUM 2
+
+
+struct isp_node {
+	uint32_t irq_val0;
+	uint32_t irq_val1;
+	uint32_t irq_val2;
+	uint32_t irq_val3;
+	uint32_t reserved;
+	struct isp_time time;
+};
+
+struct isp_queue {
+	struct isp_node node[ISP_QUEUE_LENGTH];
+	struct isp_node *write;
+	struct isp_node *read;
+};
+
+struct isp_b4awb_buf {
+	uint32_t buf_id;
+	uint32_t buf_flag;
+	unsigned long buf_phys_addr;
+};
+
+struct isp_k_private {
+	atomic_t users;
+	struct device_node *dn;
+	struct clk *clock;
+	struct semaphore device_lock;
+	struct semaphore ioctl_lock;
+	unsigned long block_buf_addr;
+	uint32_t block_buf_len;
+	unsigned long reg_buf_addr;
+	uint32_t reg_buf_len;
+	uint32_t lsc_load_buf_id;
+	uint32_t lsc_update_buf_id;
+	unsigned long raw_aem_buf_addr;
+	uint32_t raw_aem_buf_len;
+	uint32_t ct_load_buf_id;
+	unsigned long full_gamma_buf_addr;
+	uint32_t full_gamma_buf_len;
+	uint32_t full_gamma_buf_id;
+	unsigned long yuv_ygamma_buf_addr;
+	uint32_t yuv_ygamma_buf_len;
+	uint32_t yuv_ygamma_buf_id;
+	unsigned long raw_awbm_buf_addr;
+	uint32_t raw_awbm_buf_len;
+	struct isp_b4awb_buf b4awb_buf[ISP_BING4AWB_NUM];
+	uint32_t lsc_buf_phys_addr;
+	unsigned long yiq_antiflicker_buf_addr;
+	uint32_t yiq_antiflicker_len;
+	uint32_t yiq_antiflicker_order;
+	unsigned long yiq_aem_buf_addr;
+	uint32_t yiq_aem_buf_len;
+};
+
+struct isp_drv_private {
+	spinlock_t isr_lock;
+	struct semaphore isr_done_lock;
+	struct isp_queue queue;
+};
+
+struct isp_k_file {
+	struct isp_k_private *isp_private;
+	struct isp_drv_private drv_private;
+};
+
+int32_t isp_get_int_num(struct isp_node *node);
+void isp_clr_int(void);
+void isp_en_irq(uint32_t irq_mode);
+int32_t isp_axi_bus_waiting(void);
+int32_t isp_capability(void *param);
+int32_t isp_cfg_param(void  *param, struct isp_k_private *isp_private);
+
+#endif
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/inc/isp_reg.h b/drivers/media/sprd_isp/isp2.0/tshark2/inc/isp_reg.h
new file mode 100644
index 00000000..755b5c24
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/inc/isp_reg.h
@@ -0,0 +1,676 @@
+/*
+ * 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 <mach/hardware.h>
+#ifndef CONFIG_64BIT
+#include <soc/sprd/hardware.h>
+#else
+#include <soc/sprd/irqs.h>
+#endif
+#include "parse_hwinfo_tshark2.h"
+
+#define ISP_BASE_ADDR                      ISP_BASE
+
+/*isp sub block: Interrupt*/
+#define ISP_INT_STATUS                     (ISP_BASE_ADDR+0x0000UL)
+#define ISP_INT_EN0                        (ISP_BASE_ADDR+0x0014UL)
+#define ISP_INT_CLR0                       (ISP_BASE_ADDR+0x0018UL)
+#define ISP_INT_RAW0                       (ISP_BASE_ADDR+0x001CUL)
+#define ISP_INT_INT0                       (ISP_BASE_ADDR+0x0020UL)
+#define ISP_INT_EN1                        (ISP_BASE_ADDR+0x0024UL)
+#define ISP_INT_CLR1                       (ISP_BASE_ADDR+0x0028UL)
+#define ISP_INT_RAW1                       (ISP_BASE_ADDR+0x002CUL)
+#define ISP_INT_INT1                       (ISP_BASE_ADDR+0x0030UL)
+#define ISP_INT_EN2                        (ISP_BASE_ADDR+0x0034UL)
+#define ISP_INT_CLR2                       (ISP_BASE_ADDR+0x0038UL)
+#define ISP_INT_RAW2                       (ISP_BASE_ADDR+0x003CUL)
+#define ISP_INT_INT2                       (ISP_BASE_ADDR+0x0040UL)
+#define ISP_INT_EN3                        (ISP_BASE_ADDR+0x0044UL)
+#define ISP_INT_CLR3                       (ISP_BASE_ADDR+0x0048UL)
+#define ISP_INT_RAW3                       (ISP_BASE_ADDR+0x004CUL)
+#define ISP_INT_INT3                       (ISP_BASE_ADDR+0x0050UL)
+#define ISP_INT_ALL_DONE_CTRL              (ISP_BASE_ADDR+0x0054UL)
+
+/*isp sub block: Fetch*/
+#define ISP_FETCH_MEM_STATUS0              (ISP_BASE_ADDR+0x0100UL)
+#define ISP_FETCH_MEM_STATUS1              (ISP_BASE_ADDR+0x0104UL)
+#define ISP_FETCH_DCAM_STATUS0             (ISP_BASE_ADDR+0x0108UL)
+#define ISP_FETCH_MIPI_STATUS              (ISP_BASE_ADDR+0x010CUL)
+#define ISP_FETCH_PARAM                    (ISP_BASE_ADDR+0x0114UL)
+#define ISP_FETCH_START                    (ISP_BASE_ADDR+0x0118UL)
+#define ISP_FETCH_SLICE_SIZE               (ISP_BASE_ADDR+0x0120UL)
+#define ISP_FETCH_SLICE_Y_ADDR             (ISP_BASE_ADDR+0x0124UL)
+#define ISP_FETCH_SLICE_Y_PITCH            (ISP_BASE_ADDR+0x0128UL)
+#define ISP_FETCH_SLICE_U_ADDR             (ISP_BASE_ADDR+0x012CUL)
+#define ISP_FETCH_SLICE_U_PITCH            (ISP_BASE_ADDR+0x0130UL)
+#define ISP_FETCH_SLICE_V_ADDR             (ISP_BASE_ADDR+0x0134UL)
+#define ISP_FETCH_SLICE_V_PITCH            (ISP_BASE_ADDR+0x0138UL)
+#define ISP_FETCH_MIPI_WORD_INFO           (ISP_BASE_ADDR+0x013CUL)
+#define ISP_FETCH_MIPI_BYTE_INFO           (ISP_BASE_ADDR+0x0140UL)
+#define ISP_FETCH_LINE_DLY_CTRL            (ISP_BASE_ADDR+0x0144UL)
+
+/*isp sub block: Store*/
+#define ISP_STORE_STATUS_MEM0              (ISP_BASE_ADDR+0x0200UL)
+#define ISP_STORE_STATUS_MEM1              (ISP_BASE_ADDR+0x0204UL)
+#define ISP_STORE_STATUS_DCAM0             (ISP_BASE_ADDR+0x0208UL)
+#define ISP_STORE_STATUS_DCAM1             (ISP_BASE_ADDR+0x020CUL)
+#define ISP_STORE_PARAM                    (ISP_BASE_ADDR+0x0214UL)
+#define ISP_STORE_SLICE_SIZE               (ISP_BASE_ADDR+0x0218UL)
+#define ISP_STORE_BORDER                   (ISP_BASE_ADDR+0x021CUL)
+#define ISP_STORE_Y_ADDR                   (ISP_BASE_ADDR+0x0220UL)
+#define ISP_STORE_Y_PITCH                  (ISP_BASE_ADDR+0x0224UL)
+#define ISP_STORE_U_ADDR                   (ISP_BASE_ADDR+0x0228UL)
+#define ISP_STORE_U_PITCH                  (ISP_BASE_ADDR+0x022CUL)
+#define ISP_STORE_V_ADDR                   (ISP_BASE_ADDR+0x0230UL)
+#define ISP_STORE_V_PITCH                  (ISP_BASE_ADDR+0x0234UL)
+#define ISP_STORE_SHADOW_CLR               (ISP_BASE_ADDR+0x0238UL)
+
+/*isp sub block: dispatch*/
+#define ISP_DISPATCH_STATUS_CH0            (ISP_BASE_ADDR+0x0300UL)
+#define ISP_DISPATCH_STATUS_CH1            (ISP_BASE_ADDR+0x0304UL)
+#define ISP_DISPATCH_STATUS_COMM           (ISP_BASE_ADDR+0x0308UL)
+#define ISP_DISPATCH_STATUS1_CH0           (ISP_BASE_ADDR+0x030CUL)
+#define ISP_DISPATCH_STATUS1_CH1           (ISP_BASE_ADDR+0x0310UL)
+#define ISP_DISPATCH_CH0_BAYER             (ISP_BASE_ADDR+0x0314UL)
+#define ISP_DISPATCH_CH0_SIZE              (ISP_BASE_ADDR+0x0318UL)
+#define ISP_DISPATCH_CH1_SIZE              (ISP_BASE_ADDR+0x031CUL)
+#define ISP_DISPATCH_DLY                   (ISP_BASE_ADDR+0x0320UL)
+#define ISP_DISPATCH_CH1_BAYER             (ISP_BASE_ADDR+0x0324UL)
+#define ISP_DISPATCH_HW_CTRL_CH0           (ISP_BASE_ADDR+0x0328UL)
+#define ISP_DISPATCH_HW_CTRL_CH1           (ISP_BASE_ADDR+0x032CUL)
+
+/*isp sub block: arbiter*/
+#define ISP_ARBITER_WR_STATUS              (ISP_BASE_ADDR+0x0400UL)
+#define ISP_ARBITER_RD_STATUS              (ISP_BASE_ADDR+0x0404UL)
+#define ISP_ARBITER_PARAM                  (ISP_BASE_ADDR+0x0414UL)
+#define ISP_ARBITER_ENDIAN_CH0             (ISP_BASE_ADDR+0x0418UL)
+#define ISP_ARBITER_ENDIAN_CH1             (ISP_BASE_ADDR+0x041CUL)
+#define ISP_ARBITER_CTRL                   (ISP_BASE_ADDR+0x0420UL)
+
+/*isp sub block: axi*/
+#define ISP_AXI_WR_MASTER_STATUS           (ISP_BASE_ADDR+0x0500UL)
+#define ISP_AXI_RD_MASTER_STATUS           (ISP_BASE_ADDR+0x0504UL)
+#define ISP_AXI_ITI2AXIM_CTRL              (ISP_BASE_ADDR+0x0514UL)
+#define ISP_AXI_CONVERT_WR_CTRL            (ISP_BASE_ADDR+0x0518UL)
+
+/*isp sub block:  raw sizer*/
+#define ISP_RAW_SIZER_STATUS0              (ISP_BASE_ADDR+0x0600UL)
+#define ISP_RAW_SIZER_PARAM                (ISP_BASE_ADDR+0x0614UL)
+#define ISP_RAW_SIZER_CROP_SRC             (ISP_BASE_ADDR+0x0618UL)
+#define ISP_RAW_SIZER_CROP_DST             (ISP_BASE_ADDR+0x061CUL)
+#define ISP_RAW_SIZER_CROP_START           (ISP_BASE_ADDR+0x0620UL)
+#define ISP_RAW_SIZER_DST                  (ISP_BASE_ADDR+0x0624UL)
+#define ISP_RAW_SIZER_BPC                  (ISP_BASE_ADDR+0x0628UL)
+#define ISP_RAW_SIZER_HCOEFF0              (ISP_BASE_ADDR+0x062CUL)
+#define ISP_RAW_SIZER_VCOEFF0              (ISP_BASE_ADDR+0x0684UL)
+#define ISP_RAW_SIZER_INIT_HOR0            (ISP_BASE_ADDR+0x06B0UL)
+#define ISP_RAW_SIZER_INIT_HOR1            (ISP_BASE_ADDR+0x06B4UL)
+#define ISP_RAW_SIZER_INIT_HOR2            (ISP_BASE_ADDR+0x06B8UL)
+#define ISP_RAW_SIZER_INIT_VER0            (ISP_BASE_ADDR+0x06BCUL)
+#define ISP_RAW_SIZER_INIT_VER1            (ISP_BASE_ADDR+0x06C0UL)
+#define ISP_RAW_SIZER_INIT_VER2            (ISP_BASE_ADDR+0x06C4UL)
+
+/*isp sub block: common*/
+#define ISP_COMMON_VERSION                 (ISP_BASE_ADDR+0x0700UL)
+#define ISP_COMMON_STATUS0                 (ISP_BASE_ADDR+0x0704UL)
+#define ISP_COMMON_STATUS1                 (ISP_BASE_ADDR+0x0708UL)
+#define ISP_COMMON_CTRL_CH0                (ISP_BASE_ADDR+0x0714UL)
+#define ISP_COMMON_SPACE_SEL               (ISP_BASE_ADDR+0x0718UL)
+#define ISP_COMMON_CTRL_CH1                (ISP_BASE_ADDR+0x071CUL)
+#define ISP_COMMON_CTRL_AWBM               (ISP_BASE_ADDR+0x0720UL)
+#define ISP_COMMON_PMU_RAW_MASK            (ISP_BASE_ADDR+0x0724UL)
+#define ISP_COMMON_PMU_HW_MASK             (ISP_BASE_ADDR+0x0728UL)
+#define ISP_COMMON_PMU_HW_ENABLE           (ISP_BASE_ADDR+0x072CUL)
+#define ISP_COMMON_PMU_SW_SWITCH           (ISP_BASE_ADDR+0x0730UL)
+#define ISP_COMMON_PMU_SW_TOGGLE           (ISP_BASE_ADDR+0x0734UL)
+#define ISP_COMMON_LBUF_OFFSET0            (ISP_BASE_ADDR+0x0738UL)
+#define ISP_SHADOW_CTRL_CH0                (ISP_BASE_ADDR+0x073CUL)
+#define ISP_SHADOW_CTRL_CH1                (ISP_BASE_ADDR+0x0740UL)
+#define ISP_COMMON_3A_CTRL0                (ISP_BASE_ADDR+0x0744UL)
+#define ISP_COMMON_LBUF_OFFSET1            (ISP_BASE_ADDR+0x0748UL)
+#define ISP_COMMON_3A_CTRL1                (ISP_BASE_ADDR+0x074CUL)
+#define ISP_COMMON_RESERVED0               (ISP_BASE_ADDR+0x0750UL)
+
+/*isp sub block: Pre Global Gain*/
+#define ISP_PGG_STATUS                     (ISP_BASE_ADDR+0x1000UL)
+#define ISP_PGG_PARAM                      (ISP_BASE_ADDR+0x1014UL)
+
+/*isp sub block: BLC: back level calibration*/
+#define ISP_BLC_STATUS                     (ISP_BASE_ADDR+0x1100UL)
+#define ISP_BLC_PARAM                      (ISP_BASE_ADDR+0x1114UL)
+#define ISP_BLC_B_PARAM_R_B                (ISP_BASE_ADDR+0x1118UL)
+#define ISP_BLC_B_PARAM_G                  (ISP_BASE_ADDR+0x111CUL)
+
+/*isp sub block: RGBG*/
+#define ISP_RGBG_STATUS                    (ISP_BASE_ADDR+0x1200UL)
+#define ISP_RGBG_PARAM                     (ISP_BASE_ADDR+0x1214UL)
+#define ISP_RGBG_RB                        (ISP_BASE_ADDR+0x1218UL)
+#define ISP_RGBG_G                         (ISP_BASE_ADDR+0x121CUL)
+
+/*isp sub block: PWD*/
+#define ISP_PWD_STATUS0                    (ISP_BASE_ADDR+0x1300UL)
+#define ISP_PWD_STATUS1                    (ISP_BASE_ADDR+0x1304UL)
+#define ISP_PWD_PARAM                      (ISP_BASE_ADDR+0x1314UL)
+#define ISP_PWD_PARAM1                     (ISP_BASE_ADDR+0x1318UL)
+#define ISP_PWD_PARAM2                     (ISP_BASE_ADDR+0x131CUL)
+#define ISP_PWD_PARAM3                     (ISP_BASE_ADDR+0x1320UL)
+#define ISP_PWD_PARAM4                     (ISP_BASE_ADDR+0x1324UL)
+#define ISP_PWD_PARAM5                     (ISP_BASE_ADDR+0x1328UL)
+#define ISP_PWD_PARAM6                     (ISP_BASE_ADDR+0x132CUL)
+#define ISP_PWD_PARAM7                     (ISP_BASE_ADDR+0x1330UL)
+#define ISP_PWD_PARAM8                     (ISP_BASE_ADDR+0x1334UL)
+#define ISP_PWD_PARAM9                     (ISP_BASE_ADDR+0x1338UL)
+#define ISP_PWD_PARAM10                    (ISP_BASE_ADDR+0x133CUL)
+
+/*isp sub block: NLC*/
+#define ISP_NLC_STATUS                     (ISP_BASE_ADDR+0x1400UL)
+#define ISP_NLC_PARA                       (ISP_BASE_ADDR+0x1414UL)
+#define ISP_NLC_PARA_R0                    (ISP_BASE_ADDR+0x1418UL)
+#define ISP_NLC_PARA_R9                    (ISP_BASE_ADDR+0x143CUL)
+#define ISP_NLC_PARA_G0                    (ISP_BASE_ADDR+0x1440UL)
+#define ISP_NLC_PARA_G9                    (ISP_BASE_ADDR+0x1464UL)
+#define ISP_NLC_PARA_B0                    (ISP_BASE_ADDR+0x1468UL)
+#define ISP_NLC_PARA_B9                    (ISP_BASE_ADDR+0x148CUL)
+#define ISP_NLC_PARA_L0                    (ISP_BASE_ADDR+0x1490UL)
+
+/*isp sub block: lens shading calibration*/
+#define ISP_LENS_STATUS                    (ISP_BASE_ADDR+0x1500UL)
+#define ISP_LENS_PARAM                     (ISP_BASE_ADDR+0x1514UL)
+#define ISP_LENS_PARAM_ADDR                (ISP_BASE_ADDR+0x1518UL)
+#define ISP_LENS_SLICE_POS                 (ISP_BASE_ADDR+0x151CUL)
+#define ISP_LENS_LOAD_EB                   (ISP_BASE_ADDR+0x1520UL)
+#define ISP_LENS_GRID_PITCH                (ISP_BASE_ADDR+0x1524UL)
+#define ISP_LENS_GRID_SIZE                 (ISP_BASE_ADDR+0x1528UL)
+#define ISP_LENS_LOAD_BUF                  (ISP_BASE_ADDR+0x152CUL)
+#define ISP_LENS_MISC                      (ISP_BASE_ADDR+0x1530UL)
+#define ISP_LENS_SLICE_SIZE                (ISP_BASE_ADDR+0x1534UL)
+#define ISP_LENS_INIT_COOR                 (ISP_BASE_ADDR+0x1538UL)
+#define ISP_LENS_Q0_VALUE                  (ISP_BASE_ADDR+0x153CUL)
+
+/*isp sub block: binning*/
+#define ISP_BINNING_STATUS                 (ISP_BASE_ADDR+0x1600UL)
+#define ISP_BINNING_PARAM                  (ISP_BASE_ADDR+0x1614UL)
+#define ISP_BINNING_MEM_ADDR               (ISP_BASE_ADDR+0x1618UL)
+#define ISP_BINNING_PITCH                  (ISP_BASE_ADDR+0x161CUL)
+
+/*isp sub block: AWBM*/
+#define ISP_AWBM_STATUS                    (ISP_BASE_ADDR+0x1700UL)
+#define ISP_AWBM_PARAM                     (ISP_BASE_ADDR+0x1714UL)
+#define ISP_AWBM_BLOCK_OFFSET              (ISP_BASE_ADDR+0x1718UL)
+#define ISP_AWBM_BLOCK_SIZE                (ISP_BASE_ADDR+0x171CUL)
+#define ISP_AWBM_WR_0_S                    (ISP_BASE_ADDR+0x1720UL)
+#define ISP_AWBM_WR_0_E                    (ISP_BASE_ADDR+0x1724UL)
+#define ISP_AWBM_NW_0_XYR                  (ISP_BASE_ADDR+0x1748UL)
+#define ISP_AWBM_CLCTOR_0_S                (ISP_BASE_ADDR+0x175CUL)
+#define ISP_AWBM_CLCTOR_0_E                (ISP_BASE_ADDR+0x1760UL)
+#define ISP_AWBM_CLCTR_0_PIXEL_NUM         (ISP_BASE_ADDR+0x1784UL)
+#define ISP_AWBM_MEM_ADDR                  (ISP_BASE_ADDR+0x1798UL)
+#define ISP_AWBM_THR_VALUE1                (ISP_BASE_ADDR+0x17A0UL)
+#define ISP_AWBM_THR_VALUE2                (ISP_BASE_ADDR+0x17A4UL)
+
+/*isp sub block: AWBC*/
+#define ISP_AWBC_STATUS                    (ISP_BASE_ADDR+0x1800UL)
+#define ISP_AWBC_PARAM                     (ISP_BASE_ADDR+0x1814UL)
+#define ISP_AWBC_GAIN0                     (ISP_BASE_ADDR+0x1818UL)
+#define ISP_AWBC_GAIN1                     (ISP_BASE_ADDR+0x181CUL)
+#define ISP_AWBC_THRD                      (ISP_BASE_ADDR+0x1820UL)
+#define ISP_AWBC_OFFSET0                   (ISP_BASE_ADDR+0x1824UL)
+#define ISP_AWBC_OFFSET1                   (ISP_BASE_ADDR+0x1828UL)
+#define ISP_AWBC_GAIN0_BUF                 (ISP_BASE_ADDR+0x182CUL)
+#define ISP_AWBC_GAIN1_BUF                 (ISP_BASE_ADDR+0x1830UL)
+#define ISP_AWBC_OFFSET0_BUF               (ISP_BASE_ADDR+0x1834UL)
+#define ISP_AWBC_OFFSET1_BUF               (ISP_BASE_ADDR+0x1838UL)
+#define ISP_AWBC_GAIN0_READ                (ISP_BASE_ADDR+0x183CUL)
+#define ISP_AWBC_GAIN1_READ                (ISP_BASE_ADDR+0x1840UL)
+#define ISP_AWBC_OFFSET0_READ              (ISP_BASE_ADDR+0x1844UL)
+#define ISP_AWBC_OFFSET1_READ              (ISP_BASE_ADDR+0x1848UL)
+
+/*isp sub block: AEM*/
+#define ISP_AEM_STATUS                     (ISP_BASE_ADDR+0x1900UL)
+#define ISP_AEM_PARAM                      (ISP_BASE_ADDR+0x1914UL)
+#define ISP_AEM_OFFSET                     (ISP_BASE_ADDR+0x1918UL)
+#define ISP_AEM_BLK_SIZE                   (ISP_BASE_ADDR+0x191CUL)
+#define ISP_AEM_SLICE_SIZE                 (ISP_BASE_ADDR+0x1920UL)
+
+/*isp sub block: BPC: bad pixel correction*/
+#define ISP_BPC_STATUS                     (ISP_BASE_ADDR+0x1A00UL)
+#define ISP_BPC_PARAM                      (ISP_BASE_ADDR+0x1A14UL)
+#define ISP_BPC_CFG                        (ISP_BASE_ADDR+0x1A18UL)
+#define ISP_BPC_FACTOR                     (ISP_BASE_ADDR+0x1A1CUL)
+#define ISP_BPC_COEFF                      (ISP_BASE_ADDR+0x1A20UL)
+#define ISP_BPC_LUTWORD0                   (ISP_BASE_ADDR+0x1A24UL)
+#define ISP_BPC_NEW_OLD_SEL                (ISP_BASE_ADDR+0x1A44UL)
+#define ISP_BPC_MAP_ADDR                   (ISP_BASE_ADDR+0x1A48UL)
+
+/*isp sub block: GRGB*/
+#define ISP_GRGB_STATUS                    (ISP_BASE_ADDR+0x1B00UL)
+#define ISP_GRGB_PARAM                     (ISP_BASE_ADDR+0x1B14UL)
+#define ISP_GRGB_GRID                      (ISP_BASE_ADDR+0x1B18UL)
+
+/*isp sub block: BDN*/
+#define ISP_BDN_STATUS                     (ISP_BASE_ADDR+0x1C00UL)
+#define ISP_BDN_PARAM                      (ISP_BASE_ADDR+0x1C14UL)
+#define ISP_BDN_DISWEI0_0                  (ISP_BASE_ADDR+0x1C18UL)
+#define ISP_BDN_DISWEI0_1                  (ISP_BASE_ADDR+0x1C1CUL)
+#define ISP_BDN_RANWEI0_0                  (ISP_BASE_ADDR+0x1C20UL)
+#define ISP_BDN_RANWEI0_7                  (ISP_BASE_ADDR+0x1C3CUL)
+#define ISP_BDN_1DLNC_CENTER               (ISP_BASE_ADDR+0x1DA8UL)
+#define ISP_BDN_1DLNC_SQUARE_X             (ISP_BASE_ADDR+0x1DACUL)
+#define ISP_BDN_1DLNC_SQUARE_Y             (ISP_BASE_ADDR+0x1DB0UL)
+#define ISP_BDN_1DLNC_P                    (ISP_BASE_ADDR+0x1DB4UL)
+#define ISP_BDN_1DLNC_SIZE                 (ISP_BASE_ADDR+0x1DB8UL)
+#define ISP_BDN_1DLNC_POS                  (ISP_BASE_ADDR+0x1DBCUL)
+#define	ISP_BDN_1DLNC_OFFSET               (ISP_BASE_ADDR+0x1DC0UL)
+
+/*isp sub block: RGBG2*/
+#define ISP_RGBG2_STATUS                   (ISP_BASE_ADDR+0x1E00UL)
+#define ISP_RGBG2_PARAM                    (ISP_BASE_ADDR+0x1E14UL)
+#define ISP_RGBG2_GAIN                     (ISP_BASE_ADDR+0x1E18UL)
+#define ISP_RGBG2_OFFSET                   (ISP_BASE_ADDR+0x1E1CUL)
+
+/*isp sub block: 1d lnc*/
+#define ISP_1D_LNC_STATUS                  (ISP_BASE_ADDR+0x1F00UL)
+#define ISP_1D_LNC_PARAM                   (ISP_BASE_ADDR+0x1F14UL)
+#define ISP_1D_LNC_PARAM1                  (ISP_BASE_ADDR+0x1F18UL)
+#define ISP_1D_LNC_PARAM2                  (ISP_BASE_ADDR+0x1F1CUL)
+#define ISP_1D_LNC_PARAM3                  (ISP_BASE_ADDR+0x1F20UL)
+#define ISP_1D_LNC_PARAM4                  (ISP_BASE_ADDR+0x1F24UL)
+#define ISP_1D_LNC_PARAM5                  (ISP_BASE_ADDR+0x1F28UL)
+#define ISP_1D_LNC_PARAM6                  (ISP_BASE_ADDR+0x1F2CUL)
+#define ISP_1D_LNC_PARAM7                  (ISP_BASE_ADDR+0x1F30UL)
+#define ISP_1D_LNC_PARAM8                  (ISP_BASE_ADDR+0x1F34UL)
+#define ISP_1D_LNC_PARAM9                  (ISP_BASE_ADDR+0x1F38UL)
+#define ISP_1D_LNC_PARAM10                 (ISP_BASE_ADDR+0x1F3CUL)
+#define ISP_1D_LNC_PARAM11                 (ISP_BASE_ADDR+0x1F40UL)
+#define ISP_1D_LNC_PARAM12                 (ISP_BASE_ADDR+0x1F44UL)
+#define ISP_1D_LNC_PARAM13                 (ISP_BASE_ADDR+0x1F48UL)
+#define ISP_1D_LNC_PARAM14                 (ISP_BASE_ADDR+0x1F4CUL)
+#define ISP_1D_LNC_PARAM15                 (ISP_BASE_ADDR+0x1F50UL)
+#define ISP_1D_LNC_PARAM16                 (ISP_BASE_ADDR+0x1F54UL)
+#define ISP_1D_LNC_PARAM17                 (ISP_BASE_ADDR+0x1F58UL)
+#define ISP_1D_LNC_PARAM18                 (ISP_BASE_ADDR+0x1F5CUL)
+
+/*isp sub block: NLM VST IVST*/
+#define ISP_VST_PARA                       (ISP_BASE_ADDR+0x2014UL)
+#define ISP_IVST_PARA                      (ISP_BASE_ADDR+0x2214UL)
+#define ISP_NLM_LB_STATUS0                 (ISP_BASE_ADDR+0x2100UL)
+#define ISP_NLM_LB_STATUS1                 (ISP_BASE_ADDR+0x2104UL)
+#define ISP_NLM_STATUS                     (ISP_BASE_ADDR+0x2108UL)
+#define ISP_NLM_PARA                       (ISP_BASE_ADDR+0x2114UL)
+#define ISP_NLM_FLAT_PARA_0                (ISP_BASE_ADDR+0x2118UL)
+#define	ISP_NLM_STERNGTH                   (ISP_BASE_ADDR+0x212CUL)
+#define ISP_NLM_IS_FLAT                    (ISP_BASE_ADDR+0x2130UL)
+#define ISP_NLM_ADD_BACK                   (ISP_BASE_ADDR+0x2134UL)
+#define ISP_NLM_DIRECTION_0                (ISP_BASE_ADDR+0x2138UL)
+#define ISP_NLM_DIRECTION_1                (ISP_BASE_ADDR+0x213CUL)
+#define ISP_NLM_LUT_W_0                    (ISP_BASE_ADDR+0x2140UL)
+
+/*isp sub block: CFA: clolor filter array*/
+#define ISP_CFAE_STATUS                    (ISP_BASE_ADDR+0x3000UL)
+#define ISP_CFAE_EE_CFG0                   (ISP_BASE_ADDR+0x3014UL)
+#define ISP_CFAE_THRD_0                    (ISP_BASE_ADDR+0x3018UL)
+#define ISP_CFAE_THRD_1                    (ISP_BASE_ADDR+0x301CUL)
+#define ISP_CFAE_THRD_2                    (ISP_BASE_ADDR+0x3020UL)
+#define ISP_CFAE_THRD_3                    (ISP_BASE_ADDR+0x3024UL)
+#define ISP_CFAE_THRD_4                    (ISP_BASE_ADDR+0x3028UL)
+#define ISP_CFAE_EE_CFG1                   (ISP_BASE_ADDR+0x302CUL)
+
+/*isp sub block:CMC: Color matrix correction for 10 bit   */
+#define ISP_CMC10_STATUS0                  (ISP_BASE_ADDR+0x3100UL)
+#define ISP_CMC10_STATUS1                  (ISP_BASE_ADDR+0x3104UL)
+#define ISP_CMC10_PARAM                    (ISP_BASE_ADDR+0x3114UL)
+#define ISP_CMC10_MATRIX0                  (ISP_BASE_ADDR+0x3118UL)
+#define ISP_CMC10_MATRIX0_BUF              (ISP_BASE_ADDR+0x312CUL)
+
+/*isp sub block: GAMMA */
+#define ISP_GAMMA_STATUS                   (ISP_BASE_ADDR+0x3300UL)
+#define ISP_GAMMA_PARAM                    (ISP_BASE_ADDR+0x3314UL)
+
+/*isp sub block:CMC: Color matrix correction for 8 bit  */
+#define ISP_CMC8_STATUS0                   (ISP_BASE_ADDR+0x3500UL)
+#define ISP_CMC8_STATUS1                   (ISP_BASE_ADDR+0x3504UL)
+#define ISP_CMC8_PARAM                     (ISP_BASE_ADDR+0x3514UL)
+#define ISP_CMC8_MATRIX0                   (ISP_BASE_ADDR+0x3518UL)
+#define ISP_CMC8_MATRIX0_BUF               (ISP_BASE_ADDR+0x352CUL)
+
+/*CT: Color transformation*/
+#define ISP_CT_STATUS0                     (ISP_BASE_ADDR+0x3600UL)
+#define ISP_CT_STATUS1                     (ISP_BASE_ADDR+0x3604UL)
+#define ISP_CT_PARAM                       (ISP_BASE_ADDR+0x3614UL)
+
+/*isp sub block: CCE: clolor conversion enhancement*/
+#define ISP_CCE_STATUS0                    (ISP_BASE_ADDR+0x3700UL)
+#define ISP_CCE_STATUS1                    (ISP_BASE_ADDR+0x3704UL)
+#define ISP_CCE_PARAM                      (ISP_BASE_ADDR+0x3714UL)
+#define ISP_CCE_MATRIX0                    (ISP_BASE_ADDR+0x3718UL)
+#define ISP_CCE_MATRIX1                    (ISP_BASE_ADDR+0x371CUL)
+#define ISP_CCE_MATRIX2                    (ISP_BASE_ADDR+0x3720UL)
+#define ISP_CCE_MATRIX3                    (ISP_BASE_ADDR+0x3724UL)
+#define ISP_CCE_MATRIX4                    (ISP_BASE_ADDR+0x3728UL)
+#define ISP_CCE_SHIFT                      (ISP_BASE_ADDR+0x372CUL)
+#define ISP_CCE_UVD_PARAM0                 (ISP_BASE_ADDR+0x3730UL)
+#define ISP_CCE_UVD_PARAM1                 (ISP_BASE_ADDR+0x3734UL)
+#define ISP_CCE_UVD_PARAM2                 (ISP_BASE_ADDR+0x3738UL)
+#define ISP_CCE_UVD_PARAM3                 (ISP_BASE_ADDR+0x373CUL)
+#define ISP_CCE_UVD_PARAM4                 (ISP_BASE_ADDR+0x3740UL)
+#define ISP_CCE_UVD_PARAM5                 (ISP_BASE_ADDR+0x3744UL)
+
+/*isp sub block:HSV*/
+#define ISP_HSV_STATUS                     (ISP_BASE_ADDR+0x3800UL)
+#define ISP_HSV_PARAM                      (ISP_BASE_ADDR+0x3814UL)
+
+/*isp sub block:Radial CSC*/
+#define ISP_CSC_STATUS                     (ISP_BASE_ADDR + 0x3900UL)
+#define ISP_CSC_CTRL                       (ISP_BASE_ADDR + 0x3914UL)
+#define ISP_CSC_RCC                        (ISP_BASE_ADDR + 0x3918UL)
+#define ISP_CSC_BCC                        (ISP_BASE_ADDR + 0x391CUL)
+#define ISP_CSC_REDX2INIT                  (ISP_BASE_ADDR + 0x3920UL)
+#define ISP_CSC_REDY2INIT                  (ISP_BASE_ADDR + 0x3924UL)
+#define ISP_CSC_BLUEX2INIT                 (ISP_BASE_ADDR + 0x3928UL)
+#define ISP_CSC_BLUEY2INIT                 (ISP_BASE_ADDR + 0x392CUL)
+#define ISP_CSC_REDTHR                     (ISP_BASE_ADDR + 0x3930UL)
+#define ISP_CSC_BLUETHR                    (ISP_BASE_ADDR + 0x3934UL)
+#define ISP_CSC_REDPOLY                    (ISP_BASE_ADDR + 0x3938UL)
+#define ISP_CSC_BLUEPOLY                   (ISP_BASE_ADDR + 0x393CUL)
+#define ISP_CSC_MAXGAIN                    (ISP_BASE_ADDR + 0x3940UL)
+#define ISP_CSC_PICSIZE                    (ISP_BASE_ADDR + 0x3944UL)
+#define ISP_CSC_START_ROW_COL              (ISP_BASE_ADDR + 0x3948UL)
+
+/*isp sub block:ISP_PRECNRNEW*/
+#define ISP_PRECNRNEW_STATUS0              (ISP_BASE_ADDR+0x3A00UL)
+#define ISP_PRECNRNEW_STATUS1              (ISP_BASE_ADDR+0x3A04UL)
+#define ISP_PRECNRNEW_CFG                  (ISP_BASE_ADDR+0x3A14UL)
+#define ISP_PRECNRNEW_MEDIAN_THR           (ISP_BASE_ADDR+0x3A18UL)
+#define ISP_PRECNRNEW_THRU                 (ISP_BASE_ADDR+0x3A1CUL)
+#define ISP_PRECNRNEW_THRV                 (ISP_BASE_ADDR+0x3A20UL)
+
+/*isp sub block:ISP_PSTRZ*/
+#define ISP_PSTRZ_STATUS                   (ISP_BASE_ADDR+0x3B00UL)
+#define ISP_PSTRZ_PARAM                    (ISP_BASE_ADDR+0x3B14UL)
+#define ISP_PSTRZ_LEVEL0                   (ISP_BASE_ADDR+0x3B18UL)
+#define ISP_PSTRZ_LEVEL1                   (ISP_BASE_ADDR+0x3B1CUL)
+#define ISP_PSTRZ_LEVEL2                   (ISP_BASE_ADDR+0x3B20UL)
+#define ISP_PSTRZ_LEVEL3                   (ISP_BASE_ADDR+0x3B24UL)
+#define ISP_PSTRZ_LEVEL4                   (ISP_BASE_ADDR+0x3B28UL)
+#define ISP_PSTRZ_LEVEL5                   (ISP_BASE_ADDR+0x3B2CUL)
+#define ISP_PSTRZ_LEVEL6                   (ISP_BASE_ADDR+0x3B30UL)
+#define ISP_PSTRZ_LEVEL7                   (ISP_BASE_ADDR+0x3B34UL)
+
+/*isp sub block: AFM : auto focus monitor*/
+#define ISP_RGB_AFM_STATUS0                (ISP_BASE_ADDR+0x3C00UL)
+#define ISP_RGB_AFM_STATUS1                (ISP_BASE_ADDR+0x3C04UL)
+#define ISP_RGB_AFM_PARAM                  (ISP_BASE_ADDR+0x3C14UL)
+#define ISP_RGB_AFM_FRAME_RANGE            (ISP_BASE_ADDR+0x3C18UL)
+#define ISP_RGB_AFM_SOBEL_THRESHOLD        (ISP_BASE_ADDR+0x3C1CUL)
+#define ISP_RGB_AFM_SPSMD_THRESHOLD_MAX    (ISP_BASE_ADDR+0x3C20UL)
+#define ISP_RGB_AFM_WIN_RANGE0             (ISP_BASE_ADDR+0x3C24UL)
+#define ISP_RGB_AFM_TYPE1_VAL00            (ISP_BASE_ADDR+0x3CECUL)
+#define ISP_RGB_AFM_TYPE2_VAL00            (ISP_BASE_ADDR+0x3D50UL)
+#define ISP_RGB_AFM_SPSMD_THRESHOLD_MIN    (ISP_BASE_ADDR+0x3DB4UL)
+
+/*isp sub block:YIQ AEM*/
+#define ISP_YIQ_AEM_STATUS                 (ISP_BASE_ADDR + 0x4100UL)
+#define ISP_YIQ_AEM_PARAM                  (ISP_BASE_ADDR + 0x4114UL)
+#define ISP_YIQ_YGAMMA_NODE_X0             (ISP_BASE_ADDR + 0x4118UL)
+#define ISP_YIQ_YGAMMA_NODE_X1             (ISP_BASE_ADDR + 0x411CUL)
+#define ISP_YIQ_YGAMMA_NODE_Y0             (ISP_BASE_ADDR + 0x4120UL)
+#define ISP_YIQ_YGAMMA_NODE_Y1             (ISP_BASE_ADDR + 0x4124UL)
+#define ISP_YIQ_YGAMMA_NODE_Y2             (ISP_BASE_ADDR + 0x4128UL)
+#define ISP_YIQ_YGAMMA_NODE_IDX            (ISP_BASE_ADDR + 0x412CUL)
+#define ISP_YIQ_AEM_OFFSET                 (ISP_BASE_ADDR + 0x4130UL)
+#define ISP_YIQ_AEM_BLK_SIZE               (ISP_BASE_ADDR + 0x4134UL)
+#define ISP_YIQ_AEM_SLICE_SIZE             (ISP_BASE_ADDR + 0x4138UL)
+
+/*isp sub block:ANTI FLICKER*/
+#define ISP_ANTI_FLICKER_STATUS0           (ISP_BASE_ADDR + 0x4200UL)
+#define ISP_ANTI_FLICKER_STATUS1           (ISP_BASE_ADDR + 0x4204UL)
+#define ISP_ANTI_FLICKER_PARAM0            (ISP_BASE_ADDR + 0x4214UL)
+#define ISP_ANTI_FLICKER_PARAM1            (ISP_BASE_ADDR + 0x4218UL)
+#define ISP_ANTI_FLICKER_COL_POS           (ISP_BASE_ADDR + 0x421CUL)
+#define ISP_ANTI_FLICKER_DDR_INIT_ADDR     (ISP_BASE_ADDR + 0x4220UL)
+
+/*isp sub block:YIQ AFM*/
+#define ISP_YIQ_AFM_STATUS0                (ISP_BASE_ADDR + 0x4300UL)
+#define ISP_YIQ_AFM_STATUS1                (ISP_BASE_ADDR + 0x4304UL)
+#define ISP_YIQ_AFM_PARAM                  (ISP_BASE_ADDR + 0x4314UL)
+#define ISP_YIQ_AFM_WIN_RANGE0             (ISP_BASE_ADDR + 0x4318UL)
+#define ISP_YIQ_AFM_COEF0_1                (ISP_BASE_ADDR + 0x43E0UL)
+#define ISP_YIQ_AFM_COEF2_3                (ISP_BASE_ADDR + 0x43E4UL)
+#define ISP_YIQ_AFM_COEF4_5                (ISP_BASE_ADDR + 0x43E8UL)
+#define ISP_YIQ_AFM_COEF6_7                (ISP_BASE_ADDR + 0x43ECUL)
+#define ISP_YIQ_AFM_COEF8_9                (ISP_BASE_ADDR + 0x43F0UL)
+#define ISP_YIQ_AFM_COEF10                 (ISP_BASE_ADDR + 0x43F4UL)
+#define ISP_YIQ_AFM_LAPLACE0               (ISP_BASE_ADDR + 0x43F8UL)
+#define ISP_YIQ_AFM_SLICE_SIZE             (ISP_BASE_ADDR + 0x4588UL)
+
+/*isp sub block: Pre-CDN*/
+#define ISP_PRECDN_STATUS0                 (ISP_BASE_ADDR+0x5000UL)
+#define ISP_PRECDN_STATUS1                 (ISP_BASE_ADDR+0x5004UL)
+#define ISP_PRECDN_PARAM                   (ISP_BASE_ADDR+0x5014UL)
+#define ISP_PRECDN_MEDIAN_THRUV01          (ISP_BASE_ADDR+0x5018UL)
+#define ISP_PRECDN_THRYUV                  (ISP_BASE_ADDR+0x501CUL)
+#define ISP_PRECDN_SEGU_0                  (ISP_BASE_ADDR+0x5020UL)
+#define ISP_PRECDN_SEGU_3                  (ISP_BASE_ADDR+0x502CUL)
+#define ISP_PRECDN_SEGV_0                  (ISP_BASE_ADDR+0x5030UL)
+#define ISP_PRECDN_SEGV_3                  (ISP_BASE_ADDR+0x503CUL)
+#define ISP_PRECDN_SEGY_0                  (ISP_BASE_ADDR+0x5040UL)
+#define ISP_PRECDN_SEGY_3                  (ISP_BASE_ADDR+0x504CUL)
+#define ISP_PRECDN_DISTW0                  (ISP_BASE_ADDR+0x5050UL)
+#define ISP_PRECDN_DISTW3                  (ISP_BASE_ADDR+0x505CUL)
+
+/*isp sub block: Pre-Filter*/
+#define ISP_PREF_STATUS0                   (ISP_BASE_ADDR+0x5100UL)
+#define ISP_PREF_STATUS1                   (ISP_BASE_ADDR+0x5104UL)
+#define ISP_PREF_PARAM                     (ISP_BASE_ADDR+0x5114UL)
+#define ISP_PREF_THRD                      (ISP_BASE_ADDR+0x5118UL)
+
+/*isp sub block: Brightness*/
+#define ISP_BRIGHT_STATUS                  (ISP_BASE_ADDR+0x5300UL)
+#define ISP_BRIGHT_PARAM                   (ISP_BASE_ADDR+0x5314UL)
+
+/*isp sub block: Contrast*/
+#define ISP_CONTRAST_STATUS                (ISP_BASE_ADDR+0x5400UL)
+#define ISP_CONTRAST_PARAM                 (ISP_BASE_ADDR+0x5414UL)
+
+/*isp sub block: HIST : histogram*/
+#define ISP_HIST_STATUS                    (ISP_BASE_ADDR+0x5500UL)
+#define ISP_HIST_PARAM                     (ISP_BASE_ADDR+0x5514UL)
+#define ISP_HIST_RATIO                     (ISP_BASE_ADDR+0x5518UL)
+#define ISP_HIST_MAX_MIN                   (ISP_BASE_ADDR+0x551CUL)
+#define ISP_HIST_SLICE_SIZE                (ISP_BASE_ADDR+0x5520UL)
+#define ISP_HIST_ADJUST                    (ISP_BASE_ADDR+0x5524UL)
+
+/*isp sub block: HIST2*/
+#define ISP_HIST2_STATUS                   (ISP_BASE_ADDR+0x5600UL)
+#define ISP_HIST2_PARAM                    (ISP_BASE_ADDR+0x5614UL)
+#define ISP_HIST2_ROI_S0                   (ISP_BASE_ADDR+0x5618UL)
+#define ISP_HIST2_ROI_E0                   (ISP_BASE_ADDR+0x561CUL)
+
+/*isp sub block: AUTOCONT : auto contrast adjustment*/
+#define ISP_AUTOCONT_STATUS                (ISP_BASE_ADDR+0x5700UL)
+#define ISP_AUTOCONT_PARAM                 (ISP_BASE_ADDR+0x5714UL)
+#define ISP_AUTOCONT_MAX_MIN               (ISP_BASE_ADDR+0x5718UL)
+
+/*isp sub block: cdn*/
+#define ISP_CDN_STATUS0                    (ISP_BASE_ADDR+0x5800UL)
+#define ISP_CDN_STATUS1                    (ISP_BASE_ADDR+0x5804UL)
+#define ISP_CDN_PARAM                      (ISP_BASE_ADDR+0x5814UL)
+#define ISP_CDN_THRUV                      (ISP_BASE_ADDR+0x5818UL)
+#define ISP_CDN_U_RANWEI_0                 (ISP_BASE_ADDR+0x581CUL)
+#define ISP_CDN_U_RANWEI_7                 (ISP_BASE_ADDR+0x5838UL)
+#define ISP_CDN_V_RANWEI_0                 (ISP_BASE_ADDR+0x583CUL)
+#define ISP_CDN_V_RANWEI_7                 (ISP_BASE_ADDR+0x5858UL)
+
+/*isp sub block: edge*/
+#define ISP_EE_STATUS                      (ISP_BASE_ADDR+0x5900UL)
+#define ISP_EE_PARAM                       (ISP_BASE_ADDR+0x5914UL)
+#define ISP_EE_CFG0                        (ISP_BASE_ADDR+0x5918UL)
+#define ISP_EE_CFG1                        (ISP_BASE_ADDR+0x591CUL)
+#define ISP_EE_CFG2                        (ISP_BASE_ADDR+0x5920UL)
+#define ISP_EE_CFG3                        (ISP_BASE_ADDR+0x5924UL)
+#define ISP_EE_CFG4                        (ISP_BASE_ADDR+0x5928UL)
+#define ISP_EE_CFG5                        (ISP_BASE_ADDR+0x592CUL)
+#define ISP_EE_CFG6                        (ISP_BASE_ADDR+0x5930UL)
+#define ISP_EE_CFG7                        (ISP_BASE_ADDR+0x5934UL)
+#define ISP_EE_ADP_CFG0                    (ISP_BASE_ADDR+0x5938UL)
+#define ISP_EE_ADP_CFG1                    (ISP_BASE_ADDR+0x593CUL)
+#define ISP_EE_ADP_CFG2                    (ISP_BASE_ADDR+0x5940UL)
+
+/*isp sub block: emboss*/
+#define ISP_EMBOSS_Y_STATUS                (ISP_BASE_ADDR+0x5A00UL)
+#define ISP_EMBOSS_Y_PARAM                 (ISP_BASE_ADDR+0x5A14UL)
+#define ISP_EMBOSS_UV_STATUS               (ISP_BASE_ADDR+0x5F00UL)
+#define ISP_EMBOSS_UV_PARAM                (ISP_BASE_ADDR+0x5F14UL)
+
+/*isp sub block: CSS*/
+#define ISP_CSS_STATUS                     (ISP_BASE_ADDR+0x5B00UL)
+#define ISP_CSS_PARAM                      (ISP_BASE_ADDR+0x5B14UL)
+#define ISP_CSS_THRD0                      (ISP_BASE_ADDR+0x5B18UL)
+#define ISP_CSS_LH_RATIO                   (ISP_BASE_ADDR+0x5B1CUL)
+#define ISP_CSS_EX_TH_0                    (ISP_BASE_ADDR+0x5B20UL)
+#define ISP_CSS_EX_TH_1                    (ISP_BASE_ADDR+0x5B24UL)
+#define ISP_CSS_CHROM_L_TH_0               (ISP_BASE_ADDR+0x5B28UL)
+#define ISP_CSS_CHROM_L_TH_1               (ISP_BASE_ADDR+0x5B2CUL)
+#define ISP_CSS_CHROM_H_TH_0               (ISP_BASE_ADDR+0x5B30UL)
+#define ISP_CSS_CHROM_H_TH_1               (ISP_BASE_ADDR+0x5B34UL)
+#define ISP_CSS_RATIO                      (ISP_BASE_ADDR+0x5B38UL)
+
+/*isp sub block: csa*/
+#define ISP_CSA_STATUS                     (ISP_BASE_ADDR+0x5C00UL)
+#define ISP_CSA_PARAM                      (ISP_BASE_ADDR+0x5C14UL)
+
+/*isp sub block: hua*/
+#define ISP_HUA_STATUS                     (ISP_BASE_ADDR+0x5D00UL)
+#define ISP_HUA_PARAM                      (ISP_BASE_ADDR+0x5D14UL)
+
+/*isp sub block: post-cdn*/
+#define ISP_POSTCDN_STATUS                 (ISP_BASE_ADDR+0x5E00UL)
+#define ISP_POSTCDN_COMMON_CTRL            (ISP_BASE_ADDR+0x5E14UL)
+#define ISP_POSTCDN_ADPT_THR               (ISP_BASE_ADDR+0x5E18UL)
+#define ISP_POSTCDN_UVTHR                  (ISP_BASE_ADDR+0x5E1CUL)
+#define ISP_POSTCDN_THRU                   (ISP_BASE_ADDR+0x5E20UL)
+#define ISP_POSTCDN_THRV                   (ISP_BASE_ADDR+0x5E24UL)
+#define ISP_POSTCDN_RSEGU01                (ISP_BASE_ADDR+0x5E28UL)
+#define ISP_POSTCDN_RSEGU23                (ISP_BASE_ADDR+0x5E2CUL)
+#define ISP_POSTCDN_RSEGU45                (ISP_BASE_ADDR+0x5E30UL)
+#define ISP_POSTCDN_RSEGU6                 (ISP_BASE_ADDR+0x5E34UL)
+#define ISP_POSTCDN_RSEGV01                (ISP_BASE_ADDR+0x5E38UL)
+#define ISP_POSTCDN_RSEGV23                (ISP_BASE_ADDR+0x5E3CUL)
+#define ISP_POSTCDN_RSEGV45                (ISP_BASE_ADDR+0x5E40UL)
+#define ISP_POSTCDN_RSEGV6                 (ISP_BASE_ADDR+0x5E44UL)
+#define ISP_POSTCDN_R_DISTW0               (ISP_BASE_ADDR+0x5E48UL)
+#define ISP_POSTCDN_START_ROW_MOD4         (ISP_BASE_ADDR+0x5E84UL)
+
+/*isp sub block: ygamma*/
+#define ISP_YGAMMA_STATUS                  (ISP_BASE_ADDR+0x6000UL)
+#define ISP_YGAMMA_PARAM                   (ISP_BASE_ADDR+0x6014UL)
+
+/*isp sub block: ydelay*/
+#define ISP_YDELAY_STATUS                  (ISP_BASE_ADDR+0x6100UL)
+#define ISP_YDELAY_PARAM                   (ISP_BASE_ADDR+0x6114UL)
+
+/*isp sub block: iircnr*/
+#define ISP_IIRCNR_STATUS0                 (ISP_BASE_ADDR+0x6400UL)
+#define ISP_IIRCNR_STATUS1                 (ISP_BASE_ADDR+0x6404UL)
+#define ISP_IIRCNR_PARAM                   (ISP_BASE_ADDR+0x6414UL)
+#define ISP_IIRCNR_PARAM1                  (ISP_BASE_ADDR+0x6418UL)
+#define ISP_IIRCNR_PARAM2                  (ISP_BASE_ADDR+0x641CUL)
+#define ISP_IIRCNR_PARAM3                  (ISP_BASE_ADDR+0x6420UL)
+#define ISP_IIRCNR_PARAM4                  (ISP_BASE_ADDR+0x6424UL)
+#define ISP_IIRCNR_PARAM5                  (ISP_BASE_ADDR+0x6428UL)
+#define ISP_IIRCNR_PARAM6                  (ISP_BASE_ADDR+0x642CUL)
+#define ISP_IIRCNR_PARAM7                  (ISP_BASE_ADDR+0x6430UL)
+#define ISP_IIRCNR_PARAM8                  (ISP_BASE_ADDR+0x6434UL)
+#define ISP_IIRCNR_PARAM9                  (ISP_BASE_ADDR+0x6438UL)
+#define ISP_YRANDOM_PARAM0                 (ISP_BASE_ADDR+0x643CUL)
+#define ISP_YRANDOM_PARAM1                 (ISP_BASE_ADDR+0x6440UL)
+#define ISP_YRANDOM_PARAM2                 (ISP_BASE_ADDR+0x6444UL)
+#define ISP_YRANDOM_STATUS0                (ISP_BASE_ADDR+0x6448UL)
+#define ISP_YRANDOM_STATUS1                (ISP_BASE_ADDR+0x644CUL)
+#define ISP_YRANDOM_STATUS2                (ISP_BASE_ADDR+0x6450UL)
+
+#define ISP_AXI_MASTER                     (ISP_BASE_ADDR+0x2000UL)
+#define ISP_AXI_MASTER_STOP                (ISP_BASE_ADDR+0X2054UL)
+#define ISP_REG_MAX_SIZE                   SPRD_ISP_SIZE
+
+/*pingpang buffer*/
+#define ISP_3D_LUT_BUF0_CH0                (ISP_BASE_ADDR+0x17000UL)
+#define ISP_HSV_BUF0_CH0                   (ISP_BASE_ADDR+0x18000UL)
+#define ISP_VST_BUF0_CH0                   (ISP_BASE_ADDR+0x19000UL)
+#define ISP_IVST_BUF0_CH0                  (ISP_BASE_ADDR+0x1A000UL)
+#define ISP_FGAMMA_R_BUF0_CH0              (ISP_BASE_ADDR+0x1B000UL)
+#define ISP_FGAMMA_G_BUF0_CH0              (ISP_BASE_ADDR+0x1C000UL)
+#define ISP_FGAMMA_B_BUF0_CH0              (ISP_BASE_ADDR+0x1D000UL)
+#define ISP_YGAMMA_BUF0_CH0                (ISP_BASE_ADDR+0x1E000UL)
+#define ISP_NLM_BUF0_CH0                   (ISP_BASE_ADDR+0x1F000UL)
+#define ISP_3D_LUT_BUF1_CH0                (ISP_BASE_ADDR+0x20000UL)
+#define ISP_HSV_BUF1_CH0                   (ISP_BASE_ADDR+0x21000UL)
+#define ISP_VST_BUF1_CH0                   (ISP_BASE_ADDR+0x22000UL)
+#define ISP_IVST_BUF1_CH0                  (ISP_BASE_ADDR+0x23000UL)
+#define ISP_FGAMMA_R_BUF1_CH0              (ISP_BASE_ADDR+0x24000UL)
+#define ISP_FGAMMA_G_BUF1_CH0              (ISP_BASE_ADDR+0x25000UL)
+#define ISP_FGAMMA_B_BUF1_CH0              (ISP_BASE_ADDR+0x26000UL)
+#define ISP_YGAMMA_BUF1_CH0                (ISP_BASE_ADDR+0x27000UL)
+#define ISP_NLM_BUF1_CH0                   (ISP_BASE_ADDR+0x28000UL)
+#define ISP_LEN_BUF0_CH0                   (ISP_BASE_ADDR+0x29000UL)
+#define ISP_LEN_BUF1_CH0                   (ISP_BASE_ADDR+0x2b000UL)
+
+#define ISP_AHB_BASE                       SPRD_MMAHB_BASE
+#define ISP_MODULE_EB                      (ISP_AHB_BASE+0x0000UL)
+#define ISP_MODULE_RESET                   (ISP_AHB_BASE+0x0004UL)
+#define ISP_CORE_CLK_EB                    (ISP_AHB_BASE+0x0008UL)
+
+/*isp v memory1: awbm*/
+#define ISP_RAW_AWBM_OUTPUT                (ISP_BASE_ADDR+0x10000)
+/*#define ISP_RAW_AWBM_ITEM                  256*/
+
+/*isp v memory2: aem*/
+#define ISP_RAW_AEM_OUTPUT                 (ISP_BASE_ADDR+0x12000)
+/*#define ISP_RAW_AEM_ITEM                   1024*/
+
+/*isp v memory3: yiq_aem*/
+#define ISP_YIQ_AEM_OUTPUT                 (ISP_BASE_ADDR+0x14000)
+/*#define ISP_YIQ_AEM_ITEM                   1024*/
+
+/*isp v memory11: 3D_LUT0*/
+#define ISP_3D_LUT0_OUTPUT                 (ISP_BASE_ADDR+0x17000)
+/*#define ISP_3D_LUT0_ITEM                    729*/
+
+/*isp v memory12: HSV BUF0*/
+#define ISP_HSV_BUF0_OUTPUT                (ISP_BASE_ADDR+0x18000)
+/*#define ISP_HSV_ITEM                     361*/
+
+/*isp v memory20: 3D_LUT1*/
+#define ISP_3D_LUT1_OUTPUT                 (ISP_BASE_ADDR+0x20000)
+/*#define ISP_3D_LUT1_ITEM                    729*/
+
+/*isp v memory21: HSV BUF1*/
+#define ISP_HSV_BUF1_OUTPUT                (ISP_BASE_ADDR+0x21000)
+/*#define ISP_HSV_ITEM                     361*/
+
+/*irq line number in system*/
+#define ISP_IRQ                            IRQ_ISP_INT
+
+#define ISP_RST_LOG_BIT                    BIT_2
+#define ISP_RST_CFG_BIT                    BIT_3
+
+#define ISP_IRQ_HW_MASK                    (0xFFFFFFFF)
+#define ISP_IRQ_NUM                        (32)
+#define ISP_REG_BUF_SIZE                   (4 * 1024)
+#define ISP_RAW_AE_BUF_SIZE                (1024 * 4 * 3)
+#define ISP_FRGB_GAMMA_BUF_SIZE                (129 * 4)
+#define ISP_YUV_YGAMMA_BUF_SIZE            (129 * 4)
+#define ISP_RAW_AWB_BUF_SIZE                (256 * 4 * 9)
+#define ISP_BING4AWB_SIZE                  (640 * 480 * 2)
+#define ISP_YIQ_ANTIFLICKER_SIZE           (3120 * 4 * 61)
+#define ISP_YIQ_AEM_BUF_SIZE               (1024 * 4)
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_cfg_param.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_cfg_param.c
new file mode 100644
index 00000000..17fb3198
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_cfg_param.c
@@ -0,0 +1,131 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_block.h"
+
+typedef int32_t (*isp_cfg_fun_ptr)(struct isp_io_param *isp_param);
+
+struct isp_cfg_fun {
+	uint32_t sub_block;
+	isp_cfg_fun_ptr cfg_fun;
+};
+
+static struct isp_cfg_fun isp_cfg_fun_tab[] = {
+	{ISP_BLOCK_PRE_GLB_GAIN,           isp_k_cfg_pgg},
+	{ISP_BLOCK_BLC,                    isp_k_cfg_blc},
+	{ISP_BLOCK_RGB_GAIN,               isp_k_cfg_rgb_gain},
+	{ISP_BLOCK_PRE_WAVELET,            isp_k_cfg_pwd},
+	{ISP_BLOCK_NLC,                    isp_k_cfg_nlc},
+	/*{ISP_BLOCK_2D_LSC,                    isp_k_cfg_2d_lsc},*/
+	{ISP_BLOCK_1D_LSC,                 isp_k_cfg_1d_lsc},
+	/*{ISP_BLOCK_BINNING4AWB,                isp_k_cfg_binning},*/
+	/*{ISP_BLOCK_AWB,                    isp_k_cfg_awb},*/
+	/*{ISP_BLOCK_RAW_AEM,                isp_k_cfg_raw_aem},*/
+	{ISP_BLOCK_BPC,                 isp_k_cfg_bpc},
+	{ISP_BLOCK_BDN,               isp_k_cfg_bdn},
+	{ISP_BLOCK_GRGB,                   isp_k_cfg_grgb},
+	{ISP_BLOCK_RGB_GAIN2,              isp_k_cfg_rgb_gain2},
+	{ISP_BLOCK_NLM,                    isp_k_cfg_nlm},
+	{ISP_BLOCK_CFA,                 isp_k_cfg_cfa},
+	{ISP_BLOCK_CMC,                    isp_k_cfg_cmc10},
+	/*{ISP_BLOCK_GAMMA,                  isp_k_cfg_gamma},*/
+	{ISP_BLOCK_CMC8,                   isp_k_cfg_cmc8},
+	/*{ISP_BLOCK_CT,                     isp_k_cfg_ct},*/
+	{ISP_BLOCK_CCE,                    isp_k_cfg_cce},
+	{ISP_BLOCK_HSV,                    isp_k_cfg_hsv},
+	{ISP_BLOCK_CSC,                    isp_k_cfg_csc},
+	{ISP_BLOCK_PRE_CDN_RGB,            isp_k_cfg_pre_cdn_rgb},
+	{ISP_BLOCK_POSTERIZE,              isp_k_cfg_posterize},
+	{ISP_BLOCK_AFM_V1,                 isp_k_cfg_rgb_afm},
+	/*{ISP_BLOCK_YIQ_AEM,                isp_k_cfg_yiq_aem},*/
+	/*{ISP_BLOCK_ANTI_FLICKER,           isp_k_cfg_anti_flicker},*/
+	{ISP_BLOCK_YIQ_AFM,                isp_k_cfg_yiq_afm},
+	{ISP_BLOCK_YUV_PRECDN,             isp_k_cfg_yuv_precdn},
+	{ISP_BLOCK_PRE_FILTER,             isp_k_cfg_prefilter},
+	{ISP_BLOCK_BRIGHTNESS,             isp_k_cfg_brightness},
+	{ISP_BLOCK_CONTRAST,               isp_k_cfg_contrast},
+	{ISP_BLOCK_HIST,                   isp_k_cfg_hist},
+	{ISP_BLOCK_HIST2,                  isp_k_cfg_hist2},
+	{ISP_BLOCK_ACA,                    isp_k_cfg_aca},
+	{ISP_BLOCK_YUV_CDN,                isp_k_cfg_yuv_cdn},
+	{ISP_BLOCK_EDGE,                   isp_k_cfg_edge},
+	{ISP_BLOCK_CSS,                    isp_k_cfg_css},
+	{ISP_BLOCK_CSA,                    isp_k_cfg_csa},
+	{ISP_BLOCK_HUE,                    isp_k_cfg_hue},
+	{ISP_BLOCK_POST_CDN,               isp_k_cfg_post_cdn},
+	{ISP_BLOCK_EMBOSS,                 isp_k_cfg_emboss},
+	/*{ISP_BLOCK_YGAMMA,                 isp_k_cfg_ygamma},*/
+	{ISP_BLOCK_YDELAY,                 isp_k_cfg_ydelay},
+	{ISP_BLOCK_IIRCNR,                 isp_k_cfg_iircnr},
+	{ISP_BLOCK_FETCH,                  isp_k_cfg_fetch},
+	{ISP_BLOCK_STORE,                  isp_k_cfg_store},
+	{ISP_BLOCK_DISPATCH,               isp_k_cfg_dispatch},
+	{ISP_BLOCK_ARBITER_V1,             isp_k_cfg_arbiter},
+	{ISP_BLOCK_RAW_SIZER,              isp_k_cfg_raw_sizer},
+	{ISP_BLOCK_COMMON_V1,              isp_k_cfg_common},
+};
+
+int32_t isp_cfg_param(void  *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t i = 0, cnt = 0;
+	isp_cfg_fun_ptr cfg_fun_ptr = NULL;
+	struct isp_io_param isp_param = {0, 0, 0, NULL};
+
+	if (!param) {
+		printk("isp_cfg_param: param is null error.\n");
+		return -1;
+	}
+
+	ret = copy_from_user((void *)&isp_param, (void *)param, sizeof(isp_param));
+	if ( 0 != ret) {
+		printk("isp_cfg_param: copy error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (ISP_BLOCK_ANTI_FLICKER == isp_param.sub_block) {
+		ret = isp_k_cfg_anti_flicker(&isp_param, isp_private);
+	} else if (ISP_BLOCK_2D_LSC == isp_param.sub_block) {
+		ret = isp_k_cfg_2d_lsc(&isp_param, isp_private);
+	} else if (ISP_BLOCK_RAW_AEM == isp_param.sub_block) {
+		ret = isp_k_cfg_raw_aem(&isp_param, isp_private);
+	} else if (ISP_BLOCK_YIQ_AEM == isp_param.sub_block) {
+		ret = isp_k_cfg_yiq_aem(&isp_param, isp_private);
+	} else if (ISP_BLOCK_GAMMA == isp_param.sub_block) {
+		ret = isp_k_cfg_gamma(&isp_param, isp_private);
+	} else if (ISP_BLOCK_CT == isp_param.sub_block) {
+		ret = isp_k_cfg_ct(&isp_param, isp_private);
+	} else if (ISP_BLOCK_YGAMMA == isp_param.sub_block) {
+		ret = isp_k_cfg_ygamma(&isp_param, isp_private);
+	} else if (ISP_BLOCK_AWB == isp_param.sub_block) {
+		ret = isp_k_cfg_awb(&isp_param, isp_private);
+	} else if(ISP_BLOCK_BINNING4AWB == isp_param.sub_block){
+		ret = isp_k_cfg_binning(&isp_param, isp_private);
+	} else {
+		cnt = sizeof(isp_cfg_fun_tab) / sizeof(isp_cfg_fun_tab[0]);
+		for (i = 0; i < cnt; i++) {
+			if (isp_param.sub_block == isp_cfg_fun_tab[i].sub_block) {
+				cfg_fun_ptr = isp_cfg_fun_tab[i].cfg_fun;
+				break;
+			}
+		}
+
+		if (NULL != cfg_fun_ptr)
+			ret = cfg_fun_ptr(&isp_param);
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_1d_lsc.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_1d_lsc.c
new file mode 100644
index 00000000..3daa3ef5
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_1d_lsc.c
@@ -0,0 +1,146 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_1d_lsc_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_1d_lsc_info lnc_info;
+
+	ret = copy_from_user((void *)&lnc_info, param->property_param, sizeof(lnc_info));
+	if (0 != ret) {
+		printk("isp_k_1d_lsc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_1D_LNC_PARAM, BIT_0, lnc_info.bypass);
+
+	val = (lnc_info.gain_max_thr & 0x1FFF) << 1;
+	REG_MWR(ISP_1D_LNC_PARAM, 0x3FFE, val);
+
+	val = ((lnc_info.center_r0c0_col_x & 0x1FFF) << 12) | (lnc_info.center_r0c0_row_y & 0xFFF);
+	REG_WR(ISP_1D_LNC_PARAM1, val);
+	val = ((lnc_info.center_r0c1_col_x & 0x1FFF) << 12) | (lnc_info.center_r0c1_row_y & 0xFFF);
+	REG_WR(ISP_1D_LNC_PARAM2, val);
+	val = ((lnc_info.center_r1c0_col_x & 0x1FFF) << 12) | (lnc_info.center_r1c0_row_y & 0xFFF);
+	REG_WR(ISP_1D_LNC_PARAM3, val);
+	val = ((lnc_info.center_r1c1_col_x & 0x1FFF) << 12) | (lnc_info.center_r1c1_row_y & 0xFFF);
+	REG_WR(ISP_1D_LNC_PARAM4, val);
+
+	val = lnc_info.delta_square_r0c0_x & 0x3FFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM5, val);
+	val = lnc_info.delta_square_r0c1_x & 0x3FFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM7, val);
+	val = lnc_info.delta_square_r1c0_x & 0x3FFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM9, val);
+	val = lnc_info.delta_square_r1c1_x & 0x3FFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM11, val);
+	val = lnc_info.delta_square_r0c0_y & 0xFFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM6, val);
+	val = lnc_info.delta_square_r0c1_y & 0xFFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM8, val);
+	val = lnc_info.delta_square_r1c0_y & 0xFFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM10, val);
+	val = lnc_info.delta_square_r1c1_y & 0xFFFFFF;
+	REG_WR(ISP_1D_LNC_PARAM12, val);
+
+	val = ((lnc_info.coef_r0c0_p1 & 0xFFFF) << 11) | (lnc_info.coef_r0c0_p2 & 0x7FF);
+	REG_WR(ISP_1D_LNC_PARAM13, val);
+	val = ((lnc_info.coef_r0c1_p1 & 0xFFFF) << 11) | (lnc_info.coef_r0c1_p2 & 0x7FF);
+	REG_WR(ISP_1D_LNC_PARAM14, val);
+	val = ((lnc_info.coef_r1c0_p1 & 0xFFFF) << 11) | (lnc_info.coef_r1c0_p2 & 0x7FF);
+	REG_WR(ISP_1D_LNC_PARAM15, val);
+	val = ((lnc_info.coef_r1c1_p1 & 0xFFFF) << 11) | (lnc_info.coef_r1c1_p2 & 0x7FF);
+	REG_WR(ISP_1D_LNC_PARAM16, val);
+
+	val = ((lnc_info.start_pos.x & 0x1FFF) << 12) | (lnc_info.start_pos.y & 0xFFF);
+	REG_WR(ISP_1D_LNC_PARAM18, val);
+
+	return ret;
+}
+
+static int32_t isp_k_1d_lsc_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size;
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_1d_lsc_slice_size: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.width & 0x1FFF) << 12) | (size.height & 0xFFF);
+
+	REG_WR(ISP_1D_LNC_PARAM17, val);
+
+	return ret;
+}
+
+static int32_t isp_k_1d_lsc_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct img_offset pos;
+
+	ret = copy_from_user((void *)&pos, param->property_param, sizeof(struct img_offset));
+	if (0 != ret) {
+		printk("isp_k_1d_lsc_pos: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((pos.x & 0x1FFF) << 12) | (pos.y & 0xFFF);
+
+	REG_WR(ISP_1D_LNC_PARAM18, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_1d_lsc(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_1d_lsc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_1d_lsc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_1D_LSC_BLOCK:
+		ret = isp_k_1d_lsc_block(param);
+		break;
+	case ISP_PRO_1D_LSC_SLICE_SIZE:
+		ret = isp_k_1d_lsc_slice_size(param);
+		break;
+	case ISP_PRO_1D_LSC_POS:
+		ret = isp_k_1d_lsc_pos(param);
+		break;
+	default:
+		printk("isp_k_cfg_1d_lsc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_2d_lsc.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_2d_lsc.c
new file mode 100644
index 00000000..b0c4bd74
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_2d_lsc.c
@@ -0,0 +1,537 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include <asm/cacheflush.h>
+#include <linux/delay.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+
+#define ISP_LSC_TIME_OUT_MAX        5
+#define ISP_LSC_BUF0                0
+#define ISP_LSC_BUF1                1
+
+#if 0
+#define CLIP(input,top, bottom) {if (input>top) input = top; if (input < bottom) input = bottom;}
+#define TABLE_LEN_128	128
+#define TABLE_LEN_96	96
+
+typedef struct lnc_bicubic_weight_t_64_tag
+{
+	int16_t w0;
+	int16_t w1;
+	int16_t w2;
+	int16_t w3;
+}LNC_BICUBIC_WEIGHT_TABLE_T;
+////////10bit precision//////////////////////////////////////
+static LNC_BICUBIC_WEIGHT_TABLE_T lnc_bicubic_weight_t_96_simple[] =
+{
+	{0,	1024,	0},
+	{-5,1024,	6},
+	{-10,1023,	12},
+	{-15,1022,	18},
+	{-20,1020,	25},
+	{-24,1017,	32},
+	{-28,1014,	40},
+	{-32,1011,	48},
+	{-36,1007,	56},
+	{-39,1003,	65},
+	{-43,998,	74},
+	{-46,993,	83},
+	{-49,987,	93},
+	{-52,981,	103},
+	{-54,974,	113},
+	{-57,967,	124},
+	{-59,960,	135},
+	{-61,952,	146},
+	{-63,944,	158},
+	{-65,936,	170},
+	{-67,927,	182},
+	{-68,918,	194},
+	{-70,908,	206},
+	{-71,898,	219},
+	{-72,888,	232},
+	{-73,878,	245},
+	{-74,867,	258},
+	{-74,856,	272},
+	{-75,844,	285},
+	{-75,833,	299},
+	{-76,821,	313},
+	{-76,809,	327},
+	{-76,796,	341},
+	{-76,784,	356},
+	{-76,771,	370},
+	{-75,758,	384},
+	{-75,745,	399},
+	{-75,732,	414},
+	{-74,718,	428},
+	{-73,704,	443},
+	{-73,691,	458},
+	{-72,677,	473},
+	{-71,663,	487},
+	{-70,648,	502},
+	{-69,634,	517},
+	{-68,620,	532},
+	{-67,605,	547},
+	{-65,591,	561},
+	{-64,576,	576},
+};
+
+static LNC_BICUBIC_WEIGHT_TABLE_T lnc_bicubic_weight_t_128_simple[] =
+{
+	 {0,	1024,	0},
+	 {-4,	1024,	4},
+	 {-8,	1023,	8},
+	 {-11,	1023,	13},
+	 {-15,	1022,	18},
+	 {-18,	1020,	23},
+	 {-22,	1019,	28},
+	 {-25,	1017,	34},
+	 {-28,	1014,	40},
+	 {-31,	1012,	46},
+	 {-34,	1009,	52},
+	 {-37,	1006,	58},
+	 {-39,	1003,	65},
+	 {-42,	999,	72},
+	 {-44,	995,	78},
+	 {-47,	991,	86},
+	 {-49,	987,	93},
+	 {-51,	982,	101},
+	 {-53,	978,	108},
+	 {-55,	973,	116},
+	 {-57,	967,	124},
+	 {-59,	962,	132},
+	 {-60,	956,	141},
+	 {-62,	950,	149},
+	 {-63,	944,	158},
+	 {-65,	938,	167},
+	 {-66,	931,	176},
+	 {-67,	925,	185},
+	 {-68,	918,	194},
+	 {-69,	910,	203},
+	 {-70,	903,	213},
+	 {-71,	896,	222},
+	 {-72,	888,	232},
+	 {-73,	880,	242},
+	 {-73,	872,	252},
+	 {-74,	864,	262},
+	 {-74,	856,	272},
+	 {-75,	847,	282},
+	 {-75,	839,	292},
+	 {-75,	830,	303},
+	 {-76,	821,	313},
+	 {-76,	812,	324},
+	 {-76,	803,	334},
+	{-76,	793,	345},
+	{-76,	784,	356},
+	{-76,	774,	366},
+	{-76,	765,	377},
+	{-75,	755,	388},
+	{-75,	745,	399},
+	{-75,	735,	410},
+	{-74,	725,	421},
+	{-74,	715,	432},
+	{-73,	704,	443},
+	{-73,	694,	454},
+	{-72,	684,	465},
+	{-72,	673,	476},
+	{-71,	663,	487},
+	{-70,	652,	498},
+	{-69,	641,	510},
+	{-69,	631,	521},
+	{-68,	620,	532},
+	{-67,	609,	543},
+	{-66,	598,	554},
+	{-65,	587,	565},
+	{-64,	576,	576},
+};
+
+static uint16_t ISP_Cubic1D(uint16_t a, uint16_t b, uint16_t c, uint16_t d, uint16_t u, uint16_t box)
+{
+	int32_t out_value;
+	uint16_t out_value_uint16_t;
+	int16_t w0, w1, w2, w3;
+	uint32_t out_value_tmp;
+	int16_t sub_tmp0;
+	int16_t sub_tmp1;
+	int16_t sub_tmp2;
+
+	if(box ==96)
+	{
+		//use simple table
+		if ( u < (TABLE_LEN_96/2 + 1) )
+		{
+			w0 = lnc_bicubic_weight_t_96_simple[u].w0 ;
+			w1 = lnc_bicubic_weight_t_96_simple[u].w1 ;
+			w2 = lnc_bicubic_weight_t_96_simple[u].w2 ;
+
+			sub_tmp0 = a-d;
+			sub_tmp1 = b-d;
+			sub_tmp2 = c-d;
+			out_value_tmp = ((uint32_t)d)<<10;
+			out_value = out_value_tmp + sub_tmp0 * w0  + sub_tmp1 * w1 + sub_tmp2 * w2;
+		}
+		else
+		{
+			w1 = lnc_bicubic_weight_t_96_simple[TABLE_LEN_96 - u].w2 ;
+			w2 = lnc_bicubic_weight_t_96_simple[TABLE_LEN_96 - u].w1 ;
+			w3 = lnc_bicubic_weight_t_96_simple[TABLE_LEN_96 - u].w0 ;
+
+			sub_tmp0 = b-a;
+			sub_tmp1 = c-a;
+			sub_tmp2 = d-a;
+			out_value_tmp = ((uint32_t)a)<<10;
+			out_value = out_value_tmp + sub_tmp0 * w1  + sub_tmp1 * w2 + sub_tmp2 * w3;
+		}
+
+	}
+	else
+	{
+		u = u * (TABLE_LEN_128 / box);
+
+		//use simple table
+		if ( u < (TABLE_LEN_128/2 + 1) )
+		{
+			w0 = lnc_bicubic_weight_t_128_simple[u].w0 ;
+			w1 = lnc_bicubic_weight_t_128_simple[u].w1 ;
+			w2 = lnc_bicubic_weight_t_128_simple[u].w2 ;
+
+			sub_tmp0 = a-d;
+			sub_tmp1 = b-d;
+			sub_tmp2 = c-d;
+			out_value_tmp = ((uint32_t)d)<<10;
+			out_value = out_value_tmp + sub_tmp0 * w0  + sub_tmp1 * w1 + sub_tmp2 * w2;
+		}
+		else
+		{
+			w1 = lnc_bicubic_weight_t_128_simple[TABLE_LEN_128 - u].w2 ;
+			w2 = lnc_bicubic_weight_t_128_simple[TABLE_LEN_128 - u].w1 ;
+			w3 = lnc_bicubic_weight_t_128_simple[TABLE_LEN_128 - u].w0 ;
+
+			sub_tmp0 = b-a;
+			sub_tmp1 = c-a;
+			sub_tmp2 = d-a;
+			out_value_tmp = ((uint32_t)a)<<10;
+			out_value = out_value_tmp + sub_tmp0 * w1  + sub_tmp1 * w2 + sub_tmp2 * w3;
+		}
+	}
+
+	//CLIP(out_value, 4095*1024*2, 1024*1024);	// for LSC gain, 1024 = 1.0, 4095 = 4.0 ; 4095*2 is for boundary extension.
+	CLIP(out_value, 16383*1024, 1024*1024);	// for LSC gain, 1024 = 1.0, 16383 = 16.0 ; 16383 is for boundary extension, 14 bit parameter is used.
+
+	out_value_uint16_t = (uint16_t)((out_value + 512) >> 10);
+
+	return out_value_uint16_t;
+}
+
+
+static int32_t ISP_GenerateQValues(uint32_t word_endian, uint32_t q_val[][5], unsigned long param_address, uint16_t grid_w, uint16_t grid_num, uint16_t u)
+{
+	uint8_t i;
+	uint16_t A0, B0, C0, D0;
+	uint16_t A1, B1, C1, D1;
+	uint32_t *addr = (uint32_t *)param_address;
+
+	if (param_address == 0x0 || grid_num == 0x0) {
+		printk("ISP_GenerateQValues param_address error addr=0x%lx grid_num=%d \n",param_address, grid_num);
+		return -1;
+	}
+
+	//printk("ISP_GenerateQValues:addr=%x  grid_w=%d  grid_num=%d u=%d \n",param_address,grid_w,grid_num,u);
+	#if 0
+	for (i = 0; i < 5; i++) {
+		A0  = (uint16_t)*(addr + i * 2) & 0xFFFF;
+		B0  = (uint16_t)*(addr + i * 2 + grid_w * 2) & 0xFFFF;
+		C0  = (uint16_t)*(addr + i * 2 + grid_w * 2 * 2) & 0xFFFF;
+		D0  = (uint16_t)*(addr + i * 2 + grid_w * 2 * 3) & 0xFFFF;
+		A1  = (uint16_t)(*(addr + i * 2) >> 16);
+		B1  = (uint16_t)(*(addr + i * 2 + grid_w * 2) >> 16);
+		C1  = (uint16_t)(*(addr + i * 2 + grid_w * 2 * 2) >> 16);
+		D1  = (uint16_t)(*(addr + i * 2 + grid_w * 2 * 3) >> 16);
+		q_val[0][i] = ISP_Cubic1D(A0, B0, C0, D0, u, grid_num);
+		q_val[1][i] = ISP_Cubic1D(A1, B1, C1, D1, u, grid_num);
+	}
+	#endif
+	#if 1
+	for (i = 0; i < 5; i++) {
+		if (1 == word_endian) {	// ABCD = 1 word
+			A0  = *(addr + i * 2) >> 16;					// AB
+			B0  = *(addr + i * 2 + grid_w * 2) >> 16;       // AB
+			C0  = *(addr + i * 2 + grid_w * 2 * 2) >> 16;   // AB
+			D0  = *(addr + i * 2 + grid_w * 2 * 3) >> 16;   // AB
+			A1  = *(addr + i * 2) & 0xFFFF;					// CD
+			B1  = *(addr + i * 2 + grid_w * 2) & 0xFFFF;    // CD
+			C1  = *(addr + i * 2 + grid_w * 2 * 2) & 0xFFFF;// CD
+			D1  = *(addr + i * 2 + grid_w * 2 * 3) & 0xFFFF;// CD
+		} else if (2 == word_endian) { // CDAB = 1 word
+			A0  = *(addr + i * 2) & 0xFFFF;
+			B0  = *(addr + i * 2 + grid_w * 2) & 0xFFFF;
+			C0  = *(addr + i * 2 + grid_w * 2 * 2) & 0xFFFF;
+			D0  = *(addr + i * 2 + grid_w * 2 * 3) & 0xFFFF;
+			A1  = *(addr + i * 2) >> 16;
+			B1  = *(addr + i * 2 + grid_w * 2) >> 16;
+			C1  = *(addr + i * 2 + grid_w * 2 * 2) >> 16;
+			D1  = *(addr + i * 2 + grid_w * 2 * 3) >> 16;
+		} else if (0 == word_endian) { // DCBA = 1 word
+			A0  = ((*(addr + i * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2) >> 8) & 0x000000FF);
+			B0  = ((*(addr + i * 2 + grid_w * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2) >> 8) & 0x000000FF);
+			C0  = ((*(addr + i * 2 + grid_w * 2 * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2 * 2) >> 8) & 0x000000FF);
+			D0  = ((*(addr + i * 2 + grid_w * 2 * 3) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2 * 3) >> 8) & 0x000000FF);
+			A1  = ((*(addr + i * 2) << 8) & 0xFF000000) | ((*(addr + i * 2) >> 8) & 0x00FF0000);
+			B1  = ((*(addr + i * 2 + grid_w * 2) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2) >> 8) & 0x00FF0000);
+			C1  = ((*(addr + i * 2 + grid_w * 2 * 2) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2 * 2) >> 8) & 0x00FF0000);
+			D1  = ((*(addr + i * 2 + grid_w * 2 * 3) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2 * 3) >> 8) & 0x00FF0000);
+		} else if (3 == word_endian) { // BADC = 1 word
+			A0  = ((*(addr + i * 2) << 8) & 0xFF000000) | ((*(addr + i * 2) >> 8) & 0x00FF0000);
+			B0  = ((*(addr + i * 2 + grid_w * 2) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2) >> 8) & 0x00FF0000);
+			C0  = ((*(addr + i * 2 + grid_w * 2 * 2) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2 * 2) >> 8) & 0x00FF0000);
+			D0  = ((*(addr + i * 2 + grid_w * 2 * 3) << 8) & 0xFF000000) | ((*(addr + i * 2 + grid_w * 2 * 3) >> 8) & 0x00FF0000);
+			A1  = ((*(addr + i * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2) >> 8) & 0x000000FF);
+			B1  = ((*(addr + i * 2 + grid_w * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2) >> 8) & 0x000000FF);
+			C1  = ((*(addr + i * 2 + grid_w * 2 * 2) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2 * 2) >> 8) & 0x000000FF);
+			D1  = ((*(addr + i * 2 + grid_w * 2 * 3) << 8) & 0x0000FF00) | ((*(addr + i * 2 + grid_w * 2 * 3) >> 8) & 0x000000FF);
+		}
+		//printk("ISP_GenerateQValues: A0=%x B0=%x C0=%x D0=%x A1=%x B1=%x C1=%x D1=%x \n",A0,B0,C0,D0,A1,B1,C1,D1);
+		q_val[0][i] = ISP_Cubic1D(A0, B0, C0, D0, u, grid_num);
+		q_val[1][i] = ISP_Cubic1D(A1, B1, C1, D1, u, grid_num);
+		//printk("ISP_GenerateQValues: q_val[0][%d] = %d  q_val[1][%d] = %d \n",i,q_val[0][i],i ,q_val[1][i] );
+	}
+	#endif
+
+	return 0;
+}
+#endif
+
+static int32_t isp_k_2d_lsc_param_load(struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t time_out_cnt = 0;
+	uint32_t addr = 0, reg_value = 0;
+
+	if (ISP_LSC_BUF0 == isp_private->lsc_load_buf_id) {
+		isp_private->lsc_load_buf_id = ISP_LSC_BUF1;
+	} else {
+		isp_private->lsc_load_buf_id = ISP_LSC_BUF0;
+	}
+	REG_MWR(ISP_LENS_LOAD_BUF, BIT_0, isp_private->lsc_load_buf_id);
+	REG_WR(ISP_LENS_PARAM_ADDR, isp_private->lsc_buf_phys_addr);
+	REG_OWR(ISP_LENS_LOAD_EB, BIT_0);
+	REG_MWR(ISP_LENS_PARAM, BIT_1, isp_private->lsc_load_buf_id << 1);
+	isp_private->lsc_update_buf_id = isp_private->lsc_load_buf_id;
+
+	reg_value = REG_RD(ISP_INT_RAW0);
+
+	while ((0x00 == (reg_value & ISP_INT_EVT_LSC_LOAD))
+		&& (time_out_cnt < ISP_LSC_TIME_OUT_MAX)) {
+		msleep(1);
+		reg_value = REG_RD(ISP_INT_RAW0);
+		time_out_cnt++;
+	}
+	if (time_out_cnt >= ISP_LSC_TIME_OUT_MAX) {
+		ret = -1;
+		printk("isp_k_2d_lsc_param_load: lsc load time out error.\n");
+	}
+	REG_OWR(ISP_INT_CLR0, ISP_INT_EVT_LSC_LOAD);
+
+	return ret;
+}
+
+static int32_t isp_k_2d_lsc_block(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	//uint32_t qvalue_addr = ISP_LEN_BUF0_CH0;
+	struct isp_dev_2d_lsc_info lens_info;
+
+	memset(&lens_info, 0x00, sizeof(lens_info));
+
+	ret = copy_from_user((void *)&lens_info, param->property_param, sizeof(lens_info));
+	if (0 != ret) {
+		printk("isp_k_2d_lsc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((lens_info.offset_y & 0xFFFF) << 16) | (lens_info.offset_x & 0xFFFF);
+	REG_WR(ISP_LENS_SLICE_POS, val);
+
+	val = lens_info.grid_pitch & 0x1FF;
+	REG_MWR(ISP_LENS_GRID_PITCH, 0x1FF, val);
+
+	val = (lens_info.grid_width & 0xFF) << 16;
+	REG_MWR(ISP_LENS_GRID_PITCH, 0xFF0000, val);
+
+	val = ((lens_info.grid_num_t & 0xFFFF) << 16) | ((lens_info.grid_y_num & 0xFF) << 8) | (lens_info.grid_x_num & 0xFF);
+	REG_WR(ISP_LENS_GRID_SIZE, val);
+
+	REG_MWR(ISP_LENS_LOAD_BUF, BIT_1, lens_info.load_chn_sel << 1);
+
+	REG_MWR(ISP_LENS_MISC, (BIT_1 | BIT_0), (lens_info.endian & 0x03));
+
+	val = ((lens_info.slice_size.height & 0xFFFF) << 16) | (lens_info.slice_size.width & 0xFFFF);
+	REG_WR(ISP_LENS_SLICE_SIZE, val);
+
+	val = ((lens_info.relative_y & 0xFF) << 8) | (lens_info.relative_x & 0xFF);
+	REG_WR(ISP_LENS_INIT_COOR, val);
+
+	/*ret = isp_k_2d_lsc_param_load(&src_buf, isp_private, &qvalue_addr);
+	REG_WR(ISP_LENS_PARAM_ADDR, qvalue_addr);
+	printk("isp_k_2d_lsc_block:qvalue_addr=%x grid_x_num=%d grid_width=%d  relative_y=%d \n",qvalue_addr,(lens_info.grid_x_num & 0xFF),(lens_info.grid_width & 0xFF), (lens_info.relative_y & 0xFF)>>1);
+
+	ISP_GenerateQValues(1, lens_info.q_value, qvalue_addr, ((uint16_t)lens_info.grid_x_num & 0xFF) + 2,(lens_info.grid_width & 0xFF), (lens_info.relative_y & 0xFF)>>1);
+	*/
+
+	ret = isp_k_2d_lsc_param_load(isp_private);
+	if (0 != ret) {
+		printk("isp_k_2d_lsc_block: lsc load para error, ret=0x%x\n", (uint32_t)ret);
+		REG_MWR(ISP_LENS_PARAM, BIT_0, ISP_BYPASS_EB);
+		return -1;
+	}
+
+	for (i = 0; i < 5; i++) {
+		val = ((lens_info.q_value[0][i] & 0x3FFF) << 16) | (lens_info.q_value[1][i] & 0x3FFF);
+		REG_WR(ISP_LENS_Q0_VALUE + i * 4, val);
+	}
+
+	REG_MWR(ISP_LENS_PARAM, BIT_0, lens_info.bypass);
+
+	return ret;
+
+}
+
+static int32_t isp_k_2d_lsc_param_update(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	REG_MWR(ISP_LENS_PARAM, BIT_1, isp_private->lsc_update_buf_id << 1);
+
+	return ret;
+}
+
+static int32_t isp_k_2d_lsc_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_offset offset = {0, 0};
+
+	ret = copy_from_user((void *)&offset, param->property_param, sizeof(offset));
+	if (0 != ret) {
+		printk("isp_k_lens_pos: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((offset.y & 0xFFFF) << 16) | (offset.x & 0xFFFF);
+
+	REG_WR(ISP_LENS_SLICE_POS, val);
+
+	return ret;
+}
+
+static int32_t isp_k_2d_lsc_grid_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t grid_total = 0;
+	struct isp_img_size size = {0, 0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_2d_lsc_grid_size: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	grid_total = (size.height + 2) * (size.width + 2);
+	val = ((grid_total & 0xFFFF) << 16) | ((size.height & 0xFF) << 8) | (size.width & 0xFF);
+	REG_WR(ISP_LENS_GRID_SIZE, val);
+
+	return ret;
+}
+
+static int32_t isp_k_2d_lsc_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0, 0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_2d_lsc_slice_size: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0xFFFF) << 16) | (size.width & 0xFFFF);
+
+	REG_WR(ISP_LENS_SLICE_SIZE, val);
+
+	return ret;
+}
+
+static int32_t isp_k_2d_lsc_transaddr(struct isp_io_param *param,
+			struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	struct isp_lsc_addr lsc_addr;
+
+	ret = copy_from_user((void *)&lsc_addr, param->property_param, sizeof(struct isp_lsc_addr));
+
+	isp_private->lsc_buf_phys_addr = lsc_addr.phys_addr;
+
+	printk("lsc phys addr 0x%x,\n",isp_private->lsc_buf_phys_addr);
+	return ret;
+}
+
+int32_t isp_k_cfg_2d_lsc(struct isp_io_param *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_2d_lsc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_2d_lsc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_2D_LSC_BLOCK:
+		ret = isp_k_2d_lsc_block(param, isp_private);
+		break;
+	case ISP_PRO_2D_LSC_PARAM_UPDATE:
+		ret = isp_k_2d_lsc_param_update(param, isp_private);
+		break;
+	case ISP_PRO_2D_LSC_POS:
+		ret = isp_k_2d_lsc_pos(param);
+		break;
+	case ISP_PRO_2D_LSC_GRID_SIZE:
+		ret = isp_k_2d_lsc_grid_size(param);
+		break;
+	case ISP_PRO_2D_LSC_SLICE_SIZE:
+		ret = isp_k_2d_lsc_slice_size(param);
+		break;
+	case ISP_PRO_2D_LSC_TRANSADDR:
+		ret = isp_k_2d_lsc_transaddr(param, isp_private);
+		break;
+	default:
+		printk("isp_k_cfg_2d_lsc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_aca.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_aca.c
new file mode 100644
index 00000000..0d784c73
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_aca.c
@@ -0,0 +1,78 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_aca_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_autocont_info_v1 autocont_info;
+	uint32_t val = 0;
+
+	memset(&autocont_info, 0x00, sizeof(autocont_info));
+
+	ret = copy_from_user((void *)&autocont_info, param->property_param, sizeof(autocont_info));
+	if (0 != ret) {
+		printk("isp_k_aca_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((autocont_info.out_max & 0xFF) << 24)
+			| ((autocont_info.out_min & 0xFF) << 16)
+			| ((autocont_info.in_max & 0xFF) << 8)
+			| (autocont_info.in_min & 0xFF);
+
+	REG_WR(ISP_AUTOCONT_MAX_MIN, val);
+
+	if (autocont_info.mode) {
+		REG_OWR(ISP_AUTOCONT_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_AUTOCONT_PARAM, BIT_1, 0);
+	}
+
+	if (autocont_info.bypass) {
+		REG_OWR(ISP_AUTOCONT_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_AUTOCONT_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_aca(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_aca: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_aca: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_ACA_BLOCK:
+		ret = isp_k_aca_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_aca: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_anti_flicker.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_anti_flicker.c
new file mode 100755
index 00000000..e1f29d71
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_anti_flicker.c
@@ -0,0 +1,150 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include <asm/cacheflush.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+static int32_t isp_k_afl_param_update(struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t addr = 0;
+#ifndef CONFIG_64BIT
+	void *buf_ptr = (void *)isp_private->yiq_antiflicker_buf_addr;
+#endif
+	uint32_t buf_len = isp_private->yiq_antiflicker_len;
+
+	if((0x00 != isp_private->yiq_antiflicker_buf_addr) && (0x00 != isp_private->yiq_antiflicker_len)) {
+
+#ifndef CONFIG_64BIT
+		dmac_flush_range(buf_ptr, buf_ptr + buf_len);
+		outer_flush_range(__pa(buf_ptr), __pa(buf_ptr) + buf_len);
+#endif
+		addr = (uint32_t)__pa(isp_private->yiq_antiflicker_buf_addr);
+
+		REG_WR(ISP_ANTI_FLICKER_DDR_INIT_ADDR, addr);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_afl_statistic(struct isp_io_param *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	int32_t i = 0;
+	int32_t *addr = NULL;
+	if((0x00 != isp_private->yiq_antiflicker_buf_addr) && (0x00 != param->property_param) \
+		&& (0x00 != isp_private->yiq_antiflicker_len) ) {
+
+		ret = copy_to_user(param->property_param, isp_private->yiq_antiflicker_buf_addr, isp_private->yiq_antiflicker_len);
+		if (0 != ret) {
+			ret = -1;
+			printk("isp_k_afl_statistic: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+		}
+
+	}
+}
+
+static int32_t isp_k_afl_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_afl_bypass: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (bypass) {
+		REG_OWR(ISP_ANTI_FLICKER_PARAM0, BIT_0);
+	} else {
+		REG_MWR(ISP_ANTI_FLICKER_PARAM0, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+
+static int32_t isp_k_anti_flicker_block(struct isp_io_param *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	struct isp_dev_anti_flicker_info_v1 afl_info;
+
+	memset(&afl_info, 0x00, sizeof(afl_info));
+
+	ret = copy_from_user((void *)&afl_info, param->property_param, sizeof(afl_info));
+	if (0 != ret) {
+		printk("isp_k_anti_flicker_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM0, BIT_0, afl_info.bypass);
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM0, BIT_1, afl_info.mode << 1);
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM0, 0xF << 2, afl_info.skip_frame_num << 2);
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM1, 0xF , afl_info.line_step);
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM1, 0xFF << 8, afl_info.frame_num << 8);
+
+	REG_MWR(ISP_ANTI_FLICKER_PARAM1, 0xFFFF << 16, afl_info.vheight << 16);
+
+	REG_MWR(ISP_ANTI_FLICKER_COL_POS, 0xFFFF , afl_info.start_col);
+
+	REG_MWR(ISP_ANTI_FLICKER_COL_POS,  0xFFFF << 16, afl_info.end_col << 16);
+
+	//config afl DDR initial address
+	isp_k_afl_param_update(isp_private);
+
+	//REG_WR(ISP_ANTI_FLICKER_DDR_INIT_ADDR, afl_info.addr);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_anti_flicker(struct isp_io_param *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_anti_flicker: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_anti_flicker: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_ANTI_FLICKER_BLOCK:
+		ret = isp_k_anti_flicker_block(param, isp_private);
+		break;
+	case ISP_PRO_ANTI_FLICKER_STATISTIC:
+		ret = isp_k_afl_statistic(param, isp_private);
+		break;
+	case ISP_PRO_ANTI_FLICKER_BYPASS:
+		ret = isp_k_afl_bypass(param);
+		break;
+	default:
+		printk("isp_k_cfg_anti_flicker: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_arbiter.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_arbiter.c
new file mode 100644
index 00000000..4031b04e
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_arbiter.c
@@ -0,0 +1,177 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_arbiter_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_arbiter_info_v1 arbiter_info;
+	uint32_t val = 0;
+
+	memset(&arbiter_info, 0x00, sizeof(arbiter_info));
+
+	ret = copy_from_user((void *)&arbiter_info, param->property_param, sizeof(arbiter_info));
+	if (0 != ret) {
+		printk("isp_k_arbiter_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((arbiter_info.endian_ch0.bpc_endian & 0x3) << 8) | ((arbiter_info.endian_ch0.lens_endian & 0x3) << 6)
+		| ((arbiter_info.endian_ch0.store_endian & 0x3) << 4) | ((arbiter_info.endian_ch0.fetch_bit_reorder & 0x1) << 2)
+		| (arbiter_info.endian_ch0.fetch_endian & 0x3);
+	REG_WR(ISP_ARBITER_ENDIAN_CH0, val);
+
+	val = ((arbiter_info.endian_ch1.bpc_endian & 0x3) << 8) | ((arbiter_info.endian_ch1.lens_endian & 0x3) << 6)
+		| ((arbiter_info.endian_ch1.store_endian & 0x3) << 4) | ((arbiter_info.endian_ch1.fetch_bit_reorder & 0x1) << 2)
+		| (arbiter_info.endian_ch1.fetch_endian & 0x3);
+	REG_WR(ISP_ARBITER_ENDIAN_CH1, val);
+
+	val = (arbiter_info.para.pause_cycle & 0xFF) | ((arbiter_info.para.reset & 0x1) << 8);
+	REG_WR(ISP_ARBITER_PARAM, val);
+
+	return ret;
+}
+
+static int32_t isp_k_arbiter_wr_status(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t status = 0;
+
+	status = REG_RD(ISP_PRO_ARBITER_WR_STATUS);
+
+	ret = copy_to_user(param->property_param, (void*)&status, sizeof(status));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_arbiter_wr_status: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_arbiter_rd_status(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t status = 0;
+
+	status = REG_RD(ISP_PRO_ARBITER_RD_STATUS);
+
+	ret = copy_to_user(param->property_param, (void*)&status, sizeof(status));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_arbiter_rd_status: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_arbiter_endian_ch0(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct arbiter_endian_v1 endian = {0};
+
+	ret = copy_from_user((void *)&endian, param->property_param, sizeof(endian));
+	if (0 != ret) {
+		printk("isp_k_arbiter_endian_ch0: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((endian.bpc_endian & 0x3) << 8) | ((endian.lens_endian & 0x3) << 6) | ((endian.store_endian & 0x3) << 4)
+		| ((endian.fetch_bit_reorder & 0x1) << 2) | (endian.fetch_endian & 0x3);
+	REG_WR(ISP_ARBITER_ENDIAN_CH0, val);
+
+	return ret;
+}
+
+static int32_t isp_k_arbiter_endian_ch1(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct arbiter_endian_v1 endian = {0};
+
+	ret = copy_from_user((void *)&endian, param->property_param, sizeof(endian));
+	if (0 != ret) {
+		printk("isp_k_arbiter_endian_ch1: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((endian.bpc_endian & 0x3) << 8) | ((endian.lens_endian & 0x3) << 6) | ((endian.store_endian & 0x3) << 4)
+		| ((endian.fetch_bit_reorder & 0x1) << 2) | (endian.fetch_endian & 0x3);
+	REG_WR(ISP_ARBITER_ENDIAN_CH1, val);
+
+	return ret;
+}
+
+static int32_t isp_k_arbiter_param(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct arbiter_param_v1 para = {0};
+
+	ret = copy_from_user((void *)&para, param->property_param, sizeof(para));
+	if (0 != ret) {
+		printk("isp_k_arbiter_param: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (para.pause_cycle & 0xFF) | ((para.reset & 0x1) << 8);
+	REG_WR(ISP_ARBITER_PARAM, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_arbiter(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_arbiter: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_arbiter: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_ARBITER_BLOCK:
+		ret = isp_k_arbiter_block(param);
+		break;
+	case ISP_PRO_ARBITER_WR_STATUS:
+		ret = isp_k_arbiter_wr_status(param);
+		break;
+	case ISP_PRO_ARBITER_RD_STATUS:
+		ret = isp_k_arbiter_rd_status(param);
+		break;
+	case ISP_PRO_ARBITER_PARAM:
+		ret = isp_k_arbiter_param(param);
+		break;
+	case ISP_PRO_ARBITER_ENDIAN_CH0:
+		ret = isp_k_arbiter_endian_ch0(param);
+		break;
+	case ISP_PRO_ARBITER_ENDIAN_CH1:
+		ret = isp_k_arbiter_endian_ch1(param);
+		break;
+	default:
+		printk("isp_k_cfg_arbiter: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_awb.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_awb.c
new file mode 100644
index 00000000..0c33d355
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_awb.c
@@ -0,0 +1,192 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+static int32_t isp_k_awb_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	struct isp_dev_awb_info_v1 awb_info;
+
+	memset(&awb_info, 0x00, sizeof(awb_info));
+
+	ret = copy_from_user((void *)&awb_info, param->property_param, sizeof(awb_info));
+	if (0 != ret) {
+		printk("isp_k_awbm_bypass: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	//printk("isp_k_awb_block: %d  %d  %d  %d \n",awb_info.slice_size.width,awb_info.slice_size.height,awb_info.block_size.width,awb_info.block_size.height);
+	//printk("isp_k_awb_block: gain r=%d  gr=%d  b=%d \n",awb_info.gain.r,awb_info.gain.gr,awb_info.gain.b);
+	//printk("isp_k_awb_block: offset r=%d  gr=%d  b=%d  \n",awb_info.gain_offset.r,awb_info.gain_offset.gr,awb_info.gain_offset.b);
+	/*AWBM*/
+
+	REG_MWR(ISP_AWBM_PARAM, BIT_0, awb_info.awbm_bypass);
+
+	REG_MWR(ISP_AWBM_PARAM, BIT_1, awb_info.mode << 1);
+
+	val = (awb_info.skip_num & 0x0F) << 2;
+	REG_MWR(ISP_AWBM_PARAM, (BIT_5 | BIT_4 | BIT_3 | BIT_2), val);
+
+	val = ((awb_info.block_offset.y & 0xFFFF) << 16) | (awb_info.block_offset.x & 0xFFFF);
+	REG_WR(ISP_AWBM_BLOCK_OFFSET, val);
+
+	val = ((awb_info.block_size.height & 0x1FF) << 9) | (awb_info.block_size.width & 0x1FF);
+	REG_MWR(ISP_AWBM_BLOCK_SIZE, 0x1FFFF, val);
+
+	val = (awb_info.shift & 0x1F) << 18;
+	REG_MWR(ISP_AWBM_BLOCK_SIZE, (0x1F << 18), val);
+
+	REG_MWR(ISP_AWBM_PARAM, BIT_8, awb_info.thr_bypass << 8);
+
+	for (i = 0; i < 5; i++) {
+		val = ((awb_info.rect_pos.start_x[i] & 0x3FF) << 16) | (awb_info.rect_pos.start_y[i] & 0x3FF);
+		REG_WR(ISP_AWBM_WR_0_S + i * 8, val);
+		val = ((awb_info.rect_pos.end_x[i] & 0x3FF) << 16) | (awb_info.rect_pos.end_y[i] & 0x3FF);
+		REG_WR(ISP_AWBM_WR_0_E + i * 8, val);
+	}
+
+	for (i = 0; i < 5; i++) {
+		val = ((awb_info.circle_pos.x[i] & 0x3FF) << 18) | ((awb_info.circle_pos.y[i] & 0x3FF) << 8) | (awb_info.circle_pos.r[i] & 0xFF);
+		REG_WR(ISP_AWBM_NW_0_XYR + i * 4, val);
+	}
+
+	for (i = 0; i < 5; i++) {
+		val = ((awb_info.clctor_pos.start_x[i] & 0x3FF) << 16) | (awb_info.clctor_pos.start_y[i] & 0x3FF);
+		REG_WR(ISP_AWBM_CLCTOR_0_S + i * 8, val);
+		val = ((awb_info.clctor_pos.end_x[i] & 0x3FF) << 16) | (awb_info.clctor_pos.end_y[i] & 0x3FF);
+		REG_WR(ISP_AWBM_CLCTOR_0_E + i * 8, val);
+	}
+
+	val = ((awb_info.thr.g_low & 0x3FF) << 20) | ((awb_info.thr.r_high & 0x3FF) << 10) | (awb_info.thr.r_low & 0x3FF);
+	REG_WR(ISP_AWBM_THR_VALUE1, val);
+	val = ((awb_info.thr.b_high & 0x3FF) << 20) | ((awb_info.thr.b_low & 0x3FF) << 10) | (awb_info.thr.g_high & 0x3FF);
+	REG_WR(ISP_AWBM_THR_VALUE2, val);
+
+//	val = ((awb_info.slice_size.height & 0xFFFF) << 16) | (awb_info.slice_size.width & 0xFFFF);
+//	REG_WR(ISP_AEM_SLICE_SIZE, val);
+
+	REG_MWR(ISP_AWBM_PARAM, BIT_6, awb_info.skip_num_clear << 6);
+
+	REG_WR(ISP_AWBM_MEM_ADDR, awb_info.mem_addr);
+
+	/*AWBC*/
+
+	REG_MWR(ISP_AWBC_PARAM, BIT_0, awb_info.awbc_bypass);
+
+	REG_MWR(ISP_AWBC_PARAM, BIT_1, awb_info.alpha_bypass << 1);
+
+	val = (awb_info.alpha_value & 0x3FF) << 4;
+	REG_MWR(ISP_AWBC_PARAM, 0x3FF0, val);
+
+	REG_MWR(ISP_AWBC_PARAM, BIT_3, awb_info.buf_sel << 3);
+
+	val = ((awb_info.gain.b & 0x3FFF) << 16) | (awb_info.gain.r & 0x3FFF);
+	REG_WR(ISP_AWBC_GAIN0, val);
+	val = ((awb_info.gain.gb & 0x3FFF) << 16) | (awb_info.gain.gr & 0x3FFF);
+	REG_WR(ISP_AWBC_GAIN1, val);
+
+	val = ((awb_info.thrd.b & 0x3FF) << 20) | ((awb_info.thrd.g & 0x3FF) << 10) | (awb_info.thrd.r & 0x3FF);
+	REG_WR(ISP_AWBC_THRD, val);
+
+	val = ((awb_info.gain_offset.b & 0xFFFF) << 16) | (awb_info.gain_offset.r & 0xFFFF);
+	REG_WR(ISP_AWBC_OFFSET0, val);
+	val = ((awb_info.gain_offset.gb & 0xFFFF) << 16) | (awb_info.gain_offset.gr & 0xFFFF);
+	REG_WR(ISP_AWBC_OFFSET1, val);
+
+	val = ((awb_info.gain_buff.b & 0x3FFF) << 16) | (awb_info.gain_buff.r & 0x3FFF);
+	REG_WR(ISP_AWBC_GAIN0_BUF, val);
+	val = ((awb_info.gain_buff.gb & 0x3FFF) << 16) | (awb_info.gain_buff.gr & 0x3FFF);
+	REG_WR(ISP_AWBC_GAIN1_BUF, val);
+
+	val = ((awb_info.gain_offset_buff.b & 0xFFFF) << 16) | (awb_info.gain_offset_buff.r & 0xFFFF);
+	REG_WR(ISP_AWBC_OFFSET0_BUF, val);
+	val = ((awb_info.gain_offset_buff.gb & 0xFFFF) << 16) | (awb_info.gain_offset_buff.gr & 0xFFFF);
+	REG_WR(ISP_AWBC_OFFSET1_BUF, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_awb_statistics(struct isp_io_param *param,
+	struct isp_k_private *isp_private)
+{
+	int32_t ret = 0, i = 0;
+	unsigned long addr = 0;
+	struct isp_raw_awbm_statistics *awbm_statistics = NULL;
+
+	awbm_statistics = (struct isp_raw_awbm_statistics *)isp_private->raw_awbm_buf_addr;
+	if (!awbm_statistics) {
+		ret = -1;
+		printk("isp_k_raw_awb_statistics: alloc memory error.\n");
+		return -1;
+	}
+
+	addr = ISP_RAW_AWBM_OUTPUT;
+
+	for (i = 0x00; i < ISP_RAW_AWBM_ITEM; i++) {
+		(awbm_statistics + i)->num4 = REG_RD(addr) >> 16;
+		(awbm_statistics + i)->num_t = REG_RD(addr) & 0xffff;
+		(awbm_statistics + i)->num2 = REG_RD(addr + 4) >> 16;
+		(awbm_statistics + i)->num3 = REG_RD(addr + 4) & 0xffff;
+		(awbm_statistics + i)->num0 = REG_RD(addr + 8) >> 16;
+		(awbm_statistics + i)->num1 = REG_RD(addr + 8) & 0xffff;
+		(awbm_statistics + i)->block_b = REG_RD(addr + 12);
+		(awbm_statistics + i)->block_g = REG_RD(addr + 16);
+		(awbm_statistics + i)->block_r = REG_RD(addr + 20);
+		addr += 32;
+	}
+
+	ret = copy_to_user(param->property_param, (void*)awbm_statistics, sizeof(struct isp_raw_awbm_statistics) * ISP_RAW_AWBM_ITEM);
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_raw_awb_statistics: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_awb(struct isp_io_param *param,
+	struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_awb: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_awb: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_AWB_BLOCK:
+		ret = isp_k_awb_block(param);
+		break;
+	case ISP_PRO_AWBM_STATISTICS:
+		ret = isp_k_raw_awb_statistics(param, isp_private);
+		break;
+	default:
+		printk("isp_k_cfg_awb: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_bdn.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_bdn.c
new file mode 100644
index 00000000..9589b8c3
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_bdn.c
@@ -0,0 +1,121 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_bdn_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	uint32_t j = 0;
+	struct isp_dev_bdn_info_v1 bdn_info;
+
+	memset(&bdn_info, 0x00, sizeof(bdn_info));
+
+	ret = copy_from_user((void *)&bdn_info, param->property_param, sizeof(bdn_info));
+	if (0 != ret) {
+		printk("isp_k_bdn_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_BDN_PARAM, BIT_1, bdn_info.radial_bypass << 1);
+
+	REG_MWR(ISP_BDN_PARAM, 0x7F0, bdn_info.addback << 4);
+
+	for (i = 0; i < 10; i++) {
+		REG_WR(ISP_BDN_DISWEI0_0 + 40 * i, bdn_info.dis[i][0]);
+
+		REG_WR(ISP_BDN_DISWEI0_1 + 40 * i, bdn_info.dis[i][1]);
+	}
+
+	for (i = 0; i < 10; i++) {
+		for (j = 0; j < 7; j++) {
+			REG_WR(ISP_BDN_RANWEI0_0 + i * 40 + j * 4, bdn_info.ran[i][j]);
+		}
+
+		REG_WR(ISP_BDN_RANWEI0_7 + i * 40, bdn_info.ran[i][7]);
+	}
+
+	val = ((bdn_info.offset_x & 0x1FFF) << 12) | (bdn_info.offset_y & 0xFFF);
+	REG_WR(ISP_BDN_1DLNC_CENTER, val);
+
+	val = bdn_info.squ_x2 & 0x3FFFFFF;
+	REG_WR(ISP_BDN_1DLNC_SQUARE_X, val);
+	val = bdn_info.squ_y2 & 0xFFFFFF;
+	REG_WR(ISP_BDN_1DLNC_SQUARE_Y, val);
+
+	val = ((bdn_info.coef2 & 0xFFFF) << 11) | (bdn_info.coef & 0x7FF);
+	REG_WR(ISP_BDN_1DLNC_P, val);
+
+	val = ((bdn_info.start_pos_x & 0x1FFF) << 12) | (bdn_info.start_pos_y & 0xFFF);
+	REG_WR(ISP_BDN_1DLNC_POS, val);
+
+	REG_WR(ISP_BDN_1DLNC_OFFSET, bdn_info.offset & 0x3FFFFFF);
+
+	REG_MWR(ISP_BDN_PARAM, BIT_0, bdn_info.bypass);
+
+	return ret;
+
+}
+
+static int32_t isp_k_bdn_1d_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size = {0, 0};
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_bdn_1d_slice_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.width & 0x1FFF) << 12) | (size.height & 0xFFF);
+	REG_WR(ISP_BDN_1DLNC_SIZE, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_bdn(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_bdn: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_bdn: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_BDN_BLOCK:
+		ret = isp_k_bdn_block(param);
+		break;
+	case ISP_PRO_BDN_SLICE_SIZE:
+		ret = isp_k_bdn_1d_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_bdn: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_binning4awb.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_binning4awb.c
new file mode 100755
index 00000000..e64be9c4
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_binning4awb.c
@@ -0,0 +1,249 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include <asm/cacheflush.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+static int32_t isp_k_binging_param_update(struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	/*config buf_id 0 as default*/
+	isp_private->b4awb_buf[0].buf_flag = 1;
+	REG_WR(ISP_BINNING_MEM_ADDR, isp_private->b4awb_buf[0].buf_phys_addr);
+
+	return ret;
+}
+
+static int32_t isp_k_binning_block(struct isp_io_param *param,
+			struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_binning4awb_info_v1 binning_info;
+
+	ret = copy_from_user((void *)&binning_info, param->property_param, sizeof(binning_info));
+	if (0 != ret) {
+		printk("isp_k_binning_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (isp_private->b4awb_buf[0].buf_phys_addr == 0 || isp_private->b4awb_buf[1].buf_phys_addr == 0) {
+		REG_MWR(ISP_BINNING_PARAM, BIT_0, 0x1);
+		return ret;
+	}
+
+	isp_k_binging_param_update(isp_private);
+
+	val = (binning_info.burst_mode & 0x3) << 2;
+	REG_MWR(ISP_BINNING_PARAM, 0xC, val);
+
+	val = (binning_info.endian & 0x1) << 1;
+	REG_MWR(ISP_BINNING_PARAM, BIT_1, val);
+
+	val = (binning_info.mem_fifo_clr & 0x1) << 7;
+	REG_MWR(ISP_BINNING_PARAM, 0x80, val);
+
+	val = ((binning_info.hx & 0x7) << 4) | ((binning_info.vx & 0x7) << 8);
+	REG_MWR(ISP_BINNING_PARAM, 0x770, val);
+
+	REG_WR(ISP_BINNING_PITCH, binning_info.pitch);
+
+	REG_MWR(ISP_BINNING_PARAM, BIT_0, binning_info.bypass);
+
+	return ret;
+
+}
+
+static int32_t isp_k_binging_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_binning_scaling_ratio: copy_from_user error, ret = 0x%x\n",(uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_BINNING_PARAM, BIT_0, bypass);
+
+	return ret;
+}
+
+static int32_t isp_k_binging_endian(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t endian = 0;
+	ret = copy_from_user((void *)&endian, param->property_param, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_binning_scaling_ratio: copy_from_user error, ret = 0x%x\n",(uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_BINNING_PARAM, BIT_1, endian << 1);
+
+	return ret;
+}
+
+static int32_t isp_k_binning_scaling_ratio(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_scaling_ratio scaling_ratio;
+	ret = copy_from_user((void *)&scaling_ratio, param->property_param, sizeof(struct isp_scaling_ratio));
+	if (0 != ret) {
+		printk("isp_k_binning_scaling_ratio: copy_from_user error, ret = 0x%x\n",(uint32_t)ret);
+		return -1;
+	}
+
+	val = ((scaling_ratio.vertical & 0x7)<< 8)| ((scaling_ratio.horizontal & 0x7) << 4);
+	REG_MWR(ISP_BINNING_PARAM, 0x770, val);
+
+	return ret;
+}
+
+static int32_t isp_k_binning_get_scaling_ratio(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_scaling_ratio scaling_ratio;
+
+	val = REG_RD(ISP_BINNING_PARAM);
+
+	scaling_ratio.vertical= (val >> 8) & 0x7;
+	scaling_ratio.horizontal = (val >> 4) & 0x7;
+
+	ret = copy_to_user(param->property_param, (void *)&scaling_ratio, sizeof(struct isp_scaling_ratio));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_binning_get_scaling_ratio: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_binging_mem_addr(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t addr = 0;
+
+	ret = copy_from_user((void *)&addr, param->property_param, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_binning_scaling_ratio: copy_from_user error, ret = 0x%x\n",(uint32_t)ret);
+		return -1;
+	}
+
+	REG_WR(ISP_BINNING_MEM_ADDR, addr);
+
+	return ret;
+}
+
+static int32_t isp_k_binning_statistics_buf(struct isp_io_param *param,
+			struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t buf_id = 0;
+
+	if (isp_private->b4awb_buf[0].buf_flag == 0) {
+		buf_id = isp_private->b4awb_buf[0].buf_id;
+	} else if (isp_private->b4awb_buf[1].buf_flag == 0) {
+		buf_id = isp_private->b4awb_buf[1].buf_id;
+	}
+
+	ret = copy_to_user(param->property_param, (void*)&buf_id, sizeof(uint32_t));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_binning_statistics_buf: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_binning_buffaddr(struct isp_io_param *param,
+			struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	int32_t i = 0;
+	unsigned long phys_addr[2];
+	struct isp_b4awb_phys phy_addr;
+
+	ret = copy_from_user((void *)&phy_addr, param->property_param, sizeof(struct isp_b4awb_phys));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_binning_buffaddr: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	phys_addr[0] = phy_addr.phys0;
+	phys_addr[1] = phy_addr.phys1;
+
+	for (i = 0; i < ISP_BING4AWB_NUM; i++) {
+		isp_private->b4awb_buf[i].buf_id = i;
+		isp_private->b4awb_buf[i].buf_flag = 0;
+		isp_private->b4awb_buf[i].buf_phys_addr = phys_addr[i];
+	}
+
+	printk("phys_addr 0x%lx, 0x%lx\n",phys_addr[0], phys_addr[1]);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_binning(struct isp_io_param *param, struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_binning: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_binning: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_BINNING4AWB_BLOCK:
+		ret = isp_k_binning_block(param, isp_private);
+		break;
+	case ISP_PRO_BINNING4AWB_BYPASS:
+		ret = isp_k_binging_bypass(param);
+		break;
+	case ISP_PRO_BINNING4AWB_SCALING_RATIO:
+		ret = isp_k_binning_scaling_ratio(param);
+		break;
+	case ISP_PRO_BINNING4AWB_GET_SCALING_RATIO:
+		ret = isp_k_binning_get_scaling_ratio(param);
+		break;
+	case ISP_PRO_BINNING4AWB_MEM_ADDR:
+		ret = isp_k_binging_mem_addr(param);
+		break;
+	case ISP_PRO_BINNING4AWB_STATISTICS_BUF:
+		ret = isp_k_binning_statistics_buf(param, isp_private);
+		break;
+	case ISP_PRO_BINNING4AWB_TRANSADDR:
+		ret = isp_k_binning_buffaddr(param, isp_private);
+		break;
+	case ISP_PRO_BINNING4AWB_ENDIAN:
+		ret = isp_k_binging_endian(param);
+		break;
+	default:
+		printk("isp_k_cfg_binning: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_blc.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_blc.c
new file mode 100644
index 00000000..af18c2a7
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_blc.c
@@ -0,0 +1,66 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_blc_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_blc_info blc_info;
+
+	ret = copy_from_user((void *)&blc_info, param->property_param, sizeof(blc_info));
+	if (0 != ret) {
+		printk("isp_k_blc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((blc_info.b & 0x3FF) << 10) | (blc_info.r & 0x3FF);
+	REG_WR(ISP_BLC_B_PARAM_R_B, val);
+	val = ((blc_info.gb & 0x3FF) << 10) | (blc_info.gr & 0x3FF);
+	REG_WR(ISP_BLC_B_PARAM_G, val);
+
+	REG_MWR(ISP_BLC_PARAM, BIT_0, blc_info.bypass);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_blc(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_blc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_blc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_BLC_BLOCK:
+		ret = isp_k_blc_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_blc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_bpc.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_bpc.c
new file mode 100644
index 00000000..29248946
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_bpc.c
@@ -0,0 +1,101 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_bpc_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	struct isp_dev_bpc_info_v1 bpc_info;
+
+	memset(&bpc_info, 0x00, sizeof(bpc_info));
+
+	ret = copy_from_user((void *)&bpc_info, param->property_param, sizeof(bpc_info));
+	if (0 != ret) {
+		printk("isp_k_bpc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_BPC_PARAM, BIT_0, bpc_info.bypass);
+
+	REG_MWR(ISP_BPC_PARAM, BIT_1, bpc_info.pvd_bypass << 1);
+
+	REG_MWR(ISP_BPC_PARAM, BIT_4 | BIT_5, bpc_info.bpc_mode << 4);
+
+	REG_MWR(ISP_BPC_PARAM, BIT_10 | BIT_9 | BIT_8, bpc_info.mask_mode << 8);
+
+	val = ((bpc_info.kmax & 0x7) << 20) | ((bpc_info.kmin & 0x7) << 16);
+	REG_MWR(ISP_BPC_PARAM, 0x770000, val);
+
+	REG_MWR(ISP_BPC_NEW_OLD_SEL, BIT_0, bpc_info.new_old_sel);
+
+	REG_MWR(ISP_BPC_NEW_OLD_SEL, BIT_1, bpc_info.map_done_sel << 1);
+
+	val = ((bpc_info.safe_factor & 0x1F) << 4) | (bpc_info.flat_factor & 0x7);
+	REG_WR(ISP_BPC_FACTOR, val);
+
+	val = ((bpc_info.dead_coeff & 0x7) << 4) | (bpc_info.spike_coeff & 0x7);
+	REG_WR(ISP_BPC_COEFF, val);
+
+	for (i = 0; i < 8; i++) {
+		val = ((bpc_info.lut_level[i] & 0x3FF) << 20) | ((bpc_info.slope_k[i] & 0x3FF) << 10) | (bpc_info.intercept_b[i] & 0x3FF);
+		REG_WR(ISP_BPC_LUTWORD0 + i * 4, val);
+	}
+
+	REG_MWR(ISP_BPC_CFG, BIT_10 | BIT_9 | BIT_8, bpc_info.delta << 8);
+
+	REG_MWR(ISP_BPC_CFG, BIT_7, bpc_info.bpc_map_fifo_clr << 7);
+
+	REG_MWR(ISP_BPC_CFG, BIT_6 | BIT_5 | BIT_4, bpc_info.ktimes << 4);
+
+	REG_MWR(ISP_BPC_CFG, 0x7, bpc_info.cntr_threshold);
+
+	REG_MWR(ISP_BPC_CFG, BIT_3, bpc_info.bad_map_hw_fifo_clr_en << 3);
+
+	REG_WR(ISP_BPC_MAP_ADDR, bpc_info.bpc_map_addr_new);
+
+	REG_MWR(ISP_BPC_CFG, 0xFFFF0000, bpc_info.bad_pixel_num << 16);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_bpc(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_bpc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_bpc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_BPC_BLOCK:
+		ret = isp_k_bpc_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_bpc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_brightness.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_brightness.c
new file mode 100644
index 00000000..4c649621
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_brightness.c
@@ -0,0 +1,67 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_brightness_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_brightness_info brightness_info;
+
+	memset(&brightness_info, 0x00, sizeof(brightness_info));
+
+	ret = copy_from_user((void *)&brightness_info, param->property_param, sizeof(brightness_info));
+	if (0 != ret) {
+		printk("isp_k_brightness_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_BRIGHT_PARAM, 0x1FE, ((brightness_info.factor & 0xFF) << 1));
+
+	if (brightness_info.bypass) {
+		REG_OWR(ISP_BRIGHT_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_BRIGHT_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_brightness(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_brightness: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_brightness: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_BRIGHT_BLOCK:
+		ret = isp_k_brightness_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_brightness: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_capability.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_capability.c
new file mode 100644
index 00000000..7b9a7640
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_capability.c
@@ -0,0 +1,202 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+#if defined(CONFIG_ARCH_SCX35LT8)
+#define ISP_MAX_WIDTH             4416
+#define ISP_MAX_HEIGHT            3168
+#define ISP_MAX_SLICE_WIDTH       4416
+#define ISP_MAX_SLICE_HEIGHT      3168
+#else
+#define ISP_MAX_WIDTH             3280
+#define ISP_MAX_HEIGHT            2464
+#define ISP_MAX_SLICE_WIDTH       3280
+#define ISP_MAX_SLICE_HEIGHT      2464
+#endif
+#define ISP_AWB_WIN_UNIT          32
+#define ISP_AWB_DEFAULT_GAIN      0x400
+#define ISP_AF_MAX_WIN_NUM        9
+
+static int32_t isp_k_capability_chip_id(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	uint32_t chip_id = 0;
+
+	chip_id = ISP_CHIP_ID_TSHARK2;
+
+	ret = copy_to_user(param->property_param, (void*)&chip_id, sizeof(chip_id));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_capability_chip_id: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_single_size(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size = {0, 0};
+
+	size.width = ISP_MAX_WIDTH;
+	size.height = ISP_MAX_HEIGHT;
+
+	ret = copy_to_user(param->property_param, (void*)&size, sizeof(size));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_capability_single_size: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_continue_size(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size = {0, 0};
+
+	size.width = ISP_MAX_SLICE_WIDTH;
+	size.height = ISP_MAX_SLICE_HEIGHT;
+
+	ret = copy_to_user(param->property_param, (void*)&size, sizeof(size));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_capability_continue_size: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_awb_win(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size = {0, 0};
+
+	size.width = ISP_AWB_WIN_UNIT;
+	size.height = ISP_AWB_WIN_UNIT;
+
+	ret = copy_to_user(param->property_param, (void*)&size, sizeof(size));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_capability_awb_win: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_awb_default_gain(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	uint32_t gain = 0;
+
+	gain = ISP_AWB_DEFAULT_GAIN;
+
+	ret = copy_to_user(param->property_param, (void*)&gain, sizeof(gain));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_capability_awb_default_gain: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_af_max_win_num(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	uint32_t win_num = 0;
+
+	win_num = ISP_AF_MAX_WIN_NUM;
+
+	ret = copy_to_user(param->property_param, (void*)&win_num, sizeof(win_num));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_capability_af_max_win_num: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_capability_time(struct isp_capability *param)
+{
+	int32_t ret = 0;
+	struct isp_time time;
+	struct timespec ts;
+
+	ktime_get_ts(&ts);
+	time.sec = ts.tv_sec;
+	time.usec = ts.tv_nsec / NSEC_PER_USEC;
+
+	ret = copy_to_user(param->property_param, (void*)&time, sizeof(time));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_capability_time: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+int32_t isp_capability(void *param)
+{
+	int32_t ret = 0;
+	struct isp_capability cap_param = {0, 0, NULL};
+
+	if (!param) {
+		printk("isp_capability: param is null error.\n");
+		return -1;
+	}
+
+	ret = copy_from_user((void *)&cap_param, (void*)param, sizeof(cap_param));
+	if ( 0 != ret) {
+		printk("isp_capability: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (NULL == cap_param.property_param) {
+		printk("isp_capability: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(cap_param.index) {
+	case ISP_CAPABILITY_CHIP_ID:
+		ret = isp_k_capability_chip_id(&cap_param);
+		break;
+	case ISP_CAPABILITY_SINGLE_SIZE:
+		ret = isp_k_capability_single_size(&cap_param);
+		break;
+	case ISP_CAPABILITY_CONTINE_SIZE:
+		ret = isp_k_capability_continue_size(&cap_param);
+		break;
+	case ISP_CAPABILITY_AWB_WIN:
+		ret = isp_k_capability_awb_win(&cap_param);
+		break;
+	case ISP_CAPABILITY_AWB_DEFAULT_GAIN:
+		ret = isp_k_capability_awb_default_gain(&cap_param);
+		break;
+	case ISP_CAPABILITY_AF_MAX_WIN_NUM:
+		ret = isp_k_capability_af_max_win_num(&cap_param);
+		break;
+	case ISP_CAPABILITY_TIME:
+		ret = isp_k_capability_time(&cap_param);
+		break;
+	default:
+		printk("isp_capability: fail cmd id:%d, not supported.\n", cap_param.index);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cce.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cce.c
new file mode 100644
index 00000000..06a84ab9
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cce.c
@@ -0,0 +1,147 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_cce_block_uv(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_cce_uvd_info cce_uvd_info;
+
+	memset(&cce_uvd_info, 0x00, sizeof(cce_uvd_info));
+
+	ret = copy_from_user((void *)&cce_uvd_info, param->property_param, sizeof(cce_uvd_info));
+	if (0 != ret) {
+		printk("isp_k_cce_block_uv: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (cce_uvd_info.lum_th_h_len & 0xF)
+		| ((cce_uvd_info.lum_th_h & 0xFF) << 8)
+		| ((cce_uvd_info.lum_th_l_len & 0xF) << 16)
+		| ((cce_uvd_info.lum_th_l & 0xFF) << 24);
+	REG_WR(ISP_CCE_UVD_PARAM0, val);
+
+	val = (cce_uvd_info.chroma_min_h & 0xFF)
+		| ((cce_uvd_info.chroma_min_l & 0xFF) << 8)
+		| ((cce_uvd_info.chroma_max_h & 0xFF) << 16)
+		| ((cce_uvd_info.chroma_max_l & 0xFF) << 24);
+	REG_WR(ISP_CCE_UVD_PARAM1, val);
+
+	val = (cce_uvd_info.u_th1_h & 0xFF)
+		| ((cce_uvd_info.u_th1_l & 0xFF) << 8)
+		| ((cce_uvd_info.u_th0_h & 0xFF) << 16)
+		| ((cce_uvd_info.u_th0_l & 0xFF) << 24);
+	REG_WR(ISP_CCE_UVD_PARAM2, val);
+
+	val = (cce_uvd_info.v_th1_h & 0xFF)
+		| ((cce_uvd_info.v_th1_l & 0xFF) << 8)
+		| ((cce_uvd_info.v_th0_h & 0xFF) << 16)
+		| ((cce_uvd_info.v_th0_l & 0xFF) << 24);
+	REG_WR(ISP_CCE_UVD_PARAM3, val);
+
+	val = (cce_uvd_info.ratio[7] & 0xF)
+		| ((cce_uvd_info.ratio[6] & 0xF) << 4)
+		| ((cce_uvd_info.ratio[5] & 0xF) << 8)
+		| ((cce_uvd_info.ratio[4] & 0xF) << 12)
+		| ((cce_uvd_info.ratio[3] & 0xF) << 16)
+		| ((cce_uvd_info.ratio[2] & 0xF) << 20)
+		| ((cce_uvd_info.ratio[1] & 0xF) << 24)
+		| ((cce_uvd_info.ratio[0] & 0xF) << 28);
+	REG_WR(ISP_CCE_UVD_PARAM4, val);
+
+	val = (cce_uvd_info.base & 0xF)
+		| ((cce_uvd_info.ratio[8] & 0xF) << 8);
+	REG_WR(ISP_CCE_UVD_PARAM5, val);
+
+	REG_MWR(ISP_CCE_PARAM, BIT_0, cce_uvd_info.uvdiv_bypass);
+
+	return ret;
+}
+
+static int32_t isp_k_cce_block_matrix(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t val1 = 0;
+	struct isp_dev_cce_info_v1 cce_info;
+
+	memset(&cce_info, 0x00, sizeof(cce_info));
+
+	ret = copy_from_user((void *)&cce_info, param->property_param, sizeof(cce_info));
+	if (0 != ret) {
+		printk("isp_k_cce_block_matrix: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((cce_info.matrix[1] & 0x7FF) << 11) | (cce_info.matrix[0] & 0x7FF);
+	val1 = ((cce_info.matrix[3] & 0x7FF) << 11) | (cce_info.matrix[2] & 0x7FF);
+	if ((0 == val)
+		|| (0 == val1)) {
+		printk("isp_k_cce_block_matrix: copy error, 0x%x, 0x%x, 0x%x, 0x%x\n", cce_info.matrix[0], cce_info.matrix[1], cce_info.matrix[2], cce_info.matrix[3]);
+		return ret;
+	}
+
+	REG_MWR(ISP_CCE_PARAM, BIT_1, cce_info.mode << 1);
+
+	val = ((cce_info.matrix[1] & 0x7FF) << 11) | (cce_info.matrix[0] & 0x7FF);
+	REG_WR(ISP_CCE_MATRIX0, val);
+	val = ((cce_info.matrix[3] & 0x7FF) << 11) | (cce_info.matrix[2] & 0x7FF);
+	REG_WR(ISP_CCE_MATRIX1, val);
+	val = ((cce_info.matrix[5] & 0x7FF) << 11) | (cce_info.matrix[4] & 0x7FF);
+	REG_WR(ISP_CCE_MATRIX2, val);
+	val = ((cce_info.matrix[7] & 0x7FF) << 11) | (cce_info.matrix[6] & 0x7FF);
+	REG_WR(ISP_CCE_MATRIX3, val);
+	val = cce_info.matrix[8] & 0x7FF;
+	REG_WR(ISP_CCE_MATRIX4, val);
+
+	val = (cce_info.y_offset & 0x1FF) | ((cce_info.u_offset & 0x1FF) << 9)
+		| ((cce_info.v_offset & 0x1FF) << 18);
+	REG_WR(ISP_CCE_SHIFT, (val & 0x7FFFFFF));
+
+	return ret;
+}
+
+int32_t isp_k_cfg_cce(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_cce: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_cce: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CCE_BLOCK_MATRIX:
+		ret = isp_k_cce_block_matrix(param);
+		break;
+	case ISP_PRO_CCE_BLOCK_UV:
+		ret = isp_k_cce_block_uv(param);
+		break;
+	default:
+		printk("isp_k_cfg_cce: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cdn.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cdn.c
new file mode 100644
index 00000000..e8b8e716
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cdn.c
@@ -0,0 +1,109 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_yuv_cdn_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_yuv_cdn_info cdn_info;
+	uint32_t val = 0;
+	uint32_t i = 0;
+
+	memset(&cdn_info, 0x00, sizeof(cdn_info));
+
+	ret = copy_from_user((void *)&cdn_info, param->property_param, sizeof(cdn_info));
+	if (0 != ret) {
+		printk("isp_k_yuv_cdn_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (cdn_info.median_writeback_en) {
+		REG_OWR(ISP_CDN_PARAM, BIT_2);
+	} else {
+		REG_MWR(ISP_CDN_PARAM, BIT_2, 0);
+	}
+
+	REG_MWR(ISP_CDN_PARAM, 0x38, cdn_info.median_mode << 3);
+
+	REG_MWR(ISP_CDN_PARAM, BIT_7 | BIT_6, cdn_info.gaussian_mode << 6);
+
+	REG_MWR(ISP_CDN_PARAM, 0x3FFF00, cdn_info.median_thr << 8);
+
+	val = (cdn_info.median_thru0 & 0x7F) | ((cdn_info.median_thru1 & 0xFF) << 8)
+		| ((cdn_info.median_thrv0 & 0x7F) << 16) | ((cdn_info.median_thrv1 & 0xFF) << 24);
+	REG_WR(ISP_CDN_THRUV, val);
+
+	for (i = 0; i < 7; i++) {
+		val = (cdn_info.rangewu[i*4] & 0x3F) | ((cdn_info.rangewu[i*4+1] & 0x3F) << 8)
+			| ((cdn_info.rangewu[i*4+2] & 0x3F) << 16) | ((cdn_info.rangewu[i*4+3] & 0x3F) << 24);
+		REG_WR(ISP_CDN_U_RANWEI_0 + i * 4, val);
+	}
+
+	val = (cdn_info.rangewu[28] & 0x3F) | ((cdn_info.rangewu[29] & 0x3F) << 8)
+		| ((cdn_info.rangewu[30] & 0x3F) << 16);
+	REG_WR(ISP_CDN_U_RANWEI_7, val);
+
+	for (i = 0; i < 7; i++) {
+		val = (cdn_info.rangewv[i*4] & 0x3F) | ((cdn_info.rangewv[i*4+1] & 0x3F) << 8)
+			| ((cdn_info.rangewv[i*4+2] & 0x3F) << 16) | ((cdn_info.rangewv[i*4+3] & 0x3F) << 24);
+		REG_WR(ISP_CDN_V_RANWEI_0 + i * 4, val);
+	}
+
+	val = (cdn_info.rangewv[28] & 0x3F) | ((cdn_info.rangewv[29] & 0x3F) << 8)
+		| ((cdn_info.rangewv[30] & 0x3F) << 16);
+	REG_WR(ISP_CDN_V_RANWEI_7, val);
+
+	if (cdn_info.filter_bypass) {
+		REG_OWR(ISP_CDN_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_CDN_PARAM, BIT_1, 0);
+	}
+
+	if (cdn_info.bypass) {
+		REG_OWR(ISP_CDN_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_CDN_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_yuv_cdn(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_yuv_cdn: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_yuv_cdn: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_YUV_CDN_BLOCK:
+		ret = isp_k_yuv_cdn_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_yuv_cdn: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cfa.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cfa.c
new file mode 100644
index 00000000..ceeed46a
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cfa.c
@@ -0,0 +1,90 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_cfa_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_cfa_info_v1 cfa_info;
+
+	memset(&cfa_info, 0x00, sizeof(cfa_info));
+
+	ret = copy_from_user((void *)&cfa_info, param->property_param, sizeof(cfa_info));
+	if (0 != ret) {
+		printk("isp_k_cfa_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_CFAE_EE_CFG0, BIT_0, cfa_info.bypass);
+
+	REG_MWR(ISP_CFAE_EE_CFG0, 0xF<<28, cfa_info.grid_gain << 28);
+
+	REG_MWR(ISP_CFAE_EE_CFG0, 0x3<<24, cfa_info.avg_mode << 24);
+
+	REG_MWR(ISP_CFAE_EE_CFG0, 0xFFF<<12, cfa_info.gbuf_addr_max << 12);
+
+	REG_MWR(ISP_CFAE_EE_CFG0, BIT_1, cfa_info.ee_bypass << 1);
+
+	REG_MWR(ISP_CFAE_EE_CFG0, 0x3F<<4, cfa_info.doee_base << 4);
+
+	REG_MWR(ISP_CFAE_EE_CFG1, 0xF<<16, cfa_info.inter_chl_gain << 16);
+
+	val = (cfa_info.cfa_uni_dir_intplt_tr & 0xFFFF) | ((cfa_info.cfai_ee_uni_dir_tr & 0xFFFF) << 16);
+	REG_WR(ISP_CFAE_THRD_0,val);
+	val = (cfa_info.cfai_ee_edge_tr & 0xFFF) | ((cfa_info.cfai_ee_diagonal_tr & 0xFFF) << 16);
+	REG_WR(ISP_CFAE_THRD_1,val);
+	val =(cfa_info.cfai_ee_grid_tr & 0xFFF) | ((cfa_info.cfai_doee_clip_tr & 0x3F) << 12)
+		| ((cfa_info.cfai_ee_saturation_level & 0x3FF) << 22);
+	REG_WR(ISP_CFAE_THRD_2,val);
+	val = (cfa_info.plt_diff_tr & 0xFFFF) | ((cfa_info.grid_min_tr & 0xFFFF) << 16);
+	REG_WR(ISP_CFAE_THRD_3,val);
+	val = (cfa_info.strength_tr_neg & 0xFFFF) | ((cfa_info.strength_tr_pos & 0xFFFF) << 16);
+	REG_WR(ISP_CFAE_THRD_4,val);
+	REG_MWR(ISP_CFAE_EE_CFG1, 0x3F, cfa_info.ee_strength_neg);
+	REG_MWR(ISP_CFAE_EE_CFG1, 0x3F << 8, cfa_info.ee_strength_pos << 8);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_cfa(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_cfa: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_cfa: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CFA_BLOCK:
+		ret = isp_k_cfa_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_cfa: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cmc10.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cmc10.c
new file mode 100644
index 00000000..8c127c9a
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cmc10.c
@@ -0,0 +1,93 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_cmc10_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_cmc10_info cmc10_info;
+
+	memset(&cmc10_info, 0x00, sizeof(cmc10_info));
+
+	ret = copy_from_user((void *)&cmc10_info, param->property_param, sizeof(cmc10_info));
+	if (0 != ret) {
+		printk("isp_k_cmc10_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_CMC10_PARAM, BIT_0, cmc10_info.bypass);
+
+	REG_MWR(ISP_CMC10_PARAM, BIT_3, cmc10_info.buf_sel << 3);
+
+	REG_MWR(ISP_CMC10_PARAM, 0x3FF << 4, cmc10_info.alpha << 4);
+
+	REG_MWR(ISP_CMC10_PARAM, BIT_1, cmc10_info.alpha_bypass << 1);
+
+	val = ((cmc10_info.matrix.val[1] & 0x3FFF) << 14) | (cmc10_info.matrix.val[0] & 0x3FFF);
+	REG_WR(ISP_CMC10_MATRIX0, val);
+	val = ((cmc10_info.matrix.val[3] & 0x3FFF) << 14) | (cmc10_info.matrix.val[2] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0 + 4), val);
+	val = ((cmc10_info.matrix.val[5] & 0x3FFF) << 14) | (cmc10_info.matrix.val[4] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0 + 8), val);
+	val = ((cmc10_info.matrix.val[7] & 0x3FFF) << 14) | (cmc10_info.matrix.val[6] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0 + 12), val);
+	val = cmc10_info.matrix.val[8] & 0x3FFF;
+	REG_WR((ISP_CMC10_MATRIX0 + 16), val);
+
+	val = ((cmc10_info.matrix_buf.val[1] & 0x3FFF) << 14) | (cmc10_info.matrix_buf.val[0] & 0x3FFF);
+	REG_WR(ISP_CMC10_MATRIX0_BUF, val);
+	val = ((cmc10_info.matrix_buf.val[3] & 0x3FFF) << 14) | (cmc10_info.matrix_buf.val[2] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0_BUF + 4), val);
+	val = ((cmc10_info.matrix_buf.val[5] & 0x3FFF) << 14) | (cmc10_info.matrix_buf.val[4] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0_BUF + 8), val);
+	val = ((cmc10_info.matrix_buf.val[7] & 0x3FFF) << 14) | (cmc10_info.matrix_buf.val[6] & 0x3FFF);
+	REG_WR((ISP_CMC10_MATRIX0_BUF + 12), val);
+	val = cmc10_info.matrix_buf.val[8] & 0x3FFF;
+	REG_WR((ISP_CMC10_MATRIX0_BUF + 16), val);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_cmc10(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_cmc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_cmc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CMC_BLOCK:
+		ret = isp_k_cmc10_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_cmc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cmc8.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cmc8.c
new file mode 100644
index 00000000..35121772
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_cmc8.c
@@ -0,0 +1,92 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_cmc8_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_cmc8_info_v1 cmc8_info;
+
+	memset(&cmc8_info, 0x00, sizeof(cmc8_info));
+
+	ret = copy_from_user((void *)&cmc8_info, param->property_param, sizeof(cmc8_info));
+	if (0 != ret) {
+		printk("isp_k_cmc8_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_CMC8_PARAM, BIT_0, cmc8_info.bypass);
+
+	REG_MWR(ISP_CMC8_PARAM, BIT_3, cmc8_info.buf_sel << 3);
+
+	REG_MWR(ISP_CMC8_PARAM, 0x3FF << 4, cmc8_info.alpha << 4);
+
+	REG_MWR(ISP_CMC8_PARAM, BIT_1, cmc8_info.alpha_bypass << 1);
+
+	val = ((cmc8_info.matrix.val[1] & 0x3FFF) << 14) | (cmc8_info.matrix.val[0] & 0x3FFF);
+	REG_WR(ISP_CMC8_MATRIX0, val);
+	val = ((cmc8_info.matrix.val[3] & 0x3FFF) << 14) | (cmc8_info.matrix.val[2] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0 + 4), val);
+	val = ((cmc8_info.matrix.val[5] & 0x3FFF) << 14) | (cmc8_info.matrix.val[4] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0 + 8), val);
+	val = ((cmc8_info.matrix.val[7] & 0x3FFF) << 14) | (cmc8_info.matrix.val[6] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0 + 12), val);
+	val = cmc8_info.matrix.val[8] & 0x3FFF;
+	REG_WR((ISP_CMC8_MATRIX0 + 16), val);
+
+	val = ((cmc8_info.matrix_buf.val[1] & 0x3FFF) << 14) | (cmc8_info.matrix_buf.val[0] & 0x3FFF);
+	REG_WR(ISP_CMC8_MATRIX0_BUF, val);
+	val = ((cmc8_info.matrix_buf.val[3] & 0x3FFF) << 14) | (cmc8_info.matrix_buf.val[2] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0_BUF + 4), val);
+	val = ((cmc8_info.matrix_buf.val[5] & 0x3FFF) << 14) | (cmc8_info.matrix_buf.val[4] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0_BUF + 8), val);
+	val = ((cmc8_info.matrix_buf.val[7] & 0x3FFF) << 14) | (cmc8_info.matrix_buf.val[6] & 0x3FFF);
+	REG_WR((ISP_CMC8_MATRIX0_BUF + 12), val);
+	val = cmc8_info.matrix_buf.val[8] & 0x3FFF;
+	REG_WR((ISP_CMC8_MATRIX0_BUF + 16), val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_cmc8(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_cmc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_cmc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CMC8_BLOCK:
+		ret = isp_k_cmc8_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_cmc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_common.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_common.c
new file mode 100644
index 00000000..677838d4
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_common.c
@@ -0,0 +1,533 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_common_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_common_info_v1 common_info;
+
+	memset(&common_info, 0x00, sizeof(common_info));
+
+	ret = copy_from_user((void *)&common_info, param->property_param, sizeof(common_info));
+	if (0 != ret) {
+		printk("isp_k_common_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3, common_info.fetch_sel_0);
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 4, common_info.sizer_sel_0  << 4);
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 16, common_info.store_sel_0  << 16);
+	REG_MWR(ISP_COMMON_CTRL_CH1, 3, common_info.fetch_sel_1);
+	REG_MWR(ISP_COMMON_CTRL_CH1, 3 << 4, common_info.sizer_sel_1  << 4);
+	REG_MWR(ISP_COMMON_CTRL_CH1, 3 << 16, common_info.store_sel_1  << 16);
+	REG_MWR(ISP_COMMON_SPACE_SEL, 3 , common_info.fetch_color_format) ;
+	REG_MWR(ISP_COMMON_SPACE_SEL, 3  << 2, common_info.store_color_format << 2) ;
+	REG_MWR(ISP_COMMON_CTRL_AWBM, BIT_0 , common_info.awbm_pos) ;
+	REG_MWR(ISP_COMMON_3A_CTRL0, 3, common_info.y_afm_pos_0);
+	REG_MWR(ISP_COMMON_3A_CTRL0, 3 << 4, common_info.y_aem_pos_0  << 4);
+	REG_MWR(ISP_COMMON_3A_CTRL1, 3, common_info.y_afm_pos_1);
+	REG_MWR(ISP_COMMON_3A_CTRL1, 3 << 4, common_info.y_aem_pos_1  << 4);
+	REG_WR(ISP_COMMON_LBUF_OFFSET0, ((common_info.lbuf_off.cfae_lbuf_offset & 0xFFFF) << 16 ) | (common_info.lbuf_off.comm_lbuf_offset & 0xFFFF));
+	REG_WR(ISP_COMMON_LBUF_OFFSET1, ((common_info.lbuf_off.ydly_lbuf_offset& 0xFFFF) << 16 ) | (common_info.lbuf_off.awbm_lbuf_offset & 0xFFFF));
+
+	return ret;
+}
+
+static int32_t isp_k_common_version(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t version = 0;
+
+	version = REG_RD(ISP_COMMON_VERSION);
+
+	ret = copy_to_user(param->property_param, (void*)&version, sizeof(version));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_common_version: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_common_status0(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t status = 0;
+
+	status = REG_RD(ISP_COMMON_STATUS0);
+
+	ret = copy_to_user(param->property_param, (void*)&status, sizeof(status));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_common_status0: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_common_status1(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t status = 0;
+
+	status = REG_RD(ISP_COMMON_STATUS1);
+
+	ret = copy_to_user(param->property_param, (void*)&status, sizeof(status));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_common_status1: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel0_fetch_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t fetch_sel = 0;
+
+	ret = copy_from_user((void *)&fetch_sel, param->property_param, sizeof(fetch_sel));
+	if (0 != ret) {
+		printk("isp_k_channel0_fetch_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3, fetch_sel);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel0_sizer_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t sizer_sel = 0;
+
+	ret = copy_from_user((void *)&sizer_sel, param->property_param, sizeof(sizer_sel));
+	if (0 != ret) {
+		printk("isp_k_channel0_sizer_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 4, sizer_sel  << 4);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel0_store_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t store_sel = 0;
+
+	ret = copy_from_user((void *)&store_sel, param->property_param, sizeof(store_sel));
+	if (0 != ret) {
+		printk("isp_k_common_channel0_store_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_CH0, 3 << 16, store_sel  << 16);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel1_fetch_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t fetch_sel = 0;
+
+	ret = copy_from_user((void *)&fetch_sel, param->property_param, sizeof(fetch_sel));
+	if (0 != ret) {
+		printk("isp_k_channel1_fetch_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_CH1, 3, fetch_sel);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel1_sizer_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t sizer_sel = 0;
+
+	ret = copy_from_user((void *)&sizer_sel, param->property_param, sizeof(sizer_sel));
+	if (0 != ret) {
+		printk("isp_k_common_channel1_sizer_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_CH1, 3 << 4, sizer_sel  << 4);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel1_store_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t store_sel = 0;
+
+	ret = copy_from_user((void *)&store_sel, param->property_param, sizeof(store_sel));
+	if (0 != ret) {
+		printk("isp_k_common_channel1_store_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_CH1, 3 << 16, store_sel  << 16);
+
+	return ret;
+}
+
+static int32_t isp_k_common_fetch_color_space_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t color_space = 0;
+
+	ret = copy_from_user((void *)&color_space, param->property_param, sizeof(color_space));
+	if (0 != ret) {
+		printk("isp_k_common_fetch_color_space_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_SPACE_SEL, 3 , color_space) ;
+
+	return ret;
+}
+
+static int32_t isp_k_common_store_color_space_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t color_space = 0;
+
+	ret = copy_from_user((void *)&color_space, param->property_param, sizeof(color_space));
+	if (0 != ret) {
+		printk("isp_k_common_store_color_space_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_SPACE_SEL, 3  << 2, color_space << 2) ;
+
+	return ret;
+}
+
+static int32_t isp_k_common_awbm_pos_sel(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t awbm_pos = 0;
+
+	ret = copy_from_user((void *)&awbm_pos, param->property_param, sizeof(awbm_pos));
+	if (0 != ret) {
+		printk("isp_k_common_awbm_pos_sel: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_CTRL_AWBM, BIT_0 , awbm_pos) ;
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel0_y_afm_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t position = 0;
+
+	ret = copy_from_user((void *)&position, param->property_param, sizeof(position));
+	if (0 != ret) {
+		printk("isp_k_common_channel0_y_afm_pos: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_3A_CTRL0, 3, position);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel0_y_aem_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t position = 0;
+
+	ret = copy_from_user((void *)&position, param->property_param, sizeof(position));
+	if (0 != ret) {
+		printk("isp_k_common_channel0_y_aem_pos: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_3A_CTRL0, 3 << 4, position  << 4);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel1_y_afm_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t position = 0;
+
+	ret = copy_from_user((void *)&position, param->property_param, sizeof(position));
+	if (0 != ret) {
+		printk("isp_k_common_channel1_y_afm_pos: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_3A_CTRL1, 3, position);
+
+	return ret;
+}
+
+static int32_t isp_k_common_channel1_y_aem_pos(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t position = 0;
+
+	ret = copy_from_user((void *)&position, param->property_param, sizeof(position));
+	if (0 != ret) {
+		printk("isp_k_common_channel1_y_aem_pos: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_3A_CTRL1, 3 << 4, position  << 4);
+
+	return ret;
+}
+
+static int32_t isp_k_common_lbuf_offset(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_common_lbuf_param_v1 lbuf_off;
+
+	memset(&lbuf_off, 0x00, sizeof(lbuf_off));
+	ret = copy_from_user((void *)&lbuf_off, param->property_param, sizeof(lbuf_off));
+	if (0 != ret) {
+		printk("isp_k_common_lbuf_offset: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_WR(ISP_COMMON_LBUF_OFFSET0, ((lbuf_off.cfae_lbuf_offset & 0xFFFF) << 16 ) | (lbuf_off.comm_lbuf_offset & 0xFFFF));
+	REG_WR(ISP_COMMON_LBUF_OFFSET1, ((lbuf_off.ydly_lbuf_offset& 0xFFFF) << 16 ) | (lbuf_off.awbm_lbuf_offset & 0xFFFF));
+
+	return ret;
+}
+
+static int32_t isp_k_all_shadow_ctrl(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t auto_shadow = 0;
+
+	ret = copy_from_user((void *)&auto_shadow, param->property_param, sizeof(auto_shadow));
+	if (0 != ret) {
+		printk("isp_k_all_shadow_ctrl: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_SHADOW_CTRL_CH0, 1 << 16, auto_shadow  << 16);
+
+	return ret;
+}
+
+static int32_t isp_k_awbm_shadow_ctrl(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t shadow_done = 0;
+
+	ret = copy_from_user((void *)&shadow_done, param->property_param, sizeof(shadow_done));
+	if (0 != ret) {
+		printk("isp_k_awbm_shadow_ctrl: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_SHADOW_CTRL_CH0, 1 << 17, shadow_done  << 17);
+
+	return ret;
+}
+
+static int32_t isp_k_ae_shadow_ctrl(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t shadow_done = 0;
+
+	ret = copy_from_user((void *)&shadow_done, param->property_param, sizeof(shadow_done));
+	if (0 != ret) {
+		printk("isp_k_ae_shadow_ctrl: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_SHADOW_CTRL_CH0, 1 << 18, shadow_done  << 18);
+
+	return ret;
+}
+
+static int32_t isp_k_af_shadow_ctrl(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t shadow_done = 0;
+
+	ret = copy_from_user((void *)&shadow_done, param->property_param, sizeof(shadow_done));
+	if (0 != ret) {
+		printk("isp_k_af_shadow_ctrl: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_SHADOW_CTRL_CH0, 1 << 19, shadow_done  << 19);
+
+	return ret;
+}
+
+static int32_t isp_k_afl_shadow_ctrl(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t shadow_done = 0;
+
+	ret = copy_from_user((void *)&shadow_done, param->property_param, sizeof(shadow_done));
+	if (0 != ret) {
+		printk("isp_k_afl_shadow_ctrl: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_SHADOW_CTRL_CH0, 1 << 20, shadow_done  << 20);
+
+	return ret;
+}
+
+static int32_t isp_k_comm_shadow_ctrl(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t shadow_done = 0;
+
+	ret = copy_from_user((void *)&shadow_done, param->property_param, sizeof(shadow_done));
+	if (0 != ret) {
+		printk("isp_k_comm_shadow_ctrl: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_SHADOW_CTRL_CH0, 1 << 21, shadow_done  << 21);
+
+	return ret;
+}
+
+static int32_t isp_k_3a_shadow_ctrl(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t enable = 0;
+
+	ret = copy_from_user((void *)&enable, param->property_param, sizeof(enable));
+	if (0 != ret) {
+		printk("isp_k_3a_shadow_ctrl: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_COMMON_RESERVED0, 1 << 2, enable  << 2);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_common(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_common: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_common: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_COMMON_BLOCK:
+		ret = isp_k_common_block(param);
+		break;
+	case ISP_PRO_COMMON_VERSION:
+		ret = isp_k_common_version(param);
+		break;
+	case ISP_PRO_COMMON_STATUS0:
+		ret = isp_k_common_status0(param);
+		break;
+	case ISP_PRO_COMMON_STATUS1:
+		ret = isp_k_common_status1(param);
+		break;
+	case ISP_PRO_COMMON_CH0_FETCH_SEL:
+		ret = isp_k_common_channel0_fetch_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH0_SIZER_SEL:
+		ret = isp_k_common_channel0_sizer_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH0_STORE_SEL:
+		ret = isp_k_common_channel0_store_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH1_FETCH_SEL:
+		ret = isp_k_common_channel1_fetch_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH1_SIZER_SEL:
+		ret = isp_k_common_channel1_sizer_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH1_STORE_SEL:
+		ret = isp_k_common_channel1_store_sel(param);
+		break;
+	case ISP_PRO_COMMON_FETCH_COLOR_SPACE_SEL:
+		ret = isp_k_common_fetch_color_space_sel(param);
+		break;
+	case ISP_PRO_COMMON_STORE_COLOR_SPACE_SEL:
+		ret = isp_k_common_store_color_space_sel(param);
+		break;
+	case ISP_PRO_COMMON_AWBM_POS_SEL:
+		ret = isp_k_common_awbm_pos_sel(param);
+		break;
+	case ISP_PRO_COMMON_CH0_AEM2_POS:
+		ret = isp_k_common_channel0_y_aem_pos(param);
+		break;
+	case ISP_PRO_COMMON_CH0_Y_AFM_POS:
+		ret = isp_k_common_channel0_y_afm_pos(param);
+		break;
+	case ISP_PRO_COMMON_CH1_AEM2_POS:
+		ret = isp_k_common_channel1_y_aem_pos(param);
+		break;
+	case ISP_PRO_COMMON_CH1_Y_AFM_POS:
+		ret = isp_k_common_channel1_y_afm_pos(param);
+		break;
+	case ISP_PRO_COMMON_LBUF_OFFSET:
+		ret = isp_k_common_lbuf_offset(param);
+		break;
+	case ISP_PRO_COMMON_SHADOW_ALL_CTRL:
+		ret = isp_k_all_shadow_ctrl(param);
+		break;
+	case ISP_PRO_COMMON_AWBM_SHADOW:
+		ret = isp_k_awbm_shadow_ctrl(param);
+		break;
+	case ISP_PRO_COMMON_AE_SHADOW:
+		ret = isp_k_ae_shadow_ctrl(param);
+		break;
+	case ISP_PRO_COMMON_AF_SHADOW:
+		ret = isp_k_af_shadow_ctrl(param);
+		break;
+	case ISP_PRO_COMMON_AFL_SHADOW:
+		ret = isp_k_afl_shadow_ctrl(param);
+		break;
+	case ISP_PRO_COMMON_COMM_SHADOW:
+		ret = isp_k_comm_shadow_ctrl(param);
+		break;
+	case ISP_PRO_COMMON_3A_SINGLE_FRAME_CTRL:
+		ret = isp_k_3a_shadow_ctrl(param);
+		break;
+	default:
+		printk("isp_k_cfg_common: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_contrast.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_contrast.c
new file mode 100644
index 00000000..36f7750d
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_contrast.c
@@ -0,0 +1,67 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_contrast_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_contrast_info contrast_info;
+
+	memset(&contrast_info, 0x00, sizeof(contrast_info));
+
+	ret = copy_from_user((void *)&contrast_info, param->property_param, sizeof(contrast_info));
+	if (0 != ret) {
+		printk("isp_k_contrast_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_CONTRAST_PARAM, 0x1FE, (contrast_info.factor << 1));
+
+	if (contrast_info.bypass) {
+		REG_OWR(ISP_CONTRAST_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_CONTRAST_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_contrast(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_contrast: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_contrast: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CONTRAST_BLOCK:
+		ret = isp_k_contrast_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_contrast: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_csa.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_csa.c
new file mode 100644
index 00000000..1aa7ef49
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_csa.c
@@ -0,0 +1,68 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_csa_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_csa_info_v1 csa_info;
+	uint32_t val = 0;
+
+	memset(&csa_info, 0x00, sizeof(csa_info));
+
+	ret = copy_from_user((void *)&csa_info, param->property_param, sizeof(csa_info));
+	if (0 != ret) {
+		printk("isp_k_csa_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((csa_info.factor_v & 0xFF) << 8) | ((csa_info.factor_u & 0xFF) << 16);
+	REG_MWR(ISP_CSA_PARAM, 0xFFFF00, val);
+
+	if (csa_info.bypass) {
+		REG_OWR(ISP_CSA_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_CSA_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_csa(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_csa: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_csa: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CSA_BLOCK:
+		ret = isp_k_csa_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_csa: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_csc.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_csc.c
new file mode 100644
index 00000000..7612b698
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_csc.c
@@ -0,0 +1,114 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_csc_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_csc_info csc_info;
+
+	memset(&csc_info, 0x00, sizeof(csc_info));
+
+	ret = copy_from_user((void *)&csc_info, param->property_param, sizeof(csc_info));
+	if (0 != ret) {
+		printk("isp_k_csc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_CSC_CTRL, BIT_0, csc_info.bypass);
+
+	val = (csc_info.red_centre_x & 0x1FFF) | ((csc_info.red_centre_y & 0xFFF) << 16);
+	REG_WR(ISP_CSC_RCC, val);
+
+	val = (csc_info.blue_centre_x & 0x1FFF) | ((csc_info.blue_centre_y & 0xFFF) << 16);
+	REG_WR(ISP_CSC_BCC, val);
+
+	REG_WR(ISP_CSC_REDTHR, csc_info.red_threshold & 0x3FFFFFF);
+
+	REG_WR(ISP_CSC_BLUETHR, (csc_info.blue_threshold & 0x3FFFFFF));
+
+	val = (csc_info.red_p1_param & 0x1FFF) | ((csc_info.red_p2_param & 0x7FF) << 16);
+	REG_WR(ISP_CSC_REDPOLY, val);
+
+	val = (csc_info.blue_p1_param & 0x1FFF) | ((csc_info.blue_p2_param & 0x7FF) << 16);
+	REG_WR(ISP_CSC_BLUEPOLY, val);
+
+	REG_WR(ISP_CSC_MAXGAIN, (csc_info.max_gain_thr & 0x1FFF));
+
+	val = (csc_info.start_pos.x & 0xFFF) | ((csc_info.start_pos.y & 0x1FFF) << 12);
+	REG_WR(ISP_CSC_START_ROW_COL, val );
+
+	val = csc_info.red_x2_init;
+	REG_WR( ISP_CSC_REDX2INIT, (val & 0x3FFFFFF));
+	val = csc_info.red_y2_init;
+	REG_WR( ISP_CSC_REDY2INIT, (val & 0x3FFFFFF));
+
+	val = csc_info.blue_x2_init;
+	REG_WR( ISP_CSC_BLUEX2INIT, (val & 0x3FFFFFF));
+	val = csc_info.blue_y2_init;
+	REG_WR( ISP_CSC_BLUEY2INIT, (val & 0x3FFFFFF));
+
+	return ret;
+
+}
+
+static int32_t isp_k_csc_pic_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size pic_size = {0, 0};
+
+	ret = copy_from_user((void *)&pic_size, param->property_param, sizeof(pic_size));
+	if (0 != ret) {
+		printk("isp_k_csc_pic_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	val = (pic_size.width& 0x1FFF) | ((pic_size.height& 0xFFF) << 16);
+	REG_WR(ISP_CSC_PICSIZE, val );
+
+	return ret;
+}
+
+int32_t isp_k_cfg_csc(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_csc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_csc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CSC_BLOCK:
+		ret = isp_k_csc_block(param);
+		break;
+	case ISP_PRO_CSC_PIC_SIZE:
+		ret = isp_k_csc_pic_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_csc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_css.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_css.c
new file mode 100644
index 00000000..2147bd53
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_css.c
@@ -0,0 +1,112 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_css_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_css_info_v1 css_info;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&css_info, param->property_param, sizeof(css_info));
+	if (0 != ret) {
+		printk("isp_k_css_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (css_info.lh_chrom_th & 0x1F) << 24;
+	REG_MWR(ISP_CSS_PARAM, 0x1F000000, val);
+
+	val = ((css_info.chrom_lower_th[0] & 0x1F) << 16) | ((css_info.chrom_lower_th[1] & 0x1F) << 8)
+		| (css_info.chrom_lower_th[2] & 0x1F);
+	REG_MWR(ISP_CSS_CHROM_L_TH_0, 0x1F1F1F, val);
+
+	val = ((css_info.chrom_lower_th[3] & 0x1F) << 24) | ((css_info.chrom_lower_th[4] & 0x1F) << 16)
+		| ((css_info.chrom_lower_th[5] & 0x1F) << 8) | (css_info.chrom_lower_th[6] & 0x1F);
+	REG_WR(ISP_CSS_CHROM_L_TH_1, val);
+
+	val = ((css_info.chrom_high_th[0] & 0x1F) << 16) | ((css_info.chrom_high_th[1] & 0x1F) << 8)
+		| (css_info.chrom_high_th[2] & 0x1F);
+	REG_WR(ISP_CSS_CHROM_H_TH_0, val);
+
+	val = ((css_info.chrom_high_th[3] & 0x1F) << 24) | ((css_info.chrom_high_th[4] & 0x1F) << 16)
+		| ((css_info.chrom_high_th[5] & 0x1F) << 8) | (css_info.chrom_high_th[6] & 0x1F);
+	REG_WR(ISP_CSS_CHROM_H_TH_1, val);
+
+	val = ((css_info.lum_low_shift & 0x7) << 16) | ((css_info.lum_hig_shift & 0x7) << 8);
+	REG_MWR(ISP_CSS_PARAM, 0x70700, val);
+
+	val = (css_info.lh_ratio[7] & 0xF) | ((css_info.lh_ratio[6] & 0xF) << 4)
+		| ((css_info.lh_ratio[5] & 0xF) <<  8) | ((css_info.lh_ratio[4] & 0xF) << 12)
+		| ((css_info.lh_ratio[3] & 0xF) << 16) | ((css_info.lh_ratio[2] & 0xF) << 20)
+		| ((css_info.lh_ratio[1] & 0xF) << 24) | ((css_info.lh_ratio[0] & 0xF) << 28);
+	REG_WR(ISP_CSS_LH_RATIO, val);
+
+	val = (css_info.ratio[7] & 0xF) | ((css_info.ratio[6] & 0xF) << 4)
+		| ((css_info.ratio[5] & 0xF) <<  8) | ((css_info.ratio[4] & 0xF) << 12)
+		| ((css_info.ratio[3] & 0xF) << 16) | ((css_info.ratio[2] & 0xF) << 20)
+		| ((css_info.ratio[1] & 0xF) << 24) | ((css_info.ratio[0] & 0xF) << 28);
+	REG_WR(ISP_CSS_RATIO, val);
+
+	val = (css_info.lum_hh_th & 0xFF) | ((css_info.lum_hig_th & 0xFF) << 8)
+		| ((css_info.lum_ll_th & 0xFF) << 16) | ((css_info.lum_low_th & 0xFF) << 24);
+	REG_WR(ISP_CSS_THRD0, val);
+
+	val = (css_info.v_th_0_h & 0xFF) | ((css_info.v_th_0_l & 0xFF) << 8)
+		| ((css_info.u_th_0_h & 0xFF) << 16) | ((css_info.u_th_0_l & 0xFF) << 24);
+	REG_WR(ISP_CSS_EX_TH_0, val);
+
+	val = (css_info.v_th_1_h & 0xFF) | ((css_info.v_th_1_l & 0xFF) << 8)
+		| ((css_info.u_th_1_h & 0xFF) << 16) | ((css_info.u_th_1_l & 0xFF) << 24);
+	REG_WR(ISP_CSS_EX_TH_1, val);
+
+	REG_MWR(ISP_CSS_CHROM_L_TH_0, 0x1F000000, css_info.cutoff_th << 24);
+
+	if (css_info.bypass) {
+		REG_OWR(ISP_CSS_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_CSS_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_css(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_css: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_css: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CSS_BLOCK:
+		ret = isp_k_css_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_css: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_ct.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_ct.c
new file mode 100644
index 00000000..2d723636
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_ct.c
@@ -0,0 +1,98 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+#define ISP_3D_LUT_BUF0                0
+#define ISP_3D_LUT_BUF1                1
+
+static int32_t isp_k_ct_block(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t buf_size = 0;
+	unsigned long dst_buf = 0;
+	struct isp_dev_ct_info ct_info;
+	void *data_ptr = NULL;
+
+	buf_size = ISP_3D_LUT_ITEM * 4;
+	memset(&ct_info, 0x00, sizeof(ct_info));
+
+	ret = copy_from_user((void *)&ct_info, param->property_param, sizeof(ct_info));
+	if (0 != ret) {
+		printk("isp_k_ct_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+#ifdef CONFIG_64BIT
+	data_ptr = (void*)(((unsigned long)ct_info.data_ptr[1] << 32) | ct_info.data_ptr[0]);
+#else
+	data_ptr = (void*)(ct_info.data_ptr[0]);
+#endif
+
+	if (NULL == data_ptr || ct_info.size > buf_size) {
+		printk("isp_k_ct_block: memory error: %p %x.\n",
+			data_ptr, ct_info.size);
+	}
+
+	if (ISP_3D_LUT_BUF0 == isp_private->ct_load_buf_id) {
+		dst_buf = ISP_3D_LUT1_OUTPUT;
+		isp_private->ct_load_buf_id = ISP_3D_LUT_BUF1;
+	} else {
+		dst_buf = ISP_3D_LUT0_OUTPUT;
+		isp_private->ct_load_buf_id = ISP_3D_LUT_BUF0;
+	}
+
+	ret = copy_from_user((void *)dst_buf, data_ptr, ct_info.size);
+	if (0 != ret) {
+		printk("isp_k_ct_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_CT_PARAM, BIT_1, (isp_private->ct_load_buf_id << 1));
+
+	REG_MWR(ISP_CT_PARAM, BIT_0, ct_info.bypass);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_ct(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_ct: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_ct: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_CT_BLOCK:
+		ret = isp_k_ct_block(param, isp_private);
+		break;
+	default:
+		printk("isp_k_cfg_ct: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_dispatch.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_dispatch.c
new file mode 100644
index 00000000..6bc5dde5
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_dispatch.c
@@ -0,0 +1,143 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_dispatch_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_dispatch_info_v1 dispatch_info;
+
+	memset(&dispatch_info, 0x00, sizeof(dispatch_info));
+
+	ret = copy_from_user((void *)&dispatch_info, param->property_param, sizeof(dispatch_info));
+	if (0 != ret) {
+		printk("isp_k_dispatch_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_WR(ISP_DISPATCH_CH0_BAYER, dispatch_info.bayer_ch0 & 0x3);
+	REG_WR(ISP_DISPATCH_CH1_BAYER, dispatch_info.bayer_ch1 & 0x3);
+
+	return ret;
+}
+
+static int32_t isp_k_dispatch_ch0_bayer(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&val, param->property_param, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_dispatch_ch0_bayer: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_WR(ISP_DISPATCH_CH0_BAYER, val & 0x3);
+
+	return ret;
+}
+
+static int32_t isp_k_dispatch_ch1_bayer(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&val, param->property_param, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_dispatch_ch1_bayer: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_WR(ISP_DISPATCH_CH1_BAYER, val & 0x3);
+
+	return ret;
+}
+
+static int32_t isp_k_dispatch_ch0_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_dispatch_ch0_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0xFFFF) << 16) | (size.width & 0xFFFF);
+	REG_WR(ISP_DISPATCH_CH0_SIZE, val);
+
+	return ret;
+}
+
+static int32_t isp_k_dispatch_ch1_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_dispatch_ch1_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0xFFFF) << 16) | (size.width & 0xFFFF);
+	REG_WR(ISP_DISPATCH_CH1_SIZE, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_dispatch(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_dispatch: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_dispatch: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_DISPATCH_BLOCK:
+		ret = isp_k_dispatch_block(param);
+		break;
+	case ISP_PRO_DISPATCH_CH0_BAYER:
+		ret = isp_k_dispatch_ch0_bayer(param);
+		break;
+	case ISP_PRO_DISPATCH_CH1_BAYER:
+		ret = isp_k_dispatch_ch1_bayer(param);
+		break;
+	case ISP_PRO_DISPATCH_CH0_SIZE:
+		ret = isp_k_dispatch_ch0_size(param);
+		break;
+	case ISP_PRO_DISPATCH_CH1_SIZE:
+		ret = isp_k_dispatch_ch1_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_dispatch: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_edge.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_edge.c
new file mode 100644
index 00000000..3d19be00
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_edge.c
@@ -0,0 +1,126 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_edge_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_edge_info_v1 edge_info;
+	uint32_t val = 0;
+
+	memset(&edge_info, 0x00, sizeof(edge_info));
+
+	ret = copy_from_user((void *)&edge_info, param->property_param, sizeof(edge_info));
+	if (0 != ret) {
+		printk("isp_k_edge_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_EE_CFG0, BIT_29 | BIT_28, edge_info.mode << 28);
+
+	val = (edge_info.ee_str_m_n & 0x7F) | ((edge_info.ee_str_m_p & 0x7F) << 7)
+		| ((edge_info.ee_str_d_n & 0x7F) << 14) | ((edge_info.ee_str_d_p & 0x7F) << 21);
+	REG_MWR(ISP_EE_CFG0, 0xFFFFFFF, val);
+
+	val = ((edge_info.ee_incr_d_p & 0xFF) << 8) | (edge_info.ee_incr_d_n & 0xFF);
+	REG_MWR(ISP_EE_CFG1, 0xFFFF, val);
+
+	val = ((edge_info.ee_thr_d_n & 0xFF) << 16) | ((edge_info.ee_thr_d_p & 0xFF) << 24);
+	REG_MWR(ISP_EE_CFG1, 0xFFFF0000, val);
+
+	val = (edge_info.ee_flat_thr_1 & 0xFF) | ((edge_info.ee_flat_thr_2 & 0xFF) << 8);
+	REG_MWR(ISP_EE_CFG2, 0xFFFF, val);
+
+	val = ((edge_info.ee_incr_m_n & 0xFF) << 16) | ((edge_info.ee_incr_m_p & 0xFF) << 24);
+	REG_MWR(ISP_EE_CFG2, 0xFFFF0000, val);
+
+	val = (edge_info.ee_txt_thr_1 & 0xFF) | ((edge_info.ee_txt_thr_2 & 0xFF) << 8)
+		| ((edge_info.ee_txt_thr_3 & 0xFF) << 16);
+	REG_WR(ISP_EE_CFG3, val);
+
+	val = ((edge_info.ee_corner_cor & 0x1) << 28) | ((edge_info.ee_corner_th_p & 0x1F) << 23)
+		| ((edge_info.ee_corner_th_n & 0x1F) << 18) | ((edge_info.ee_corner_gain_p & 0x7F) << 11)
+		| ((edge_info.ee_corner_gain_n & 0x7F) << 4) | ((edge_info.ee_corner_sm_p & 0x3) << 2)
+		| (edge_info.ee_corner_sm_n & 0x3);
+	REG_WR(ISP_EE_CFG4, val);
+
+	val = ((edge_info.ee_edge_smooth_mode & 0x3) << 26) | ((edge_info.ee_flat_smooth_mode & 0x3) << 24)
+		| ((edge_info.ee_smooth_thr & 0xFF) << 8) | (edge_info.ee_smooth_strength & 0xFF);
+	REG_MWR(ISP_EE_CFG5, 0xF00FFFF, val);
+
+	val = (edge_info.sigma & 0xFF) << 16;
+	REG_MWR(ISP_EE_CFG5, 0xFF0000, val);
+
+	val = ((edge_info.ee_str_b_p & 0xFF) << 24) | ((edge_info.ee_str_b_n & 0xFF) << 16)
+		| ((edge_info.ee_incr_b_p & 0xFF) << 8) | (edge_info.ee_incr_b_n & 0xFF);
+	REG_WR(ISP_EE_CFG6, val);
+
+	val = ((edge_info.ratio[1] & 0xFF) << 8) | (edge_info.ratio[0] & 0xFF);
+	REG_MWR(ISP_EE_CFG7, 0xFFFF, val);
+
+	val = (edge_info.ee_clip_after_smooth_en & 0x1) << 25;
+	REG_MWR(ISP_EE_CFG7, BIT_25, val);
+
+	val = ((edge_info.ipd_bypass & 0x1) << 24) | ((edge_info.ipd_flat_thr & 0xFF) << 16);
+	REG_MWR(ISP_EE_CFG7, 0x1FF0000, val);
+
+	val = (edge_info.ee_t1_cfg & 0x3FF) | ((edge_info.ee_t2_cfg & 0x3FF) << 10)
+		| ((edge_info.ee_t3_cfg & 0x3FF) << 20);
+	REG_WR(ISP_EE_ADP_CFG0, val);
+
+	val = (edge_info.ee_t4_cfg & 0x3FF) | ((edge_info.ee_cv_clip_n & 0xFF) << 16)
+		| ((edge_info.ee_cv_clip_p & 0xFF) << 24);
+	REG_WR(ISP_EE_ADP_CFG1, val);
+
+	val = (edge_info.ee_r1_cfg & 0xFF) | ((edge_info.ee_r2_cfg & 0xFF) << 8)
+		| ((edge_info.ee_r3_cfg & 0xFF) << 16);
+	REG_WR(ISP_EE_ADP_CFG2, val);
+
+
+	if (edge_info.bypass) {
+		REG_OWR(ISP_EE_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_EE_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_edge(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_edge: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_edge: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_EDGE_BLOCK:
+		ret = isp_k_edge_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_edge: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_emboss.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_emboss.c
new file mode 100644
index 00000000..27319afc
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_emboss.c
@@ -0,0 +1,74 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_emboss_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_emboss_info_v1 emboss_info;
+
+	memset(&emboss_info, 0x00, sizeof(emboss_info));
+
+	ret = copy_from_user((void *)&emboss_info, param->property_param, sizeof(emboss_info));
+	if (0 != ret) {
+		printk("isp_k_emboss_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_EMBOSS_Y_PARAM, 0x7E, (emboss_info.y_step & 0x3F) << 1);
+
+	if (emboss_info.y_bypass) {
+		REG_OWR(ISP_EMBOSS_Y_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_EMBOSS_Y_PARAM, BIT_0, 0);
+	}
+
+	REG_MWR(ISP_EMBOSS_UV_PARAM, 0x7E, (emboss_info.uv_step & 0x3F) << 1);
+
+	if (emboss_info.uv_bypass) {
+		REG_OWR(ISP_EMBOSS_UV_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_EMBOSS_UV_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_emboss(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_emboss: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_emboss: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_EMBOSS_BLOCK:
+		ret = isp_k_emboss_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_emboss: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_fetch.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_fetch.c
new file mode 100644
index 00000000..721afc21
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_fetch.c
@@ -0,0 +1,126 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_fetch_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_fetch_info_v1 fetch_info;
+
+	memset(&fetch_info, 0x00, sizeof(fetch_info));
+
+	ret = copy_from_user((void *)&fetch_info, param->property_param, sizeof(fetch_info));
+	if (0 != ret) {
+		printk("isp_k_fetch_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (fetch_info.substract) {
+		REG_OWR(ISP_FETCH_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_FETCH_PARAM, BIT_1, 0);
+	}
+
+	REG_MWR(ISP_FETCH_PARAM, 0xF0, (fetch_info.color_format << 4));
+
+	REG_WR(ISP_FETCH_SLICE_Y_ADDR, fetch_info.addr.chn0);
+	REG_WR(ISP_FETCH_SLICE_Y_PITCH, fetch_info.pitch.chn0);
+	REG_WR(ISP_FETCH_SLICE_U_ADDR, fetch_info.addr.chn1);
+	REG_WR(ISP_FETCH_SLICE_U_PITCH, fetch_info.pitch.chn1);
+	REG_WR(ISP_FETCH_SLICE_V_ADDR, fetch_info.addr.chn2);
+	REG_WR(ISP_FETCH_SLICE_V_PITCH, fetch_info.pitch.chn2);
+	REG_WR(ISP_FETCH_MIPI_WORD_INFO, (fetch_info.mipi_word_num & 0xFFFF));
+	REG_WR(ISP_FETCH_MIPI_BYTE_INFO, (fetch_info.mipi_byte_rel_pos & 0x0F));
+
+	if (fetch_info.bypass) {
+		REG_OWR(ISP_FETCH_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_FETCH_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_fetch_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t size = 0;
+	struct isp_img_size slice_size = {0, 0};
+
+	ret = copy_from_user((void *)&slice_size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_fetch_slice_size: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	size = ((slice_size.height & 0xFFFF) << 16) | (slice_size.width & 0xFFFF);
+
+	REG_WR(ISP_FETCH_SLICE_SIZE, size);
+
+	return ret;
+}
+
+static int32_t isp_k_fetch_start_isp(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t fetch_start = 0;
+
+	ret = copy_from_user((void *)&fetch_start, param->property_param, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_fetch_start_isp: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (fetch_start) {
+		REG_OWR(ISP_FETCH_START, BIT_0);
+	} else {
+		REG_MWR(ISP_FETCH_START, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_fetch(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_fetch: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_fetch: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_FETCH_BLOCK:
+		ret = isp_k_fetch_block(param);
+		break;
+	case ISP_PRO_FETCH_SLICE_SIZE:
+		ret = isp_k_fetch_slice_size(param);
+		break;
+	case ISP_PRO_FETCH_START_ISP:
+		ret = isp_k_fetch_start_isp(param);
+		break;
+	default:
+		printk("isp_k_cfg_fetch: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_gamma.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_gamma.c
new file mode 100644
index 00000000..5ba65f66
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_gamma.c
@@ -0,0 +1,131 @@
+/*
+ * 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/uaccess.h>
+#include <linux/vmalloc.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+#define ISP_FRGB_GAMC_BUF0                0
+#define ISP_FRGB_GAMC_BUF1                1
+
+static int32_t isp_k_pingpang_frgb_gamc(struct coordinate_xy *nodes,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t i, j;
+	uint32_t val = 0;
+	unsigned long r_buf_addr;
+	unsigned long g_buf_addr;
+	unsigned long b_buf_addr;
+	struct coordinate_xy *p_nodes = NULL;
+
+	if (!nodes) {
+		ret = -1;
+		printk("isp_k_pingpang_frgb_gamc: node is null error .\n");
+		return ret;
+	}
+
+	p_nodes = nodes;
+
+	if (ISP_FRGB_GAMC_BUF0 == isp_private->full_gamma_buf_id) {
+		r_buf_addr = ISP_FGAMMA_R_BUF1_CH0;
+		g_buf_addr = ISP_FGAMMA_G_BUF1_CH0;
+		b_buf_addr = ISP_FGAMMA_B_BUF1_CH0;
+		isp_private->full_gamma_buf_id = ISP_FRGB_GAMC_BUF1;
+	} else {
+		r_buf_addr = ISP_FGAMMA_R_BUF0_CH0;
+		g_buf_addr = ISP_FGAMMA_G_BUF0_CH0;
+		b_buf_addr = ISP_FGAMMA_B_BUF0_CH0;
+		isp_private->full_gamma_buf_id = ISP_FRGB_GAMC_BUF0;
+	}
+
+	for(i = 0,j = 0;i < ISP_PINGPANG_FRGB_GAMC_NUM;i++,j+=4) {
+		REG_WR(r_buf_addr + j, p_nodes[i].node_y & 0xff);
+		REG_WR(g_buf_addr + j, p_nodes[i].node_y & 0xff);
+		REG_WR(b_buf_addr + j, p_nodes[i].node_y & 0xff);
+	}
+
+	val = ((isp_private->full_gamma_buf_id & 0x1 ) << 1) | ((isp_private->full_gamma_buf_id & 0x1) << 2) | ((isp_private->full_gamma_buf_id & 0x1 ) << 3);
+	REG_MWR(ISP_GAMMA_PARAM, 0x0000000E, val);
+
+	return ret;
+}
+
+static int32_t isp_k_gamma_block(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t bypass;
+	struct isp_dev_gamma_info_v1 *param_p= (struct isp_dev_gamma_info_v1 *)param->property_param;
+	struct coordinate_xy *nodes = NULL;
+
+	nodes = (struct coordinate_xy *)isp_private->full_gamma_buf_addr;
+	if (!nodes) {
+		ret = -1;
+		printk("isp_k_gamma_block: alloc memory error.\n");
+		return -1;
+	}
+
+	ret = copy_from_user((void *)&bypass, (void *)&param_p->bypass, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_gamma_block: copy bypass error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	ret = copy_from_user((void *)nodes, (void *)param_p->nodes, ISP_FRGB_GAMMA_BUF_SIZE);
+	if (0 != ret) {
+		printk("isp_k_gamma_block: copy nodes error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	ret = isp_k_pingpang_frgb_gamc(nodes, isp_private);
+	if (0 != ret) {
+		printk("isp_k_gamma_block: pingpang error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_GAMMA_PARAM, BIT_0, bypass);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_gamma(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_gamma: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_gamma: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_GAMMA_BLOCK:
+		ret = isp_k_gamma_block(param, isp_private);
+		break;
+	default:
+		printk("isp_k_cfg_gamma: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_grgb.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_grgb.c
new file mode 100644
index 00000000..6bf40d2a
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_grgb.c
@@ -0,0 +1,70 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_grgb_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_grgb_info_v1 grgb_info;
+
+	memset(&grgb_info, 0x00, sizeof(grgb_info));
+
+	ret = copy_from_user((void *)&grgb_info, param->property_param, sizeof(grgb_info));
+	if (0 != ret) {
+		printk("isp_k_grgb_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_GRGB_PARAM, BIT_0, grgb_info.bypass);
+
+	val = ((grgb_info.diff & 0x3FF) << 7) | ((grgb_info.edge & 0x3F) << 1);
+	REG_MWR(ISP_GRGB_PARAM, 0x1FFFE, val);
+	val = grgb_info.grid & 0xFFF;
+	REG_MWR(ISP_GRGB_GRID, 0xFFF, val);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_grgb(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_grgb: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_grgb: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_GRGB_BLOCK:
+		ret = isp_k_grgb_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_grgb: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hist.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hist.c
new file mode 100644
index 00000000..dabdd420
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hist.c
@@ -0,0 +1,131 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_hist_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_hist_info_v1 hist_info;
+	uint32_t val = 0;
+
+	memset(&hist_info, 0x00, sizeof(hist_info));
+
+	ret = copy_from_user((void *)&hist_info, param->property_param, sizeof(hist_info));
+	if (0 != ret) {
+		printk("isp_k_hist_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (hist_info.buf_rst_en) {
+		REG_OWR(ISP_HIST_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_1, 0);
+	}
+
+	if (hist_info.pof_rst_en) {
+		REG_OWR(ISP_HIST_PARAM, BIT_9);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_9, 0);
+	}
+
+	if (hist_info.skip_num_clr) {
+		REG_OWR(ISP_HIST_PARAM, BIT_8);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_8, 0);
+	}
+
+	REG_MWR(ISP_HIST_PARAM, 0xF0, hist_info.skip_num << 4);
+
+	if (hist_info.mode) {
+		REG_OWR(ISP_HIST_PARAM, BIT_3);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_3, 0);
+	}
+
+	val = ((hist_info.high_ratio & 0xFFFF) << 16)
+			| (hist_info.low_ratio & 0xFFFF);
+
+	REG_WR(ISP_HIST_RATIO, val);
+
+	val = (hist_info.dif_adj & 0xFF) | ((hist_info.small_adj & 0xFF) << 8)
+		| ((hist_info.big_adj & 0xFF) << 16);
+
+	REG_WR(ISP_HIST_ADJUST, val);
+
+	if (hist_info.off) {
+		REG_OWR(ISP_HIST_PARAM, BIT_2);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_2, 0);
+	}
+
+	if (hist_info.bypass) {
+		REG_OWR(ISP_HIST_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_HIST_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_hist_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_hist_slice_size: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0xFFFF) << 16)
+			| (size.width & 0xFFFF);
+
+	REG_WR(ISP_HIST_SLICE_SIZE, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_hist(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_hist: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_hist: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_HIST_BLOCK:
+		ret = isp_k_hist_block(param);
+		break;
+	case ISP_PRO_HIST_SLICE_SIZE:
+		ret = isp_k_hist_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_hist: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hist2.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hist2.c
new file mode 100644
index 00000000..2ee88107
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hist2.c
@@ -0,0 +1,94 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_hist2_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_hist2_info_v1 hist2_info;
+	uint32_t val = 0;
+	uint32_t i = 0;
+
+	memset(&hist2_info, 0x00, sizeof(hist2_info));
+
+	ret = copy_from_user((void *)&hist2_info, param->property_param, sizeof(hist2_info));
+	if (0 != ret) {
+		printk("isp_k_hist2_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (hist2_info.skip_num_clr) {
+		REG_OWR(ISP_HIST2_PARAM, BIT_8);
+	} else {
+		REG_MWR(ISP_HIST2_PARAM, BIT_8, 0);
+	}
+
+	REG_MWR(ISP_HIST2_PARAM, 0xF0, hist2_info.skip_num << 4);
+
+	if (hist2_info.mode) {
+		REG_OWR(ISP_HIST2_PARAM, BIT_3);
+	} else {
+		REG_MWR(ISP_HIST2_PARAM, BIT_3, 0);
+	}
+
+	for (i = 0; i < 4; i++) {
+		val = (hist2_info.hist_roi_y_s[i] & 0xFFFF) | ((hist2_info.hist_roi_x_s[i] & 0xFFFF) << 16);
+		REG_WR(ISP_HIST2_ROI_S0 + i * 8, val);
+
+		val = (hist2_info.hist_roi_y_e[i] & 0xFFFF) | ((hist2_info.hist_roi_x_e[i] & 0xFFFF) << 16);
+		REG_WR(ISP_HIST2_ROI_E0 + i * 8, val);
+	}
+
+	if (hist2_info.en) {
+		REG_OWR(ISP_HIST2_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_HIST2_PARAM, BIT_1, 0);
+	}
+
+	if (hist2_info.bypass) {
+		REG_OWR(ISP_HIST2_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_HIST2_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_hist2(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_hist2: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_hist2: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_HIST2_BLOCK:
+		ret = isp_k_hist2_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_hist2: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hsv.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hsv.c
new file mode 100644
index 00000000..5083242b
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hsv.c
@@ -0,0 +1,95 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_hsv_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int32_t buf_size = 0;
+	unsigned long dst_addr = 0;
+	struct isp_dev_hsv_info_v1 hsv_info;
+	void *data_ptr = NULL;
+
+	memset(&hsv_info, 0x00, sizeof(hsv_info));
+
+	ret = copy_from_user((void *)&hsv_info, param->property_param, sizeof(hsv_info));
+	if (0 != ret) {
+		printk("isp_k_hsv_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+#ifdef CONFIG_64BIT
+	data_ptr = (void*)(((unsigned long)hsv_info.data_ptr[1] << 32) | hsv_info.data_ptr[0]);
+#else
+	data_ptr = (void*)(hsv_info.data_ptr[0]);
+#endif
+
+	buf_size = ISP_HSV_ITEM * 4;
+	if (NULL == data_ptr || hsv_info.size > buf_size) {
+		printk("isp_k_hsv_block : memory error %p %x \n",
+			data_ptr, hsv_info.size);
+		return -1;
+	}
+
+	if (hsv_info.buf_sel << 1 & BIT_1) {
+		dst_addr = ISP_HSV_BUF1_OUTPUT;
+	} else {
+		dst_addr = ISP_HSV_BUF0_OUTPUT;
+	}
+
+	ret = copy_from_user((void *)dst_addr, data_ptr, hsv_info.size);
+	if (0 != ret) {
+		printk("isp_k_hsv_block: copy error 0x%x \n",(uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_HSV_PARAM, BIT_1, hsv_info.buf_sel << 1);
+
+	REG_MWR(ISP_HSV_PARAM, BIT_0, hsv_info.bypass);
+
+	return ret;
+
+}
+
+
+int32_t isp_k_cfg_hsv(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_hsv: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_hsv: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_HSV_BLOCK:
+		ret = isp_k_hsv_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_hsv: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hua.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hua.c
new file mode 100644
index 00000000..f4570330
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_hua.c
@@ -0,0 +1,68 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_hue_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_hue_info_v1 hua_info;
+
+	memset(&hua_info, 0x00, sizeof(hua_info));
+
+	ret = copy_from_user((void *)&hua_info, param->property_param, sizeof(hua_info));
+	if (0 != ret) {
+		printk("isp_k_hue_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_HUA_PARAM, 0x1FF0, hua_info.theta << 4);
+
+	if (hua_info.bypass) {
+		REG_OWR(ISP_HUA_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_HUA_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+
+int32_t isp_k_cfg_hue(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_hue: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_hue: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_HUE_BLOCK:
+		ret = isp_k_hue_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_hue: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_iircnr.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_iircnr.c
new file mode 100644
index 00000000..6c6e0591
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_iircnr.c
@@ -0,0 +1,133 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_iircnr_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_iircnr_info_v1 iircnr_info;
+	uint32_t val = 0;
+
+	memset(&iircnr_info, 0x00, sizeof(iircnr_info));
+
+	ret = copy_from_user((void *)&iircnr_info, param->property_param, sizeof(iircnr_info));
+	if (0 != ret) {
+		printk("isp_k_iircnr_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (iircnr_info.mode) {
+		REG_OWR(ISP_IIRCNR_PARAM1, BIT_0);
+	} else {
+		REG_MWR(ISP_IIRCNR_PARAM1, BIT_0, 0);
+	}
+
+	val = ((iircnr_info.y_th & 0xFF) << 12) | ((iircnr_info.uv_th & 0x7FF) << 1);
+	REG_MWR(ISP_IIRCNR_PARAM1, 0xFFFFE, val);
+
+	val = ((iircnr_info.uv_pg_th & 0x3FFF) << 10) | (iircnr_info.uv_dist & 0x3FF);
+	REG_WR(ISP_IIRCNR_PARAM2, val);
+
+	val = ((iircnr_info.uv_low_thr2 & 0x1FFFF) << 14) | (iircnr_info.uv_low_thr1 & 0x3FFF);
+	REG_WR(ISP_IIRCNR_PARAM3, val);
+
+	val = iircnr_info.uv_s_th & 0xFF;
+	REG_MWR(ISP_IIRCNR_PARAM6, 0xFF, val);
+
+	val = (iircnr_info.alpha_low_v & 0x3FFF) | ((iircnr_info.alpha_low_u & 0x3FFF) << 14);
+	REG_WR(ISP_IIRCNR_PARAM7, val);
+
+	val = iircnr_info.uv_high_thr2 & 0x1FFFF;
+	REG_WR(ISP_IIRCNR_PARAM9, val);
+
+	val = iircnr_info.ymd_u & 0x3FFFFFFF;
+	REG_WR(ISP_IIRCNR_PARAM4, val);
+
+	val = iircnr_info.ymd_v & 0x3FFFFFFF;
+	REG_WR(ISP_IIRCNR_PARAM5, val);
+
+	REG_MWR(ISP_IIRCNR_PARAM6, 0xFF00, iircnr_info.slope << 8);
+	REG_WR(ISP_IIRCNR_PARAM8, iircnr_info.factor & 0x1FFFFFF);
+
+
+	if (iircnr_info.bypass) {
+		REG_OWR(ISP_IIRCNR_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_IIRCNR_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_yrandom_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_yrandom_info_v1 yrandom_info;
+	uint32_t val = 0;
+
+	memset(&yrandom_info, 0x00, sizeof(yrandom_info));
+
+	ret = copy_from_user((void *)&yrandom_info, param->property_param, sizeof(yrandom_info));
+	if (0 != ret) {
+		printk("isp_k_yrandom_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_YRANDOM_PARAM0, 0xFFFFFF00, yrandom_info.seed << 8);
+	REG_MWR(ISP_YRANDOM_PARAM0, BIT_2, yrandom_info.mode << 2);
+	REG_MWR(ISP_YRANDOM_PARAM0, BIT_0, yrandom_info.init);
+	REG_MWR(ISP_YRANDOM_PARAM1, 0x7FF0000, yrandom_info.offset << 16);
+	REG_MWR(ISP_YRANDOM_PARAM1, 0xF, yrandom_info.shift);
+
+	val = (yrandom_info.takeBit[0] & 0xF) | ((yrandom_info.takeBit[1] & 0xF) << 4)
+		| ((yrandom_info.takeBit[2] & 0xF) << 8) | ((yrandom_info.takeBit[3] & 0xF) << 12)
+		| ((yrandom_info.takeBit[4] & 0xF) << 16) | ((yrandom_info.takeBit[5] & 0xF) << 20)
+		| ((yrandom_info.takeBit[6] & 0xF) << 24) | ((yrandom_info.takeBit[7] & 0xF) << 28);
+	REG_WR(ISP_YRANDOM_PARAM2, val);
+
+	REG_MWR(ISP_YRANDOM_PARAM0, BIT_0, yrandom_info.bypass);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_iircnr(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_iircnr: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_iircnr: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_IIRCNR_BLOCK:
+		ret = isp_k_iircnr_block(param);
+		break;
+	case ISP_PRO_YRANDOM_BLOCK:
+		ret = isp_k_yrandom_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_iircnr: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_isr.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_isr.c
new file mode 100644
index 00000000..d493e086
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_isr.c
@@ -0,0 +1,102 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include <linux/delay.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+#define ISP_TIME_OUT_MAX (500)
+
+int32_t isp_get_int_num(struct isp_node *node)
+{
+
+	node->irq_val1 = REG_RD(ISP_INT_INT0);
+	node->irq_val2 = REG_RD(ISP_INT_INT1);
+	node->irq_val3 = REG_RD(ISP_INT_INT2);
+
+	if ((0 == node->irq_val1)
+		&& (0 == node->irq_val2)
+		&& (0 == node->irq_val3)) {
+		printk("isp_get_int_num: int error.\n");
+		return -1;
+	}
+
+	REG_WR(ISP_INT_CLR0, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR1, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR2, ISP_IRQ_HW_MASK);
+
+	return 0;
+}
+
+void isp_clr_int(void)
+{
+	REG_WR(ISP_INT_CLR0, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR1, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR2, ISP_IRQ_HW_MASK);
+}
+
+void isp_en_irq(uint32_t irq_mode)
+{
+	REG_WR(ISP_INT_CLR0, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR1, ISP_IRQ_HW_MASK);
+	REG_WR(ISP_INT_CLR2, ISP_IRQ_HW_MASK);
+
+	switch(irq_mode) {
+	case ISP_INT_VIDEO_MODE:
+		REG_WR(ISP_INT_EN0, ISP_INT_DCAMERA_SOF | ISP_INT_AEM_DONE | ISP_INT_AFM_RGB_DONE | ISP_INT_AFL_DONE | ISP_INT_AEM2_DONE \
+				| ISP_INT_BINNING_DONE);
+		REG_WR(ISP_INT_EN1, 0);
+		REG_WR(ISP_INT_EN2, 0);
+		break;
+	case ISP_INT_CAPTURE_MODE:
+		REG_WR(ISP_INT_EN0, ISP_INT_STORE_DONE);
+		REG_WR(ISP_INT_EN1, 0);
+		REG_WR(ISP_INT_EN2, 0);
+		break;
+	case ISP_INT_CLEAR_MODE:
+		REG_WR(ISP_INT_EN0, 0);
+		REG_WR(ISP_INT_EN1, 0);
+		REG_WR(ISP_INT_EN2, 0);
+		break;
+	default:
+		printk("isp_en_irq: irq_mode error.\n");
+		break;
+	}
+}
+
+int32_t isp_axi_bus_waiting(void)
+{
+	int32_t ret = 0;
+	uint32_t reg_value = 0;
+	uint32_t time_out_cnt = 0;
+
+	REG_OWR(ISP_AXI_ITI2AXIM_CTRL, BIT_18);
+
+	reg_value = REG_RD(ISP_INT_STATUS);
+	while ((0x00 == (reg_value & BIT_3))
+		&& (time_out_cnt < ISP_TIME_OUT_MAX)) {
+		time_out_cnt++;
+		udelay(50);
+		reg_value = REG_RD(ISP_INT_STATUS);
+	}
+
+	if (time_out_cnt >= ISP_TIME_OUT_MAX) {
+		ret = -1;
+		printk("isp_axi_bus_waiting: time out.\n");
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_nlc.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_nlc.c
new file mode 100755
index 00000000..1be70137
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_nlc.c
@@ -0,0 +1,83 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_nlc_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	struct isp_dev_nlc_info_v1 nlc_info;
+
+	memset(&nlc_info, 0x00, sizeof(nlc_info));
+
+	ret = copy_from_user((void *)&nlc_info, param->property_param, sizeof(nlc_info));
+	if (0 != ret) {
+		printk("isp_k_nlc_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	for (i = 0; i < 9; i++) {
+		val = ((nlc_info.node.r_node[i*3] & 0x3FF) << 20) | ((nlc_info.node.r_node[i*3+1] & 0x3FF) << 10) | (nlc_info.node.r_node[i*3+2] & 0x3FF);
+		REG_WR(ISP_NLC_PARA_R0 + i * 4, val);
+		val = ((nlc_info.node.g_node[i*3] & 0x3FF) << 20) | ((nlc_info.node.g_node[i*3+1] & 0x3FF) << 10) | (nlc_info.node.g_node[i*3+2] & 0x3FF);
+		REG_WR(ISP_NLC_PARA_G0 + i * 4, val);
+		val = ((nlc_info.node.b_node[i*3] & 0x3FF) << 20) | ((nlc_info.node.b_node[i*3+1] & 0x3FF) << 10) | (nlc_info.node.b_node[i*3+2] & 0x3FF);
+		REG_WR(ISP_NLC_PARA_B0 + i * 4, val);
+		val = ((nlc_info.node.l_node[i*3] & 0x3FF) << 20) | ((nlc_info.node.l_node[i*3+1] & 0x3FF) << 10) | (nlc_info.node.l_node[i*3+2] & 0x3FF);
+		REG_WR(ISP_NLC_PARA_L0 + i * 4, val);
+	}
+
+	val = ((nlc_info.node.r_node[27] & 0x3FF) << 20) | ((nlc_info.node.r_node[28] & 0x3FF) << 10);
+	REG_WR(ISP_NLC_PARA_R9, val);
+	val = ((nlc_info.node.g_node[27] & 0x3FF) << 20) | ((nlc_info.node.g_node[28] & 0x3FF) << 10);
+	REG_WR(ISP_NLC_PARA_G9, val);
+	val = ((nlc_info.node.b_node[27] & 0x3FF) << 20) | ((nlc_info.node.b_node[28] & 0x3FF) << 10);
+	REG_WR(ISP_NLC_PARA_B9, val);
+
+	REG_MWR(ISP_NLC_PARA, BIT_0, nlc_info.bypass);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_nlc(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_nlc: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_nlc: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_NLC_BLOCK:
+		ret = isp_k_nlc_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_nlc: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_nlm.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_nlm.c
new file mode 100644
index 00000000..4cf73b08
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_nlm.c
@@ -0,0 +1,250 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include <linux/vmalloc.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_vst_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_vst_info_v1 vst_info;
+
+	ret = copy_from_user((void *)&vst_info, param->property_param, sizeof(vst_info));
+	if (0 != ret) {
+		printk("isp_k_vst_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_VST_PARA, BIT_0, vst_info.bypass);
+
+	REG_MWR(ISP_VST_PARA, BIT_1, vst_info.buf_sel << 1);
+
+	return ret;
+
+}
+
+static int32_t isp_k_nlm_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	struct isp_dev_nlm_info_v1 nlm_info;
+	uint32_t *buff0 = NULL;
+	uint32_t *buff1 = NULL;
+	uint32_t *buff2 = NULL;
+	unsigned long buf_addr = 0;
+	void *vst_addr = NULL;
+	void *ivst_addr = NULL;
+	void *nlm_addr = NULL;
+
+	ret = copy_from_user((void *)&nlm_info, param->property_param, sizeof(nlm_info));
+	if (0 != ret) {
+		printk("isp_k_nlm_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	buff0 = vzalloc(nlm_info.vst_len);
+	if (NULL == buff0) {
+		printk("isp_k_nlm_block:vst kmalloc error\n");
+		return -1;
+	}
+
+	buff1 = vzalloc(nlm_info.ivst_len);
+	if (NULL == buff1) {
+		printk("isp_k_nlm_block:ivst kmalloc error\n");
+		vfree(buff0);
+		return -1;
+	}
+
+	buff2 = vzalloc(nlm_info.nlm_len);
+	if (NULL == buff2) {
+		printk("isp_k_nlm_block:nlm kmalloc error\n");
+		vfree(buff0);
+		vfree(buff1);
+		return -1;
+	}
+
+#ifdef CONFIG_64BIT
+	vst_addr = (void*)(((unsigned long)nlm_info.vst_addr[1] << 32) | nlm_info.vst_addr[0]);
+#else
+	vst_addr = (void*)(nlm_info.vst_addr[0]);
+#endif
+	ret = copy_from_user((void *)buff0, vst_addr, nlm_info.vst_len);
+	if (0 != ret) {
+		printk("isp_k_nlm_block: vst copy error, ret=0x%x\n", (uint32_t)ret);
+		vfree(buff0);
+		vfree(buff1);
+		vfree(buff2);
+		return -1;
+	}
+
+#ifdef CONFIG_64BIT
+	ivst_addr = (void*)(((unsigned long)nlm_info.ivst_addr[1] << 32) | nlm_info.ivst_addr[0]);
+#else
+	ivst_addr = (void*)(nlm_info.ivst_addr[0]);
+#endif
+	ret = copy_from_user((void *)buff1, ivst_addr, nlm_info.ivst_len);
+	if (0 != ret) {
+		printk("isp_k_nlm_block: ivst copy error, ret=0x%x\n", (uint32_t)ret);
+		vfree(buff0);
+		vfree(buff1);
+		vfree(buff2);
+		return -1;
+	}
+
+#ifdef CONFIG_64BIT
+		nlm_addr = (void*)(((unsigned long)nlm_info.nlm_addr[1] << 32) | nlm_info.nlm_addr[0]);
+#else
+		nlm_addr = (void*)(nlm_info.nlm_addr[0]);
+#endif
+	ret = copy_from_user((void *)buff2, nlm_addr, nlm_info.nlm_len);
+	if (0 != ret) {
+		printk("isp_k_nlm_block: nlm copy error, ret=0x%x\n", (uint32_t)ret);
+		vfree(buff0);
+		vfree(buff1);
+		vfree(buff2);
+		return -1;
+	}
+
+	REG_MWR(ISP_NLM_PARA, BIT_1, nlm_info.imp_opt_bypass << 1);
+	REG_MWR(ISP_NLM_PARA, BIT_2, nlm_info.flat_opt_bypass << 2);
+	REG_MWR(ISP_NLM_PARA, BIT_3, nlm_info.flat_thr_bypass << 3);
+	REG_MWR(ISP_NLM_PARA, BIT_4, nlm_info.direction_mode_bypass << 4);
+
+	REG_MWR(ISP_NLM_PARA, BIT_31, nlm_info.buf_sel<<31);
+
+	for (i = 0; i < 5; i++) {
+		val = (nlm_info.thresh[i] & 0x3FFF) | ((nlm_info.cnt[i] & 0x1F) << 16)
+			| ((nlm_info.strength[i] & 0xFF) << 24);
+		REG_WR(ISP_NLM_FLAT_PARA_0 + i * 4, val);
+	}
+
+	REG_MWR(ISP_NLM_STERNGTH, 0x7F, nlm_info.streng_th);
+
+	REG_MWR(ISP_NLM_STERNGTH, 0xFF00, nlm_info.texture_dec << 8);
+
+	//REG_WR(ISP_NLM_IS_FLAT, nlm_info.is_flat & 0xFF);
+
+	REG_MWR(ISP_NLM_ADD_BACK, 0x7F, nlm_info.addback);
+
+	REG_MWR(ISP_NLM_ADD_BACK, BIT_7, nlm_info.opt_mode << 7);
+
+	REG_MWR(ISP_NLM_DIRECTION_0, BIT_17 | BIT_16, nlm_info.dist_mode << 16);
+
+	val = ((nlm_info.w_shift[0] & 0x3) << 4) | ((nlm_info.w_shift[1] & 0x3) << 6) | ((nlm_info.w_shift[2] & 0x3) << 8);
+	REG_MWR(ISP_NLM_DIRECTION_0, 0x3F0, val);
+
+	REG_MWR(ISP_NLM_DIRECTION_0, 0x7, nlm_info.cnt_th);
+
+	REG_MWR(ISP_NLM_DIRECTION_1, 0xFFFF0000, nlm_info.tdist_min_th << 16);
+
+	REG_MWR(ISP_NLM_DIRECTION_1, 0xFFFF, nlm_info.diff_th);
+
+	for (i = 0; i < 24; i++) {
+		val = (nlm_info.lut_w[i*3+0] & 0x3FF) | ((nlm_info.lut_w[i*3+1] & 0x3FF) << 10)
+			| ((nlm_info.lut_w[i*3+2] & 0x3FF) << 20);
+		REG_WR(ISP_NLM_LUT_W_0 + i * 4, val);
+	}
+
+	if(nlm_info.buf_sel) {
+		buf_addr = ISP_NLM_BUF1_CH0;
+		memcpy((void *)buf_addr, buff2, ISP_VST_IVST_NUM * sizeof(uint32_t));
+	} else {
+		buf_addr = ISP_NLM_BUF0_CH0;
+		memcpy((void *)buf_addr, buff2, ISP_VST_IVST_NUM * sizeof(uint32_t));
+	}
+
+	if (nlm_info.buf_sel ) {
+		buf_addr = ISP_VST_BUF1_CH0;
+		memcpy((void *)buf_addr, buff0, ISP_VST_IVST_NUM * sizeof(uint32_t));
+	} else {
+		buf_addr = ISP_VST_BUF0_CH0;
+		memcpy((void *)buf_addr, buff0, ISP_VST_IVST_NUM * sizeof(uint32_t));
+	}
+
+	if (nlm_info.buf_sel ) {
+		buf_addr = ISP_IVST_BUF1_CH0;
+		memcpy((void *)buf_addr, buff1, ISP_VST_IVST_NUM * sizeof(uint32_t));
+	} else {
+		buf_addr = ISP_IVST_BUF0_CH0;
+		memcpy((void *)buf_addr, buff1, ISP_VST_IVST_NUM * sizeof(uint32_t));
+	}
+
+	/*vst ivst follow nlm*/
+	REG_MWR(ISP_VST_PARA, BIT_1, nlm_info.buf_sel << 1);
+	REG_MWR(ISP_IVST_PARA, BIT_1, nlm_info.buf_sel << 1);
+
+	REG_MWR(ISP_NLM_PARA, BIT_0, nlm_info.bypass);
+	REG_MWR(ISP_IVST_PARA, BIT_0, nlm_info.bypass);
+	REG_MWR(ISP_VST_PARA, BIT_0, nlm_info.bypass);
+
+	vfree(buff0);
+	vfree(buff1);
+	vfree(buff2);
+	return ret;
+}
+
+static int32_t isp_k_ivst_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	struct isp_dev_ivst_info_v1 ivst_info;
+
+	ret = copy_from_user((void *)&ivst_info, param->property_param, sizeof(ivst_info));
+	if (0 != ret) {
+		printk("isp_k_ivst_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_IVST_PARA, BIT_0, ivst_info.bypass);
+
+	REG_MWR(ISP_IVST_PARA, BIT_1, ivst_info.buf_sel << 1);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_nlm(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_nlm: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_nlm: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_VST_BLOCK:
+		ret = isp_k_vst_block(param);
+		break;
+	case ISP_PRO_NLM_BLOCK:
+		ret = isp_k_nlm_block(param);;
+		break;
+	case ISP_PRO_IVST_BLOCK:
+		ret = isp_k_ivst_block(param);;
+		break;
+	default:
+		printk("isp_k_cfg_nlm: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pgg.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pgg.c
new file mode 100644
index 00000000..8cdd023d
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pgg.c
@@ -0,0 +1,67 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_pgg_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_pre_glb_gain_info pgg_info;
+
+	memset(&pgg_info, 0x00, sizeof(pgg_info));
+
+	ret = copy_from_user((void *)&pgg_info, param->property_param, sizeof(pgg_info));
+	if (0 != ret) {
+		printk("isp_k_pgg_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_PGG_PARAM, 0xFFFF00, (pgg_info.gain << 8));
+
+	if (pgg_info.bypass) {
+		REG_OWR(ISP_PGG_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_PGG_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_pgg(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_pgg: param is null error.\n");
+		return -1;
+	}
+
+	if (!param->property_param) {
+		printk("isp_k_cfg_pgg: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_PRE_GLB_GAIN_BLOCK:
+		ret = isp_k_pgg_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_pgg: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_post_cdn.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_post_cdn.c
new file mode 100644
index 00000000..8ad8c679
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_post_cdn.c
@@ -0,0 +1,128 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_post_cdn_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_post_cdn_info post_cdn_info;
+	uint32_t val = 0;
+	uint32_t i = 0;
+
+	memset(&post_cdn_info, 0x00, sizeof(post_cdn_info));
+
+	ret = copy_from_user((void *)&post_cdn_info, param->property_param, sizeof(post_cdn_info));
+	if (0 != ret) {
+		printk("isp_k_post_cdn_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+
+	REG_WR(ISP_POSTCDN_ADPT_THR, post_cdn_info.adapt_med_thr & 0x3FFF);
+
+	REG_MWR(ISP_POSTCDN_COMMON_CTRL, 0xE0, post_cdn_info.median_mode << 5);
+
+	if (post_cdn_info.uvjoint) {
+		REG_OWR(ISP_POSTCDN_COMMON_CTRL, BIT_4);
+	} else {
+		REG_MWR(ISP_POSTCDN_COMMON_CTRL, BIT_4, 0);
+	}
+
+	if (post_cdn_info.writeback_en) {
+		REG_OWR(ISP_POSTCDN_COMMON_CTRL, BIT_3);
+	} else {
+		REG_MWR(ISP_POSTCDN_COMMON_CTRL, BIT_3, 0);
+	}
+
+	if (post_cdn_info.mode) {
+		REG_OWR(ISP_POSTCDN_COMMON_CTRL, BIT_2);
+	} else {
+		REG_MWR(ISP_POSTCDN_COMMON_CTRL, BIT_2, 0);
+	}
+
+	val = (post_cdn_info.uvthr0 & 0x1FF) | ((post_cdn_info.uvthr1 & 0x1FF) << 16);
+	REG_WR(ISP_POSTCDN_UVTHR, val);
+	val = (post_cdn_info.thru0 & 0xFF) | ((post_cdn_info.thru1 & 0xFF) << 16);
+	REG_WR(ISP_POSTCDN_THRU, val);
+	val = (post_cdn_info.thrv0 & 0xFF) | ((post_cdn_info.thrv1 & 0xFF) << 16);
+	REG_WR(ISP_POSTCDN_THRV, val);
+
+	for (i = 0; i < 3; i++) {
+		val = (post_cdn_info.r_segu[0][i*2] & 0xFF) | ((post_cdn_info.r_segu[1][i*2] & 0x7) << 8)
+			| ((post_cdn_info.r_segu[0][i*2+1] & 0xFF) << 16) | ((post_cdn_info.r_segu[1][i*2+1] & 0x7) << 24);
+		REG_WR(ISP_POSTCDN_RSEGU01 + i * 4, val);
+	}
+	val = (post_cdn_info.r_segu[0][6] & 0xFF) | ((post_cdn_info.r_segu[1][6] & 0x7) << 8);
+	REG_WR(ISP_POSTCDN_RSEGU6, val);
+	for (i = 0; i < 3; i++) {
+		val = (post_cdn_info.r_segv[0][i*2] & 0xFF) | ((post_cdn_info.r_segv[1][i*2] & 0x7) << 8)
+			| ((post_cdn_info.r_segv[0][i*2+1] & 0xFF) << 16) | ((post_cdn_info.r_segv[1][i*2+1] & 0x7) << 24);
+		REG_WR(ISP_POSTCDN_RSEGV01 + i * 4, val);
+	}
+	val = (post_cdn_info.r_segv[0][6] & 0xFF) | ((post_cdn_info.r_segv[1][6] & 0x7) << 8);
+	REG_WR(ISP_POSTCDN_RSEGV6, val);
+
+
+	for (i = 0; i < 15; i++) {
+		val = (post_cdn_info.r_distw[i][0] & 0x7) | ((post_cdn_info.r_distw[i][1] & 0x7) << 3)
+			| ((post_cdn_info.r_distw[i][2] & 0x7) << 6) | ((post_cdn_info.r_distw[i][3] & 0x7) << 9)
+			| ((post_cdn_info.r_distw[i][4] & 0x7) << 12);
+		REG_WR(ISP_POSTCDN_R_DISTW0 + i * 4, val);
+	}
+
+	REG_WR(ISP_POSTCDN_START_ROW_MOD4, post_cdn_info.start_row_mod4 & 0x3);
+
+	if (post_cdn_info.downsample_bypass) {
+		REG_OWR(ISP_POSTCDN_COMMON_CTRL, BIT_1);
+	} else {
+		REG_MWR(ISP_POSTCDN_COMMON_CTRL, BIT_1, 0);
+	}
+
+	if (post_cdn_info.bypass) {
+		REG_OWR(ISP_POSTCDN_COMMON_CTRL, BIT_0);
+	} else {
+		REG_MWR(ISP_POSTCDN_COMMON_CTRL, BIT_0, 0);
+	}
+
+
+	return ret;
+}
+
+int32_t isp_k_cfg_post_cdn(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_post_cdn: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_post_cdn: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_POST_CDN_BLOCK:
+		ret = isp_k_post_cdn_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_post_cdn: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pre_cdn.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pre_cdn.c
new file mode 100644
index 00000000..f4be5578
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pre_cdn.c
@@ -0,0 +1,135 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_yuv_precdn_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_yuv_precdn_info pre_cdn_info;
+	uint32_t val = 0;
+	uint32_t i = 0;
+
+	memset(&pre_cdn_info, 0x00, sizeof(pre_cdn_info));
+
+	ret = copy_from_user((void *)&pre_cdn_info, param->property_param, sizeof(pre_cdn_info));
+	if (0 != ret) {
+		printk("isp_k_yuv_precdn_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (pre_cdn_info.mode) {
+		REG_OWR(ISP_PRECDN_PARAM, BIT_4);
+	} else {
+		REG_MWR(ISP_PRECDN_PARAM, BIT_4, 0);
+	}
+
+	if (pre_cdn_info.median_writeback_en) {
+		REG_OWR(ISP_PRECDN_PARAM, BIT_8);
+	} else {
+		REG_MWR(ISP_PRECDN_PARAM, BIT_8, 0);
+	}
+
+	REG_MWR(ISP_PRECDN_PARAM, BIT_13 | BIT_12, pre_cdn_info.median_mode << 12);
+
+	if (pre_cdn_info.uv_joint) {
+		REG_OWR(ISP_PRECDN_PARAM, BIT_20);
+	} else {
+		REG_MWR(ISP_PRECDN_PARAM, BIT_20, 0);
+	}
+
+	REG_MWR(ISP_PRECDN_PARAM, BIT_17 | BIT_16, pre_cdn_info.den_stren << 16);
+
+	val = (pre_cdn_info.median_thr_u[0] & 0x7F) | ((pre_cdn_info.median_thr_u[1] & 0xFF) << 8)
+		| ((pre_cdn_info.median_thr_v[0] & 0x7F) << 16) | ((pre_cdn_info.median_thr_v[1] & 0xFF) << 24);
+	REG_WR(ISP_PRECDN_MEDIAN_THRUV01, val);
+
+	val = (pre_cdn_info.median_thr & 0x1FF) | ((pre_cdn_info.uv_thr & 0xFF) << 16)
+		| ((pre_cdn_info.y_thr & 0xFF) << 24);
+	REG_WR(ISP_PRECDN_THRYUV, val);
+
+	for (i = 0; i < 3; i++) {
+		val = (pre_cdn_info.r_segu[0][i*2] & 0xFF) | ((pre_cdn_info.r_segu[1][i*2] & 0x7) << 8)
+			| ((pre_cdn_info.r_segu[0][i*2+1] & 0xFF) << 16) | ((pre_cdn_info.r_segu[1][i*2+1] & 0x7) << 24);
+		REG_WR(ISP_PRECDN_SEGU_0 + i * 4, val);
+	}
+
+	val = (pre_cdn_info.r_segu[0][6] & 0xFF) | ((pre_cdn_info.r_segu[1][6] & 0x7) << 8);
+	REG_WR(ISP_PRECDN_SEGU_3, val);
+
+	for (i = 0; i < 3; i++) {
+		val = (pre_cdn_info.r_segv[0][i*2] & 0xFF) | ((pre_cdn_info.r_segv[1][i*2] & 0x7) << 8)
+			| ((pre_cdn_info.r_segv[0][i*2+1] & 0xFF) << 16) | ((pre_cdn_info.r_segv[1][i*2+1] & 0x7) << 24);
+		REG_WR(ISP_PRECDN_SEGV_0 + i * 4, val);
+	}
+
+	val = (pre_cdn_info.r_segv[0][6] & 0xFF) | ((pre_cdn_info.r_segv[1][6] & 0x7) << 8);
+	REG_WR(ISP_PRECDN_SEGV_3, val);
+
+	for (i = 0; i < 3; i++) {
+		val = (pre_cdn_info.r_segy[0][i*2] & 0xFF) | ((pre_cdn_info.r_segy[1][i*2] & 0x7) << 8)
+			| ((pre_cdn_info.r_segy[0][i*2+1] & 0xFF) << 16) | ((pre_cdn_info.r_segy[1][i*2+1] & 0x7) << 24);
+		REG_WR(ISP_PRECDN_SEGY_0 + i * 4, val);
+	}
+
+	val = (pre_cdn_info.r_segy[0][6] & 0xFF) | ((pre_cdn_info.r_segy[1][6] & 0x7) << 8);
+	REG_WR(ISP_PRECDN_SEGY_3, val);
+
+	for (i = 0; i < 3; i++) {
+		val = (pre_cdn_info.r_distw[i*8] & 0x7) | ((pre_cdn_info.r_distw[i*8+1] & 0x7) << 4)
+			| ((pre_cdn_info.r_distw[i*8+2] & 0x7) << 8) | ((pre_cdn_info.r_distw[i*8+3] & 0x7) << 12)
+			| ((pre_cdn_info.r_distw[i*8+4] & 0x7) << 16) | ((pre_cdn_info.r_distw[i*8+5] & 0x7) << 20)
+			| ((pre_cdn_info.r_distw[i*8+6] & 0x7) << 24) | ((pre_cdn_info.r_distw[i*8+7] & 0x7) << 28);
+		REG_WR(ISP_PRECDN_DISTW0 + i * 4, val);
+	}
+
+	val = pre_cdn_info.r_distw[24] & 0x7;
+	REG_WR(ISP_PRECDN_DISTW3, val);
+
+	if (pre_cdn_info.bypass) {
+		REG_OWR(ISP_PRECDN_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_PRECDN_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_yuv_precdn(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_yuv_precdn: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_yuv_precdn: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_YUV_PRECDN_BLOCK:
+		ret = isp_k_yuv_precdn_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_yuv_precdn: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pre_cdn_rgb.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pre_cdn_rgb.c
new file mode 100644
index 00000000..d5bde126
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pre_cdn_rgb.c
@@ -0,0 +1,73 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_pre_cdn_rgb_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_pre_cdn_rgb_info pcr_info;
+
+	memset(&pcr_info, 0x00, sizeof(pcr_info));
+
+	ret = copy_from_user((void *)&pcr_info, param->property_param, sizeof(pcr_info));
+	if (0 != ret) {
+		printk("isp_k_pre_cdn_rgb_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_PRECNRNEW_CFG, BIT_0, pcr_info.bypass);
+
+	REG_MWR(ISP_PRECNRNEW_CFG, 0x3 << 1, pcr_info.median_mode << 1);
+
+	val = pcr_info.median_thr & 0xFFFF;
+	REG_WR(ISP_PRECNRNEW_MEDIAN_THR, val);
+	val = (pcr_info.thru0 & 0xFFFF) | ((pcr_info.thru1 & 0xFFFF) << 16);
+	REG_WR(ISP_PRECNRNEW_THRU, val);
+	val = (pcr_info.thrv0 & 0xFFFF) | ((pcr_info.thrv1 & 0xFFFF) << 16);
+	REG_WR(ISP_PRECNRNEW_THRV, val);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_pre_cdn_rgb(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_pre_cdn_rgb: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_pre_cdn_rgb: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_PRE_CDN_RGB_BLOCK:
+		ret = isp_k_pre_cdn_rgb_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_pre_cdn_rgb: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_prefilter.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_prefilter.c
new file mode 100644
index 00000000..ea25ccf1
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_prefilter.c
@@ -0,0 +1,73 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_prefilter_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_prefilter_info_v1 prefilter_info;
+
+	memset(&prefilter_info, 0x00, sizeof(prefilter_info));
+
+	ret = copy_from_user((void *)&prefilter_info, param->property_param, sizeof(prefilter_info));
+	if (0 != ret) {
+		printk("isp_k_prefilter_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (prefilter_info.writeback) {
+		REG_OWR(ISP_PREF_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_PREF_PARAM, BIT_1, 0);
+	}
+
+	REG_WR(ISP_PREF_THRD, prefilter_info.thrd & 0xFF);
+
+	if (prefilter_info.bypass) {
+		REG_OWR(ISP_PREF_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_PREF_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_prefilter(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_prefilter: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_prefilter: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_PREF_BLOCK:
+		ret = isp_k_prefilter_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_prefilter: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pstrz.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pstrz.c
new file mode 100644
index 00000000..0db4e234
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pstrz.c
@@ -0,0 +1,71 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_posterize_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	struct isp_dev_posterize_info pstrz_info;
+
+	memset(&pstrz_info, 0x00, sizeof(pstrz_info));
+
+	ret = copy_from_user((void *)&pstrz_info, param->property_param, sizeof(pstrz_info));
+	if (0 != ret) {
+		printk("isp_k_posterize_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_PSTRZ_PARAM, BIT_0, pstrz_info.bypass);
+
+	for (i = 0; i < 8; i++) {
+		val = (pstrz_info.posterize_level_out[i] & 0xFF) | ((pstrz_info.posterize_level_top[i] & 0xFF) << 8)
+			| ((pstrz_info.posterize_level_bottom[i] & 0xFF) << 16);
+		REG_WR(ISP_PSTRZ_LEVEL0 + i * 4, val);
+	}
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_posterize(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_posterize: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_posterize: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_POSTERIZE_BLOCK:
+		ret = isp_k_posterize_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_posterize: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pwd.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pwd.c
new file mode 100644
index 00000000..c7bc4ca4
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_pwd.c
@@ -0,0 +1,123 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_pwd_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_pre_wavelet_info_v1 pwd_info;
+
+	memset(&pwd_info, 0x00, sizeof(pwd_info));
+
+	ret = copy_from_user((void *)&pwd_info, param->property_param, sizeof(pwd_info));
+	if (0 != ret) {
+		printk("isp_k_pwd_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((pwd_info.gain_thrs0 & 0x7FF) << 6) | ((pwd_info.gain_thrs1 & 0x7FF) << 17);
+	REG_MWR(ISP_PWD_PARAM, 0x0FFFFFC0, val);
+
+	val = (pwd_info.bitshift0 & 0x7) | ((pwd_info.bitshift1 & 0xFF) << 3);
+	REG_MWR(ISP_PWD_PARAM1, 0x7FF, val);
+
+	val = (pwd_info.offset & 0xFF) << 11;
+	REG_MWR(ISP_PWD_PARAM1, 0x7F800, val);
+
+	val = (pwd_info.nsr_slope & 0x3FF) << 4;
+	REG_MWR(ISP_PWD_PARAM2, 0x3FF0, val);
+
+	val = pwd_info.lum_ratio & 0xF;
+	REG_MWR(ISP_PWD_PARAM2, 0xF, val);
+
+	val = ((pwd_info.center_pos_x & 0x1FFF) << 12) | (pwd_info.center_pos_y & 0xFFF);
+	REG_WR(ISP_PWD_PARAM3, val);
+
+	val = pwd_info.delta_x2 & 0x3FFFFFF;
+	REG_WR(ISP_PWD_PARAM4, val);
+	val = pwd_info.delta_y2 & 0xFFFFFF;
+	REG_WR(ISP_PWD_PARAM5, val);
+
+	val = pwd_info.r2_thr & 0x3FFFFFF;
+	REG_WR(ISP_PWD_PARAM6, val);
+
+	val = ((pwd_info.p_param1 & 0x3FFF) << 12) | (pwd_info.p_param2 & 0xFFF);
+	REG_WR(ISP_PWD_PARAM7, val);
+
+	val = (pwd_info.addback & 0x7F) << 13;
+	REG_MWR(ISP_PWD_PARAM8, 0xFE000, val);
+
+	val = pwd_info.gain_max_thr & 0x1FFF;
+	REG_MWR(ISP_PWD_PARAM8, 0x1FFF, val);
+
+	val = ((pwd_info.pos_x & 0x1FFF) << 12) | (pwd_info.pos_y & 0xFFF);
+	REG_WR(ISP_PWD_PARAM10, val);
+
+	REG_MWR(ISP_PWD_PARAM, BIT_1, pwd_info.radial_bypass << 1);
+	REG_MWR(ISP_PWD_PARAM, BIT_0, pwd_info.bypass);
+
+	return ret;
+}
+
+static int32_t isp_k_pwd_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0, 0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_pwd_slice_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.width & 0x1FFF) << 12) | (size.height & 0xFFF);
+	REG_WR(ISP_PWD_PARAM9, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_pwd(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_pwd: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_pwd: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_PWD_BLOCK:
+		ret = isp_k_pwd_block(param);
+		break;
+	case ISP_PRO_PWD_SLICE_SIZE:
+		ret = isp_k_pwd_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_pwd: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_raw_aem.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_raw_aem.c
new file mode 100644
index 00000000..5e4509d5
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_raw_aem.c
@@ -0,0 +1,255 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+static int32_t isp_k_raw_aem_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_raw_aem_info aem_info;
+
+	memset(&aem_info, 0x00, sizeof(aem_info));
+
+	ret = copy_from_user((void *)&aem_info, param->property_param, sizeof(aem_info));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_AEM_PARAM, BIT_0, aem_info.bypass);
+
+	val = (aem_info.shift & 0x1F) << 18;
+	if(0 != val) {
+		printk("isp_k_raw_aem_block: shift error, 0x%x\n", val);
+	}
+	REG_MWR(ISP_AEM_BLK_SIZE, 0x7C0000, 0);
+
+	REG_MWR(ISP_AEM_PARAM, BIT_1, aem_info.mode << 1);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_bypass: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_AEM_PARAM, BIT_0, bypass);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_mode(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t mode = 0;
+
+	ret = copy_from_user((void *)&mode, param->property_param, sizeof(mode));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_mode: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_AEM_PARAM, BIT_1, mode << 1);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_statistics(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0, i = 0;
+	uint32_t val0 = 0, val1 = 0;
+	unsigned long addr = 0;
+	struct isp_raw_aem_statistics *aem_statistics = NULL;
+
+	aem_statistics = (struct isp_raw_aem_statistics *)isp_private->raw_aem_buf_addr;
+	if (!aem_statistics) {
+		ret = -1;
+		printk("isp_k_raw_aem_statistics: alloc memory error.\n");
+		return -1;
+	}
+
+	addr = ISP_RAW_AEM_OUTPUT;
+	for (i = 0x00; i < ISP_RAW_AEM_ITEM; i++) {
+		val0 = REG_RD(addr);
+		val1 = REG_RD(addr + 4);
+		aem_statistics->r[i]= (val1 >> 11) & 0x1fffff;
+		aem_statistics->g[i]= val0 & 0x3fffff;
+		aem_statistics->b[i]= ((val1 & 0x7ff) << 10) | ((val0 >> 22) & 0x3ff);
+		addr += 8;
+	}
+
+	ret = copy_to_user(param->property_param, (void*)aem_statistics, sizeof(struct isp_raw_aem_statistics));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_raw_aem_statistics: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_skip_num(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t skip_num;
+
+	ret = copy_from_user((void *)&skip_num, param->property_param, sizeof(skip_num));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_skip_num: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (skip_num & 0xF) << 4;
+	REG_MWR(ISP_AEM_PARAM, 0xF0, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_shift(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t shift = 0;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&shift, param->property_param, sizeof(shift));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_shift: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (shift & 0x1F) << 18;
+	if(0 != val) {
+		printk("isp_k_raw_aem_shift: shift error, 0x%x\n", val);
+	}
+	REG_MWR(ISP_AEM_BLK_SIZE, 0x7C0000, 0);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_offset(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct img_offset offset;
+
+	ret = copy_from_user((void *)&offset, param->property_param, sizeof(struct img_offset));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_offset: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((offset.y & 0xFFFF) << 16) | (offset.x & 0xFFFF);
+	REG_WR(ISP_AEM_OFFSET, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_blk_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_blk_size: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0x1FF) << 9) | (size.width & 0x1FF);
+	REG_MWR(ISP_AEM_BLK_SIZE, 0x3FFFF, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_aem_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_slice_size: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0xFFFF) << 16) | (size.width & 0xFFFF);
+	REG_WR(ISP_AEM_SLICE_SIZE, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_raw_aem(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_raw_aem: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_raw_aem: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_RAW_AEM_BLOCK:
+		ret = isp_k_raw_aem_block(param);
+		break;
+	case ISP_PRO_RAW_AEM_BYPASS:
+		ret = isp_k_raw_aem_bypass(param);
+		break;
+	case ISP_PRO_RAW_AEM_MODE:
+		ret = isp_k_raw_aem_mode(param);
+		break;
+	case ISP_PRO_RAW_AEM_STATISTICS:
+		ret = isp_k_raw_aem_statistics(param, isp_private);
+		break;
+	case ISP_PRO_RAW_AEM_SKIP_NUM:
+		ret = isp_k_raw_aem_skip_num(param);
+		break;
+	case ISP_PRO_RAW_AEM_SHIFT:
+		ret = isp_k_raw_aem_shift(param);
+		break;
+	case ISP_PRO_RAW_AEM_OFFSET:
+		ret = isp_k_raw_aem_offset(param);
+		break;
+	case ISP_PRO_RAW_AEM_BLK_SIZE:
+		ret = isp_k_raw_aem_blk_size(param);
+		break;
+	case ISP_PRO_RAW_AEM_SLICE_SIZE:
+		ret = isp_k_raw_aem_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_raw_aem: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_raw_afm.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_raw_afm.c
new file mode 100644
index 00000000..b3f97c3f
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_raw_afm.c
@@ -0,0 +1,497 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+#define ISP_AFM_WIN_NUM_V1  25
+static int32_t isp_k_raw_afm_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	int max_num = ISP_AFM_WIN_NUM_V1;
+	struct isp_dev_rgb_afm_info_v1 rafm_info;
+
+	memset(&rafm_info, 0x00, sizeof(rafm_info));
+
+	ret = copy_from_user((void *)&rafm_info, param->property_param, sizeof(rafm_info));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_0, rafm_info.bypass);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_1, rafm_info.mode << 1);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, 0xF<<2, (rafm_info.skip_num << 2));
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_6, rafm_info.skip_num_clear << 6);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_7, rafm_info.spsmd_rtgbot_enable << 7);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_8, rafm_info.spsmd_diagonal_enable << 8);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_9, rafm_info.spsmd_cal_mode << 9);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_10, rafm_info.af_sel_filter1 << 10);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_11, rafm_info.af_sel_filter2 << 11);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, BIT_12, rafm_info.sobel_type << 12);
+
+	REG_MWR(ISP_RGB_AFM_PARAM, (BIT_13)|(BIT_14), rafm_info.spsmd_type << 13);
+
+	val = ((rafm_info.sobel_threshold_max << 16) & 0xffff0000)
+			| (rafm_info.sobel_threshold_min & 0xffff);
+	REG_WR(ISP_RGB_AFM_SOBEL_THRESHOLD, val);
+
+	REG_WR(ISP_RGB_AFM_SPSMD_THRESHOLD_MIN, rafm_info.spsmd_threshold_min);
+	REG_WR(ISP_RGB_AFM_SPSMD_THRESHOLD_MAX, rafm_info.spsmd_threshold_max);
+
+	for (i = 0; i < max_num; i++) {
+		val = ((rafm_info.coord[i].start_y <<16) & 0xffff0000)
+				| (rafm_info.coord[i].start_x & 0xffff);
+		REG_WR((ISP_RGB_AFM_WIN_RANGE0 + 4*2*i), val);
+
+		val = ((rafm_info.coord[i].end_y <<16) & 0xffff0000)
+			| (rafm_info.coord[i].end_x & 0xffff);
+		REG_WR((ISP_RGB_AFM_WIN_RANGE0 + 4*(2*i+1)), val);
+	}
+
+	return ret;
+
+}
+
+static int32_t isp_k_raw_afm_frame_range(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size  frame_size = {0, 0};
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&frame_size, param->property_param, sizeof(frame_size));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_frame_range: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (frame_size.height & 0xFFFF) | ((frame_size.width & 0xFFFF) << 16);
+	REG_WR(ISP_RGB_AFM_FRAME_RANGE, val);
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_type1_statistic(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int i = 0;
+	int max_item = ISP_AFM_WIN_NUM_V1;
+	struct isp_raw_afm_statistic item;
+
+	memset(&item, 0, sizeof(struct isp_raw_afm_statistic));
+	for (i = 0; i < max_item; i++) {
+		item.val[i] = REG_RD((ISP_RGB_AFM_TYPE1_VAL00 + 4*i));
+	}
+	ret = copy_to_user(param->property_param, (void*)&item, sizeof(item));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_raw_afm_statistic: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_type2_statistic(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int i = 0;
+	int max_item = ISP_AFM_WIN_NUM_V1;
+	struct isp_raw_afm_statistic item;
+
+	memset(&item, 0, sizeof(struct isp_raw_afm_statistic));
+	for (i = 0; i < max_item; i++) {
+		item.val[i] = REG_RD((ISP_RGB_AFM_TYPE2_VAL00 + 4*i));
+	}
+	ret = copy_to_user(param->property_param, (void*)&item, sizeof(item));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_raw_afm_statistic: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_bypass: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (bypass) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_mode(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t mode = 0;
+
+	ret = copy_from_user((void *)&mode, param->property_param, sizeof(mode));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_mode: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (mode) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_1, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_skip_num(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t skip_num = 0;
+
+	ret = copy_from_user((void *)&skip_num, param->property_param, sizeof(skip_num));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_skip_num: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_RGB_AFM_PARAM, 0xF<<2, (skip_num <<2));
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_skip_num_clr(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t is_clear = 0;
+
+	ret = copy_from_user((void *)&is_clear, param->property_param, sizeof(is_clear));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_skip_num_clr: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (is_clear) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_6);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_6, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_spsmd_rtgbot_enable(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t is_enable = 0;
+
+	ret = copy_from_user((void *)&is_enable, param->property_param, sizeof(is_enable));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_spsmd_rtgbot_enable: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (is_enable) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_7);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_7, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_spsmd_diagonal_enable(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t is_enable = 0;
+
+	ret = copy_from_user((void *)&is_enable, param->property_param, sizeof(is_enable));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_spsmd_diagonal_enable: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (is_enable) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_8);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_8, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_spsmd_cal_mode(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t cal_mode = 0;
+
+	ret = copy_from_user((void *)&cal_mode, param->property_param, sizeof(cal_mode));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_spsmd_cal_mode: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	if (cal_mode) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_9);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_9, 0);
+	}
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_sel_filter1(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t af_sel_filter = 0;
+
+	ret = copy_from_user((void *)&af_sel_filter, param->property_param, sizeof(af_sel_filter));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_sel_filter1: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	if (af_sel_filter) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_10);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_10, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_sel_filter2(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t af_sel_filter = 0;
+
+	ret = copy_from_user((void *)&af_sel_filter, param->property_param, sizeof(af_sel_filter));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	if (af_sel_filter) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_11);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_11, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_sobel_type(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t sobel_type = 0;
+
+	ret = copy_from_user((void *)&sobel_type, param->property_param, sizeof(sobel_type));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (sobel_type) {
+		REG_OWR(ISP_RGB_AFM_PARAM, BIT_12);
+	} else {
+		REG_MWR(ISP_RGB_AFM_PARAM, BIT_12, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_spsmd_type(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t spsmd_type = 0;
+
+	ret = copy_from_user((void *)&spsmd_type, param->property_param, sizeof(spsmd_type));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_RGB_AFM_PARAM, (BIT_13)|(BIT_14), spsmd_type<<13);
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_sobel_threshold(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct sobel_thrd sobel_threshold = {0, 0};
+
+	ret = copy_from_user((void *)&sobel_threshold, param->property_param, sizeof(sobel_threshold));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_sel_filter2: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	val = ((sobel_threshold.max<<16) & 0xffff0000)
+			| (sobel_threshold.min & 0xffff);
+	REG_WR(ISP_RGB_AFM_SOBEL_THRESHOLD, val);
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_spsmd_threshold(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct spsmd_thrd spsmd_threshold = {0, 0};
+
+	ret = copy_from_user((void *)&spsmd_threshold, param->property_param, sizeof(spsmd_threshold));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_spsmd_threshold: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	REG_WR(ISP_RGB_AFM_SPSMD_THRESHOLD_MIN, spsmd_threshold.min);
+	REG_WR(ISP_RGB_AFM_SPSMD_THRESHOLD_MAX, spsmd_threshold.max);
+	return ret;
+}
+
+static int32_t isp_k_raw_afm_win(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int i = 0;
+	int max_num = ISP_AFM_WIN_NUM_V1;
+	struct isp_coord coord[ISP_AFM_WIN_NUM_V1];
+	uint32_t val = 0;
+
+
+	memset(coord, 0, sizeof(coord));
+	ret = copy_from_user((void *)&coord, param->property_param, sizeof(coord));
+	if (0 != ret) {
+		printk("isp_k_raw_afm_win: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	for (i = 0; i < max_num; i++) {
+		val = ((coord[i].start_y <<16) & 0xffff0000)
+				| (coord[i].start_x & 0xffff);
+		REG_WR((ISP_RGB_AFM_WIN_RANGE0 + 4*2*i), val);
+
+		val = ((coord[i].end_y <<16) & 0xffff0000)
+			| (coord[i].end_x & 0xffff);
+		REG_WR((ISP_RGB_AFM_WIN_RANGE0 + 4*(2*i+1)), val);
+	}
+
+	return ret;
+}
+
+
+static int32_t isp_k_raw_afm_win_num(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t num = ISP_AFM_WIN_NUM_V1;
+
+	ret = copy_to_user(param->property_param, (void*)&num, sizeof(num));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_raw_afm_win_num: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_rgb_afm(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_afm: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_afm: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_RGB_AFM_BLOCK:
+		ret = isp_k_raw_afm_block(param);
+		break;
+	case ISP_PRO_RGB_AFM_FRAME_SIZE:
+		ret = isp_k_raw_afm_frame_range(param);
+		break;
+	case ISP_PRO_RGB_AFM_TYPE1_STATISTIC:
+		ret = isp_k_raw_afm_type1_statistic(param);
+		break;
+	case ISP_PRO_RGB_AFM_TYPE2_STATISTIC:
+		ret = isp_k_raw_afm_type2_statistic(param);
+		break;
+	case ISP_PRO_RGB_AFM_BYPASS:
+		ret = isp_k_raw_afm_bypass(param);
+		break;
+	case ISP_PRO_RGB_AFM_MODE:
+		ret = isp_k_raw_afm_mode(param);
+		break;
+	case ISP_PRO_RGB_AFM_SKIP_NUM:
+		ret = isp_k_raw_afm_skip_num(param);
+		break;
+	case ISP_PRO_RGB_AFM_SKIP_NUM_CLR:
+		ret = isp_k_raw_afm_skip_num_clr(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_RTGBOT_ENABLE:
+		ret = isp_k_raw_afm_spsmd_rtgbot_enable(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_DIAGONAL_ENABLE:
+		ret = isp_k_raw_afm_spsmd_diagonal_enable(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_CAL_MOD:
+		ret = isp_k_raw_afm_spsmd_cal_mode(param);
+		break;
+	case ISP_PRO_RGB_AFM_SEL_FILTER1:
+		ret = isp_k_raw_afm_sel_filter1(param);
+		break;
+	case ISP_PRO_RGB_AFM_SEL_FILTER2:
+		ret = isp_k_raw_afm_sel_filter2(param);
+		break;
+	case ISP_PRO_RGB_AFM_SOBEL_TYPE:
+		ret = isp_k_raw_afm_sobel_type(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_TYPE:
+		ret = isp_k_raw_afm_spsmd_type(param);
+		break;
+	case ISP_PRO_RGB_AFM_SOBEL_THRESHOLD:
+		ret = isp_k_raw_afm_sobel_threshold(param);
+		break;
+	case ISP_PRO_RGB_AFM_SPSMD_THRESHOLD:
+		ret = isp_k_raw_afm_spsmd_threshold(param);
+		break;
+	case ISP_PRO_RGB_AFM_WIN:
+		ret = isp_k_raw_afm_win(param);
+		break;
+	case ISP_PRO_RGB_AFM_WIN_NUM:
+		ret = isp_k_raw_afm_win_num(param);
+		break;
+	default:
+		printk("isp_k_cfg_afm: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_raw_sizer.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_raw_sizer.c
new file mode 100644
index 00000000..9525d9e8
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_raw_sizer.c
@@ -0,0 +1,369 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_raw_sizer_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_bypass: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (bypass) {
+		REG_OWR(ISP_RAW_SIZER_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_RAW_SIZER_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_bpc_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_bpc_bypass: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (bypass) {
+		REG_OWR(ISP_RAW_SIZER_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_RAW_SIZER_PARAM, BIT_1, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_crop_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_crop_bypass: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (bypass) {
+		REG_OWR(ISP_RAW_SIZER_PARAM, BIT_2);
+	} else {
+		REG_MWR(ISP_RAW_SIZER_PARAM, BIT_2, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_crop_src_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size src_size;
+
+	ret = copy_from_user((void *)&src_size, param->property_param, sizeof(src_size));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_crop_src_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (src_size.height & 0xFFFF)
+		| ((src_size.width & 0xFFFF) << 16);
+	REG_WR(ISP_RAW_SIZER_CROP_SRC, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_crop_dest_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size dest_size;
+
+	ret = copy_from_user((void *)&dest_size, param->property_param, sizeof(dest_size));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_crop_dest_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (dest_size.height & 0xFFFF)
+		| ((dest_size.width & 0xFFFF) << 16);
+	REG_WR(ISP_RAW_SIZER_CROP_DST, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_crop_start(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_offset crop_start;
+
+	ret = copy_from_user((void *)&crop_start, param->property_param, sizeof(crop_start));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_crop_start: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (crop_start.y& 0xFFFF)
+		| ((crop_start.x & 0xFFFF) << 16);
+	REG_WR(ISP_RAW_SIZER_CROP_START, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_dest_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size dest_size;
+
+	ret = copy_from_user((void *)&dest_size, param->property_param, sizeof(dest_size));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_dest_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (dest_size.height & 0xFFFF)
+		| ((dest_size.width & 0xFFFF) << 16);
+	REG_WR(ISP_RAW_SIZER_DST, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_bpc_shift_flactor(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t shift = 0;
+
+	ret = copy_from_user((void *)&shift, param->property_param, sizeof(shift));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_bpc_shift_flactor: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_RAW_SIZER_BPC, 0x7, shift);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_bpc_multi_flactor(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t mult_flactor = 0;
+
+	ret = copy_from_user((void *)&mult_flactor, param->property_param, sizeof(mult_flactor));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_bpc_multi_flactor: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_RAW_SIZER_BPC, (0x7 << 4), (mult_flactor << 4));
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_bpc_min_diff(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t min_diff = 0;
+
+	ret = copy_from_user((void *)&min_diff, param->property_param, sizeof(min_diff));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_bpc_multi_flactor: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_RAW_SIZER_BPC, (0xFF << 8), (min_diff << 8));
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_hcoeff(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t coeff[64] ;
+	uint32_t i = 0 ;
+	uint32_t val = 0 ;
+
+	memset(&coeff, 0, sizeof(coeff));
+	ret = copy_from_user((void *)&coeff, param->property_param, sizeof(coeff));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_hcoeff: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	for (i = 0; i < 21; i++) {
+		val = (coeff[i * 3] & 0x1FF)
+			| ((coeff[i * 3 + 1] & 0x1FF) << 9)
+			| ((coeff[i * 3 + 2] & 0x1FF) << 18);
+		REG_WR(ISP_RAW_SIZER_HCOEFF0 + i * 4, val);
+	}
+	val = (coeff[i * 3] & 0x1FF);
+	REG_WR( ISP_RAW_SIZER_HCOEFF0 + i * 4, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_vcoeff(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t coeff[32] ;
+	uint32_t i = 0 ;
+	uint32_t val = 0 ;
+
+	memset(&coeff, 0, sizeof(coeff));
+	ret = copy_from_user((void *)&coeff, param->property_param, sizeof(coeff));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_vcoeff: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	for (i = 0; i < 10; i++) {
+		val = (coeff[i * 3] & 0x1FF)
+			| ((coeff[i * 3 + 1] & 0x1FF) << 9)
+			| ((coeff[i * 3 + 2] & 0x1FF) << 18);
+		REG_WR(ISP_RAW_SIZER_VCOEFF0 + i * 4, val);
+	}
+	val = (coeff[i * 3] & 0x1FF)
+		| ((coeff[i * 3 + 1] & 0x1FF) << 9);
+	REG_WR( ISP_RAW_SIZER_VCOEFF0 + i * 4, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_h_init_para(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_raw_sizer_init_para init_para;
+	uint32_t val = 0 ;
+
+	ret = copy_from_user((void *)&init_para, param->property_param, sizeof(init_para));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_h_init_para: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (init_para.residual_half_wd & 0xFFFF) | ((init_para.half_dst_wd_remain & 0xFFFF) << 16);
+	REG_WR(ISP_RAW_SIZER_INIT_HOR0, val);
+
+	val = (init_para.adv_a_init_residual & 0xFFFF) | ((init_para.adv_b_init_residual & 0xFFFF) << 16);
+	REG_WR(ISP_RAW_SIZER_INIT_HOR1, val);
+
+	val = (init_para.offset_base_incr & 0xFF) | ((init_para.offset_incr_init_a & 0xFF) << 8)
+	| ((init_para.offset_incr_init_b & 0xFF) << 16);
+	REG_WR( ISP_RAW_SIZER_INIT_HOR2, val);
+
+	return ret;
+}
+
+static int32_t isp_k_raw_sizer_v_init_para(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_raw_sizer_init_para init_para;
+	uint32_t val = 0 ;
+
+	ret = copy_from_user((void *)&init_para, param->property_param, sizeof(init_para));
+	if (0 != ret) {
+		printk("isp_k_raw_sizer_v_init_para: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (init_para.residual_half_wd & 0xFFFF) | ((init_para.half_dst_wd_remain & 0xFFFF) << 16);
+	REG_WR(ISP_RAW_SIZER_INIT_VER0, val);
+
+	val = (init_para.adv_a_init_residual & 0xFFFF) | ((init_para.adv_b_init_residual & 0xFFFF) << 16);
+	REG_WR(ISP_RAW_SIZER_INIT_VER1, val);
+
+	val = (init_para.offset_base_incr & 0xFF) | ((init_para.offset_incr_init_a & 0xFF) << 8)
+	| ((init_para.offset_incr_init_b & 0xFF) << 16);
+	REG_WR( ISP_RAW_SIZER_INIT_VER2, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_raw_sizer(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_raw_sizer: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_raw_sizer: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_RAW_SIZER_BYPASS:
+		ret = isp_k_raw_sizer_bypass(param);
+		break;
+	case ISP_PRO_RAW_SIZER_BPC_BYPASS:
+		ret = isp_k_raw_sizer_bpc_bypass(param);
+		break;
+	case ISP_PRO_RAW_SIZER_CROP_BYPASS:
+		ret = isp_k_raw_sizer_crop_bypass(param);
+		break;
+	case ISP_PRO_RAW_SIZER_CROP_SRC:
+		ret = isp_k_raw_sizer_crop_src_size(param);
+		break;
+	case ISP_PRO_RAW_SIZER_CROP_DST:
+		ret = isp_k_raw_sizer_crop_dest_size(param);
+		break;
+	case ISP_PRO_RAW_SIZER_CROP_START:
+		ret = isp_k_raw_sizer_crop_start(param);
+		break;
+	case ISP_PRO_RAW_SIZER_DST:
+		ret = isp_k_raw_sizer_dest_size(param);
+		break;
+	case ISP_PRO_RAW_SIZER_BPC_MULTI:
+		ret = isp_k_raw_sizer_bpc_multi_flactor(param);
+		break;
+	case ISP_PRO_RAW_SIZER_BPC_SHIFT:
+		ret = isp_k_raw_sizer_bpc_shift_flactor(param);
+		break;
+	case ISP_PRO_RAW_SIZER_BPC_MIN_DIFF:
+		ret = isp_k_raw_sizer_bpc_min_diff(param);
+		break;
+	case ISP_PRO_RAW_SIZER_HCOEFF:
+		ret = isp_k_raw_sizer_hcoeff(param);
+		break;
+	case ISP_PRO_RAW_SIZER_VCOEFF:
+		ret = isp_k_raw_sizer_vcoeff(param);
+		break;
+	case ISP_PRO_RAW_SIZER_H_INIT_PARA:
+		ret = isp_k_raw_sizer_h_init_para(param);
+		break;
+	case ISP_PRO_RAW_SIZER_V_INIT_PARA:
+		ret = isp_k_raw_sizer_v_init_para(param);
+		break;
+	default:
+		printk("isp_k_cfg_raw_sizer: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_rgb_gain.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_rgb_gain.c
new file mode 100644
index 00000000..5cc2c554
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_rgb_gain.c
@@ -0,0 +1,69 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_rgb_gain_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_rgb_gain_info_v1 gain_info;
+
+	ret = copy_from_user((void *)&gain_info, param->property_param, sizeof(gain_info));
+	if (0 != ret) {
+		printk("isp_k_rgb_gain_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (gain_info.global_gain & 0xFFFF) << 16;
+	REG_MWR(ISP_RGBG_PARAM, 0xFFFF0000, val);
+
+	val = ((gain_info.r_gain & 0xFFFF) << 16) | (gain_info.b_gain & 0xFFFF);
+	REG_WR(ISP_RGBG_RB, val);
+	val = gain_info.g_gain & 0xFFFF;
+	REG_WR(ISP_RGBG_G, val);
+
+	REG_MWR(ISP_RGBG_PARAM, BIT_0, gain_info.bypass);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_rgb_gain(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_rgb_gain: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_rgb_gain: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_RGB_GAIN_BLOCK:
+		ret = isp_k_rgb_gain_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_rgb_gain: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_rgb_gain2.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_rgb_gain2.c
new file mode 100644
index 00000000..425ac6b1
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_rgb_gain2.c
@@ -0,0 +1,69 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_rgb_gain2_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_rgb_gain2_info gain_info;
+
+	ret = copy_from_user((void *)&gain_info, param->property_param, sizeof(gain_info));
+	if (0 != ret) {
+		printk("isp_k_rgb_gain2_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (gain_info.r_gain & 0xFFF) << 16;
+	REG_MWR(ISP_RGBG2_PARAM, 0xFFF0000, val);
+	val = ((gain_info.b_gain & 0xFFF) << 16) | (gain_info.g_gain & 0xFFF);
+	REG_WR(ISP_RGBG2_GAIN, val);
+
+	val = ((gain_info.r_offset & 0x3FF) << 20) | ((gain_info.g_offset & 0x3FF) << 10) | (gain_info.b_offset & 0x3FF);
+	REG_WR(ISP_RGBG2_OFFSET, val);
+
+	REG_MWR(ISP_RGBG2_PARAM, BIT_0, gain_info.bypass);
+
+	return ret;
+
+}
+
+int32_t isp_k_cfg_rgb_gain2(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_rgb_gain2: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_rgb_gain2: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_RGB_GAIN2_BLOCK:
+		ret = isp_k_rgb_gain2_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_rgb_gain2: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_store.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_store.c
new file mode 100644
index 00000000..2ae73bec
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_store.c
@@ -0,0 +1,101 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_store_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_store_info_v1 store_info;
+
+	memset(&store_info, 0x00, sizeof(store_info));
+
+	ret = copy_from_user((void *)&store_info, param->property_param, sizeof(store_info));
+	if (0 != ret) {
+		printk("isp_k_store_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (store_info.substract) {
+		REG_OWR(ISP_STORE_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_STORE_PARAM, BIT_1, 0);
+	}
+
+	REG_MWR(ISP_STORE_PARAM, 0xF0, (store_info.color_format << 4));
+
+	REG_WR(ISP_STORE_Y_ADDR, store_info.addr.chn0);
+	REG_WR(ISP_STORE_Y_PITCH, store_info.pitch.chn0);
+	REG_WR(ISP_STORE_U_ADDR, store_info.addr.chn1);
+	REG_WR(ISP_STORE_U_PITCH, store_info.pitch.chn1);
+	REG_WR(ISP_STORE_V_ADDR, store_info.addr.chn2);
+	REG_WR(ISP_STORE_V_PITCH, store_info.pitch.chn2);
+
+	if (store_info.bypass) {
+		REG_OWR(ISP_STORE_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_STORE_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_store_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size size = {0, 0};
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
+	if (0 != ret) {
+		printk("isp_k_store_slice_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height& 0xFFFF) << 16) | (size.width & 0xFFFF);
+	REG_WR(ISP_STORE_SLICE_SIZE, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_store(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_store: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_store: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_STORE_BLOCK:
+		ret = isp_k_store_block(param);
+		break;
+	case ISP_PRO_STORE_SLICE_SIZE:
+		ret = isp_k_store_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_store: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_y_delay.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_y_delay.c
new file mode 100644
index 00000000..b735c790
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_y_delay.c
@@ -0,0 +1,63 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_ydelay_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_dev_ydelay_info ydelay_info;
+
+	ret = copy_from_user((void *)&ydelay_info, param->property_param, sizeof(ydelay_info));
+	if (0 != ret) {
+		printk("isp_k_ydelay_block: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	if (ydelay_info.bypass) {
+		REG_OWR(ISP_YDELAY_PARAM, BIT_0);
+	} else {
+		REG_MWR(ISP_YDELAY_PARAM, BIT_0, 0);
+	}
+
+	return ret;
+}
+
+int32_t isp_k_cfg_ydelay(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_ydelay: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_ydelay: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_YDELAY_BLOCK:
+		ret = isp_k_ydelay_block(param);
+		break;
+	default:
+		printk("isp_k_cfg_ydelay: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_y_gamma.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_y_gamma.c
new file mode 100644
index 00000000..cc485740
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_y_gamma.c
@@ -0,0 +1,121 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+
+#define ISP_YUV_YGAMMA_BUF0      0
+#define ISP_YUV_YGAMMA_BUF1      1
+
+static int32_t isp_k_pingpang_yuv_ygamma(struct coordinate_xy *nodes,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t i = 0, j = 0;
+	unsigned long ybuf_addr = 0;
+	struct coordinate_xy *p_nodes = NULL;
+
+	if (!nodes) {
+		ret = -1;
+		printk("isp_k_pingpang_yuv_ygamma: node is null error .\n");
+		return ret;
+	}
+	p_nodes = nodes;
+
+	if (ISP_YUV_YGAMMA_BUF0 == isp_private->yuv_ygamma_buf_id) {
+		ybuf_addr = ISP_YGAMMA_BUF1_CH0;
+		isp_private->yuv_ygamma_buf_id = ISP_YUV_YGAMMA_BUF1;
+	} else {
+		ybuf_addr = ISP_YGAMMA_BUF0_CH0;
+		isp_private->yuv_ygamma_buf_id = ISP_YUV_YGAMMA_BUF0;
+	}
+
+	for (i = 0, j = 0; i < ISP_PINGPANG_YUV_YGAMMA_NUM; i++, j += 4) {
+		REG_WR(ybuf_addr + j, p_nodes[i].node_y & 0xff);
+	}
+
+	if (isp_private->yuv_ygamma_buf_id) {
+		REG_OWR(ISP_YGAMMA_PARAM, BIT_1);
+	} else {
+		REG_MWR(ISP_YGAMMA_PARAM, BIT_1, 0);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_ygamma_block(struct isp_io_param *param,
+	struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t bypass;
+	struct isp_dev_ygamma_info *ygamma_info = (struct isp_dev_ygamma_info *)param->property_param;
+	struct coordinate_xy *nodes = NULL;
+
+	nodes = (struct coordinate_xy *)isp_private->yuv_ygamma_buf_addr;
+	if (!nodes) {
+		ret = -1;
+		printk("isp_k_ygamma_block: alloc memory error.\n");
+		return -1;
+	}
+
+	ret = copy_from_user((void *)&bypass, (void *)&ygamma_info->bypass, sizeof(uint32_t));
+	if (0 != ret) {
+		printk("isp_k_ygamma_block: copy bypass error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	ret = copy_from_user((void *)nodes, (void *)ygamma_info->nodes, ISP_YUV_YGAMMA_BUF_SIZE);
+	if (0 != ret) {
+		printk("isp_k_ygamma_block: copy nodes error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	ret = isp_k_pingpang_yuv_ygamma(nodes, isp_private);
+	if (0 != ret) {
+		printk("isp_k_ygamma_block: pingpang error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+	REG_MWR(ISP_YGAMMA_PARAM, BIT_0, bypass);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_ygamma(struct isp_io_param *param,
+	struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_ygamma: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_ygamma: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_YGAMMA_BLOCK:
+		ret = isp_k_ygamma_block(param, isp_private);
+		break;
+	default:
+		printk("isp_k_cfg_ygamma: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_yiq_aem.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_yiq_aem.c
new file mode 100755
index 00000000..eb23d899
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_yiq_aem.c
@@ -0,0 +1,256 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+#include "isp_drv.h"
+
+static int32_t isp_k_yiq_aem_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_dev_yiq_aem_info_v1 yaem_info;
+
+	memset(&yaem_info, 0x00, sizeof(yaem_info));
+
+	ret = copy_from_user((void *)&yaem_info, param->property_param, sizeof(yaem_info));
+	if (0 != ret) {
+		printk("isp_k_yiq_aem_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_YIQ_AEM_PARAM, BIT_7, yaem_info.ygamma_bypass << 7);
+
+	val = ((yaem_info.gamma_xnode[0] & 0xFF)<<24) | ((yaem_info.gamma_xnode[1] & 0xFF)<<16)
+		| ((yaem_info.gamma_xnode[2] & 0xFF)<<8) | (yaem_info.gamma_xnode[3] & 0xFF);
+	REG_WR(ISP_YIQ_YGAMMA_NODE_X0 , val);
+	val = ((yaem_info.gamma_xnode[4] & 0xFF)<<24) | ((yaem_info.gamma_xnode[5] & 0xFF)<<16)
+		| ((yaem_info.gamma_xnode[6] & 0xFF)<<8) | (yaem_info.gamma_xnode[7] & 0xFF);
+	REG_WR(ISP_YIQ_YGAMMA_NODE_X1 , val);
+
+	val = ((yaem_info.gamma_ynode[0] & 0xFF)<<24) | ((yaem_info.gamma_ynode[1] & 0xFF)<<16)
+		| ((yaem_info.gamma_ynode[2] & 0xFF)<<8) | (yaem_info.gamma_ynode[3] & 0xFF);
+	REG_WR( ISP_YIQ_YGAMMA_NODE_Y0 , val);
+	val = ((yaem_info.gamma_ynode[4] & 0xFF)<<24) | ((yaem_info.gamma_ynode[5] & 0xFF)<<16)
+		| ((yaem_info.gamma_ynode[6] & 0xFF)<<8) | (yaem_info.gamma_ynode[7] & 0xFF);
+	REG_WR(ISP_YIQ_YGAMMA_NODE_Y1 , val);
+	val = ((yaem_info.gamma_ynode[8] & 0xFF)<<24) | ((yaem_info.gamma_ynode[9] & 0xFF)<<16);
+	REG_WR(ISP_YIQ_YGAMMA_NODE_Y2 , val);
+
+	val = ((yaem_info.gamma_node_idx[1]&0x7) << 24) | ((yaem_info.gamma_node_idx[2]&0x7) << 21) |
+			((yaem_info.gamma_node_idx[3]&0x7) << 18) | ((yaem_info.gamma_node_idx[4]&0x7) << 15) |
+			((yaem_info.gamma_node_idx[5]&0x7) << 12) | ((yaem_info.gamma_node_idx[6]&0x7) <<  9) |
+			((yaem_info.gamma_node_idx[7]&0x7) <<  6) | ((yaem_info.gamma_node_idx[8]&0x7) <<  3) |
+			(yaem_info.gamma_node_idx[9]&0x7);
+	REG_WR( ISP_YIQ_YGAMMA_NODE_IDX, val);
+
+	REG_MWR(ISP_YIQ_AEM_PARAM, BIT_0, yaem_info.aem_bypass);
+
+	REG_MWR(ISP_YIQ_AEM_PARAM, BIT_1, yaem_info.aem_mode << 1);
+
+	REG_MWR(ISP_YIQ_AEM_PARAM, 0xF << 2, yaem_info.aem_skip_num << 2);
+
+	val = (yaem_info.offset_x & 0xFFFF) | ((yaem_info.offset_y & 0xFFFF) << 16);
+	REG_WR( ISP_YIQ_AEM_OFFSET, val);
+
+	val = (yaem_info.width& 0x1FF) | ((yaem_info.height& 0x1FF) << 9);
+	REG_WR( ISP_YIQ_AEM_BLK_SIZE, val);
+
+	return ret;
+
+}
+
+static int32_t isp_k_yiq_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size slice_size= {0, 0};
+
+	ret = copy_from_user((void *)&slice_size, param->property_param, sizeof(slice_size));
+	if (0 != ret) {
+		printk("isp_k_ae_skip_num: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (slice_size.width&  0xFFFF) | ((slice_size.height&  0xFFFF) << 16);
+	REG_WR( ISP_YIQ_AEM_SLICE_SIZE, val);
+
+
+	return ret;
+}
+
+static int32_t isp_k_yiq_aem_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_bypass: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_YIQ_AEM_PARAM, BIT_0, bypass);
+	return ret;
+}
+
+static int32_t isp_k_yiq_aem_ygamma_bypass(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t bypass = 0;
+
+	ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
+	if (0 != ret) {
+		printk("isp_k_raw_aem_bypass: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_YIQ_AEM_PARAM, BIT_7, bypass << 7);
+	return ret;
+}
+
+static int32_t isp_k_yiq_aem_statistics(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0, i = 0;
+	uint32_t val = 0;
+	unsigned long addr = 0;
+	struct isp_aem_statistics *yiq_aem_statistics = NULL;
+
+	yiq_aem_statistics = (struct isp_aem_statistics *)isp_private->yiq_aem_buf_addr;
+	if (!yiq_aem_statistics) {
+		ret = -1;
+		printk("isp_k_yiq_aem_statistics: alloc memory error.\n");
+		return -1;
+	}
+
+	addr = ISP_YIQ_AEM_OUTPUT;
+	for (i = 0x00; i < ISP_YIQ_AEM_ITEM; i++) {
+		val = REG_RD(addr);
+		yiq_aem_statistics->val[i]= val & 0x3fffff;
+		addr += 4;
+	}
+
+	ret = copy_to_user(param->property_param, (void*)yiq_aem_statistics, sizeof(struct isp_aem_statistics));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_yiq_aem_statistics: copy error, ret=0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_yiq_aem_skip_num(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t skip_num;
+
+	ret = copy_from_user((void *)&skip_num, param->property_param, sizeof(skip_num));
+	if (0 != ret) {
+		printk("isp_k_yiq_aem_skip_num: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (skip_num & 0xF) << 2;
+	REG_MWR(ISP_YIQ_AEM_PARAM, 0x3C, val);
+
+	return ret;
+}
+
+static int32_t isp_k_yiq_aem_offset(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct img_offset offset;
+
+	ret = copy_from_user((void *)&offset, param->property_param, sizeof(struct img_offset));
+	if (0 != ret) {
+		printk("isp_k_yiq_aem_offset: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((offset.y & 0xFFFF) << 16) | (offset.x & 0xFFFF);
+	REG_WR(ISP_YIQ_AEM_OFFSET, val);
+
+	return ret;
+}
+
+static int32_t isp_k_yiq_aem_blk_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size;
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_yiq_aem_blk_size: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.height & 0x1FF) << 9) | (size.width & 0x1FF);
+	REG_MWR(ISP_YIQ_AEM_BLK_SIZE, 0x3FFFF, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_yiq_aem(struct isp_io_param *param,
+		struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_yiq: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_yiq: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_YIQ_AEM_BLOCK:
+		ret = isp_k_yiq_aem_block(param);
+		break;
+	case ISP_PRO_YIQ_AEM_YGAMMA_BYPASS:
+		ret = isp_k_yiq_aem_ygamma_bypass(param);
+		break;
+	case ISP_PRO_YIQ_AEM_BYPASS:
+		ret = isp_k_yiq_aem_bypass(param);
+		break;
+	case ISP_PRO_YIQ_AEM_STATISTICS:
+		ret = isp_k_yiq_aem_statistics(param, isp_private);
+		break;
+	case ISP_PRO_YIQ_AEM_SKIP_NUM:
+		ret = isp_k_yiq_aem_skip_num(param);
+		break;
+	case ISP_PRO_YIQ_AEM_OFFSET:
+		ret = isp_k_yiq_aem_offset(param);
+		break;
+	case ISP_PRO_YIQ_AEM_BLK_SIZE:
+		ret = isp_k_yiq_aem_blk_size(param);
+		break;
+	case ISP_PRO_YIQ_AEM_SLICE_SIZE:
+		ret = isp_k_yiq_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_yiq: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_yiq_afm.c b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_yiq_afm.c
new file mode 100755
index 00000000..aca98933
--- /dev/null
+++ b/drivers/media/sprd_isp/isp2.0/tshark2/src/isp_k_yiq_afm.c
@@ -0,0 +1,193 @@
+/*
+ * 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/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+#define ISP_AFM_WIN_NUM_V1  25
+
+static int32_t isp_k_yiq_afm_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	int max_num = ISP_AFM_WIN_NUM_V1;
+	struct isp_dev_yiq_afm_info_v1 afm_info;
+
+	memset(&afm_info, 0x00, sizeof(afm_info));
+
+	ret = copy_from_user((void *)&afm_info, param->property_param, sizeof(afm_info));
+	if (0 != ret) {
+		printk("isp_k_yiq_afm_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, BIT_6, afm_info.mode << 6);
+
+	REG_MWR(ISP_COMMON_3A_CTRL0, BIT_0, afm_info.source_pos);
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, 0x1F<<1, (afm_info.shift << 1));
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, 0xF<<7, (afm_info.skip_num << 7));
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, BIT_11, afm_info.skip_num_clear << 11);
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, 0x7<<13, (afm_info.format << 13));
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, BIT_16, afm_info.iir_bypass << 16);
+
+	for (i = 0; i < max_num; i++) {
+		val = ((afm_info.coord[i].start_y <<16) & 0xffff0000)
+				| (afm_info.coord[i].start_x & 0xffff);
+		REG_WR((ISP_YIQ_AFM_WIN_RANGE0 + 4*2*i), val);
+
+		val = ((afm_info.coord[i].end_y <<16) & 0xffff0000)
+			| (afm_info.coord[i].end_x & 0xffff);
+		REG_WR((ISP_YIQ_AFM_WIN_RANGE0 + 4*(2*i+1)), val);
+	}
+
+	for (i = 0; i < 10; i+= 2) {
+		val = (afm_info.IIR_c[i] & 0xFFF) | ((afm_info.IIR_c[i + 1] & 0xFFF) << 16);
+		REG_WR(ISP_YIQ_AFM_COEF0_1 + (i / 2) * 4, val);
+	}
+	val = afm_info.IIR_c[10] & 0xFFF;
+	REG_WR(ISP_YIQ_AFM_COEF10, val);
+
+	REG_MWR(ISP_YIQ_AFM_PARAM, BIT_0, afm_info.bypass);
+
+	return ret;
+
+}
+
+static int32_t isp_k_yiq_afm_statistic(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int i = 0;
+	int max_item = ISP_AFM_WIN_NUM_V1*4;
+	struct isp_yiq_afm_statistic item;
+
+	memset(&item, 0, sizeof(struct isp_yiq_afm_statistic));
+	for (i = 0; i < max_item; i++) {
+		item.val[i] = REG_RD((ISP_YIQ_AFM_LAPLACE0 + 4*i));
+	}
+	ret = copy_to_user(param->property_param, (void*)&item, sizeof(item));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_yiq_afm_statistic: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_yiq_afm_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	struct isp_img_size slice_size= {0, 0};
+
+	ret = copy_from_user((void *)&slice_size, param->property_param, sizeof(slice_size));
+	if (0 != ret) {
+		printk("isp_k_ae_skip_num: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = (slice_size.width&  0xFFFF) | ((slice_size.height&  0xFFFF) << 16);
+	REG_WR( ISP_YIQ_AFM_SLICE_SIZE, val);
+
+
+	return ret;
+}
+
+static int32_t isp_k_yiq_afm_win(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	int i = 0;
+	int max_num = ISP_AFM_WIN_NUM_V1;
+	struct isp_coord coord[ISP_AFM_WIN_NUM_V1];
+	uint32_t val = 0;
+
+
+	memset(coord, 0, sizeof(coord));
+	ret = copy_from_user((void *)&coord, param->property_param, sizeof(coord));
+	if (0 != ret) {
+		printk("isp_k_yiq_afm_win: read copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	for (i = 0; i < max_num; i++) {
+		val = ((coord[i].start_y <<16) & 0xffff0000)
+				| (coord[i].start_x & 0xffff);
+		REG_WR((ISP_YIQ_AFM_WIN_RANGE0 + 4*2*i), val);
+
+		val = ((coord[i].end_y <<16) & 0xffff0000)
+			| (coord[i].end_x & 0xffff);
+		REG_WR((ISP_YIQ_AFM_WIN_RANGE0 + 4*(2*i+1)), val);
+	}
+
+	return ret;
+}
+
+static int32_t isp_k_yiq_afm_win_num(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t num = ISP_AFM_WIN_NUM_V1;
+
+	ret = copy_to_user(param->property_param, (void*)&num, sizeof(num));
+	if (0 != ret) {
+		ret = -1;
+		printk("isp_k_yiq_afm_win_num: copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+	}
+
+	return ret;
+}
+
+
+int32_t isp_k_cfg_yiq_afm(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_afm: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_afm: property_param is null error.\n");
+		return -1;
+	}
+
+	switch (param->property) {
+	case ISP_PRO_YIQ_AFM_BLOCK:
+		ret = isp_k_yiq_afm_block(param);
+		break;
+	case ISP_PRO_YIQ_AFM_SLICE_SIZE:
+		ret = isp_k_yiq_afm_slice_size(param);
+		break;
+	case ISP_PRO_YIQ_AFM_STATISTIC:
+		ret = isp_k_yiq_afm_statistic(param);
+		break;
+	case ISP_PRO_YIQ_AFM_WIN_NUM:
+		ret = isp_k_yiq_afm_win_num(param);
+		break;
+	case ISP_PRO_YIQ_AFM_WIN:
+		ret = isp_k_yiq_afm_win(param);
+		break;
+	default:
+		printk("isp_k_cfg_yiq_afm: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_isp/isp_drv.c b/drivers/media/sprd_isp/isp_drv.c
new file mode 100644
index 00000000..f2d567ce
--- /dev/null
+++ b/drivers/media/sprd_isp/isp_drv.c
@@ -0,0 +1,1800 @@
+/*
+ * 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/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/poll.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/miscdevice.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <linux/clk.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/vmalloc.h>
+//#include <mach/sci.h>
+#include <soc/sprd/sci.h>
+//#include <mach/hardware.h>
+#ifndef CONFIG_64BIT
+#include <soc/sprd/hardware.h>
+#endif
+#include <asm/cacheflush.h>
+#include <video/sprd_isp.h>
+#include "parse_hwinfo.h"
+#include "compat_isp_drv.h"
+#include "isp_drv.h"
+#include "isp_reg.h"
+
+#define ISP_MINOR MISC_DYNAMIC_MINOR
+
+static struct isp_k_private *s_isp_private;
+
+static int isp_wr_addr(struct isp_reg_bits *ptr);
+
+static int32_t isp_block_buf_alloc(struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	uint32_t buf_len = 0;
+
+	buf_len = ISP_REG_BUF_SIZE + ISP_RAW_AE_BUF_SIZE + ISP_FRGB_GAMMA_BUF_SIZE + ISP_YUV_YGAMMA_BUF_SIZE + ISP_RAW_AWB_BUF_SIZE + ISP_YIQ_AEM_BUF_SIZE;
+
+	isp_private->block_buf_addr = (unsigned long)vzalloc(buf_len);
+	if (0 == isp_private->block_buf_addr) {
+		ret = -1;
+		printk("isp_block_buf_alloc: no memory error.\n");
+	} else {
+		isp_private->block_buf_len = buf_len;
+		isp_private->reg_buf_addr = isp_private->block_buf_addr;
+		isp_private->reg_buf_len = ISP_REG_BUF_SIZE;
+		isp_private->raw_aem_buf_addr = isp_private->reg_buf_addr + isp_private->reg_buf_len;
+		isp_private->raw_aem_buf_len = ISP_RAW_AE_BUF_SIZE;
+		isp_private->full_gamma_buf_addr = isp_private->raw_aem_buf_addr + isp_private->raw_aem_buf_len;
+		isp_private->full_gamma_buf_len = ISP_FRGB_GAMMA_BUF_SIZE;
+		isp_private->yuv_ygamma_buf_addr = isp_private->full_gamma_buf_addr + isp_private->full_gamma_buf_len;
+		isp_private->yuv_ygamma_buf_len = ISP_YUV_YGAMMA_BUF_SIZE;
+		isp_private->raw_awbm_buf_addr = isp_private->yuv_ygamma_buf_addr + isp_private->yuv_ygamma_buf_len;
+		isp_private->raw_awbm_buf_len = ISP_RAW_AWB_BUF_SIZE;
+		isp_private->yiq_aem_buf_addr = isp_private->raw_awbm_buf_addr + isp_private->raw_awbm_buf_len;
+		isp_private->yiq_aem_buf_len = ISP_YIQ_AEM_BUF_SIZE;
+	}
+
+	return ret;
+}
+
+static int32_t isp_block_buf_free(struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if ((0x00 != isp_private->block_buf_addr)
+		&& (0x00 != isp_private->block_buf_len)) {
+		vfree((void *)isp_private->block_buf_addr);
+		isp_private->block_buf_addr = 0x00;
+		isp_private->block_buf_len = 0x00;
+		isp_private->reg_buf_addr = 0x00;
+		isp_private->reg_buf_len = 0x00;
+		isp_private->raw_aem_buf_addr = 0x00;
+		isp_private->raw_aem_buf_len = 0x00;
+		isp_private->full_gamma_buf_addr = 0x00;
+		isp_private->full_gamma_buf_len = 0x00;
+		isp_private->yuv_ygamma_buf_addr = 0x00;
+		isp_private->yuv_ygamma_buf_len = 0x00;
+		isp_private->raw_awbm_buf_addr = 0x00;
+		isp_private->raw_awbm_buf_len = 0x00;
+	}
+
+	return ret;
+}
+
+static int32_t isp_yiq_antiflicker_buf_free(struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+
+	if ((0x00 != isp_private->yiq_antiflicker_buf_addr)
+		&& (0x00 != isp_private->yiq_antiflicker_order)) {
+		free_pages(isp_private->yiq_antiflicker_buf_addr, isp_private->yiq_antiflicker_order);
+		isp_private->yiq_antiflicker_buf_addr = 0x00;
+		isp_private->yiq_antiflicker_len = 0x00;
+		isp_private->yiq_antiflicker_order = 0x00;
+	}
+
+	return ret;
+
+}
+
+static int32_t isp_yiq_antiflicker_buf_alloc(struct isp_k_private *isp_private, uint32_t len)
+{
+		int32_t ret = 0x00;
+#ifndef CONFIG_64BIT
+		uint32_t buf = 0x00;
+		void *ptr = NULL;
+#endif
+
+		if (0x00 < len) {
+			isp_private->yiq_antiflicker_len = len;
+			isp_private->yiq_antiflicker_order = get_order(len);
+			isp_private->yiq_antiflicker_buf_addr = (unsigned long)__get_free_pages(GFP_KERNEL | __GFP_COMP, isp_private->yiq_antiflicker_order);
+			if (NULL == (void*)isp_private->yiq_antiflicker_buf_addr) {
+				printk("isp_yiq_antiflicker_buf_alloc: memory error, addr:0x%lx, len:0x%x, order:0x%x.\n",
+					isp_private->yiq_antiflicker_buf_addr,
+					isp_private->yiq_antiflicker_len,
+					isp_private->yiq_antiflicker_order);
+				return -1;
+			}
+#ifndef CONFIG_64BIT
+			ptr = (void*)isp_private->yiq_antiflicker_buf_addr;
+			buf = virt_to_phys((volatile void *)isp_private->yiq_antiflicker_buf_addr);
+
+			dmac_flush_range(ptr, ptr + len);
+			outer_flush_range(__pa(ptr), __pa(ptr) + len);
+#endif
+		}
+
+		return ret;
+
+}
+
+static int32_t isp_b4awb_switch_buf(struct isp_k_private *isp_private)
+{
+	int32_t ret = 0;
+	int32_t i = 0;
+
+	/*first bypass b4awb*/
+	REG_MWR(ISP_BINNING_PARAM, BIT_0, 0x1);
+
+	/*switch buf*/
+	if (isp_private->b4awb_buf[0].buf_flag == 1) {
+		isp_private->b4awb_buf[1].buf_flag = 1;
+		REG_WR(ISP_BINNING_MEM_ADDR, isp_private->b4awb_buf[1].buf_phys_addr);
+		isp_private->b4awb_buf[0].buf_flag = 0;
+	} else if (isp_private->b4awb_buf[1].buf_flag == 1) {
+		isp_private->b4awb_buf[0].buf_flag = 1;
+		REG_WR(ISP_BINNING_MEM_ADDR, isp_private->b4awb_buf[0].buf_phys_addr);
+		isp_private->b4awb_buf[1].buf_flag = 0;
+	}
+
+	/*enable b4awb*/
+	REG_MWR(ISP_BINNING_PARAM, BIT_0, 0x0);
+
+	return ret;
+}
+
+static void isp_read_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
+{
+	uint32_t i = 0;
+	unsigned long reg_val = 0, reg_addr = 0;
+
+	for (i = 0; i < counts; i++) {
+		reg_addr = ISP_BASE_ADDR + reg_bits_ptr[i].reg_addr;
+		reg_val = REG_RD(reg_addr);
+		reg_bits_ptr[i].reg_value = reg_val;
+	}
+}
+
+static void isp_write_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
+{
+	uint32_t i = 0;
+	unsigned long reg_val = 0, reg_addr = 0;
+
+	for (i = 0; i < counts; i++) {
+		reg_addr = reg_bits_ptr[i].reg_addr + ISP_BASE_ADDR;
+		reg_val = reg_bits_ptr[i].reg_value;
+		REG_WR(reg_addr, reg_val);
+	}
+}
+
+static int32_t isp_queue_init(struct isp_queue *queue)
+{
+	if (NULL == queue) {
+		printk("isp_queue_init: queue is null error.\n");
+		return -1;
+	}
+
+	memset(queue, 0x00, sizeof(*queue));
+	queue->write = &queue->node[0];
+	queue->read  = &queue->node[0];
+
+	return 0;
+}
+
+static int32_t isp_queue_write(struct isp_queue *queue, struct isp_node *node)
+{
+	struct isp_node *ori_node = NULL;
+
+	if (NULL == queue || NULL == node) {
+		printk("isp_queue_write: queue or node is null error %p %p\n",
+			queue, node);
+		return -1;
+	}
+
+	ori_node = queue->write;
+
+	*queue->write++ = *node;
+	if (queue->write > &queue->node[ISP_QUEUE_LENGTH-1])
+		queue->write = &queue->node[0];
+
+	if (queue->write == queue->read)
+		queue->write = ori_node;
+
+	return 0;
+}
+
+static int32_t isp_queue_read(struct isp_queue *queue, struct isp_node *node)
+{
+	if (NULL == queue || NULL == node) {
+		printk("isp_queue_read: queue or node is null error %p %p\n",
+			queue, node);
+		return -1;
+	}
+
+	if (queue->read != queue->write) {
+		*node = *queue->read++;
+		if (queue->read > &queue->node[ISP_QUEUE_LENGTH-1])
+			queue->read = &queue->node[0];
+	}
+
+	return 0;
+}
+
+static int32_t isp_set_clk(struct isp_k_file *file, enum isp_clk_sel clk_sel)
+{
+	int32_t ret = 0;
+	char *parent = "clk_256m";
+	struct clk *clk_parent = NULL;
+	struct isp_k_private *isp_private = NULL;
+
+	if (!file) {
+		printk("isp_set_clk: file is null error.\n");
+		return -1;
+	}
+
+	isp_private = file->isp_private;
+	if (!isp_private) {
+		printk("isp_set_clk: isp_private is null error.\n");
+		return -1;
+	}
+
+	switch (clk_sel) {
+	case ISP_CLK_480M:
+		parent = "clk_usbpll";
+		break;
+	case ISP_CLK_384M:
+		parent = "clk_384m";
+		break;
+	case ISP_CLK_312M:
+		parent = "clk_312m";
+		break;
+	case ISP_CLK_256M:
+		parent = "clk_256m";
+		break;
+	case ISP_CLK_128M:
+		parent = "clk_128m";
+		break;
+	case ISP_CLK_48M:
+		parent = "clk_48m";
+		break;
+	case ISP_CLK_76M8:
+		parent = "clk_76p8m";
+		break;
+	case ISP_CLK_NONE:
+		printk("isp_set_clk: close clock %d\n", (int)clk_get_rate(isp_private->clock));
+		if (isp_private->clock) {
+			clk_disable(isp_private->clock);
+			clk_put(isp_private->clock);
+			isp_private->clock = NULL;
+		}
+		return 0;
+	default:
+		parent = "clk_128m";
+		break;
+	}
+
+	if (NULL == isp_private->clock) {
+		isp_private->clock = parse_clk(isp_private->dn, "clk_isp");
+		if (IS_ERR(isp_private->clock)) {
+			printk("isp_set_clk: parse_clk error.\n");
+			return -1;
+		}
+	} else {
+		clk_disable(isp_private->clock);
+	}
+
+	clk_parent = clk_get(NULL, parent);
+	if (IS_ERR(clk_parent)) {
+		printk("isp_set_clk: clk_get error %d\n", (int)clk_parent);
+		return -1;
+	}
+
+	ret = clk_set_parent(isp_private->clock, clk_parent);
+	if(ret){
+		printk("isp_set_clk: clk_set_parent error.\n");
+	}
+
+	ret = clk_enable(isp_private->clock);
+	if (ret) {
+		printk("isp_set_clk: clk_enable error.\n");
+		return -1;
+	}
+
+	return ret;
+}
+
+static int32_t isp_module_rst(struct isp_k_file *file)
+{
+	int32_t ret = 0;
+	struct isp_k_private *isp_private = NULL;
+
+	if (!file) {
+		printk("isp_module_rst: file is null error.\n");
+		return -1;
+	}
+
+	isp_private = file->isp_private;
+	if (!isp_private) {
+		printk("isp_module_rst: isp_private is null error.\n");
+		return -1;
+	}
+
+	if (0x00 != atomic_read(&isp_private->users)) {
+		ret = isp_axi_bus_waiting();
+
+		isp_clr_int();
+
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+
+		sci_glb_clr(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+		sci_glb_clr(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+	}
+
+	return ret;
+}
+
+static int32_t isp_module_eb(struct isp_k_file *file)
+{
+	int32_t ret = 0;
+	struct isp_k_private *isp_private = NULL;
+
+	if (!file) {
+		printk("isp_module_eb: file is null error.\n");
+		return -1;
+	}
+
+	isp_private = file->isp_private;
+	if (!isp_private) {
+		printk("isp_module_eb: isp_private is null error.\n");
+		return -1;
+	}
+
+	if (0x01 == atomic_inc_return(&isp_private->users)) {
+
+		ret = clk_mm_i_eb(isp_private->dn, 1);
+		if (unlikely(0 != ret)) {
+			ret = -1;
+			printk("isp_module_eb: clk_mm_i_eb error.\n");
+		}
+
+	#if defined(CONFIG_MACH_SP7720EA)
+		ret = isp_set_clk(file, ISP_CLK_256M);
+	#elif defined(CONFIG_ARCH_SCX35LT8)
+		ret = isp_set_clk(file, ISP_CLK_480M);
+	#else
+		ret = isp_set_clk(file, ISP_CLK_312M);
+	#endif
+		if (unlikely(0 != ret)) {
+			ret = -1;
+			printk("isp_module_eb: isp_set_clk error.\n");
+		}
+	}
+
+	return ret;
+}
+
+static int32_t isp_module_dis(struct isp_k_file *file)
+{
+	int32_t ret = 0;
+	struct isp_k_private *isp_private = NULL;
+
+	if (!file) {
+		printk("isp_module_dis: file is null error.\n");
+		return -1;
+	}
+
+	isp_private = file->isp_private;
+	if (!isp_private) {
+		printk("isp_module_dis: isp_private is null error.\n");
+		return -1;
+	}
+
+	if (0x00 == atomic_dec_return(&isp_private->users)) {
+
+		ret = isp_set_clk(file, ISP_CLK_NONE);
+		if (unlikely(0 != ret)) {
+			ret = -1;
+			printk("isp_module_dis: isp_set_clk error.\n");
+		}
+
+		ret = clk_mm_i_eb(isp_private->dn, 0);
+		if (unlikely(0 != ret)) {
+			ret = -1;
+			printk("isp_module_dis: close clk_mm_i error.\n");
+		}
+	}
+
+	return ret;
+}
+
+static irqreturn_t isp_isr(int irq, void *dev_id)
+{
+	int32_t ret = 0;
+	unsigned long flag = 0;
+	uint32_t val = 0;
+	struct isp_node node;
+	struct isp_k_file *fd = NULL;
+	struct isp_drv_private *drv_private = NULL;
+	struct timespec ts;
+
+	if (!dev_id) {
+		printk("isp_isr: dev_id is null error.\n");
+		return IRQ_NONE;
+	}
+
+	fd = (struct isp_k_file *)dev_id;
+	drv_private = (struct isp_drv_private *)&fd->drv_private;
+
+	if (!drv_private) {
+		printk("isp_isr: drv_private is null error.\n");
+		return IRQ_NONE;
+	}
+
+	spin_lock_irqsave(&drv_private->isr_lock, flag);
+	memset(&node, 0x00, sizeof(node));
+	ret = isp_get_int_num(&node);
+
+	/*B4AWB INT*/
+	/*if (node.irq_val1 & BIT_18) {
+		isp_b4awb_switch_buf(fd->isp_private);
+	}*/
+
+	ktime_get_ts(&ts);
+	node.time.sec = ts.tv_sec;
+	node.time.usec =  ts.tv_nsec / NSEC_PER_USEC;
+	isp_queue_write((struct isp_queue *)&drv_private->queue, (struct isp_node *)&node);
+	spin_unlock_irqrestore(&drv_private->isr_lock, flag);
+
+	up(&drv_private->isr_done_lock);
+
+	if (ret) {
+		return IRQ_NONE;
+	} else {
+		return IRQ_HANDLED;
+	}
+}
+
+static int32_t isp_register_irq(struct isp_k_file *file)
+{
+	int32_t ret = 0;
+
+	ret = request_irq(ISP_IRQ, isp_isr, IRQF_SHARED, "ISP", (void *)file);
+
+	return ret;
+}
+
+static void isp_unregister_irq(struct isp_k_file *file)
+{
+	free_irq (ISP_IRQ, (void *)file);
+}
+
+static int isp_open (struct inode *node, struct file *file)
+{
+	int ret = 0;
+	struct isp_k_private *isp_private = s_isp_private;//platform_get_drvdata(rot_get_platform_device())
+	struct isp_k_file *fd = NULL;
+
+	if (!file) {
+		ret = -EINVAL;
+		printk("isp_open: file is null error.\n");
+		return ret;
+	}
+
+	if (!isp_private) {
+		ret = -EFAULT;
+		printk("isp_open: isp_private is null, error.\n");
+		return ret;
+	}
+
+	down(&isp_private->device_lock);
+
+	fd = vzalloc(sizeof(*fd));
+	if (!fd) {
+		ret = -ENOMEM;
+		up(&isp_private->device_lock);
+		printk("isp_open: no memory for fd, error.\n");
+		return ret;
+	}
+
+	fd->isp_private = isp_private;
+
+	spin_lock_init(&fd->drv_private.isr_lock);
+	sema_init(&fd->drv_private.isr_done_lock, 0);
+	ret = isp_queue_init(&(fd->drv_private.queue));
+	if (unlikely(0 != ret)) {
+		ret = -EFAULT;
+		vfree(fd);
+		up(&isp_private->device_lock);
+		printk("isp_open: isp_queue_init error.\n");
+		return ret;
+	}
+
+	ret = isp_module_eb(fd);
+	if (unlikely(0 != ret)) {
+		ret = -EIO;
+		printk("isp_open: isp_module_eb error.\n");
+		goto open_exit;
+	}
+
+	ret = isp_module_rst(fd);
+	if (unlikely(0 != ret)) {
+		ret = -EIO;
+		isp_module_dis(fd);
+		printk("isp_open: isp_module_rst error.\n");
+		goto open_exit;
+	}
+
+	ret = isp_register_irq(fd);
+	if (unlikely(0 != ret)) {
+		ret = -EIO;
+		isp_module_dis(fd);
+		printk("isp_open: isp_register_irq error.\n");
+		goto open_exit;
+	}
+
+	file->private_data = fd;
+
+	printk("isp_open: success.\n");
+
+	return ret;
+
+open_exit:
+	vfree(fd);
+	fd = NULL;
+
+	file->private_data = NULL;
+
+	up(&isp_private->device_lock);
+
+	return ret;
+}
+
+static int isp_release (struct inode *node, struct file *file)
+{
+	int ret = 0;
+	struct isp_k_private *isp_private = NULL;
+	struct isp_k_file *fd = NULL;
+
+	if (!file) {
+		ret = -EINVAL;
+		printk("isp_release: file is null error.\n");
+		return ret;
+	}
+
+	fd = file->private_data;
+	if (!fd) {
+		ret = -EFAULT;
+		printk("isp_release: fd is null error.\n");
+		return ret;
+	}
+
+	isp_private = fd->isp_private;
+	if (!isp_private) {
+		printk("isp_release: isp_private is null error.\n");
+		goto fd_free;
+	}
+
+	down(&isp_private->ioctl_lock);
+
+	isp_unregister_irq(fd);
+
+	ret = isp_module_dis(fd);
+
+	up(&isp_private->ioctl_lock);
+
+fd_free:
+	vfree(fd);
+	fd = NULL;
+
+	file->private_data = NULL;
+
+	if (isp_private)
+		up(&isp_private->device_lock);
+
+	printk("isp_release: success.\n");
+
+	return 0;
+}
+
+static long isp_ioctl( struct file *file, unsigned int cmd, unsigned long param)
+{
+	long ret = 0;
+	struct isp_irq irq_param;
+	struct isp_node node;
+	struct isp_reg_param reg_param = {0, 0};
+	struct isp_reg_bits *reg_bits_ptr = NULL;
+	struct isp_k_private *isp_private = NULL;
+	struct isp_drv_private *drv_private = NULL;
+	struct isp_k_file *fd = NULL;
+
+	if (!file) {
+		ret = -EINVAL;
+		printk("isp_ioctl: file is null error.\n");
+		return ret;
+	}
+
+	fd = file->private_data;
+	if (!fd) {
+		ret = - EFAULT;
+		printk("isp_ioctl: private_data is null error.\n");
+		return ret;
+	}
+
+	isp_private = fd->isp_private;
+	if (!isp_private) {
+		ret = -EFAULT;
+		printk("isp_ioctl: isp_private is null error.\n");
+		return ret;
+	}
+
+	drv_private = &fd->drv_private;
+
+	switch (cmd) {
+	case ISP_IO_IRQ:
+	{
+		ret = down_interruptible(&fd->drv_private.isr_done_lock);
+		if (ret) {
+			memset(&irq_param, 0, sizeof(irq_param));
+			irq_param.ret_val = ret;
+			ret = copy_to_user ((void *)param, (void *)&irq_param, sizeof(irq_param));
+			if ( 0 != ret) {
+				printk("isp_ioctl: irq: copy_to_user error ret = %d\n", (uint32_t)ret);
+			}
+			ret = -ERESTARTSYS;
+			return ret;
+		}
+
+		ret = isp_queue_read(&drv_private->queue, &node);
+		if (0 != ret) {
+			ret = -EFAULT;
+			printk("isp_ioctl: isp_queue_read error, ret = 0x%x\n", (uint32_t)ret);
+			return ret;
+		}
+
+		memset(&irq_param, 0, sizeof(irq_param));
+		irq_param.irq_val0 = node.irq_val0;
+		irq_param.irq_val1 = node.irq_val1;
+		irq_param.irq_val2 = node.irq_val2;
+		irq_param.irq_val3 = node.irq_val3;
+		irq_param.reserved = node.reserved;
+		irq_param.time = node.time;
+		ret = copy_to_user ((void *)param, (void *)&irq_param, sizeof(irq_param));
+		if (0 != ret) {
+			ret = -EFAULT;
+			printk("isp_k: ioctl irq: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+		}
+		break;
+	}
+
+	case ISP_IO_READ:
+	{
+		uint32_t buf_size = 0;
+
+		down(&isp_private->ioctl_lock);
+
+		ret = copy_from_user((void *)&reg_param, (void *)param, sizeof(struct isp_reg_param));
+		if ( 0 != ret) {
+			ret = -EFAULT;
+			printk("isp_ioctl: read copy_from_user 0 error, ret = 0x%x\n", (uint32_t)ret);
+			goto io_read_exit;
+		}
+
+		buf_size = reg_param.counts * sizeof(struct isp_reg_bits);
+		if (buf_size > isp_private->reg_buf_len) {
+			ret = -EFAULT;
+			printk("isp_ioctl: read buf len error.\n");
+			goto io_read_exit;
+		}
+
+		reg_bits_ptr = (struct isp_reg_bits *)isp_private->reg_buf_addr;
+		ret = copy_from_user((void *)reg_bits_ptr, (void *)reg_param.reg_param, buf_size);
+		if ( 0 != ret) {
+			ret = -EFAULT;
+			printk("isp_ioctl: read copy_from_user 1 error, ret = 0x%x\n", (uint32_t)ret);
+			goto io_read_exit;
+		}
+
+		isp_read_reg(reg_bits_ptr, reg_param.counts);
+
+		ret = copy_to_user((void *)reg_param.reg_param, (void *)reg_bits_ptr, buf_size);
+		if ( 0 != ret) {
+			ret = -EFAULT;
+			printk("isp_ioctl: read copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
+			goto io_read_exit;
+		}
+
+		io_read_exit:
+		if (reg_bits_ptr) {
+			memset((void *)isp_private->reg_buf_addr, 0x00, buf_size);
+			reg_bits_ptr = NULL;
+		}
+
+		up(&isp_private->ioctl_lock);
+
+		break;
+	}
+
+	case ISP_IO_WRITE:
+	{
+		uint32_t buf_size = 0;
+
+		down(&isp_private->ioctl_lock);
+
+		ret = copy_from_user((void *)&reg_param, (void *)param, sizeof(struct isp_reg_param));
+		if ( 0 != ret) {
+			printk("isp_ioctl: write copy_from_user 0 error, ret = 0x%x\n", (uint32_t)ret);
+			ret = -EFAULT;
+			goto io_write_exit;
+		}
+
+		buf_size = reg_param.counts * sizeof(struct isp_reg_bits);
+		if (buf_size > isp_private->reg_buf_len) {
+			ret = -EFAULT;
+			printk("isp_ioctl: write buf len error.\n");
+			goto io_write_exit;
+		}
+
+		reg_bits_ptr = (struct isp_reg_bits *)isp_private->reg_buf_addr;
+		ret = copy_from_user((void *)reg_bits_ptr, (void *)reg_param.reg_param, buf_size);
+		if ( 0 != ret) {
+			ret = -EFAULT;
+			printk("isp_ioctl: write copy_from_user 1 error, ret = 0x%x\n", (uint32_t)ret);
+			goto io_write_exit;
+		}
+
+		isp_write_reg(reg_bits_ptr, reg_param.counts);
+
+		io_write_exit:
+		if (reg_bits_ptr) {
+			memset((void *)isp_private->reg_buf_addr, 0x00, buf_size);
+			reg_bits_ptr = NULL;
+		}
+
+		up(&isp_private->ioctl_lock);
+
+		break;
+	}
+
+	case ISP_IO_RST:
+	{
+		down(&isp_private->ioctl_lock);
+
+		ret = isp_module_rst(fd);
+		if (ret) {
+			ret = -EFAULT;
+			printk("isp_ioctl: restet error.\n");
+		}
+
+		up(&isp_private->ioctl_lock);
+
+		break;
+	}
+
+	case ISP_IO_STOP:
+	{
+		unsigned long flag = 0;
+		struct isp_node node;
+
+		down(&isp_private->ioctl_lock);
+
+		isp_en_irq(ISP_INT_CLEAR_MODE);
+
+		spin_lock_irqsave(&drv_private->isr_lock,flag);
+		memset(&node, 0x00, sizeof(node));
+		node.reserved = ISP_INT_EVT_STOP;
+		isp_queue_write((struct isp_queue *)&drv_private->queue, (struct isp_node *)&node);
+		spin_unlock_irqrestore(&drv_private->isr_lock, flag);
+
+		up(&fd->drv_private.isr_done_lock);
+
+		up(&isp_private->ioctl_lock);
+
+		break;
+	}
+
+	case ISP_IO_INT:
+	{
+		struct isp_interrupt int_param;
+
+		down(&isp_private->ioctl_lock);
+
+		ret = copy_from_user((void *)&int_param, (void *)param, sizeof(int_param));
+		if (ret) {
+			ret = -EFAULT;
+			printk("isp_ioctl: int copy_from_user error, ret = %d\n", (uint32_t)ret);
+		}
+
+		if (0 == ret)
+			isp_en_irq(int_param.int_mode);
+
+		up(&isp_private->ioctl_lock);
+
+		break;
+	}
+
+	case ISP_IO_CFG_PARAM:
+		down(&isp_private->ioctl_lock);
+		ret = isp_cfg_param((void *)param, isp_private);
+		up(&isp_private->ioctl_lock);
+		break;
+
+	case ISP_IO_CAPABILITY:
+		ret = isp_capability((void *)param);
+		break;
+
+	case ISP_REG_READ:
+	{
+		int ret;
+		int num;
+		int i;
+		int ISP_REG_NUM = 20467;
+
+		struct isp_reg_bits *ptr = (struct isp_reg_bits *)vmalloc(ISP_REG_NUM * sizeof(struct isp_reg_bits));
+
+		if (NULL == ptr) {
+			printk("isp_ioctl:REG_READ: kmalloc error\n");
+			return -ENOMEM;
+		}
+		memset(ptr, 0, ISP_REG_NUM * sizeof(struct isp_reg_bits));
+
+		num = isp_wr_addr(ptr);
+
+		isp_read_reg(ptr, num);
+
+		ret = copy_to_user((void *)param, (void *)ptr, ISP_REG_NUM * sizeof(struct isp_reg_bits));
+		if ( 0 != ret) {
+			printk("isp_ioctl: REG_READ: copy_to_user error ret = %d\n", (uint32_t)ret);
+			vfree(ptr);
+			return ret;
+			}
+		vfree(ptr);
+		break;
+	}
+
+	default:
+		printk("isp_ioctl: cmd is unsupported, cmd = %x\n", (int32_t)cmd);
+		return -EFAULT;
+	}
+
+	return ret;
+}
+
+static struct file_operations isp_fops = {
+	.owner = THIS_MODULE,
+	.open = isp_open,
+	.unlocked_ioctl = isp_ioctl,
+	.compat_ioctl = compat_isp_ioctl,
+	.release = isp_release,
+};
+
+static struct miscdevice isp_dev = {
+	.minor = ISP_MINOR,
+	.name = "sprd_isp",
+	.fops = &isp_fops,
+};
+
+static int isp_probe(struct platform_device *pdev)
+{
+	int ret = 0;
+	struct isp_k_private *isp_private = NULL;
+
+	isp_private = devm_kzalloc(&pdev->dev, sizeof(*isp_private), GFP_KERNEL);
+	if (!isp_private) {
+		printk("isp_probe: isp_private is null error.\n");
+		return -ENOMEM;
+	}
+
+	atomic_set(&isp_private->users, 0);
+	isp_private->dn = pdev->dev.of_node;
+	isp_private->clock = NULL;
+	sema_init(&isp_private->device_lock, 1);
+	sema_init(&isp_private->ioctl_lock, 1);
+	ret = isp_block_buf_alloc(isp_private);
+	if (ret) {
+		ret = -ENOMEM;
+		devm_kfree(&pdev->dev, isp_private);
+		printk("isp_probe: no memory for isp_private, error.\n");
+		return ret;
+	}
+
+	platform_set_drvdata(pdev, isp_private);
+
+	s_isp_private = isp_private;
+
+	ret = isp_yiq_antiflicker_buf_alloc(isp_private, ISP_YIQ_ANTIFLICKER_SIZE);
+	if (ret) {
+		ret = -ENOMEM;
+		isp_block_buf_free(isp_private);
+		devm_kfree(&pdev->dev, isp_private);
+		platform_set_drvdata(pdev, NULL);
+		printk("isp_probe: no memory for isp lsc buf alloc, error.\n");
+		return ret;
+	}
+
+	ret = misc_register(&isp_dev);
+	if (ret) {
+		ret = -EACCES;
+		isp_yiq_antiflicker_buf_free(isp_private);
+		isp_block_buf_free(isp_private);
+		devm_kfree(&pdev->dev, isp_private);
+		platform_set_drvdata(pdev, NULL);
+		printk("isp_probe: misc_register error.\n");
+	}
+
+	parse_baseaddress(pdev->dev.of_node);
+	printk("isp_probe: success.\n");
+
+	return ret;
+}
+
+static int isp_remove(struct platform_device *dev)
+{
+	struct isp_k_private *isp_private = NULL;
+
+	isp_private = platform_get_drvdata(dev);
+
+	if (isp_private) {
+		isp_yiq_antiflicker_buf_free(isp_private);
+		isp_block_buf_free(isp_private);
+		devm_kfree(&dev->dev, isp_private);
+		platform_set_drvdata(dev, NULL);
+	} else {
+		printk("isp_remove: isp_private is null error.\n");
+	}
+
+	misc_deregister(&isp_dev);
+
+	printk("isp_remove: success.\n");
+
+	return 0;
+}
+
+static const struct of_device_id of_match_table_isp[] = {
+	{ .compatible = "sprd,sprd_isp", },
+	{ },
+};
+
+static struct platform_driver isp_driver = {
+	.probe = isp_probe,
+	.remove = isp_remove,
+	.driver = {
+		.owner = THIS_MODULE,
+		.name = "sprd_isp",
+		.of_match_table = of_match_ptr(of_match_table_isp),
+	},
+};
+
+static int __init isp_init(void)
+{
+	printk ("isp_init: success.\n");
+
+	if (platform_driver_register(&isp_driver)) {
+		printk ("isp_init: platform_driver_register error.\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+static void __exit isp_exit(void)
+{
+	printk ("isp_exit: success.\n");
+
+	platform_driver_unregister(&isp_driver);
+}
+
+static int isp_wr_addr(struct isp_reg_bits *ptr)
+{
+		int i;
+		int sum = 0;
+
+		if(NULL == ptr){
+			printk("isp_wr_addr: ptr\n");
+			return -1;
+		}
+
+		struct isp_reg_bits *ptr_reg = ptr;
+
+		ptr_reg -> reg_addr = 0x0000; /* Interrupt part*/
+		sum++;
+
+		for (i = 0; i < 17; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0014 + i * 0x4;
+			sum++;
+		}
+
+		for (i = 0; i < 4; i++)    /*Fetch*/
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0100 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0114 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 10; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0120 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 4; i++)  /* store*/
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0200 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 10; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0214 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 12; i++) /* dispatch */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0300 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* arbiter */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0400 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 4; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0414 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)  /* axi */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0500 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0514 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;	/* raw sizer */
+		ptr_reg -> reg_addr = 0x0600;
+		sum++;
+
+		for(i = 0; i < 45; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x0614 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 3; i++)  /* common */
+		{
+			ptr_reg++;
+            ptr_reg -> reg_addr = 0x0700 + i * 0x4;
+			sum++;
+        }
+
+		for(i = 0; i < 16; i++)
+        {
+            ptr_reg++;
+            ptr_reg -> reg_addr = 0x0714 + i * 0x4;
+			sum++;
+        }
+
+		for(i = 0; i < 2; i++) /* global gain */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1000 + i * 0x14;
+			sum++;
+		}
+
+		ptr_reg++;  /* BLC */
+		ptr_reg -> reg_addr = 0x1100;
+		sum++;
+
+		for(i = 0; i < 3; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1114 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;  /* RGBG */
+		ptr_reg -> reg_addr = 0x1200;
+		sum++;
+
+		for(i = 0; i < 3; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1214 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* PWD */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1300 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 11; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1314 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;  /* NLC */
+		ptr_reg -> reg_addr = 0x1400;
+		sum++;
+
+		for(i = 0; (ptr_reg->reg_addr) < 0x14b0; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1414 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;  /* lens shading calibration */
+		ptr_reg -> reg_addr = 0x1500;
+		sum++;
+
+		for(i = 0; i < 15; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1514 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;  /* binning */
+		ptr_reg -> reg_addr = 0x1600;
+		sum++;
+
+		for(i = 0; i < 3; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1614 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;  /* AWBM */
+		ptr_reg -> reg_addr = 0x1700;
+		sum++;
+
+		for(i = 0; i < 34; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1714 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x17A0 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++; /* AWBC */
+		ptr_reg -> reg_addr = 0x1800;
+		sum++;
+
+		for(i = 0; i < 14; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1814 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++; /* AEM */
+		ptr_reg -> reg_addr = 0x1900;
+		sum++;
+
+		for(i = 0; i < 4; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1914 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++; /* BPC */
+		ptr_reg -> reg_addr = 0x1A00;
+		sum++;
+
+		for(i = 0; i < 14; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1A14 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++; /* GRGB */
+		ptr_reg -> reg_addr = 0x1B00;
+		sum++;
+
+		for(i = 0; i < 2; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1B14 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++; /* BDN */
+		ptr_reg -> reg_addr = 0x1C00;
+		sum++;
+
+		for(i = 0; i < 101; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1C14 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 7; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1DA8 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;  /* RGBG2 */
+		ptr_reg -> reg_addr = 0x1E00;
+		sum++;
+
+		for(i = 0; i < 3; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1E14 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;  /* 1d lnc */
+		ptr_reg -> reg_addr = 0x1F00;
+		sum++;
+
+		for(i = 0; i < 19; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1F14 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;  /* NLM VST IVST */
+		ptr_reg -> reg_addr = 0x2014;
+		sum++;
+
+		ptr_reg++;
+		ptr_reg -> reg_addr = 0x2214;
+		sum++;
+
+		for(i = 0; i < 3; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x2100 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 35; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x2114 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;  /* CFA: clolor filter array */
+		ptr_reg -> reg_addr = 0x3000;
+		sum++;
+
+		for(i = 0; i < 7; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3014 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)  /* CMC */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3100 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 5; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3114 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 5; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x312C + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)  /* GAMMA */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3300 + i * 0x14;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)  /* Color matrix correction for 8 bits */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3500 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 16; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3514 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* CT: Color transformation */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3600 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;
+		ptr_reg -> reg_addr = 0x3614;
+		sum++;
+
+		for(i = 0; i < 2; i++)  /* CCE: clolor conversion enhancement */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3700 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 13; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3714 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)  /* HSV */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3800 + i * 0x14;
+			sum++;
+		}
+
+		ptr_reg++; /* Radial CSC */
+		ptr_reg -> reg_addr = 0x3900;
+		sum++;
+
+		for(i = 0; i < 14; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3914 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)  /* ISP_PRECNRNEW */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3A00 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 4; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3A14 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++; /* ISP_PSTRZ */
+		ptr_reg -> reg_addr = 0x3B00;
+		sum++;
+
+		for(i = 0; i < 9; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3B14 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* AFM: auto focus monitor */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3C00 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 105; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x3C14 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;  /* YIQ AEM */
+		ptr_reg -> reg_addr = 0x4100;
+		sum++;
+
+		for(i = 0; i < 10; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x4114 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* ANTI FLICKER */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x4200 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 4; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x4214 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* YIQ AFM */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x4300 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 158; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x4314 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* Pre-CDN */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5000 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 19; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5014 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* Pre-Filter */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5100 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5114 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)  /* Brightness */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5300 + i * 0x14;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)  /* Contrast */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5400 + i * 0x14;
+			sum++;
+		}
+
+		ptr_reg++; /* HIST: histogram */
+		ptr_reg -> reg_addr = 0x5500;
+		sum++;
+
+		for(i = 0; i < 5; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5514 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++; /* HIST2 */
+		ptr_reg -> reg_addr = 0x5600;
+		sum++;
+
+		for(i = 0; i < 9; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5614 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++; /* AUTOCONT: auto contrat adjustment */
+		ptr_reg -> reg_addr = 0x5700;
+		sum++;
+
+		for(i = 0; i < 2; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5714 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* cdn */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5800 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 18; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5814 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++; /* edge */
+		ptr_reg -> reg_addr = 0x5900;
+		sum++;
+
+		for(i = 0; i < 12; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5914 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* emboss */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5A00 + i * 0x14;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5A00 + i * 0x14;
+			sum++;
+		}
+
+		ptr_reg++; /* CSS */
+		ptr_reg -> reg_addr = 0x5B00;
+		sum++;
+
+		for(i = 0; i < 10; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5B14 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* csa */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5C00 + i * 0x14;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* hua */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5D00 + i * 0x14;
+			sum++;
+		}
+
+		ptr_reg++; /* post-cdn */
+		ptr_reg -> reg_addr = 0x5E00;
+		sum++;
+
+		for(i = 0; i < 29; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x5E14 + i * 0x4;
+			sum++;
+		}
+
+		ptr_reg++;
+		ptr_reg -> reg_addr = 0x5F14;
+		sum++;
+
+		for(i = 0; i < 2; i++) /* ygamma */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x6000 + i * 0x14;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* ydelay */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x6100 + i * 0x14;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++) /* iircnr */
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x6400 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 16; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x6414 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 2; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x2000 + i * 0x54;
+			sum++;
+		}
+
+		for(i = 0; (ptr_reg->reg_addr) < 0x153fc; i++) // isp v memory1: awbm; isp v memory2:aem
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x10000 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; (ptr_reg->reg_addr) < 0x163fc; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x16000 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; (ptr_reg->reg_addr) < 0x17b60; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x17000 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; (ptr_reg->reg_addr) < 0x185a0; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x18000 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; (ptr_reg->reg_addr) < 0x1b200; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x19000 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 3; i++)
+		{
+			int addr_n;
+			int addr_base = 0x1c000 + i * 0x1000;
+			for(addr_n = 0; (ptr_reg->reg_addr) < (addr_base + 0x200); addr_n++)
+			{
+				ptr_reg++;
+				ptr_reg -> reg_addr = addr_base + addr_n * 0x4;
+				sum++;
+			}
+		}
+
+		for(i = 0; (ptr_reg->reg_addr) < 0x20b60; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x1f000 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; (ptr_reg->reg_addr) < 0x215a0; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x21000 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; (ptr_reg->reg_addr) < 0x24200; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x22000 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; i < 3; i++)
+		{
+			int addr_n;
+			int addr_base = 0x25000 + i * 0x1000;
+			for(addr_n = 0; (ptr_reg->reg_addr) < (addr_base + 0x200); addr_n++)
+			{
+				ptr_reg++;
+				ptr_reg -> reg_addr = addr_base + addr_n * 0x4;
+				sum++;
+			}
+		}
+
+		for(i = 0; (ptr_reg->reg_addr) < 0x2b2fc; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x28000 + i * 0x4;
+			sum++;
+		}
+
+		for(i = 0; (ptr_reg->reg_addr) < 0x2e2fc; i++)
+		{
+			ptr_reg++;
+			ptr_reg -> reg_addr = 0x2C000 + i * 0x4;
+			sum++;
+		}
+
+		return sum;
+}
+
+module_init(isp_init);
+module_exit(isp_exit);
+MODULE_DESCRIPTION("Isp Driver");
+MODULE_LICENSE("GPL");