M7350/kernel/drivers/power/smb349.c

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