From 8e4bff4cab0ddac6060645b0715210484d02ff40 Mon Sep 17 00:00:00 2001
From: Yuval Adam <_@yuv.al>
Date: Wed, 30 Aug 2017 08:25:59 +0000
Subject: Initial file dump from open source release

---
 .../media/sprd_isp/isp2.0/pike/src/isp_cfg_param.c | 133 +++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_1d_lsc.c  | 146 ++++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_2d_lsc.c  | 537 +++++++++++++++++++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_aca.c |  78 +++
 .../sprd_isp/isp2.0/pike/src/isp_k_anti_flicker.c  | 155 ++++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_arbiter.c | 177 +++++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_awb.c | 191 ++++++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_bdn.c | 121 +++++
 .../sprd_isp/isp2.0/pike/src/isp_k_binning4awb.c   | 231 +++++++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_blc.c |  66 +++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_bpc.c | 101 ++++
 .../sprd_isp/isp2.0/pike/src/isp_k_brightness.c    |  67 +++
 .../sprd_isp/isp2.0/pike/src/isp_k_capability.c    | 195 ++++++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cce.c | 147 ++++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cdn.c | 109 +++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cfa.c |  90 ++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_cmc10.c   |  93 ++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_cmc8.c    |  92 ++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_common.c  | 411 ++++++++++++++++
 .../sprd_isp/isp2.0/pike/src/isp_k_contrast.c      |  67 +++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_csa.c |  68 +++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_csc.c | 114 +++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_css.c | 112 +++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_ct.c  |  92 ++++
 .../sprd_isp/isp2.0/pike/src/isp_k_dispatch.c      | 143 ++++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_edge.c    | 128 +++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_emboss.c  |  74 +++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_fetch.c   | 127 +++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_gamma.c   | 143 ++++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_grgb.c    |  70 +++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hdr.c | 142 ++++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_hist.c    | 131 +++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_hist2.c   |  95 ++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hsv.c |  95 ++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hua.c |  68 +++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_isr.c | 101 ++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_nlc.c |  83 ++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_nlm.c | 202 ++++++++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pgg.c |  67 +++
 .../sprd_isp/isp2.0/pike/src/isp_k_post_cdn.c      | 129 +++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_pre_cdn.c | 135 ++++++
 .../sprd_isp/isp2.0/pike/src/isp_k_pre_cdn_rgb.c   |  73 +++
 .../sprd_isp/isp2.0/pike/src/isp_k_prefilter.c     |  73 +++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_pstrz.c   |  71 +++
 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pwd.c | 123 +++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_raw_aem.c | 255 ++++++++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_raw_afm.c | 497 +++++++++++++++++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_rgb2y.c   |  62 +++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_rgb_afm.c | 415 ++++++++++++++++
 .../sprd_isp/isp2.0/pike/src/isp_k_rgb_gain.c      |  69 +++
 .../sprd_isp/isp2.0/pike/src/isp_k_rgb_gain2.c     |  67 +++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_store.c   | 101 ++++
 .../sprd_isp/isp2.0/pike/src/isp_k_uv_prefilter.c  |  68 +++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_y_delay.c |  63 +++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_y_gamma.c | 133 +++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_yiq_aem.c | 121 +++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_yiq_afm.c | 120 +++++
 .../media/sprd_isp/isp2.0/pike/src/isp_k_yuv_nlm.c | 135 ++++++
 58 files changed, 7972 insertions(+)
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_cfg_param.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_1d_lsc.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_2d_lsc.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_aca.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_anti_flicker.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_arbiter.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_awb.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_bdn.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_binning4awb.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_blc.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_bpc.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_brightness.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_capability.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cce.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cdn.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cfa.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cmc10.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_cmc8.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_common.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_contrast.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_csa.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_csc.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_css.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_ct.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_dispatch.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_edge.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_emboss.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_fetch.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_gamma.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_grgb.c
 create mode 100755 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hdr.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hist.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hist2.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hsv.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_hua.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_isr.c
 create mode 100755 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_nlc.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_nlm.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pgg.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_post_cdn.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pre_cdn.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pre_cdn_rgb.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_prefilter.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pstrz.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_pwd.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_raw_aem.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_raw_afm.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb2y.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_afm.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_gain.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_rgb_gain2.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_store.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_uv_prefilter.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_y_delay.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_y_gamma.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yiq_aem.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yiq_afm.c
 create mode 100644 drivers/media/sprd_isp/isp2.0/pike/src/isp_k_yuv_nlm.c

(limited to 'drivers/media/sprd_isp/isp2.0/pike/src')

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
-- 
cgit v1.3.1