/* drivers/leds/leds-tps61310.c
 *
 * Copyright (C) 2008-2009 HTC Corporation.
 *
 * 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/i2c.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/workqueue.h>
#include <linux/leds.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/module.h>

#ifdef CONFIG_HAS_EARLYSUSPEND
#include <linux/earlysuspend.h>
#endif

#define FLT_DBG_LOG(fmt, ...) \
		printk(KERN_DEBUG "[FLT]TPS " fmt, ##__VA_ARGS__)
#define FLT_INFO_LOG(fmt, ...) \
		printk(KERN_INFO "[FLT]TPS " fmt, ##__VA_ARGS__)
#define FLT_ERR_LOG(fmt, ...) \
		printk(KERN_ERR "[FLT][ERR]TPS " fmt, ##__VA_ARGS__)

#define FLASHLIGHT_NAME "flashlight"
#define TPS61310_RETRY_COUNT 10

enum flashlight_mode_flags {
	FL_MODE_OFF = 0,
	FL_MODE_TORCH,
	FL_MODE_FLASH,
	FL_MODE_PRE_FLASH,
	FL_MODE_TORCH_LED_A,
	FL_MODE_TORCH_LED_B,
	FL_MODE_TORCH_LEVEL_1,
	FL_MODE_TORCH_LEVEL_2,
	FL_MODE_CAMERA_EFFECT_FLASH,
	FL_MODE_CAMERA_EFFECT_PRE_FLASH,
	FL_MODE_FLASH_LEVEL1,
	FL_MODE_FLASH_LEVEL2,
	FL_MODE_FLASH_LEVEL3,
	FL_MODE_FLASH_LEVEL4,
	FL_MODE_FLASH_LEVEL5,
	FL_MODE_FLASH_LEVEL6,
	FL_MODE_FLASH_LEVEL7,
	FL_MODE_VIDEO_TORCH = 30,
	FL_MODE_VIDEO_TORCH_1,
	FL_MODE_VIDEO_TORCH_2,
	FL_MODE_VIDEO_TORCH_3,
	FL_MODE_VIDEO_TORCH_4,
};

struct TPS61310_flashlight_platform_data {
	void (*gpio_init) (void);
	uint32_t flash_duration_ms;
	uint32_t led_count; /* 0: 1 LED, 1: 2 LED */
	uint32_t tps61310_strb0;
	uint32_t tps61310_strb1;
	uint32_t tps61310_reset;
	uint8_t mode_pin_suspend_state_low;
	uint32_t enable_FLT_1500mA;
	uint32_t disable_tx_mask;
	uint32_t power_save;
	uint32_t power_save_2;
};

struct tps61310_data {
	struct led_classdev 		fl_lcdev;
#ifdef CONFIG_HAS_EARLYSUSPEND
	struct early_suspend		fl_early_suspend;
#endif
	enum flashlight_mode_flags 	mode_status;
	uint32_t			flash_sw_timeout;
	struct mutex 			tps61310_data_mutex;
	uint32_t			strb0;
	uint32_t			strb1;
	uint32_t			reset;
	uint8_t 			led_count;
	uint8_t 			mode_pin_suspend_state_low;
	uint8_t				enable_FLT_1500mA;
	uint8_t				disable_tx_mask;
	uint32_t			power_save;
	uint32_t			power_save_2;
	struct tps61310_led_data	*led_array;
};

static struct i2c_client *this_client;
static struct tps61310_data *this_tps61310;
struct delayed_work tps61310_delayed_work;
static struct workqueue_struct *tps61310_work_queue;
static struct mutex tps61310_mutex;

static int switch_state = 1;
static int retry = 0;
static int reg_init_fail = 0;

static int regaddr = 0x00;
static int regdata = 0x00;
static int reg_buffered[256] = {0x00};

static int tps61310_i2c_command(uint8_t, uint8_t);
static int tps61310_flashlight_control(int);
static int tps61310_flashlight_mode(int);

static ssize_t sw_timeout_show(struct device *dev, struct device_attribute *attr,
		char *buf)
{
	return sprintf(buf, "%d\n", this_tps61310->flash_sw_timeout);
}
static ssize_t sw_timeout_store(
		struct device *dev, struct device_attribute *attr,
		const char *buf, size_t size)
{
	int input;
	sscanf(buf, "%d", &input);
	FLT_INFO_LOG("%s: %d\n",__func__,input);
	this_tps61310->flash_sw_timeout = input;
	return size;
}
static DEVICE_ATTR(sw_timeout, S_IRUGO | S_IWUSR, sw_timeout_show, sw_timeout_store);

static ssize_t regaddr_show(struct device *dev, struct device_attribute *attr,
		char *buf)
{
	return sprintf(buf, "0x%02x\n", regaddr);
}
static ssize_t regaddr_store(
		struct device *dev, struct device_attribute *attr,
		const char *buf, size_t size)
{
	int input;
	sscanf(buf, "%x", &input);
	FLT_INFO_LOG("%s: %d\n",__func__,input);
	regaddr = input;
	return size;
}
static DEVICE_ATTR(regaddr, S_IRUGO | S_IWUSR, regaddr_show, regaddr_store);

static ssize_t regdata_show(struct device *dev, struct device_attribute *attr,
		char *buf)
{
	return sprintf(buf, "0x%02x\n", reg_buffered[regaddr]);
}
static ssize_t regdata_store(
		struct device *dev, struct device_attribute *attr,
		const char *buf, size_t size)
{
	int input;
	sscanf(buf, "%x", &input);
	FLT_INFO_LOG("%s: %d\n",__func__,input);
	regdata = input;

	tps61310_i2c_command(regaddr, regdata);

	return size;
}
static DEVICE_ATTR(regdata, S_IRUGO | S_IWUSR, regdata_show, regdata_store);

static ssize_t switch_show(struct device *dev, struct device_attribute *attr,
		char *buf)
{
	return sprintf(buf, "switch status:%d \n", switch_state);
}

static ssize_t switch_store(
		struct device *dev, struct device_attribute *attr,
		const char *buf, size_t size)
{
	int switch_status;
	switch_status = -1;
	sscanf(buf, "%d ",&switch_status);
	FLT_INFO_LOG("%s: %d\n",__func__,switch_status);
	switch_state = switch_status;
	return size;
}

static DEVICE_ATTR(function_switch, S_IRUGO | S_IWUSR, switch_show, switch_store);

static ssize_t max_current_show(struct device *dev, struct device_attribute *attr,
		char *buf)
{
	if (this_tps61310->enable_FLT_1500mA)
		return sprintf(buf, "1500\n");
	else
		return sprintf(buf, "750\n");
}
static DEVICE_ATTR(max_current, S_IRUGO, max_current_show, NULL);
static ssize_t flash_store(
		struct device *dev, struct device_attribute *attr,
		const char *buf, size_t size)
{
	int val;
	sscanf(buf, "%d ",&val);
	FLT_INFO_LOG("%s: %d\n",__func__,val);
	tps61310_flashlight_mode(val);
	return size;
}
static DEVICE_ATTR(flash, S_IWUSR, NULL, flash_store);

static int TPS61310_I2C_TxData(char *txData, int length)
{
	uint8_t loop_i;
	struct i2c_msg msg[] = {
		{
		 .addr = this_client->addr,
		 .flags = 0,
		 .len = length,
		 .buf = txData,
		 },
	};

	for (loop_i = 0; loop_i < TPS61310_RETRY_COUNT; loop_i++) {
		if (i2c_transfer(this_client->adapter, msg, 1) > 0)
			break;

		mdelay(10);
	}

	if (loop_i >= TPS61310_RETRY_COUNT) {
		FLT_ERR_LOG("%s retry over %d\n", __func__,
							TPS61310_RETRY_COUNT);
		return -EIO;
	}

	return 0;
}

static int tps61310_i2c_command(uint8_t address, uint8_t data)
{
	uint8_t buffer[2];
	int ret;
	int err = 0;

	reg_buffered[address] = data;

	buffer[0] = address;
	buffer[1] = data;
	ret = TPS61310_I2C_TxData(buffer, 2);
	if (ret < 0) {
		FLT_ERR_LOG("%s error\n", __func__);
		if (this_tps61310->reset) {
			FLT_INFO_LOG("reset register");
			gpio_set_value_cansleep(this_tps61310->reset, 0);
			mdelay(10);
			gpio_set_value_cansleep(this_tps61310->reset, 1);
			if (address!=0x07 && address!=0x04) {
				if (this_tps61310->enable_FLT_1500mA) {
					err |= tps61310_i2c_command(0x07, 0x46);
					err |= tps61310_i2c_command(0x04, 0x10);
				} else {
					/* voltage drop monitor*/
					err |= tps61310_i2c_command(0x07, 0xF6);
				}
				if (err)
					reg_init_fail++;
			} else {
				reg_init_fail++;
			}
		}
		return ret;
	}
	return 0;
}

static int flashlight_turn_off(void)
{
	int status;
	FLT_INFO_LOG("%s\n", __func__);
	gpio_set_value_cansleep(this_tps61310->strb0, 0);
	gpio_set_value_cansleep(this_tps61310->strb1, 1);
	tps61310_i2c_command(0x02, 0x08);
	tps61310_i2c_command(0x01, 0x00);
	FLT_INFO_LOG("%s %d\n", __func__,this_tps61310->mode_status);
	/* Avoid current overflow consumption while flash with 1.5A,
	 *  enable/disable moden function
	 */
	if (this_tps61310->power_save) {
		status = this_tps61310->mode_status;
		if (status == 2 || (status >= 10 && status <=16)) {
			FLT_INFO_LOG("Disable power saving\n");
			gpio_set_value_cansleep(this_tps61310->power_save, 0);
		} else if (status == FL_MODE_PRE_FLASH) {
			FLT_INFO_LOG("Enable power saving\n");
			gpio_set_value_cansleep(this_tps61310->power_save, 1);
		}
	}
	if (this_tps61310->power_save_2) {
		status = this_tps61310->mode_status;
		if (status == 2 || (status >= 10 && status <=16)) {
			FLT_INFO_LOG("Disable power saving\n");
			gpio_set_value_cansleep(this_tps61310->power_save_2, 0);
		} else if (status == FL_MODE_PRE_FLASH) {
			FLT_INFO_LOG("Enable power saving\n");
			gpio_set_value_cansleep(this_tps61310->power_save_2, 1);
		}
	}
	this_tps61310->mode_status = FL_MODE_OFF;
	return 0;
}

void retry_flashlight_control(int err, int mode)
{
	if (err && !retry) {
		FLT_INFO_LOG("%s error once\n", __func__);
		retry++;
		mutex_unlock(&tps61310_mutex);
		tps61310_flashlight_control(mode);
		mutex_lock(&tps61310_mutex);
	} else if(err) {
		FLT_INFO_LOG("%s error twice\n", __func__);
		retry = 0;
	}
}

int tps61310_flashlight_mode(int mode)
{
	int err = 0;
	uint8_t current_hex = 0x0;
	FLT_INFO_LOG("camera flash current %d\n", mode);
	mutex_lock(&tps61310_mutex);
	if (this_tps61310->reset && reg_init_fail) {
		reg_init_fail = 0;
		if (this_tps61310->enable_FLT_1500mA) {
			err |= tps61310_i2c_command(0x07, 0x46);
			err |= tps61310_i2c_command(0x04, 0x10);
		} else {
			/* voltage drop monitor*/
			err |= tps61310_i2c_command(0x07, 0xF6);
		}
	}
	if (err) {
		FLT_ERR_LOG("%s error init register\n", __func__);
		reg_init_fail = 0;
		mutex_unlock(&tps61310_mutex);
		return -err;
	}
#if defined CONFIG_FLASHLIGHT_1500mA
	if (mode == 0)
		flashlight_turn_off();
	else if (mode > 0) {
		FLT_INFO_LOG("flash 1.5A\n");
		if (mode >= 750) {
			current_hex = (mode - 750) / 50;
			current_hex += 0x80;
			tps61310_i2c_command(0x05, 0x6F);
			tps61310_i2c_command(0x00, 0x00);
			tps61310_i2c_command(0x01, 0x9E);
			tps61310_i2c_command(0x02, current_hex);
		} else {
			current_hex =  mode / 25;
			current_hex += 0x80;
			tps61310_i2c_command(0x05, 0x6A);
			tps61310_i2c_command(0x00, 0x00);
			tps61310_i2c_command(0x01, current_hex);
		}
		gpio_set_value_cansleep(this_tps61310->strb1, 0);
		gpio_set_value_cansleep(this_tps61310->strb0, 1);
		queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
				   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
	}
#endif
#if !defined CONFIG_FLASHLIGHT_1500mA
	if (mode == 0)
		flashlight_turn_off();
	else if (mode > 0) {
		current_hex =  mode / 25;
		current_hex += 0x80;
		tps61310_i2c_command(0x05, 0x6F);
		tps61310_i2c_command(0x00, 0x00);
		tps61310_i2c_command(0x01, current_hex);
		gpio_set_value_cansleep(this_tps61310->strb1, 0);
		gpio_set_value_cansleep(this_tps61310->strb0, 1);
		queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
				   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
	}
#endif
	mutex_unlock(&tps61310_mutex);
	return 0;
}

int tps61310_flashlight_control(int mode)
{
	int ret = 0;
	int err = 0;

	mutex_lock(&tps61310_mutex);
	if (this_tps61310->reset && reg_init_fail) {
		reg_init_fail = 0;
		if (this_tps61310->enable_FLT_1500mA) {
			err |= tps61310_i2c_command(0x07, 0x46);
			err |= tps61310_i2c_command(0x04, 0x10);
		} else {
			/* voltage drop monitor*/
			err |= tps61310_i2c_command(0x07, 0xF6);
		}
	}
	if (err) {
		FLT_ERR_LOG("%s error init register\n", __func__);
		reg_init_fail = 0;
		mutex_unlock(&tps61310_mutex);
		return -err;
	}
	if (this_tps61310->led_count == 1) {
		if (this_tps61310->enable_FLT_1500mA) {
#if defined CONFIG_FLASHLIGHT_1500mA
			switch (mode) {
			case FL_MODE_OFF:
				flashlight_turn_off();
			break;
			case FL_MODE_FLASH:
				FLT_INFO_LOG("flash 1.5A\n");
				tps61310_i2c_command(0x05, 0x6F);
				tps61310_i2c_command(0x00, 0x00);
				tps61310_i2c_command(0x01, 0x9E);
				tps61310_i2c_command(0x02, 0x8F);
				gpio_set_value_cansleep(this_tps61310->strb1, 0);
				gpio_set_value_cansleep(this_tps61310->strb0, 1);
				queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
						   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL1:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x86);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL2:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x88);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL3:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x8C);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL4:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x90);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL5:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x94);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL6:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x98);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL7:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x9C);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_PRE_FLASH:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x04);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_VIDEO_TORCH:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x04);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_VIDEO_TORCH_1:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x01);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_VIDEO_TORCH_2:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x02);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_VIDEO_TORCH_3:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x03);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_VIDEO_TORCH_4:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x04);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_TORCH:
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				err |= tps61310_i2c_command(0x05, 0x6A);
				err |= tps61310_i2c_command(0x00, 0x05);
				err |= tps61310_i2c_command(0x01, 0x40);
				if (this_tps61310->reset)
					retry_flashlight_control(err, mode);
			break;
			case FL_MODE_TORCH_LEVEL_1:
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				err |= tps61310_i2c_command(0x05, 0x6A);
				err |= tps61310_i2c_command(0x00, 0x01);
				err |= tps61310_i2c_command(0x01, 0x40);
				if (this_tps61310->reset)
					retry_flashlight_control(err, mode);
			break;
			case FL_MODE_TORCH_LEVEL_2:
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				err |= tps61310_i2c_command(0x05, 0x6A);
				err |= tps61310_i2c_command(0x00, 0x03);
				err |= tps61310_i2c_command(0x01, 0x40);
				if (this_tps61310->reset)
					retry_flashlight_control(err, mode);
			break;
			default:
				FLT_ERR_LOG("%s: unknown flash_light flags: %d\n",
									__func__, mode);
				ret = -EINVAL;
			break;
			}
#endif
		} else {
#if !defined CONFIG_FLASHLIGHT_1500mA
			switch (mode) {
			case FL_MODE_OFF:
				flashlight_turn_off();
			break;
			case FL_MODE_FLASH:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x00);
				tps61310_i2c_command(0x01, 0x9E);
				gpio_set_value_cansleep(this_tps61310->strb1, 0);
				gpio_set_value_cansleep(this_tps61310->strb0, 1);
				queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
						   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL1:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x86);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL2:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x88);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL3:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x8C);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL4:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x90);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL5:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x94);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL6:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x98);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_FLASH_LEVEL7:
					tps61310_i2c_command(0x05, 0x6A);
					tps61310_i2c_command(0x00, 0x00);
					tps61310_i2c_command(0x01, 0x9C);
					gpio_set_value_cansleep(this_tps61310->strb1, 0);
					gpio_set_value_cansleep(this_tps61310->strb0, 1);
					queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
							   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
			break;
			case FL_MODE_PRE_FLASH:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x04);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_VIDEO_TORCH:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x04);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_VIDEO_TORCH_1:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x01);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_VIDEO_TORCH_2:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x02);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_VIDEO_TORCH_3:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x03);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_VIDEO_TORCH_4:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x04);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_TORCH:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x05);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_TORCH_LEVEL_1:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x01);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			case FL_MODE_TORCH_LEVEL_2:
				tps61310_i2c_command(0x05, 0x6A);
				tps61310_i2c_command(0x00, 0x03);
				gpio_set_value_cansleep(this_tps61310->strb0, 0);
				gpio_set_value_cansleep(this_tps61310->strb1, 1);
				tps61310_i2c_command(0x01, 0x40);
			break;
			default:
				FLT_ERR_LOG("%s: unknown flash_light flags: %d\n",
									__func__, mode);
				ret = -EINVAL;
			break;
			}
#endif
		}
	} else if (this_tps61310->led_count == 2) {
#if defined CONFIG_TWO_FLASHLIGHT
	switch (mode) {
	case FL_MODE_OFF:
		flashlight_turn_off();
	break;
	case FL_MODE_FLASH:
		tps61310_i2c_command(0x05, 0x6B);
		tps61310_i2c_command(0x00, 0x00);
		tps61310_i2c_command(0x02, 0x90);
		tps61310_i2c_command(0x01, 0x90);
		gpio_set_value_cansleep(this_tps61310->strb1, 0);
		gpio_set_value_cansleep(this_tps61310->strb0, 1);
		queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
				   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
	break;
	case FL_MODE_FLASH_LEVEL1:
			tps61310_i2c_command(0x05, 0x6B);
			tps61310_i2c_command(0x00, 0x00);
			tps61310_i2c_command(0x02, 0x83);
			tps61310_i2c_command(0x01, 0x83);
			gpio_set_value_cansleep(this_tps61310->strb1, 0);
			gpio_set_value_cansleep(this_tps61310->strb0, 1);
			queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
					   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
	break;
	case FL_MODE_FLASH_LEVEL2:
			tps61310_i2c_command(0x05, 0x6B);
			tps61310_i2c_command(0x00, 0x00);
			tps61310_i2c_command(0x02, 0x84);
			tps61310_i2c_command(0x01, 0x84);
			gpio_set_value_cansleep(this_tps61310->strb1, 0);
			gpio_set_value_cansleep(this_tps61310->strb0, 1);
			queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
					   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
	break;
	case FL_MODE_FLASH_LEVEL3:
			tps61310_i2c_command(0x05, 0x6B);
			tps61310_i2c_command(0x00, 0x00);
			tps61310_i2c_command(0x02, 0x86);
			tps61310_i2c_command(0x01, 0x86);
			gpio_set_value_cansleep(this_tps61310->strb1, 0);
			gpio_set_value_cansleep(this_tps61310->strb0, 1);
			queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
					   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
	break;
	case FL_MODE_FLASH_LEVEL4:
			tps61310_i2c_command(0x05, 0x6B);
			tps61310_i2c_command(0x00, 0x00);
			tps61310_i2c_command(0x02, 0x88);
			tps61310_i2c_command(0x01, 0x88);
			gpio_set_value_cansleep(this_tps61310->strb1, 0);
			gpio_set_value_cansleep(this_tps61310->strb0, 1);
			queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
					   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
	break;
	case FL_MODE_FLASH_LEVEL5:
			tps61310_i2c_command(0x05, 0x6B);
			tps61310_i2c_command(0x00, 0x00);
			tps61310_i2c_command(0x02, 0x8A);
			tps61310_i2c_command(0x01, 0x8A);
			gpio_set_value_cansleep(this_tps61310->strb1, 0);
			gpio_set_value_cansleep(this_tps61310->strb0, 1);
			queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
					   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
	break;
	case FL_MODE_FLASH_LEVEL6:
			tps61310_i2c_command(0x05, 0x6B);
			tps61310_i2c_command(0x00, 0x00);
			tps61310_i2c_command(0x02, 0x8C);
			tps61310_i2c_command(0x01, 0x8C);
			gpio_set_value_cansleep(this_tps61310->strb1, 0);
			gpio_set_value_cansleep(this_tps61310->strb0, 1);
			queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
					   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
	break;
	case FL_MODE_FLASH_LEVEL7:
			tps61310_i2c_command(0x05, 0x6B);
			tps61310_i2c_command(0x00, 0x00);
			tps61310_i2c_command(0x02, 0x8E);
			tps61310_i2c_command(0x01, 0x8E);
			gpio_set_value_cansleep(this_tps61310->strb1, 0);
			gpio_set_value_cansleep(this_tps61310->strb0, 1);
			queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
					   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
	break;
	case FL_MODE_PRE_FLASH:
		tps61310_i2c_command(0x05, 0x6B);
		tps61310_i2c_command(0x00, 0x12);
		gpio_set_value_cansleep(this_tps61310->strb0, 0);
		gpio_set_value_cansleep(this_tps61310->strb1, 1);
		tps61310_i2c_command(0x01, 0x40);
	break;
	case FL_MODE_VIDEO_TORCH:
		tps61310_i2c_command(0x05, 0x6B);
		tps61310_i2c_command(0x00, 0x12);
		gpio_set_value_cansleep(this_tps61310->strb0, 0);
		gpio_set_value_cansleep(this_tps61310->strb1, 1);
		tps61310_i2c_command(0x01, 0x40);
	break;
	case FL_MODE_TORCH:
		tps61310_i2c_command(0x05, 0x6B);
		tps61310_i2c_command(0x00, 0x1B);
		gpio_set_value_cansleep(this_tps61310->strb0, 0);
		gpio_set_value_cansleep(this_tps61310->strb1, 1);
		tps61310_i2c_command(0x01, 0x40);
	break;
	case FL_MODE_TORCH_LEVEL_1:
		tps61310_i2c_command(0x05, 0x6B);
		tps61310_i2c_command(0x00, 0x09);
		gpio_set_value_cansleep(this_tps61310->strb0, 0);
		gpio_set_value_cansleep(this_tps61310->strb1, 1);
		tps61310_i2c_command(0x01, 0x40);
	break;
	case FL_MODE_TORCH_LEVEL_2:
		tps61310_i2c_command(0x05, 0x6B);
		tps61310_i2c_command(0x00, 0x12);
		gpio_set_value_cansleep(this_tps61310->strb0, 0);
		gpio_set_value_cansleep(this_tps61310->strb1, 1);
		tps61310_i2c_command(0x01, 0x40);
	break;
	case FL_MODE_TORCH_LED_A:
		tps61310_i2c_command(0x05, 0x69);
		tps61310_i2c_command(0x00, 0x09);
		gpio_set_value_cansleep(this_tps61310->strb0, 0);
		gpio_set_value_cansleep(this_tps61310->strb1, 1);
		tps61310_i2c_command(0x01, 0x40);
	break;
	case FL_MODE_TORCH_LED_B:
		tps61310_i2c_command(0x05, 0x6A);
		tps61310_i2c_command(0x00, 0x09);
		gpio_set_value_cansleep(this_tps61310->strb0, 0);
		gpio_set_value_cansleep(this_tps61310->strb1, 1);
		tps61310_i2c_command(0x01, 0x40);
	break;

	default:
		FLT_ERR_LOG("%s: unknown flash_light flags: %d\n",
							__func__, mode);
		ret = -EINVAL;
	break;
	}
#endif
		}

	FLT_INFO_LOG("%s: mode: %d\n", __func__, mode);
	this_tps61310->mode_status = mode;
	mutex_unlock(&tps61310_mutex);

	return ret;
}

static void fl_lcdev_brightness_set(struct led_classdev *led_cdev,
						enum led_brightness brightness)
{
	enum flashlight_mode_flags mode;
	int ret = -1;


	if (brightness > 0 && brightness <= LED_HALF) {
		if (brightness == (LED_HALF - 2))
			mode = FL_MODE_TORCH_LEVEL_1;
		else if (brightness == (LED_HALF - 1))
			mode = FL_MODE_TORCH_LEVEL_2;
		else if (brightness == 1 && this_tps61310->led_count ==2)
			mode = FL_MODE_TORCH_LED_A;
		else if (brightness == 2 && this_tps61310->led_count ==2)
			mode = FL_MODE_TORCH_LED_B;
		else
			mode = FL_MODE_TORCH;
	} else if (brightness > LED_HALF && brightness <= LED_FULL) {
		if (brightness == (LED_HALF + 1))
			mode = FL_MODE_PRE_FLASH; /* pre-flash mode */
		else if (brightness == (LED_HALF + 3))
			mode = FL_MODE_FLASH_LEVEL1; /* Flashlight mode LEVEL1*/
		else if (brightness == (LED_HALF + 4))
			mode = FL_MODE_FLASH_LEVEL2; /* Flashlight mode LEVEL2*/
		else if (brightness == (LED_HALF + 5))
			mode = FL_MODE_FLASH_LEVEL3; /* Flashlight mode LEVEL3*/
		else if (brightness == (LED_HALF + 6))
			mode = FL_MODE_FLASH_LEVEL4; /* Flashlight mode LEVEL4*/
		else if (brightness == (LED_HALF + 7))
			mode = FL_MODE_FLASH_LEVEL5; /* Flashlight mode LEVEL5*/
		else if (brightness == (LED_HALF + 8))
			mode = FL_MODE_FLASH_LEVEL6; /* Flashlight mode LEVEL6*/
		else if (brightness == (LED_HALF + 9))
			mode = FL_MODE_FLASH_LEVEL7; /* Flashlight mode LEVEL7*/
		else
			mode = FL_MODE_FLASH; /* Flashlight mode */
	} else
		/* off and else */
		mode = FL_MODE_OFF;

	if ((mode != FL_MODE_OFF) && switch_state == 0){
		FLT_INFO_LOG("%s flashlight is disabled by switch, mode = %d\n",__func__, mode);
		return;
	}

	retry = 0;
	ret = tps61310_flashlight_control(mode);
	if (ret) {
		FLT_ERR_LOG("%s: control failure rc:%d\n", __func__, ret);
		return;
	}
}

#ifdef CONFIG_HAS_EARLYSUSPEND
static void flashlight_early_suspend(struct early_suspend *handler)
{
	FLT_INFO_LOG("%s\n", __func__);
	if (this_tps61310->mode_status)
		flashlight_turn_off();
	if (this_tps61310->power_save)
		gpio_set_value_cansleep(this_tps61310->power_save, 0);
	if (this_tps61310->power_save_2)
		gpio_set_value_cansleep(this_tps61310->power_save_2, 0);
}

static void flashlight_late_resume(struct early_suspend *handler)
{
}
#endif

static void flashlight_turn_off_work(struct work_struct *work)
{
	FLT_INFO_LOG("%s\n", __func__);
	flashlight_turn_off();
}

static int tps61310_parse_dt(struct device *dev, struct TPS61310_flashlight_platform_data *pdata)
{
	struct property *prop;
	struct device_node *dt = dev->of_node;
	prop = of_find_property(dt, "tps61310,tps61310_strb0", NULL);
	if (prop) {
		pdata->tps61310_strb0 = of_get_named_gpio(dt, "tps61310,tps61310_strb0", 0);
	}
	prop = of_find_property(dt, "tps61310,tps61310_strb1", NULL);
	if (prop) {
		pdata->tps61310_strb1 = of_get_named_gpio(dt, "tps61310,tps61310_strb1", 0);
	}
	prop = of_find_property(dt, "tps61310,flash_duration_ms", NULL);
	if (prop) {
		of_property_read_u32(dt, "tps61310,flash_duration_ms", &pdata->flash_duration_ms);
	}
	prop = of_find_property(dt, "tps61310,enable_FLT_1500mA", NULL);
	if (prop) {
		of_property_read_u32(dt, "tps61310,enable_FLT_1500mA", &pdata->enable_FLT_1500mA);
	}
	prop = of_find_property(dt, "tps61310,led_count", NULL);
	if (prop) {
		of_property_read_u32(dt, "tps61310,led_count", &pdata->led_count);
	}
	prop = of_find_property(dt, "tps61310,disable_tx_mask", NULL);
	if (prop) {
		of_property_read_u32(dt, "tps61310,disable_tx_mask", &pdata->disable_tx_mask);
	}

	return 0;

}

enum led_status {
	OFF = 0,
	ON,
	BLINK,
};

enum led_id {
	LED_2   = 0,
	LED_1_3 = 1,
};

struct tps61310_led_data {
	u8			num_leds;
	struct i2c_client	*client_dev;
	struct tps61310_data 	*tps61310;
	int status;
	struct led_classdev	cdev;
	int			max_current;
	int			id;
	u8			default_state;
	int                     torch_mode;
	struct mutex		lock;
	struct work_struct	work;
};

static int tps61310_get_common_configs(struct tps61310_led_data *led,
		struct device_node *node)
{
	int rc;
	const char *temp_string;

	led->cdev.default_trigger = "none";
	rc = of_property_read_string(node, "linux,default-trigger",
		&temp_string);
	if (!rc)
		led->cdev.default_trigger = temp_string;
	else if (rc != -EINVAL)
		return rc;

	led->default_state = LEDS_GPIO_DEFSTATE_OFF;
	rc = of_property_read_string(node, "default-state",
		&temp_string);
	if (!rc) {
		if (!strcmp(temp_string, "keep"))
			led->default_state = LEDS_GPIO_DEFSTATE_KEEP;
		else if (!strcmp(temp_string, "on"))
			led->default_state = LEDS_GPIO_DEFSTATE_ON;
		else
			led->default_state = LEDS_GPIO_DEFSTATE_OFF;
	} else if (rc != -EINVAL)
		return rc;

	return 0;
}

static int tps61310_error_recover(void)
{
	int err = 0;
	if (this_tps61310->reset && reg_init_fail) {
		reg_init_fail = 0;
		if (this_tps61310->enable_FLT_1500mA) {
			err |= tps61310_i2c_command(0x07, 0x46);
			err |= tps61310_i2c_command(0x04, 0x10);
		} else {
			/* voltage drop monitor*/
			err |= tps61310_i2c_command(0x07, 0xF6);
		}
	}
	if (err) {
		FLT_ERR_LOG("%s error init register\n", __func__);
		reg_init_fail = 0;
		return -err;
	}

	return err;
}

static void tps61310_flash_strb(void)
{
	gpio_set_value_cansleep(this_tps61310->strb1, 0);
	gpio_set_value_cansleep(this_tps61310->strb0, 1);
	queue_delayed_work(tps61310_work_queue, &tps61310_delayed_work,
			   msecs_to_jiffies(this_tps61310->flash_sw_timeout));
}

static void tps61310_torch_strb(void)
{
	gpio_set_value_cansleep(this_tps61310->strb0, 0);
	gpio_set_value_cansleep(this_tps61310->strb1, 1);
	tps61310_i2c_command(0x01, 0x40);
}

static int tps61310_flash_set(struct tps61310_led_data *led,
				enum led_brightness value)
{
	int err = 0;
	uint8_t current_hex = 0x0;

	FLT_INFO_LOG("flash set:%d\n", value);

	mutex_lock(&tps61310_mutex);
	err = tps61310_error_recover();
	if ( err ) {
		mutex_unlock(&tps61310_mutex);
		return err;
	}

	if ( value == 0 )
		flashlight_turn_off();
	else if ( value > 0 ) {
		uint8_t enled = 0x68;
		switch (led->id)
		{
		case LED_2:
			current_hex = value / 25;
			current_hex += 0x80;
			enled |= 0x02;
			tps61310_i2c_command(0x05, enled);
			tps61310_i2c_command(0x00, 0x00);
			tps61310_i2c_command(0x01, current_hex);
			printk(KERN_INFO "[FLT]"
					"set led2 current to 0x%x.\r\n", current_hex);
			break;
		case LED_1_3:
			current_hex = value / 50;
			current_hex += 0x80;
			enled |= 0x05;
			tps61310_i2c_command(0x05, enled);
			tps61310_i2c_command(0x00, 0x00);
			tps61310_i2c_command(0x02, current_hex);
			printk(KERN_INFO "[FLT]"
					"set led13 current to 0x%x.\r\n", current_hex);
			break;
		}

		tps61310_flash_strb();
	}

	mutex_unlock(&tps61310_mutex);
	return err;
}

static int tps61310_torch_set(struct tps61310_led_data *led,
				enum led_brightness value)
{
	int err = 0;
	uint8_t current_hex = 0x0;

	FLT_INFO_LOG("torch set:%d\n", value);

	mutex_lock(&tps61310_mutex);
	err = tps61310_error_recover();
	if ( err ) {
		mutex_unlock(&tps61310_mutex);
		return err;
	}

	if ( value == 0 )
		flashlight_turn_off();
	else if ( value > 0 ) {
		switch (led->id) {
		case LED_2:
			current_hex = (value / 25) & 0x07;
			tps61310_i2c_command(0x05, 0x6A);
			tps61310_i2c_command(0x00, current_hex);
			break;
		case LED_1_3:
			current_hex = ((value / 50) << 3) & 0x38;
			tps61310_i2c_command(0x05, 0x6B);
			tps61310_i2c_command(0x00, current_hex);
			break;
		};

		tps61310_torch_strb();
	}

	mutex_unlock(&tps61310_mutex);
	return err;
}

static void __tps61310_led_work(struct tps61310_led_data *led,
				enum led_brightness value)
{
	mutex_lock(&led->lock);
	if ( led->torch_mode ) {
		switch (led->id) {
		case LED_2:
			tps61310_torch_set(led, value);
			break;
		case LED_1_3:
			tps61310_torch_set(led, value);
			break;
		};
	} else {
		switch (led->id) {
		case LED_2:
			tps61310_flash_set(led, value);
			break;
		case LED_1_3:
			tps61310_flash_set(led, value);
			break;
		};
	}
	mutex_unlock(&led->lock);
}

static void tps61310_led_work(struct work_struct *work)
{
	struct tps61310_led_data *led = container_of(work,
					struct tps61310_led_data, work);

	__tps61310_led_work(led, led->cdev.brightness);

	return;
}

static void tps61310_led_set(struct led_classdev *led_cdev,
				enum led_brightness value)
{
	struct tps61310_led_data *led;

	led = container_of(led_cdev, struct tps61310_led_data, cdev);
	if (value < LED_OFF || value > led->cdev.max_brightness) {
		printk(KERN_ERR "[FLT]"
				"Invalid brightness value\n");
		return;
	}

	led->cdev.brightness = value;
	schedule_work(&led->work);
}

static enum led_brightness tps61310_led_get(struct led_classdev *led_cdev)
{
	struct tps61310_led_data *led;

	led = container_of(led_cdev, struct tps61310_led_data, cdev);

	return led->cdev.brightness;
}

static int tps61310_probe(struct i2c_client *client,
					const struct i2c_device_id *id)
{
	struct tps61310_data *tps61310;
	struct TPS61310_flashlight_platform_data *pdata;
	int i = 0;

	struct tps61310_led_data *led, *led_array;
	struct device_node *node, *temp;
	int num_leds = 0, parsed_leds = 0;
	const char *led_label;
	int rc;

	tps61310 = NULL;
	pdata = NULL;

	FLT_INFO_LOG("%s +\n", __func__);
	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
	if (pdata == NULL) {
		FLT_ERR_LOG("%s: kzalloc pdata fail !!!\n", __func__);
		rc = -ENOMEM;
		goto fail_allocate_memory;
	}
	rc = tps61310_parse_dt(&client->dev, pdata);

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		FLT_ERR_LOG("%s: i2c check fail !!!\n", __func__);
		rc = -ENODEV;
		goto fail_allocate_memory;
	}

	tps61310 = kzalloc(sizeof(struct tps61310_data), GFP_KERNEL);
	if (!tps61310) {
		FLT_ERR_LOG("%s: kzalloc data fail !!!\n", __func__);
		rc = -ENOMEM;
		goto fail_allocate_memory;
	}

	i2c_set_clientdata(client, tps61310);
	this_client = client;

	INIT_DELAYED_WORK(&tps61310_delayed_work, flashlight_turn_off_work);
	tps61310_work_queue = create_singlethread_workqueue("tps61310_wq");
	if (!tps61310_work_queue)
		goto err_create_tps61310_work_queue;

	tps61310->fl_lcdev.name              = FLASHLIGHT_NAME;
	tps61310->fl_lcdev.brightness_set    = fl_lcdev_brightness_set;
	tps61310->strb0                      = pdata->tps61310_strb0;
	tps61310->strb1                      = pdata->tps61310_strb1;
	tps61310->reset                      = pdata->tps61310_reset;
	tps61310->flash_sw_timeout           = pdata->flash_duration_ms;
	tps61310->led_count                  = (pdata->led_count) ? pdata->led_count : 1;
	tps61310->mode_pin_suspend_state_low = pdata->mode_pin_suspend_state_low;
	tps61310->enable_FLT_1500mA          = pdata->enable_FLT_1500mA;
	tps61310->disable_tx_mask            = pdata->disable_tx_mask;
	tps61310->power_save                 = pdata->power_save;
	tps61310->power_save_2               = pdata->power_save_2;

	if (tps61310->strb0) {
		rc = gpio_request(tps61310->strb0, "strb0");
		if (rc) {
			FLT_ERR_LOG("%s: unable to request gpio %d (%d)\n",
				__func__, tps61310->strb0, rc);
			goto fail_allocate_resource;
		}

		rc = gpio_direction_output(tps61310->strb0, 0);
		if (rc) {
			FLT_ERR_LOG("%s: Unable to set direction (%d)\n", __func__, rc);
			goto fail_allocate_resource;
		}
	}
	if (tps61310->strb1) {
		rc = gpio_request(tps61310->strb1, "strb1");
		if (rc) {
			FLT_ERR_LOG("%s: unable to request gpio %d (%d)\n",
				__func__, tps61310->strb1, rc);
			goto fail_allocate_resource;
		}

		rc = gpio_direction_output(tps61310->strb1, 1);
		if (rc) {
			FLT_ERR_LOG("%s: Unable to set direction (%d)\n", __func__, rc);
			goto fail_allocate_resource;
		}
	}
	if (tps61310->flash_sw_timeout <= 0)
		tps61310->flash_sw_timeout = 600;

	node = client->dev.of_node;

	if (node == NULL) {
		rc = -ENODEV;
		goto fail_parsing_of_node;
	}

	temp = NULL;
	while ((temp = of_get_next_child(node, temp)))
		num_leds++;

	if (!num_leds) {
		rc = -ECHILD;
		goto fail_parsing_of_node;
	}

	led_array = devm_kzalloc(&client->dev,
		(sizeof(struct tps61310_led_data) * num_leds), GFP_KERNEL);
	if (!led_array) {
		dev_err(&client->dev, "Unable to allocate memory\n");
		rc = -ENOMEM;
		goto fail_parsing_of_node;
	}

	tps61310->led_array = led_array;
	for_each_child_of_node(node, temp) {
		led = &led_array[parsed_leds];
		led->num_leds = num_leds;
		led->client_dev = client;
		led->tps61310 = tps61310;
		led->status = OFF;

		rc = of_property_read_string(temp, "label", &led_label);
		if (rc < 0) {
			printk(KERN_ERR "[FLT] "
				"Failure reading label, rc = %d\n", rc);
			goto fail_id_check;
		}

		rc = of_property_read_string(temp, "linux,name", &led->cdev.name);
		if (rc < 0) {
			printk(KERN_ERR "[FLT] "
				"Failure reading led name, rc = %d\n", rc);
			goto fail_id_check;
		}

		rc = of_property_read_u32(temp, "max-current", &led->max_current);
		if (rc < 0) {
			printk(KERN_ERR "[FLT] "
				"Failure reading max_current, rc =  %d\n", rc);
			goto fail_id_check;
		}

		rc = of_property_read_u32(temp, "id", &led->id);
		if (rc < 0) {
			printk(KERN_ERR "[FLT] "
				"Failure reading led id, rc =  %d\n", rc);
			goto fail_id_check;
		}

		rc = tps61310_get_common_configs(led, temp);
		if (rc) {
			printk(KERN_ERR "[FLT] "
				"Failure reading common led configuration," \
				" rc = %d\n", rc);
			goto fail_id_check;
		}

		led->cdev.brightness_set    = tps61310_led_set;
		led->cdev.brightness_get    = tps61310_led_get;

		if (strncmp(led_label, "flash", sizeof("flash")) == 0) {
			led->torch_mode = 0;
			if (rc < 0) {
				printk(KERN_ERR "[FLT] "
					"Unable to read flash config data\n");
				goto fail_id_check;
			}
		} else if (strncmp(led_label, "torch", sizeof("torch")) == 0) {
			led->torch_mode = 1;
			if (rc < 0) {
				printk(KERN_ERR "[FLT] "
					"Unable to read torch config data\n");
				goto fail_id_check;
			}
		} else {
			printk(KERN_ERR "[FLT] "
				"No LED matching label\n");
			rc = -EINVAL;
			goto fail_id_check;
		}

		mutex_init(&led->lock);
		INIT_WORK(&led->work, tps61310_led_work);

		led->cdev.max_brightness = led->max_current;

		rc = led_classdev_register(&client->dev, &led->cdev);
		if (rc) {
			printk(KERN_ERR "[FLT] "
					"unable to register led %d,rc=%d\n",
					led->id, rc);
			goto fail_id_check;
		}

		/* configure default state */
		switch (led->default_state) {
			case LEDS_GPIO_DEFSTATE_OFF:
				led->cdev.brightness = LED_OFF;
				break;
			case LEDS_GPIO_DEFSTATE_ON:
				led->cdev.brightness = led->cdev.max_brightness;
				__tps61310_led_work(led, led->cdev.brightness);
				schedule_work(&led->work);
				break;
			case LEDS_GPIO_DEFSTATE_KEEP:
				led->cdev.brightness = led->cdev.max_brightness;
				break;
		}

		parsed_leds++;
	}

	mutex_init(&tps61310_mutex);
	rc = led_classdev_register(&client->dev, &tps61310->fl_lcdev);
	if (rc < 0) {
		FLT_ERR_LOG("%s: failed on led_classdev_register (%d)\n", __func__, rc);
		goto platform_data_null;
	}

	this_tps61310 = tps61310;

#ifdef CONFIG_HAS_EARLYSUSPEND
	tps61310->fl_early_suspend.suspend = flashlight_early_suspend;
	tps61310->fl_early_suspend.resume  = flashlight_late_resume;
	register_early_suspend(&tps61310->fl_early_suspend);
#endif

	rc = device_create_file(tps61310->fl_lcdev.dev, &dev_attr_sw_timeout);
	if (rc < 0) {
		FLT_ERR_LOG("%s, create sw_timeout sysfs fail\n", __func__);
	}
	rc = device_create_file(tps61310->fl_lcdev.dev, &dev_attr_regaddr);
	if (rc < 0) {
		FLT_ERR_LOG("%s, create regaddr sysfs fail\n", __func__);
	}
	rc = device_create_file(tps61310->fl_lcdev.dev, &dev_attr_regdata);
	if (rc < 0) {
		FLT_ERR_LOG("%s, create regdata sysfs fail\n", __func__);
	}
	rc = device_create_file(tps61310->fl_lcdev.dev, &dev_attr_function_switch);
	if (rc < 0) {
		FLT_ERR_LOG("%s, create function_switch sysfs fail\n", __func__);
	}
	rc = device_create_file(tps61310->fl_lcdev.dev, &dev_attr_max_current);
	if (rc < 0) {
		FLT_ERR_LOG("%s, create max_current sysfs fail\n", __func__);
	}
	rc = device_create_file(tps61310->fl_lcdev.dev, &dev_attr_flash);
	if (rc < 0) {
		FLT_ERR_LOG("%s, create max_current sysfs fail\n", __func__);
	}
	/* initial register set as shutdown mode */
	tps61310_i2c_command(0x01, 0x00);

	if (this_tps61310->enable_FLT_1500mA) {
		FLT_INFO_LOG("Flashlight with 1.5A\n");
		tps61310_i2c_command(0x07, 0x46);
		tps61310_i2c_command(0x04, 0x10);
	} else {
		/* disable voltage drop monitor */
		tps61310_i2c_command(0x07, 0x76);
	}
	/* Disable Tx-mask for issue of can flash while using lower band radio */
	if (this_tps61310->disable_tx_mask)
		tps61310_i2c_command(0x03, 0xC0);
	if (this_tps61310->reset)
		FLT_INFO_LOG("%s reset pin exist\n", __func__);
	else
		FLT_INFO_LOG("%s no reset pin\n", __func__);
	if (this_tps61310->power_save) {
		FLT_INFO_LOG("%s power save pin exist\n", __func__);
		gpio_set_value_cansleep(this_tps61310->power_save, 0);
	}
	else
		FLT_INFO_LOG("%s no power save pin\n", __func__);
	if (this_tps61310->power_save_2) {
		FLT_INFO_LOG("%s power save pin_2 exist\n", __func__);
		gpio_set_value_cansleep(this_tps61310->power_save_2, 0);
	}
	else
		FLT_INFO_LOG("%s no power save pin_2\n", __func__);

	FLT_INFO_LOG("%s -\n", __func__);

	if (pdata) kfree(pdata);
	return 0;

platform_data_null:
	destroy_workqueue(tps61310_work_queue);
	mutex_destroy(&tps61310_mutex);
fail_id_check:
	for (i = 0; i < parsed_leds; i++) {
		mutex_destroy(&led_array[i].lock);
		led_classdev_unregister(&led_array[i].cdev);
	}
fail_parsing_of_node:
	if (tps61310->strb1) {
		gpio_free(tps61310->strb1);
	}
	if (tps61310->strb0) {
		gpio_free(tps61310->strb0);
	}
fail_allocate_resource:
err_create_tps61310_work_queue:
fail_allocate_memory:
	if (tps61310) kfree(tps61310);

	if (pdata) kfree(pdata);
	return rc;
}

static int tps61310_remove(struct i2c_client *client)
{
	struct tps61310_data *tps61310 = i2c_get_clientdata(client);
	struct tps61310_led_data *led_array = tps61310->led_array;

	if (led_array) {
		int i, parsed_leds = led_array->num_leds;
		for (i=0; i<parsed_leds; i++) {
			cancel_work_sync(&led_array[i].work);
			mutex_destroy(&led_array[i].lock);
			led_classdev_unregister(&led_array[i].cdev);
		}
	}

#ifdef CONFIG_HAS_EARLYSUSPEND
	unregister_early_suspend(&tps61310->fl_early_suspend);
#endif

	destroy_workqueue(tps61310_work_queue);
	mutex_destroy(&tps61310_mutex);
	led_classdev_unregister(&tps61310->fl_lcdev);

	if (tps61310->strb1) {
		gpio_free(tps61310->strb1);
	}
	if (tps61310->strb0) {
		gpio_free(tps61310->strb0);
	}

	kfree(tps61310);

	FLT_INFO_LOG("%s:\n", __func__);
	return 0;
}

static const struct i2c_device_id tps61310_id[] = {
	{ "tps61310", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, tps61310_id);
static int tps61310_resume(struct i2c_client *client)
{

		FLT_INFO_LOG("%s:\n", __func__);
		if (this_tps61310->mode_pin_suspend_state_low)
			gpio_set_value_cansleep(this_tps61310->strb1, 1);
		return 0;
}
static int tps61310_suspend(struct i2c_client *client, pm_message_t state)
{

		FLT_INFO_LOG("%s:\n", __func__);
		if (this_tps61310->mode_pin_suspend_state_low)
			gpio_set_value_cansleep(this_tps61310->strb1, 0);

		return 0;
}

static const struct of_device_id tps61310_mttable[] = {
	{ .compatible = "ti,tps61310"},
	{ },
};

static struct i2c_driver tps61310_driver = {
	.driver		= {
		.name = "tps61310",
		.owner = THIS_MODULE,
		.of_match_table = tps61310_mttable,
	},
	.probe		= tps61310_probe,
	.remove		= tps61310_remove,
	.suspend	= tps61310_suspend,
	.resume		= tps61310_resume,
	.id_table = tps61310_id,
};
module_i2c_driver(tps61310_driver);

MODULE_DESCRIPTION("TPS61310 Led Flash driver");
MODULE_LICENSE("GPL");