path: root/drivers/media/sprd_sensor/sensor_drv_k.c

/*
 * 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");