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

---
 drivers/media/sprd_sensor/Makefile                 |   14 +
 drivers/media/sprd_sensor/compat_sensor_drv_k.c    |  213 +++
 drivers/media/sprd_sensor/compat_sensor_drv_k.h    |   25 +
 drivers/media/sprd_sensor/csi2/csi_access.c        |   26 +
 drivers/media/sprd_sensor/csi2/csi_access.h        |   17 +
 drivers/media/sprd_sensor/csi2/csi_api.c           |  730 +++++++
 drivers/media/sprd_sensor/csi2/csi_api.h           |   79 +
 drivers/media/sprd_sensor/csi2/csi_api_null.c      |  130 ++
 drivers/media/sprd_sensor/csi2/csi_driver.c        |  502 +++++
 drivers/media/sprd_sensor/csi2/csi_driver.h        |  136 ++
 drivers/media/sprd_sensor/csi2/csi_log.c           |  177 ++
 drivers/media/sprd_sensor/csi2/csi_log.h           |   78 +
 drivers/media/sprd_sensor/csi2/csi_system.c        |   84 +
 drivers/media/sprd_sensor/csi2/csi_system.h        |   28 +
 drivers/media/sprd_sensor/csi2/csi_types.h         |   15 +
 drivers/media/sprd_sensor/csi2/usc28c_init.c       |  281 +++
 drivers/media/sprd_sensor/otp/Makefile             |    6 +
 drivers/media/sprd_sensor/otp/sensor_otp.c         |   23 +
 drivers/media/sprd_sensor/otp/sensor_otp.h         |   18 +
 .../sprd_sensor/otp/sensor_otp_coreprime3g_ve.c    |  268 +++
 drivers/media/sprd_sensor/power/Makefile           |   22 +
 drivers/media/sprd_sensor/power/sensor_power.c     |   40 +
 drivers/media/sprd_sensor/power/sensor_power.h     |   21 +
 .../power/sensor_power_coreprime3g_ve.c            |  159 ++
 .../sprd_sensor/power/sensor_power_coreprimelite.c |  160 ++
 .../power/sensor_power_grandprime3g_ve.c           |  247 +++
 .../power/sensor_power_grandprime_dtv.c            |  247 +++
 .../sprd_sensor/power/sensor_power_sharkl_t8.c     |  247 +++
 .../sprd_sensor/power/sensor_power_sharkls_z3lte.c |  160 ++
 .../sprd_sensor/power/sensor_power_tshark2tabe.c   |  143 ++
 drivers/media/sprd_sensor/sensor_drv_k.c           | 2005 ++++++++++++++++++++
 drivers/media/sprd_sensor/sensor_drv_sprd.h        |   93 +
 32 files changed, 6394 insertions(+)
 create mode 100644 drivers/media/sprd_sensor/Makefile
 create mode 100644 drivers/media/sprd_sensor/compat_sensor_drv_k.c
 create mode 100644 drivers/media/sprd_sensor/compat_sensor_drv_k.h
 create mode 100644 drivers/media/sprd_sensor/csi2/csi_access.c
 create mode 100644 drivers/media/sprd_sensor/csi2/csi_access.h
 create mode 100644 drivers/media/sprd_sensor/csi2/csi_api.c
 create mode 100644 drivers/media/sprd_sensor/csi2/csi_api.h
 create mode 100755 drivers/media/sprd_sensor/csi2/csi_api_null.c
 create mode 100644 drivers/media/sprd_sensor/csi2/csi_driver.c
 create mode 100644 drivers/media/sprd_sensor/csi2/csi_driver.h
 create mode 100644 drivers/media/sprd_sensor/csi2/csi_log.c
 create mode 100644 drivers/media/sprd_sensor/csi2/csi_log.h
 create mode 100644 drivers/media/sprd_sensor/csi2/csi_system.c
 create mode 100644 drivers/media/sprd_sensor/csi2/csi_system.h
 create mode 100644 drivers/media/sprd_sensor/csi2/csi_types.h
 create mode 100644 drivers/media/sprd_sensor/csi2/usc28c_init.c
 create mode 100644 drivers/media/sprd_sensor/otp/Makefile
 create mode 100644 drivers/media/sprd_sensor/otp/sensor_otp.c
 create mode 100644 drivers/media/sprd_sensor/otp/sensor_otp.h
 create mode 100644 drivers/media/sprd_sensor/otp/sensor_otp_coreprime3g_ve.c
 create mode 100755 drivers/media/sprd_sensor/power/Makefile
 create mode 100644 drivers/media/sprd_sensor/power/sensor_power.c
 create mode 100644 drivers/media/sprd_sensor/power/sensor_power.h
 create mode 100755 drivers/media/sprd_sensor/power/sensor_power_coreprime3g_ve.c
 create mode 100644 drivers/media/sprd_sensor/power/sensor_power_coreprimelite.c
 create mode 100644 drivers/media/sprd_sensor/power/sensor_power_grandprime3g_ve.c
 create mode 100755 drivers/media/sprd_sensor/power/sensor_power_grandprime_dtv.c
 create mode 100644 drivers/media/sprd_sensor/power/sensor_power_sharkl_t8.c
 create mode 100644 drivers/media/sprd_sensor/power/sensor_power_sharkls_z3lte.c
 create mode 100755 drivers/media/sprd_sensor/power/sensor_power_tshark2tabe.c
 create mode 100755 drivers/media/sprd_sensor/sensor_drv_k.c
 create mode 100644 drivers/media/sprd_sensor/sensor_drv_sprd.h

(limited to 'drivers/media/sprd_sensor')

diff --git a/drivers/media/sprd_sensor/Makefile b/drivers/media/sprd_sensor/Makefile
new file mode 100644
index 00000000..99fff856
--- /dev/null
+++ b/drivers/media/sprd_sensor/Makefile
@@ -0,0 +1,14 @@
+include drivers/media/sprd_dcam/common/Makefile.inc
+
+common-file := csi2/csi_access.o csi2/csi_driver.o csi2/csi_log.o csi2/csi_system.o
+
+sprd_sensor-objs := csi2/csi_api.o
+
+ifeq ($(CONFIG_64BIT),y)
+sprd_sensor-objs += compat_sensor_drv_k.o $(common-file)
+endif
+
+sprd_sensor-objs += sensor_drv_k.o $(common-file)
+obj-y += sprd_sensor.o
+obj-y += power/ otp/
+
diff --git a/drivers/media/sprd_sensor/compat_sensor_drv_k.c b/drivers/media/sprd_sensor/compat_sensor_drv_k.c
new file mode 100644
index 00000000..f17613d4
--- /dev/null
+++ b/drivers/media/sprd_sensor/compat_sensor_drv_k.c
@@ -0,0 +1,213 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/compat.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <video/sensor_drv_k.h>
+#include "compat_sensor_drv_k.h"
+
+//#define DEBUG_COMPAT_SENSOR_DRV
+#ifdef  DEBUG_COMPAT_SENSOR_DRV
+#define COMPAT_SENSOR_PRINT                      printk
+#else
+#define COMPAT_SENSOR_PRINT(...)
+#endif
+
+struct compat_sensor_reg_tab_tag {
+	compat_caddr_t sensor_reg_tab_ptr;
+	uint32_t reg_count;
+	uint32_t reg_bits;
+	uint32_t burst_mode;
+};
+
+struct compat_sensor_i2c_tag {
+	compat_caddr_t i2c_data;
+	uint16_t i2c_count;
+	uint16_t slave_addr;
+};
+
+struct compat_sensor_otp_data_info_tag {
+	uint32_t size;
+	compat_caddr_t data_ptr;
+};
+
+struct compat_sensor_otp_param_tag {
+	uint32_t start_addr;
+	uint32_t len;
+	compat_caddr_t buff;
+	struct compat_sensor_otp_data_info_tag golden;
+	struct compat_sensor_otp_data_info_tag awb;
+	struct compat_sensor_otp_data_info_tag lsc;
+	uint32_t type;
+};
+
+#define COMPAT_SENSOR_IO_I2C_WRITE_REGS    _IOW(SENSOR_IOC_MAGIC,  14, struct compat_sensor_reg_tab_tag)
+#define COMPAT_SENSOR_IO_I2C_WRITE_EXT     _IOW(SENSOR_IOC_MAGIC,  17, struct compat_sensor_i2c_tag)
+#define COMPAT_SENSOR_IO_I2C_READ_EXT      _IOWR(SENSOR_IOC_MAGIC, 20, struct compat_sensor_i2c_tag)
+#define COMPAT_SENSOR_IO_READ_OTPDATA      _IOWR(SENSOR_IOC_MAGIC, 254,struct compat_sensor_otp_param_tag)
+
+static long compat_get_sensor_reg_tab_tag(
+			struct compat_sensor_reg_tab_tag __user *data32,
+			struct sensor_reg_tab_tag __user *data)
+{
+	compat_caddr_t c;
+	uint32_t i;
+	int err;
+
+	err = get_user(c, &data32->sensor_reg_tab_ptr);
+	err |= put_user(c, &data->sensor_reg_tab_ptr);
+	err |= get_user(i, &data32->reg_count);
+	err |= put_user(i, &data->reg_count);
+	err |= get_user(i, &data32->reg_bits);
+	err |= put_user(i, &data->reg_bits);
+	err |= get_user(i, &data32->burst_mode);
+	err |= put_user(i, &data->burst_mode);
+
+	COMPAT_SENSOR_PRINT("sensor_reg_tab_ptr: %p reg_count: %d reg_bits: %d burst_mode: %d\n",
+		data->sensor_reg_tab_ptr, data->reg_count, data->reg_bits, data->burst_mode);
+	return err;
+}
+
+
+static long compat_get_sensor_i2c_tag(
+			struct compat_sensor_i2c_tag __user *data32,
+			struct sensor_i2c_tag __user *data)
+{
+	compat_caddr_t c;
+	uint16_t i;
+	int err;
+
+	err = get_user(c, &data32->i2c_data);
+	err |= put_user(c, &data->i2c_data);
+	err |= get_user(i, &data32->i2c_count);
+	err |= put_user(i, &data->i2c_count);
+	err |= get_user(i, &data32->slave_addr);
+	err |= put_user(i, &data->slave_addr);
+
+	COMPAT_SENSOR_PRINT("i2c_data: %p i2c_count: %d slave_addr: %d\n",
+		data->i2c_data, data->i2c_count, data->slave_addr);
+	return err;
+}
+
+static long compat_get_otp_param_tag(
+			struct compat_sensor_otp_param_tag __user *data32,
+			struct _sensor_otp_param_tag __user *data)
+{
+	compat_caddr_t c;
+	uint32_t i;
+	int err;
+
+	err = get_user(i, &data32->start_addr);
+	err |= put_user(i, &data->start_addr);
+	err |= get_user(i, &data32->len);
+	err |= put_user(i, &data->len);
+	err |= get_user(c, &data32->buff);
+	err |= put_user(c, &data->buff);
+
+	err |= get_user(c, &data32->awb.data_ptr);
+	err |= put_user(c, &data->awb.data_ptr);
+	err |= get_user(i, &data32->awb.size);
+	err |= put_user(i, &data->awb.size);
+
+	err |= get_user(c, &data32->lsc.data_ptr);
+	err |= put_user(c, &data->lsc.data_ptr);
+	err |= get_user(i, &data32->lsc.size);
+	err |= put_user(i, &data->lsc.size);
+	return err;
+}
+
+long compat_sensor_k_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+	int compatible_arg = 1;
+	long err = 0;
+
+	if (!filp->f_op || !filp->f_op->unlocked_ioctl)
+		return -ENOTTY;
+
+	switch (cmd) {
+	case COMPAT_SENSOR_IO_I2C_WRITE_REGS:
+	{
+		struct compat_sensor_reg_tab_tag __user *data32;
+		struct sensor_reg_tab_tag __user *data;
+
+		data32 = compat_ptr(arg);
+		data = compat_alloc_user_space(sizeof(*data));
+		if (NULL == data)
+			return -EFAULT;
+
+		err = compat_get_sensor_reg_tab_tag(data32, data);
+		if (err)
+			return err;
+		return filp->f_op->unlocked_ioctl(filp, SENSOR_IO_I2C_WRITE_REGS,
+								(unsigned long)data);
+	}
+
+	case COMPAT_SENSOR_IO_I2C_WRITE_EXT:
+	{
+		struct compat_sensor_i2c_tag __user *data32;
+		struct sensor_i2c_tag __user *data;
+
+		data32 = compat_ptr(arg);
+		data = compat_alloc_user_space(sizeof(*data));
+		if (NULL == data)
+			return -EFAULT;
+
+		err = compat_get_sensor_i2c_tag(data32, data);
+		if (err)
+			return err;
+		return filp->f_op->unlocked_ioctl(filp, SENSOR_IO_I2C_WRITE_EXT,
+								(unsigned long)data);
+	}
+
+	case COMPAT_SENSOR_IO_I2C_READ_EXT:
+	{
+		struct compat_sensor_i2c_tag __user *data32;
+		struct sensor_i2c_tag __user *data;
+
+		data32 = compat_ptr(arg);
+		data = compat_alloc_user_space(sizeof(*data));
+		if (NULL == data)
+			return -EFAULT;
+
+		err = compat_get_sensor_i2c_tag(data32, data);
+		if (err)
+			return err;
+		return filp->f_op->unlocked_ioctl(filp, SENSOR_IO_I2C_READ_EXT,
+								(unsigned long)data);
+	}
+
+	case COMPAT_SENSOR_IO_READ_OTPDATA:
+	{
+		struct compat_sensor_otp_param_tag __user *data32;
+		SENSOR_OTP_PARAM_T __user *data;
+
+		printk("SENSOR: ioctl COMPAT_SENSOR_IO_READ_OTPDATA \n");
+		data32 = compat_ptr(arg);
+		data = compat_alloc_user_space(sizeof(*data));
+		if (NULL == data)
+			return -EFAULT;
+
+		err = compat_get_otp_param_tag(data32, data);
+		if (err)
+			return err;
+		return filp->f_op->unlocked_ioctl(filp, SENSOR_IO_READ_OTPDATA,
+								(unsigned long)data);
+	}
+	break;
+
+	default:
+		return filp->f_op->unlocked_ioctl(filp, cmd,
+						(unsigned long)compat_ptr(arg));
+	}
+}
diff --git a/drivers/media/sprd_sensor/compat_sensor_drv_k.h b/drivers/media/sprd_sensor/compat_sensor_drv_k.h
new file mode 100644
index 00000000..9cededeb
--- /dev/null
+++ b/drivers/media/sprd_sensor/compat_sensor_drv_k.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef _COMPAT_IMG_SCALE_H_
+#define _COMPAT_IMG_SCALE_H_
+
+#if IS_ENABLED(CONFIG_COMPAT)
+
+long compat_sensor_k_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
+
+#else
+
+#define compat_sensor_k_ioctl  NULL
+
+#endif /* CONFIG_COMPAT */
+#endif
diff --git a/drivers/media/sprd_sensor/csi2/csi_access.c b/drivers/media/sprd_sensor/csi2/csi_access.c
new file mode 100644
index 00000000..9a37476f
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_access.c
@@ -0,0 +1,26 @@
+/*
+ *  access.c
+ *
+ *  Created on: Jun 25, 2010
+ *      Author: klabadi & dlopo
+ */
+#include "csi_types.h"
+#include "csi_access.h"
+#include "csi_log.h"
+
+static u32 * access_base_addr = 0;
+int access_init(u32 * base_addr)
+{
+    access_base_addr = base_addr;
+    return 0;
+}
+
+u32 access_read(u16 addr)
+{
+    return access_base_addr[addr];
+}
+
+void access_write(u32 data, u16 addr)
+{
+    access_base_addr[addr] = data;
+}
\ No newline at end of file
diff --git a/drivers/media/sprd_sensor/csi2/csi_access.h b/drivers/media/sprd_sensor/csi2/csi_access.h
new file mode 100644
index 00000000..6c9e8ee9
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_access.h
@@ -0,0 +1,17 @@
+/*
+ * access.h
+ *
+ *  Created on: Jun 25, 2010
+ *      Author: klabadi & dlopo
+ */
+
+#ifndef ACCESS_H_
+#define ACCESS_H_
+
+#include <linux/types.h>
+int access_init(u32 * base_addr);
+u32 access_read(u16 addr);
+
+void access_write(u32 data, u16 addr);
+
+#endif /* ACCESS_H_ */
\ No newline at end of file
diff --git a/drivers/media/sprd_sensor/csi2/csi_api.c b/drivers/media/sprd_sensor/csi2/csi_api.c
new file mode 100644
index 00000000..12af2bf6
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_api.c
@@ -0,0 +1,730 @@
+#include <linux/kernel.h>
+#include <linux/semaphore.h>
+#include <linux/delay.h>
+#include <linux/vmalloc.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+#include <soc/sprd/sci_glb_regs.h>
+
+#ifndef CONFIG_64BIT
+#include <mach/irqs.h>
+#include <soc/sprd/globalregs.h>
+#include <soc/sprd/hardware.h>
+#else
+#include <soc/sprd/irqs.h>
+#endif
+#include "parse_hwinfo.h"
+#include <soc/sprd/sci.h>
+
+#include "csi_api.h"
+#include "csi_log.h"
+
+#define CSI2_EB              (SPRD_MMAHB_BASE)
+#define CSI2_EB_BIT          (1 << 4)
+#define CSI2_RST             (SPRD_MMAHB_BASE + 0x4)
+#define CSI2_RST_BIT         (1 << 5)
+
+#if defined(CONFIG_SC_FPGA) && defined(CONFIG_MACH_SP7720EA)
+extern void usc28c_csi_init(void);
+#endif
+void csi_api_event1_handler(int irq, void *handle);
+void csi_api_event2_handler(int irq, void *handle);
+
+
+static void csi_phy_power_down(u32 phy_id, u32 is_eb)
+{
+#if IS_ENABLED(VERSION3T) || IS_ENABLED(VERSION3D)
+	/*bit0: phya ; bit1: phyb*/
+	if (is_eb) {
+		if (0x03 == (phy_id & 0x03)) {
+			sci_glb_set(REG_AON_APB_PWR_CTRL, (BIT_CSI0_PHY_PD | BIT_CSI1_PHY_PD));
+		} else {
+			if (0x01 == (phy_id & 0x01)) {
+				sci_glb_set(REG_AON_APB_PWR_CTRL, BIT_CSI0_PHY_PD);
+			}
+
+			if (0x02 == (phy_id & 0x02)) {
+				sci_glb_set(REG_AON_APB_PWR_CTRL, BIT_CSI1_PHY_PD);
+			}
+		}
+	} else {
+		if (0x03 == (phy_id & 0x03)) {
+			sci_glb_clr(REG_AON_APB_PWR_CTRL, (BIT_CSI0_PHY_PD | BIT_CSI1_PHY_PD));
+		} else {
+			if (0x01 == (phy_id & 0x01)) {
+				sci_glb_clr(REG_AON_APB_PWR_CTRL, BIT_CSI0_PHY_PD);
+			}
+
+			if (0x02 == (phy_id & 0x02)) {
+				sci_glb_clr(REG_AON_APB_PWR_CTRL, BIT_CSI1_PHY_PD);
+			}
+		}
+	}
+#elif IS_ENABLED(VERSION3L)
+	/*bit0: phya ; bit1: phyb*/
+	if (is_eb) {
+		if (0x03 == (phy_id & 0x03)) {
+			printk("csi phy erro: scx35l does not support the combination of phya & phyb\n");
+		} else {
+			if (0x01 == (phy_id & 0x01)) {
+				sci_glb_set(REG_AON_APB_PWR_CTRL, (3 << 12));
+			}
+
+			if (0x02 == (phy_id & 0x02)) {
+				sci_glb_set(REG_AON_APB_PWR_CTRL, (3 << 10));
+			}
+		}
+	} else {
+		if (0x03 == (phy_id & 0x03)) {
+			printk("csi phy erro: scx35l does not support the combination of phya & phyb\n");
+		} else {
+			if (0x01 == (phy_id & 0x01)) {
+				sci_glb_clr(REG_AON_APB_PWR_CTRL, (1 << 13));
+				udelay(500);
+				sci_glb_clr(REG_AON_APB_PWR_CTRL, (1 << 12));
+			}
+
+			if (0x02 == (phy_id & 0x02)) {
+				sci_glb_clr(REG_AON_APB_PWR_CTRL, (1 << 11));
+				udelay(500);
+				sci_glb_clr(REG_AON_APB_PWR_CTRL, (1 << 10));
+			}
+		}
+	}
+#endif
+}
+
+static void csi_enable(void)
+{
+	sci_glb_set(CSI2_EB, CSI2_EB_BIT);
+	sci_glb_set(CSI2_RST, CSI2_RST_BIT);
+	udelay(1);
+	sci_glb_clr(CSI2_RST, CSI2_RST_BIT);
+}
+
+int csi_api_malloc(void **handle)
+{
+	int ret = 0;
+	struct csi_context *csi_handle = NULL;
+	csi_handle = (struct csi_context *)vzalloc(sizeof(struct csi_context));
+	if (NULL == handle) {
+		printk("vzalloc fail,no mem");
+		return -1;
+	}
+	csi_handle->g_csi2_irq = 0x12000034;
+	spin_lock_init(&csi_handle->csi2_lock);
+	*handle = csi_handle;
+
+	return ret;
+}
+
+void csi_api_free(void *handle)
+{
+	if (handle != NULL) {
+		vfree(handle);
+		handle = NULL;
+	}
+}
+
+u8 csi_api_init(u32 bps_per_lane, u32 phy_id)
+{
+	csi_error_t e = SUCCESS;
+    u64 base_address = CSI2_BASE;
+
+#if defined(CONFIG_SC_FPGA) && defined(CONFIG_MACH_SP7720EA)
+	usc28c_csi_init();
+#endif
+
+    do {
+		csi_phy_power_down(phy_id, 0);
+		csi_enable();
+		e = csi_init(base_address);
+		if(e != SUCCESS) {
+			LOG_ERROR("Unable to initialise driver");
+			break;
+		}
+		dphy_init(bps_per_lane, phy_id);
+    }while(0);
+
+    return e;
+}
+
+u8 csi_api_start(void *handle)
+{
+	csi_error_t e = SUCCESS;
+	int         ret = 0;
+	struct csi_context *csi_handle = handle;
+
+	if (NULL == handle) {
+		printk("handle null\n");
+		return ERR_UNDEFINED;
+	}
+	do {
+		/* set only one lane (lane 0) as active (ON) */
+		e = csi_set_on_lanes(1);
+		if(e != SUCCESS) {
+			LOG_ERROR("Unable to set lanes");
+			csi_close();
+			break;
+		}
+		LOG_DEBUG("Lane set OK");
+		e = csi_shut_down_phy(0);
+		if(e != SUCCESS) {
+			LOG_ERROR("Unable to bring up PHY");
+			csi_close();
+			break;
+		}
+		LOG_DEBUG("PHY power up OK");
+
+		e = csi_reset_phy();
+		if(e != SUCCESS) {
+			LOG_ERROR("Unable to reset PHY");
+			csi_close();
+			break;
+		}
+		LOG_DEBUG("PHY reset OK");
+
+		e = csi_reset_controller();
+		if(e != SUCCESS) {
+			LOG_ERROR("Unable to reset controller");
+			csi_close();
+			break;
+		}
+		/* MASK all interrupts */
+		csi_event_disable(0xffffffff, 1);
+		csi_event_disable(0xffffffff, 2);
+		ret = request_irq(IRQ_CSI_INT0,
+				(irq_handler_t)csi_api_event1_handler,
+				IRQF_SHARED,
+				"CSI2_0",
+				(void *)csi_handle);
+		if (ret) {
+			e = ERR_UNDEFINED;
+			break;
+		}
+
+		ret = request_irq(IRQ_CSI_INT1,
+				(irq_handler_t)csi_api_event2_handler,
+				IRQF_SHARED,
+				"CSI2_1",
+				(void *)csi_handle);
+		if (ret) {
+			e = ERR_UNDEFINED;
+			break;
+		}
+
+	} while(0);
+
+	return e;
+}
+
+u8 csi_api_close(void *handle, u32 phy_id)
+{
+	struct csi_context *csi_handle = handle;
+	if (NULL == handle) {
+		printk("handle null\n");
+		return ERR_UNDEFINED;
+	}
+	LOG_DEBUG("exit");
+	csi_api_unregister_all_events(handle);
+	csi_shut_down_phy(1);
+	free_irq(IRQ_CSI_INT0, &csi_handle->g_csi2_irq);
+	free_irq(IRQ_CSI_INT1, &csi_handle->g_csi2_irq);
+	csi_close();
+	csi_phy_power_down(phy_id, 1);
+
+	return SUCCESS;
+}
+
+u8 csi_api_set_on_lanes(u8 no_of_lanes)
+{
+    return csi_set_on_lanes(no_of_lanes);
+}
+
+u8 csi_api_get_on_lanes()
+{
+    return csi_get_on_lanes();
+}
+
+csi_lane_state_t csi_api_get_clk_state()
+{
+    return csi_clk_state();
+}
+
+csi_lane_state_t csi_api_get_lane_state(u8 lane)
+{
+    return csi_lane_module_state(lane);
+}
+
+static u32 csi_api_event_map(u8 event, u8 vc_lane)
+{
+	switch((csi_event_t)(event)) {
+	case ERR_PHY_TX_START:
+		return (0x1 << (event + vc_lane));
+	case ERR_FRAME_BOUNDARY_MATCH:
+		return (0x1 << (event + vc_lane));
+	case ERR_FRAME_SEQUENCE:
+		return (0x1 << (event + vc_lane));
+	case ERR_CRC_DURING_FRAME:
+		return (0x1 << (event + vc_lane));
+	case ERR_LINE_CRC:
+		return (0x1 << (24 + vc_lane));
+	case ERR_DOUBLE_ECC:
+		return (0x1 << 28);
+	case ERR_PHY_ESCAPE_ENTRY:
+		return (0x1 << (0 + vc_lane));
+	case ERR_ECC_SINGLE:
+		return (0x1 << (8 + vc_lane));
+	case ERR_UNSUPPORTED_DATA_TYPE:
+		return (0x1 << (12 + vc_lane));
+	case MAX_EVENT:
+		break;
+	default:
+		break;
+	}
+	switch((csi_line_event_t)(event)) {
+	case ERR_LINE_BOUNDARY_MATCH:
+		return (0x1 << (16 + (vc_lane % 4)));
+	case ERR_LINE_SEQUENCE:
+		return (0x1 << (20 + (vc_lane % 4)));
+	default:
+		break;
+	}
+	/* writing the following value affects nothing */
+	return 0x80000000;
+}
+
+u8 csi_api_register_event(void *handle, csi_event_t event, u8 vc_lane, handler_t handler)
+{
+	/* the VC_LANE value is the lane number ONLY in PHY ERRORS
+	  * e rest are all virtual channels number except for
+	  * double ECC, where VC is unknown
+	  */
+	u8 e = SUCCESS;
+	struct csi_context *csi_handle = handle;
+	if (NULL == handle) {
+		printk("handle null\n");
+		return ERR_UNDEFINED;
+	}
+	/* the maximum */
+	if (vc_lane < 4) {
+		switch(event) {
+		case ERR_PHY_TX_START:
+				LOG_WARNING("the lane value depends on the synthesis defines");
+				LOG_WARNING("make sure this value does not exceed these defines");
+		case ERR_FRAME_BOUNDARY_MATCH:
+		case ERR_FRAME_SEQUENCE:
+		case ERR_CRC_DURING_FRAME:
+		case ERR_LINE_CRC:
+		case ERR_DOUBLE_ECC:
+			e = csi_event_enable(csi_api_event_map(event, vc_lane), 1);
+			break;
+
+		case ERR_PHY_ESCAPE_ENTRY:
+			LOG_WARNING("the lane value depends on the synthesis defines");
+			LOG_WARNING("make sure this value does not exceed these defines");
+		case ERR_ECC_SINGLE:
+		case ERR_UNSUPPORTED_DATA_TYPE:
+			e = csi_event_enable(csi_api_event_map(event, vc_lane), 2);
+			break;
+
+		default:
+			e = ERROR_EVENT_TYPE_INVALID;
+			break;
+		}
+	} else {
+		e = ERROR_VC_LANE_OUT_OF_BOUND;
+	}
+	if (e == SUCCESS) {
+		csi_handle->csi_api_event_registry[event + vc_lane] = handler;
+	}
+
+	return e;
+}
+
+u8 csi_api_unregister_event(void *handle, csi_event_t event, u8 vc_lane)
+{
+	csi_error_t e = SUCCESS;
+	struct csi_context *csi_handle = handle;
+	if (NULL == handle) {
+		printk("handle null\n");
+		return ERR_UNDEFINED;
+	}
+	/* the maximum */
+    if (vc_lane < 4) {
+		switch(event) {
+		case ERR_PHY_TX_START:
+			LOG_WARNING("the lane value depends on the synthesis defines");
+			LOG_WARNING("make sure this value does not exceed these defines");
+		case ERR_FRAME_BOUNDARY_MATCH:
+		case ERR_FRAME_SEQUENCE:
+		case ERR_CRC_DURING_FRAME:
+		case ERR_LINE_CRC:
+		case ERR_DOUBLE_ECC:
+			e = csi_event_disable(csi_api_event_map(event, vc_lane), 1);
+			break;
+
+		case ERR_PHY_ESCAPE_ENTRY:
+			LOG_WARNING("the lane value depends on the synthesis defines");
+			LOG_WARNING("make sure this value does not exceed these defines");
+		case ERR_ECC_SINGLE:
+		case ERR_UNSUPPORTED_DATA_TYPE:
+			e = csi_event_disable(csi_api_event_map(event, vc_lane), 2);
+			break;
+
+		default:
+			e = ERROR_EVENT_TYPE_INVALID;
+			break;
+
+		}
+    } else {
+        e = ERROR_VC_LANE_OUT_OF_BOUND;
+    }
+    if (e == SUCCESS) {
+        csi_handle->csi_api_event_registry[event + vc_lane] = NULL;
+    }
+
+    return e;
+}
+
+u8 csi_api_register_line_event(void *handle, u8 vc, csi_data_type_t data_type, csi_line_event_t line_event, handler_t handler)
+{
+	u8 id = 0;
+	int counter = 0;
+	int first_slot = -1;
+	int already_registered = 0;
+	u8 e = SUCCESS;
+	struct csi_context *csi_handle = handle;
+	if (NULL == handle) {
+		printk("handle null\n");
+		return ERR_UNDEFINED;
+	}
+
+	if ((data_type < NULL_PACKET)
+	|| ((data_type > EMBEDDED_8BIT_NON_IMAGE_DATA) && (data_type < YUV420_8BIT))
+	|| ((data_type > RGB888) && (data_type < RAW6))
+	|| ((data_type > RAW14) && (data_type < USER_DEFINED_8BIT_DATA_TYPE_1 ))
+	|| (data_type > USER_DEFINED_8BIT_DATA_TYPE_8)) {
+		/* wrong data type - not long packet */
+		return ERROR_DATA_TYPE_INVALID;
+	}
+	/* the maximum */
+	if (vc > 3) {
+		return ERROR_VC_LANE_OUT_OF_BOUND;
+	}
+	id = (u8)((vc << 6)) | (u8)(data_type);
+
+	for (counter = 0; counter < 8; counter++) {
+		if (csi_get_registered_line_event(counter) == 0) {
+			/* first empty slot to register event */
+			first_slot = counter;
+			break;
+		}
+		if (id == csi_get_registered_line_event(counter)) {
+			LOG_WARNING("already registered line/datatype");
+			already_registered = 1;
+			first_slot = counter; /* no need to register it again */
+								/* but NOT that there are no slots!*/
+			break;
+		}
+	}
+	/* if not all slots are taken */
+	if (first_slot != -1) {
+		/* un-mask (whether registered or not) */
+		e = csi_event_enable(csi_api_event_map(line_event, first_slot), (first_slot / 4 == 1)? 2: 1);
+		if (e == SUCCESS) {
+			/* if not already registered */
+			if (already_registered != 1) {
+				e = csi_register_line_event(vc, data_type, first_slot);
+				if (csi_handle->csi_api_event_registry[line_event + first_slot] != NULL) {
+					LOG_WARNING("already registered event and callback (overwriting!)");
+				}
+			}
+			/* register callback */
+			csi_handle->csi_api_event_registry[line_event + first_slot] = handler;
+		}
+	} else {
+		LOG_WARNING("all slots are taken");
+		e = ERROR_SLOTS_FULL;
+	}
+
+	return e;
+}
+
+u8 csi_api_unregister_line_event(void *handle, u8 vc, csi_data_type_t data_type, csi_line_event_t line_event)
+{
+	u8 id = 0;
+	int counter = 0;
+	int replace_slot = -1;
+	int last_slot = -1;
+	u8 vc_new = 0;
+	csi_data_type_t dt_new;
+	csi_line_event_t other_line_event;
+	struct csi_context *csi_handle = handle;
+	if (NULL == handle) {
+		printk("handle null\n");
+		return ERR_UNDEFINED;
+	}
+
+	if ((data_type < NULL_PACKET)
+	|| ((data_type > EMBEDDED_8BIT_NON_IMAGE_DATA) && (data_type < YUV420_8BIT))
+	|| ((data_type > RGB888) && (data_type < RAW6))
+	|| ((data_type > RAW14) && (data_type < USER_DEFINED_8BIT_DATA_TYPE_1 ))
+	|| (data_type > USER_DEFINED_8BIT_DATA_TYPE_8)) {
+		/* wrong data type - not long packet */
+		return ERROR_DATA_TYPE_INVALID;
+	}
+	/* the maximum */
+	if (vc > 3) {
+		return ERROR_VC_LANE_OUT_OF_BOUND;
+	}
+	if (line_event == ERR_LINE_BOUNDARY_MATCH) {
+		other_line_event = ERR_LINE_SEQUENCE;
+	} else if (line_event == ERR_LINE_SEQUENCE) {
+		other_line_event = ERR_LINE_BOUNDARY_MATCH;
+	} else {
+		return ERROR_DATA_TYPE_INVALID;
+	}
+	id = (vc << 6) | data_type;
+	for (counter = 0; counter < 8; counter++) {
+		if (id == csi_get_registered_line_event(counter)) {
+			replace_slot = counter;
+		}
+		if (csi_get_registered_line_event(counter) == 0) {
+			last_slot = counter - 1;
+			break;
+		}
+	}
+	if (replace_slot == -1) {
+		return ERROR_NOT_REGISTERED;
+	}
+	if (last_slot == -1) {
+		last_slot = 7; /* the very last entry */
+	}
+	vc_new = csi_get_registered_line_event(last_slot) >> 6;
+	dt_new = (csi_get_registered_line_event(last_slot) << 2) >> 2;
+
+	if ((csi_handle->csi_api_event_registry[other_line_event + replace_slot] == NULL) && (last_slot != replace_slot)) {
+		/* swap IDI with last registered if its NOT the last entry*/
+		/* copy the last to (over) the one to be deleted*/
+		csi_register_line_event(vc_new, dt_new, replace_slot);
+		/* now that last registered is copied to a new location, unregister old location */
+		csi_event_disable(csi_api_event_map(line_event, last_slot), (last_slot / 4 == 1)? 2: 1);
+		/* swap event registry */
+		csi_handle->csi_api_event_registry[line_event + replace_slot] = csi_handle->csi_api_event_registry[line_event + last_slot];
+		/* mask last slot */
+		if (csi_handle->csi_api_event_registry[other_line_event + last_slot] != NULL) {
+			/* swap event registry - the other possible line event of the last slot */
+			csi_handle->csi_api_event_registry[other_line_event + replace_slot] = csi_handle->csi_api_event_registry[other_line_event + last_slot];
+			/* mask last slot, other line event!*/
+			csi_event_disable(csi_api_event_map(other_line_event, last_slot), (last_slot / 4 == 1)? 2: 1);
+			/* un mask other line event */
+			csi_event_enable(csi_api_event_map(other_line_event, replace_slot), (replace_slot / 4 == 1)? 2: 1);
+		}
+		csi_unregister_line_event(last_slot);
+	} else {
+		/* remove from event registry */
+		csi_handle->csi_api_event_registry[line_event + replace_slot] = NULL;
+		/* mask */
+		csi_event_disable(csi_api_event_map(line_event, replace_slot), (replace_slot / 4 == 1)? 2: 1);
+
+		if ((csi_handle->csi_api_event_registry[other_line_event + replace_slot] == NULL) && (last_slot == replace_slot)) {  /* if it is last entry */
+			csi_unregister_line_event(last_slot);
+		}
+	}
+
+	return SUCCESS;
+}
+
+void csi_api_event1_handler(int irq, void *handle)
+{
+	u32 source = 0;
+	unsigned long flag;
+	struct csi_context *csi_handle = handle;
+	if (NULL == handle) {
+		printk("handle null\n");
+		return;
+	}
+
+	source = csi_event_get_source(1);
+	spin_lock_irqsave(&csi_handle->csi2_lock,flag);
+	if (NULL != csi_handle->isr_cb) {
+		(*csi_handle->isr_cb)(1, source, csi_handle->u_data);
+	}
+	spin_unlock_irqrestore(&csi_handle->csi2_lock, flag);
+
+	return;
+#if 0
+	if (source > 0) {   /* map to enumerator csi_event_t or csi_line_event_t */
+		if ((source & (0xf << 0)) > 0) {
+			tmp = ERR_PHY_TX_START + ((source & 0xf) >> 1);
+		}
+		if ((source & (0xf << 4)) > 0) {
+			tmp = ERR_FRAME_BOUNDARY_MATCH + ((source & 0xf0) >> 5);
+		}
+		if ((source & (0xf << 8)) > 0) {
+			tmp = ERR_FRAME_SEQUENCE + ((source & (0xf << 8)) >> 9);
+		}
+		if ((source & (0xf << 12)) > 0) {
+			tmp = ERR_CRC_DURING_FRAME + ((source & (0xf << 12)) >> 13);
+		}
+		if ((source & (0xf << 16)) > 0) {
+			tmp = ERR_LINE_BOUNDARY_MATCH + ((source & (0xf << 16)) >> 17);
+		}
+		if ((source & (0xf << 20)) > 0) {
+			tmp = ERR_LINE_SEQUENCE + ((source & (0xf << 20)) >> 21);
+		}
+		if ((source & (0xf << 24)) > 0) {
+			tmp = ERR_LINE_CRC + ((source & (0xf << 24)) >> 25);
+		}
+		if ((source & (0xf << 28)) > 0) {
+			tmp = ERR_DOUBLE_ECC;
+		}
+		/* call callback if valid */
+		if (tmp != 0x80000000) {
+			if (csi_api_event_registry[tmp] != NULL) {
+				csi_api_event_registry[tmp](param);
+			}
+		}
+	}
+#endif
+}
+
+void csi_api_event2_handler(int irq, void *handle)
+{
+	u32 source = 0;
+	unsigned long flag;
+	struct csi_context *csi_handle = handle;
+	if (NULL == handle) {
+		printk("handle null\n");
+		return ;
+	}
+
+	source = csi_event_get_source(2);
+	spin_lock_irqsave(&csi_handle->csi2_lock, flag);
+	if (csi_handle->isr_cb) {
+		(*csi_handle->isr_cb)(2, source, csi_handle->u_data);
+	}
+	spin_unlock_irqrestore(&csi_handle->csi2_lock, flag);
+
+	return;
+
+#if 0
+	source = csi_event_get_source(2);
+
+	if (source > 0) {
+		/* map to enumerator csi_event_t or csi_line_event_t */
+		if ((source & (0xf << 0)) > 0) {
+			tmp = ERR_PHY_ESCAPE_ENTRY + ((source & 0xf) >> 1);
+		}
+
+		if ((source & (0xf << 4)) > 0) {
+			; /* error discarded */
+		}
+
+		if ((source & (0xf << 8)) > 0) {
+			tmp = ERR_ECC_SINGLE + ((source & (0xf << 8)) >> 9);
+		}
+		if ((source & (0xf << 12)) > 0) {
+			tmp = ERR_UNSUPPORTED_DATA_TYPE + ((source & (0xf << 12)) >> 13);
+		}
+		if ((source & (0xf << 16)) > 0) {
+			tmp = ERR_LINE_BOUNDARY_MATCH + 4 + ((source & (0xf << 16)) >> 17);
+			/* 4 added because its in ERR2. ERR1 already has 4 */
+		}
+		if ((source & (0xf << 20)) > 0) {
+			tmp = ERR_LINE_SEQUENCE + 4 + ((source & (0xf << 20)) >> 21);
+		}
+		/* call callback if valid */
+		if (tmp != 0x80000000) {
+			if (csi_api_event_registry[tmp] != NULL) {
+				csi_api_event_registry[tmp](param);
+			}
+		}
+	}
+#endif
+}
+
+u8 csi_api_unregister_all_events(void *handle)
+{
+	u8 e = SUCCESS;
+	u8 counter = 0;
+	struct csi_context *csi_handle = handle;
+	if (NULL == handle) {
+		printk("handle null\n");
+		return -1;
+	}
+
+	e = csi_event_disable(0xffffffff, 1);
+	e = csi_event_disable(0xffffffff, 2);
+	if (e == SUCCESS) {
+		for (counter = 0; counter < 8; counter++) {
+			e = csi_unregister_line_event(counter);
+		}
+		for (counter = (u8)(ERR_PHY_TX_START); counter < (u8)(MAX_EVENT); counter++) {
+			csi_handle->csi_api_event_registry[counter] = NULL;
+		}
+	}
+
+	return e;
+}
+
+u8 csi_api_shut_down_phy(u8 shutdown)
+{
+	return csi_shut_down_phy(shutdown);
+}
+
+u8 csi_api_reset_phy()
+{
+	return csi_reset_phy();
+}
+
+u8 csi_api_reset_controller()
+{
+	return csi_reset_controller();
+}
+
+u8 csi_api_core_write(csi_registers_t address, u32 data)
+{
+	return csi_core_write(address, data);
+}
+
+u32 csi_api_core_read(csi_registers_t address)
+{
+	return csi_core_read(address);
+}
+
+int csi_reg_isr(void *handle, csi2_isr_func user_func, void* user_data)
+{
+	unsigned long                flag;
+	struct csi_context *csi_handle = handle;
+	if (NULL == handle) {
+		printk("handle null\n");
+		return ERR_UNDEFINED;
+	}
+
+	spin_lock_irqsave(&csi_handle->csi2_lock, flag);
+	csi_handle->isr_cb = user_func;
+	csi_handle->u_data = user_data;
+	spin_unlock_irqrestore(&csi_handle->csi2_lock, flag);
+
+	return 0;
+}
+
+int csi_read_registers(u32* reg_buf, u32 *buf_len)
+{
+	u32                *reg_addr = (u32*)CSI2_BASE;
+
+	if (NULL == reg_buf || NULL == buf_len || 0 != (*buf_len % 4)) {
+		return -1;
+	}
+
+	while (buf_len != 0 && reg_addr < (u64)(CSI2_BASE + SPRD_CSI2_REG_SIZE)) {
+		*reg_buf++ = *(volatile u32*)reg_addr++;
+		*buf_len -= 4;
+	}
+
+	*buf_len = SPRD_CSI2_REG_SIZE;
+
+	return 0;
+}
diff --git a/drivers/media/sprd_sensor/csi2/csi_api.h b/drivers/media/sprd_sensor/csi2/csi_api.h
new file mode 100644
index 00000000..b49bee7a
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_api.h
@@ -0,0 +1,79 @@
+/*
+ * csi_driver
+ * 12/05/2010
+ * Synopsys Inc. PT02
+ */
+
+#ifndef CSI_API_H_
+#define CSI_API_H_
+
+#include "csi_types.h"
+#include "csi_driver.h"
+#include <linux/spinlock.h>
+
+#define SPRD_CSI2_REG_SIZE             0x40
+
+typedef int (*csi2_isr_func)(u32 err_id, u32 err_status, void* u_data);
+
+/* enumerators index the handler array rather than masks */
+typedef enum
+{
+    ERR_PHY_TX_START = 0,
+    ERR_FRAME_BOUNDARY_MATCH = 4,
+    ERR_FRAME_SEQUENCE = 8,
+    ERR_CRC_DURING_FRAME = 12,
+    ERR_LINE_CRC = 16,
+    ERR_DOUBLE_ECC = 20,
+    ERR_PHY_ESCAPE_ENTRY = 21,
+    ERR_ECC_SINGLE = 25,
+    ERR_UNSUPPORTED_DATA_TYPE = 29,
+    MAX_EVENT = 49
+} csi_event_t;
+typedef enum
+{
+    ERR_LINE_BOUNDARY_MATCH = 33,
+    ERR_LINE_SEQUENCE = 41
+} csi_line_event_t;
+typedef enum
+{
+    ERROR_VC_LANE_OUT_OF_BOUND =    0xCA,
+    ERROR_EVENT_TYPE_INVALID = 0xC9,
+    ERROR_DATA_TYPE_INVALID = 0xC8,
+    ERROR_SLOTS_FULL = 0xC7,
+    ERROR_ALREADY_REGISTERED = 0xC6,
+    ERROR_NOT_REGISTERED = 0xC5
+} csi_api_error_t;
+
+struct csi_context {
+	u32                g_csi2_irq;
+	csi2_isr_func      isr_cb;
+	void              *u_data;
+	spinlock_t         csi2_lock;
+	handler_t          csi_api_event_registry[MAX_EVENT];
+};
+
+int csi_api_malloc(void **handle);
+void csi_api_free(void *handle);
+u8 csi_api_init(u32 bps_per_lane, u32 phy_id);
+u8 csi_api_start(void *handle);
+//u8 csi_api_start(u32 base_address);
+u8 csi_api_close(void *handle, u32 phy_id);
+u8 csi_api_set_on_lanes(u8 no_of_lanes);
+u8 csi_api_get_on_lanes(void);
+csi_lane_state_t csi_api_get_clk_state(void);
+csi_lane_state_t csi_api_get_lane_state(u8 lane);
+u8 csi_api_register_line_event(void *handle, u8 vc, csi_data_type_t data_type, csi_line_event_t line_event, handler_t handler);
+u8 csi_api_unregister_line_event(void *handle, u8 vc, csi_data_type_t data_type, csi_line_event_t line_event);
+u8 csi_api_register_event(void *handle, csi_event_t event, u8 vc_lane, handler_t handler);
+u8 csi_api_unregister_event(void *handle, csi_event_t event, u8 vc_lane);
+u8 csi_api_unregister_all_events(void *handle);
+u8 csi_api_shut_down_phy(u8 shutdown);
+u8 csi_api_reset_phy(void);
+u8 csi_api_reset_controller(void);
+u8 csi_api_core_write(csi_registers_t address, u32 data);
+u32 csi_api_core_read(csi_registers_t address);
+int csi_reg_isr(void *handle, csi2_isr_func user_func, void* user_data);
+int csi_read_registers(uint32_t* reg_buf, uint32_t *buf_len);
+
+#endif /* CSI_API_H_ */
+
diff --git a/drivers/media/sprd_sensor/csi2/csi_api_null.c b/drivers/media/sprd_sensor/csi2/csi_api_null.c
new file mode 100755
index 00000000..56b7556f
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_api_null.c
@@ -0,0 +1,130 @@
+#include <linux/kernel.h>
+#include <linux/semaphore.h>
+#include <linux/delay.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+
+
+#include "csi_api.h"
+#include "csi_log.h"
+
+void csi_api_event1_handler(int irq, void *handle);
+void csi_api_event2_handler(int irq, void *handle);
+int csi_api_malloc(void **handle)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+
+void csi_api_free(void *handle)
+{
+}
+u8 csi_api_init(u32 bps_per_lane, u32 phy_id)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_start(void *handle)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_close(void *handle, u32 phy_id)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_set_on_lanes(u8 no_of_lanes)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+
+u8 csi_api_get_on_lanes()
+{
+	return ERR_NOT_COMPATIBLE;
+}
+csi_lane_state_t csi_api_get_clk_state()
+{
+	return ERR_NOT_COMPATIBLE;
+}
+csi_lane_state_t csi_api_get_lane_state(u8 lane)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_register_event(void *handle, csi_event_t event, u8 vc_lane, handler_t handler)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_unregister_event(void *handle, csi_event_t event, u8 vc_lane)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_register_line_event(void *handle, u8 vc, csi_data_type_t data_type, csi_line_event_t line_event, handler_t handler)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_unregister_line_event(void *handle, u8 vc, csi_data_type_t data_type, csi_line_event_t line_event)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+void csi_api_event1_handler(int irq, void *handle)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+void csi_api_event2_handler(int irq, void *handle)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_unregister_all_events(void *handle)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_shut_down_phy(u8 shutdown)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_reset_phy()
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_reset_controller()
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u8 csi_api_core_write(csi_registers_t address, u32 data)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+u32 csi_api_core_read(csi_registers_t address)
+{
+	return ERR_NOT_COMPATIBLE;
+}
+
+int csi_reg_isr(void *handle, csi2_isr_func user_func, void* user_data)
+{
+	unsigned long                flag;
+	struct csi_context *csi_handle = handle;
+	if (NULL == handle) {
+		printk("handle null\n");
+		return ERR_UNDEFINED;
+	}
+
+	spin_lock_irqsave(&csi_handle->csi2_lock, flag);
+	csi_handle->isr_cb = user_func;
+	csi_handle->u_data = user_data;
+	spin_unlock_irqrestore(&csi_handle->csi2_lock, flag);
+	return 0;
+}
+
+int csi_read_registers(u32* reg_buf, u32 *buf_len)
+{
+	u32                *reg_addr = (u32*)CSI2_BASE;
+
+	if (NULL == reg_buf || NULL == buf_len || 0 != (*buf_len % 4)) {
+		return -1;
+	}
+
+	while (buf_len != 0 && (u32)reg_addr < (CSI2_BASE + SPRD_CSI2_REG_SIZE)) {
+		*reg_buf++ = *(volatile u32*)reg_addr++;
+		*buf_len -= 4;
+	}
+
+	*buf_len = SPRD_CSI2_REG_SIZE;
+	return 0;
+}
diff --git a/drivers/media/sprd_sensor/csi2/csi_driver.c b/drivers/media/sprd_sensor/csi2/csi_driver.c
new file mode 100644
index 00000000..dc4c922c
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_driver.c
@@ -0,0 +1,502 @@
+#include <linux/delay.h>
+#include "csi_driver.h"
+#include "csi_access.h"
+#include "csi_log.h"
+#ifndef CONFIG_64BIT
+#include <soc/sprd/hardware.h>
+#else
+#include "parse_hwinfo.h"
+#endif
+#include <soc/sprd/sci.h>
+
+
+static int csi_core_initialized = 0;
+
+static const struct csi_pclk_cfg csi_pclk_setting[CSI_PCLK_CFG_COUNTER] = {
+	{80,    90,   0x00, 4},
+	{90,   100, 0x10, 4},
+	{100, 110, 0x20, 4},
+	{110, 130, 0x01, 6},
+	{130, 140, 0x11, 6},
+	{140, 150, 0x21, 6},
+	{150, 170, 0x02, 9},
+	{170, 180, 0x12, 9},
+	{180, 200, 0x22, 9},
+	{200, 220, 0x03, 10},
+	{220, 240, 0x13, 10},
+	{240, 250, 0x23, 10},
+	{250, 270, 0x04, 13},
+	{270, 300, 0x14, 13},
+	{300, 330, 0x05, 17},
+	{330, 360, 0x15, 17},
+	{360, 400, 0x25, 17},
+#ifdef IS_ENABLED(VERSION3T) || IS_ENABLED(VERSION3D)
+	{400, 450, 0x06, 25},
+	{450, 500, 0x16, 26},
+#elif IS_ENABLED(VERSION3L)
+	{400, 450, 0x06, 23},
+	{450, 500, 0x16, 23},
+#endif
+	{500, 550, 0x07, 28},
+	{550, 600, 0x17, 28},
+	{600, 650, 0x08, 33},
+	{650, 700, 0x18, 33},
+	{700, 750, 0x09, 38},
+	{750, 800, 0x19, 38},
+	{800, 850, 0x29, 38},
+	{850, 900, 0x39, 38},
+	{900, 950, 0x0A, 52},
+	{950, 1000, 0x1A, 52}
+};
+
+#if IS_ENABLED(VERSION3T)
+static void dpy_ab_clr(void)
+{
+	sci_glb_clr(SPRD_MMAHB_BASE + 0x000C, 0x1F);
+}
+
+static void dpy_a_enable(void)
+{
+	sci_glb_clr(SPRD_MMAHB_BASE + 0x000C, 0x07);
+	sci_glb_set(SPRD_MMAHB_BASE + 0x000C, 0x0C);
+}
+
+static void dpy_b_enable(void)
+{
+	sci_glb_clr(SPRD_MMAHB_BASE + 0x000C, 0x07);
+	sci_glb_set(SPRD_MMAHB_BASE + 0x000C, 0x0F);
+}
+
+static void dpy_c_enable(void)
+{
+
+}
+
+static void dpy_ab_sync(void)
+{
+	sci_glb_clr(SPRD_MMAHB_BASE + 0x000C, 0x07);
+}
+#elif IS_ENABLED(VERSION3D)
+static void dpy_ab_clr(void)
+{
+	sci_glb_clr(SPRD_MMAHB_BASE + 0x000C, 0x3F);
+}
+
+static void dpy_a_enable(void)
+{
+	sci_glb_clr(SPRD_MMAHB_BASE + 0x000C, 0x07);
+	sci_glb_set(SPRD_MMAHB_BASE + 0x000C, 0x0C);
+}
+
+static void dpy_b_enable(void)
+{
+	sci_glb_clr(SPRD_MMAHB_BASE + 0x000C, 0x07);
+	sci_glb_set(SPRD_MMAHB_BASE + 0x000C, 0x0F);
+}
+
+static void dpy_c_enable(void)
+{
+	sci_glb_clr(SPRD_MMAHB_BASE + 0x000C, 0x3F);
+	sci_glb_set(SPRD_MMAHB_BASE + 0x000C, 0x2C);
+}
+
+static void dpy_ab_sync(void)
+{
+	sci_glb_clr(SPRD_MMAHB_BASE + 0x000C, 0x07);
+}
+#else IS_ENABLED(VERSION3L)
+static void dpy_ab_clr(void)
+{
+}
+static void dpy_a_enable(void)
+{
+	sci_glb_clr(SPRD_MMAHB_BASE + 0x000C, 0x01);
+}
+static void dpy_b_enable(void)
+{
+	sci_glb_set(SPRD_MMAHB_BASE + 0x000C, 0x01);
+}
+
+static void dpy_c_enable(void)
+{
+}
+
+static void dpy_ab_sync(void)
+{
+}
+#endif
+
+static void dphy_write(u8 test_code, u8 test_data, u8* test_out)
+{
+	u32 temp = 0xffffff00;
+
+	csi_core_write_part(PHY_TST_CRTL1, 0, PHY_TESTEN, 1); //phy_testen = 0
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL0,1, PHY_TESTCLK, 1); //phy_testclk = 1
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL1, test_code, PHY_TESTDIN, PHY_TESTDIN_W); //phy_testdin
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL1, 1, PHY_TESTEN, 1);//phy_testen = 1
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL0, 0, PHY_TESTCLK, 1);//phy_testclk = 0
+	udelay(1);
+	temp = csi_core_read_part(PHY_TST_CRTL1, PHY_TESTDOUT,PHY_TESTDOUT_W);
+	*test_out = (u8)temp;
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL1, 0, PHY_TESTEN, 1); //phy_testen = 0
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL1, test_data, PHY_TESTDIN, PHY_TESTDIN_W);//phy_testdin
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL0,1, PHY_TESTCLK, 1);//phy_testclk = 1
+	udelay(1);
+}
+
+static void dphy_cfg_start(void)
+{
+	csi_core_write_part(PHY_TST_CRTL1, 0, PHY_TESTEN, 1); //phy_testen = 0
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL0,1, PHY_TESTCLK, 1); //phy_testclk = 1
+	udelay(1);
+}
+
+static void dphy_cfg_done(void)
+{
+	csi_core_write_part(PHY_TST_CRTL1, 0, PHY_TESTEN, 1); //phy_testen = 0
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL0,1, PHY_TESTCLK, 1); //phy_testclk = 1
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL1, 0, PHY_TESTDIN, PHY_TESTDIN_W);//phy_testdin
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL1, 1, PHY_TESTEN, 1);//phy_testen = 1
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL0, 0, PHY_TESTCLK, 1);//phy_testclk = 0
+	udelay(1);
+}
+
+static void csi_get_pclk_cfg(u32 bps_per_lane, struct csi_pclk_cfg *csi_pclk_cfg_ptr)
+{
+	u32 i = 0;
+	int rtn = -1;
+
+	for (i =0 ; i < CSI_PCLK_CFG_COUNTER; i++) {
+		if ( bps_per_lane >= csi_pclk_setting[i].pclk_start && bps_per_lane < csi_pclk_setting[i].pclk_end) {
+			csi_pclk_cfg_ptr->hsfreqrange = csi_pclk_setting[i].hsfreqrange;
+			csi_pclk_cfg_ptr->hsrxthssettle = csi_pclk_setting[i].hsrxthssettle;
+			rtn = 0;
+			break;
+		}
+	}
+
+	if (rtn) {
+		csi_pclk_cfg_ptr->hsfreqrange = csi_pclk_setting[CSI_PCLK_CFG_COUNTER -2].hsfreqrange;
+		csi_pclk_cfg_ptr->hsrxthssettle = csi_pclk_setting[CSI_PCLK_CFG_COUNTER -2].hsrxthssettle;
+	}
+}
+
+static void dphy_init_common(u32 bps_per_lane, u32 phy_id, u32 rx_mode)
+{
+	u8 temp = 0;
+	struct csi_pclk_cfg csi_pclk_cfg_val = {0, 0, 0, 0};
+
+	csi_core_write_part(PHY_SHUTDOWNZ,  0, 0, 1);
+	csi_core_write_part(DPHY_RSTZ, 0, 0, 1);
+	csi_core_write_part(PHY_TST_CRTL0, 1, PHY_TESTCLR, 1);
+	udelay(1);
+	csi_core_write_part(PHY_TST_CRTL0, 0, PHY_TESTCLR, 1);
+	udelay(1);
+	dphy_cfg_start();
+
+#if defined(CONFIG_MACH_SP7720EA)
+#if defined(CONFIG_SC_FPGA)
+	sci_glb_write(SPRD_GPIO_BASE + 0x0008, 0xd, -1UL);
+	dphy_write(0x30, 0xc0, &temp);
+#endif
+	dphy_write(0x37, 0x03, &temp);
+	//LOG_DEBUG2 ("%04x default  reg value: %04x\r\n", 0x37, temp);
+	dphy_write(0x47, 0x03, &temp);
+	//LOG_DEBUG2 ("%04x default  reg value: %04x\r\n", 0x47, temp);
+	dphy_write(0x57, 0x03, &temp);
+	//LOG_DEBUG2 ("%04x default  reg value: %04x\r\n", 0x57, temp);
+	dphy_write(0x67, 0x03, &temp);
+	dphy_write(0x77, 0x03, &temp);
+#else
+	csi_get_pclk_cfg(bps_per_lane, &csi_pclk_cfg_val);
+
+#if IS_ENABLED(VERSION3L) || IS_ENABLED(VERSION3T) || IS_ENABLED(VERSION3D)
+	if (0x03 == phy_id) {
+		if (0x00 == rx_mode) {
+			dphy_write(0x34, 0x14, &temp);
+		} else {
+			dphy_write(0x34, 0xA0, &temp);
+		}
+	} else {
+		dphy_write(0x34, 0x14, &temp);
+	}
+#else
+	dphy_write(0x34, 0x14, &temp);
+#endif
+
+	dphy_write(0x44, (((csi_pclk_cfg_val.hsfreqrange & 0x3F) << 1) & 0x7E), &temp);
+	dphy_write(0x75, (0x80 | (csi_pclk_cfg_val.hsrxthssettle & 0x7F)), &temp);
+	dphy_write(0x54, 0x14, &temp);
+	dphy_write(0x64, 0x14, &temp);
+	dphy_write(0x74, 0x14, &temp);
+#endif
+	dphy_cfg_done();
+}
+
+void dphy_init(u32 bps_per_lane, u32 phy_id)
+{
+#if IS_ENABLED(VERSION3L) || IS_ENABLED(VERSION3T) || IS_ENABLED(VERSION3D)
+	dpy_ab_clr();
+
+	if (phy_id & 0x01) {
+		dpy_a_enable();
+		dphy_init_common(bps_per_lane, phy_id, 0);
+	}
+
+	if (phy_id & 0x02) {
+		dpy_b_enable();
+		dphy_init_common(bps_per_lane, phy_id, 1);
+	}
+
+	if (0x03 == (phy_id & 0x03)) {
+		dpy_ab_sync();
+	}
+
+	if (phy_id & 0x04) {
+		dpy_c_enable();
+		dphy_init_common(bps_per_lane, phy_id, 0);
+	}
+
+#else
+	dphy_init_common(bps_per_lane, phy_id, 0);
+#endif
+}
+
+u8 csi_init(u64 base_address)
+{
+    csi_error_t e = SUCCESS;
+    do {
+		if (csi_core_initialized == 0) {
+			access_init((u32*)base_address);
+			if (csi_core_read(VERSION) == (u32)(CURRENT_VERSION)) {
+				csi_core_initialized = 1;
+				break;
+			} else {
+				LOG_ERROR("Driver not compatible with core");
+				e = ERR_NOT_COMPATIBLE;
+				break;
+			}
+		} else {
+			LOG_ERROR("driver already initialised");
+			e = ERR_ALREADY_INIT;
+			break;
+		}
+    } while(0);
+
+    return e;
+}
+
+u8 csi_close()
+{
+	csi_shut_down_phy(1);
+	csi_reset_controller();
+	csi_core_initialized = 0;
+	return SUCCESS;
+}
+
+u8 csi_get_on_lanes()
+{
+	return (csi_core_read_part(N_LANES, 0, 2) + 1);
+}
+
+u8 csi_set_on_lanes(u8 lanes)
+{
+	return csi_core_write_part(N_LANES, (lanes - 1), 0, 2);
+}
+
+u8 csi_shut_down_phy(u8 shutdown)
+{
+	LOG_DEBUG2("shutdown", shutdown);
+	/*  active low - bit 0 */
+	return csi_core_write_part(PHY_SHUTDOWNZ, shutdown? 0: 1, 0, 1);
+}
+
+u8 csi_reset_phy()
+{
+	/*  active low - bit 0 */
+	int retVal = 0xffff;
+	retVal = csi_core_write_part(DPHY_RSTZ, 0, 0, 1);
+	switch (retVal) {
+	case SUCCESS:
+		return csi_core_write_part(DPHY_RSTZ, 1, 0, 1);
+		break;
+	case ERR_NOT_INIT:
+		LOG_ERROR("Driver not initialized");
+		return retVal;
+		break;
+	default:
+		LOG_ERROR("Undefined error");
+		return ERR_UNDEFINED;
+		break;
+	}
+}
+
+u8 csi_reset_controller()
+{
+	/*  active low - bit 0 */
+	int retVal = 0xffff;
+	retVal = csi_core_write_part(CSI2_RESETN, 0, 0, 1);
+	switch (retVal) {
+	case SUCCESS:
+		return csi_core_write_part(CSI2_RESETN, 1, 0, 1);
+		break;
+	case ERR_NOT_INIT:
+		LOG_ERROR("Driver not initialized");
+		return retVal;
+		break;
+	default:
+		LOG_ERROR("Undefined error");
+		return ERR_UNDEFINED;
+		break;
+	}
+}
+
+csi_lane_state_t csi_lane_module_state(u8 lane)
+{
+    if (lane < csi_core_read_part(N_LANES, 0, 2) + 1) {
+        if (csi_core_read_part(PHY_STATE, lane, 1)) {
+            return CSI_LANE_ULTRA_LOW_POWER;
+        }
+        else if (csi_core_read_part(PHY_STATE, (lane + 4), 1)) {
+            return CSI_LANE_STOP;
+        }
+        return CSI_LANE_ON;
+    } else {
+        LOG_WARNING("Lane switched off");
+        return CSI_LANE_OFF;
+    }
+}
+
+csi_lane_state_t csi_clk_state()
+{
+	if (!csi_core_read_part(PHY_STATE, 9, 1)) {
+		return CSI_LANE_ULTRA_LOW_POWER;
+	} else if (csi_core_read_part(PHY_STATE, 10, 1)) {
+		return CSI_LANE_STOP;
+	} else if (csi_core_read_part(PHY_STATE, 8, 1)) {
+		return CSI_LANE_HIGH_SPEED;
+	}
+
+	return CSI_LANE_ON;
+}
+
+u8 csi_payload_bypass(u8 on)
+{
+	return csi_core_write_part(PHY_STATE, on? 1: 0, 11, 1);
+}
+
+u8 csi_register_line_event(u8 virtual_channel_no, csi_data_type_t data_type, u8 offset)
+{
+	u8 id = 0;
+	csi_registers_t reg_offset = 0;
+	LOG_TRACE();
+	if ((virtual_channel_no > 4) || (offset > 8)) {
+		return ERR_OUT_OF_BOUND;
+	}
+	id = (virtual_channel_no << 6) | data_type;
+
+	reg_offset = ((offset / 4) == 1) ? DATA_IDS_2: DATA_IDS_1;
+
+	return csi_core_write_part(reg_offset, id, (offset * 8), 8);
+}
+u8 csi_unregister_line_event(u8 offset)
+{
+	csi_registers_t reg_offset = 0;
+	LOG_TRACE();
+	if (offset > 8) {
+		return ERR_OUT_OF_BOUND;
+	}
+	reg_offset = ((offset / 4) == 1) ? DATA_IDS_2: DATA_IDS_1;
+	return csi_core_write_part(reg_offset, 0x00, (offset * 8), 8);
+}
+
+u8 csi_get_registered_line_event(u8 offset)
+{
+	csi_registers_t reg_offset = 0;
+	LOG_TRACE();
+	if (offset > 8) {
+		return ERR_OUT_OF_BOUND;
+	}
+	reg_offset = ((offset / 4) == 1) ? DATA_IDS_2: DATA_IDS_1;
+	return (u8)csi_core_read_part(reg_offset, (offset * 8), 8);
+}
+
+u8 csi_event_disable(u32 mask, u8 err_reg_no)
+{
+	switch (err_reg_no) {
+	case 1:
+		return csi_core_write(MASK1, mask | csi_core_read(MASK1));
+	case 2:
+		return csi_core_write(MASK2, mask | csi_core_read(MASK2));
+	default:
+		return ERR_OUT_OF_BOUND;
+	}
+}
+
+u8 csi_event_enable(u32 mask, u8 err_reg_no)
+{
+	switch (err_reg_no) {
+	case 1:
+		return csi_core_write(MASK1, (~mask) & csi_core_read(MASK1));
+	case 2:
+		return csi_core_write(MASK2, (~mask) & csi_core_read(MASK2));
+	default:
+		return ERR_OUT_OF_BOUND;
+	}
+}
+u32 csi_event_get_source(u8 err_reg_no)
+{
+	switch (err_reg_no) {
+	case 1:
+		return csi_core_read(ERR1);
+	case 2:
+		return csi_core_read(ERR2);
+	default:
+		return ERR_OUT_OF_BOUND;
+	}
+}
+
+/*  register methods */
+u32 csi_core_read(csi_registers_t address)
+{
+	return access_read(address>>2);
+}
+
+u8 csi_core_write(csi_registers_t address, u32 data)
+{
+	if (csi_core_initialized == 0) {
+		LOG_ERROR("driver not initialised");
+		return ERR_NOT_INIT;
+	}
+	LOG_DEBUG3("write", data, address>>2);
+	access_write(data, address>>2);
+
+	return SUCCESS;
+}
+
+u8 csi_core_write_part(csi_registers_t address, u32 data, u8 shift, u8 width)
+{
+	u32 mask = (1 << width) - 1;
+	u32 temp = csi_core_read(address);
+	temp &= ~(mask << shift);
+	temp |= (data & mask) << shift;
+	return csi_core_write(address, temp);
+}
+
+u32 csi_core_read_part(csi_registers_t address, u8 shift, u8 width)
+{
+	return (csi_core_read(address) >> shift) & ((1 << width) - 1);
+}
+
diff --git a/drivers/media/sprd_sensor/csi2/csi_driver.h b/drivers/media/sprd_sensor/csi2/csi_driver.h
new file mode 100644
index 00000000..dbe2648a
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_driver.h
@@ -0,0 +1,136 @@
+/*
+ * csi_driver
+ * 12/05/2010
+ * Synopsys Inc. PT02
+ */
+
+#ifndef CSI_DRIVER_H_
+#define CSI_DRIVER_H_
+
+#include "csi_types.h"
+
+//#define CURRENT_VERSION 0x3130302A
+#ifdef __SIMULATOR__
+#define CURRENT_VERSION 0
+#else // __SIMULATOR__
+
+#define CURRENT_VERSION 0x3130332A
+
+#endif // __SIMULATOR__
+
+#define PHY_TESTCLR 0
+#define PHY_TESTCLK 1
+#define PHY_TESTDIN 0
+#define PHY_TESTDOUT 8
+#define PHY_TESTEN 16
+
+#define PHY_TESTDIN_W 8
+#define PHY_TESTDOUT_W 8
+
+#define CSI_PCLK_CFG_COUNTER 29
+
+typedef enum
+{
+    VERSION =       0x00,
+    N_LANES =       0x04,
+    PHY_SHUTDOWNZ = 0x08,
+    DPHY_RSTZ =     0x0C,
+    CSI2_RESETN =   0x10,
+    PHY_STATE =     0x14,
+    DATA_IDS_1 =    0x18,
+    DATA_IDS_2 =    0x1C,
+    ERR1 =          0x20,
+    ERR2 =          0x24,
+    MASK1 =         0x28,
+    MASK2 =         0x2C,
+    PHY_TST_CRTL0 = 0x30,
+    PHY_TST_CRTL1 = 0x34
+} csi_registers_t;
+
+typedef enum
+{
+    CSI_LANE_OFF = 0,
+    CSI_LANE_ON,
+    CSI_LANE_ULTRA_LOW_POWER,
+    CSI_LANE_STOP,
+    CSI_LANE_HIGH_SPEED
+} csi_lane_state_t;
+
+typedef enum
+{
+    ERR_NOT_INIT = 0xFE,
+    ERR_ALREADY_INIT = 0xFD,
+    ERR_NOT_COMPATIBLE = 0xFC,
+    ERR_UNDEFINED = 0xFB,
+    ERR_OUT_OF_BOUND = 0xFA,
+    SUCCESS = 0
+} csi_error_t;
+
+typedef enum
+{
+    NULL_PACKET = 0x10,
+    BLANKING_DATA = 0x11,
+    EMBEDDED_8BIT_NON_IMAGE_DATA = 0x12,
+    YUV420_8BIT = 0x18,
+    YUV420_10BIT = 0x19,
+    LEGACY_YUV420_8BIT = 0x1A,
+    YUV420_8BIT_CHROMA_SHIFTED = 0x1C,
+    YUV420_10BIT_CHROMA_SHIFTED = 0x1D,
+    YUV422_8BIT = 0x1E,
+    YUV422_10BIT = 0x1F,
+    RGB444 = 0x20,
+    RGB555 = 0x21,
+    RGB565 = 0x22,
+    RGB666 = 0x23,
+    RGB888 = 0x24,
+    RAW6 = 0x28,
+    RAW7 = 0x29,
+    RAW8 = 0x2A,
+    RAW10 = 0x2B,
+    RAW12 = 0x2C,
+    RAW14 = 0x2D,
+    USER_DEFINED_8BIT_DATA_TYPE_1 = 0x30,
+    USER_DEFINED_8BIT_DATA_TYPE_2 = 0x31,
+    USER_DEFINED_8BIT_DATA_TYPE_3 = 0x32,
+    USER_DEFINED_8BIT_DATA_TYPE_4 = 0x33,
+    USER_DEFINED_8BIT_DATA_TYPE_5 = 0x34,
+    USER_DEFINED_8BIT_DATA_TYPE_6 = 0x35,
+    USER_DEFINED_8BIT_DATA_TYPE_7 = 0x36,
+    USER_DEFINED_8BIT_DATA_TYPE_8 = 0x37
+} csi_data_type_t;
+
+struct csi_pclk_cfg {
+	u32 pclk_start;
+	u32 pclk_end;
+	u8    hsfreqrange;
+	u8    hsrxthssettle;
+};
+
+void dphy_init(u32 bps_per_lane, u32 phy_id);
+u8 csi_init(u64 base_address);
+u8 csi_close(void);
+u8 csi_get_on_lanes(void);
+u8 csi_set_on_lanes(u8 lanes);
+u8 csi_shut_down_phy(u8 shutdown);
+u8 csi_reset_phy(void);
+u8 csi_reset_controller(void);
+csi_lane_state_t csi_lane_module_state(u8 lane);
+csi_lane_state_t csi_clk_state(void);
+u8 csi_payload_bypass(u8 on);
+u8 csi_register_line_event(u8 virtual_channel_no, csi_data_type_t data_type, u8 offset);
+u8 csi_unregister_line_event(u8 offset);
+u8 csi_get_registered_line_event(u8 offset);
+u8 csi_event_disable(u32 mask, u8 err_reg_no);
+u8 csi_event_enable(u32 mask, u8 err_reg_no);
+u32 csi_event_get_source(u8 err_reg_no);
+
+/******************************************************************************
+ * register access methods
+******************************************************************************/
+u32 csi_core_read(csi_registers_t address);
+u8 csi_core_write(csi_registers_t address, u32 data);
+u8 csi_core_write_part(csi_registers_t address, u32 data, u8 shift, u8 width);
+u32 csi_core_read_part(csi_registers_t address, u8 shift, u8 width);
+
+#endif /* CSI_DRIVER_H_ */
+
diff --git a/drivers/media/sprd_sensor/csi2/csi_log.c b/drivers/media/sprd_sensor/csi2/csi_log.c
new file mode 100644
index 00000000..38dd0589
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_log.c
@@ -0,0 +1,177 @@
+/*
+ * log.c
+ *
+ *  Created on: Jun 25, 2010
+ *      Author: klabadi & dlopo
+ */
+#include <linux/kernel.h>
+#include "csi_log.h"
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+static log_verbose_t log_verbose = VERBOSE_NOTICE;
+static log_numeric_t log_numeric = NUMERIC_HEX;
+static unsigned log_verbose_write = 0;
+
+void log_set_verbose(log_verbose_t verbose)
+{
+    log_verbose = verbose;
+}
+
+void log_set_numeric(log_numeric_t numeric)
+{
+    log_numeric = numeric;
+}
+
+void log_set_verbose_write(unsigned state)
+{
+    log_verbose_write = state;
+}
+
+void log_print_write(unsigned a, unsigned b)
+{
+    if (log_verbose_write == 1)
+    {
+        if (log_numeric == NUMERIC_DEC)
+        {
+            printk("%d, %d\n", a, b);
+        }
+        else
+        {
+            printk("0x%x, 0x%x\n", a, b);
+        }
+    }
+}
+
+void log_print0(log_verbose_t verbose, const char* function_name)
+{
+    if (verbose == VERBOSE_ERROR)
+    {
+        printk("ERROR: ");
+    }
+    if (verbose == VERBOSE_WARN)
+    {
+        printk("WARNING: ");
+    }
+    if (verbose <= log_verbose)
+    {
+        printk("%s\n", function_name);
+    }
+}
+
+void log_print1(log_verbose_t verbose, const char* function_name, const char* a)
+{
+    if (verbose == VERBOSE_ERROR)
+    {
+        printk("ERROR: ");
+    }
+    if (verbose == VERBOSE_WARN)
+    {
+        printk("WARNING: ");
+    }
+    if (verbose <= log_verbose)
+    {
+        printk("%s: %s\n", function_name, a);
+    }
+}
+
+void log_print2(log_verbose_t verbose, const char* function_name, const char* a,
+        unsigned b)
+{
+    if (verbose == VERBOSE_ERROR)
+    {
+        printk("ERROR: ");
+    }
+    if (verbose == VERBOSE_WARN)
+    {
+        printk("WARNING: ");
+    }
+    if (verbose <= log_verbose)
+    {
+        if (log_numeric == NUMERIC_DEC)
+        {
+            printk("%s: %s, %d\n", function_name, a, b);
+        }
+        else
+        {
+            printk("%s: %s, 0x%x\n", function_name, a, b);
+        }
+    }
+}
+
+void log_print3(log_verbose_t verbose, const char* function_name, const char* a,
+        unsigned b, unsigned c)
+{
+    if (verbose == VERBOSE_ERROR)
+    {
+        printk("ERROR: ");
+    }
+    if (verbose == VERBOSE_WARN)
+    {
+        printk("WARNING: ");
+    }
+    if (verbose <= log_verbose)
+    {
+        if (log_numeric == NUMERIC_DEC)
+        {
+            printk("%s: %s, %d, %d\n", function_name, a, b, c);
+        }
+        else
+        {
+            printk("%s: %s, 0x%x, 0x%x\n", function_name, a, b, c);
+        }
+    }
+}
+
+void log_print_int(log_verbose_t verbose, const char* a, unsigned b)
+{
+    if (verbose <= log_verbose)
+    {
+        if (log_numeric == NUMERIC_DEC)
+        {
+            printk("%s: %d\n", a, b);
+        }
+        else
+        {
+            printk("%s: 0x%x\n", a, b);
+        }
+    }
+}
+
+void log_print_int2(log_verbose_t verbose, const char* a, unsigned b,
+        unsigned c)
+{
+    if (verbose <= log_verbose)
+    {
+        if (log_numeric == NUMERIC_DEC)
+        {
+            printk("%s: %d, %d\n", a, b, c);
+        }
+        else
+        {
+            printk("%s: 0x%x, 0x%x\n", a, b, c);
+        }
+    }
+}
+
+void log_print_int3(log_verbose_t verbose, const char* a, unsigned b,
+        unsigned c, unsigned d)
+{
+    if (verbose <= log_verbose)
+    {
+        if (log_numeric == NUMERIC_DEC)
+        {
+            printk("%s: %d, %d, %d\n", a, b, c, d);
+        }
+        else
+        {
+            printk("%s: 0x%x, 0x%x, 0x%x\n", a, b, c, d);
+        }
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/drivers/media/sprd_sensor/csi2/csi_log.h b/drivers/media/sprd_sensor/csi2/csi_log.h
new file mode 100644
index 00000000..ff7c073a
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_log.h
@@ -0,0 +1,78 @@
+/*
+ * log.h
+ *
+ *  Created on: Jun 25, 2010
+ *      Author: klabadi & dlopo
+ */
+
+#ifndef LOG_H_
+#define LOG_H_
+
+#define __FUNCTION__ (__func__)
+
+typedef enum
+{
+    VERBOSE_ERROR = 0,
+    VERBOSE_WARN,
+    VERBOSE_NOTICE,
+    VERBOSE_DEBUG,
+    VERBOSE_TRACE
+} log_verbose_t;
+
+typedef enum
+{
+    NUMERIC_DEC = 0, NUMERIC_HEX
+} log_numeric_t;
+
+void log_set_verbose(log_verbose_t verbose);
+void log_set_numeric(log_numeric_t numeric);
+void log_set_verbose_write(unsigned state);
+
+void log_print_write(unsigned a, unsigned b);
+
+void log_print0(log_verbose_t verbose, const char* function_name);
+
+void log_print1(log_verbose_t verbose, const char* function_name, const char* a);
+
+void log_print2(log_verbose_t verbose, const char* function_name, const char* a,
+        unsigned b);
+
+void log_print3(log_verbose_t verbose, const char* function_name, const char* a,
+        unsigned b, unsigned c);
+
+void log_print_int(log_verbose_t verbose, const char* a, unsigned b);
+
+void log_print_int2(log_verbose_t verbose, const char* a, unsigned b,
+        unsigned c);
+
+void log_print_int3(log_verbose_t verbose, const char* a, unsigned b,
+        unsigned c, unsigned d);
+
+#define LOG_ASSERT(x, a)        while (!(x)) { LOG_ERROR(a); exit(-1); }
+#define LOG_EXIT(a)             do { LOG_ERROR(a); exit(-1); } while (0)
+#define LOG_WRITE(a, b)         log_print_write((a), (b))
+
+#define LOG_ERROR(a)            log_print1(VERBOSE_ERROR,  __FUNCTION__, (a))
+#define LOG_ERROR2(a, b)        log_print2(VERBOSE_ERROR,  __FUNCTION__, (a), (b))
+#define LOG_ERROR3(a, b, c)     log_print3(VERBOSE_ERROR,  __FUNCTION__, (a), (b), (c))
+#define LOG_WARNING(a)          log_print1(VERBOSE_WARN,   __FUNCTION__, (a))
+#define LOG_WARNING2(a, b)      log_print2(VERBOSE_WARN,   __FUNCTION__, (a), (b))
+#define LOG_WARNING3(a, b, c)   log_print3(VERBOSE_WARN,   __FUNCTION__, (a), (b), (c))
+#define LOG_NOTICE(a)           log_print1(VERBOSE_NOTICE, __FUNCTION__, (a))
+#define LOG_NOTICE2(a, b)       log_print2(VERBOSE_NOTICE, __FUNCTION__, (a), (b))
+#define LOG_NOTICE3(a, b, c)    log_print3(VERBOSE_NOTICE, __FUNCTION__, (a), (b), (c))
+#define LOG_DEBUG(a)            log_print1(VERBOSE_DEBUG,  __FUNCTION__, (a))
+#define LOG_DEBUG2(a, b)        log_print2(VERBOSE_DEBUG,  __FUNCTION__, (a), (b))
+#define LOG_DEBUG3(a, b, c)     log_print3(VERBOSE_DEBUG,  __FUNCTION__, (a), (b), (c))
+#define LOG_TRACE()             log_print0(VERBOSE_TRACE,  __FUNCTION__)
+#define LOG_TRACE1(a)           log_print_int(VERBOSE_TRACE,  __FUNCTION__, (a))
+#define LOG_TRACE2(a, b)        log_print_int2(VERBOSE_TRACE,  __FUNCTION__, (a), (b))
+#define LOG_TRACE3(a, b, c)     log_print3(VERBOSE_TRACE,  __FUNCTION__, (a), (b), (c))
+
+#define LOG_MENU(a)                 log_print0(VERBOSE_NOTICE, (a))
+#define LOG_MENUSTR(a, b)           log_print1(VERBOSE_NOTICE, (a), (b))
+#define LOG_MENUINT(a, b)           log_print_int(VERBOSE_NOTICE, (a),(b))
+#define LOG_MENUINT2(a, b, c)       log_print_int2(VERBOSE_NOTICE, (a),(b), (c))
+#define LOG_MENUINT3(a, b, c, d)    log_print_int3(VERBOSE_NOTICE, (a),(b), (c), (d))
+
+#endif /* LOG_H_ */
diff --git a/drivers/media/sprd_sensor/csi2/csi_system.c b/drivers/media/sprd_sensor/csi2/csi_system.c
new file mode 100644
index 00000000..408983e7
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_system.c
@@ -0,0 +1,84 @@
+/*
+ * system.c
+ *
+ *  Created on: Jun 25, 2010
+ *      Author: klabadi & dlopo
+ *
+ *
+ *  @note: this file should be re-written to match the environment the
+ *  API is running on
+ */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#include "csi_system.h"
+#include "csi_log.h"
+
+void system_sleep_ms(unsigned ms)
+{
+
+}
+
+int system_thread_create(void* handle, thread_t p_func, void* param)
+{
+    return 0;
+}
+int system_thread_destruct(void* handle)
+{
+    return 0;
+}
+
+int system_start(thread_t thread)
+{
+    return 1;
+}
+
+static unsigned system_interrupt_map(interrupt_id_t id)
+{
+    return ~0;
+}
+
+int system_interrupt_disable(interrupt_id_t id)
+{
+    if (system_interrupt_map(id) != (unsigned) (~0))
+    {
+        return 0;
+    }
+    LOG_ERROR("Interrupt not mapped");
+    return 0;
+}
+
+int system_interrupt_enable(interrupt_id_t id)
+{
+    if (system_interrupt_map(id) != (unsigned) (~0))
+    {
+        return 0;
+    }
+    LOG_ERROR("Interrupt not mapped");
+    return 0;
+}
+
+int system_interrupt_acknowledge(interrupt_id_t id)
+{
+    if (system_interrupt_map(id) != (unsigned) (~0))
+    {
+        return 0;
+    }
+    LOG_ERROR("Interrupt not mapped");
+    return 0;
+}
+int system_interrupt_handler_register(interrupt_id_t id, handler_t handler,
+        void * param)
+{
+    return 0;
+}
+
+int system_interrupt_handler_unregister(interrupt_id_t id)
+{
+    return 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/drivers/media/sprd_sensor/csi2/csi_system.h b/drivers/media/sprd_sensor/csi2/csi_system.h
new file mode 100644
index 00000000..21f19886
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_system.h
@@ -0,0 +1,28 @@
+/*
+ * system.h
+ *
+ *  Created on: Jun 25, 2010
+ *      Author: klabadi & dlopo
+ */
+
+#ifndef SYSTEM_H_
+#define SYSTEM_H_
+
+#include "csi_types.h"
+
+typedef enum
+{
+    CSI_INT_ERR1 = 1, CSI_INT_ERR2
+} interrupt_id_t;
+void system_sleep_ms(unsigned ms);
+int system_thread_create(void* handle, thread_t p_func, void* param);
+int system_thread_destruct(void* handle);
+int system_start(thread_t thread);
+int system_interrupt_disable(interrupt_id_t id);
+int system_interrupt_enable(interrupt_id_t id);
+int system_interrupt_acknowledge(interrupt_id_t id);
+int system_interrupt_handler_register(interrupt_id_t id, handler_t handler, void * param);
+int system_interrupt_handler_unregister(interrupt_id_t id);
+
+
+#endif /* SYSTEM_H_ */
\ No newline at end of file
diff --git a/drivers/media/sprd_sensor/csi2/csi_types.h b/drivers/media/sprd_sensor/csi2/csi_types.h
new file mode 100644
index 00000000..d7c9031d
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/csi_types.h
@@ -0,0 +1,15 @@
+/*
+ * types.h
+ *
+ * Created on: Aug 25, 2010
+ * Author: klabadi & dlopo
+ */
+
+#ifndef TYPES_H_
+#define TYPES_H_
+#include <linux/types.h>
+
+typedef void (*handler_t)(void *);
+typedef void* (*thread_t)(void *);
+
+#endif /* TYPES_H_ */
\ No newline at end of file
diff --git a/drivers/media/sprd_sensor/csi2/usc28c_init.c b/drivers/media/sprd_sensor/csi2/usc28c_init.c
new file mode 100644
index 00000000..c0e2071a
--- /dev/null
+++ b/drivers/media/sprd_sensor/csi2/usc28c_init.c
@@ -0,0 +1,281 @@
+
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+#ifndef CONFIG_64BIT
+#include <soc/sprd/hardware.h>
+#else
+#include "parse_hwinfo.h"
+#endif
+
+#define CTL_BASE_ENABLE_USC28C_CSI     0x403f0008
+
+#define pr_info                        printk
+
+#define ARM_GPIO_BASE_CNT              (192)
+
+#define SPI_USC28C_SCK_GPIO_PIN        (200)
+#define SPI_USC28C_SEN_GPIO_PIN        (201)
+#define SPI_USC28C_DAT_GPIO_PIN        (202)
+
+#define SPI_USC28C_SCK_GPIO_MASK       (1<<(SPI_USC28C_SCK_GPIO_PIN-ARM_GPIO_BASE_CNT))
+#define SPI_USC28C_SEN_GPIO_MASK       (1<<(SPI_USC28C_SEN_GPIO_PIN-ARM_GPIO_BASE_CNT))
+#define SPI_USC28C_DAT_GPIO_MASK       (1<<(SPI_USC28C_DAT_GPIO_PIN-ARM_GPIO_BASE_CNT))
+#define SPI_CLK_DELAY                  0
+#define SPI_READ_REG                   0x3F
+
+#define GPIO_CHIP_USC28C_OFFSET        (SPRD_GPIO_BASE + 0x600)
+
+#if 0
+struct gpio_ctrl_reg {
+	volatile u32 data; /* bits data */
+	volatile u32 msk; /* bits data mask */
+	volatile u32 dir; /* bits data direction */
+	volatile u32 is; /* bits interrupt sense */
+	volatile u32 ibe; /* bits both edges interrupt */
+	volatile u32 iev; /* bits interrupt event */
+	volatile u32 ie; /* bits interrupt enable */
+	volatile u32 ris; /* bits raw interrupt status */
+	volatile u32 mis; /* bits masked interrupt status */
+	volatile u32 inen; /* input enable */
+};
+#endif
+
+static void gpio_set_dir(u8 port, u8 dir)
+{
+#if 0
+	volatile struct gpio_ctrl_reg *reg;
+
+	reg = (volatile struct gpio_ctrl_reg *)(GPIO_CHIP_USC28C_OFFSET);
+	if (dir) {
+		reg->dir |= 1 << ((u32) (port - ARM_GPIO_BASE_CNT)); // OUTPUT MODE.
+	} else {
+		reg->dir &= ~((u32)(1 << ((u32) (port - ARM_GPIO_BASE_CNT)))); // INPUT MODE.
+	}
+	reg->msk |= (1 << (u32)(port - ARM_GPIO_BASE_CNT)); // OUTPUT MODE.
+#else
+	u32 value;
+
+	if (dir) {
+		value = 1 << ((u32) (port - ARM_GPIO_BASE_CNT));
+		value |= __raw_readl(GPIO_CHIP_USC28C_OFFSET + 0x08);
+	} else {
+		value = ~((u32)(1 << ((u32) (port - ARM_GPIO_BASE_CNT))));
+		value &= __raw_readl(GPIO_CHIP_USC28C_OFFSET + 0x08);
+	}
+	__raw_writel(value, GPIO_CHIP_USC28C_OFFSET + 0x08);
+
+	value = (1 << (u32)(port - ARM_GPIO_BASE_CNT));
+	value |= __raw_readl(GPIO_CHIP_USC28C_OFFSET + 0x04);
+	__raw_writel(value, GPIO_CHIP_USC28C_OFFSET + 0x04);
+#endif
+}
+
+static void gpio_out(u8 port, u8 data)
+{
+#if 0
+	volatile struct gpio_ctrl_reg *reg;
+
+	reg = (volatile struct gpio_ctrl_reg *)(GPIO_CHIP_USC28C_OFFSET);
+	if (data) {
+		reg->data |= (1 << (u32)(port - ARM_GPIO_BASE_CNT)); // set 1.
+	} else {
+		reg->data &= ~(1 << (u32)(port - ARM_GPIO_BASE_CNT)); // set 0.
+	}
+#else
+	u32 value;
+
+	if (data) {
+		value = (1 << (u32)(port - ARM_GPIO_BASE_CNT));
+		value |= __raw_readl(GPIO_CHIP_USC28C_OFFSET);
+	} else {
+		value = ~(1 << (u32)(port - ARM_GPIO_BASE_CNT));
+		value &= __raw_readl(GPIO_CHIP_USC28C_OFFSET);
+	}
+	__raw_writel(value, GPIO_CHIP_USC28C_OFFSET);
+#endif
+}
+
+static void gpio_out_combo(u32 sclk, u32 sen, u32 dat)
+{
+#if 0
+	volatile struct gpio_ctrl_reg *reg;
+	u32 read_dat;
+	u32 reg_set = 0;
+
+	reg = (volatile struct gpio_ctrl_reg *)(GPIO_CHIP_USC28C_OFFSET);
+
+	if (sclk) {
+		reg_set |= SPI_USC28C_SCK_GPIO_MASK;
+	}
+	if (sen) {
+		reg_set |= SPI_USC28C_SEN_GPIO_MASK;
+	}
+	if (dat) {
+		reg_set |= SPI_USC28C_DAT_GPIO_MASK;
+	}
+	read_dat = reg->data;
+	read_dat &= ~(SPI_USC28C_SCK_GPIO_MASK | SPI_USC28C_SEN_GPIO_MASK
+			| SPI_USC28C_DAT_GPIO_MASK);
+	read_dat |= reg_set;
+	reg->data = read_dat;
+#else
+	u32 value;
+	u32 reg_set = 0;
+
+	if (sclk) {
+		reg_set |= SPI_USC28C_SCK_GPIO_MASK;
+	}
+	if (sen) {
+		reg_set |= SPI_USC28C_SEN_GPIO_MASK;
+	}
+	if (dat) {
+		reg_set |= SPI_USC28C_DAT_GPIO_MASK;
+	}
+
+	value = __raw_readl(GPIO_CHIP_USC28C_OFFSET);
+	value &= ~(SPI_USC28C_SCK_GPIO_MASK | SPI_USC28C_SEN_GPIO_MASK
+			| SPI_USC28C_DAT_GPIO_MASK);
+	value |= reg_set;
+	__raw_writel(value, GPIO_CHIP_USC28C_OFFSET);
+#endif
+}
+
+static u8 gpio_in(u8 port)
+{
+#if 0
+	volatile struct gpio_ctrl_reg *reg;
+	u32 data;
+
+	reg = (volatile struct gpio_ctrl_reg *)(GPIO_CHIP_USC28C_OFFSET);
+
+	data = reg->data;
+	if (data & (1 << (port - ARM_GPIO_BASE_CNT))) {
+		return 1;
+	}
+	return 0;
+#else
+	u32 value;
+
+	value = __raw_readl(GPIO_CHIP_USC28C_OFFSET);
+	if (value & (1 << (port - ARM_GPIO_BASE_CNT))) {
+		return 1;
+	}
+	return 0;
+#endif
+}
+
+static void __usc28c_spi_init(void)
+{
+	gpio_set_dir(SPI_USC28C_SCK_GPIO_PIN, 1);
+	gpio_set_dir(SPI_USC28C_SEN_GPIO_PIN, 1);
+	gpio_set_dir(SPI_USC28C_DAT_GPIO_PIN, 1);
+
+	gpio_out(SPI_USC28C_SCK_GPIO_PIN, 0);
+	gpio_out(SPI_USC28C_SEN_GPIO_PIN, 1);
+	gpio_out(SPI_USC28C_DAT_GPIO_PIN, 0);
+}
+
+static void __spi_reg_w(u16 reg, u16 val)
+{
+	s8 i;
+	u8 temp = 0;
+
+	gpio_set_dir(SPI_USC28C_SCK_GPIO_PIN, 1);
+	gpio_set_dir(SPI_USC28C_SEN_GPIO_PIN, 1);
+	gpio_set_dir(SPI_USC28C_DAT_GPIO_PIN, 1);
+
+	gpio_out_combo(0, 1, 0);
+	udelay(SPI_CLK_DELAY);
+	if (val & (1 << 15)) {
+		gpio_out_combo(0, 0, 1);
+	} else {
+		gpio_out_combo(0, 0, 0);
+	}
+	udelay(SPI_CLK_DELAY);
+	gpio_out(SPI_USC28C_SCK_GPIO_PIN, 1);
+	udelay(SPI_CLK_DELAY);
+
+	for (i = 14; i >= 0; i--) {
+		gpio_out_combo(0, 0, val & (1 << i));
+		udelay(SPI_CLK_DELAY);
+		gpio_out(SPI_USC28C_SCK_GPIO_PIN, 1);
+		udelay(SPI_CLK_DELAY);
+	}
+
+	for (i = 1; i >= 0; i--) {
+		gpio_out_combo(0, 0, temp & (1 << i));
+		udelay(SPI_CLK_DELAY);
+		gpio_out(SPI_USC28C_SCK_GPIO_PIN, 1);
+		udelay(SPI_CLK_DELAY);
+	}
+
+	for (i = 15; i >= 0; i--) {
+		gpio_out_combo(0, 0, reg & (1 << i));
+		udelay(SPI_CLK_DELAY);
+		gpio_out(SPI_USC28C_SCK_GPIO_PIN, 1);
+		udelay(SPI_CLK_DELAY);
+	}
+	udelay(SPI_CLK_DELAY);
+	gpio_out_combo(0, 1, 1);
+}
+
+static u16 __spi_reg_r(u16 reg)
+{
+	s8 i;
+	u16 recv = 0;
+
+	__spi_reg_w(SPI_READ_REG, reg);
+	gpio_set_dir(SPI_USC28C_DAT_GPIO_PIN, 0);
+
+	gpio_out(SPI_USC28C_SCK_GPIO_PIN, 1);
+	udelay(SPI_CLK_DELAY);
+	gpio_out(SPI_USC28C_SCK_GPIO_PIN, 0);
+
+	for (i = 15; i >= 0; i--) {
+		udelay(SPI_CLK_DELAY);
+		gpio_out(SPI_USC28C_SCK_GPIO_PIN, 1);
+		recv <<= 1;
+		udelay(SPI_CLK_DELAY);
+		recv |= gpio_in(SPI_USC28C_DAT_GPIO_PIN);
+		gpio_out(SPI_USC28C_SCK_GPIO_PIN, 0);
+	}
+
+	return recv;
+}
+
+void usc28c_csi_init(void)
+{
+	static u32 initialized = 0;
+	u32 base_addr;
+
+	if (initialized) {
+		/* already initialized */
+		return;
+	}
+
+	base_addr = ioremap(CTL_BASE_ENABLE_USC28C_CSI, 0x10);
+	pr_info("%s: usc28c base addr: 0x%x\n", __func__, base_addr);
+	__raw_writel(0x1000, base_addr);
+
+	__usc28c_spi_init();
+
+	/* reg 0x00:
+	    bit0: DSI power switch (normal function set 1)
+	    bit1: CSI power switch for V1 (normal function set 1)
+	    bit2: CSI power switch for V2 (normal function set 1)
+	    bit3: CSI select signal (0 for V1, 1 for V2)
+
+	    reg 0x10:
+	    0x02 for DSI mode, 0x03 for CSI mode
+	*/
+	__spi_reg_w(0x00, 0x0f);
+	__spi_reg_w(0x10, 0x03);
+	pr_info("%s: chip usc28c csi mode is chosen\n", __func__);
+
+	pr_info("Reg0x%04x, value: 0x%04x and Reg0x%04x, value: 0x%04x\n",
+			0x0, __spi_reg_r(0x0), 0x10, __spi_reg_r(0x10));
+
+	initialized = 1;
+}
+
diff --git a/drivers/media/sprd_sensor/otp/Makefile b/drivers/media/sprd_sensor/otp/Makefile
new file mode 100644
index 00000000..17f91f11
--- /dev/null
+++ b/drivers/media/sprd_sensor/otp/Makefile
@@ -0,0 +1,6 @@
+
+ifeq ($(CONFIG_MACH_GRANDPRIME3G_VE),y)
+obj-y += sensor_otp_coreprime3g_ve.o
+else
+obj-y += sensor_otp.o
+endif
diff --git a/drivers/media/sprd_sensor/otp/sensor_otp.c b/drivers/media/sprd_sensor/otp/sensor_otp.c
new file mode 100644
index 00000000..53075776
--- /dev/null
+++ b/drivers/media/sprd_sensor/otp/sensor_otp.c
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <video/sensor_drv_k.h>
+
+int sensor_reloadinfo_thread(void *data)
+{
+	int ret = 0;
+	return ret;
+}
diff --git a/drivers/media/sprd_sensor/otp/sensor_otp.h b/drivers/media/sprd_sensor/otp/sensor_otp.h
new file mode 100644
index 00000000..ae8ca508
--- /dev/null
+++ b/drivers/media/sprd_sensor/otp/sensor_otp.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _SENSOR_OTP_H_
+#define _SENSOR_OTP_H_
+
+int sensor_reloadinfo_thread(void *data);
+#endif
diff --git a/drivers/media/sprd_sensor/otp/sensor_otp_coreprime3g_ve.c b/drivers/media/sprd_sensor/otp/sensor_otp_coreprime3g_ve.c
new file mode 100644
index 00000000..927ffbd5
--- /dev/null
+++ b/drivers/media/sprd_sensor/otp/sensor_otp_coreprime3g_ve.c
@@ -0,0 +1,268 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <linux/kthread.h>
+#include <linux/fs.h>
+
+#include <video/sensor_drv_k.h>
+#include <linux/vmalloc.h>
+#include <linux/sprd_mm.h>
+
+#include "sensor_otp.h"
+
+
+#define DW9807_EEPROM_SLAVE_ADDR  (0xB0 >> 1)
+
+#define SENSOR_SUCCESS      0
+#define cmr_bzero(b, len)                     memset((b), '\0', (len))
+#define cmr_copy(b, a, len)                   memcpy((b), (a), (len))
+
+
+enum sensor_cmd {
+  SENSOR_ACCESS_VAL,
+};
+
+typedef enum {
+  SENSOR_VAL_TYPE_READ_OTP,
+} SENSOR_IOCTL_VAL_TYPE;
+
+
+typedef struct _sensor_val_tag {
+  uint8_t type;
+  void *pval;
+} SENSOR_VAL_T, *SENSOR_VAL_T_PTR;
+
+struct isp_data_t {
+  uint32_t size;
+  void *data_ptr;
+};
+
+
+	//static struct task_struct * otp_task = NULL;
+static struct file *pfile = NULL;
+static struct file *pdebugfile = NULL;
+
+static int z_ioctl (struct file *f, unsigned int cmd, unsigned long arg)
+{
+  if (f->f_op->compat_ioctl)
+    return f->f_op->compat_ioctl (f, cmd, arg);
+  else if (f->f_op->unlocked_ioctl)
+    return f->f_op->unlocked_ioctl (f, cmd, arg);
+}
+
+static void Sensor_PowerOn (uint32_t power_on)
+{
+  struct sensor_power_info_tag power_cfg;
+  uint32_t mclk = 24;
+
+  memset (&power_cfg, 0, sizeof (struct sensor_power_info_tag));
+  power_cfg.op_sensor_id = 0;
+  if (power_on)  {
+      power_cfg.is_on = 1;
+    } else {
+      power_cfg.is_on = 0;
+    }
+  z_ioctl (pfile, SENSOR_IO_POWER_CFG, &power_cfg);
+
+  if (power_on) {
+      z_ioctl (pfile, SENSOR_IO_SET_MCLK, &mclk);
+    }
+}
+
+static int Sensor_WriteI2C (uint16_t slave_addr, uint8_t * cmd, uint16_t cmd_length)
+{
+  struct sensor_i2c_tag i2c_tab;
+  int ret = SENSOR_SUCCESS;
+
+  i2c_tab.slave_addr = slave_addr;
+  i2c_tab.i2c_data = cmd;
+  i2c_tab.i2c_count = cmd_length;
+
+  MM_TRACE ("Sensor_ReadI2C, slave_addr=0x%x, ptr=0x%p, count=%d\n",
+	    i2c_tab.slave_addr, i2c_tab.i2c_data, i2c_tab.i2c_count);
+
+  ret = z_ioctl (pfile, SENSOR_IO_I2C_WRITE_EXT, &i2c_tab);
+
+  return ret;
+}
+
+static int Sensor_ReadI2C (uint16_t slave_addr, uint8_t * cmd, uint16_t cmd_length)
+{
+  struct sensor_i2c_tag i2c_tab;
+  int ret = SENSOR_SUCCESS;
+
+  i2c_tab.slave_addr = slave_addr;
+  i2c_tab.i2c_data = cmd;
+  i2c_tab.i2c_count = cmd_length;
+
+//       MM_TRACE("Sensor_ReadI2C, slave_addr=0x%x, ptr=0x%p, count=%d\n",
+//            i2c_tab.slave_addr, i2c_tab.i2c_data, i2c_tab.i2c_count);
+
+  ret = z_ioctl (pfile, SENSOR_IO_I2C_READ_EXT, &i2c_tab);
+
+  return ret;
+}
+
+static uint32_t _read_otp (void *sensor_handle, int sensor_id, int cmd, long arg)
+{
+  uint32_t rtn = SENSOR_SUCCESS;
+  SENSOR_OTP_PARAM_T *param_ptr = (SENSOR_OTP_PARAM_T *) (((SENSOR_VAL_T *) arg)->pval);
+  uint32_t start_addr = 0;
+  uint32_t len = 0;
+  uint8_t *buff = NULL;
+  uint8_t cmd_val[3] = { 0x00 };
+  uint16_t cmd_len;
+  uint32_t i;
+
+  if (NULL == param_ptr) {
+      return -1;
+    }
+
+  MM_TRACE ("SENSOR_s5k4h5yc: _s5k4h5yc_read_otp E\n");
+
+  cmd_len = 2;
+  cmd_val[0] = 0x00;
+  cmd_val[1] = 0x00;
+  rtn = Sensor_WriteI2C (DW9807_EEPROM_SLAVE_ADDR, (uint8_t *) & cmd_val[0], cmd_len);
+  udelay (1000);		//usleep(1000);
+
+  MM_TRACE ("write i2c rtn %d type %d\n", rtn, param_ptr->type);
+
+  buff = param_ptr->buff;
+  if (SENSOR_OTP_PARAM_NORMAL == param_ptr->type) {
+      start_addr = param_ptr->start_addr;
+      len = 8192;
+    } else if (SENSOR_OTP_PARAM_CHECKSUM == param_ptr->type) {
+      start_addr = 0xFC;
+      len = 4;
+    } else if (SENSOR_OTP_PARAM_READBYTE == param_ptr->type) {
+      start_addr = param_ptr->start_addr;
+      len = param_ptr->len;
+    }
+
+  // EEPROM READ
+  for (i = 0; i < len; i++) {
+      cmd_val[0] = ((start_addr + i) >> 8) & 0xff;
+      cmd_val[1] = (start_addr + i) & 0xff;
+      rtn =	Sensor_ReadI2C (DW9807_EEPROM_SLAVE_ADDR, (uint8_t *) & cmd_val[0], cmd_len);
+      if (SENSOR_SUCCESS == rtn) {
+	  buff[i] = (cmd_val[0]) & 0xff;
+	}
+      //MM_TRACE("rtn %d value %d addr 0x%x\ns", rtn, buff[i], start_addr + i);
+    }
+  param_ptr->len = len;
+
+  MM_TRACE ("SENSOR_s5k4h5yc: _s5k4h5yc_read_otp X\n");
+
+  return rtn;
+
+}
+
+int sensor_reloadinfo_thread (void *data)
+{
+  int32_t rtn = 0;
+  int ret = 0;
+  SENSOR_OTP_PARAM_T *param_ptr = (SENSOR_OTP_PARAM_T *) data;
+
+  uint32_t clock = 400000;
+
+  loff_t otp_start_addr = 0;
+  uint32_t otp_data_len = 0;
+  SENSOR_VAL_T val;
+  struct isp_data_t checksum_otp;
+  struct isp_data_t sensor_otp;
+  uint32_t is_need_checksum = 0;
+
+  MM_TRACE ("sensor_reloadinfo_thread start\n");
+  msleep (2500);
+
+  cmr_bzero (&checksum_otp, sizeof (checksum_otp));
+  cmr_bzero (&sensor_otp, sizeof (sensor_otp));
+  cmr_bzero (param_ptr, sizeof (SENSOR_OTP_PARAM_T));
+
+  pfile = filp_open ("/dev/sprd_sensor", O_RDWR, 0);
+  if (IS_ERR (pfile)) {
+      MM_TRACE ("open /dev/sprd_sensor failed\n");
+      return -1;
+    }
+  Sensor_PowerOn (1);
+
+  ret = z_ioctl (pfile, SENSOR_IO_SET_I2CCLOCK, &clock);
+
+  //checksum
+  checksum_otp.size = 4;
+  checksum_otp.data_ptr = vmalloc (checksum_otp.size);
+  if (NULL == checksum_otp.data_ptr) {
+      MM_TRACE ("malloc checksum_otp buffer failed\n");
+      goto EXIT;
+    }
+
+  cmr_bzero (param_ptr, sizeof (SENSOR_OTP_PARAM_T));
+  param_ptr->start_addr = 0;
+  param_ptr->len = checksum_otp.size;
+  param_ptr->buff = checksum_otp.data_ptr;
+  param_ptr->type = SENSOR_OTP_PARAM_CHECKSUM;
+  val.type = SENSOR_VAL_TYPE_READ_OTP;
+  val.pval = param_ptr;
+  ret = _read_otp (NULL, 0, SENSOR_ACCESS_VAL, (long) &val);
+  if (ret || 0 == param_ptr->len) {
+      MM_TRACE ("read otp data checksum failed\n");
+      goto EXIT;
+    }
+
+  /*read lsc, awb from real otp */
+  //camera_calibrationconfigure_load(&otp_start_addr, &otp_data_len);
+  otp_data_len = 8192;
+  sensor_otp.data_ptr = vmalloc (otp_data_len);
+  if (NULL == sensor_otp.data_ptr) {
+      MM_TRACE ("malloc random lsc file failed\n");
+      goto EXIT;
+    }
+
+  cmr_bzero (param_ptr, sizeof (SENSOR_OTP_PARAM_T));
+  param_ptr->start_addr = 0;
+  param_ptr->len = 0;
+  param_ptr->buff = sensor_otp.data_ptr;
+  param_ptr->type = SENSOR_OTP_PARAM_NORMAL;
+  val.type = SENSOR_VAL_TYPE_READ_OTP;
+  val.pval = param_ptr;
+  ret = _read_otp (NULL, 0, SENSOR_ACCESS_VAL, (long) &val);
+  if (ret || 0 == param_ptr->len) {
+      MM_TRACE ("read otp data failed\n");
+      goto EXIT;
+    }
+  param_ptr->golden.size = checksum_otp.size;
+  param_ptr->golden.data_ptr = checksum_otp.data_ptr;
+#if 0
+	pdebugfile = filp_open ("/data/otp.bin", O_CREAT|O_RDWR, 0);
+	if (IS_ERR (pdebugfile)) {
+		MM_TRACE ("open /data/otp.bin failed\n");
+		return -1;
+	  }
+	vfs_write(pdebugfile, param_ptr->buff,otp_data_len, &otp_start_addr);
+	filp_close(pdebugfile, NULL);
+#endif
+
+EXIT:
+  filp_close (pfile, NULL);
+  Sensor_PowerOn (0);
+  MM_TRACE ("sensor_reloadinfo_thread end\n");
+  return rtn;
+}
diff --git a/drivers/media/sprd_sensor/power/Makefile b/drivers/media/sprd_sensor/power/Makefile
new file mode 100755
index 00000000..cba96600
--- /dev/null
+++ b/drivers/media/sprd_sensor/power/Makefile
@@ -0,0 +1,22 @@
+
+ifeq ($(CONFIG_MACH_COREPRIMELITE),y)
+obj-y += sensor_power_coreprimelite.o
+else ifeq ($(CONFIG_MACH_TSHARK2TABE),y)
+obj-y += sensor_power_tshark2tabe.o
+else ifeq ($(CONFIG_MACH_GRANDPRIME3G_VE),y)
+obj-y += sensor_power_grandprime3g_ve.o
+else ifeq ($(CONFIG_MACH_SS_SHARKLT8),y)
+obj-y += sensor_power_sharkl_t8.o
+else ifeq ($(CONFIG_MACH_SS_SHARKLT8LIGHTSLEEP),y)
+obj-y += sensor_power_sharkl_t8.o
+else ifeq ($(CONFIG_MACH_GRANDPRIME_DTV),y)
+obj-y += sensor_power_grandprime_dtv.o
+else ifeq ($(CONFIG_MACH_COREPRIME3G_VE),y)
+obj-y += sensor_power_coreprime3g_ve.o
+else ifeq ($(CONFIG_MACH_SHARKLS_Z3LTE),y)
+obj-y += sensor_power_sharkls_z3lte.o
+else ifeq ($(CONFIG_MACH_TIZENZ3_3G),y)
+obj-y += sensor_power_sharkls_z3lte.o
+else
+obj-y += sensor_power.o
+endif
diff --git a/drivers/media/sprd_sensor/power/sensor_power.c b/drivers/media/sprd_sensor/power/sensor_power.c
new file mode 100644
index 00000000..85957fe9
--- /dev/null
+++ b/drivers/media/sprd_sensor/power/sensor_power.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/kernel.h>
+//#include <mach/hardware.h>
+//#include <mach/board.h>
+#include <video/sensor_drv_k.h>
+#include "../sensor_drv_sprd.h"
+
+
+int sensor_power_on(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+	(void)sensor_id;(void)dev0;(void)dev1;(void)dev2;
+
+	return ret;
+}
+
+int sensor_power_off(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+	(void)sensor_id;(void)dev0;(void)dev1;(void)dev2;
+
+
+	return ret;
+}
diff --git a/drivers/media/sprd_sensor/power/sensor_power.h b/drivers/media/sprd_sensor/power/sensor_power.h
new file mode 100644
index 00000000..f7769dfd
--- /dev/null
+++ b/drivers/media/sprd_sensor/power/sensor_power.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _SENSOR_POWER_H_
+#define _SENSOR_POWER_H_
+
+#include <linux/types.h>
+
+int sensor_power_on(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2);
+int sensor_power_off(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2);
+#endif
diff --git a/drivers/media/sprd_sensor/power/sensor_power_coreprime3g_ve.c b/drivers/media/sprd_sensor/power/sensor_power_coreprime3g_ve.c
new file mode 100755
index 00000000..d0be249d
--- /dev/null
+++ b/drivers/media/sprd_sensor/power/sensor_power_coreprime3g_ve.c
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <soc/sprd/hardware.h>
+#include <soc/sprd/board.h>
+#include "../sensor_drv_sprd.h"
+
+static int sensor_s5k4ecgx_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	/*set default status for main and sub sensor*/
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select sub sensor(sensor hi255);
+	sensor_k_set_pd_level(fd_handle,0);//power down valid for hi255
+	sensor_k_set_rst_level(fd_handle,0);//reset valid for hi255
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor(sensor hi544);
+	sensor_k_set_pd_level(fd_handle,0);//power down valid for hi544
+	sensor_k_set_rst_level(fd_handle,0);//reset valid for hi544
+	mdelay(1);
+
+	/*power on sequence*/
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_2800MV);//AF monitor
+	mdelay(1);//delay
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);//IO vdd
+	udelay(500);//delay >2ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);//anolog vdd
+	udelay(1000);//delay > 0us
+	sensor_k_set_mclk(fd_handle,24);
+	udelay(500);//delay > 0us
+	sensor_k_set_voltage_dvdd(fd_handle,SENSOR_VDD_1200MV);//core vdd
+	udelay(1000);//delay >= 10us
+	sensor_k_set_pd_level(fd_handle,1);//power down
+	udelay(30);//delay >= 15us
+	sensor_k_set_rst_level(fd_handle,1);//reset
+	udelay(100);//delay > 60us
+	printk("sensor_s5k4ecgx_poweron OK \n");
+	return ret;
+}
+
+static int sensor_s5k4ecgx_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor(sensor hi544);
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_rst_level(fd_handle,0);//reset valid for hi544
+	udelay(100);//delay >50us
+	sensor_k_set_mclk(fd_handle,0);// disable mclk
+	udelay(100);//delay >= 0us
+	sensor_k_set_pd_level(fd_handle,0);//power down valid for hi544
+	udelay(100);//delay < 10ms
+	sensor_k_set_voltage_iovdd(fd_handle,SENSOR_VDD_CLOSED);
+	udelay(10);//delay < 10ms
+	sensor_k_set_voltage_avdd(fd_handle,SENSOR_VDD_CLOSED);//close anolog vdd
+	mdelay(5);//delay >= 0us
+	sensor_k_set_voltage_dvdd(fd_handle,SENSOR_VDD_CLOSED);//close core vdd
+	mdelay(1);//delay
+	sensor_k_set_voltage_cammot(fd_handle,SENSOR_VDD_CLOSED);//AF monitor
+	udelay(10);//delay
+
+	printk("sensor_s5k4ecgx_poweroff OK \n");
+	return ret;
+
+}
+
+
+static int sensor_hi255_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor(sensor hi544);
+	sensor_k_set_pd_level(fd_handle,0);//power down valid for hi544
+	sensor_k_set_rst_level(fd_handle,0);//reset valid for hi544
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor(sensor hi255);
+	sensor_k_set_pd_level(fd_handle,0);//power down valid for hi255
+	sensor_k_set_rst_level(fd_handle,0);//reset valid for hi255
+	udelay(1);
+	sensor_k_set_voltage_iovdd(fd_handle,SENSOR_VDD_1800MV);//IO vdd
+	udelay(10);//delay 6ms < 10ms
+	sensor_k_set_voltage_avdd(fd_handle,SENSOR_VDD_2800MV);
+	udelay(10);
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);
+	sensor_k_set_voltage_dvdd(fd_handle,SENSOR_VDD_1200MV);//core vdd
+	mdelay(2);
+	sensor_k_set_voltage_dvdd(fd_handle,SENSOR_VDD_CLOSED);//close core vdd
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_pd_level(fd_handle,1);
+	mdelay(2);//delay 2ms > 1ms
+	sensor_k_set_mclk(fd_handle,24);
+	mdelay(31);//delay 30ms >= 30ms
+	sensor_k_set_rst_level(fd_handle,1);
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	printk("hi255_poweron OK \n");
+
+	return ret;
+}
+
+static int sensor_hi255_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor(sensor hi255);
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_rst_level(fd_handle,0);//reset valid for hi255
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_mclk(fd_handle,0);// disable mclk
+	udelay(1);//delay 1us > 0ns
+	sensor_k_set_pd_level(fd_handle,0);//power down valid for hi255
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_voltage_avdd(fd_handle,SENSOR_VDD_CLOSED);
+	//mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_voltage_iovdd(fd_handle,SENSOR_VDD_CLOSED);
+	udelay(1);
+	printk("hi255_poweroff OK \n");
+
+	return ret;
+}
+
+int sensor_power_on(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	if (SENSOR_DEV_0 == sensor_id) {
+		ret = sensor_s5k4ecgx_poweron(fd_handle, dev0, dev1, dev2);
+	} else if (SENSOR_DEV_1 == sensor_id) {
+		ret = sensor_hi255_poweron(fd_handle, dev0, dev1, dev2);
+	}
+	return ret;
+}
+
+int sensor_power_off(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	if (SENSOR_DEV_0 == sensor_id) {
+		ret = sensor_s5k4ecgx_poweroff(fd_handle, dev0, dev1, dev2);
+	} else if (SENSOR_DEV_1 == sensor_id) {
+		ret = sensor_hi255_poweroff(fd_handle, dev0, dev1, dev2);
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_sensor/power/sensor_power_coreprimelite.c b/drivers/media/sprd_sensor/power/sensor_power_coreprimelite.c
new file mode 100644
index 00000000..e7d2010c
--- /dev/null
+++ b/drivers/media/sprd_sensor/power/sensor_power_coreprimelite.c
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <soc/sprd/hardware.h>
+#include <soc/sprd/board.h>
+#include <video/sensor_drv_k.h>
+#include "../sensor_drv_sprd.h"
+
+static int sensor_s5k4ecgx_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	/*set default status for main and sub sensor*/
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select sub sensor(sensor hi255);
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi255
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi255
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor(sensor hi544);
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi544
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi544
+	mdelay(1);
+
+	/*power on sequence*/
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_2800MV);//AF monitor
+	mdelay(1);//delay
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);//IO vdd
+	udelay(500);//delay >2ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);//anolog vdd
+	udelay(1000);//delay > 0us
+	sensor_k_set_mclk(fd_handle, 24);
+	udelay(500);//delay > 0us
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_1200MV);//core vdd
+	udelay(1000);//delay >= 10us
+	sensor_k_set_pd_level(fd_handle, 1);//power down
+	udelay(30);//delay >= 15us
+	sensor_k_set_rst_level(fd_handle, 1);//reset
+	udelay(100);//delay > 60us
+	printk("sensor_s5k4ecgx_poweron OK \n");
+	return ret;
+}
+
+static int sensor_s5k4ecgx_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor(sensor hi544);
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi544
+	udelay(100);//delay >50us
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+	udelay(100);//delay >= 0us
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi544
+	udelay(100);//delay < 10ms
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+	udelay(10);//delay < 10ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);//close anolog vdd
+	mdelay(5);//delay >= 0us
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_CLOSED);//close core vdd
+	mdelay(1);//delay
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_CLOSED);//AF monitor
+	udelay(10);//delay
+
+	printk("sensor_s5k4ecgx_poweroff OK \n");
+	return ret;
+
+}
+
+static int sensor_hi255_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor(sensor hi544);
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi544
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi544
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor(sensor hi255);
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi255
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi255
+	udelay(1);
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);//IO vdd
+	udelay(10);//delay 6ms < 10ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);
+	udelay(10);
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_1200MV);//core vdd
+	mdelay(2);
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_CLOSED);//close core vdd
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_pd_level(fd_handle, 1);
+	mdelay(2);//delay 2ms > 1ms
+	sensor_k_set_mclk(fd_handle, 24);
+	mdelay(31);//delay 30ms >= 30ms
+	sensor_k_set_rst_level(fd_handle, 1);
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	printk("hi255_poweron OK \n");
+
+	return ret;
+}
+
+static int sensor_hi255_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor(sensor hi255);
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi255
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+	udelay(1);//delay 1us > 0ns
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi255
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);
+	//mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+	udelay(1);
+	printk("hi255_poweroff OK \n");
+
+	return ret;
+}
+
+
+int sensor_power_on(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	if (SENSOR_DEV_0 == sensor_id) {
+		ret = sensor_s5k4ecgx_poweron(fd_handle, dev0, dev1, dev2);
+	} else if (SENSOR_DEV_1 == sensor_id) {
+		ret = sensor_hi255_poweron(fd_handle, dev0, dev1, dev2);
+	}
+	return ret;
+}
+
+int sensor_power_off(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	if (SENSOR_DEV_0 == sensor_id) {
+		ret = sensor_s5k4ecgx_poweroff(fd_handle, dev0, dev1, dev2);
+	} else if (SENSOR_DEV_1 == sensor_id) {
+		ret = sensor_hi255_poweroff(fd_handle, dev0, dev1, dev2);
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_sensor/power/sensor_power_grandprime3g_ve.c b/drivers/media/sprd_sensor/power/sensor_power_grandprime3g_ve.c
new file mode 100644
index 00000000..fe5c25db
--- /dev/null
+++ b/drivers/media/sprd_sensor/power/sensor_power_grandprime3g_ve.c
@@ -0,0 +1,247 @@
+/*
+
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+
+ *
+
+ * This software is licensed under the terms of the GNU General Public
+
+ * License version 2, as published by the Free Software Foundation, and
+
+ * may be copied, distributed, and modified under those terms.
+
+ *
+
+ * This program is distributed in the hope that it will be useful,
+
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+
+ * GNU General Public License for more details.
+
+ */
+
+#include <linux/module.h>
+
+#include <linux/kernel.h>
+
+#include <linux/init.h>
+
+#include <linux/bitops.h>
+
+#include <linux/delay.h>
+
+#include <linux/kernel.h>
+
+#include <soc/sprd/hardware.h>
+
+#include <soc/sprd/board.h>
+
+#include "../sensor_drv_sprd.h"
+
+
+
+static int sensor_s5k4h5yc_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select sub sensor
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	udelay(100);
+
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_2800MV);
+	udelay(10);
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_1200MV);
+	udelay(10);
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);
+	udelay(10);
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);
+	mdelay(2);//delay 2ms > 1ms
+	sensor_k_set_rst_level(fd_handle, 1);
+	udelay(750);
+	sensor_k_set_mclk(fd_handle, 24);
+	mdelay(2);//delay 6ms < 10ms
+	//sensor_k_set_pd_level(fd_handle, 1);
+//	mdelay(30);//delay 30ms >= 30ms
+	printk("s5k4h5yc_poweron OK \n");
+	return ret;
+}
+
+
+
+static int sensor_s5k4h5yc_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select sub sensor
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor
+
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_CLOSED);
+
+	udelay(10);
+
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	mdelay(6);//delay 6ms < 10ms
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	mdelay(2);//delay 2us > 16MCLK = 16/24 us
+
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	mdelay(2);
+
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	mdelay(2);
+
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	mdelay(6);//delay 6ms < 10ms
+
+	printk("s5k4h5yc_poweroff OK \n");
+return ret;
+
+}
+
+
+
+static int sensor_s5k5e3yx_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select sub sensor
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_1200MV);
+
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);
+
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);
+
+	udelay(50);
+
+	sensor_k_set_rst_level(fd_handle, 1);
+
+	udelay(250);
+
+	sensor_k_set_mclk(fd_handle, 24);
+
+	udelay(200);//delay 6ms < 10ms
+
+	printk("s5k5e3yx poweron OK \n");
+
+	return ret;
+
+}
+
+
+
+static int sensor_s5k5e3yx_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor
+
+	udelay(100);//delay 2us > 16MCLK = 16/24 us
+
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+	printk("s5k5e3yx poweroff OK \n");
+	return ret;
+
+}
+
+
+
+int sensor_power_on(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+
+
+	if (SENSOR_DEV_0 == sensor_id) {
+
+		ret = sensor_s5k4h5yc_poweron(fd_handle, dev0, dev1, dev2);
+
+	} else if (SENSOR_DEV_1 == sensor_id) {
+
+		ret = sensor_s5k5e3yx_poweron(fd_handle, dev0, dev1, dev2);
+
+	}
+
+	return ret;
+
+}
+
+
+
+int sensor_power_off(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+
+
+	if (SENSOR_DEV_0 == sensor_id) {
+
+		ret = sensor_s5k4h5yc_poweroff(fd_handle, dev0, dev1, dev2);
+
+	} else if (SENSOR_DEV_1 == sensor_id) {
+
+		ret = sensor_s5k5e3yx_poweroff(fd_handle, dev0, dev1, dev2);
+
+	}
+
+
+
+	return ret;
+
+}
+
diff --git a/drivers/media/sprd_sensor/power/sensor_power_grandprime_dtv.c b/drivers/media/sprd_sensor/power/sensor_power_grandprime_dtv.c
new file mode 100755
index 00000000..fe5c25db
--- /dev/null
+++ b/drivers/media/sprd_sensor/power/sensor_power_grandprime_dtv.c
@@ -0,0 +1,247 @@
+/*
+
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+
+ *
+
+ * This software is licensed under the terms of the GNU General Public
+
+ * License version 2, as published by the Free Software Foundation, and
+
+ * may be copied, distributed, and modified under those terms.
+
+ *
+
+ * This program is distributed in the hope that it will be useful,
+
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+
+ * GNU General Public License for more details.
+
+ */
+
+#include <linux/module.h>
+
+#include <linux/kernel.h>
+
+#include <linux/init.h>
+
+#include <linux/bitops.h>
+
+#include <linux/delay.h>
+
+#include <linux/kernel.h>
+
+#include <soc/sprd/hardware.h>
+
+#include <soc/sprd/board.h>
+
+#include "../sensor_drv_sprd.h"
+
+
+
+static int sensor_s5k4h5yc_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select sub sensor
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	udelay(100);
+
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_2800MV);
+	udelay(10);
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_1200MV);
+	udelay(10);
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);
+	udelay(10);
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);
+	mdelay(2);//delay 2ms > 1ms
+	sensor_k_set_rst_level(fd_handle, 1);
+	udelay(750);
+	sensor_k_set_mclk(fd_handle, 24);
+	mdelay(2);//delay 6ms < 10ms
+	//sensor_k_set_pd_level(fd_handle, 1);
+//	mdelay(30);//delay 30ms >= 30ms
+	printk("s5k4h5yc_poweron OK \n");
+	return ret;
+}
+
+
+
+static int sensor_s5k4h5yc_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select sub sensor
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor
+
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_CLOSED);
+
+	udelay(10);
+
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	mdelay(6);//delay 6ms < 10ms
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	mdelay(2);//delay 2us > 16MCLK = 16/24 us
+
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	mdelay(2);
+
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	mdelay(2);
+
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	mdelay(6);//delay 6ms < 10ms
+
+	printk("s5k4h5yc_poweroff OK \n");
+return ret;
+
+}
+
+
+
+static int sensor_s5k5e3yx_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select sub sensor
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_1200MV);
+
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);
+
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);
+
+	udelay(50);
+
+	sensor_k_set_rst_level(fd_handle, 1);
+
+	udelay(250);
+
+	sensor_k_set_mclk(fd_handle, 24);
+
+	udelay(200);//delay 6ms < 10ms
+
+	printk("s5k5e3yx poweron OK \n");
+
+	return ret;
+
+}
+
+
+
+static int sensor_s5k5e3yx_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor
+
+	udelay(100);//delay 2us > 16MCLK = 16/24 us
+
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+	printk("s5k5e3yx poweroff OK \n");
+	return ret;
+
+}
+
+
+
+int sensor_power_on(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+
+
+	if (SENSOR_DEV_0 == sensor_id) {
+
+		ret = sensor_s5k4h5yc_poweron(fd_handle, dev0, dev1, dev2);
+
+	} else if (SENSOR_DEV_1 == sensor_id) {
+
+		ret = sensor_s5k5e3yx_poweron(fd_handle, dev0, dev1, dev2);
+
+	}
+
+	return ret;
+
+}
+
+
+
+int sensor_power_off(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+
+
+	if (SENSOR_DEV_0 == sensor_id) {
+
+		ret = sensor_s5k4h5yc_poweroff(fd_handle, dev0, dev1, dev2);
+
+	} else if (SENSOR_DEV_1 == sensor_id) {
+
+		ret = sensor_s5k5e3yx_poweroff(fd_handle, dev0, dev1, dev2);
+
+	}
+
+
+
+	return ret;
+
+}
+
diff --git a/drivers/media/sprd_sensor/power/sensor_power_sharkl_t8.c b/drivers/media/sprd_sensor/power/sensor_power_sharkl_t8.c
new file mode 100644
index 00000000..ad9736e8
--- /dev/null
+++ b/drivers/media/sprd_sensor/power/sensor_power_sharkl_t8.c
@@ -0,0 +1,247 @@
+/*
+
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+
+ *
+
+ * This software is licensed under the terms of the GNU General Public
+
+ * License version 2, as published by the Free Software Foundation, and
+
+ * may be copied, distributed, and modified under those terms.
+
+ *
+
+ * This program is distributed in the hope that it will be useful,
+
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+
+ * GNU General Public License for more details.
+
+ */
+
+#include <linux/module.h>
+
+#include <linux/kernel.h>
+
+#include <linux/init.h>
+
+#include <linux/bitops.h>
+
+#include <linux/delay.h>
+
+#include <linux/kernel.h>
+
+#include <soc/sprd/hardware.h>
+
+#include <soc/sprd/board.h>
+
+#include "../sensor_drv_sprd.h"
+
+
+
+static int sensor_s5k4h5yc_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select sub sensor
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	udelay(100);
+
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_2800MV);
+	udelay(10);
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_1200MV);
+	udelay(10);
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);
+	udelay(10);
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);
+	mdelay(2);//delay 2ms > 1ms
+	sensor_k_set_rst_level(fd_handle, 1);
+	udelay(750);
+	sensor_k_set_mclk(fd_handle, 24);
+	mdelay(2);//delay 6ms < 10ms
+	//sensor_k_set_pd_level(fd_handle, 1);
+//	mdelay(30);//delay 30ms >= 30ms
+	printk("s5k4h5yc_poweron OK \n");
+	return ret;
+}
+
+
+
+static int sensor_s5k4h5yc_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select sub sensor
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor
+
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_CLOSED);
+
+	udelay(10);
+
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	mdelay(6);//delay 6ms < 10ms
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	mdelay(2);//delay 2us > 16MCLK = 16/24 us
+
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	mdelay(2);
+
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	mdelay(2);
+
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	mdelay(6);//delay 6ms < 10ms
+
+	printk("s5k4h5yc_poweroff OK \n");
+return ret;
+
+}
+
+
+
+static int sensor_s5k5e3yx_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select sub sensor
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_1200MV);
+
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);
+
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);
+
+	udelay(50);
+
+	sensor_k_set_rst_level(fd_handle, 1);
+
+	udelay(250);
+
+	sensor_k_set_mclk(fd_handle, 24);
+
+	udelay(200);//delay 6ms < 10ms
+
+	printk("s5k5e3yx poweron OK \n");
+
+	return ret;
+
+}
+
+
+
+static int sensor_s5k5e3yx_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor
+
+	udelay(100);//delay 2us > 16MCLK = 16/24 us
+
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+
+	//sensor_k_set_pd_level(fd_handle, 0);//power down
+
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);
+
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+	printk("s5k5e3yx poweroff OK \n");
+	return ret;
+
+}
+
+
+
+int sensor_power_on(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+
+
+	if (SENSOR_DEV_0 == sensor_id) {
+
+		//ret = sensor_s5k4h5yc_poweron(fd_handle, dev0, dev1, dev2);
+
+	} else if (SENSOR_DEV_1 == sensor_id) {
+
+		ret = sensor_s5k5e3yx_poweron(fd_handle, dev0, dev1, dev2);
+
+	}
+
+	return ret;
+
+}
+
+
+
+int sensor_power_off(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+
+{
+
+	int ret = 0;
+
+
+
+	if (SENSOR_DEV_0 == sensor_id) {
+
+		//ret = sensor_s5k4h5yc_poweroff(fd_handle, dev0, dev1, dev2);
+
+	} else if (SENSOR_DEV_1 == sensor_id) {
+
+		ret = sensor_s5k5e3yx_poweroff(fd_handle, dev0, dev1, dev2);
+
+	}
+
+
+
+	return ret;
+
+}
+
diff --git a/drivers/media/sprd_sensor/power/sensor_power_sharkls_z3lte.c b/drivers/media/sprd_sensor/power/sensor_power_sharkls_z3lte.c
new file mode 100644
index 00000000..e7d2010c
--- /dev/null
+++ b/drivers/media/sprd_sensor/power/sensor_power_sharkls_z3lte.c
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <soc/sprd/hardware.h>
+#include <soc/sprd/board.h>
+#include <video/sensor_drv_k.h>
+#include "../sensor_drv_sprd.h"
+
+static int sensor_s5k4ecgx_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	/*set default status for main and sub sensor*/
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select sub sensor(sensor hi255);
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi255
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi255
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor(sensor hi544);
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi544
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi544
+	mdelay(1);
+
+	/*power on sequence*/
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_2800MV);//AF monitor
+	mdelay(1);//delay
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);//IO vdd
+	udelay(500);//delay >2ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);//anolog vdd
+	udelay(1000);//delay > 0us
+	sensor_k_set_mclk(fd_handle, 24);
+	udelay(500);//delay > 0us
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_1200MV);//core vdd
+	udelay(1000);//delay >= 10us
+	sensor_k_set_pd_level(fd_handle, 1);//power down
+	udelay(30);//delay >= 15us
+	sensor_k_set_rst_level(fd_handle, 1);//reset
+	udelay(100);//delay > 60us
+	printk("sensor_s5k4ecgx_poweron OK \n");
+	return ret;
+}
+
+static int sensor_s5k4ecgx_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor(sensor hi544);
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi544
+	udelay(100);//delay >50us
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+	udelay(100);//delay >= 0us
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi544
+	udelay(100);//delay < 10ms
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+	udelay(10);//delay < 10ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);//close anolog vdd
+	mdelay(5);//delay >= 0us
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_CLOSED);//close core vdd
+	mdelay(1);//delay
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_CLOSED);//AF monitor
+	udelay(10);//delay
+
+	printk("sensor_s5k4ecgx_poweroff OK \n");
+	return ret;
+
+}
+
+static int sensor_hi255_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor(sensor hi544);
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi544
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi544
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor(sensor hi255);
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi255
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi255
+	udelay(1);
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);//IO vdd
+	udelay(10);//delay 6ms < 10ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);
+	udelay(10);
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_1200MV);//core vdd
+	mdelay(2);
+	sensor_k_set_voltage_dvdd(fd_handle, SENSOR_VDD_CLOSED);//close core vdd
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_pd_level(fd_handle, 1);
+	mdelay(2);//delay 2ms > 1ms
+	sensor_k_set_mclk(fd_handle, 24);
+	mdelay(31);//delay 30ms >= 30ms
+	sensor_k_set_rst_level(fd_handle, 1);
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	printk("hi255_poweron OK \n");
+
+	return ret;
+}
+
+static int sensor_hi255_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor(sensor hi255);
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_rst_level(fd_handle, 0);//reset valid for hi255
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+	udelay(1);//delay 1us > 0ns
+	sensor_k_set_pd_level(fd_handle, 0);//power down valid for hi255
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);
+	//mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+	udelay(1);
+	printk("hi255_poweroff OK \n");
+
+	return ret;
+}
+
+
+int sensor_power_on(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	if (SENSOR_DEV_0 == sensor_id) {
+		ret = sensor_s5k4ecgx_poweron(fd_handle, dev0, dev1, dev2);
+	} else if (SENSOR_DEV_1 == sensor_id) {
+		ret = sensor_hi255_poweron(fd_handle, dev0, dev1, dev2);
+	}
+	return ret;
+}
+
+int sensor_power_off(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	if (SENSOR_DEV_0 == sensor_id) {
+		ret = sensor_s5k4ecgx_poweroff(fd_handle, dev0, dev1, dev2);
+	} else if (SENSOR_DEV_1 == sensor_id) {
+		ret = sensor_hi255_poweroff(fd_handle, dev0, dev1, dev2);
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_sensor/power/sensor_power_tshark2tabe.c b/drivers/media/sprd_sensor/power/sensor_power_tshark2tabe.c
new file mode 100755
index 00000000..4cfa6f18
--- /dev/null
+++ b/drivers/media/sprd_sensor/power/sensor_power_tshark2tabe.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/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <soc/sprd/hardware.h>
+#include <soc/sprd/board.h>
+#include "../sensor_drv_sprd.h"
+
+static int sensor_hi544_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select sub sensor
+	sensor_k_set_pd_level(fd_handle, 0);//power down
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor
+	sensor_k_set_pd_level(fd_handle, 0);//power down
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+	udelay(10);
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_2800MV);
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);
+	udelay(10);
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_pd_level(fd_handle, 1);
+	mdelay(2);//delay 2ms > 1ms
+	sensor_k_set_mclk(fd_handle, 24);
+	mdelay(30);//delay 30ms >= 30ms
+	sensor_k_set_rst_level(fd_handle, 1);
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	printk("hi544_poweron OK \n");
+
+	return ret;
+}
+
+static int sensor_hi544_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select main sensor
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+	mdelay(10);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+	udelay(1);//delay 1us > 0ns
+	sensor_k_set_pd_level(fd_handle, 0);//power down
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+	udelay(1);
+	sensor_k_set_voltage_cammot(fd_handle, SENSOR_VDD_CLOSED);
+	printk("hi544_poweroff OK \n");
+
+	return ret;
+}
+
+
+static int sensor_hi255_poweron(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_0);//select sub sensor
+	sensor_k_set_pd_level(fd_handle, 0);//power down
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor
+	sensor_k_set_pd_level(fd_handle, 0);//power down
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+	udelay(1);
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_1800MV);
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_2800MV);
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_pd_level(fd_handle, 1);
+	mdelay(2);//delay 2ms > 1ms
+	sensor_k_set_mclk(fd_handle, 24);
+	mdelay(30);//delay 30ms >= 30ms
+	sensor_k_set_rst_level(fd_handle, 1);
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	printk("hi255_poweron OK \n");
+
+	return ret;
+}
+
+static int sensor_hi255_poweroff(uint32_t *fd_handle, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	sensor_k_sensor_sel(fd_handle, SENSOR_DEV_1);//select main sensor
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_rst_level(fd_handle, 0);//reset
+	udelay(2);//delay 2us > 16MCLK = 16/24 us
+	sensor_k_set_mclk(fd_handle, 0);// disable mclk
+	udelay(1);//delay 1us > 0ns
+	sensor_k_set_pd_level(fd_handle, 0);//power down
+	mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_voltage_avdd(fd_handle, SENSOR_VDD_CLOSED);
+	//mdelay(6);//delay 6ms < 10ms
+	sensor_k_set_voltage_iovdd(fd_handle, SENSOR_VDD_CLOSED);
+	udelay(1);
+	printk("hi255_poweroff OK \n");
+
+	return ret;
+}
+
+int sensor_power_on(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	if (SENSOR_DEV_0 == sensor_id) {
+		ret = sensor_hi544_poweron(fd_handle, dev0, dev1, dev2);
+	} else if (SENSOR_DEV_1 == sensor_id) {
+		ret = sensor_hi255_poweron(fd_handle, dev0, dev1, dev2);
+	}
+	return ret;
+}
+
+int sensor_power_off(uint32_t *fd_handle, uint32_t sensor_id, struct sensor_power *dev0, struct sensor_power *dev1, struct sensor_power *dev2)
+{
+	int ret = 0;
+
+	if (SENSOR_DEV_0 == sensor_id) {
+		ret = sensor_hi544_poweroff(fd_handle, dev0, dev1, dev2);
+	} else if (SENSOR_DEV_1 == sensor_id) {
+		ret = sensor_hi255_poweroff(fd_handle, dev0, dev1, dev2);
+	}
+
+	return ret;
+}
diff --git a/drivers/media/sprd_sensor/sensor_drv_k.c b/drivers/media/sprd_sensor/sensor_drv_k.c
new file mode 100755
index 00000000..d0122dfb
--- /dev/null
+++ b/drivers/media/sprd_sensor/sensor_drv_k.c
@@ -0,0 +1,2005 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/poll.h>
+#include <linux/fs.h>
+#include <linux/irq.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/miscdevice.h>
+#include <asm/io.h>
+#include <linux/file.h>
+
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/of_gpio.h>
+#include <linux/vmalloc.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/gpio.h>
+#include <linux/clk.h>
+#include <linux/wakelock.h>
+
+#include <linux/regulator/consumer.h>
+
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#include <linux/of_i2c.h>
+#include <linux/kthread.h>
+
+#ifndef CONFIG_64BIT
+#include <soc/sprd/dma.h>
+#include <soc/sprd/hardware.h>
+#include <soc/sprd/board.h>
+#include <soc/sprd/regulator.h>
+#include <soc/sprd/arch_misc.h>
+#include <soc/sprd/adi.h>
+
+#endif
+#include <soc/sprd/i2c-sprd.h>
+
+#include <video/sensor_drv_k.h>
+#include "sensor_drv_sprd.h"
+#include "compat_sensor_drv_k.h"
+#include "csi2/csi_api.h"
+#include "parse_hwinfo.h"
+#ifdef  CONFIG_SC_FPGA
+#include "dcam_reg.h"
+#endif
+#include "power/sensor_power.h"
+#include "otp/sensor_otp.h"
+
+#define SENSOR_CLK                        "clk_sensor"
+#define SENSOR_DEVICE_NAME                "sprd_sensor"
+
+#define DEBUG_SENSOR_DRV
+#ifdef  DEBUG_SENSOR_DRV
+#define SENSOR_PRINT                      pr_debug
+#else
+#define SENSOR_PRINT(...)
+#endif
+#define SENSOR_PRINT_ERR                  printk
+#define SENSOR_PRINT_HIGH                 printk
+
+#define SENSOR_K_SUCCESS                  0
+#define SENSOR_K_FAIL                     (-1)
+#define SENSOR_K_FALSE                    0
+#define SENSOR_K_TRUE                     1
+
+#ifndef  CONFIG_SC_FPGA
+#define LOCAL                             static
+#else
+#define LOCAL
+#endif
+
+#define PNULL                             ((void *)0)
+
+#define NUMBER_MAX                        0x7FFFFFF
+
+#define SENSOR_MINOR                      MISC_DYNAMIC_MINOR
+#define SLEEP_MS(ms)                      msleep(ms)
+
+#define SENSOR_I2C_ID                     0
+#define SENSOR_I2C_OP_TRY_NUM             3
+#define SENSOR_CMD_BITS_8                 1
+#define SENSOR_CMD_BITS_16                2
+#define SENSOR_I2C_VAL_8BIT               0x00
+#define SENSOR_I2C_VAL_16BIT              0x01
+#define SENSOR_I2C_REG_8BIT               (0x00 << 1)
+#define SENSOR_I2C_REG_16BIT              (0x01 << 1)
+#define SENSOR_I2C_CUSTOM                 (0x01 << 2)
+#define SENSOR_LOW_EIGHT_BIT              0xff
+
+#define SENSOR_WRITE_DELAY                0xffff
+#define DEBUG_STR                         "Error L %d, %s \n"
+#define DEBUG_ARGS                        __LINE__,__FUNCTION__
+#define SENSOR_MCLK_SRC_NUM               4
+#define SENSOR_MCLK_DIV_MAX               4
+#define SENSOR_ABS(a)                     ((a) > 0 ? (a) : -(a))
+#define SENSOR_LOWEST_ADDR                0x800
+#define SENSOR_ADDR_INVALID(addr)         ((unsigned long)(addr) < SENSOR_LOWEST_ADDR)
+
+#define SENSOR_CHECK_ZERO(a)                                   \
+	do {                                                       \
+		if (SENSOR_ADDR_INVALID(a)) {                          \
+			printk("SENSOR, zero pointer \n");                 \
+			printk(DEBUG_STR, DEBUG_ARGS);                     \
+			return -EFAULT;                                    \
+		}                                                      \
+	} while(0)
+
+#define SENSOR_CHECK_ZERO_VOID(a)                               \
+	do {                                                        \
+		if (SENSOR_ADDR_INVALID(a)) {                           \
+			printk("SENSOR, zero pointer \n");                  \
+			printk(DEBUG_STR, DEBUG_ARGS);                      \
+			return;                                             \
+		}                                                       \
+	} while(0)
+
+struct sensor_mclk_tag {
+	uint32_t                        clock;
+	char                            *src_name;
+};
+
+struct sensor_mem_tag {
+	void                            *buf_ptr;
+	size_t                          size;
+};
+
+struct sensor_module_tag {
+	struct mutex                    sync_lock;
+	atomic_t                        users;
+	struct i2c_client               *cur_i2c_client;
+	struct i2c_client               *vcm_i2c_client;
+	uint32_t                        vcm_gpio_i2c_flag;
+};
+
+struct sensor_module_tab_tag {
+	atomic_t                        total_users;
+	uint32_t                        padding;
+	struct mutex                    sensor_id_lock;
+	struct device_node              *of_node;
+	struct clk                      *sensor_mm_in_clk;
+	struct wake_lock                wakelock;
+	struct sensor_module_tag        sensor_dev_tab[SENSOR_DEV_MAX];
+	SENSOR_OTP_PARAM_T 				otp_param[SENSOR_DEV_MAX];
+};
+
+struct sensor_gpio_tag {
+	int                             pwn;
+	int                             reset;
+};
+
+struct sensor_file_tag {
+	struct sensor_module_tab_tag    *module_data;
+	uint32_t                        sensor_id;
+	uint32_t                        sensor_mclk;
+	uint32_t                        iopower_on_count;
+	uint32_t                        avddpower_on_count;
+	uint32_t                        dvddpower_on_count;
+	uint32_t                        motpower_on_count;
+	uint32_t                        mipi_on;
+	uint32_t                        padding;
+	uint32_t                        phy_id;
+	uint32_t                        if_type;
+	struct sensor_gpio_tag          gpio_tab;
+	struct clk                      *ccir_clk;
+	struct clk                      *ccir_enable_clk;
+	struct clk                      *mipi_clk;
+	struct regulator                *camvio_regulator;
+	struct regulator                *camavdd_regulator;
+	struct regulator                *camdvdd_regulator;
+	struct regulator                *cammot_regulator;
+	struct sensor_mem_tag           sensor_mem;
+	void                            *csi_handle;
+};
+
+LOCAL const struct sensor_mclk_tag c_sensor_mclk_tab[SENSOR_MCLK_SRC_NUM] = {
+						{96, "clk_96m"},
+						{77, "clk_76m8"},
+						{48, "clk_48m"},
+						{26, "ext_26m"}
+};
+
+LOCAL struct sensor_name socname = {-1,-1};
+
+LOCAL void* _sensor_k_malloc(struct sensor_file_tag *fd_handle, size_t size)
+{
+	if (SENSOR_ADDR_INVALID(fd_handle)) {
+		printk("SENSOR, zero pointer \n");
+		printk(DEBUG_STR, DEBUG_ARGS);
+		return PNULL;
+	}
+
+	if(PNULL == fd_handle->sensor_mem.buf_ptr) {
+		fd_handle->sensor_mem.buf_ptr = vzalloc(size);
+		if(PNULL != fd_handle->sensor_mem.buf_ptr) {
+			fd_handle->sensor_mem.size = size;
+		}
+
+	} else if (size > fd_handle->sensor_mem.size) {
+		//realloc memory
+		vfree(fd_handle->sensor_mem.buf_ptr);
+		fd_handle->sensor_mem.buf_ptr = PNULL;
+		fd_handle->sensor_mem.size = 0;
+		fd_handle->sensor_mem.buf_ptr = vzalloc(size);
+		if (PNULL != fd_handle->sensor_mem.buf_ptr) {
+			fd_handle->sensor_mem.size = size;
+		}
+	}
+
+	return fd_handle->sensor_mem.buf_ptr;
+}
+
+LOCAL void _sensor_k_free(struct sensor_file_tag *fd_handle, void *p)
+{
+	/* memory will not be free */
+	return;
+}
+
+#if 0
+LOCAL struct platform_device*  _sensor_k_get_platform_device(void)
+{
+	struct device *dev;
+
+	dev = bus_find_device_by_name(&platform_bus_type, NULL, SENSOR_DEVICE_NAME);
+	if (!dev) {
+		printk("%s error: find device\n", __func__);
+		return NULL;
+	}
+
+	return to_platform_device(dev);
+}
+#endif
+
+int sensor_k_set_pd_level(uint32_t *fd_handle, uint8_t power_level)
+{
+	struct sensor_module_tab_tag    *p_mod;
+	struct sensor_file_tag          *fd = (struct sensor_file_tag *)fd_handle;
+
+	SENSOR_CHECK_ZERO(fd);
+	p_mod = fd->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+#ifndef	CONFIG_SC_FPGA_PIN
+	get_gpio_id(p_mod->of_node, &fd->gpio_tab.pwn, &fd->gpio_tab.reset, fd->sensor_id);
+	SENSOR_PRINT_HIGH("SENSOR: pwn %d \n", fd->gpio_tab.pwn);
+	if (0 == power_level) {
+		gpio_direction_output(fd->gpio_tab.pwn, 0);
+	} else {
+		gpio_direction_output(fd->gpio_tab.pwn, 1);
+	}
+#else
+	SENSOR_PRINT_HIGH("CAP_SENSOR_CTRL 0x%lx\n", CAP_SENSOR_CTRL);
+	if (0 == power_level) {
+		REG_MWR(CAP_SENSOR_CTRL,0x0f,0);
+	} else {
+		REG_MWR(CAP_SENSOR_CTRL,0x0f,0x0f);
+	}
+	SENSOR_PRINT_HIGH("CAP_SENSOR_CTRL val=0x%x\n", REG_RD(CAP_SENSOR_CTRL));
+#endif
+
+	return SENSOR_K_SUCCESS;
+}
+
+LOCAL void _sensor_regulator_disable(struct sensor_file_tag *fd_handle, uint32_t *power_on_count, struct regulator * ptr_cam_regulator)
+{
+	SENSOR_CHECK_ZERO_VOID(fd_handle);
+
+	while (*power_on_count > 0) {
+		regulator_disable(ptr_cam_regulator);
+		(*power_on_count)--;
+	}
+	SENSOR_PRINT("sensor pwr off done: cnt=0x%x, io=%x, av=%x, dv=%x, mo=%x \n", *power_on_count,
+		fd_handle->iopower_on_count,
+		fd_handle->avddpower_on_count,
+		fd_handle->dvddpower_on_count,
+		fd_handle->motpower_on_count);
+
+}
+
+LOCAL int _sensor_regulator_enable(struct sensor_file_tag *fd_handle, uint32_t *power_on_count, struct regulator * ptr_cam_regulator)
+{
+	int err;
+	SENSOR_CHECK_ZERO(fd_handle);
+
+	err = regulator_enable(ptr_cam_regulator);
+	(*power_on_count)++;
+
+	SENSOR_PRINT("sensor pwr on done: cnt=0x%x, io=%x, av=%x, dv=%x, mo=%x \n", *power_on_count,
+		fd_handle->iopower_on_count,
+		fd_handle->avddpower_on_count,
+		fd_handle->dvddpower_on_count,
+		fd_handle->motpower_on_count);
+
+	return err;
+}
+
+LOCAL int _sensor_k_get_voltage_value(uint32_t *val)
+{
+	uint32_t             volt_value = 0;
+
+	SENSOR_CHECK_ZERO(val);
+
+	switch (*val) {
+	case SENSOR_VDD_3800MV:
+		volt_value = SENSOER_VDD_3800MV;
+		break;
+	case SENSOR_VDD_3300MV:
+		volt_value = SENSOER_VDD_3300MV;
+		break;
+	case SENSOR_VDD_3000MV:
+		volt_value = SENSOER_VDD_3000MV;
+		break;
+	case SENSOR_VDD_2800MV:
+		volt_value = SENSOER_VDD_2800MV;
+		break;
+	case SENSOR_VDD_2500MV:
+		volt_value = SENSOER_VDD_2500MV;
+		break;
+	case SENSOR_VDD_1800MV:
+		volt_value = SENSOER_VDD_1800MV;
+		break;
+	case SENSOR_VDD_1500MV:
+		volt_value = SENSOER_VDD_1500MV;
+		break;
+	case SENSOR_VDD_1300MV:
+		volt_value = SENSOER_VDD_1300MV;
+		break;
+	case SENSOR_VDD_1200MV:
+		volt_value = SENSOER_VDD_1200MV;
+		break;
+	case SENSOR_VDD_CLOSED:
+	case SENSOR_VDD_UNUSED:
+	default:
+		volt_value = 0;
+		break;
+	}
+
+	*val = volt_value;
+
+	SENSOR_PRINT("sensor get voltage val: %d \n", *val);
+
+	return SENSOR_K_SUCCESS;
+}
+
+LOCAL int _sensor_k_set_voltage(struct sensor_file_tag *fd_handle, uint32_t val, uint32_t type)
+{
+#ifdef CONFIG_SC_FPGA_LDO
+	return 0;
+#else
+	int                              ret = SENSOR_K_SUCCESS;
+	uint32_t                         volt_value = 0;
+	uint32_t                         *poweron_count = NULL;
+	char                             *regu_name;
+	struct sensor_module_tab_tag     *p_mod;
+	struct regulator                 **p_regulator = NULL;
+
+	SENSOR_CHECK_ZERO(fd_handle);
+	p_mod = fd_handle->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	SENSOR_PRINT("sensor set voltage val: %d \n", val);
+
+	get_regulator_name(p_mod->of_node, &type, fd_handle->sensor_id, &regu_name);
+
+	switch (type) {
+	case REGU_CAMAVDD:
+		p_regulator = &fd_handle->camavdd_regulator;
+		poweron_count = &fd_handle->avddpower_on_count;
+		break;
+
+	case REGU_CAMDVDD:
+		p_regulator = &fd_handle->camdvdd_regulator;
+		poweron_count = &fd_handle->dvddpower_on_count;
+		break;
+
+	case REGU_CAMIOVDD:
+		p_regulator = &fd_handle->camvio_regulator;
+		poweron_count = &fd_handle->iopower_on_count;
+		break;
+
+	case REGU_CAMMOT:
+		p_regulator = &fd_handle->cammot_regulator;
+		poweron_count = &fd_handle->motpower_on_count;
+		break;
+
+	default:
+		SENSOR_PRINT_ERR("error type = %d\n",type);
+		break;
+	}
+
+	if ((NULL == poweron_count) || (NULL == p_regulator)) {
+		SENSOR_PRINT_ERR("error param");
+		return SENSOR_K_FAIL;
+	}
+
+	if (NULL == *p_regulator) {
+		*p_regulator = regulator_get(NULL, regu_name);
+		if (IS_ERR(*p_regulator)) {
+			SENSOR_PRINT_ERR("SENSOR:get regu.fail %s %d\n", regu_name, type);
+			return SENSOR_K_FAIL;
+		}
+	}
+	volt_value = val;
+	_sensor_k_get_voltage_value(&volt_value);
+
+	if (0 != volt_value) {
+		ret = regulator_set_voltage(*p_regulator, volt_value, volt_value);
+	}
+	if (ret) {
+		SENSOR_PRINT_ERR("SENSOR:set vol err %d %s %d!.\n", ret, regu_name, type);
+		return SENSOR_K_FAIL;
+	}
+
+	if (0 != volt_value) {
+		ret = _sensor_regulator_enable(fd_handle, poweron_count, *p_regulator);
+		if (ret) {
+			regulator_put(*p_regulator);
+			*p_regulator = NULL;
+			SENSOR_PRINT_ERR("SENSOR:can't en %d %s %d!.\n", ret, regu_name, type);
+			return SENSOR_K_FAIL;
+		}
+	} else {
+		_sensor_regulator_disable(fd_handle, poweron_count, *p_regulator);
+		regulator_put(*p_regulator);
+		*p_regulator = NULL;
+		SENSOR_PRINT("SENSOR:dis regu.\n");
+	}
+
+	SENSOR_PRINT_HIGH("SENSOR:set vol %d %s %d!.\n", volt_value, regu_name, type);
+
+	return ret;
+#endif
+}
+
+int sensor_k_set_voltage_cammot(uint32_t *fd_handle, uint32_t cammot_val)
+{
+	return _sensor_k_set_voltage((struct sensor_file_tag *)fd_handle, cammot_val, REGU_CAMMOT);
+}
+
+int sensor_k_set_voltage_avdd(uint32_t *fd_handle, uint32_t avdd_val)
+{
+	return _sensor_k_set_voltage((struct sensor_file_tag *)fd_handle, avdd_val, REGU_CAMAVDD);
+}
+
+int sensor_k_set_voltage_dvdd(uint32_t *fd_handle, uint32_t dvdd_val)
+{
+#ifdef CONFIG_SC_FPGA_LDO
+	return 0;
+#else
+	int                              gpio_id = 0;
+	struct sensor_module_tab_tag     *p_mod;
+	struct sensor_file_tag           *fd = (struct sensor_file_tag *)fd_handle;
+
+	SENSOR_CHECK_ZERO(fd);
+	p_mod = fd->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	get_gpio_id_ex(p_mod->of_node, GPIO_CAMDVDD, &gpio_id, fd->sensor_id);
+	if (SENSOR_DEV_0 == fd->sensor_id && 0 != gpio_id) {
+		SENSOR_PRINT_HIGH("sensor set DVDD gpio %d\n", gpio_id);
+		if (SENSOR_VDD_CLOSED == dvdd_val) {
+			gpio_direction_output(gpio_id, 1);
+			gpio_set_value(gpio_id, 0);
+		} else {
+			gpio_direction_output(gpio_id, 1);
+			gpio_set_value(gpio_id, 1);
+		}
+		return SENSOR_K_SUCCESS;
+	}
+
+	if (SENSOR_DEV_1 == fd->sensor_id && 0 != gpio_id) {
+		SENSOR_PRINT_HIGH("sensor set DVDD gpio %d\n", gpio_id);
+		if (SENSOR_VDD_CLOSED == dvdd_val) {
+			gpio_direction_output(gpio_id, 1);
+			gpio_set_value(gpio_id, 0);
+		} else {
+			gpio_direction_output(gpio_id, 1);
+			gpio_set_value(gpio_id, 1);
+		}
+		return SENSOR_K_SUCCESS;
+	}
+
+	return _sensor_k_set_voltage((struct sensor_file_tag *)fd_handle, dvdd_val, REGU_CAMDVDD);
+#endif
+}
+
+int sensor_k_set_voltage_iovdd(uint32_t *fd_handle, uint32_t iodd_val)
+{
+	return _sensor_k_set_voltage((struct sensor_file_tag *)fd_handle, iodd_val, REGU_CAMIOVDD);
+}
+
+LOCAL int _select_sensor_mclk(struct sensor_file_tag *fd_handle, uint8_t clk_set, char **clk_src_name,
+			uint8_t * clk_div)
+{
+	uint8_t               i = 0;
+	uint8_t               j = 0;
+	uint8_t               mark_src = 0;
+	uint8_t               mark_div = 0;
+	uint8_t               mark_src_tmp = 0;
+	int                   clk_tmp = NUMBER_MAX;
+	int                   src_delta = NUMBER_MAX;
+	int                   src_delta_min = NUMBER_MAX;
+	int                   div_delta_min = NUMBER_MAX;
+	SENSOR_CHECK_ZERO(fd_handle);
+
+	SENSOR_PRINT("SENSOR sel mclk %d.\n", clk_set);
+	if (clk_set > 96 || !clk_src_name || !clk_div) {
+		return SENSOR_K_FAIL;
+	}
+	for (i = 0; i < SENSOR_MCLK_DIV_MAX; i++) {
+		clk_tmp = (int)(clk_set * (i + 1));
+		src_delta_min = NUMBER_MAX;
+		for (j = 0; j < SENSOR_MCLK_SRC_NUM; j++) {
+			src_delta = c_sensor_mclk_tab[j].clock - clk_tmp;
+			src_delta = SENSOR_ABS(src_delta);
+			if (src_delta < src_delta_min) {
+				src_delta_min = src_delta;
+				mark_src_tmp = j;
+			}
+		}
+		if (src_delta_min < div_delta_min) {
+			div_delta_min = src_delta_min;
+			mark_src = mark_src_tmp;
+			mark_div = i;
+		}
+	}
+	SENSOR_PRINT("src %d, div=%d .\n", mark_src,
+		mark_div);
+
+	*clk_src_name = c_sensor_mclk_tab[mark_src].src_name;
+	*clk_div = mark_div + 1;
+
+	return SENSOR_K_SUCCESS;
+}
+
+int32_t _sensor_k_mipi_clk_en(struct sensor_file_tag *fd_handle, struct device_node *dn)
+{
+#ifdef CONFIG_SC_FPGA_CLK
+	return 0;
+#else
+	int                     ret = 0;
+
+	SENSOR_CHECK_ZERO(fd_handle);
+
+	if (NULL == fd_handle->mipi_clk) {
+		fd_handle->mipi_clk = parse_clk(dn,"clk_dcam_mipi");
+	}
+
+	if (IS_ERR(fd_handle->mipi_clk)) {
+		printk("SENSOR: get dcam mipi clk error \n");
+		return -1;
+	} else {
+		ret = clk_enable(fd_handle->mipi_clk);
+		if (ret) {
+			printk("SENSOR: enable dcam mipi clk error %d \n", ret);
+			return -1;
+		}
+	}
+
+	return ret;
+#endif
+}
+
+int32_t _sensor_k_mipi_clk_dis(struct sensor_file_tag *fd_handle)
+{
+#ifdef CONFIG_SC_FPGA_CLK
+	return 0;
+#else
+	SENSOR_CHECK_ZERO(fd_handle);
+
+	if (fd_handle->mipi_clk) {
+		clk_disable(fd_handle->mipi_clk);
+		clk_put(fd_handle->mipi_clk);
+		fd_handle->mipi_clk = NULL;
+	}
+	return 0;
+#endif
+}
+
+LOCAL int _sensor_k_set_mclk(struct sensor_file_tag *fd_handle, struct device_node *dn, uint32_t mclk)
+{
+#ifdef CONFIG_SC_FPGA_CLK
+	return 0;
+#else
+	struct clk                *clk_parent = NULL;
+	int                       ret;
+	char                      *clk_src_name = NULL;
+	uint8_t                   clk_div;
+	SENSOR_CHECK_ZERO(fd_handle);
+
+	SENSOR_PRINT_HIGH("SENSOR: set mclk org = %d, clk = %d\n",
+				fd_handle->sensor_mclk, mclk);
+
+	if ((0 != mclk) && (fd_handle->sensor_mclk != mclk)) {
+		if (fd_handle->ccir_clk) {
+			clk_disable(fd_handle->ccir_clk);
+			SENSOR_PRINT("###sensor ccir clk off ok.\n");
+		} else {
+			fd_handle->ccir_clk = parse_clk(dn, SENSOR_CLK);
+			if (IS_ERR(fd_handle->ccir_clk)) {
+				SENSOR_PRINT_ERR("###: Failed: Can't get clock [ccir_mclk]!\n");
+				SENSOR_PRINT_ERR("###: s_sensor_clk = %p.\n",fd_handle->ccir_clk);
+			} else {
+				SENSOR_PRINT("###sensor ccir clk get ok.\n");
+			}
+		}
+		if (mclk > SENSOR_MAX_MCLK) {
+			mclk = SENSOR_MAX_MCLK;
+		}
+		if (SENSOR_K_SUCCESS != _select_sensor_mclk(fd_handle, (uint8_t) mclk, &clk_src_name, &clk_div)) {
+			SENSOR_PRINT_ERR("SENSOR:Sensor_SetMCLK select clock source fail.\n");
+			return -EINVAL;
+		}
+		SENSOR_PRINT("clk_src_name=%s, clk_div=%d \n", clk_src_name, clk_div);
+
+		clk_parent = clk_get(NULL, clk_src_name);
+		if (!clk_parent) {
+			SENSOR_PRINT_ERR("###:clock: failed to get clock [%s] by clk_get()!\n", clk_src_name);
+			return -EINVAL;
+		}
+		SENSOR_PRINT("clk_get clk_src_name=%s done\n", clk_src_name);
+
+		ret = clk_set_parent(fd_handle->ccir_clk, clk_parent);
+		if (ret) {
+			SENSOR_PRINT_ERR("###:clock: clk_set_parent() failed!parent \n");
+			return -EINVAL;
+		}
+		SENSOR_PRINT("clk_set_parent s_ccir_clk=%s done\n", (char *)(fd_handle->ccir_clk));
+
+		ret = clk_set_rate(fd_handle->ccir_clk, (mclk * SENOR_CLK_M_VALUE));
+		if (ret) {
+			SENSOR_PRINT_ERR("###:clock: clk_set_rate failed!\n");
+			return -EINVAL;
+		}
+		SENSOR_PRINT("clk_set_rate s_ccir_clk=%s done\n", (char *)(fd_handle->ccir_clk));
+
+		ret = clk_enable(fd_handle->ccir_clk);
+		if (ret) {
+			SENSOR_PRINT_ERR("###:clock: clk_enable() failed!\n");
+		} else {
+			SENSOR_PRINT("######ccir enable clk ok\n");
+		}
+
+		if (NULL == fd_handle->ccir_enable_clk) {
+			fd_handle->ccir_enable_clk	= parse_clk(dn,"clk_ccir");
+			if (IS_ERR(fd_handle->ccir_enable_clk)) {
+				SENSOR_PRINT_ERR("###: Failed: Can't get clock [clk_ccir]!\n");
+				SENSOR_PRINT_ERR("###: ccir_enable_clk = %p.\n", fd_handle->ccir_enable_clk);
+				return -EINVAL;
+			} else {
+				SENSOR_PRINT("###sensor ccir_enable_clk clk_get ok.\n");
+			}
+			ret = clk_enable(fd_handle->ccir_enable_clk);
+			if (ret) {
+				SENSOR_PRINT_ERR("###:clock: clk_enable() failed!\n");
+			} else {
+				SENSOR_PRINT("###ccir enable clk ok\n");
+			}
+		}
+
+		fd_handle->sensor_mclk = mclk;
+		SENSOR_PRINT("SENSOR: set mclk %d Hz.\n",
+			fd_handle->sensor_mclk);
+	} else if (0 == mclk) {
+		if (fd_handle->ccir_clk) {
+			clk_disable(fd_handle->ccir_clk);
+			SENSOR_PRINT("###sensor clk disable ok.\n");
+			clk_put(fd_handle->ccir_clk);
+			SENSOR_PRINT("###sensor clk put ok.\n");
+			fd_handle->ccir_clk = NULL;
+		}
+
+		if (fd_handle->ccir_enable_clk) {
+			clk_disable(fd_handle->ccir_enable_clk);
+			SENSOR_PRINT("###sensor clk disable ok.\n");
+			clk_put(fd_handle->ccir_enable_clk);
+			SENSOR_PRINT("###sensor clk put ok.\n");
+			fd_handle->ccir_enable_clk = NULL;
+		}
+		fd_handle->sensor_mclk = 0;
+		SENSOR_PRINT("SENSOR: Disable MCLK !!!");
+	} else {
+		SENSOR_PRINT("SENSOR: Do nothing !! ");
+	}
+	SENSOR_PRINT_HIGH("SENSOR: set mclk X\n");
+	return 0;
+#endif
+}
+
+int sensor_k_set_mclk(uint32_t *fd_handle, uint32_t mclk)
+{
+	struct sensor_module_tab_tag    *p_mod;
+	struct sensor_file_tag          *fd = (struct sensor_file_tag *)fd_handle;
+
+	SENSOR_CHECK_ZERO(fd);
+	p_mod = fd->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	return _sensor_k_set_mclk(fd, p_mod->of_node, mclk);
+}
+
+LOCAL int _sensor_k_reset(struct sensor_file_tag *fd_handle, uint32_t level, uint32_t width)
+{
+#ifndef	CONFIG_SC_FPGA_PIN
+	struct sensor_module_tab_tag    *p_mod;
+
+	SENSOR_CHECK_ZERO(fd_handle);
+	p_mod = fd_handle->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	get_gpio_id(p_mod->of_node, &fd_handle->gpio_tab.pwn, &fd_handle->gpio_tab.reset, fd_handle->sensor_id);
+	SENSOR_PRINT_HIGH("SENSOR: reset val %d id %d reset %d\n",level, fd_handle->sensor_id, fd_handle->gpio_tab.reset);
+
+	gpio_direction_output(fd_handle->gpio_tab.reset, level);
+	gpio_set_value(fd_handle->gpio_tab.reset, level);
+	SLEEP_MS(width);
+	gpio_set_value(fd_handle->gpio_tab.reset, !level);
+#else
+	SENSOR_PRINT_HIGH("CAP_SENSOR_CTRL 0x%lx\n", CAP_SENSOR_CTRL);
+
+	REG_MWR(CAP_SENSOR_CTRL,0xf0,level!=0?0xf0:0);
+	SLEEP_MS(width);
+	REG_MWR(CAP_SENSOR_CTRL,0xf0,level!=0?0:0xf0);
+	mdelay(1);
+#endif
+
+	return SENSOR_K_SUCCESS;
+}
+
+int sensor_k_sensor_sel(uint32_t *fd_handle, uint32_t sensor_id)
+{
+	struct sensor_file_tag          *fd = (struct sensor_file_tag *)fd_handle;
+	SENSOR_CHECK_ZERO(fd);
+	fd->sensor_id = sensor_id;
+
+	return SENSOR_K_SUCCESS;
+}
+
+int sensor_k_sensor_desel(struct sensor_file_tag *fd_handle, uint32_t sensor_id)
+{
+	SENSOR_CHECK_ZERO(fd_handle);
+	//fd_handle->sensor_id = SENSOR_ID_MAX;
+
+	SENSOR_PRINT_HIGH("sensor desel %d OK.\n", sensor_id);
+
+	return SENSOR_K_SUCCESS;
+}
+
+int sensor_k_set_rst_level(uint32_t *fd_handle, uint32_t plus_level)
+{
+	struct sensor_module_tab_tag    *p_mod;
+	struct sensor_file_tag          *fd = (struct sensor_file_tag *)fd_handle;
+
+	SENSOR_CHECK_ZERO(fd);
+	p_mod = fd->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	get_gpio_id(p_mod->of_node, &fd->gpio_tab.pwn, &fd->gpio_tab.reset, fd->sensor_id);
+	SENSOR_PRINT("SENSOR: set rst lvl: lvl %d, rst pin %d \n", plus_level, fd->gpio_tab.reset);
+
+#ifndef CONFIG_SC_FPGA_PIN
+	gpio_direction_output(fd->gpio_tab.reset, plus_level);
+	gpio_set_value(fd->gpio_tab.reset, plus_level);
+#else
+	SENSOR_PRINT_HIGH("CAP_SENSOR_CTRL 0x%lx\n", CAP_SENSOR_CTRL);
+	REG_MWR(CAP_SENSOR_CTRL,0xf0,plus_level!=0?0xf0:0x0);
+	SENSOR_PRINT_HIGH("CAP_SENSOR_CTRL val=0x%x\n", REG_RD(CAP_SENSOR_CTRL));
+#endif
+	return SENSOR_K_SUCCESS;
+}
+
+LOCAL int _Sensor_K_ReadReg(struct sensor_file_tag *fd_handle, struct sensor_reg_bits_tag *pReg)
+{
+	uint8_t                       cmd[2] = { 0 };
+	uint16_t                      w_cmd_num = 0;
+	uint16_t                      r_cmd_num = 0;
+	uint8_t                       buf_r[2] = { 0 };
+	int32_t                       ret = SENSOR_K_SUCCESS;
+	struct i2c_msg                msg_r[2];
+	uint16_t                      reg_addr;
+	int                           i;
+	struct sensor_module_tab_tag  *p_mod;
+	SENSOR_CHECK_ZERO(fd_handle);
+
+	p_mod = fd_handle->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	reg_addr = pReg->reg_addr;
+
+	if (SENSOR_I2C_REG_16BIT ==(pReg->reg_bits & SENSOR_I2C_REG_16BIT)) {
+		cmd[w_cmd_num++] = (uint8_t) ((reg_addr >> 8) & SENSOR_LOW_EIGHT_BIT);
+		cmd[w_cmd_num++] = (uint8_t) (reg_addr & SENSOR_LOW_EIGHT_BIT);
+	} else {
+		cmd[w_cmd_num++] = (uint8_t) reg_addr;
+	}
+
+	if (SENSOR_I2C_VAL_16BIT == (pReg->reg_bits & SENSOR_I2C_VAL_16BIT)) {
+		r_cmd_num = SENSOR_CMD_BITS_16;
+	} else {
+		r_cmd_num = SENSOR_CMD_BITS_8;
+	}
+
+	for (i = 0; i < SENSOR_I2C_OP_TRY_NUM; i++) {
+		msg_r[0].addr = p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client->addr;
+		msg_r[0].flags = 0;
+		msg_r[0].buf = cmd;
+		msg_r[0].len = w_cmd_num;
+		msg_r[1].addr = p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client->addr;
+		msg_r[1].flags = I2C_M_RD;
+		msg_r[1].buf = buf_r;
+		msg_r[1].len = r_cmd_num;
+		ret = i2c_transfer(p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client->adapter, msg_r, 2);
+		if (ret != 2) {
+			SENSOR_PRINT_ERR("SENSOR:read reg fail, ret %d, addr 0x%x, reg_addr 0x%x \n",
+					ret, p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client->addr,reg_addr);
+			SLEEP_MS(1);
+			ret = SENSOR_K_FAIL;
+		} else {
+			pReg->reg_value = (r_cmd_num == 1) ? (uint16_t) buf_r[0] : (uint16_t) ((buf_r[0] << 8) + buf_r[1]);
+			ret = SENSOR_K_SUCCESS;
+			break;
+		}
+	}
+
+	return ret;
+}
+
+LOCAL int _Sensor_K_WriteReg(struct sensor_file_tag *fd_handle, struct sensor_reg_bits_tag *pReg)
+{
+	uint8_t                       cmd[4] = { 0 };
+	uint32_t                      index = 0;
+	uint32_t                      cmd_num = 0;
+	struct i2c_msg                msg_w;
+	int32_t                       ret = SENSOR_K_SUCCESS;
+	uint16_t                      subaddr;
+	uint16_t                      data;
+	int                           i;
+	struct sensor_module_tab_tag  *p_mod;
+	SENSOR_CHECK_ZERO(fd_handle);
+
+	p_mod = fd_handle->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	subaddr = pReg->reg_addr;
+	data = pReg->reg_value;
+
+	if (SENSOR_I2C_REG_16BIT ==(pReg->reg_bits & SENSOR_I2C_REG_16BIT)) {
+		cmd[cmd_num++] = (uint8_t) ((subaddr >> 8) & SENSOR_LOW_EIGHT_BIT);
+		index++;
+		cmd[cmd_num++] =  (uint8_t) (subaddr & SENSOR_LOW_EIGHT_BIT);
+		index++;
+	} else {
+		cmd[cmd_num++] = (uint8_t) subaddr;
+		index++;
+	}
+
+	if (SENSOR_I2C_VAL_16BIT == (pReg->reg_bits & SENSOR_I2C_VAL_16BIT)) {
+		cmd[cmd_num++] = (uint8_t) ((data >> 8) & SENSOR_LOW_EIGHT_BIT);
+		index++;
+		cmd[cmd_num++] = (uint8_t) (data & SENSOR_LOW_EIGHT_BIT);
+		index++;
+	} else {
+		cmd[cmd_num++] = (uint8_t) data;
+		index++;
+	}
+
+	if (SENSOR_WRITE_DELAY != subaddr) {
+		for (i = 0; i < SENSOR_I2C_OP_TRY_NUM; i++) {
+			msg_w.addr = p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client->addr;
+			msg_w.flags = 0;
+			msg_w.buf = cmd;
+			msg_w.len = index;
+			ret = i2c_transfer(p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client->adapter, &msg_w, 1);
+			if (ret != 1) {
+				SENSOR_PRINT_ERR("_Sensor_K_WriteReg failed:i2cAddr=%x, addr=%x, value=%x, bit=%d \n",
+						p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client->addr, pReg->reg_addr, pReg->reg_value, pReg->reg_bits);
+				ret = SENSOR_K_FAIL;
+				continue;
+			} else {
+				ret = SENSOR_K_SUCCESS;
+				break;
+			}
+		}
+	} else {
+		SLEEP_MS(data);
+	}
+
+	return ret;
+}
+
+LOCAL int _sensor_k_get_flash_level(struct sensor_file_tag *fd_handle, struct sensor_flash_level *level)
+{
+	level->low_light  = SPRD_FLASH_LOW_CUR;
+	level->high_light = SPRD_FLASH_HIGH_CUR;
+
+	SENSOR_PRINT("Sensor get flash lvl: low %d, high %d \n", level->low_light, level->high_light);
+
+	return SENSOR_K_SUCCESS;
+}
+
+int _sensor_burst_write_init(struct sensor_file_tag *fd_handle, struct sensor_reg_tag *p_reg_table, uint32_t init_table_size);
+
+LOCAL int _sensor_k_wr_regtab(struct sensor_file_tag *fd_handle, struct sensor_reg_tab_tag *pRegTab)
+{
+	char                   *pBuff = PNULL;
+	uint32_t               cnt = pRegTab->reg_count;
+	int                    ret = SENSOR_K_SUCCESS;
+	uint32_t               size;
+	struct sensor_reg_tag  *sensor_reg_ptr;
+	struct sensor_reg_bits_tag reg_bit;
+	uint32_t               i;
+	int                    rettmp;
+	struct timeval         time1, time2;
+
+	do_gettimeofday(&time1);
+
+	size = cnt*sizeof(struct sensor_reg_tag);
+	pBuff = _sensor_k_malloc(fd_handle, size);
+	if (PNULL == pBuff) {
+		ret = SENSOR_K_FAIL;
+		SENSOR_PRINT_ERR("sensor W RegTab err:alloc fail, cnt %d, size %d\n", cnt, size);
+		goto _Sensor_K_WriteRegTab_return;
+	} else {
+		SENSOR_PRINT("sensor W RegTab: alloc success, cnt %d, size %d \n",cnt, size);
+	}
+
+	if (copy_from_user(pBuff, pRegTab->sensor_reg_tab_ptr, size)) {
+		ret = SENSOR_K_FAIL;
+		SENSOR_PRINT_ERR("sensor w err:copy user fail, size %d \n", size);
+		goto _Sensor_K_WriteRegTab_return;
+	}
+
+	sensor_reg_ptr = (struct sensor_reg_tag *)pBuff;
+
+	if (0 == pRegTab->burst_mode) {
+		for (i=0; i<cnt; i++) {
+			reg_bit.reg_addr  = sensor_reg_ptr[i].reg_addr;
+			reg_bit.reg_value = sensor_reg_ptr[i].reg_value;
+			reg_bit.reg_bits  = pRegTab->reg_bits;
+
+			rettmp = _Sensor_K_WriteReg(fd_handle, &reg_bit);
+			if(SENSOR_K_FAIL == rettmp)
+				ret = SENSOR_K_FAIL;
+		}
+	} else if (SENSOR_I2C_BUST_NB == pRegTab->burst_mode) {
+		printk("CAM %s, Line %d, burst_mode=%d, cnt=%d, start \n", __FUNCTION__, __LINE__, pRegTab->burst_mode, cnt);
+		ret = _sensor_burst_write_init(fd_handle, sensor_reg_ptr, pRegTab->reg_count);
+		printk("CAM %s, Line %d, burst_mode=%d, cnt=%d end\n", __FUNCTION__, __LINE__, pRegTab->burst_mode, cnt);
+	}
+
+
+_Sensor_K_WriteRegTab_return:
+	if (PNULL != pBuff)
+		_sensor_k_free(fd_handle, pBuff);
+
+	do_gettimeofday(&time2);
+	SENSOR_PRINT("sensor w RegTab: done, ret %d, cnt %d, time %d us \n", ret, cnt,
+		(uint32_t)((time2.tv_sec - time1.tv_sec)*1000000+(time2.tv_usec - time1.tv_usec)));
+	return ret;
+}
+
+LOCAL int _sensor_k_set_i2c_clk(struct sensor_file_tag *fd_handle, uint32_t clock)
+{
+	struct sensor_module_tab_tag  *p_mod;
+	struct i2c_client             *i2c_client;
+	SENSOR_CHECK_ZERO(fd_handle);
+
+	p_mod = fd_handle->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	if (NULL != p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client) {
+		i2c_client = p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client;
+		sprd_i2c_ctl_chg_clk(i2c_client->adapter->nr, clock);
+		SENSOR_PRINT("sensor set i2c id %d clk %d  \n", i2c_client->adapter->nr, clock);
+	}
+	if (NULL != p_mod->sensor_dev_tab[fd_handle->sensor_id].vcm_i2c_client
+		&& 0 == p_mod->sensor_dev_tab[fd_handle->sensor_id].vcm_gpio_i2c_flag) {
+		i2c_client = p_mod->sensor_dev_tab[fd_handle->sensor_id].vcm_i2c_client;
+		sprd_i2c_ctl_chg_clk(i2c_client->adapter->nr, clock);
+		SENSOR_PRINT("sensor set i2c id %d clk %d  \n", i2c_client->adapter->nr, clock);
+	}
+	SENSOR_PRINT("sensor set i2c clk %d  \n", clock);
+
+	return SENSOR_K_SUCCESS;
+}
+
+LOCAL int _sensor_k_wr_i2c(struct sensor_file_tag *fd_handle, struct sensor_i2c_tag *pI2cTab)
+{
+	char                          *pBuff = PNULL;
+	struct i2c_msg                msg_w;
+	uint32_t                      cnt = pI2cTab->i2c_count;
+	int                           ret = SENSOR_K_FAIL;
+	struct sensor_module_tab_tag  *p_mod;
+	struct i2c_client             *i2c_client;
+	SENSOR_CHECK_ZERO(fd_handle);
+
+	p_mod = fd_handle->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	pBuff = _sensor_k_malloc(fd_handle, cnt);
+	if (PNULL == pBuff) {
+		SENSOR_PRINT_ERR("sensor W I2C ERR: alloc fail, size %d\n", cnt);
+		goto sensor_k_writei2c_return;
+	} else {
+		SENSOR_PRINT("sensor W I2C: alloc success, size %d\n", cnt);
+	}
+
+	if (copy_from_user(pBuff, pI2cTab->i2c_data, cnt)) {
+		SENSOR_PRINT_ERR("sensor W I2C ERR: copy user fail, size %d \n", cnt);
+		goto sensor_k_writei2c_return;
+	}
+
+	msg_w.addr = pI2cTab->slave_addr;
+	msg_w.flags = 0;
+	msg_w.buf = pBuff;
+	msg_w.len = cnt;
+#if 1
+	if (NULL == p_mod->sensor_dev_tab[fd_handle->sensor_id].vcm_i2c_client) {
+		i2c_client = p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client;
+	} else {
+		i2c_client = p_mod->sensor_dev_tab[fd_handle->sensor_id].vcm_i2c_client;
+	}
+#else
+	i2c_client = p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client;
+#endif
+	ret = i2c_transfer(i2c_client->adapter, &msg_w, 1);
+	if (ret != 1) {
+		SENSOR_PRINT_ERR("SENSOR: w reg fail, ret: %d, addr: 0x%x\n",
+		ret, msg_w.addr);
+	} else {
+		ret = SENSOR_K_SUCCESS;
+	}
+
+sensor_k_writei2c_return:
+	if(PNULL != pBuff)
+		_sensor_k_free(fd_handle, pBuff);
+
+	SENSOR_PRINT("sensor w done, ret %d \n", ret);
+	return ret;
+}
+
+LOCAL int _sensor_k_rd_i2c(struct sensor_file_tag *fd_handle, struct sensor_i2c_tag *pI2cTab)
+{
+	struct i2c_msg	   msg_r[2];
+	int                i;
+	char               *pBuff = PNULL;
+	uint32_t           cnt = pI2cTab->i2c_count;
+	int                ret = SENSOR_K_FAIL;
+	uint16_t           read_num = cnt;
+	struct sensor_module_tab_tag  *p_mod;
+	struct i2c_client  *i2c_client;
+	SENSOR_CHECK_ZERO(fd_handle);
+
+	p_mod = fd_handle->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	/*alloc buffer */
+	pBuff = _sensor_k_malloc(fd_handle, cnt);
+	if (PNULL == pBuff) {
+		ret = SENSOR_K_FAIL;
+		SENSOR_PRINT_ERR("sensor rd I2C ERR: alloc fail, size %d\n", cnt);
+		goto sensor_k_readi2c_return;
+	} else {
+		SENSOR_PRINT("sensor rd I2C: alloc success, size %d\n", cnt);
+	}
+
+	if (copy_from_user(pBuff, pI2cTab->i2c_data, cnt)) {
+		ret = SENSOR_K_FAIL;
+		SENSOR_PRINT_ERR("sensor W I2C ERR: copy user fail, size %d \n", cnt);
+		goto sensor_k_readi2c_return;
+	}
+
+
+	for (i = 0; i < SENSOR_I2C_OP_TRY_NUM; i++) {
+		msg_r[0].addr =  pI2cTab->slave_addr;
+		msg_r[0].flags = 0;
+		msg_r[0].buf = pBuff;
+		msg_r[0].len = cnt;
+		msg_r[1].addr =  pI2cTab->slave_addr;
+		msg_r[1].flags = I2C_M_RD;
+		msg_r[1].buf = pBuff;
+		msg_r[1].len = read_num;
+#if 1
+		if (NULL == p_mod->sensor_dev_tab[fd_handle->sensor_id].vcm_i2c_client) {
+			i2c_client = p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client;
+		} else {
+			i2c_client = p_mod->sensor_dev_tab[fd_handle->sensor_id].vcm_i2c_client;
+		}
+#else
+		i2c_client = p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client;
+#endif
+		ret = i2c_transfer(i2c_client->adapter, msg_r, 2);
+		if (ret != 2) {
+			SENSOR_PRINT_ERR("SENSOR:read reg fail, ret %d, addr 0x%x \n",
+					ret, p_mod->sensor_dev_tab[fd_handle->sensor_id].cur_i2c_client->addr);
+			SLEEP_MS(20);
+			ret = SENSOR_K_FAIL;
+		} else {
+			ret = SENSOR_K_SUCCESS;
+			if (copy_to_user(pI2cTab->i2c_data, pBuff, read_num)) {
+				ret = SENSOR_K_FAIL;
+				SENSOR_PRINT_ERR("sensor W I2C ERR: copy user fail, size %d \n", cnt);
+				goto sensor_k_readi2c_return;
+			}
+			break;
+		}
+	}
+
+sensor_k_readi2c_return:
+	if(PNULL != pBuff)
+		_sensor_k_free(fd_handle, pBuff);
+
+	SENSOR_PRINT("_Sensor_K_ReadI2C, ret %d \n", ret);
+	return ret;
+}
+
+LOCAL int _sensor_csi2_error(uint32_t err_id, uint32_t err_status, void* u_data)
+{
+	int                      ret = 0;
+
+	printk("V4L2: csi2_error, %d 0x%x \n", err_id, err_status);
+
+	return ret;
+
+}
+
+int sensor_k_open(struct inode *node, struct file *file)
+{
+	int                            ret = 0;
+	struct sensor_file_tag         *p_file;
+	struct sensor_module_tab_tag   *p_mod = NULL;// platform_get_drvdata(_sensor_k_get_platform_device());
+	struct miscdevice *md = (struct miscdevice *)file->private_data ;
+
+	if (!md) {
+		ret = -EFAULT;
+		printk("rot_k_open fail miscdevice NULL \n");
+		return -1;
+	}
+	p_mod = (struct sensor_module_tab_tag*)md->this_device->platform_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	p_file = (struct sensor_file_tag *)vzalloc(sizeof(struct sensor_file_tag));
+	SENSOR_CHECK_ZERO(p_file);
+	file->private_data = p_file;
+	p_file->module_data = p_mod;
+	ret = csi_api_malloc(&p_file->csi_handle);
+	if (ret) {
+		vfree(p_file);
+		p_file = NULL;
+		return -1;
+	}
+
+	if (atomic_inc_return(&p_mod->total_users) == 1) {
+		struct device_node *dn = p_mod->of_node;
+		ret = clk_mm_i_eb(dn,1);
+		wake_lock(&p_mod->wakelock);
+	}
+	printk("sensor open %d\n", ret);
+	return ret;
+}
+
+int _sensor_k_close_mipi(struct file *file)
+{
+	int                            ret = 0;
+	struct sensor_file_tag         *p_file = file->private_data;
+	struct csi_context             *handle = NULL;
+	SENSOR_CHECK_ZERO(p_file);
+	handle = p_file->csi_handle;
+	if (NULL == handle) {
+		printk("handle null\n");
+		return -1;
+	}
+	if (INTERFACE_MIPI == p_file->if_type) {
+		if (1 == p_file->mipi_on) {
+			csi_api_close(handle, p_file->phy_id);
+			_sensor_k_mipi_clk_dis(p_file);
+			p_file->mipi_on = 0;
+			printk("MIPI off \n");
+		} else {
+			printk("MIPI already off \n");
+		}
+
+	}
+	return ret;
+}
+
+int sensor_k_release(struct inode *node, struct file *file)
+{
+	int                            ret = 0;
+	struct sensor_file_tag         *p_file = file->private_data;
+	struct sensor_module_tab_tag   *p_mod;
+
+	SENSOR_CHECK_ZERO(p_file);
+	p_mod = p_file->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	printk("sensor: release \n");
+	if (atomic_dec_return(&p_mod->total_users) == 0) {
+		struct device_node *dn = p_mod->of_node;
+		sensor_k_set_voltage_cammot((uint32_t *)p_file, SENSOR_VDD_CLOSED);
+		sensor_k_set_voltage_avdd((uint32_t *)p_file, SENSOR_VDD_CLOSED);
+		sensor_k_set_voltage_dvdd((uint32_t *)p_file, SENSOR_VDD_CLOSED);
+		sensor_k_set_voltage_iovdd((uint32_t *)p_file, SENSOR_VDD_CLOSED);
+		_sensor_k_set_mclk(p_file, dn, 0);
+		_sensor_k_close_mipi(file);
+		ret = clk_mm_i_eb(dn,0);
+
+		wake_unlock(&p_mod->wakelock);
+	}
+	if (SENSOR_ADDR_INVALID(p_file)) {
+		printk("SENSOR: Invalid addr, %p", p_mod);
+	} else {
+		csi_api_free(p_file->csi_handle);
+		vfree(p_file);
+		p_file = NULL;
+		file->private_data = NULL;
+	}
+	printk("sensor: release %d \n", ret);
+	return ret;
+}
+
+LOCAL ssize_t sensor_k_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *gpos)
+{
+	return 0;
+}
+
+LOCAL ssize_t sensor_k_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *gpos)
+{
+	char                          buf[64];
+	char                          *pBuff = PNULL;
+	struct                        i2c_msg msg_w;
+	int                           ret = SENSOR_K_FAIL;
+	int                           need_alloc = 1;
+	struct i2c_client             *i2c_client = PNULL;
+	struct sensor_file_tag        *p_file = filp->private_data;
+	struct sensor_module_tab_tag  *p_mod;
+	SENSOR_CHECK_ZERO(p_file);
+
+	p_mod = p_file->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	i2c_client = p_mod->sensor_dev_tab[p_file->sensor_id].cur_i2c_client;
+
+	SENSOR_PRINT("sensor w cnt %ld, buf %ld\n", cnt, sizeof(buf));
+
+	if (cnt < sizeof(buf)) {
+		pBuff = buf;
+		need_alloc = 0;
+	}  else {
+		pBuff = _sensor_k_malloc(p_file, cnt);
+		if (PNULL == pBuff) {
+			SENSOR_PRINT_ERR("sensor w ERR: alloc fail, size %ld \n", cnt);
+			goto sensor_k_write_return;
+		} else {
+			SENSOR_PRINT("sensor w: alloc success, size %ld \n", cnt);
+		}
+	}
+
+	if (copy_from_user(pBuff, ubuf, cnt)) {
+		SENSOR_PRINT_ERR("sensor w ERR: copy user fail, size %ld\n", cnt);
+		goto sensor_k_write_return;
+	}
+	printk("sensor clnt addr 0x%x.\n", i2c_client->addr);
+	msg_w.addr = i2c_client->addr;
+	msg_w.flags = 0;
+	msg_w.buf = pBuff;
+	msg_w.len = cnt;
+
+	ret = i2c_transfer(i2c_client->adapter, &msg_w, 1);
+	if (ret != 1) {
+		SENSOR_PRINT_ERR("SENSOR: w reg fail, ret %d, w addr: 0x%x,\n",
+				ret, i2c_client->addr);
+	} else {
+		ret = SENSOR_K_SUCCESS;
+	}
+
+sensor_k_write_return:
+	if ((PNULL != pBuff) && need_alloc)
+		_sensor_k_free(p_file, pBuff);
+
+	SENSOR_PRINT("sensor w done, ret %d \n", ret);
+	return ret;
+}
+
+int _sensor_burst_write_init(struct sensor_file_tag *fd_handle, struct sensor_reg_tag *p_reg_table, uint32_t init_table_size)
+{
+	uint32_t                      rtn = 0;
+	int                           ret = 0;
+	uint32_t                      i = 0;
+	uint32_t                      written_num = 0;
+	uint16_t                      wr_reg = 0;
+	uint16_t                      wr_val = 0;
+	uint32_t                      wr_num_once = 0;
+	uint8_t                       *p_reg_val_tmp = 0;
+	struct i2c_msg                msg_w;
+	struct i2c_client             *i2c_client = PNULL;
+	struct sensor_file_tag        *p_file = fd_handle;
+	struct sensor_module_tab_tag  *p_mod;
+	SENSOR_CHECK_ZERO(p_file);
+
+	p_mod = p_file->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	i2c_client = p_mod->sensor_dev_tab[p_file->sensor_id].cur_i2c_client;
+
+	printk("SENSOR: burst w Init\n");
+	if (0 == i2c_client) {
+		SENSOR_PRINT_ERR("SENSOR: burst w Init err, i2c_clnt NULL!.\n");
+		return -1;
+	}
+	p_reg_val_tmp = (uint8_t*)_sensor_k_malloc(fd_handle, init_table_size*sizeof(uint16_t) + 16);
+
+	if(PNULL == p_reg_val_tmp){
+		SENSOR_PRINT_ERR("_sensor_burst_write_init ERROR: alloc is fail, size = %ld \n", init_table_size*sizeof(uint16_t) + 16);
+		return -1;
+	}
+	else{
+		SENSOR_PRINT_HIGH("_sensor_burst_write_init: alloc success, size = %ld \n", init_table_size*sizeof(uint16_t) + 16);
+	}
+
+
+	while (written_num < init_table_size) {
+		wr_num_once = 2;
+
+		wr_reg = p_reg_table[written_num].reg_addr;
+		wr_val = p_reg_table[written_num].reg_value;
+		if (SENSOR_WRITE_DELAY == wr_reg) {
+			if (wr_val >= 10) {
+				msleep(wr_val);
+			} else {
+				mdelay(wr_val);
+			}
+		} else {
+			p_reg_val_tmp[0] = (uint8_t)(wr_reg);
+			p_reg_val_tmp[1] = (uint8_t)(wr_val);
+
+			if ((0x0e == wr_reg) && (0x01 == wr_val)) {
+				for (i = written_num + 1; i < init_table_size; i++) {
+					if ((0x0e == wr_reg) && (0x00 == wr_val)) {
+						break;
+					} else {
+						wr_val = p_reg_table[i].reg_value;
+						p_reg_val_tmp[wr_num_once+1] = (uint8_t)(wr_val);
+						wr_num_once ++;
+					}
+				}
+			}
+			msg_w.addr = i2c_client->addr;
+			msg_w.flags = 0;
+			msg_w.buf = p_reg_val_tmp;
+			msg_w.len = (uint32_t)(wr_num_once);
+			ret = i2c_transfer(i2c_client->adapter, &msg_w, 1);
+			if (ret!=1) {
+				SENSOR_PRINT("SENSOR: s err, val {0x%x 0x%x} {0x%x 0x%x} {0x%x 0x%x} {0x%x 0x%x} {0x%x 0x%x} {0x%x 0x%x}.\n",
+					p_reg_val_tmp[0],p_reg_val_tmp[1],p_reg_val_tmp[2],p_reg_val_tmp[3],
+					p_reg_val_tmp[4],p_reg_val_tmp[5],p_reg_val_tmp[6],p_reg_val_tmp[7],
+					p_reg_val_tmp[8],p_reg_val_tmp[9],p_reg_val_tmp[10],p_reg_val_tmp[11]);
+					SENSOR_PRINT("SENSOR: i2c w once err\n");
+				rtn = 1;
+				break;
+			}
+		}
+		written_num += wr_num_once - 1;
+	}
+	SENSOR_PRINT("SENSOR: burst w Init OK\n");
+	_sensor_k_free(fd_handle, p_reg_val_tmp);
+	return rtn;
+}
+
+LOCAL long sensor_k_ioctl(struct file *file, unsigned int cmd,
+				unsigned long arg)
+{
+	int                            ret = 0;
+	struct sensor_module_tab_tag    *p_mod;
+	struct sensor_file_tag         *p_file = file->private_data;
+
+	SENSOR_CHECK_ZERO(p_file);
+	p_mod = p_file->module_data;
+	SENSOR_CHECK_ZERO(p_mod);
+
+	SENSOR_PRINT("SENSOR: ioctl cmd %d id %d \n", cmd, p_file->sensor_id);
+
+	if (SENSOR_IO_SET_ID == cmd)
+	{
+		mutex_lock(&p_mod->sensor_id_lock);
+		ret = copy_from_user(&p_file->sensor_id, (uint32_t *) arg, sizeof(uint32_t));
+		mutex_unlock(&p_mod->sensor_id_lock);
+	}
+
+	mutex_lock(&p_mod->sensor_dev_tab[p_file->sensor_id].sync_lock);
+	switch (cmd) {
+	case SENSOR_IO_PD:
+		{
+			uint8_t power_level;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_PD \n");
+			ret = copy_from_user(&power_level, (uint8_t *) arg, sizeof(uint8_t));
+
+			if (0 == ret)
+				ret = sensor_k_set_pd_level((uint32_t *)p_file, power_level);
+		}
+		break;
+
+	case SENSOR_IO_SET_CAMMOT:
+		{
+			uint32_t vdd_val;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_SET_CAMMOT \n");
+			ret = copy_from_user(&vdd_val, (uint32_t *) arg, sizeof(uint32_t));
+			if (0 == ret)
+				ret = sensor_k_set_voltage_cammot((uint32_t *)p_file, vdd_val);
+		}
+		break;
+
+	case SENSOR_IO_SET_AVDD:
+		{
+			uint32_t vdd_val;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_SET_AVDD \n");
+			ret = copy_from_user(&vdd_val, (uint32_t *) arg, sizeof(uint32_t));
+			if (0 == ret)
+				ret = sensor_k_set_voltage_avdd((uint32_t *)p_file, vdd_val);
+		}
+		break;
+
+	case SENSOR_IO_SET_DVDD:
+		{
+			uint32_t vdd_val;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_SET_DVDD \n");
+			ret = copy_from_user(&vdd_val, (uint32_t *) arg, sizeof(uint32_t));
+			if (0 == ret)
+				ret = sensor_k_set_voltage_dvdd((uint32_t *)p_file, vdd_val);
+		}
+		break;
+
+	case SENSOR_IO_SET_IOVDD:
+		{
+			uint32_t vdd_val;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_SET_IOVDD \n");
+			ret = copy_from_user(&vdd_val, (uint32_t *) arg, sizeof(uint32_t));
+			if (0 == ret)
+				ret = sensor_k_set_voltage_iovdd((uint32_t *)p_file, vdd_val);
+		}
+		break;
+
+	case SENSOR_IO_SET_MCLK:
+		{
+			uint32_t mclk;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_SET_MCLK \n");
+			ret = copy_from_user(&mclk, (uint32_t *) arg, sizeof(uint32_t));
+			if (0 == ret)
+				ret = _sensor_k_set_mclk(p_file, p_mod->of_node, mclk);
+		}
+		break;
+
+	case SENSOR_IO_RST:
+		{
+			uint32_t rst_val[2];
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_RST \n");
+			ret = copy_from_user(rst_val, (uint32_t *) arg, 2*sizeof(uint32_t));
+			if (0 == ret)
+				ret = _sensor_k_reset(p_file, rst_val[0], rst_val[1]);
+		}
+		break;
+
+	case SENSOR_IO_I2C_INIT:
+		{
+			uint32_t sensor_id;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_I2C_INIT \n");
+			ret = copy_from_user(&sensor_id, (uint32_t *) arg, sizeof(uint32_t));
+			if (0 == ret)
+				ret = sensor_k_sensor_sel((uint32_t *)p_file, sensor_id);
+		}
+		break;
+
+	case SENSOR_IO_I2C_DEINIT:
+		{
+			uint32_t sensor_id;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_I2C_DEINIT \n");
+			ret = copy_from_user(&sensor_id, (uint32_t *) arg, sizeof(uint32_t));
+			if (0 == ret)
+				ret = sensor_k_sensor_desel(p_file, sensor_id);
+		}
+		break;
+
+	case SENSOR_IO_SET_ID:
+		{
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_SET_ID \n");
+			ret = copy_from_user(&p_file->sensor_id, (uint32_t *) arg, sizeof(uint32_t));
+			get_gpio_id(p_mod->of_node, &p_file->gpio_tab.pwn, &p_file->gpio_tab.reset, p_file->sensor_id);
+		}
+		break;
+
+	case SENSOR_IO_RST_LEVEL:
+		{
+			uint32_t level;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_RST_LEVEL \n");
+			ret = copy_from_user(&level, (uint32_t *) arg, sizeof(uint32_t));
+			if (0 == ret)
+				ret = sensor_k_set_rst_level((uint32_t *)p_file, level);
+		}
+		break;
+
+	case SENSOR_IO_I2C_ADDR:
+		{
+			uint16_t i2c_addr;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_I2C_ADDR \n");
+			ret = copy_from_user(&i2c_addr, (uint16_t *) arg, sizeof(uint16_t));
+			if (0 == ret) {
+				p_mod->sensor_dev_tab[p_file->sensor_id].cur_i2c_client->addr = (p_mod->sensor_dev_tab[p_file->sensor_id].cur_i2c_client->addr & (~0xFF)) |i2c_addr;
+				printk("SENSOR_IO_I2C_ADDR: addr = %x, %x \n", i2c_addr, p_mod->sensor_dev_tab[p_file->sensor_id].cur_i2c_client->addr);
+			}
+		}
+		break;
+
+	case SENSOR_IO_I2C_READ:
+		{
+			struct sensor_reg_bits_tag reg;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_I2C_READ \n");
+			ret = copy_from_user(&reg, (struct sensor_reg_bits_tag *) arg, sizeof(struct sensor_reg_bits_tag));
+
+			if (0 == ret) {
+				ret = _Sensor_K_ReadReg(p_file, &reg);
+				if(SENSOR_K_FAIL != ret){
+					ret = copy_to_user((struct sensor_reg_bits_tag *)arg, &reg, sizeof(struct sensor_reg_bits_tag));
+				}
+			}
+		}
+		break;
+
+	case SENSOR_IO_I2C_WRITE:
+		{
+			struct sensor_reg_bits_tag reg;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_I2C_WRITE \n");
+			ret = copy_from_user(&reg, (struct sensor_reg_bits_tag *) arg, sizeof(struct sensor_reg_bits_tag));
+
+			if (0 == ret) {
+				ret = _Sensor_K_WriteReg(p_file, &reg);
+			}
+
+		}
+		break;
+
+	case SENSOR_IO_I2C_WRITE_REGS:
+		{
+			struct sensor_reg_tab_tag regTab;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_I2C_WRITE_REGS \n");
+			ret = copy_from_user(&regTab, (struct sensor_reg_tab_tag *) arg, sizeof(struct sensor_reg_tab_tag));
+			if (0 == ret)
+				ret = _sensor_k_wr_regtab(p_file, &regTab);
+		}
+		break;
+
+	case SENSOR_IO_SET_I2CCLOCK:
+		{
+			uint32_t clock;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_SET_I2CCLOCK \n");
+			ret = copy_from_user(&clock, (uint32_t *) arg, sizeof(uint32_t));
+			if(0 == ret){
+				_sensor_k_set_i2c_clk(p_file, clock);
+			}
+		}
+		break;
+
+	case SENSOR_IO_I2C_WRITE_EXT:
+		{
+			struct sensor_i2c_tag i2cTab;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_I2C_WRITE_EXT \n");
+			ret = copy_from_user(&i2cTab, (struct sensor_i2c_tag*)arg, sizeof(struct sensor_i2c_tag));
+			if (0 == ret)
+				ret = _sensor_k_wr_i2c(p_file, &i2cTab);
+		}
+		break;
+
+	case SENSOR_IO_I2C_READ_EXT:
+		{
+			struct sensor_i2c_tag i2cTab;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_I2C_READ_EXT \n");
+			ret = copy_from_user(&i2cTab, (struct sensor_i2c_tag*) arg, sizeof(struct sensor_i2c_tag));
+			if (0 == ret)
+				ret = _sensor_k_rd_i2c(p_file, &i2cTab);
+		}
+		break;
+
+	case SENSOR_IO_GET_FLASH_LEVEL:
+		{
+			struct sensor_flash_level flash_level;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_GET_FLASH_LEVEL \n");
+			ret = copy_from_user(&flash_level, (struct sensor_flash_level *) arg, sizeof(struct sensor_flash_level));
+			if (0 == ret) {
+				ret = _sensor_k_get_flash_level(p_file, &flash_level);
+				if(SENSOR_K_FAIL != ret){
+					ret = copy_to_user((struct sensor_flash_level *)arg, &flash_level, sizeof(struct sensor_flash_level));
+				}
+			}
+		}
+		break;
+	case SENSOR_IO_GET_SOCID:
+		{
+			//struct sensor_socid_tag	Id  ;
+			uint32_t id;
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_GET_SOCID \n");
+			//Id.d_die=sci_get_chip_id();
+			//Id.a_die=sci_get_ana_chip_id()|sci_get_ana_chip_ver();
+			gpio_direction_input(238);
+			id = gpio_get_value(238);
+			//SENSOR_PRINT("cpu id 0x%x,0x%x  \n", Id.d_die,Id.a_die);
+			ret = copy_to_user((uint32_t *)arg, &id, sizeof(uint32_t));
+		}
+		break;
+	case SENSOR_IO_SET_SOCNAME:
+	    {
+	        ret = copy_from_user(&socname,(struct sensor_name *)arg,sizeof(struct sensor_name));
+	    }
+	    break;
+	case SENSOR_IO_IF_CFG:
+		{
+			struct sensor_if_cfg_tag if_cfg;
+			struct csi_context *csi_handle;
+			csi_handle = p_file->csi_handle;
+			if (NULL == csi_handle) {
+				printk("handle null\n");
+				return -1;
+			}
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_IF_CFG \n");
+			ret = copy_from_user((void*)&if_cfg, (struct sensor_if_cfg_tag *)arg, sizeof(struct sensor_if_cfg_tag));
+			if (0 == ret) {
+				if (INTERFACE_OPEN == if_cfg.is_open) {
+					if (INTERFACE_MIPI == if_cfg.if_type) {
+						if (0 == p_file->mipi_on) {
+							_sensor_k_mipi_clk_en(p_file, p_mod->of_node);
+							udelay(1);
+							ret = csi_api_init(if_cfg.bps_per_lane, if_cfg.phy_id);
+							SENSOR_PRINT("csi_api_init: %d \n", ret);
+							ret = csi_api_start(csi_handle);
+							SENSOR_PRINT("csi_api_start: %d \n", ret);
+							ret = csi_reg_isr(csi_handle, _sensor_csi2_error, (void*)p_file);
+							SENSOR_PRINT("csi_reg_isr: %d \n", ret);
+							ret = csi_set_on_lanes(if_cfg.lane_num);
+							SENSOR_PRINT("csi_set_on_lanes: %d \n", ret);
+							p_file->mipi_on = 1;
+							p_file->phy_id = if_cfg.phy_id;
+							p_file->if_type = INTERFACE_MIPI;
+							printk("MIPI on, lane %d, bps_per_lane %d, wait 10us \n", if_cfg.lane_num, if_cfg.bps_per_lane);
+						} else {
+							printk("MIPI already on \n");
+						}
+					}
+				} else {
+					if (INTERFACE_MIPI == if_cfg.if_type) {
+						if (1 == p_file->mipi_on) {
+							csi_api_close(csi_handle, if_cfg.phy_id);
+							_sensor_k_mipi_clk_dis(p_file);
+							p_file->mipi_on = 0;
+							printk("MIPI off \n");
+						} else {
+							printk("MIPI already off \n");
+						}
+
+					}
+
+				}
+			}
+		}
+		break;
+
+		case SENSOR_IO_POWER_CFG:
+		{
+			struct sensor_power_info_tag pwr_cfg;
+
+			SENSOR_PRINT("SENSOR: ioctl SENSOR_IO_POWER_CFG \n");
+			ret = copy_from_user(&pwr_cfg, (struct sensor_power_info_tag*) arg, sizeof(struct sensor_power_info_tag));
+			if (0 == ret) {
+				if (pwr_cfg.is_on) {
+					ret = sensor_power_on((uint32_t *)p_file, pwr_cfg.op_sensor_id, &pwr_cfg.dev0, &pwr_cfg.dev1, &pwr_cfg.dev2);
+				} else {
+					ret = sensor_power_off((uint32_t *)p_file, pwr_cfg.op_sensor_id, &pwr_cfg.dev0, &pwr_cfg.dev1, &pwr_cfg.dev2);
+				}
+			}
+		}
+		break;
+
+		case SENSOR_IO_READ_OTPDATA:
+		{
+			SENSOR_OTP_PARAM_T *para = (SENSOR_OTP_PARAM_T *)arg;
+			uint32_t type;
+			copy_from_user(&type, &para->type, sizeof(uint32_t));
+			printk("SENSOR: ioctl SENSOR_IO_READ_OTPDATA %p type %d\n", arg, para->type);
+
+			if(type == SENSOR_OTP_PARAM_CHECKSUM) {
+				SENSOR_OTP_DATA_INFO_T *chksum = &p_mod->otp_param[p_file->sensor_id].golden;
+				if(chksum->data_ptr && chksum->size > 0) {
+					copy_to_user(para->buff, chksum->data_ptr, chksum->size);
+					copy_to_user(&para->len, &chksum->size, sizeof(uint32_t));
+				}
+			} else if(type == SENSOR_OTP_PARAM_NORMAL) {
+
+				SENSOR_OTP_DATA_INFO_T *awb = &p_mod->otp_param[p_file->sensor_id].awb;
+				SENSOR_OTP_DATA_INFO_T *lsc = &p_mod->otp_param[p_file->sensor_id].lsc;
+
+				if(p_mod->otp_param[p_file->sensor_id].buff && p_mod->otp_param[p_file->sensor_id].len > 0) {
+					copy_to_user(para->buff, p_mod->otp_param[p_file->sensor_id].buff,
+						p_mod->otp_param[p_file->sensor_id].len);
+					copy_to_user(&para->len, &p_mod->otp_param[p_file->sensor_id].len,
+						sizeof(uint32_t));
+				}
+				if(awb->data_ptr && awb->size > 0) {
+					copy_to_user(para->awb.data_ptr, awb->data_ptr, awb->size);
+					copy_to_user(&para->awb.size, &awb->size, sizeof(uint32_t));
+				}
+				if(lsc->data_ptr && lsc->size > 0) {
+					copy_to_user(para->lsc.data_ptr, lsc->data_ptr, lsc->size);
+					copy_to_user(&para->lsc.size, &lsc->size, sizeof(uint32_t));
+				}
+			} else  {
+				printk("SENSOR: ioctl SENSOR_IO_READ_OTPDATA mismatch type \n");
+			}
+		}
+		break;
+
+	default:
+		SENSOR_PRINT("sensor_k_ioctl: inv cmd %x  \n", cmd);
+		break;
+	}
+
+	mutex_unlock(&p_mod->sensor_dev_tab[p_file->sensor_id].sync_lock);
+	return (long)ret;
+}
+
+LOCAL struct file_operations sensor_fops = {
+	.owner = THIS_MODULE,
+	.open = sensor_k_open,
+	.read = sensor_k_read,
+	.write = sensor_k_write,
+	.unlocked_ioctl = sensor_k_ioctl,
+	.compat_ioctl = compat_sensor_k_ioctl,
+	.release = sensor_k_release,
+};
+
+LOCAL struct miscdevice sensor_dev = {
+	.minor = SENSOR_MINOR,
+	.name = SENSOR_DEVICE_NAME,
+	.fops = &sensor_fops,
+};
+
+LOCAL int sensor_k_register_subdevs(struct platform_device *pdev)
+{
+	struct device_node             *adapter, *child;
+	struct sensor_module_tab_tag   *p_mod = platform_get_drvdata(pdev);
+
+	SENSOR_CHECK_ZERO(p_mod);
+
+	printk("sensor register sub device E\n");
+	for_each_compatible_node(adapter, NULL, "sprd,i2c") {
+		if (!of_find_device_by_node(adapter)) {
+			of_node_put(adapter);
+			printk("sensor find device fail\n");
+			//return -EPROBE_DEFER;
+			return 0;
+		}
+
+		for_each_available_child_of_node(adapter, child) {
+			struct i2c_client *client;
+
+			client = of_find_i2c_device_by_node(child);
+			if (!client) {
+				printk("sensor find i2c device fail\n");
+				goto e_retry;
+			}
+			if (0 == strcmp(client->name, SENSOR_DEV0_I2C_NAME)) {
+				printk("sensor dev0 i2c device 0x%x %s\n", client->addr, client->name);
+				p_mod->sensor_dev_tab[0].cur_i2c_client = client;
+			}
+			if (0 == strcmp(client->name, SENSOR_DEV1_I2C_NAME)) {
+				printk("sensor dev1 i2c device 0x%x %s\n", client->addr, client->name);
+				p_mod->sensor_dev_tab[1].cur_i2c_client = client;
+			}
+			if (0 == strcmp(client->name, SENSOR_DEV2_I2C_NAME)) {
+				printk("sensor dev2 i2c device 0x%x %s\n", client->addr, client->name);
+				p_mod->sensor_dev_tab[2].cur_i2c_client = client;
+			}
+			if (0 == strcmp(client->name, SENSOR_VCM0_I2C_NAME)) {
+				printk("sensor vcm0 i2c device 0x%x %s\n", client->addr, client->name);
+				p_mod->sensor_dev_tab[0].vcm_i2c_client = client;
+				p_mod->sensor_dev_tab[0].vcm_gpio_i2c_flag = 0;
+			}
+		}
+	}
+
+	for_each_compatible_node(adapter, NULL, "i2c-gpio") {
+		if (!of_find_device_by_node(adapter)) {
+			of_node_put(adapter);
+			printk("sensor find device fail\n");
+			return -EPROBE_DEFER;
+		}
+
+		for_each_available_child_of_node(adapter, child) {
+			struct i2c_client *client;
+
+			client = of_find_i2c_device_by_node(child);
+			if (!client) {
+				printk("sensor find vcm %s i2c device fail\n",child->name);
+			} else {
+				if (0 == strcmp(client->name, SENSOR_VCM0_I2C_NAME)) {
+					printk("sensor vcm i2c device 0x%x %s\n", client->addr, client->name);
+					p_mod->sensor_dev_tab[0].vcm_i2c_client = client;
+					p_mod->sensor_dev_tab[0].vcm_gpio_i2c_flag = 1;
+				}
+			}
+		}
+	}
+
+
+	printk("sensor register sub device success\n");
+	return 0;
+
+e_retry:
+	of_node_put(child);
+	return -EPROBE_DEFER;
+}
+
+static ssize_t sensor_name_show(struct device *dev,struct device_attribute *attr, char *buf){
+    return sprintf(buf,"%d,%d\n",socname.back_name,socname.front_name);
+}
+
+static DEVICE_ATTR(sensor_name, S_IRUGO, sensor_name_show, NULL);
+
+int sensor_k_probe(struct platform_device *pdev)
+{
+	int                          ret = 0;
+	uint32_t                     tmp = 0;
+	int                          i;
+	struct sensor_module_tab_tag *p_mod;
+#ifndef	CONFIG_SC_FPGA_PIN
+	struct sensor_gpio_tag       gpio_tab;
+#endif
+	int                          gpio_id = 0;
+
+	printk(KERN_ALERT "sensor probe called\n");
+	device_create_file(&pdev->dev, &dev_attr_sensor_name);
+	p_mod = (struct sensor_module_tab_tag *)vzalloc(sizeof(struct sensor_module_tab_tag));
+	SENSOR_CHECK_ZERO(p_mod);
+
+	for (i = 0; i < SENSOR_DEV_MAX; i++) {
+		mutex_init(&p_mod->sensor_dev_tab[i].sync_lock);
+		atomic_set(&p_mod->sensor_dev_tab[i].users, 0);
+	}
+	mutex_init(&p_mod->sensor_id_lock);
+	wake_lock_init(&p_mod->wakelock, WAKE_LOCK_SUSPEND,
+                   "pm_message_wakelock_sensor_k");
+	platform_set_drvdata(pdev, p_mod);
+	atomic_set(&p_mod->total_users, 0);
+
+	ret = misc_register(&sensor_dev);
+	if (ret) {
+		printk(KERN_ERR "can't reg miscdev on minor=%d (%d)\n",
+			SENSOR_MINOR, ret);
+		goto misc_register_error;
+	}
+
+	p_mod->of_node = pdev->dev.of_node;
+	parse_baseaddress(pdev->dev.of_node);
+	sensor_dev.this_device->platform_data = (void*)p_mod;
+
+#ifndef	CONFIG_SC_FPGA_PIN
+	for (i = 0; i < SENSOR_DEV_MAX; i++) {
+		get_gpio_id(p_mod->of_node, &gpio_tab.pwn, &gpio_tab.reset, i);
+		ret = gpio_request(gpio_tab.pwn, NULL);
+		if (ret) {
+			tmp = 1;
+			printk("sensor: gpio already request pwn %d %d.\n", gpio_tab.pwn, i);
+		}
+		ret = gpio_request(gpio_tab.reset, NULL);
+		if (ret) {
+			tmp = 1;
+			printk("sensor:  gpio already request reset %d %d.\n", gpio_tab.reset, i);
+		}
+	}
+
+	get_gpio_id_ex(p_mod->of_node, GPIO_CAMDVDD, &gpio_id, 0);
+	ret = gpio_request(gpio_id, NULL);
+	if (ret) {
+		tmp = 1;
+		printk("sensor: gpio already request GPIO_CAMDVDD %d.\n", gpio_id);
+	}
+#endif
+
+	ret = sensor_k_register_subdevs(pdev);
+	if (ret) {
+		printk(KERN_ERR "can't reg sub dev=%d (%d)\n",
+			SENSOR_MINOR, ret);
+		goto misc_register_error;
+	}
+	kthread_run(sensor_reloadinfo_thread, p_mod->otp_param, "otpreload");
+	goto exit;
+
+misc_register_error:
+	misc_deregister(&sensor_dev);
+
+	if (SENSOR_ADDR_INVALID(p_mod)) {
+		printk("SENSOR: Invalid addr, %p", p_mod);
+	} else {
+		vfree(p_mod);
+		p_mod = NULL;
+		platform_set_drvdata(pdev, NULL);
+	}
+exit:
+	if (ret) {
+		printk(KERN_ERR "sensor prb fail req gpio %d err %d\n",
+			tmp, ret);
+	} else {
+		printk(KERN_ALERT " sensor prb Success\n");
+	}
+	return ret;
+}
+
+LOCAL int sensor_k_remove(struct platform_device *dev)
+{
+	struct sensor_module_tab_tag *p_mod = platform_get_drvdata(dev);
+#ifndef CONFIG_SC_FPGA_PIN
+	struct sensor_gpio_tag       gpio_tab;
+	int                          i;
+#endif
+	int                          gpio_id = 0;
+
+	SENSOR_CHECK_ZERO(p_mod);
+
+	printk(KERN_INFO "sensor remove called !\n");
+
+#ifndef CONFIG_SC_FPGA_PIN
+	for (i = 0; i < SENSOR_DEV_MAX; i++) {
+		get_gpio_id(p_mod->of_node, &gpio_tab.pwn, &gpio_tab.reset, i);
+		gpio_free(gpio_tab.pwn);
+		gpio_free(gpio_tab.reset);
+	}
+
+	get_gpio_id_ex(p_mod->of_node, GPIO_CAMDVDD, &gpio_id, 0);
+	gpio_free(gpio_id);
+#endif
+
+	misc_deregister(&sensor_dev);
+	wake_lock_destroy(&p_mod->wakelock);
+
+	if (SENSOR_ADDR_INVALID(p_mod)) {
+		printk("SENSOR: Invalid addr, %p", p_mod);
+	} else {
+		vfree(p_mod);
+		p_mod = NULL;
+		platform_set_drvdata(dev, NULL);
+	}
+	printk(KERN_INFO "sensor remove Success !\n");
+	return 0;
+}
+
+LOCAL const struct of_device_id of_match_table_sensor[] = {
+	{ .compatible = "sprd,sprd_sensor", },
+	{ },
+};
+
+static struct platform_driver sensor_dev_driver = {
+	.probe = sensor_k_probe,
+	.remove =sensor_k_remove,
+	.driver = {
+		.owner = THIS_MODULE,
+		.name  = SENSOR_DEVICE_NAME,
+		.of_match_table = of_match_ptr(of_match_table_sensor),
+		},
+};
+
+int __init sensor_k_init(void)
+{
+	printk(KERN_INFO "sensor_k_init called !\n");
+
+	if (platform_driver_register(&sensor_dev_driver) != 0) {
+		printk("platform device register Failed \n");
+		return SENSOR_K_FAIL;
+	}
+	return 0;
+}
+
+void sensor_k_exit(void)
+{
+	printk(KERN_INFO "sensor_k_exit called !\n");
+	platform_driver_unregister(&sensor_dev_driver);
+}
+
+module_init(sensor_k_init);
+module_exit(sensor_k_exit);
+
+MODULE_DESCRIPTION("Sensor Driver");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/media/sprd_sensor/sensor_drv_sprd.h b/drivers/media/sprd_sensor/sensor_drv_sprd.h
new file mode 100644
index 00000000..bd7d3915
--- /dev/null
+++ b/drivers/media/sprd_sensor/sensor_drv_sprd.h
@@ -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.
+ */
+#ifndef _SENSOR_DRV_SPRD_H_
+#define _SENSOR_DRV_SPRD_H_
+
+#define SENSOER_VDD_1200MV                  1200000
+#define SENSOER_VDD_1300MV                  1300000
+#define SENSOER_VDD_1500MV                  1500000
+#define SENSOER_VDD_1800MV                  1800000
+#define SENSOER_VDD_2500MV                  2500000
+#define SENSOER_VDD_2800MV                  2800000
+#define SENSOER_VDD_3000MV                  3000000
+#define SENSOER_VDD_3300MV                  3300000
+#define SENSOER_VDD_3800MV                  3800000
+
+typedef enum {
+	SENSOR_VDD_3800MV = 0,
+	SENSOR_VDD_3300MV,
+	SENSOR_VDD_3000MV,
+	SENSOR_VDD_2800MV,
+	SENSOR_VDD_2500MV,
+	SENSOR_VDD_1800MV,
+	SENSOR_VDD_1500MV,
+	SENSOR_VDD_1300MV,
+	SENSOR_VDD_1200MV,
+	SENSOR_VDD_CLOSED,
+	SENSOR_VDD_UNUSED
+} SENSOR_VDD_VAL_E;
+
+enum sensor_id_e {
+	SENSOR_DEV_0 = 0,
+	SENSOR_DEV_1,
+	SENSOR_DEV_2,
+	SENSOR_DEV_MAX
+};
+
+#define SENSOR_DEV0_I2C_NAME                 "sensor_main"
+#define SENSOR_DEV1_I2C_NAME                 "sensor_sub"
+#define SENSOR_DEV2_I2C_NAME                 "sensor_i2c_dev2"
+#define SENSOR_VCM0_I2C_NAME                 "sensor_i2c_vcm0"
+
+
+#define SENSOR_DEV0_I2C_ADDR                 0x30
+#define SENSOR_DEV1_I2C_ADDR                 0x21
+#define SENSOR_DEV2_I2C_ADDR                 0x30
+
+#define SENSOR_I2C_BUST_NB                   7
+
+
+#define SENSOR_MAX_MCLK                      96       /*MHz*/
+#define SENOR_CLK_M_VALUE                    1000000
+
+#define GLOBAL_BASE                          SPRD_GREG_BASE    /*0xE0002E00UL <--> 0x8b000000 */
+#define ARM_GLOBAL_REG_GEN0                  (GLOBAL_BASE + 0x008UL)
+#define ARM_GLOBAL_REG_GEN3                  (GLOBAL_BASE + 0x01CUL)
+#define ARM_GLOBAL_PLL_SCR                   (GLOBAL_BASE + 0x070UL)
+#define GR_CLK_GEN5                          (GLOBAL_BASE + 0x07CUL)
+
+#define AHB_BASE                             SPRD_AHB_BASE    /*0xE000A000 <--> 0x20900000UL */
+#define AHB_GLOBAL_REG_CTL0                  (AHB_BASE + 0x200UL)
+#define AHB_GLOBAL_REG_SOFTRST               (AHB_BASE + 0x210UL)
+
+#define PIN_CTL_BASE                         SPRD_CPC_BASE    /*0xE002F000<-->0x8C000000UL */
+#define PIN_CTL_CCIRPD1                      PIN_CTL_BASE + 0x344UL
+#define PIN_CTL_CCIRPD0                      PIN_CTL_BASE + 0x348UL
+
+#define MISC_BASE                            SPRD_MISC_BASE    /*0xE0033000<-->0x82000000 */
+
+#define ANA_REG_BASE                         MISC_BASE + 0x480
+#define ANA_LDO_PD_CTL                       ANA_REG_BASE + 0x10
+#define ANA_LDO_VCTL2                        ANA_REG_BASE + 0x1C
+
+
+int sensor_k_set_pd_level(uint32_t *fd_handle, uint8_t power_level);
+int sensor_k_set_rst_level(uint32_t *fd_handle, uint32_t plus_level);
+int sensor_k_set_voltage_cammot(uint32_t *fd_handle, uint32_t cammot_val);
+int sensor_k_set_voltage_avdd(uint32_t *fd_handle, uint32_t avdd_val);
+int sensor_k_set_voltage_dvdd(uint32_t *fd_handle, uint32_t dvdd_val);
+int sensor_k_set_voltage_iovdd(uint32_t *fd_handle, uint32_t iodd_val);
+int sensor_k_set_mclk(uint32_t *fd_handle, uint32_t mclk);
+int sensor_k_sensor_sel(uint32_t *fd_handle, uint32_t sensor_id);
+
+#endif //_SENSOR_DRV_K_H_
-- 
cgit v1.3.1