drivers/power/smb349.c - fp2-dev/kernel/msm - Gitiles

 /* Copyright (c) 2012 The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * 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.
  *
  */
 #define pr_fmt(fmt)	"%s: " fmt, __func__

 #include <linux/i2c.h>
 #include <linux/gpio.h>
 #include <linux/errno.h>
 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/debugfs.h>
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/i2c/smb349.h>
 #include <linux/power_supply.h>

 #define SMB349_MASK(BITS, POS)  ((unsigned char)(((1 << BITS) - 1) << POS))

 /* Register definitions */
 #define CHG_CURRENT_REG			0x00
 #define CHG_OTHER_CURRENT_REG	0x01
 #define VAR_FUNC_REG			0x02
 #define FLOAT_VOLTAGE_REG		0x03
 #define CHG_CTRL_REG			0x04
 #define STAT_TIMER_REG			0x05
 #define PIN_ENABLE_CTRL_REG		0x06
 #define THERM_CTRL_A_REG		0x07
 #define SYSOK_USB3_SELECT_REG	0x08
 #define CTRL_FUNCTIONS_REG		0x09
 #define OTG_TLIM_THERM_CNTRL_REG	0x0A
 #define HARD_SOFT_LIMIT_CELL_TEMP_MONITOR_REG 0x0B
 #define FAULT_IRQ_REG	0x0C
 #define STATUS_IRQ_REG	0x0D
 #define SYSOK_REG		0x0E
 #define CMD_A_REG		0x30
 #define CMD_B_REG		0x31
 #define CMD_C_REG		0x33
 #define IRQ_A_REG		0x35
 #define IRQ_B_REG		0x36
 #define IRQ_C_REG		0x37
 #define IRQ_D_REG		0x38
 #define IRQ_E_REG		0x39
 #define IRQ_F_REG		0x3A
 #define STATUS_A_REG	0x3B
 #define STATUS_B_REG	0x3C
 #define STATUS_C_REG	0x3D
 #define STATUS_D_REG	0x3E
 #define STATUS_E_REG	0x3F

 /* Status bits and masks */
 #define CHG_STATUS_MASK		SMB349_MASK(2, 1)
 #define CHG_ENABLE_STATUS_BIT		BIT(0)

 /* Control bits and masks */
 #define FAST_CHG_CURRENT_MASK			SMB349_MASK(4, 4)
 #define AC_INPUT_CURRENT_LIMIT_MASK		SMB349_MASK(4, 0)
 #define PRE_CHG_CURRENT_MASK			SMB349_MASK(3, 5)
 #define TERMINATION_CURRENT_MASK		SMB349_MASK(3, 2)
 #define PRE_CHG_TO_FAST_CHG_THRESH_MASK	SMB349_MASK(2, 6)
 #define FLOAT_VOLTAGE_MASK				SMB349_MASK(6, 0)
 #define CHG_ENABLE_BIT			BIT(1)
 #define VOLATILE_W_PERM_BIT		BIT(7)
 #define USB_SELECTION_BIT		BIT(1)
 #define SYSTEM_FET_ENABLE_BIT	BIT(7)
 #define AUTOMATIC_INPUT_CURR_LIMIT_BIT			BIT(4)
 #define AUTOMATIC_POWER_SOURCE_DETECTION_BIT	BIT(2)
 #define BATT_OV_END_CHG_BIT		BIT(1)
 #define VCHG_FUNCTION			BIT(0)
 #define CURR_TERM_END_CHG_BIT	BIT(6)

 struct smb349_struct {
 	struct			i2c_client *client;
 	bool			charging;
 	bool			present;
 	int			chg_current_ma;

 	int			en_n_gpio;
 	int			chg_susp_gpio;
 	struct dentry		*dent;
 	spinlock_t		lock;

 	struct work_struct	chg_work;
 	struct power_supply	dc_psy;
 };

 struct chg_ma_limit_entry {
 	int fast_chg_ma_limit;
 	int ac_input_ma_limit;
 	u8  chg_current_value;
 };

 static struct smb349_struct *the_smb349_chg;

 static int smb349_read_reg(struct i2c_client *client, int reg,
 				u8 *val)
 {
 	s32 ret;
 	struct smb349_struct *smb349_chg;

 	smb349_chg = i2c_get_clientdata(client);
 	ret = i2c_smbus_read_byte_data(smb349_chg->client, reg);
 	if (ret < 0) {
 		dev_err(&smb349_chg->client->dev,
 			"i2c read fail: can't read from %02x: %d\n", reg, ret);
 		return ret;
 	} else {
 		*val = ret;
 	}

 	return 0;
 }

 static int smb349_write_reg(struct i2c_client *client, int reg,
 						u8 val)
 {
 	s32 ret;
 	struct smb349_struct *smb349_chg;

 	smb349_chg = i2c_get_clientdata(client);
 	ret = i2c_smbus_write_byte_data(smb349_chg->client, reg, val);
 	if (ret < 0) {
 		dev_err(&smb349_chg->client->dev,
 			"i2c write fail: can't write %02x to %02x: %d\n",
 			val, reg, ret);
 		return ret;
 	}
 	return 0;
 }

 static int smb349_masked_write(struct i2c_client *client, int reg,
 		u8 mask, u8 val)
 {
 	s32 rc;
 	u8 temp;

 	rc = smb349_read_reg(client, reg, &temp);
 	if (rc) {
 		pr_err("smb349_read_reg failed: reg=%03X, rc=%d\n", reg, rc);
 		return rc;
 	}
 	temp &= ~mask;
 	temp |= val & mask;
 	rc = smb349_write_reg(client, reg, temp);
 	if (rc) {
 		pr_err("smb349_write failed: reg=%03X, rc=%d\n", reg, rc);
 		return rc;
 	}
 	return 0;
 }

 static enum power_supply_property pm_power_props[] = {
 	POWER_SUPPLY_PROP_ONLINE,
 	POWER_SUPPLY_PROP_CURRENT_MAX,
 	POWER_SUPPLY_PROP_CHARGE_TYPE,
 };

 static char *pm_power_supplied_to[] = {
 	"battery",
 };

 static int get_prop_charge_type(struct smb349_struct *smb349_chg)
 {
 	if (smb349_chg->charging)
 		return POWER_SUPPLY_CHARGE_TYPE_FAST;

 	return POWER_SUPPLY_CHARGE_TYPE_NONE;
 }

 static int pm_power_get_property(struct power_supply *psy,
 				  enum power_supply_property psp,
 				  union power_supply_propval *val)
 {
 	struct smb349_struct *smb349_chg = container_of(psy,
 						struct smb349_struct,
 						dc_psy);

 	switch (psp) {
 	case POWER_SUPPLY_PROP_CURRENT_MAX:
 		val->intval = smb349_chg->chg_current_ma;
 		break;
 	case POWER_SUPPLY_PROP_ONLINE:
 		val->intval = (int)smb349_chg->present;
 		break;
 	case POWER_SUPPLY_PROP_CHARGE_TYPE:
 		val->intval = get_prop_charge_type(smb349_chg);
 		break;
 	default:
 		return -EINVAL;
 	}
 	return 0;
 }

 #define SMB349_FAST_CHG_MIN_MA	1000
 #define SMB349_FAST_CHG_STEP_MA	200
 #define SMB349_FAST_CHG_MAX_MA	4000
 #define SMB349_FAST_CHG_SHIFT	4
 static int chg_current_set(struct smb349_struct *smb349_chg)
 {
 	u8 temp;

 	if ((smb349_chg->chg_current_ma < SMB349_FAST_CHG_MIN_MA) ||
 		(smb349_chg->chg_current_ma >  SMB349_FAST_CHG_MAX_MA)) {
 		pr_err("bad mA=%d asked to set\n", smb349_chg->chg_current_ma);
 		return -EINVAL;
 	}

 	temp = (smb349_chg->chg_current_ma - SMB349_FAST_CHG_MIN_MA)
 			/ SMB349_FAST_CHG_STEP_MA;

 	temp = temp << SMB349_FAST_CHG_SHIFT;
 	pr_debug("fastchg limit=%d setting %02x\n",
 				smb349_chg->chg_current_ma, temp);
 	return smb349_masked_write(smb349_chg->client, CHG_CURRENT_REG,
 			FAST_CHG_CURRENT_MASK, temp);
 }

 static int set_reg(void *data, u64 val)
 {
 	int addr = (int)data;
 	int ret;
 	u8 temp;

 	temp = (u16) val;
 	ret = smb349_write_reg(the_smb349_chg->client, addr, temp);

 	if (ret) {
 		pr_err("smb349_write_reg to %x value =%d errored = %d\n",
 			addr, temp, ret);
 		return -EAGAIN;
 	}
 	return 0;
 }
 static int get_reg(void *data, u64 *val)
 {
 	int addr = (int)data;
 	int ret;
 	u8 temp = 0;

 	ret = smb349_read_reg(the_smb349_chg->client, addr, &temp);
 	if (ret) {
 		pr_err("smb349_read_reg to %x value =%d errored = %d\n",
 			addr, temp, ret);
 		return -EAGAIN;
 	}

 	*val = temp;
 	return 0;
 }

 DEFINE_SIMPLE_ATTRIBUTE(reg_fops, get_reg, set_reg, "0x%02llx\n");

 static void create_debugfs_entries(struct smb349_struct *smb349_chg)
 {
 	struct dentry *file;
 	smb349_chg->dent = debugfs_create_dir(SMB349_NAME, NULL);
 	if (IS_ERR(smb349_chg->dent)) {
 		pr_err("smb349 driver couldn't create debugfs dir\n");
 		return;
 	}

 	file = debugfs_create_file("CHG_CURRENT_REG", 0644, smb349_chg->dent,
 				(void *) CHG_CURRENT_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("CHG_OTHER_CURRENT_REG", 0644,
 		smb349_chg->dent, (void *) CHG_OTHER_CURRENT_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("VAR_FUNC_REG", 0644, smb349_chg->dent,
 				(void *) VAR_FUNC_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("FLOAT_VOLTAGE_REG", 0644, smb349_chg->dent,
 				(void *) FLOAT_VOLTAGE_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("CHG_CTRL_REG", 0644, smb349_chg->dent,
 				(void *) CHG_CTRL_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("STAT_TIMER_REG", 0644, smb349_chg->dent,
 				(void *) STAT_TIMER_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("PIN_ENABLE_CTRL_REG", 0644,
 		smb349_chg->dent, (void *) PIN_ENABLE_CTRL_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("PIN_ENABLE_CTRL_REG", 0644,
 		smb349_chg->dent, (void *) PIN_ENABLE_CTRL_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("PIN_ENABLE_CTRL_REG", 0644,
 		smb349_chg->dent, (void *) PIN_ENABLE_CTRL_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("THERM_CTRL_A_REG", 0644, smb349_chg->dent,
 				(void *) THERM_CTRL_A_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("SYSOK_USB3_SELECT_REG", 0644,
 		smb349_chg->dent, (void *) SYSOK_USB3_SELECT_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("CTRL_FUNCTIONS_REG", 0644,
 		smb349_chg->dent, (void *) CTRL_FUNCTIONS_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("OTG_TLIM_THERM_CNTRL_REG", 0644,
 		smb349_chg->dent, (void *) OTG_TLIM_THERM_CNTRL_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("HARD_SOFT_LIMIT_CELL_TEMP_MONITOR_REG",
 		0644, smb349_chg->dent,
 		(void *) HARD_SOFT_LIMIT_CELL_TEMP_MONITOR_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("SYSOK_REG", 0644, smb349_chg->dent,
 				(void *) SYSOK_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("CMD_A_REG", 0644, smb349_chg->dent,
 				(void *) CMD_A_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("CMD_B_REG", 0644, smb349_chg->dent,
 				(void *) CMD_B_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("CMD_C_REG", 0644, smb349_chg->dent,
 				(void *) CMD_C_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("STATUS_A_REG", 0644, smb349_chg->dent,
 				(void *) STATUS_A_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("STATUS_B_REG", 0644, smb349_chg->dent,
 				(void *) STATUS_B_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("STATUS_C_REG", 0644, smb349_chg->dent,
 				(void *) STATUS_C_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("STATUS_D_REG", 0644, smb349_chg->dent,
 				(void *) STATUS_D_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 	file = debugfs_create_file("STATUS_E_REG", 0644, smb349_chg->dent,
 				(void *) STATUS_E_REG, &reg_fops);
 	if (IS_ERR(file)) {
 		pr_err("smb349 driver couldn't create debugfs files\n");
 		return;
 	}
 }

 static void remove_debugfs_entries(struct smb349_struct *smb349_chg)
 {
 	if (smb349_chg->dent)
 		debugfs_remove_recursive(smb349_chg->dent);
 }

 static int smb349_hwinit(struct smb349_struct *smb349_chg)
 {
 	int ret;

 	ret = smb349_write_reg(smb349_chg->client, CMD_A_REG,
 			VOLATILE_W_PERM_BIT);
 	if (ret) {
 		pr_err("Failed to set VOLATILE_W_PERM_BIT rc=%d\n", ret);
 		return ret;
 	}

 	ret = smb349_masked_write(smb349_chg->client, CHG_CTRL_REG,
 				CURR_TERM_END_CHG_BIT, CURR_TERM_END_CHG_BIT);
 	if (ret) {
 		pr_err("Failed to set CURR_TERM_END_CHG_BIT rc=%d\n", ret);
 		return ret;
 	}

 	ret = chg_current_set(smb349_chg);
 	if (ret) {
 		pr_err("Failed to set FAST_CHG_CURRENT rc=%d\n", ret);
 		return ret;
 	}

 	return 0;
 }

 static int smb349_stop_charging(struct smb349_struct *smb349_chg)
 {
 	unsigned long flags;
 	int rc = 0;

 	spin_lock_irqsave(&smb349_chg->lock, flags);
 	pr_debug("stop charging %d\n", smb349_chg->charging);
 	smb349_chg->charging = 0;
 	spin_unlock_irqrestore(&smb349_chg->lock, flags);

 	if (smb349_chg->charging)
 		rc = schedule_work(&smb349_chg->chg_work);

 	return rc;
 }

 static int smb349_start_charging(struct smb349_struct *smb349_chg)
 {
 	unsigned long flags;
 	int rc;

 	rc = 0;
 	spin_lock_irqsave(&smb349_chg->lock, flags);
 	pr_debug("start charging %d\n", smb349_chg->charging);
 	smb349_chg->charging = 1;
 	spin_unlock_irqrestore(&smb349_chg->lock, flags);

 	if (!smb349_chg->charging)
 		rc = schedule_work(&smb349_chg->chg_work);

 	return rc;
 }

 static int pm_power_set_property(struct power_supply *psy,
 				  enum power_supply_property psp,
 				  const union power_supply_propval *val)
 {
 	struct smb349_struct *smb349_chg = container_of(psy,
 						struct smb349_struct,
 						dc_psy);

 	switch (psp) {
 	case POWER_SUPPLY_PROP_ONLINE:
 		if (val->intval) {
 			smb349_chg->present = val->intval;
 		} else {
 			smb349_chg->present = 0;
 			if (smb349_chg->charging)
 				return smb349_stop_charging(smb349_chg);
 		}
 		break;
 	case POWER_SUPPLY_PROP_CURRENT_MAX:
 		if (val->intval) {
 			if (smb349_chg->chg_current_ma != val->intval)
 				return -EINVAL;
 		}
 		break;
 	case POWER_SUPPLY_PROP_CHARGE_TYPE:
 		if (val->intval && smb349_chg->present) {
 			if (val->intval == POWER_SUPPLY_CHARGE_TYPE_FAST)
 				return smb349_start_charging(smb349_chg);
 			if (val->intval == POWER_SUPPLY_CHARGE_TYPE_NONE)
 				return smb349_stop_charging(smb349_chg);
 		} else {
 			return -EINVAL;
 		}
 		break;
 	default:
 		return -EINVAL;
 	}
 	power_supply_changed(&smb349_chg->dc_psy);
 	return 0;
 }

 static void chg_worker(struct work_struct *work)
 {
 	struct smb349_struct *smb349_chg = container_of(work,
 				struct smb349_struct, chg_work);
 	int ret = 0;

 	gpio_set_value_cansleep(smb349_chg->en_n_gpio, smb349_chg->charging);

 	/*
 	 * Write non-default values, charger chip reloads from
 	 * non-volatile memory if it was in suspend mode
 	 *
 	 */
 	if (smb349_chg->charging)
 		ret = smb349_hwinit(smb349_chg);
 	if (ret)
 		pr_err("Failed to re-initilaze registers\n");

 	power_supply_changed(&smb349_chg->dc_psy);
 }

 static int __devinit smb349_init_ext_chg(struct smb349_struct *smb349_chg)
 {
 	int ret;

 	smb349_chg->dc_psy.name = "dc";
 	smb349_chg->dc_psy.type = POWER_SUPPLY_TYPE_MAINS;
 	smb349_chg->dc_psy.supplied_to = pm_power_supplied_to;
 	smb349_chg->dc_psy.num_supplicants = ARRAY_SIZE(pm_power_supplied_to);
 	smb349_chg->dc_psy.properties = pm_power_props;
 	smb349_chg->dc_psy.num_properties = ARRAY_SIZE(pm_power_props);
 	smb349_chg->dc_psy.get_property = pm_power_get_property;
 	smb349_chg->dc_psy.set_property = pm_power_set_property;

 	ret = power_supply_register(&smb349_chg->client->dev,
 				&smb349_chg->dc_psy);
 	if (ret) {
 		pr_err("failed to register power_supply. ret=%d.\n", ret);
 		return ret;
 	}

 	return 0;
 }

 static int __devinit smb349_probe(struct i2c_client *client,
 				    const struct i2c_device_id *id)
 {
 	const struct smb349_platform_data *pdata;
 	struct smb349_struct *smb349_chg;
 	int ret = 0;

 	pdata = client->dev.platform_data;

 	if (pdata == NULL) {
 		dev_err(&client->dev, "%s no platform data\n", __func__);
 		ret = -EINVAL;
 		goto out;
 	}

 	if (!i2c_check_functionality(client->adapter,
 				I2C_FUNC_SMBUS_BYTE_DATA)) {
 		ret = -EIO;
 		goto out;
 	}

 	smb349_chg = kzalloc(sizeof(*smb349_chg), GFP_KERNEL);
 	if (!smb349_chg) {
 		ret = -ENOMEM;
 		goto out;
 	}

 	smb349_chg->client = client;
 	smb349_chg->chg_current_ma = pdata->chg_current_ma;
 	ret = gpio_request(pdata->chg_susp_gpio, "smb349_suspend");
 	if (ret) {
 		dev_err(&client->dev, "%s gpio_request failed for %d ret=%d\n",
 			__func__, pdata->chg_susp_gpio, ret);
 		goto free_smb349_chg;
 	}
 	smb349_chg->chg_susp_gpio = pdata->chg_susp_gpio;

 	ret = gpio_request(pdata->en_n_gpio, "smb349_charger_enable");
 	if (ret) {
 		dev_err(&client->dev, "%s gpio_request failed for %d ret=%d\n",
 			__func__, pdata->en_n_gpio, ret);
 		goto chg_susp_gpio_fail;
 	}
 	smb349_chg->en_n_gpio = pdata->en_n_gpio;

 	i2c_set_clientdata(client, smb349_chg);

 	ret = smb349_hwinit(smb349_chg);
 	if (ret)
 		goto free_smb349_chg;

 	ret = smb349_init_ext_chg(smb349_chg);
 	if (ret)
 		goto chg_en_gpio_fail;

 	the_smb349_chg = smb349_chg;

 	spin_lock_init(&smb349_chg->lock);

 	create_debugfs_entries(smb349_chg);
 	INIT_WORK(&smb349_chg->chg_work, chg_worker);

 	pr_info("OK connector present = %d\n", smb349_chg->present);
 	return 0;

 chg_en_gpio_fail:
 	gpio_free(smb349_chg->en_n_gpio);
 chg_susp_gpio_fail:
 	gpio_free(smb349_chg->chg_susp_gpio);
 free_smb349_chg:
 	kfree(smb349_chg);
 out:
 	return ret;
 }

 static int __devexit smb349_remove(struct i2c_client *client)
 {
 	const struct smb349_platform_data *pdata;
 	struct smb349_struct *smb349_chg = i2c_get_clientdata(client);

 	flush_work(&smb349_chg->chg_work);
 	pdata = client->dev.platform_data;
 	power_supply_unregister(&smb349_chg->dc_psy);
 	gpio_free(pdata->en_n_gpio);
 	gpio_free(pdata->chg_susp_gpio);
 	remove_debugfs_entries(smb349_chg);
 	kfree(smb349_chg);
 	return 0;
 }

 static int smb349_suspend(struct device *dev)
 {
 	struct smb349_struct *smb349_chg = dev_get_drvdata(dev);

 	pr_debug("suspend\n");
 	if (smb349_chg->charging)
 		return -EBUSY;
 	return 0;
 }

 static int smb349_resume(struct device *dev)
 {
 	pr_debug("resume\n");

 	return 0;
 }

 static const struct dev_pm_ops smb349_pm_ops = {
 	.suspend	= smb349_suspend,
 	.resume		= smb349_resume,
 };

 static const struct i2c_device_id smb349_id[] = {
 	{SMB349_NAME, 0},
 	{},
 };
 MODULE_DEVICE_TABLE(i2c, smb349_id);

 static struct i2c_driver smb349_driver = {
 	.driver	= {
 		   .name	= SMB349_NAME,
 		   .owner	= THIS_MODULE,
 		   .pm		= &smb349_pm_ops,
 	},
 	.probe		= smb349_probe,
 	.remove		= __devexit_p(smb349_remove),
 	.id_table	= smb349_id,
 };

 static int __init smb349_init(void)
 {
 	return i2c_add_driver(&smb349_driver);
 }
 module_init(smb349_init);

 static void __exit smb349_exit(void)
 {
 	return i2c_del_driver(&smb349_driver);
 }
 module_exit(smb349_exit);

 MODULE_DESCRIPTION("Driver for SMB349 charger chip");
 MODULE_LICENSE("GPL v2");
 MODULE_ALIAS("i2c:" SMB349_NAME);
	/* Copyright (c) 2012 The Linux Foundation. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 and
	* only version 2 as published by the Free Software Foundation.
	*
	* 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.
	*
	*/
	#define pr_fmt(fmt) "%s: " fmt, __func__

	#include <linux/i2c.h>
	#include <linux/gpio.h>
	#include <linux/errno.h>
	#include <linux/delay.h>
	#include <linux/module.h>
	#include <linux/debugfs.h>
	#include <linux/workqueue.h>
	#include <linux/interrupt.h>
	#include <linux/slab.h>
	#include <linux/i2c/smb349.h>
	#include <linux/power_supply.h>

	#define SMB349_MASK(BITS, POS) ((unsigned char)(((1 << BITS) - 1) << POS))

	/* Register definitions */
	#define CHG_CURRENT_REG 0x00
	#define CHG_OTHER_CURRENT_REG 0x01
	#define VAR_FUNC_REG 0x02
	#define FLOAT_VOLTAGE_REG 0x03
	#define CHG_CTRL_REG 0x04
	#define STAT_TIMER_REG 0x05
	#define PIN_ENABLE_CTRL_REG 0x06
	#define THERM_CTRL_A_REG 0x07
	#define SYSOK_USB3_SELECT_REG 0x08
	#define CTRL_FUNCTIONS_REG 0x09
	#define OTG_TLIM_THERM_CNTRL_REG 0x0A
	#define HARD_SOFT_LIMIT_CELL_TEMP_MONITOR_REG 0x0B
	#define FAULT_IRQ_REG 0x0C
	#define STATUS_IRQ_REG 0x0D
	#define SYSOK_REG 0x0E
	#define CMD_A_REG 0x30
	#define CMD_B_REG 0x31
	#define CMD_C_REG 0x33
	#define IRQ_A_REG 0x35
	#define IRQ_B_REG 0x36
	#define IRQ_C_REG 0x37
	#define IRQ_D_REG 0x38
	#define IRQ_E_REG 0x39
	#define IRQ_F_REG 0x3A
	#define STATUS_A_REG 0x3B
	#define STATUS_B_REG 0x3C
	#define STATUS_C_REG 0x3D
	#define STATUS_D_REG 0x3E
	#define STATUS_E_REG 0x3F

	/* Status bits and masks */
	#define CHG_STATUS_MASK SMB349_MASK(2, 1)
	#define CHG_ENABLE_STATUS_BIT BIT(0)

	/* Control bits and masks */
	#define FAST_CHG_CURRENT_MASK SMB349_MASK(4, 4)
	#define AC_INPUT_CURRENT_LIMIT_MASK SMB349_MASK(4, 0)
	#define PRE_CHG_CURRENT_MASK SMB349_MASK(3, 5)
	#define TERMINATION_CURRENT_MASK SMB349_MASK(3, 2)
	#define PRE_CHG_TO_FAST_CHG_THRESH_MASK SMB349_MASK(2, 6)
	#define FLOAT_VOLTAGE_MASK SMB349_MASK(6, 0)
	#define CHG_ENABLE_BIT BIT(1)
	#define VOLATILE_W_PERM_BIT BIT(7)
	#define USB_SELECTION_BIT BIT(1)
	#define SYSTEM_FET_ENABLE_BIT BIT(7)
	#define AUTOMATIC_INPUT_CURR_LIMIT_BIT BIT(4)
	#define AUTOMATIC_POWER_SOURCE_DETECTION_BIT BIT(2)
	#define BATT_OV_END_CHG_BIT BIT(1)
	#define VCHG_FUNCTION BIT(0)
	#define CURR_TERM_END_CHG_BIT BIT(6)

	struct smb349_struct {
	struct i2c_client *client;
	bool charging;
	bool present;
	int chg_current_ma;

	int en_n_gpio;
	int chg_susp_gpio;
	struct dentry *dent;
	spinlock_t lock;

	struct work_struct chg_work;
	struct power_supply dc_psy;
	};

	struct chg_ma_limit_entry {
	int fast_chg_ma_limit;
	int ac_input_ma_limit;
	u8 chg_current_value;
	};

	static struct smb349_struct *the_smb349_chg;

	static int smb349_read_reg(struct i2c_client *client, int reg,
	u8 *val)
	{
	s32 ret;
	struct smb349_struct *smb349_chg;

	smb349_chg = i2c_get_clientdata(client);
	ret = i2c_smbus_read_byte_data(smb349_chg->client, reg);
	if (ret < 0) {
	dev_err(&smb349_chg->client->dev,
	"i2c read fail: can't read from %02x: %d\n", reg, ret);
	return ret;
	} else {
	*val = ret;
	}

	return 0;
	}

	static int smb349_write_reg(struct i2c_client *client, int reg,
	u8 val)
	{
	s32 ret;
	struct smb349_struct *smb349_chg;

	smb349_chg = i2c_get_clientdata(client);
	ret = i2c_smbus_write_byte_data(smb349_chg->client, reg, val);
	if (ret < 0) {
	dev_err(&smb349_chg->client->dev,
	"i2c write fail: can't write %02x to %02x: %d\n",
	val, reg, ret);
	return ret;
	}
	return 0;
	}

	static int smb349_masked_write(struct i2c_client *client, int reg,
	u8 mask, u8 val)
	{
	s32 rc;
	u8 temp;

	rc = smb349_read_reg(client, reg, &temp);
	if (rc) {
	pr_err("smb349_read_reg failed: reg=%03X, rc=%d\n", reg, rc);
	return rc;
	}
	temp &= ~mask;
	temp \|= val & mask;
	rc = smb349_write_reg(client, reg, temp);
	if (rc) {
	pr_err("smb349_write failed: reg=%03X, rc=%d\n", reg, rc);
	return rc;
	}
	return 0;
	}

	static enum power_supply_property pm_power_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_CURRENT_MAX,
	POWER_SUPPLY_PROP_CHARGE_TYPE,
	};

	static char *pm_power_supplied_to[] = {
	"battery",
	};

	static int get_prop_charge_type(struct smb349_struct *smb349_chg)
	{
	if (smb349_chg->charging)
	return POWER_SUPPLY_CHARGE_TYPE_FAST;

	return POWER_SUPPLY_CHARGE_TYPE_NONE;
	}

	static int pm_power_get_property(struct power_supply *psy,
	enum power_supply_property psp,
	union power_supply_propval *val)
	{
	struct smb349_struct *smb349_chg = container_of(psy,
	struct smb349_struct,
	dc_psy);

	switch (psp) {
	case POWER_SUPPLY_PROP_CURRENT_MAX:
	val->intval = smb349_chg->chg_current_ma;
	break;
	case POWER_SUPPLY_PROP_ONLINE:
	val->intval = (int)smb349_chg->present;
	break;
	case POWER_SUPPLY_PROP_CHARGE_TYPE:
	val->intval = get_prop_charge_type(smb349_chg);
	break;
	default:
	return -EINVAL;
	}
	return 0;
	}

	#define SMB349_FAST_CHG_MIN_MA 1000
	#define SMB349_FAST_CHG_STEP_MA 200
	#define SMB349_FAST_CHG_MAX_MA 4000
	#define SMB349_FAST_CHG_SHIFT 4
	static int chg_current_set(struct smb349_struct *smb349_chg)
	{
	u8 temp;

	if ((smb349_chg->chg_current_ma < SMB349_FAST_CHG_MIN_MA) \|\|
	(smb349_chg->chg_current_ma > SMB349_FAST_CHG_MAX_MA)) {
	pr_err("bad mA=%d asked to set\n", smb349_chg->chg_current_ma);
	return -EINVAL;
	}

	temp = (smb349_chg->chg_current_ma - SMB349_FAST_CHG_MIN_MA)
	/ SMB349_FAST_CHG_STEP_MA;

	temp = temp << SMB349_FAST_CHG_SHIFT;
	pr_debug("fastchg limit=%d setting %02x\n",
	smb349_chg->chg_current_ma, temp);
	return smb349_masked_write(smb349_chg->client, CHG_CURRENT_REG,
	FAST_CHG_CURRENT_MASK, temp);
	}

	static int set_reg(void *data, u64 val)
	{
	int addr = (int)data;
	int ret;
	u8 temp;

	temp = (u16) val;
	ret = smb349_write_reg(the_smb349_chg->client, addr, temp);

	if (ret) {
	pr_err("smb349_write_reg to %x value =%d errored = %d\n",
	addr, temp, ret);
	return -EAGAIN;
	}
	return 0;
	}
	static int get_reg(void data, u64 val)
	{
	int addr = (int)data;
	int ret;
	u8 temp = 0;

	ret = smb349_read_reg(the_smb349_chg->client, addr, &temp);
	if (ret) {
	pr_err("smb349_read_reg to %x value =%d errored = %d\n",
	addr, temp, ret);
	return -EAGAIN;
	}

	*val = temp;
	return 0;
	}

	DEFINE_SIMPLE_ATTRIBUTE(reg_fops, get_reg, set_reg, "0x%02llx\n");

	static void create_debugfs_entries(struct smb349_struct *smb349_chg)
	{
	struct dentry *file;
	smb349_chg->dent = debugfs_create_dir(SMB349_NAME, NULL);
	if (IS_ERR(smb349_chg->dent)) {
	pr_err("smb349 driver couldn't create debugfs dir\n");
	return;
	}

	file = debugfs_create_file("CHG_CURRENT_REG", 0644, smb349_chg->dent,
	(void *) CHG_CURRENT_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("CHG_OTHER_CURRENT_REG", 0644,
	smb349_chg->dent, (void *) CHG_OTHER_CURRENT_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("VAR_FUNC_REG", 0644, smb349_chg->dent,
	(void *) VAR_FUNC_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("FLOAT_VOLTAGE_REG", 0644, smb349_chg->dent,
	(void *) FLOAT_VOLTAGE_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("CHG_CTRL_REG", 0644, smb349_chg->dent,
	(void *) CHG_CTRL_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("STAT_TIMER_REG", 0644, smb349_chg->dent,
	(void *) STAT_TIMER_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("PIN_ENABLE_CTRL_REG", 0644,
	smb349_chg->dent, (void *) PIN_ENABLE_CTRL_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("PIN_ENABLE_CTRL_REG", 0644,
	smb349_chg->dent, (void *) PIN_ENABLE_CTRL_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("PIN_ENABLE_CTRL_REG", 0644,
	smb349_chg->dent, (void *) PIN_ENABLE_CTRL_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("THERM_CTRL_A_REG", 0644, smb349_chg->dent,
	(void *) THERM_CTRL_A_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("SYSOK_USB3_SELECT_REG", 0644,
	smb349_chg->dent, (void *) SYSOK_USB3_SELECT_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("CTRL_FUNCTIONS_REG", 0644,
	smb349_chg->dent, (void *) CTRL_FUNCTIONS_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("OTG_TLIM_THERM_CNTRL_REG", 0644,
	smb349_chg->dent, (void *) OTG_TLIM_THERM_CNTRL_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("HARD_SOFT_LIMIT_CELL_TEMP_MONITOR_REG",
	0644, smb349_chg->dent,
	(void *) HARD_SOFT_LIMIT_CELL_TEMP_MONITOR_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("SYSOK_REG", 0644, smb349_chg->dent,
	(void *) SYSOK_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("CMD_A_REG", 0644, smb349_chg->dent,
	(void *) CMD_A_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("CMD_B_REG", 0644, smb349_chg->dent,
	(void *) CMD_B_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("CMD_C_REG", 0644, smb349_chg->dent,
	(void *) CMD_C_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("STATUS_A_REG", 0644, smb349_chg->dent,
	(void *) STATUS_A_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("STATUS_B_REG", 0644, smb349_chg->dent,
	(void *) STATUS_B_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("STATUS_C_REG", 0644, smb349_chg->dent,
	(void *) STATUS_C_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("STATUS_D_REG", 0644, smb349_chg->dent,
	(void *) STATUS_D_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	file = debugfs_create_file("STATUS_E_REG", 0644, smb349_chg->dent,
	(void *) STATUS_E_REG, &reg_fops);
	if (IS_ERR(file)) {
	pr_err("smb349 driver couldn't create debugfs files\n");
	return;
	}
	}

	static void remove_debugfs_entries(struct smb349_struct *smb349_chg)
	{
	if (smb349_chg->dent)
	debugfs_remove_recursive(smb349_chg->dent);
	}

	static int smb349_hwinit(struct smb349_struct *smb349_chg)
	{
	int ret;

	ret = smb349_write_reg(smb349_chg->client, CMD_A_REG,
	VOLATILE_W_PERM_BIT);
	if (ret) {
	pr_err("Failed to set VOLATILE_W_PERM_BIT rc=%d\n", ret);
	return ret;
	}

	ret = smb349_masked_write(smb349_chg->client, CHG_CTRL_REG,
	CURR_TERM_END_CHG_BIT, CURR_TERM_END_CHG_BIT);
	if (ret) {
	pr_err("Failed to set CURR_TERM_END_CHG_BIT rc=%d\n", ret);
	return ret;
	}

	ret = chg_current_set(smb349_chg);
	if (ret) {
	pr_err("Failed to set FAST_CHG_CURRENT rc=%d\n", ret);
	return ret;
	}

	return 0;
	}

	static int smb349_stop_charging(struct smb349_struct *smb349_chg)
	{
	unsigned long flags;
	int rc = 0;

	spin_lock_irqsave(&smb349_chg->lock, flags);
	pr_debug("stop charging %d\n", smb349_chg->charging);
	smb349_chg->charging = 0;
	spin_unlock_irqrestore(&smb349_chg->lock, flags);

	if (smb349_chg->charging)
	rc = schedule_work(&smb349_chg->chg_work);

	return rc;
	}

	static int smb349_start_charging(struct smb349_struct *smb349_chg)
	{
	unsigned long flags;
	int rc;

	rc = 0;
	spin_lock_irqsave(&smb349_chg->lock, flags);
	pr_debug("start charging %d\n", smb349_chg->charging);
	smb349_chg->charging = 1;
	spin_unlock_irqrestore(&smb349_chg->lock, flags);

	if (!smb349_chg->charging)
	rc = schedule_work(&smb349_chg->chg_work);

	return rc;
	}

	static int pm_power_set_property(struct power_supply *psy,
	enum power_supply_property psp,
	const union power_supply_propval *val)
	{
	struct smb349_struct *smb349_chg = container_of(psy,
	struct smb349_struct,
	dc_psy);

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
	if (val->intval) {
	smb349_chg->present = val->intval;
	} else {
	smb349_chg->present = 0;
	if (smb349_chg->charging)
	return smb349_stop_charging(smb349_chg);
	}
	break;
	case POWER_SUPPLY_PROP_CURRENT_MAX:
	if (val->intval) {
	if (smb349_chg->chg_current_ma != val->intval)
	return -EINVAL;
	}
	break;
	case POWER_SUPPLY_PROP_CHARGE_TYPE:
	if (val->intval && smb349_chg->present) {
	if (val->intval == POWER_SUPPLY_CHARGE_TYPE_FAST)
	return smb349_start_charging(smb349_chg);
	if (val->intval == POWER_SUPPLY_CHARGE_TYPE_NONE)
	return smb349_stop_charging(smb349_chg);
	} else {
	return -EINVAL;
	}
	break;
	default:
	return -EINVAL;
	}
	power_supply_changed(&smb349_chg->dc_psy);
	return 0;
	}

	static void chg_worker(struct work_struct *work)
	{
	struct smb349_struct *smb349_chg = container_of(work,
	struct smb349_struct, chg_work);
	int ret = 0;

	gpio_set_value_cansleep(smb349_chg->en_n_gpio, smb349_chg->charging);

	/*
	* Write non-default values, charger chip reloads from
	* non-volatile memory if it was in suspend mode
	*
	*/
	if (smb349_chg->charging)
	ret = smb349_hwinit(smb349_chg);
	if (ret)
	pr_err("Failed to re-initilaze registers\n");

	power_supply_changed(&smb349_chg->dc_psy);
	}

	static int __devinit smb349_init_ext_chg(struct smb349_struct *smb349_chg)
	{
	int ret;

	smb349_chg->dc_psy.name = "dc";
	smb349_chg->dc_psy.type = POWER_SUPPLY_TYPE_MAINS;
	smb349_chg->dc_psy.supplied_to = pm_power_supplied_to;
	smb349_chg->dc_psy.num_supplicants = ARRAY_SIZE(pm_power_supplied_to);
	smb349_chg->dc_psy.properties = pm_power_props;
	smb349_chg->dc_psy.num_properties = ARRAY_SIZE(pm_power_props);
	smb349_chg->dc_psy.get_property = pm_power_get_property;
	smb349_chg->dc_psy.set_property = pm_power_set_property;

	ret = power_supply_register(&smb349_chg->client->dev,
	&smb349_chg->dc_psy);
	if (ret) {
	pr_err("failed to register power_supply. ret=%d.\n", ret);
	return ret;
	}

	return 0;
	}

	static int __devinit smb349_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
	{
	const struct smb349_platform_data *pdata;
	struct smb349_struct *smb349_chg;
	int ret = 0;

	pdata = client->dev.platform_data;

	if (pdata == NULL) {
	dev_err(&client->dev, "%s no platform data\n", __func__);
	ret = -EINVAL;
	goto out;
	}

	if (!i2c_check_functionality(client->adapter,
	I2C_FUNC_SMBUS_BYTE_DATA)) {
	ret = -EIO;
	goto out;
	}

	smb349_chg = kzalloc(sizeof(*smb349_chg), GFP_KERNEL);
	if (!smb349_chg) {
	ret = -ENOMEM;
	goto out;
	}

	smb349_chg->client = client;
	smb349_chg->chg_current_ma = pdata->chg_current_ma;
	ret = gpio_request(pdata->chg_susp_gpio, "smb349_suspend");
	if (ret) {
	dev_err(&client->dev, "%s gpio_request failed for %d ret=%d\n",
	__func__, pdata->chg_susp_gpio, ret);
	goto free_smb349_chg;
	}
	smb349_chg->chg_susp_gpio = pdata->chg_susp_gpio;

	ret = gpio_request(pdata->en_n_gpio, "smb349_charger_enable");
	if (ret) {
	dev_err(&client->dev, "%s gpio_request failed for %d ret=%d\n",
	__func__, pdata->en_n_gpio, ret);
	goto chg_susp_gpio_fail;
	}
	smb349_chg->en_n_gpio = pdata->en_n_gpio;

	i2c_set_clientdata(client, smb349_chg);

	ret = smb349_hwinit(smb349_chg);
	if (ret)
	goto free_smb349_chg;

	ret = smb349_init_ext_chg(smb349_chg);
	if (ret)
	goto chg_en_gpio_fail;

	the_smb349_chg = smb349_chg;

	spin_lock_init(&smb349_chg->lock);

	create_debugfs_entries(smb349_chg);
	INIT_WORK(&smb349_chg->chg_work, chg_worker);

	pr_info("OK connector present = %d\n", smb349_chg->present);
	return 0;

	chg_en_gpio_fail:
	gpio_free(smb349_chg->en_n_gpio);
	chg_susp_gpio_fail:
	gpio_free(smb349_chg->chg_susp_gpio);
	free_smb349_chg:
	kfree(smb349_chg);
	out:
	return ret;
	}

	static int __devexit smb349_remove(struct i2c_client *client)
	{
	const struct smb349_platform_data *pdata;
	struct smb349_struct *smb349_chg = i2c_get_clientdata(client);

	flush_work(&smb349_chg->chg_work);
	pdata = client->dev.platform_data;
	power_supply_unregister(&smb349_chg->dc_psy);
	gpio_free(pdata->en_n_gpio);
	gpio_free(pdata->chg_susp_gpio);
	remove_debugfs_entries(smb349_chg);
	kfree(smb349_chg);
	return 0;
	}

	static int smb349_suspend(struct device *dev)
	{
	struct smb349_struct *smb349_chg = dev_get_drvdata(dev);

	pr_debug("suspend\n");
	if (smb349_chg->charging)
	return -EBUSY;
	return 0;
	}

	static int smb349_resume(struct device *dev)
	{
	pr_debug("resume\n");

	return 0;
	}

	static const struct dev_pm_ops smb349_pm_ops = {
	.suspend = smb349_suspend,
	.resume = smb349_resume,
	};

	static const struct i2c_device_id smb349_id[] = {
	{SMB349_NAME, 0},
	{},
	};
	MODULE_DEVICE_TABLE(i2c, smb349_id);

	static struct i2c_driver smb349_driver = {
	.driver = {
	.name = SMB349_NAME,
	.owner = THIS_MODULE,
	.pm = &smb349_pm_ops,
	},
	.probe = smb349_probe,
	.remove = __devexit_p(smb349_remove),
	.id_table = smb349_id,
	};

	static int __init smb349_init(void)
	{
	return i2c_add_driver(&smb349_driver);
	}
	module_init(smb349_init);

	static void __exit smb349_exit(void)
	{
	return i2c_del_driver(&smb349_driver);
	}
	module_exit(smb349_exit);

	MODULE_DESCRIPTION("Driver for SMB349 charger chip");
	MODULE_LICENSE("GPL v2");
	MODULE_ALIAS("i2c:" SMB349_NAME);