kernel: add support for ar1335

Bug 1598204

Change-Id: I453d18ce570e57c0feab8dc3b24cc2c957b95301
Signed-off-by: Ming Wong <miwong@nvidia.com>
Reviewed-on: http://git-master/r/672147
GVS: Gerrit_Virtual_Submit
Reviewed-by: Venkat Moganty <vmoganty@nvidia.com>

3 files changed, 1267 insertions, 0 deletions

diff --git a/drivers/media/platform/tegra/Kconfig b/drivers/media/platform/tegra/Kconfig
index 1bcd293e6260..0e3df3b8c45f 100644
--- a/drivers/media/platform/tegra/Kconfig
+++ b/drivers/media/platform/tegra/Kconfig
@@ -100,6 +100,15 @@ config VIDEO_AR0330
 	  maximum of 3MP resolution with slave mode
 	  capability.
 
+config VIDEO_AR1335
+        tristate "AR1335 camera sensor support"
+        depends on I2C && ARCH_TEGRA
+        ---help---
+          This is a driver for the AR1335 camera sensor
+          for use with the tegra isp.  The sensor has a
+          maximum resolution of 4208x3120 with 4 MIPI
+          lane configuration.
+
 config VIDEO_IMX132
         tristate "IMX132 camera sensor support"
         depends on I2C && ARCH_TEGRA
diff --git a/drivers/media/platform/tegra/Makefile b/drivers/media/platform/tegra/Makefile
index 6c205b2ed0e1..1d4cc49cc841 100644
--- a/drivers/media/platform/tegra/Makefile
+++ b/drivers/media/platform/tegra/Makefile
@@ -38,6 +38,7 @@ obj-$(CONFIG_VIDEO_IMX179)	+= imx179.o
 obj-$(CONFIG_VIDEO_IMX132)	+= imx132.o
 obj-$(CONFIG_VIDEO_AR0330)	+= ar0330.o
 obj-$(CONFIG_VIDEO_AR0261)	+= ar0261.o
+obj-$(CONFIG_VIDEO_AR1335)	+= ar1335.o
 obj-$(CONFIG_DEBUG_FS)		+= nvc_debugfs.o
 obj-$(CONFIG_VIDEO_OV5693)	+= ov5693.o
 obj-$(CONFIG_VIDEO_AD5823)	+= ad5823.o
diff --git a/drivers/media/platform/tegra/ar1335.c b/drivers/media/platform/tegra/ar1335.c
new file mode 100644
index 000000000000..d178fb459702
--- /dev/null
+++ b/drivers/media/platform/tegra/ar1335.c
@@ -0,0 +1,1257 @@
+/*
+ * ar1335.c - ar1335 sensor driver
+ *
+ * Copyright (c) 2014-2015, 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/regmap.h>
+#include <media/ar1335.h>
+#include <linux/gpio.h>
+#include <linux/module.h>
+
+#include <linux/kernel.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+
+#include "nvc_utilities.h"
+
+struct ar1335_reg {
+	u16 addr;
+	u16 val;
+};
+
+struct ar1335_info {
+	struct miscdevice		miscdev_info;
+	int				mode;
+	struct ar1335_power_rail	power;
+	struct ar1335_sensordata	sensor_data;
+	struct i2c_client		*i2c_client;
+	struct ar1335_platform_data	*pdata;
+	struct clk			*mclk;
+	struct regmap			*regmap;
+	struct dentry			*debugdir;
+	atomic_t			in_use;
+};
+
+static const struct regmap_config sensor_regmap_config = {
+	.reg_bits = 16,
+	.val_bits = 16,
+	.cache_type = REGCACHE_RBTREE,
+};
+
+#define AR1335_TABLE_WAIT_MS 0
+#define AR1335_TABLE_END 1
+#define AR1335_MAX_RETRIES 3
+#define AR1335_WAIT_MS 100
+
+#define MAX_BUFFER_SIZE 32
+#define AR1335_FRAME_LENGTH_ADDR 0x300A
+#define AR1335_COARSE_TIME_ADDR 0x3012
+#define AR1335_GAIN_ADDR 0x305E
+
+static struct ar1335_reg mode_4208x3120[] = {
+	{0x3042, 0x1004},
+	{0x30D2, 0x0120},
+	{0x30D4, 0x0000},
+	{0x3090, 0x0000},
+	{0x30FC, 0x0060},
+	{0x30FE, 0x0060},
+	{0x31E0, 0x0781},
+	{0x3180, 0x9434},
+	{0x317C, 0xEFF4},
+	{0x30EE, 0x4140},
+	{0x3F2C, 0x4428},
+
+	{0x3D00, 0x0446},
+	{0x3D02, 0x4C66},
+	{0x3D04, 0xFFFF},
+	{0x3D06, 0xFFFF},
+	{0x3D08, 0x5E40},
+	{0x3D0A, 0x1146},
+	{0x3D0C, 0x5D41},
+	{0x3D0E, 0x1088},
+	{0x3D10, 0x8342},
+	{0x3D12, 0x00C0},
+	{0x3D14, 0x5580},
+	{0x3D16, 0x5B83},
+	{0x3D18, 0x6084},
+	{0x3D1A, 0x5A8D},
+	{0x3D1C, 0x00C0},
+	{0x3D1E, 0x8342},
+	{0x3D20, 0x925A},
+	{0x3D22, 0x8664},
+	{0x3D24, 0x1030},
+	{0x3D26, 0x801C},
+	{0x3D28, 0x00A0},
+	{0x3D2A, 0x56B0},
+	{0x3D2C, 0x5788},
+	{0x3D2E, 0x5150},
+	{0x3D30, 0x824D},
+	{0x3D32, 0x8D58},
+	{0x3D34, 0x58D2},
+	{0x3D36, 0x438A},
+	{0x3D38, 0x4592},
+	{0x3D3A, 0x458A},
+	{0x3D3C, 0x439D},
+	{0x3D3E, 0x51CA},
+	{0x3D40, 0x5182},
+	{0x3D42, 0x100C},
+	{0x3D44, 0x9259},
+	{0x3D46, 0x5982},
+	{0x3D48, 0x5FF7},
+	{0x3D4A, 0x6182},
+	{0x3D4C, 0x6283},
+	{0x3D4E, 0x4281},
+	{0x3D50, 0x10C0},
+	{0x3D52, 0x6498},
+	{0x3D54, 0x4281},
+	{0x3D56, 0x41FF},
+	{0x3D58, 0xFFB8},
+	{0x3D5A, 0x4081},
+	{0x3D5C, 0x4080},
+	{0x3D5E, 0x4180},
+	{0x3D60, 0x4280},
+	{0x3D62, 0x438D},
+	{0x3D64, 0x44BA},
+	{0x3D66, 0x4488},
+	{0x3D68, 0x4380},
+	{0x3D6A, 0x4241},
+	{0x3D6C, 0x8140},
+	{0x3D6E, 0x8240},
+	{0x3D70, 0x8041},
+	{0x3D72, 0x8042},
+	{0x3D74, 0x8043},
+	{0x3D76, 0x8D44},
+	{0x3D78, 0xBA44},
+	{0x3D7A, 0x875E},
+	{0x3D7C, 0x4354},
+	{0x3D7E, 0x4241},
+	{0x3D80, 0x8140},
+	{0x3D82, 0x8120},
+	{0x3D84, 0x2881},
+	{0x3D86, 0x6026},
+	{0x3D88, 0x8055},
+	{0x3D8A, 0x8070},
+	{0x3D8C, 0x8040},
+	{0x3D8E, 0x4C81},
+	{0x3D90, 0x45C3},
+	{0x3D92, 0x4581},
+	{0x3D94, 0x4C40},
+	{0x3D96, 0x8070},
+	{0x3D98, 0x8040},
+	{0x3D9A, 0x4C85},
+	{0x3D9C, 0x6CA8},
+	{0x3D9E, 0x6C8C},
+	{0x3DA0, 0x000E},
+	{0x3DA2, 0xBE44},
+	{0x3DA4, 0x8844},
+	{0x3DA6, 0xBC78},
+	{0x3DA8, 0x0900},
+	{0x3DAA, 0x8904},
+	{0x3DAC, 0x8080},
+	{0x3DAE, 0x0240},
+	{0x3DB0, 0x8609},
+	{0x3DB2, 0x008E},
+	{0x3DB4, 0x0900},
+	{0x3DB6, 0x8002},
+	{0x3DB8, 0x4080},
+	{0x3DBA, 0x0480},
+	{0x3DBC, 0x887C},
+	{0x3DBE, 0xAA86},
+	{0x3DC0, 0x0900},
+	{0x3DC2, 0x877A},
+	{0x3DC4, 0x000E},
+	{0x3DC6, 0xC379},
+	{0x3DC8, 0x4C40},
+	{0x3DCA, 0xBF70},
+	{0x3DCC, 0x5E40},
+	{0x3DCE, 0x114E},
+	{0x3DD0, 0x5D41},
+	{0x3DD2, 0x5383},
+	{0x3DD4, 0x4200},
+	{0x3DD6, 0xC055},
+	{0x3DD8, 0xA400},
+	{0x3DDA, 0xC083},
+	{0x3DDC, 0x4288},
+	{0x3DDE, 0x6083},
+	{0x3DE0, 0x5B80},
+	{0x3DE2, 0x5A64},
+	{0x3DE4, 0x1030},
+	{0x3DE6, 0x801C},
+	{0x3DE8, 0x00A5},
+	{0x3DEA, 0x5697},
+	{0x3DEC, 0x57A5},
+	{0x3DEE, 0x5180},
+	{0x3DF0, 0x505A},
+	{0x3DF2, 0x814D},
+	{0x3DF4, 0x8358},
+	{0x3DF6, 0x8058},
+	{0x3DF8, 0xA943},
+	{0x3DFA, 0x8345},
+	{0x3DFC, 0xB045},
+	{0x3DFE, 0x8343},
+	{0x3E00, 0xA351},
+	{0x3E02, 0xE251},
+	{0x3E04, 0x8C59},
+	{0x3E06, 0x8059},
+	{0x3E08, 0x8A5F},
+	{0x3E0A, 0xEC7C},
+	{0x3E0C, 0xCC84},
+	{0x3E0E, 0x6182},
+	{0x3E10, 0x6283},
+	{0x3E12, 0x4283},
+	{0x3E14, 0x10CC},
+	{0x3E16, 0x6496},
+	{0x3E18, 0x4281},
+	{0x3E1A, 0x41BB},
+	{0x3E1C, 0x4082},
+	{0x3E1E, 0x407E},
+	{0x3E20, 0xCC41},
+	{0x3E22, 0x8042},
+	{0x3E24, 0x8043},
+	{0x3E26, 0x8300},
+	{0x3E28, 0xC088},
+	{0x3E2A, 0x44BA},
+	{0x3E2C, 0x4488},
+	{0x3E2E, 0x00C8},
+	{0x3E30, 0x8042},
+	{0x3E32, 0x4181},
+	{0x3E34, 0x4082},
+	{0x3E36, 0x4080},
+	{0x3E38, 0x4180},
+	{0x3E3A, 0x4280},
+	{0x3E3C, 0x4383},
+	{0x3E3E, 0x00C0},
+	{0x3E40, 0x8844},
+	{0x3E42, 0xBA44},
+	{0x3E44, 0x8800},
+	{0x3E46, 0xC880},
+	{0x3E48, 0x4241},
+	{0x3E4A, 0x8240},
+	{0x3E4C, 0x8140},
+	{0x3E4E, 0x8041},
+	{0x3E50, 0x8042},
+	{0x3E52, 0x8043},
+	{0x3E54, 0x8300},
+	{0x3E56, 0xC088},
+	{0x3E58, 0x44BA},
+	{0x3E5A, 0x4488},
+	{0x3E5C, 0x00C8},
+	{0x3E5E, 0x8042},
+	{0x3E60, 0x4181},
+	{0x3E62, 0x4082},
+	{0x3E64, 0x4080},
+	{0x3E66, 0x4180},
+	{0x3E68, 0x4280},
+	{0x3E6A, 0x4383},
+	{0x3E6C, 0x00C0},
+	{0x3E6E, 0x8844},
+	{0x3E70, 0xBA44},
+	{0x3E72, 0x8800},
+	{0x3E74, 0xC880},
+	{0x3E76, 0x4241},
+	{0x3E78, 0x8140},
+	{0x3E7A, 0x9F5E},
+	{0x3E7C, 0x8A54},
+	{0x3E7E, 0x8620},
+	{0x3E80, 0x2881},
+	{0x3E82, 0x6026},
+	{0x3E84, 0x8055},
+	{0x3E86, 0x8070},
+	{0x3E88, 0x0000},
+	{0x3E8A, 0x0000},
+	{0x3E8C, 0x0000},
+	{0x3E8E, 0x0000},
+	{0x3E90, 0x0000},
+	{0x3E92, 0x0000},
+	{0x3E94, 0x0000},
+	{0x3E96, 0x0000},
+	{0x3E98, 0x0000},
+	{0x3E9A, 0x0000},
+	{0x3E9C, 0x0000},
+	{0x3E9E, 0x0000},
+	{0x3EA0, 0x0000},
+	{0x3EA2, 0x0000},
+	{0x3EA4, 0x0000},
+	{0x3EA6, 0x0000},
+	{0x3EA8, 0x0000},
+	{0x3EAA, 0x0000},
+	{0x3EAC, 0x0000},
+	{0x3EAE, 0x0000},
+	{0x3EB0, 0x0000},
+	{0x3EB2, 0x0000},
+	{0x3EB4, 0x0000},
+
+	{0x3EB6, 0x004D},
+	{0x3EB8, 0x0F0C},
+	{0x3EBC, 0xAA06},
+	{0x3EC0, 0x1E02},
+	{0x3EC2, 0x7700},
+	{0x3EC4, 0x1308},
+	{0x3EC6, 0xEA44},
+	{0x3EC8, 0x0F0F},
+	{0x3ECA, 0x0F4A},
+	{0x3ECC, 0x0706},
+	{0x3ECE, 0x443B},
+	{0x3ED0, 0x12F0},
+	{0x3ED2, 0x0039},
+	{0x3ED4, 0x862F},
+	{0x3ED6, 0x4080},
+	{0x3ED8, 0x0523},
+	{0x3EDA, 0xF896},
+	{0x3EDC, 0x5096},
+	{0x3EDE, 0x5005},
+	{0x316A, 0x8200},
+	{0x316E, 0x8200},
+	{0x316C, 0x8200},
+	{0x3EF0, 0x4D4D},
+	{0x3EF2, 0x0101},
+	{0x3EF6, 0x0307},
+	{0x3EFA, 0x0F0F},
+	{0x3EFC, 0x0F0F},
+	{0x3EFE, 0x0F0F},
+
+	{0x31B0, 0x005C},
+	{0x31B2, 0x002D},
+	{0x31B4, 0x2412},
+	{0x31B6, 0x142A},
+	{0x31B8, 0x2413},
+	{0x31BA, 0x1C70},
+	{0x31BC, 0x868B},
+	{0x31AE, 0x0204},
+
+	{0x0300, 0x0005},
+	{0x0302, 0x0001},
+	{0x0304, 0x0101},
+	{0x0306, 0x2E2E},
+	{0x0308, 0x000A},
+	{0x030A, 0x0001},
+	{0x0112, 0x0A0A},
+	{0x3016, 0x0101},
+	{AR1335_TABLE_WAIT_MS, AR1335_WAIT_MS},
+
+	{0x0344, 0x0010},
+	{0x0348, 0x107F},
+	{0x0346, 0x0010},
+	{0x034A, 0x0C3F},
+	{0x034C, 0x1070},
+	{0x034E, 0x0C30},
+	{0x3040, 0x0041},
+	{0x0112, 0x0A0A},
+	{0x0112, 0x0A0A},
+	{0x3172, 0x0206},
+	{0x317A, 0x416E},
+	{0x3F3C, 0x0003},
+	{0x0342, 0x1240},
+	{0x0340, 0x0C4E},
+	{0x0202, 0x0C44},
+
+	{0x31E0, 0x0781},
+	{0x3F00, 0x004F},
+	{0x3F02, 0x0125},
+	{0x3F04, 0x0020},
+	{0x3F06, 0x0040},
+	{0x3F08, 0x0070},
+	{0x3F0A, 0x0101},
+	{0x3F0C, 0x0302},
+	{0x3F1E, 0x0022},
+	{0x3F1A, 0x01FF},
+	{0x3F14, 0x0101},
+	{0x3F44, 0x0707},
+	{0x3F18, 0x011E},
+	{0x3F12, 0x0303},
+	{0x3F42, 0x1511},
+	{0x3F16, 0x011E},
+	{0x3F40, 0x1511},
+
+	{0x3F3C, 0x0003},
+	{0x301A, 0x021C},
+	{AR1335_TABLE_END, 0x00}
+};
+
+enum {
+	AR1335_MODE_4208X3120,
+};
+
+static struct ar1335_reg *mode_table[] = {
+	[AR1335_MODE_4208X3120] = mode_4208x3120,
+};
+
+static inline void
+msleep_range(unsigned int delay_base)
+{
+	usleep_range(delay_base*1000, delay_base*1000+500);
+}
+
+static inline void
+ar1335_get_frame_length_regs(struct ar1335_reg *regs, u32 frame_length)
+{
+	regs->addr = AR1335_FRAME_LENGTH_ADDR;
+	regs->val = frame_length & 0xffff;
+}
+
+static inline void
+ar1335_get_coarse_time_regs(struct ar1335_reg *regs, u32 coarse_time)
+{
+	regs->addr = AR1335_COARSE_TIME_ADDR;
+	regs->val = coarse_time & 0xffff;
+}
+
+static inline void
+ar1335_get_gain_reg(struct ar1335_reg *regs, u16 gain)
+{
+	regs->addr = AR1335_GAIN_ADDR;
+	regs->val = gain;
+}
+
+static inline int
+ar1335_read_reg(struct ar1335_info *info, u16 addr, u16 *val)
+{
+	return regmap_read(info->regmap, addr, (unsigned int *) val);
+}
+
+static int
+ar1335_write_reg(struct ar1335_info *info, u16 addr, u16 val)
+{
+	int err;
+
+	err = regmap_write(info->regmap, addr, val);
+
+	if (err)
+		pr_err("%s:i2c write failed, %x = %x\n",
+			__func__, addr, val);
+
+	return err;
+}
+
+static int
+ar1335_write_table(struct ar1335_info *info,
+				 const struct ar1335_reg table[],
+				 const struct ar1335_reg override_list[],
+				 int num_override_regs)
+{
+	int err;
+	const struct ar1335_reg *next;
+	int i;
+	u16 val;
+
+	for (next = table; next->addr != AR1335_TABLE_END; next++) {
+		if (next->addr == AR1335_TABLE_WAIT_MS) {
+			msleep_range(next->val);
+			continue;
+		}
+
+		val = next->val;
+
+		/* When an override list is passed in, replace the reg */
+		/* value to write if the reg is in the list            */
+		if (override_list) {
+			for (i = 0; i < num_override_regs; i++) {
+				if (next->addr == override_list[i].addr) {
+					val = override_list[i].val;
+					break;
+				}
+			}
+		}
+
+		err = ar1335_write_reg(info, next->addr, val);
+		if (err) {
+			pr_err("%s:ar1335_write_table:%d", __func__, err);
+			return err;
+		}
+	}
+	return 0;
+}
+
+static int ar1335_get_flash_cap(struct ar1335_info *info)
+{
+	struct ar1335_flash_control *fctl;
+
+	dev_dbg(&info->i2c_client->dev, "%s: %p\n", __func__, info->pdata);
+	if (info->pdata) {
+		fctl = &info->pdata->flash_cap;
+		dev_dbg(&info->i2c_client->dev,
+			"edg: %x, st: %x, rpt: %x, dl: %x\n",
+			fctl->edge_trig_en,
+			fctl->start_edge,
+			fctl->repeat,
+			fctl->delay_frm);
+
+		if (fctl->enable)
+			return 0;
+	}
+	return -ENODEV;
+}
+
+static inline int ar1335_set_flash_control(
+	struct ar1335_info *info, struct ar1335_flash_control *fc)
+{
+	dev_dbg(&info->i2c_client->dev, "%s\n", __func__);
+	return ar1335_write_reg(info, 0x0802, 0x01);
+}
+
+static int
+ar1335_set_mode(struct ar1335_info *info, struct ar1335_mode *mode)
+{
+	int sensor_mode;
+	int err;
+	struct ar1335_reg reg_list[8];
+
+	pr_info("%s: xres %u yres %u framelength %u coarsetime %u gain %u\n",
+			 __func__, mode->xres, mode->yres, mode->frame_length,
+			 mode->coarse_time, mode->gain);
+
+	if (mode->xres == 4208 && mode->yres == 3120) {
+		sensor_mode = AR1335_MODE_4208X3120;
+	} else {
+		pr_err("%s: invalid resolution supplied to set mode %d %d\n",
+			 __func__, mode->xres, mode->yres);
+		return -EINVAL;
+	}
+
+	/* get a list of override regs for the asking frame length, */
+	/* coarse integration time, and gain.                       */
+	ar1335_get_frame_length_regs(reg_list, mode->frame_length);
+	ar1335_get_coarse_time_regs(reg_list + 1, mode->coarse_time);
+	ar1335_get_gain_reg(reg_list + 2, mode->gain);
+
+	err = ar1335_write_table(info,
+				mode_table[sensor_mode],
+				reg_list, 3);
+	if (err)
+		return err;
+	info->mode = sensor_mode;
+	pr_info("[AR1335]: stream on.\n");
+	return 0;
+}
+
+static int
+ar1335_get_status(struct ar1335_info *info, u8 *dev_status)
+{
+	*dev_status = 0;
+	return 0;
+}
+
+static int
+ar1335_set_frame_length(struct ar1335_info *info, u32 frame_length,
+						 bool group_hold)
+{
+	struct ar1335_reg reg_list[2];
+	int i = 0;
+	int ret;
+
+	ar1335_get_frame_length_regs(reg_list, frame_length);
+
+	if (group_hold) {
+		ret = ar1335_write_reg(info, 0x0104, 0x01);
+		if (ret)
+			return ret;
+	}
+
+	for (i = 0; i < 1; i++) {
+		ret = ar1335_write_reg(info, reg_list[i].addr,
+			 reg_list[i].val);
+		if (ret)
+			return ret;
+	}
+
+	if (group_hold) {
+		ret = ar1335_write_reg(info, 0x0104, 0x0);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int
+ar1335_set_coarse_time(struct ar1335_info *info, u32 coarse_time,
+						 bool group_hold)
+{
+	int ret;
+
+	struct ar1335_reg reg_list[2];
+	int i = 0;
+
+	ar1335_get_coarse_time_regs(reg_list, coarse_time);
+
+	if (group_hold) {
+		ret = ar1335_write_reg(info, 0x104, 0x01);
+		if (ret)
+			return ret;
+	}
+
+	for (i = 0; i < 1; i++) {
+		ret = ar1335_write_reg(info, reg_list[i].addr,
+			 reg_list[i].val);
+		if (ret)
+			return ret;
+	}
+
+	if (group_hold) {
+		ret = ar1335_write_reg(info, 0x104, 0x0);
+		if (ret)
+			return ret;
+	}
+	return 0;
+}
+
+static int
+ar1335_set_gain(struct ar1335_info *info, u16 gain, bool group_hold)
+{
+	int ret;
+	struct ar1335_reg reg_list;
+
+	ar1335_get_gain_reg(&reg_list, gain);
+
+	if (group_hold) {
+		ret = ar1335_write_reg(info, 0x104, 0x1);
+		if (ret)
+			return ret;
+	}
+
+	ret = ar1335_write_reg(info, reg_list.addr, reg_list.val);
+	if (ret)
+		return ret;
+
+	if (group_hold) {
+		ret = ar1335_write_reg(info, 0x104, 0x0);
+		if (ret)
+			return ret;
+	}
+	return 0;
+}
+
+static int
+ar1335_set_group_hold(struct ar1335_info *info, struct ar1335_ae *ae)
+{
+	int ret;
+	int count = 0;
+	bool group_hold_enabled = false;
+
+	if (ae->gain_enable)
+		count++;
+	if (ae->coarse_time_enable)
+		count++;
+	if (ae->frame_length_enable)
+		count++;
+	if (count >= 2)
+		group_hold_enabled = true;
+
+	if (group_hold_enabled) {
+		ret = ar1335_write_reg(info, 0x104, 0x1);
+		if (ret)
+			return ret;
+	}
+
+	if (ae->gain_enable)
+		ar1335_set_gain(info, ae->gain, true);
+	if (ae->coarse_time_enable)
+		ar1335_set_coarse_time(info, ae->coarse_time, true);
+	if (ae->frame_length_enable)
+		ar1335_set_frame_length(info, ae->frame_length, true);
+
+	if (group_hold_enabled) {
+		ret = ar1335_write_reg(info, 0x104, 0x0);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int ar1335_get_sensor_id(struct ar1335_info *info)
+{
+	int ret = 0;
+
+	pr_info("%s\n", __func__);
+	if (info->sensor_data.fuse_id_size)
+		return 0;
+
+	/* Note 1: If the sensor does not have power at this point
+	Need to supply the power, e.g. by calling power on function */
+
+	/*ret |= ar1335_write_reg(info, 0x3B02, 0x00);
+	ret |= ar1335_write_reg(info, 0x3B00, 0x01);
+	for (i = 0; i < 9; i++) {
+		ret |= ar1335_read_reg(info, 0x3B24 + i, &bak);
+		info->sensor_data.fuse_id[i] = bak;
+	}
+
+	if (!ret)
+		info->sensor_data.fuse_id_size = i;*/
+
+	/* Note 2: Need to clean up any action carried out in Note 1 */
+
+	return ret;
+}
+
+static void ar1335_mclk_disable(struct ar1335_info *info)
+{
+	dev_dbg(&info->i2c_client->dev, "%s: disable MCLK\n", __func__);
+	clk_disable_unprepare(info->mclk);
+}
+
+static int ar1335_mclk_enable(struct ar1335_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 long
+ar1335_ioctl(struct file *file,
+			 unsigned int cmd, unsigned long arg)
+{
+	int err = 0;
+	struct ar1335_info *info = file->private_data;
+
+	switch (cmd) {
+	case AR1335_IOCTL_SET_POWER:
+		if (!info->pdata)
+			break;
+		if (arg && info->pdata->power_on) {
+			err = ar1335_mclk_enable(info);
+			if (!err)
+				err = info->pdata->power_on(&info->power);
+			if (err < 0)
+				ar1335_mclk_disable(info);
+		}
+		if (!arg && info->pdata->power_off) {
+			info->pdata->power_off(&info->power);
+			ar1335_mclk_disable(info);
+		}
+		break;
+	case AR1335_IOCTL_SET_MODE:
+	{
+		struct ar1335_mode mode;
+		if (copy_from_user(&mode, (const void __user *)arg,
+			sizeof(struct ar1335_mode))) {
+			pr_err("%s:Failed to get mode from user.\n", __func__);
+			return -EFAULT;
+		}
+		return ar1335_set_mode(info, &mode);
+	}
+	case AR1335_IOCTL_SET_FRAME_LENGTH:
+		return ar1335_set_frame_length(info, (u32)arg, true);
+	case AR1335_IOCTL_SET_COARSE_TIME:
+		return ar1335_set_coarse_time(info, (u32)arg, true);
+	case AR1335_IOCTL_SET_GAIN:
+		return ar1335_set_gain(info, (u16)arg, true);
+	case AR1335_IOCTL_GET_STATUS:
+	{
+		u8 status;
+
+		err = ar1335_get_status(info, &status);
+		if (err)
+			return err;
+		if (copy_to_user((void __user *)arg, &status, 1)) {
+			pr_err("%s:Failed to copy status to user\n", __func__);
+			return -EFAULT;
+		}
+		return 0;
+	}
+	case AR1335_IOCTL_GET_SENSORDATA:
+	{
+		err = ar1335_get_sensor_id(info);
+
+		if (err) {
+			pr_err("%s:Failed to get fuse id info.\n", __func__);
+			return err;
+		}
+		if (copy_to_user((void __user *)arg, &info->sensor_data,
+				sizeof(struct ar1335_sensordata))) {
+			pr_info("%s:Failed to copy fuse id to user space\n",
+				__func__);
+			return -EFAULT;
+		}
+		return 0;
+	}
+	case AR1335_IOCTL_SET_GROUP_HOLD:
+	{
+		struct ar1335_ae ae;
+		if (copy_from_user(&ae, (const void __user *)arg,
+			sizeof(struct ar1335_ae))) {
+			pr_info("%s:fail group hold\n", __func__);
+			return -EFAULT;
+		}
+		return ar1335_set_group_hold(info, &ae);
+	}
+	case AR1335_IOCTL_SET_FLASH_MODE:
+	{
+		struct ar1335_flash_control values;
+
+		dev_dbg(&info->i2c_client->dev,
+			"AR1335_IOCTL_SET_FLASH_MODE\n");
+		if (copy_from_user(&values,
+			(const void __user *)arg,
+			sizeof(struct ar1335_flash_control))) {
+			err = -EFAULT;
+			break;
+		}
+		err = ar1335_set_flash_control(info, &values);
+		break;
+	}
+	case AR1335_IOCTL_GET_FLASH_CAP:
+		err = ar1335_get_flash_cap(info);
+		break;
+	default:
+		pr_err("%s:unknown cmd.\n", __func__);
+		err = -EINVAL;
+	}
+
+	return err;
+}
+
+static int ar1335_debugfs_show(struct seq_file *s, void *unused)
+{
+	struct ar1335_info *dev = s->private;
+
+	dev_dbg(&dev->i2c_client->dev, "%s: ++\n", __func__);
+
+	return 0;
+}
+
+static ssize_t ar1335_debugfs_write(
+	struct file *file,
+	char const __user *buf,
+	size_t count,
+	loff_t *offset)
+{
+	struct ar1335_info *dev =
+			((struct seq_file *)file->private_data)->private;
+	struct i2c_client *i2c_client = dev->i2c_client;
+	int ret = 0;
+	char buffer[MAX_BUFFER_SIZE];
+	u32 address;
+	u32 data;
+	u16 readback;
+
+	dev_dbg(&i2c_client->dev, "%s: ++\n", __func__);
+
+	if (copy_from_user(&buffer, buf, sizeof(buffer)))
+		goto debugfs_write_fail;
+
+	if (sscanf(buf, "0x%x 0x%x", &address, &data) == 2)
+		goto set_attr;
+	if (sscanf(buf, "0X%x 0X%x", &address, &data) == 2)
+		goto set_attr;
+	if (sscanf(buf, "%d %d", &address, &data) == 2)
+		goto set_attr;
+
+	if (sscanf(buf, "0x%x 0x%x", &address, &data) == 1)
+		goto read;
+	if (sscanf(buf, "0X%x 0X%x", &address, &data) == 1)
+		goto read;
+	if (sscanf(buf, "%d %d", &address, &data) == 1)
+		goto read;
+
+	dev_err(&i2c_client->dev, "SYNTAX ERROR: %s\n", buf);
+	return -EFAULT;
+
+set_attr:
+	dev_info(&i2c_client->dev,
+			"new address = %x, data = %x\n", address, data);
+	ret |= ar1335_write_reg(dev, address, data);
+read:
+	ret |= ar1335_read_reg(dev, address, &readback);
+	dev_dbg(&i2c_client->dev,
+			"wrote to address 0x%x with value 0x%x\n",
+			address, readback);
+
+	if (ret)
+		goto debugfs_write_fail;
+
+	return count;
+
+debugfs_write_fail:
+	dev_err(&i2c_client->dev,
+			"%s: test pattern write failed\n", __func__);
+	return -EFAULT;
+}
+
+static int ar1335_debugfs_open(struct inode *inode, struct file *file)
+{
+	struct ar1335_info *dev = inode->i_private;
+	struct i2c_client *i2c_client = dev->i2c_client;
+
+	dev_dbg(&i2c_client->dev, "%s: ++\n", __func__);
+
+	return single_open(file, ar1335_debugfs_show, inode->i_private);
+}
+
+static const struct file_operations ar1335_debugfs_fops = {
+	.open		= ar1335_debugfs_open,
+	.read		= seq_read,
+	.write		= ar1335_debugfs_write,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+
+static void ar1335_remove_debugfs(struct ar1335_info *dev)
+{
+	struct i2c_client *i2c_client = dev->i2c_client;
+
+	dev_dbg(&i2c_client->dev, "%s: ++\n", __func__);
+
+	debugfs_remove_recursive(dev->debugdir);
+	dev->debugdir = NULL;
+}
+
+static void ar1335_create_debugfs(struct ar1335_info *dev)
+{
+	struct dentry *ret;
+	struct i2c_client *i2c_client = dev->i2c_client;
+
+	dev_dbg(&i2c_client->dev, "%s\n", __func__);
+
+	dev->debugdir =
+		debugfs_create_dir(dev->miscdev_info.this_device->kobj.name,
+							NULL);
+	if (!dev->debugdir)
+		goto remove_debugfs;
+
+	ret = debugfs_create_file("d",
+				S_IWUSR | S_IRUGO,
+				dev->debugdir, dev,
+				&ar1335_debugfs_fops);
+	if (!ret)
+		goto remove_debugfs;
+
+	return;
+remove_debugfs:
+	dev_err(&i2c_client->dev, "couldn't create debugfs\n");
+	ar1335_remove_debugfs(dev);
+}
+
+static int ar1335_power_on(struct ar1335_power_rail *pw)
+{
+	int err;
+	struct ar1335_info *info = container_of(pw, struct ar1335_info, power);
+
+	if (unlikely(WARN_ON(!pw || !pw->iovdd || !pw->avdd)))
+		return -EFAULT;
+
+	gpio_set_value(info->pdata->reset_gpio, 0);
+	gpio_set_value(info->pdata->af_gpio, 1);
+	gpio_set_value(info->pdata->cam1_gpio, 0);
+	usleep_range(10, 20);
+
+	err = regulator_enable(pw->avdd);
+	if (err)
+		goto ar1335_avdd_fail;
+
+	err = regulator_enable(pw->iovdd);
+	if (err)
+		goto ar1335_iovdd_fail;
+
+	usleep_range(1, 2);
+	gpio_set_value(info->pdata->reset_gpio, 1);
+	gpio_set_value(info->pdata->cam1_gpio, 1);
+
+	usleep_range(300, 310);
+
+	return 1;
+
+
+ar1335_iovdd_fail:
+	regulator_disable(pw->avdd);
+
+ar1335_avdd_fail:
+	pr_err("%s failed.\n", __func__);
+	return -ENODEV;
+}
+
+static int ar1335_power_off(struct ar1335_power_rail *pw)
+{
+	struct ar1335_info *info = container_of(pw, struct ar1335_info, power);
+
+	if (unlikely(WARN_ON(!pw || !pw->iovdd || !pw->avdd)))
+		return -EFAULT;
+
+	usleep_range(1, 2);
+	gpio_set_value(info->pdata->cam1_gpio, 0);
+	usleep_range(1, 2);
+
+	regulator_disable(pw->iovdd);
+	regulator_disable(pw->avdd);
+
+	return 0;
+}
+
+static int
+ar1335_open(struct inode *inode, struct file *file)
+{
+	struct miscdevice	*miscdev = file->private_data;
+	struct ar1335_info *info;
+
+	info = container_of(miscdev, struct ar1335_info, miscdev_info);
+	/* check if the device is in use */
+	if (atomic_xchg(&info->in_use, 1)) {
+		pr_info("%s:BUSY!\n", __func__);
+		return -EBUSY;
+	}
+
+	file->private_data = info;
+
+	return 0;
+}
+
+static int
+ar1335_release(struct inode *inode, struct file *file)
+{
+	struct ar1335_info *info = file->private_data;
+
+	file->private_data = NULL;
+
+	/* warn if device is already released */
+	WARN_ON(!atomic_xchg(&info->in_use, 0));
+	return 0;
+}
+
+static int ar1335_power_put(struct ar1335_power_rail *pw)
+{
+	if (unlikely(!pw))
+		return -EFAULT;
+
+	if (likely(pw->avdd))
+		regulator_put(pw->avdd);
+
+	if (likely(pw->iovdd))
+		regulator_put(pw->iovdd);
+
+	if (likely(pw->dvdd))
+		regulator_put(pw->dvdd);
+
+	pw->avdd = NULL;
+	pw->iovdd = NULL;
+	pw->dvdd = NULL;
+
+	return 0;
+}
+
+static int ar1335_regulator_get(struct ar1335_info *info,
+	struct regulator **vreg, char vreg_name[])
+{
+	struct regulator *reg = NULL;
+	int err = 0;
+
+	reg = regulator_get(&info->i2c_client->dev, vreg_name);
+	if (unlikely(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;
+	return err;
+}
+
+static int ar1335_power_get(struct ar1335_info *info)
+{
+	struct ar1335_power_rail *pw = &info->power;
+	int err = 0;
+
+	err |= ar1335_regulator_get(info, &pw->avdd, "vana"); /* ananlog 2.7v */
+	err |= ar1335_regulator_get(info, &pw->dvdd, "vdig_csi"); /* dig 1.2v */
+	err |= ar1335_regulator_get(info, &pw->iovdd, "vif"); /* IO 1.8v */
+
+	return err;
+}
+
+static const struct file_operations ar1335_fileops = {
+	.owner = THIS_MODULE,
+	.open = ar1335_open,
+	.unlocked_ioctl = ar1335_ioctl,
+	.release = ar1335_release,
+};
+
+static struct miscdevice ar1335_device = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = "ar1335",
+	.fops = &ar1335_fileops,
+};
+
+static struct of_device_id ar1335_of_match[] = {
+	{ .compatible = "nvidia,ar1335", },
+	{ },
+};
+
+MODULE_DEVICE_TABLE(of, ar1335_of_match);
+
+static struct ar1335_platform_data *ar1335_parse_dt(struct i2c_client *client)
+{
+	struct device_node *np = client->dev.of_node;
+	struct ar1335_platform_data *board_info_pdata;
+	const struct of_device_id *match;
+
+	match = of_match_device(ar1335_of_match, &client->dev);
+	if (!match) {
+		dev_err(&client->dev, "Failed to find matching dt id\n");
+		return NULL;
+	}
+
+	board_info_pdata = devm_kzalloc(&client->dev, sizeof(*board_info_pdata),
+			GFP_KERNEL);
+	if (!board_info_pdata) {
+		dev_err(&client->dev, "Failed to allocate pdata\n");
+		return NULL;
+	}
+
+	board_info_pdata->cam1_gpio = of_get_named_gpio(np, "cam1-gpios", 0);
+	board_info_pdata->reset_gpio = of_get_named_gpio(np, "reset-gpios", 0);
+	board_info_pdata->af_gpio = of_get_named_gpio(np, "af-gpios", 0);
+
+	board_info_pdata->power_on = ar1335_power_on;
+	board_info_pdata->power_off = ar1335_power_off;
+
+	return board_info_pdata;
+}
+
+static int
+ar1335_probe(struct i2c_client *client,
+			const struct i2c_device_id *id)
+{
+	struct ar1335_info *info;
+	int err;
+	const char *mclk_name;
+
+	pr_err("[AR1335]: probing sensor.\n");
+
+	info = devm_kzalloc(&client->dev,
+			sizeof(struct ar1335_info), GFP_KERNEL);
+	if (!info) {
+		pr_err("%s:Unable to allocate memory!\n", __func__);
+		return -ENOMEM;
+	}
+
+	info->regmap = devm_regmap_init_i2c(client, &sensor_regmap_config);
+	if (IS_ERR(info->regmap)) {
+		dev_err(&client->dev,
+			"regmap init failed: %ld\n", PTR_ERR(info->regmap));
+		return -ENODEV;
+	}
+
+	if (client->dev.of_node)
+		info->pdata = ar1335_parse_dt(client);
+	else
+		info->pdata = client->dev.platform_data;
+
+	if (!info->pdata) {
+		pr_err("[AR1335]:%s:Unable to get platform data\n", __func__);
+		return -EFAULT;
+	}
+
+	info->i2c_client = client;
+	atomic_set(&info->in_use, 0);
+	info->mode = -1;
+
+	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);
+	}
+
+	ar1335_power_get(info);
+
+	memcpy(&info->miscdev_info,
+		&ar1335_device,
+		sizeof(struct miscdevice));
+
+	err = misc_register(&info->miscdev_info);
+	if (err) {
+		pr_err("%s:Unable to register misc device!\n", __func__);
+		goto ar1335_probe_fail;
+	}
+
+	i2c_set_clientdata(client, info);
+	/* create debugfs interface */
+	ar1335_create_debugfs(info);
+	pr_err("[AR1335]: end of probing sensor.\n");
+	return 0;
+
+ar1335_probe_fail:
+	ar1335_power_put(&info->power);
+
+	return err;
+}
+
+static int
+ar1335_remove(struct i2c_client *client)
+{
+	struct ar1335_info *info;
+	info = i2c_get_clientdata(client);
+	misc_deregister(&ar1335_device);
+
+	ar1335_power_put(&info->power);
+
+	ar1335_remove_debugfs(info);
+	return 0;
+}
+
+static const struct i2c_device_id ar1335_id[] = {
+	{ "ar1335", 0 },
+	{ }
+};
+
+MODULE_DEVICE_TABLE(i2c, ar1335_id);
+
+static struct i2c_driver ar1335_i2c_driver = {
+	.driver = {
+		.name = "ar1335",
+		.owner = THIS_MODULE,
+	},
+	.probe = ar1335_probe,
+	.remove = ar1335_remove,
+	.id_table = ar1335_id,
+};
+
+static int __init ar1335_init(void)
+{
+	pr_info("[AR1335] sensor driver loading\n");
+	return i2c_add_driver(&ar1335_i2c_driver);
+}
+
+static void __exit ar1335_exit(void)
+{
+	i2c_del_driver(&ar1335_i2c_driver);
+}
+
+module_init(ar1335_init);
+module_exit(ar1335_exit);