/*
 * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/i2c.h>
#include <linux/clk.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/regulator/consumer.h>
#include <linux/gpio.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/gpio.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <media/ov5693.h>

#define OV5693_ID			0x5693
#define OV5693_SENSOR_TYPE		NVC_IMAGER_TYPE_RAW
#define OV5693_RES_CHG_WAIT_TIME_MS	100
#define OV5693_SIZEOF_I2C_BUF		16
#define OV5693_TABLE_WAIT_MS		0
#define OV5693_TABLE_END		1
#define OV5693_TABLE_RESET		2
#define OV5693_TABLE_RESET_TIMEOUT	50
#define OV5693_LENS_MAX_APERTURE	0	/* _INT2FLOAT_DIVISOR */
#define OV5693_LENS_FNUMBER		0	/* _INT2FLOAT_DIVISOR */
#define OV5693_LENS_FOCAL_LENGTH	6120	/* _INT2FLOAT_DIVISOR */
#define OV5693_LENS_VIEW_ANGLE_H	60000	/* _INT2FLOAT_DIVISOR */
#define OV5693_LENS_VIEW_ANGLE_V	60000	/* _INT2FLOAT_DIVISOR */

static struct nvc_gpio_init ov5693_gpio[] = {
	{ OV5693_GPIO_TYPE_PWRDN, GPIOF_OUT_INIT_LOW, "pwrdn", false, true, },
};

struct ov5693_info {
	atomic_t in_use;
	struct i2c_client *i2c_client;
	struct ov5693_platform_data *pdata;
	struct clk *mclk;
	struct miscdevice miscdev;
	int pwr_api;
	int pwr_dev;
	struct nvc_gpio gpio[ARRAY_SIZE(ov5693_gpio)];
	struct ov5693_power_rail regulators;
	bool power_on;
	u32 mode_index;
	bool mode_valid;
	bool mode_enable;
	unsigned test_pattern;
	struct nvc_imager_static_nvc sdata;
	u8 bin_en;
	struct ov5693_fuseid fuseid;
	struct regmap *regmap;
	struct regulator *ext_vcm_vdd;
};

struct ov5693_reg {
	u16 addr;
	u16 val;
};

struct ov5693_mode_data {
	struct nvc_imager_mode sensor_mode;
	struct nvc_imager_dynamic_nvc sensor_dnvc;
	struct ov5693_reg *p_mode_i2c;
};

static struct ov5693_platform_data ov5693_dflt_pdata = {
	.cfg		= 0,
	.num		= 0,
	.dev_name	= "camera",
};

/*
 * NOTE: static vs dynamic
 * If a member in the nvc_imager_static_nvc structure is not actually
 * static data, then leave blank and add the parameter to the parameter
 * read function that dynamically reads the data.  The NVC user driver
 * will call the parameter read for the data if the member data is 0.
 * If the dynamic data becomes static during probe (a one time read
 * such as device ID) then add the dynamic read to the _sdata_init
 * function.
 */
static struct nvc_imager_static_nvc ov5693_dflt_sdata = {
	.api_version		= NVC_IMAGER_API_STATIC_VER,
	.sensor_type		= OV5693_SENSOR_TYPE,
	.bits_per_pixel		= 10,
	.sensor_id		= OV5693_ID,
	.sensor_id_minor	= 0,
	.focal_len		= OV5693_LENS_FOCAL_LENGTH,
	.max_aperture		= OV5693_LENS_MAX_APERTURE,
	.fnumber		= OV5693_LENS_FNUMBER,
	.view_angle_h		= OV5693_LENS_VIEW_ANGLE_H,
	.view_angle_v		= OV5693_LENS_VIEW_ANGLE_V,
	.res_chg_wait_time	= OV5693_RES_CHG_WAIT_TIME_MS,
};

static const struct ov5693_reg ov5693_2592x1944_i2c[] = {
	{OV5693_TABLE_RESET, 0},/* Including sw reset */
	{0x3001, 0x0a},
	{0x3002, 0x80},
	{0x3006, 0x00},
	{0x3011, 0x21},
	{0x3012, 0x09},
	{0x3013, 0x10},
	{0x3014, 0x00},
	{0x3015, 0x08},
	{0x3016, 0xf0},
	{0x3017, 0xf0},
	{0x3018, 0xf0},
	{0x301b, 0xb4},
	{0x301d, 0x02},
	{0x3021, 0x00},
	{0x3022, 0x01},
	{0x3028, 0x44},
	{0x3090, 0x02},
	{0x3091, 0x0e},
	{0x3092, 0x00},
	{0x3093, 0x00},
	{0x3098, 0x03},
	{0x3099, 0x1e},
	{0x309a, 0x02},
	{0x309b, 0x01},
	{0x309c, 0x00},
	{0x30a0, 0xd2},
	{0x30a2, 0x01},
	{0x30b2, 0x00},
	{0x30b3, 0x68},
	{0x30b4, 0x03},
	{0x30b5, 0x04},
	{0x30b6, 0x01},
	{0x3104, 0x21},
	{0x3106, 0x00},
	{0x3400, 0x04},
	{0x3401, 0x00},
	{0x3402, 0x04},
	{0x3403, 0x00},
	{0x3404, 0x04},
	{0x3405, 0x00},
	{0x3406, 0x01},
	{0x3500, 0x00},
	{0x3501, 0x7b},
	{0x3502, 0x00},
	{0x3503, 0x07},
	{0x3504, 0x00},
	{0x3505, 0x00},
	{0x3506, 0x00},
	{0x3507, 0x02},
	{0x3508, 0x00},
	{0x3509, 0x08},
	{0x350a, 0x00},
	{0x350b, 0x40},
	{0x3601, 0x0a},
	{0x3602, 0x18},
	{0x3612, 0x80},
	{0x3620, 0x54},
	{0x3621, 0xc7},
	{0x3622, 0x0f},
	{0x3625, 0x10},
	{0x3630, 0x55},
	{0x3631, 0xf4},
	{0x3632, 0x00},
	{0x3633, 0x34},
	{0x3634, 0x02},
	{0x364d, 0x0d},
	{0x364f, 0xdd},
	{0x3660, 0x04},
	{0x3662, 0x10},
	{0x3663, 0xf1},
	{0x3665, 0x00},
	{0x3666, 0x20},
	{0x3667, 0x00},
	{0x366a, 0x80},
	{0x3680, 0xe0},
	{0x3681, 0x00},
	{0x3700, 0x42},
	{0x3701, 0x14},
	{0x3702, 0xa0},
	{0x3703, 0xd8},
	{0x3704, 0x78},
	{0x3705, 0x02},
	{0x3708, 0xe2},
	{0x3709, 0xc3},
	{0x370a, 0x00},
	{0x370b, 0x20},
	{0x370c, 0x0c},
	{0x370d, 0x11},
	{0x370e, 0x00},
	{0x370f, 0x40},
	{0x3710, 0x00},
	{0x371a, 0x1c},
	{0x371b, 0x05},
	{0x371c, 0x01},
	{0x371e, 0xa1},
	{0x371f, 0x0c},
	{0x3721, 0x00},
	{0x3726, 0x00},
	{0x372a, 0x01},
	{0x3730, 0x10},
	{0x3738, 0x22},
	{0x3739, 0xe5},
	{0x373a, 0x50},
	{0x373b, 0x02},
	{0x373c, 0x41},
	{0x373f, 0x02},
	{0x3740, 0x42},
	{0x3741, 0x02},
	{0x3742, 0x18},
	{0x3743, 0x01},
	{0x3744, 0x02},
	{0x3747, 0x10},
	{0x374c, 0x04},
	{0x3751, 0xf0},
	{0x3752, 0x00},
	{0x3753, 0x00},
	{0x3754, 0xc0},
	{0x3755, 0x00},
	{0x3756, 0x1a},
	{0x3758, 0x00},
	{0x3759, 0x0f},
	{0x376b, 0x44},
	{0x375c, 0x04},
	{0x3776, 0x00},
	{0x377f, 0x08},
	{0x3780, 0x22},
	{0x3781, 0x0c},
	{0x3784, 0x2c},
	{0x3785, 0x1e},
	{0x378f, 0xf5},
	{0x3791, 0xb0},
	{0x3795, 0x00},
	{0x3796, 0x64},
	{0x3797, 0x11},
	{0x3798, 0x30},
	{0x3799, 0x41},
	{0x379a, 0x07},
	{0x379b, 0xb0},
	{0x379c, 0x0c},
	{0x37c5, 0x00},
	{0x37c6, 0x00},
	{0x37c7, 0x00},
	{0x37c9, 0x00},
	{0x37ca, 0x00},
	{0x37cb, 0x00},
	{0x37de, 0x00},
	{0x37df, 0x00},
	{0x3800, 0x00},
	{0x3801, 0x00},
	{0x3802, 0x00},
	{0x3803, 0x00},
	{0x3804, 0x0a},
	{0x3805, 0x3f},
	{0x3806, 0x07},
	{0x3807, 0xa3},
	{0x3808, 0x0a},
	{0x3809, 0x20},
	{0x380a, 0x07},
	{0x380b, 0x98},
	{0x380c, 0x0a},
	{0x380d, 0x80},
	{0x380e, 0x07},
	{0x380f, 0xc0},
	{0x3810, 0x00},
	{0x3811, 0x02},
	{0x3812, 0x00},
	{0x3813, 0x02},
	{0x3814, 0x11},
	{0x3815, 0x11},
	{0x3820, 0x00},
	{0x3821, 0x1e},
	{0x3823, 0x00},
	{0x3824, 0x00},
	{0x3825, 0x00},
	{0x3826, 0x00},
	{0x3827, 0x00},
	{0x382a, 0x04},
	{0x3a04, 0x06},
	{0x3a05, 0x14},
	{0x3a06, 0x00},
	{0x3a07, 0xfe},
	{0x3b00, 0x00},
	{0x3b02, 0x00},
	{0x3b03, 0x00},
	{0x3b04, 0x00},
	{0x3b05, 0x00},
	{0x3d00, 0x00},
	{0x3d01, 0x00},
	{0x3d02, 0x00},
	{0x3d03, 0x00},
	{0x3d04, 0x00},
	{0x3d05, 0x00},
	{0x3d06, 0x00},
	{0x3d07, 0x00},
	{0x3d08, 0x00},
	{0x3d09, 0x00},
	{0x3d0a, 0x00},
	{0x3d0b, 0x00},
	{0x3d0c, 0x00},
	{0x3d0d, 0x00},
	{0x3d0e, 0x00},
	{0x3d0f, 0x00},
	{0x3d80, 0x00},
	{0x3d81, 0x00},
	{0x3d84, 0x00},
	{0x3e07, 0x20},
	{0x4000, 0x08},
	{0x4001, 0x04},
	{0x4002, 0x45},
	{0x4004, 0x08},
	{0x4005, 0x18},
	{0x4006, 0x20},
	{0x4008, 0x24},
	{0x4009, 0x10},
	{0x400c, 0x00},
	{0x400d, 0x00},
	{0x4058, 0x00},
	{0x4101, 0xb2},
	{0x4303, 0x00},
	{0x4304, 0x08},
	{0x4307, 0x30},
	{0x4311, 0x04},
	{0x4315, 0x01},
	{0x4511, 0x05},
	{0x4512, 0x01},
	{0x4806, 0x00},
	{0x4816, 0x52},
	{0x481f, 0x30},
	{0x4826, 0x2c},
	{0x4831, 0x64},
	{0x4d00, 0x04},
	{0x4d01, 0x71},
	{0x4d02, 0xfd},
	{0x4d03, 0xf5},
	{0x4d04, 0x0c},
	{0x4d05, 0xcc},
	{0x4837, 0x09},
	{0x5000, 0x06},
	{0x5001, 0x01},
	{0x5002, 0x00},
	{0x5003, 0x20},
	{0x5046, 0x0a},
	{0x5013, 0x00},
	{0x5046, 0x0a},
	{0x5780, 0x1c},
	{0x5786, 0x20},
	{0x5787, 0x10},
	{0x5788, 0x18},
	{0x578a, 0x04},
	{0x578b, 0x02},
	{0x578c, 0x02},
	{0x578e, 0x06},
	{0x578f, 0x02},
	{0x5790, 0x02},
	{0x5791, 0xff},
	{0x5842, 0x01},
	{0x5843, 0x2b},
	{0x5844, 0x01},
	{0x5845, 0x92},
	{0x5846, 0x01},
	{0x5847, 0x8f},
	{0x5848, 0x01},
	{0x5849, 0x0c},
	{0x5e00, 0x00},
	{0x5e10, 0x0c},
	{0x0100, 0x01},

	{OV5693_TABLE_END, 0x0000}
};

static const struct ov5693_reg ov5693_1296x972_i2c[] = {
	{OV5693_TABLE_RESET, 0},/* Including sw reset */
	{0x0103, 0x01},
	{0x3001, 0x0a},
	{0x3002, 0x80},
	{0x3006, 0x00},
	{0x3011, 0x21},
	{0x3012, 0x09},
	{0x3013, 0x10},
	{0x3014, 0x00},
	{0x3015, 0x08},
	{0x3016, 0xf0},
	{0x3017, 0xf0},
	{0x3018, 0xf0},
	{0x301b, 0xb4},
	{0x301d, 0x02},
	{0x3021, 0x00},
	{0x3022, 0x01},
	{0x3028, 0x44},
	{0x3098, 0x03},
	{0x3099, 0x1e},
	{0x309a, 0x02},
	{0x309b, 0x01},
	{0x309c, 0x00},
	{0x30a0, 0xd2},
	{0x30a2, 0x01},
	{0x30b2, 0x00},
	{0x30b3, 0x64},
	{0x30b4, 0x03},
	{0x30b5, 0x04},
	{0x30b6, 0x01},
	{0x3104, 0x21},
	{0x3106, 0x00},
	{0x3400, 0x04},
	{0x3401, 0x00},
	{0x3402, 0x04},
	{0x3403, 0x00},
	{0x3404, 0x04},
	{0x3405, 0x00},
	{0x3406, 0x01},
	{0x3500, 0x00},
	{0x3501, 0x7b},
	{0x3502, 0x00},
	{0x3503, 0x07},
	{0x3504, 0x00},
	{0x3505, 0x00},
	{0x3506, 0x00},
	{0x3507, 0x02},
	{0x3508, 0x00},
	{0x3509, 0x08},
	{0x350a, 0x00},
	{0x350b, 0x40},
	{0x3601, 0x0a},
	{0x3602, 0x38},
	{0x3612, 0x80},
	{0x3620, 0x54},
	{0x3621, 0xc7},
	{0x3622, 0x0f},
	{0x3625, 0x10},
	{0x3630, 0x55},
	{0x3631, 0xf4},
	{0x3632, 0x00},
	{0x3633, 0x34},
	{0x3634, 0x02},
	{0x364d, 0x0d},
	{0x364f, 0xdd},
	{0x3660, 0x04},
	{0x3662, 0x10},
	{0x3663, 0xf1},
	{0x3665, 0x00},
	{0x3666, 0x20},
	{0x3667, 0x00},
	{0x366a, 0x80},
	{0x3680, 0xe0},
	{0x3681, 0x00},
	{0x3700, 0x42},
	{0x3701, 0x14},
	{0x3702, 0xa0},
	{0x3703, 0xd8},
	{0x3704, 0x78},
	{0x3705, 0x02},
	{0x3708, 0xe6},
	{0x3709, 0xc3},
	{0x370a, 0x00},
	{0x370b, 0x20},
	{0x370c, 0x0c},
	{0x370d, 0x11},
	{0x370e, 0x00},
	{0x370f, 0x40},
	{0x3710, 0x00},
	{0x371a, 0x1c},
	{0x371b, 0x05},
	{0x371c, 0x01},
	{0x371e, 0xa1},
	{0x371f, 0x0c},
	{0x3721, 0x00},
	{0x3724, 0x10},
	{0x3726, 0x00},
	{0x372a, 0x01},
	{0x3730, 0x10},
	{0x3738, 0x22},
	{0x3739, 0xe5},
	{0x373a, 0x50},
	{0x373b, 0x02},
	{0x373c, 0x41},
	{0x373f, 0x02},
	{0x3740, 0x42},
	{0x3741, 0x02},
	{0x3742, 0x18},
	{0x3743, 0x01},
	{0x3744, 0x02},
	{0x3747, 0x10},
	{0x374c, 0x04},
	{0x3751, 0xf0},
	{0x3752, 0x00},
	{0x3753, 0x00},
	{0x3754, 0xc0},
	{0x3755, 0x00},
	{0x3756, 0x1a},
	{0x3758, 0x00},
	{0x3759, 0x0f},
	{0x376b, 0x44},
	{0x375c, 0x04},
	{0x3774, 0x10},
	{0x3776, 0x00},
	{0x377f, 0x08},
	{0x3780, 0x22},
	{0x3781, 0x0c},
	{0x3784, 0x2c},
	{0x3785, 0x1e},
	{0x378f, 0xf5},
	{0x3791, 0xb0},
	{0x3795, 0x00},
	{0x3796, 0x64},
	{0x3797, 0x11},
	{0x3798, 0x30},
	{0x3799, 0x41},
	{0x379a, 0x07},
	{0x379b, 0xb0},
	{0x379c, 0x0c},
	{0x37c5, 0x00},
	{0x37c6, 0x00},
	{0x37c7, 0x00},
	{0x37c9, 0x00},
	{0x37ca, 0x00},
	{0x37cb, 0x00},
	{0x37de, 0x00},
	{0x37df, 0x00},
	{0x3800, 0x00},
	{0x3801, 0x00},
	{0x3802, 0x00},
	{0x3803, 0x00},
	{0x3804, 0x0a},
	{0x3805, 0x3f},
	{0x3806, 0x07},
	{0x3807, 0xa3},
	{0x3808, 0x05},
	{0x3809, 0x10},
	{0x380a, 0x03},
	{0x380b, 0xcc},
	{0x380c, 0x0a},
	{0x380d, 0x80},
	{0x380e, 0x07},
	{0x380f, 0xc0},
	{0x3810, 0x00},
	{0x3811, 0x02},
	{0x3812, 0x00},
	{0x3813, 0x02},
	{0x3814, 0x31},
	{0x3815, 0x31},
	{0x3820, 0x01},
	{0x3821, 0x1f},
	{0x3823, 0x00},
	{0x3824, 0x00},
	{0x3825, 0x00},
	{0x3826, 0x00},
	{0x3827, 0x00},
	{0x382a, 0x04},
	{0x3a04, 0x06},
	{0x3a05, 0x14},
	{0x3a06, 0x00},
	{0x3a07, 0xfe},
	{0x3b00, 0x00},
	{0x3b02, 0x00},
	{0x3b03, 0x00},
	{0x3b04, 0x00},
	{0x3b05, 0x00},
	{0x3e07, 0x20},
	{0x4000, 0x08},
	{0x4001, 0x04},
	{0x4002, 0x45},
	{0x4004, 0x08},
	{0x4005, 0x18},
	{0x4006, 0x20},
	{0x4008, 0x24},
	{0x4009, 0x40},
	{0x400c, 0x00},
	{0x400d, 0x00},
	{0x4058, 0x00},
	{0x404e, 0x37},
	{0x404f, 0x8f},
	{0x4058, 0x00},
	{0x4101, 0xb2},
	{0x4303, 0x00},
	{0x4304, 0x08},
	{0x4307, 0x30},
	{0x4311, 0x04},
	{0x4315, 0x01},
	{0x4511, 0x05},
	{0x4512, 0x01},
	{0x4806, 0x00},
	{0x4816, 0x52},
	{0x481f, 0x30},
	{0x4826, 0x2c},
	{0x4831, 0x64},
	{0x4d00, 0x04},
	{0x4d01, 0x71},
	{0x4d02, 0xfd},
	{0x4d03, 0xf5},
	{0x4d04, 0x0c},
	{0x4d05, 0xcc},
	{0x4837, 0x0a},
	{0x5000, 0x06},
	{0x5001, 0x01},
	{0x5002, 0x00},
	{0x5003, 0x20},
	{0x5046, 0x0a},
	{0x5013, 0x00},
	{0x5046, 0x0a},
	{0x5780, 0x1c},
	{0x5786, 0x20},
	{0x5787, 0x10},
	{0x5788, 0x18},
	{0x578a, 0x04},
	{0x578b, 0x02},
	{0x578c, 0x02},
	{0x578e, 0x06},
	{0x578f, 0x02},
	{0x5790, 0x02},
	{0x5791, 0xff},
	{0x5842, 0x01},
	{0x5843, 0x2b},
	{0x5844, 0x01},
	{0x5845, 0x92},
	{0x5846, 0x01},
	{0x5847, 0x8f},
	{0x5848, 0x01},
	{0x5849, 0x0c},
	{0x5e00, 0x00},
	{0x5e10, 0x0c},
	{0x0100, 0x01},
	{OV5693_TABLE_END, 0x0000}
};

static const struct ov5693_reg ov5693_1920x1080_i2c[] = {
	{OV5693_TABLE_RESET, 0x0},/*, 0xIncluding, 0xsw, 0xreset, 0x*/
	{0x3001, 0x0a},
	{0x3002, 0x80},
	{0x3006, 0x00},
	{0x3011, 0x21},
	{0x3012, 0x09},
	{0x3013, 0x10},
	{0x3014, 0x00},
	{0x3015, 0x08},
	{0x3016, 0xf0},
	{0x3017, 0xf0},
	{0x3018, 0xf0},
	{0x301b, 0xb4},
	{0x301d, 0x02},
	{0x3021, 0x00},
	{0x3022, 0x01},
	{0x3028, 0x44},
	{0x3098, 0x03},
	{0x3099, 0x1e},
	{0x309a, 0x02},
	{0x309b, 0x01},
	{0x309c, 0x00},
	{0x30a0, 0xd2},
	{0x30a2, 0x01},
	{0x30b2, 0x00},
	{0x30b3, 0x64},
	{0x30b4, 0x03},
	{0x30b5, 0x04},
	{0x30b6, 0x01},
	{0x3104, 0x21},
	{0x3106, 0x00},
	{0x3400, 0x04},
	{0x3401, 0x00},
	{0x3402, 0x04},
	{0x3403, 0x00},
	{0x3404, 0x04},
	{0x3405, 0x00},
	{0x3406, 0x01},
	{0x3500, 0x00},
	{0x3501, 0x7b},
	{0x3502, 0x00},
	{0x3503, 0x07},
	{0x3504, 0x00},
	{0x3505, 0x00},
	{0x3506, 0x00},
	{0x3507, 0x02},
	{0x3508, 0x00},
	{0x3509, 0x08},
	{0x350a, 0x00},
	{0x350b, 0x40},
	{0x3601, 0x0a},
	{0x3602, 0x38},
	{0x3612, 0x80},
	{0x3620, 0x54},
	{0x3621, 0xc7},
	{0x3622, 0x0f},
	{0x3625, 0x10},
	{0x3630, 0x55},
	{0x3631, 0xf4},
	{0x3632, 0x00},
	{0x3633, 0x34},
	{0x3634, 0x02},
	{0x364d, 0x0d},
	{0x364f, 0xdd},
	{0x3660, 0x04},
	{0x3662, 0x10},
	{0x3663, 0xf1},
	{0x3665, 0x00},
	{0x3666, 0x20},
	{0x3667, 0x00},
	{0x366a, 0x80},
	{0x3680, 0xe0},
	{0x3681, 0x00},
	{0x3700, 0x42},
	{0x3701, 0x14},
	{0x3702, 0xa0},
	{0x3703, 0xd8},
	{0x3704, 0x78},
	{0x3705, 0x02},
	{0x3708, 0xe2},
	{0x3709, 0xc3},
	{0x370a, 0x00},
	{0x370b, 0x20},
	{0x370c, 0x0c},
	{0x370d, 0x11},
	{0x370e, 0x00},
	{0x370f, 0x40},
	{0x3710, 0x00},
	{0x371a, 0x1c},
	{0x371b, 0x05},
	{0x371c, 0x01},
	{0x371e, 0xa1},
	{0x371f, 0x0c},
	{0x3721, 0x00},
	{0x3724, 0x10},
	{0x3726, 0x00},
	{0x372a, 0x01},
	{0x3730, 0x10},
	{0x3738, 0x22},
	{0x3739, 0xe5},
	{0x373a, 0x50},
	{0x373b, 0x02},
	{0x373c, 0x41},
	{0x373f, 0x02},
	{0x3740, 0x42},
	{0x3741, 0x02},
	{0x3742, 0x18},
	{0x3743, 0x01},
	{0x3744, 0x02},
	{0x3747, 0x10},
	{0x374c, 0x04},
	{0x3751, 0xf0},
	{0x3752, 0x00},
	{0x3753, 0x00},
	{0x3754, 0xc0},
	{0x3755, 0x00},
	{0x3756, 0x1a},
	{0x3758, 0x00},
	{0x3759, 0x0f},
	{0x376b, 0x44},
	{0x375c, 0x04},
	{0x3774, 0x10},
	{0x3776, 0x00},
	{0x377f, 0x08},
	{0x3780, 0x22},
	{0x3781, 0x0c},
	{0x3784, 0x2c},
	{0x3785, 0x1e},
	{0x378f, 0xf5},
	{0x3791, 0xb0},
	{0x3795, 0x00},
	{0x3796, 0x64},
	{0x3797, 0x11},
	{0x3798, 0x30},
	{0x3799, 0x41},
	{0x379a, 0x07},
	{0x379b, 0xb0},
	{0x379c, 0x0c},
	{0x37c5, 0x00},
	{0x37c6, 0x00},
	{0x37c7, 0x00},
	{0x37c9, 0x00},
	{0x37ca, 0x00},
	{0x37cb, 0x00},
	{0x37de, 0x00},
	{0x37df, 0x00},
	{0x3800, 0x00},
	{0x3801, 0x00},
	{0x3802, 0x00},
	{0x3803, 0xf8},
	{0x3804, 0x0a},
	{0x3805, 0x3f},
	{0x3806, 0x06},
	{0x3807, 0xab},
	{0x3808, 0x07},
	{0x3809, 0x80},
	{0x380a, 0x04},
	{0x380b, 0x38},
	{0x380c, 0x0a},
	{0x380d, 0x80},
	{0x380e, 0x07},
	{0x380f, 0xc0},
	{0x3810, 0x00},
	{0x3811, 0x02},
	{0x3812, 0x00},
	{0x3813, 0x02},
	{0x3814, 0x11},
	{0x3815, 0x11},
	{0x3820, 0x00},
	{0x3821, 0x1e},
	{0x3823, 0x00},
	{0x3824, 0x00},
	{0x3825, 0x00},
	{0x3826, 0x00},
	{0x3827, 0x00},
	{0x382a, 0x04},
	{0x3a04, 0x06},
	{0x3a05, 0x14},
	{0x3a06, 0x00},
	{0x3a07, 0xfe},
	{0x3b00, 0x00},
	{0x3b02, 0x00},
	{0x3b03, 0x00},
	{0x3b04, 0x00},
	{0x3b05, 0x00},
	{0x3e07, 0x20},
	{0x4000, 0x08},
	{0x4001, 0x04},
	{0x4002, 0x45},
	{0x4004, 0x08},
	{0x4005, 0x18},
	{0x4006, 0x20},
	{0x4008, 0x24},
	{0x4009, 0x40},
	{0x400c, 0x00},
	{0x400d, 0x00},
	{0x4058, 0x00},
	{0x404e, 0x37},
	{0x404f, 0x8f},
	{0x4058, 0x00},
	{0x4101, 0xb2},
	{0x4303, 0x00},
	{0x4304, 0x08},
	{0x4307, 0x30},
	{0x4311, 0x04},
	{0x4315, 0x01},
	{0x4511, 0x05},
	{0x4512, 0x01},
	{0x4806, 0x00},
	{0x4816, 0x52},
	{0x481f, 0x30},
	{0x4826, 0x2c},
	{0x4831, 0x64},
	{0x4d00, 0x04},
	{0x4d01, 0x71},
	{0x4d02, 0xfd},
	{0x4d03, 0xf5},
	{0x4d04, 0x0c},
	{0x4d05, 0xcc},
	{0x4837, 0x0a},
	{0x5000, 0x06},
	{0x5001, 0x01},
	{0x5002, 0x80},
	{0x5003, 0x20},
	{0x5046, 0x0a},
	{0x5013, 0x00},
	{0x5046, 0x0a},
	{0x5780, 0x1c},
	{0x5786, 0x20},
	{0x5787, 0x10},
	{0x5788, 0x18},
	{0x578a, 0x04},
	{0x578b, 0x02},
	{0x578c, 0x02},
	{0x578e, 0x06},
	{0x578f, 0x02},
	{0x5790, 0x02},
	{0x5791, 0xff},
	{0x5842, 0x01},
	{0x5843, 0x2b},
	{0x5844, 0x01},
	{0x5845, 0x92},
	{0x5846, 0x01},
	{0x5847, 0x8f},
	{0x5848, 0x01},
	{0x5849, 0x0c},
	{0x5e00, 0x00},
	{0x5e10, 0x0c},
	{0x0100, 0x01},
	{OV5693_TABLE_END, 0x0000}
};


static const struct ov5693_reg ov5693_1280x720_120fps_i2c[] = {
	{OV5693_TABLE_RESET, 0},/* Including sw reset */
	{0x3001, 0x0a},
	{0x3002, 0x80},
	{0x3006, 0x00},
	{0x3011, 0x21},
	{0x3012, 0x09},
	{0x3013, 0x10},
	{0x3014, 0x00},
	{0x3015, 0x08},
	{0x3016, 0xf0},
	{0x3017, 0xf0},
	{0x3018, 0xf0},
	{0x301b, 0xb4},
	{0x301d, 0x02},
	{0x3021, 0x00},
	{0x3022, 0x01},
	{0x3028, 0x44},
	{0x3098, 0x03},
	{0x3099, 0x1e},
	{0x309a, 0x02},
	{0x309b, 0x01},
	{0x309c, 0x00},
	{0x30a0, 0xd2},
	{0x30a2, 0x01},
	{0x30b2, 0x00},
	{0x30b3, 0x64},
	{0x30b4, 0x03},
	{0x30b5, 0x04},
	{0x30b6, 0x01},
	{0x3104, 0x21},
	{0x3106, 0x00},
	{0x3400, 0x04},
	{0x3401, 0x00},
	{0x3402, 0x04},
	{0x3403, 0x00},
	{0x3404, 0x04},
	{0x3405, 0x00},
	{0x3406, 0x01},
	{0x3500, 0x00},
	{0x3501, 0x2e},
	{0x3502, 0x80},
	{0x3503, 0x07},
	{0x3504, 0x00},
	{0x3505, 0x00},
	{0x3506, 0x00},
	{0x3507, 0x02},
	{0x3508, 0x00},
	{0x3509, 0x08},
	{0x350a, 0x00},
	{0x350b, 0x40},
	{0x3601, 0x0a},
	{0x3602, 0x38},
	{0x3612, 0x80},
	{0x3620, 0x54},
	{0x3621, 0xc7},
	{0x3622, 0x0f},
	{0x3625, 0x10},
	{0x3630, 0x55},
	{0x3631, 0xf4},
	{0x3632, 0x00},
	{0x3633, 0x34},
	{0x3634, 0x02},
	{0x364d, 0x0d},
	{0x364f, 0xdd},
	{0x3660, 0x04},
	{0x3662, 0x10},
	{0x3663, 0xf1},
	{0x3665, 0x00},
	{0x3666, 0x20},
	{0x3667, 0x00},
	{0x366a, 0x80},
	{0x3680, 0xe0},
	{0x3681, 0x00},
	{0x3700, 0x42},
	{0x3701, 0x14},
	{0x3702, 0xa0},
	{0x3703, 0xd8},
	{0x3704, 0x78},
	{0x3705, 0x02},
	{0x3708, 0xe6},
	{0x3709, 0xc7},
	{0x370a, 0x00},
	{0x370b, 0x20},
	{0x370c, 0x0c},
	{0x370d, 0x11},
	{0x370e, 0x00},
	{0x370f, 0x40},
	{0x3710, 0x00},
	{0x371a, 0x1c},
	{0x371b, 0x05},
	{0x371c, 0x01},
	{0x371e, 0xa1},
	{0x371f, 0x0c},
	{0x3721, 0x00},
	{0x3724, 0x10},
	{0x3726, 0x00},
	{0x372a, 0x01},
	{0x3730, 0x10},
	{0x3738, 0x22},
	{0x3739, 0xe5},
	{0x373a, 0x50},
	{0x373b, 0x02},
	{0x373c, 0x41},
	{0x373f, 0x02},
	{0x3740, 0x42},
	{0x3741, 0x02},
	{0x3742, 0x18},
	{0x3743, 0x01},
	{0x3744, 0x02},
	{0x3747, 0x10},
	{0x374c, 0x04},
	{0x3751, 0xf0},
	{0x3752, 0x00},
	{0x3753, 0x00},
	{0x3754, 0xc0},
	{0x3755, 0x00},
	{0x3756, 0x1a},
	{0x3758, 0x00},
	{0x3759, 0x0f},
	{0x376b, 0x44},
	{0x375c, 0x04},
	{0x3774, 0x10},
	{0x3776, 0x00},
	{0x377f, 0x08},
	{0x3780, 0x22},
	{0x3781, 0x0c},
	{0x3784, 0x2c},
	{0x3785, 0x1e},
	{0x378f, 0xf5},
	{0x3791, 0xb0},
	{0x3795, 0x00},
	{0x3796, 0x64},
	{0x3797, 0x11},
	{0x3798, 0x30},
	{0x3799, 0x41},
	{0x379a, 0x07},
	{0x379b, 0xb0},
	{0x379c, 0x0c},
	{0x37c5, 0x00},
	{0x37c6, 0x00},
	{0x37c7, 0x00},
	{0x37c9, 0x00},
	{0x37ca, 0x00},
	{0x37cb, 0x00},
	{0x37de, 0x00},
	{0x37df, 0x00},
	{0x3800, 0x00},
	{0x3801, 0x00},
	{0x3802, 0x00},
	{0x3803, 0xf4},
	{0x3804, 0x0a},
	{0x3805, 0x3f},
	{0x3806, 0x06},
	{0x3807, 0xab},
	{0x3808, 0x05},
	{0x3809, 0x00},
	{0x380a, 0x02},
	{0x380b, 0xd0},
	{0x380c, 0x06},
	{0x380d, 0xd8},
	{0x380e, 0x02},
	{0x380f, 0xf8},
	{0x3810, 0x00},
	{0x3811, 0x02},
	{0x3812, 0x00},
	{0x3813, 0x02},
	{0x3814, 0x31},
	{0x3815, 0x31},
	{0x3820, 0x04},
	{0x3821, 0x1f},
	{0x3823, 0x00},
	{0x3824, 0x00},
	{0x3825, 0x00},
	{0x3826, 0x00},
	{0x3827, 0x00},
	{0x382a, 0x04},
	{0x3a04, 0x06},
	{0x3a05, 0x14},
	{0x3a06, 0x00},
	{0x3a07, 0xfe},
	{0x3b00, 0x00},
	{0x3b02, 0x00},
	{0x3b03, 0x00},
	{0x3b04, 0x00},
	{0x3b05, 0x00},
	{0x3e07, 0x20},
	{0x4000, 0x08},
	{0x4001, 0x04},
	{0x4002, 0x45},
	{0x4004, 0x08},
	{0x4005, 0x18},
	{0x4006, 0x20},
	{0x4008, 0x24},
	{0x4009, 0x40},
	{0x400c, 0x00},
	{0x400d, 0x00},
	{0x4058, 0x00},
	{0x404e, 0x37},
	{0x404f, 0x8f},
	{0x4058, 0x00},
	{0x4101, 0xb2},
	{0x4303, 0x00},
	{0x4304, 0x08},
	{0x4307, 0x30},
	{0x4311, 0x04},
	{0x4315, 0x01},
	{0x4511, 0x05},
	{0x4512, 0x01},
	{0x4806, 0x00},
	{0x4816, 0x52},
	{0x481f, 0x30},
	{0x4826, 0x2c},
	{0x4831, 0x64},
	{0x4d00, 0x04},
	{0x4d01, 0x71},
	{0x4d02, 0xfd},
	{0x4d03, 0xf5},
	{0x4d04, 0x0c},
	{0x4d05, 0xcc},
	{0x4837, 0x0a},
	{0x5000, 0x06},
	{0x5001, 0x01},
	{0x5002, 0x00},
	{0x5003, 0x20},
	{0x5046, 0x0a},
	{0x5013, 0x00},
	{0x5046, 0x0a},
	{0x5780, 0x1c},
	{0x5786, 0x20},
	{0x5787, 0x10},
	{0x5788, 0x18},
	{0x578a, 0x04},
	{0x578b, 0x02},
	{0x578c, 0x02},
	{0x578e, 0x06},
	{0x578f, 0x02},
	{0x5790, 0x02},
	{0x5791, 0xff},
	{0x5842, 0x01},
	{0x5843, 0x2b},
	{0x5844, 0x01},
	{0x5845, 0x92},
	{0x5846, 0x01},
	{0x5847, 0x8f},
	{0x5848, 0x01},
	{0x5849, 0x0c},
	{0x5e00, 0x00},
	{0x5e10, 0x0c},
	{0x0100, 0x01},
	{0x350b, 0xF8},
	{OV5693_TABLE_END, 0x0000}
};

enum {
	OV5693_MODE_2592x1944 = 0,
	OV5693_MODE_1920x1080,
	OV5693_MODE_1296x972,
	OV5693_MODE_1280x720_120FPS,
};

static const struct ov5693_reg *mode_table[] = {
	[OV5693_MODE_2592x1944]		= ov5693_2592x1944_i2c,
	[OV5693_MODE_1920x1080]		= ov5693_1920x1080_i2c,
	[OV5693_MODE_1296x972]		= ov5693_1296x972_i2c,
	[OV5693_MODE_1280x720_120FPS]	= ov5693_1280x720_120fps_i2c,
};

static int ov5693_i2c_rd8(struct ov5693_info *info, u16 reg, u8 *val)
{
	unsigned int data;
	int ret = regmap_read(info->regmap, reg, &data);
	*val = data;

	return ret;
}

static int ov5693_i2c_wr_table(struct ov5693_info *info,
				const struct ov5693_reg table[])
{
	int err;
	int buf_count = 0;
	const struct ov5693_reg *next, *n_next;
	u16 i2c_reg = 0;
	u8 i2c_buf[OV5693_SIZEOF_I2C_BUF];

	u8 *b_ptr = i2c_buf;
	u8 reset_status = 1;
	u8 reset_tries_left = OV5693_TABLE_RESET_TIMEOUT;

	for (next = table; next->addr != OV5693_TABLE_END; next++) {
		if (next->addr == OV5693_TABLE_WAIT_MS) {
			msleep(next->val);
			continue;
		} else if (next->addr == OV5693_TABLE_RESET) {
			err = regmap_write(info->regmap, 0x0103, 0x01);
			if (err)
				return err;
			while (reset_status) {
				usleep_range(200, 300);
				if (reset_tries_left < 1)
					return -EIO;
				err = ov5693_i2c_rd8(info, 0x0103,
							&reset_status);
				if (err)
					return err;
				reset_status &= 0x01;
				reset_tries_left -= 1;
			}
			continue;
		}

		if (buf_count == 0) {
			b_ptr = i2c_buf;
			i2c_reg = next->addr;
		}

		*b_ptr++ = next->val;
		buf_count++;
		n_next = next + 1;
		if (n_next->addr == next->addr + 1 &&
			n_next->addr != OV5693_TABLE_WAIT_MS &&
			buf_count < OV5693_SIZEOF_I2C_BUF &&
			n_next->addr != OV5693_TABLE_RESET &&
			n_next->addr != OV5693_TABLE_END)
			continue;

		err = regmap_bulk_write(info->regmap, i2c_reg,
					i2c_buf, buf_count);
		if (err)
			return err;

		buf_count = 0;
	}

	return 0;
}


static inline int ov5693_frame_length_reg(struct ov5693_reg *regs,
					u32 frame_length)
{
	regs->addr = 0x380E;
	regs->val = (frame_length >> 8) & 0xff;
	(regs + 1)->addr = 0x380F;
	(regs + 1)->val = (frame_length) & 0xff;

	return 2;
}

static inline int ov5693_coarse_time_reg(struct ov5693_reg *regs,
					u32 coarse_time)
{
	regs->addr = 0x3500;
	regs->val = (coarse_time >> 12) & 0xff;
	(regs + 1)->addr = 0x3501;
	(regs + 1)->val = (coarse_time >> 4) & 0xff;
	(regs + 2)->addr = 0x3502;
	(regs + 2)->val = (coarse_time & 0xf) << 4;

	return 3;
}

#define OV5693_ENTER_GROUP_HOLD(group_hold) \
	do {	\
		if (group_hold) {   \
			reg_list[offset].addr = 0x3208; \
			reg_list[offset].val = 0x01;\
			offset++;  \
		}   \
	} while (0)

#define OV5693_LEAVE_GROUP_HOLD(group_hold) \
	do {	\
		if (group_hold) {   \
			reg_list[offset].addr = 0x3208; \
			reg_list[offset].val = 0x11;\
			offset++;  \
			reg_list[offset].addr = 0x3208; \
			reg_list[offset].val = 0xe1;\
			offset++;  \
		} \
	} while (0)

static int ov5693_set_frame_length(struct ov5693_info *info,
				   u32 frame_length, bool group_hold)
{
	struct ov5693_reg reg_list[9];
	int err = 0;
	int offset = 0;

	OV5693_ENTER_GROUP_HOLD(group_hold);
	offset += ov5693_frame_length_reg(reg_list + offset, frame_length);
	OV5693_LEAVE_GROUP_HOLD(group_hold);

	reg_list[offset].addr = OV5693_TABLE_END;
	offset++;

	err = ov5693_i2c_wr_table(info, reg_list);

	return err;
}

static int ov5693_set_coarse_time(struct ov5693_info *info,
				  u32 coarse_time, bool group_hold)
{
	struct ov5693_reg reg_list[16];
	int err = 0;
	int offset = 0;

	OV5693_ENTER_GROUP_HOLD(group_hold);
	offset += ov5693_coarse_time_reg(reg_list + offset, coarse_time);
	OV5693_LEAVE_GROUP_HOLD(group_hold);

	reg_list[offset].addr = OV5693_TABLE_END;
	offset++;

	err = ov5693_i2c_wr_table(info, reg_list);

	return err;
}

static inline int ov5693_gain_reg(struct ov5693_reg *regs, u32 gain)
{
	(regs)->addr = 0x350B;
	(regs)->val = gain;

	return 1;
}

static int ov5693_bin_wr(struct ov5693_info *info, u8 enable)
{
	int err = 0;

	if (enable == info->bin_en)
		return 0;

	if (!err)
		info->bin_en = enable;
	dev_dbg(&info->i2c_client->dev, "%s bin_en=%x err=%d\n",
		__func__, info->bin_en, err);
	return err;
}

static int ov5693_exposure_wr(struct ov5693_info *info,
				struct ov5693_mode *mode)
{
	struct ov5693_reg reg_list[16];
	int err = 0;
	int offset = 0;
	bool group_hold = true; /* To use GROUP_HOLD macros */

	OV5693_ENTER_GROUP_HOLD(group_hold);
	offset += ov5693_coarse_time_reg(reg_list + offset, mode->coarse_time);
	offset += ov5693_gain_reg(reg_list + offset, mode->gain);
	OV5693_LEAVE_GROUP_HOLD(group_hold);

	reg_list[offset].addr = OV5693_TABLE_END;
	err = ov5693_i2c_wr_table(info, reg_list);

	return err;
}


static int ov5693_set_gain(struct ov5693_info *info, u32 gain, bool group_hold)
{
	struct ov5693_reg reg_list[9];
	int err = 0;
	int offset = 0;

	OV5693_ENTER_GROUP_HOLD(group_hold);
	offset += ov5693_gain_reg(reg_list + offset, gain);
	OV5693_LEAVE_GROUP_HOLD(group_hold);

	reg_list[offset].addr = OV5693_TABLE_END;
	offset++;

	err = ov5693_i2c_wr_table(info, reg_list);

	return err;
}

static int ov5693_set_group_hold(struct ov5693_info *info,
				struct ov5693_ae *ae)
{
	int err = 0;
	struct ov5693_reg reg_list[16];
	int offset = 0;
	bool group_hold = true; /* To use GROUP_HOLD macros */

	OV5693_ENTER_GROUP_HOLD(group_hold);
	if (ae->gain_enable)
		offset += ov5693_gain_reg(reg_list + offset,
					  ae->gain);
	if (ae->frame_length_enable)
		offset += ov5693_frame_length_reg(reg_list + offset,
						  ae->frame_length);
	if (ae->coarse_time_enable)
		offset += ov5693_coarse_time_reg(reg_list + offset,
						 ae->coarse_time);
	OV5693_LEAVE_GROUP_HOLD(group_hold);

	reg_list[offset].addr = OV5693_TABLE_END;
	err |= ov5693_i2c_wr_table(info, reg_list);

	return err;
}

static int ov5693_gpio_rd(struct ov5693_info *info,
			enum ov5693_gpio_type type)
{
	int val = -EINVAL;

	if (info->gpio[type].gpio) {
		val = gpio_get_value_cansleep(info->gpio[type].gpio);
		dev_dbg(&info->i2c_client->dev, "%s %u %d\n", __func__,
		       info->gpio[type].gpio, val);
		if (!info->gpio[type].active_high)
			val = !val;
		val &= 1;
	}
	return val; /* return read value or error */
}

static int ov5693_gpio_wr(struct ov5693_info *info,
			enum ov5693_gpio_type type,
			int val) /* val: 0=deassert, 1=assert */
{
	int err = -EINVAL;

	if (info->gpio[type].gpio) {
		if (!info->gpio[type].active_high)
			val = !val;
		val &= 1;
		err = val;
		gpio_set_value_cansleep(info->gpio[type].gpio, val);
		dev_dbg(&info->i2c_client->dev, "%s %u %d\n", __func__,
		       info->gpio[type].gpio, val);
	}
	return err; /* return value written or error */
}

static void ov5693_gpio_pwrdn(struct ov5693_info *info, int val)
{
	int prev_val;

	prev_val = ov5693_gpio_rd(info, OV5693_GPIO_TYPE_PWRDN);
	if ((prev_val < 0) || (val == prev_val))
		return;

	ov5693_gpio_wr(info, OV5693_GPIO_TYPE_PWRDN, val);
	if (!val && prev_val)
		/* if transition from assert to deassert then delay for I2C */
		msleep(50);
}

static void ov5693_gpio_exit(struct ov5693_info *info)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(ov5693_gpio); i++) {
		if (info->gpio[i].gpio && info->gpio[i].own)
			gpio_free(info->gpio[i].gpio);
	}
}

static void ov5693_gpio_init(struct ov5693_info *info)
{
	char label[32];
	unsigned long flags;
	unsigned type;
	unsigned i;
	unsigned j;
	int err;

	if (!info->pdata->gpio_count || !info->pdata->gpio)
		return;

	for (i = 0; i < ARRAY_SIZE(ov5693_gpio); i++) {
		type = ov5693_gpio[i].gpio_type;
		for (j = 0; j < info->pdata->gpio_count; j++) {
			if (type == info->pdata->gpio[j].gpio_type)
				break;
		}
		if (j == info->pdata->gpio_count)
			continue;

		info->gpio[type].gpio = info->pdata->gpio[j].gpio;
		if (ov5693_gpio[i].use_flags) {
			flags = ov5693_gpio[i].flags;
			info->gpio[type].active_high =
						ov5693_gpio[i].active_high;
		} else {
			info->gpio[type].active_high =
					info->pdata->gpio[j].active_high;
			if (info->gpio[type].active_high)
				flags = GPIOF_OUT_INIT_LOW;
			else
				flags = GPIOF_OUT_INIT_HIGH;
		}
		if (!info->pdata->gpio[j].init_en)
			continue;

		snprintf(label, sizeof(label), "ov5693_%u_%s",
			 info->pdata->num, ov5693_gpio[i].label);
		err = gpio_request_one(info->gpio[type].gpio, flags, label);
		if (err) {
			dev_err(&info->i2c_client->dev,
				"%s ERR %s %u\n", __func__, label,
				info->gpio[type].gpio);
		} else {
			info->gpio[type].own = true;
			dev_dbg(&info->i2c_client->dev,
				"%s %s %u\n", __func__, label,
				info->gpio[type].gpio);
		}
	}
}

static void ov5693_mclk_disable(struct ov5693_info *info)
{
	dev_dbg(&info->i2c_client->dev, "%s: disable MCLK\n", __func__);
	clk_disable_unprepare(info->mclk);
}

static int ov5693_mclk_enable(struct ov5693_info *info)
{
	int err;
	unsigned long mclk_init_rate = 24000000;

	dev_dbg(&info->i2c_client->dev, "%s: enable MCLK with %lu Hz\n",
		__func__, mclk_init_rate);

	err = clk_set_rate(info->mclk, mclk_init_rate);
	if (!err)
		err = clk_prepare_enable(info->mclk);

	return err;
}

static int ov5693_power_off(struct ov5693_info *info)
{
	struct ov5693_power_rail *pw = &info->regulators;
	int err;

	if (false == info->power_on)
		return 0;

	if (info->pdata && info->pdata->power_off) {
		err = info->pdata->power_off(pw);
		if (0 > err)
			return err;
		info->power_on = false;
		ov5693_gpio_pwrdn(info, 1);
		ov5693_mclk_disable(info);
	} else {
		dev_err(&info->i2c_client->dev,
			"%s ERR: has no power_off function\n", __func__);
		err = -EINVAL;
	}
	return err;
}

static int ov5693_power_on(struct ov5693_info *info, bool standby)
{
	struct ov5693_power_rail *pw = &info->regulators;
	int err;

	if (true == info->power_on)
		return 0;

	err = ov5693_mclk_enable(info);
	if (err)
		return err;

	if (info->pdata && info->pdata->power_on) {
		err = info->pdata->power_on(pw);
		if (err >= 0) {
			info->power_on = true;
			ov5693_gpio_pwrdn(info, standby ? 1 : 0);
			msleep(100);
		}
	} else {
		dev_err(&info->i2c_client->dev,
			"%s ERR: has no power_on function\n", __func__);
		err = -EINVAL;
	}

	if (err < 0)
		ov5693_mclk_disable(info);

	return err;
}

static int ov5693_pm_wr(struct ov5693_info *info, int pwr)
{
	int err = 0;

	if ((info->pdata->cfg & (NVC_CFG_OFF2STDBY | NVC_CFG_BOOT_INIT)) &&
			(pwr == NVC_PWR_OFF ||
			 pwr == NVC_PWR_STDBY_OFF))
		pwr = NVC_PWR_STDBY;
	if (pwr == info->pwr_dev)
		return 0;

	switch (pwr) {
	case NVC_PWR_OFF_FORCE:
	case NVC_PWR_OFF:
	case NVC_PWR_STDBY_OFF:
		err = ov5693_power_off(info);
		info->mode_valid = false;
		info->bin_en = 0;
		break;

	case NVC_PWR_STDBY:
		err = ov5693_power_on(info, true);
		break;

	case NVC_PWR_COMM:
	case NVC_PWR_ON:
		err = ov5693_power_on(info, false);
		break;

	default:
		err = -EINVAL;
		break;
	}

	if (err < 0) {
		dev_err(&info->i2c_client->dev, "%s err %d\n", __func__, err);
		pwr = NVC_PWR_ERR;
	}
	info->pwr_dev = pwr;
	dev_dbg(&info->i2c_client->dev, "%s pwr_dev=%d\n",
		__func__, info->pwr_dev);
	if (err > 0)
		return 0;

	return err;
}

static int ov5693_pm_dev_wr(struct ov5693_info *info, int pwr)
{
	if (info->mode_enable)
		pwr = NVC_PWR_ON;
	if (pwr < info->pwr_api)
		pwr = info->pwr_api;
	return ov5693_pm_wr(info, pwr);
}

static void ov5693_pm_exit(struct ov5693_info *info)
{
	ov5693_pm_wr(info, NVC_PWR_OFF_FORCE);

	ov5693_gpio_exit(info);
}

static void ov5693_regulator_get(struct ov5693_info *info,
				 struct regulator **vreg,
				 const char vreg_name[])
{
	struct regulator *reg = NULL;
	int err = 0;

	reg = devm_regulator_get(&info->i2c_client->dev, vreg_name);
	if (IS_ERR(reg)) {
		dev_err(&info->i2c_client->dev, "%s %s ERR: %d\n",
			__func__, vreg_name, (int)reg);
		err = PTR_ERR(reg);
		reg = NULL;
	} else {
		dev_dbg(&info->i2c_client->dev, "%s: %s\n",
			__func__, vreg_name);
	}

	*vreg = reg;
}

static void ov5693_pm_init(struct ov5693_info *info)
{
	struct ov5693_power_rail *pw = &info->regulators;

	ov5693_gpio_init(info);

	ov5693_regulator_get(info, &pw->dvdd, "dvdd");

	ov5693_regulator_get(info, &pw->avdd, "avdd");

	ov5693_regulator_get(info, &pw->dovdd, "dovdd");
	info->power_on = false;
}

static int ov5693_mode_able(struct ov5693_info *info, bool mode_enable)
{
	u8 val;
	int err;

	if (mode_enable)
		val = 0x01;
	else
		val = 0x00;
	err = regmap_write(info->regmap, 0x0100, val);
	if (!err) {
		info->mode_enable = mode_enable;
		dev_dbg(&info->i2c_client->dev, "%s streaming=%x\n",
			__func__, info->mode_enable);
		if (!mode_enable)
			ov5693_pm_dev_wr(info, NVC_PWR_STDBY);
	}
	return err;
}

static int ov5693_mode_wr_full(struct ov5693_info *info, u32 mode_index)
{
	int err;

	ov5693_pm_dev_wr(info, NVC_PWR_ON);
	ov5693_bin_wr(info, 0);
	err = ov5693_i2c_wr_table(info, mode_table[mode_index]);
	if (!err) {
		dev_dbg(&info->i2c_client->dev,
			"init done(mode=%d)!!!\n", mode_index);
		info->mode_index = mode_index;
		info->mode_valid = true;
	} else {
		dev_dbg(&info->i2c_client->dev,
			"init error(mode=%d)!!!\n", mode_index);
		info->mode_valid = false;
	}
	return err;
}


static int ov5693_set_mode(struct ov5693_info *info,
		struct ov5693_mode *mode)
{
	u32 mode_index = 0;
	int err = 0;

	if (!mode->res_x && !mode->res_y) {
		if (mode->frame_length || mode->coarse_time || mode->gain) {
			/* write exposure only */
			err = ov5693_exposure_wr(info, mode);
			return err;
		} else {
			/* turn off streaming */
			err = ov5693_mode_able(info, false);
			return err;
		}
	}

	if (mode->res_x == 2592 && mode->res_y == 1944)
		mode_index = OV5693_MODE_2592x1944;
	else if (mode->res_x == 1296 && mode->res_y == 972)
		mode_index = OV5693_MODE_1296x972;
	else if (mode->res_x == 1920 && mode->res_y == 1080)
		mode_index = OV5693_MODE_1920x1080;
	else if (mode->res_x == 1280 && mode->res_y == 720)
		mode_index = OV5693_MODE_1280x720_120FPS;

	if (!info->mode_valid || (info->mode_index != mode_index))
		err = ov5693_mode_wr_full(info, mode_index);
	else
		dev_dbg(&info->i2c_client->dev, "%s short mode\n", __func__);
	dev_dbg(&info->i2c_client->dev, "%s: mode #: %d\n",
		__func__, mode_index);
	dev_dbg(&info->i2c_client->dev, "%s: AE: %d, %d, %d\n",
		__func__, mode->frame_length,
		mode->coarse_time, mode->gain);
	err |= ov5693_exposure_wr(info, mode);
	if (err < 0) {
		info->mode_valid = false;
		dev_err(&info->i2c_client->dev,
			"%s set_mode error\n", __func__);
		goto ov5693_mode_wr_err;
	}

	return 0;

ov5693_mode_wr_err:
	if (!info->mode_enable)
		ov5693_pm_dev_wr(info, NVC_PWR_OFF);
	return err;
}

static int ov5693_get_fuse_id(struct ov5693_info *info)
{
	ov5693_i2c_rd8(info, 0x300A, &info->fuseid.id[0]);
	ov5693_i2c_rd8(info, 0x300B, &info->fuseid.id[1]);
	info->fuseid.size = 2;
	dev_dbg(&info->i2c_client->dev, "ov5693 fuse_id: %x,%x\n",
		info->fuseid.id[0], info->fuseid.id[1]);
	return 0;
}

static long ov5693_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct ov5693_info *info = file->private_data;
	int err;

	switch (cmd) {
	case OV5693_IOCTL_SET_MODE:
	{
		struct ov5693_mode mode;
		if (copy_from_user(&mode,
			(const void __user *)arg,
			sizeof(struct ov5693_mode))) {
			dev_err(&info->i2c_client->dev,
				"%s:Failed to get mode from user.\n",
			__func__);
			return -EFAULT;
		}
		return ov5693_set_mode(info, &mode);
	}
	case OV5693_IOCTL_GET_STATUS: {
		u8 status = 0;
		if (copy_to_user((void __user *)arg, &status, sizeof(status))) {
			dev_err(&info->i2c_client->dev,
				"%s:Failed to copy status to user.\n",
			__func__);
			return -EFAULT;
		}
		return 0;
		}

	case OV5693_IOCTL_SET_GROUP_HOLD: {
		struct ov5693_ae ae;
		if (copy_from_user(&ae, (const void __user *)arg,
				sizeof(struct ov5693_ae))) {
			dev_dbg(&info->i2c_client->dev,
				"%s:fail group hold\n", __func__);
			return -EFAULT;
		}

		return ov5693_set_group_hold(info, &ae);
		}

	case OV5693_IOCTL_SET_FRAME_LENGTH:
		return ov5693_set_frame_length(info, (u32)arg, true);

	case OV5693_IOCTL_SET_COARSE_TIME:
		return ov5693_set_coarse_time(info, (u32)arg, true);

	case OV5693_IOCTL_SET_GAIN:
		return ov5693_set_gain(info, (u32)arg, true);

	case OV5693_IOCTL_GET_FUSEID:
	{
		err = ov5693_get_fuse_id(info);

		if (err) {
			dev_err(&info->i2c_client->dev, "%s:Failed to get fuse id info.\n",
			__func__);
			return err;
		}
		if (copy_to_user((void __user *)arg,
				&info->fuseid,
				sizeof(struct ov5693_fuseid))) {
			dev_dbg(&info->i2c_client->dev, "%s:Fail copy fuse id to user space\n",
				__func__);
			return -EFAULT;
		}
		return 0;
	}
	default:
		dev_err(&info->i2c_client->dev, "%s unsupported ioctl: %x\n",
			__func__, cmd);
	}
	return -EINVAL;
}

static void ov5693_sdata_init(struct ov5693_info *info)
{
	memcpy(&info->sdata, &ov5693_dflt_sdata, sizeof(info->sdata));
	if (info->pdata->lens_focal_length)
		info->sdata.focal_len = info->pdata->lens_focal_length;
	if (info->pdata->lens_max_aperture)
		info->sdata.max_aperture = info->pdata->lens_max_aperture;
	if (info->pdata->lens_fnumber)
		info->sdata.fnumber = info->pdata->lens_fnumber;
	if (info->pdata->lens_view_angle_h)
		info->sdata.view_angle_h = info->pdata->lens_view_angle_h;
	if (info->pdata->lens_view_angle_v)
		info->sdata.view_angle_v = info->pdata->lens_view_angle_v;
}

static int ov5693_open(struct inode *inode, struct file *file)
{
	int err;
	struct miscdevice *miscdev = file->private_data;
	struct ov5693_info *info = dev_get_drvdata(miscdev->parent);

	if (atomic_xchg(&info->in_use, 1))
		return -EBUSY;

	file->private_data = info;
	dev_dbg(&info->i2c_client->dev, "%s\n", __func__);

	err = ov5693_power_on(info, false);
	return err;
}

int ov5693_release(struct inode *inode, struct file *file)
{
	struct ov5693_info *info = file->private_data;

	dev_dbg(&info->i2c_client->dev, "%s\n", __func__);
	ov5693_pm_wr(info, NVC_PWR_OFF);
	file->private_data = NULL;
	WARN_ON(!atomic_xchg(&info->in_use, 0));
	return 0;
}

static const struct file_operations ov5693_fileops = {
	.owner = THIS_MODULE,
	.open = ov5693_open,
	.unlocked_ioctl = ov5693_ioctl,
	.release = ov5693_release,
};

static void ov5693_del(struct ov5693_info *info)
{
	ov5693_pm_exit(info);
	synchronize_rcu();
}

static int ov5693_remove(struct i2c_client *client)
{
	struct ov5693_info *info = i2c_get_clientdata(client);

	dev_dbg(&info->i2c_client->dev, "%s\n", __func__);
	misc_deregister(&info->miscdev);
	ov5693_del(info);
	return 0;
}

static struct of_device_id ov5693_of_match[] = {
	{ .compatible = "nvidia,ov5693", },
	{ },
};

MODULE_DEVICE_TABLE(of, ov5693_of_match);

static int ov5693_platform_power_on(struct ov5693_power_rail *pw)
{
	int err;
	struct ov5693_info *info = container_of(pw, struct ov5693_info,
						regulators);

	if (info->pdata->use_vcm_vdd) {
		err = regulator_enable(info->ext_vcm_vdd);
		if (unlikely(err))
			goto ov5693_vcm_fail;
	}

	ov5693_gpio_wr(info, OV5693_GPIO_TYPE_PWRDN, 0);
	usleep_range(10, 20);

	err = regulator_enable(pw->avdd);
	if (err)
		goto ov5693_avdd_fail;

	err = regulator_enable(pw->dovdd);
	if (err)
		goto ov5693_iovdd_fail;

	usleep_range(1, 2);
	ov5693_gpio_wr(info, OV5693_GPIO_TYPE_PWRDN, 1);

	usleep_range(300, 310);

	return 0;

ov5693_iovdd_fail:
	regulator_disable(pw->avdd);

ov5693_avdd_fail:
	if (info->pdata->use_vcm_vdd)
		regulator_disable(info->ext_vcm_vdd);

ov5693_vcm_fail:
	pr_err("%s FAILED\n", __func__);
	return err;
}

static int ov5693_platform_power_off(struct ov5693_power_rail *pw)
{
	struct ov5693_info *info = container_of(pw, struct ov5693_info,
						regulators);

	usleep_range(21, 25);
	ov5693_gpio_wr(info, OV5693_GPIO_TYPE_PWRDN, 0);
	usleep_range(1, 2);

	regulator_disable(pw->dovdd);
	regulator_disable(pw->avdd);
	if (info->pdata->use_vcm_vdd)
		regulator_disable(info->ext_vcm_vdd);

	return 0;
}

static int ov5693_parse_dt_gpio(struct device_node *np, const char *name,
				enum ov5693_gpio_type type,
				struct nvc_gpio_pdata *pdata)
{
	enum of_gpio_flags gpio_flags;

	if (of_find_property(np, name, NULL)) {
		pdata->gpio = of_get_named_gpio_flags(np, name, 0, &gpio_flags);
		pdata->gpio_type = type;
		pdata->init_en = true;
		pdata->active_high = !(gpio_flags & OF_GPIO_ACTIVE_LOW);
		return 1;
	}
	return 0;
}

static struct ov5693_platform_data *ov5693_parse_dt(struct i2c_client *client)
{
	struct device_node *np = client->dev.of_node;
	struct ov5693_platform_data *pdata;
	struct nvc_gpio_pdata *gpio_pdata = NULL;

	pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
	if (!pdata) {
		dev_err(&client->dev, "Failed to allocate pdata\n");
		return ERR_PTR(-ENOMEM);
	}

	gpio_pdata = devm_kzalloc(&client->dev,
		sizeof(*gpio_pdata) * ARRAY_SIZE(ov5693_gpio), GFP_KERNEL);
	if (!gpio_pdata) {
		dev_err(&client->dev, "cannot allocate gpio data memory\n");
		return ERR_PTR(-ENOMEM);
	}

	/* init with default platform data values */
	memcpy(pdata, &ov5693_dflt_pdata, sizeof(*pdata));

	/* extra regulators info */
	pdata->use_vcm_vdd = of_property_read_bool(np, "nvidia,use-vcm-vdd");

	/* generic info */
	of_property_read_u32(np, "nvidia,num", &pdata->num);
	of_property_read_string(np, "nvidia,dev-name", &pdata->dev_name);

	/* ov5693 gpios */
	pdata->gpio_count = 0;
	pdata->gpio_count += ov5693_parse_dt_gpio(np,
				"reset-gpios", OV5693_GPIO_TYPE_PWRDN,
				&gpio_pdata[pdata->gpio_count]);
	pdata->gpio = gpio_pdata;

	/* MCLK clock info */
	of_property_read_string(np, "nvidia,mclk_name",
				&pdata->mclk_name);

	/* ov5693 power functions */
	pdata->power_on = ov5693_platform_power_on;
	pdata->power_off = ov5693_platform_power_off;

	return pdata;
}

static int ov5693_probe(
	struct i2c_client *client,
	const struct i2c_device_id *id)
{
	struct ov5693_info *info;
	char dname[16];
	unsigned long clock_probe_rate;
	int err;
	const char *mclk_name;
	static struct regmap_config ad5823_regmap_config = {
		.reg_bits = 16,
		.val_bits = 8,
	};


	dev_dbg(&client->dev, "%s\n", __func__);
	info = devm_kzalloc(&client->dev, sizeof(*info), GFP_KERNEL);
	if (info == NULL) {
		dev_err(&client->dev, "%s: kzalloc error\n", __func__);
		return -ENOMEM;
	}

	info->i2c_client = client;
	if (client->dev.of_node) {
		info->pdata = ov5693_parse_dt(client);
		if (IS_ERR(info->pdata)) {
			err = PTR_ERR(info->pdata);
			dev_err(&client->dev,
				"Failed to parse OF node: %d\n", err);
			return err;
		}
	} else if (client->dev.platform_data)
		info->pdata = client->dev.platform_data;
	else {
		info->pdata = &ov5693_dflt_pdata;
		dev_dbg(&client->dev,
			"%s No platform data. Using defaults.\n",
			__func__);
	}
	if (info->pdata->use_vcm_vdd) {
		info->ext_vcm_vdd = devm_regulator_get(&info->i2c_client->dev,
							"ext_vcm_vdd");
		if (WARN_ON(IS_ERR(info->ext_vcm_vdd))) {
			err = PTR_ERR(info->ext_vcm_vdd);
			dev_err(&client->dev,
				"ext_vcm_vdd get failed %d\n", err);
			info->ext_vcm_vdd = NULL;
			return err;
		}
	}

	info->regmap = devm_regmap_init_i2c(client, &ad5823_regmap_config);
	if (IS_ERR(info->regmap)) {
		err = PTR_ERR(info->regmap);
		dev_err(&client->dev,
			"Failed to allocate register map: %d\n", err);
		return err;
	}

	mclk_name = info->pdata->mclk_name ?
		    info->pdata->mclk_name : "default_mclk";
	info->mclk = devm_clk_get(&client->dev, mclk_name);
	if (IS_ERR(info->mclk)) {
		dev_err(&client->dev, "%s: unable to get clock %s\n",
			__func__, mclk_name);
		return PTR_ERR(info->mclk);
	}

	i2c_set_clientdata(client, info);
	ov5693_pm_init(info);
	if (!info->regulators.avdd || !info->regulators.dovdd)
		return -EFAULT;

	ov5693_sdata_init(info);
	if (info->pdata->cfg & (NVC_CFG_NODEV | NVC_CFG_BOOT_INIT)) {
		if (info->pdata->probe_clock) {
			clock_probe_rate = 6000;  /* initial_clcok*/
			clock_probe_rate *= 1000;
			info->pdata->probe_clock(clock_probe_rate);
		}
		ov5693_pm_dev_wr(info, NVC_PWR_COMM);
		ov5693_pm_dev_wr(info, NVC_PWR_OFF);
		if (info->pdata->probe_clock)
			info->pdata->probe_clock(0);
	}
	if (info->pdata->dev_name != NULL)
		strcpy(dname, info->pdata->dev_name);
	else
		strcpy(dname, "ov5693");
	if (info->pdata->num)
		snprintf(dname, sizeof(dname), "%s.%u",
			 dname, info->pdata->num);
	info->miscdev.name = dname;
	info->miscdev.fops = &ov5693_fileops;
	info->miscdev.minor = MISC_DYNAMIC_MINOR;
	info->miscdev.parent = &client->dev;
	if (misc_register(&info->miscdev)) {
		dev_err(&client->dev, "%s unable to register misc device %s\n",
			__func__, dname);
		ov5693_del(info);
		return -ENODEV;
	}

	dev_dbg(&client->dev, "ov5693 sensor driver loading done\n");
	return 0;
}

static const struct i2c_device_id ov5693_id[] = {
	{ "ov5693", 0 },
	{ },
};

MODULE_DEVICE_TABLE(i2c, ov5693_id);

static struct i2c_driver ov5693_i2c_driver = {
	.driver = {
		.name = "ov5693",
		.owner = THIS_MODULE,
		.of_match_table = ov5693_of_match,
	},
	.id_table = ov5693_id,
	.probe = ov5693_probe,
	.remove = ov5693_remove,
};

module_i2c_driver(ov5693_i2c_driver);
MODULE_LICENSE("GPL v2");