blob: 21d7aea03bfaa135cba4435edfc090062facf58e [file] [log] [blame]
/* 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/power_supply.h>
#include <linux/i2c/smb350.h>
#include <linux/bitops.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <linux/printk.h>
/* Register definitions */
#define CHG_CURRENT_REG 0x00 /* Non-Volatile + mirror */
#define CHG_OTHER_CURRENT_REG 0x01 /* Non-Volatile + mirror */
#define VAR_FUNC_REG 0x02 /* Non-Volatile + mirror */
#define FLOAT_VOLTAGE_REG 0x03 /* Non-Volatile + mirror */
#define CHG_CTRL_REG 0x04 /* Non-Volatile + mirror */
#define STAT_TIMER_REG 0x05 /* Non-Volatile + mirror */
#define PIN_ENABLE_CTRL_REG 0x06 /* Non-Volatile + mirror */
#define THERM_CTRL_A_REG 0x07 /* Non-Volatile + mirror */
#define SYSOK_USB3_SELECT_REG 0x08 /* Non-Volatile + mirror */
#define CTRL_FUNCTIONS_REG 0x09 /* Non-Volatile + mirror */
#define OTG_TLIM_THERM_CNTRL_REG 0x0A /* Non-Volatile + mirror */
#define TEMP_MONITOR_REG 0x0B /* Non-Volatile + mirror */
#define FAULT_IRQ_REG 0x0C /* Non-Volatile */
#define IRQ_ENABLE_REG 0x0D /* Non-Volatile */
#define SYSOK_REG 0x0E /* Non-Volatile + mirror */
#define AUTO_INPUT_VOLT_DETECT_REG 0x10 /* Non-Volatile Read-Only */
#define STATUS_IRQ_REG 0x11 /* Non-Volatile Read-Only */
#define I2C_SLAVE_ADDR_REG 0x12 /* Non-Volatile Read-Only */
#define CMD_A_REG 0x30 /* Volatile Read-Write */
#define CMD_B_REG 0x31 /* Volatile Read-Write */
#define CMD_C_REG 0x33 /* Volatile Read-Write */
#define HW_VERSION_REG 0x34 /* Volatile Read-Only */
#define IRQ_STATUS_A_REG 0x35 /* Volatile Read-Only */
#define IRQ_STATUS_B_REG 0x36 /* Volatile Read-Only */
#define IRQ_STATUS_C_REG 0x37 /* Volatile Read-Only */
#define IRQ_STATUS_D_REG 0x38 /* Volatile Read-Only */
#define IRQ_STATUS_E_REG 0x39 /* Volatile Read-Only */
#define IRQ_STATUS_F_REG 0x3A /* Volatile Read-Only */
#define STATUS_A_REG 0x3B /* Volatile Read-Only */
#define STATUS_B_REG 0x3D /* Volatile Read-Only */
/* Note: STATUS_C_REG was removed from SMB349 to SMB350 */
#define STATUS_D_REG 0x3E /* Volatile Read-Only */
#define STATUS_E_REG 0x3F /* Volatile Read-Only */
#define IRQ_STATUS_NUM (IRQ_STATUS_F_REG - IRQ_STATUS_A_REG + 1)
/* Status bits and masks */
#define SMB350_MASK(BITS, POS) ((u8)(((1 << BITS) - 1) << POS))
#define FAST_CHG_CURRENT_MASK SMB350_MASK(4, 4)
#define SMB350_FAST_CHG_MIN_MA 1000
#define SMB350_FAST_CHG_STEP_MA 200
#define SMB350_FAST_CHG_MAX_MA 3600
#define TERM_CURRENT_MASK SMB350_MASK(3, 2)
#define SMB350_TERM_CUR_MIN_MA 200
#define SMB350_TERM_CUR_STEP_MA 100
#define SMB350_TERM_CUR_MAX_MA 700
#define CMD_A_VOLATILE_WR_PERM BIT(7)
#define CHG_CTRL_CURR_TERM_END_CHG BIT(6)
enum smb350_chg_status {
SMB_CHG_STATUS_NONE = 0,
SMB_CHG_STATUS_PRE_CHARGE = 1,
SMB_CHG_STATUS_FAST_CHARGE = 2,
SMB_CHG_STATUS_TAPER_CHARGE = 3,
};
static const char * const smb350_chg_status[] = {
"none",
"pre-charge",
"fast-charge",
"taper-charge"
};
struct smb350_device {
/* setup */
int chg_current_ma;
int term_current_ma;
int chg_en_n_gpio;
int chg_susp_n_gpio;
int stat_gpio;
int irq;
/* internal */
enum smb350_chg_status chg_status;
struct i2c_client *client;
struct delayed_work irq_work;
struct dentry *dent;
struct wake_lock chg_wake_lock;
struct power_supply dc_psy;
};
static struct smb350_device *smb350_dev;
struct debug_reg {
char *name;
u8 reg;
};
#define SMB350_DEBUG_REG(x) {#x, x##_REG}
static struct debug_reg smb350_debug_regs[] = {
SMB350_DEBUG_REG(CHG_CURRENT),
SMB350_DEBUG_REG(CHG_OTHER_CURRENT),
SMB350_DEBUG_REG(VAR_FUNC),
SMB350_DEBUG_REG(FLOAT_VOLTAGE),
SMB350_DEBUG_REG(CHG_CTRL),
SMB350_DEBUG_REG(STAT_TIMER),
SMB350_DEBUG_REG(PIN_ENABLE_CTRL),
SMB350_DEBUG_REG(THERM_CTRL_A),
SMB350_DEBUG_REG(SYSOK_USB3_SELECT),
SMB350_DEBUG_REG(CTRL_FUNCTIONS),
SMB350_DEBUG_REG(OTG_TLIM_THERM_CNTRL),
SMB350_DEBUG_REG(TEMP_MONITOR),
SMB350_DEBUG_REG(FAULT_IRQ),
SMB350_DEBUG_REG(IRQ_ENABLE),
SMB350_DEBUG_REG(SYSOK),
SMB350_DEBUG_REG(AUTO_INPUT_VOLT_DETECT),
SMB350_DEBUG_REG(STATUS_IRQ),
SMB350_DEBUG_REG(I2C_SLAVE_ADDR),
SMB350_DEBUG_REG(CMD_A),
SMB350_DEBUG_REG(CMD_B),
SMB350_DEBUG_REG(CMD_C),
SMB350_DEBUG_REG(HW_VERSION),
SMB350_DEBUG_REG(IRQ_STATUS_A),
SMB350_DEBUG_REG(IRQ_STATUS_B),
SMB350_DEBUG_REG(IRQ_STATUS_C),
SMB350_DEBUG_REG(IRQ_STATUS_D),
SMB350_DEBUG_REG(IRQ_STATUS_E),
SMB350_DEBUG_REG(IRQ_STATUS_F),
SMB350_DEBUG_REG(STATUS_A),
SMB350_DEBUG_REG(STATUS_B),
SMB350_DEBUG_REG(STATUS_D),
SMB350_DEBUG_REG(STATUS_E),
};
/*
* Read 8-bit register value. return negative value on error.
*/
static int smb350_read_reg(struct i2c_client *client, u8 reg)
{
int val;
val = i2c_smbus_read_byte_data(client, reg);
if (val < 0)
pr_err("i2c read fail. reg=0x%x.ret=%d.\n", reg, val);
else
pr_debug("reg=0x%02X.val=0x%02X.\n", reg , val);
return val;
}
/*
* Write 8-bit register value. return negative value on error.
*/
static int smb350_write_reg(struct i2c_client *client, u8 reg, u8 val)
{
int ret;
ret = i2c_smbus_write_byte_data(client, reg, val);
if (ret < 0)
pr_err("i2c read fail. reg=0x%x.val=0x%x.ret=%d.\n",
reg, val, ret);
else
pr_debug("reg=0x%02X.val=0x%02X.\n", reg , val);
return ret;
}
static int smb350_masked_write(struct i2c_client *client, int reg, u8 mask,
u8 val)
{
int ret;
int temp;
int shift = find_first_bit((unsigned long *) &mask, 8);
temp = smb350_read_reg(client, reg);
if (temp < 0)
return temp;
temp &= ~mask;
temp |= (val << shift) & mask;
ret = smb350_write_reg(client, reg, temp);
return ret;
}
static bool smb350_is_dc_present(struct i2c_client *client)
{
u16 irq_status_f = smb350_read_reg(client, IRQ_STATUS_F_REG);
bool power_ok = irq_status_f & 0x01;
/* Power-ok , IRQ_STATUS_F_REG bit#0 */
if (power_ok)
pr_debug("DC is present.\n");
else
pr_debug("DC is missing.\n");
return power_ok;
}
static bool smb350_is_charger_present(struct i2c_client *client)
{
int val;
/* Normally the device is non-removable and embedded on the board.
* Verify that charger is present by getting I2C response.
*/
val = smb350_read_reg(client, STATUS_B_REG);
if (val < 0)
return false;
return true;
}
static int smb350_get_prop_charge_type(struct smb350_device *dev)
{
int status_b;
enum smb350_chg_status status;
int chg_type = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
bool chg_enabled;
bool charger_err;
struct i2c_client *client = dev->client;
status_b = smb350_read_reg(client, STATUS_B_REG);
if (status_b < 0) {
pr_err("failed to read STATUS_B_REG.\n");
return POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
}
chg_enabled = (bool) (status_b & 0x01);
charger_err = (bool) (status_b & (1<<6));
if (!chg_enabled) {
pr_warn("Charging not enabled.\n");
return POWER_SUPPLY_CHARGE_TYPE_NONE;
}
if (charger_err) {
pr_warn("Charger error detected.\n");
return POWER_SUPPLY_CHARGE_TYPE_NONE;
}
status = (status_b >> 1) & 0x3;
if (status == SMB_CHG_STATUS_NONE)
chg_type = POWER_SUPPLY_CHARGE_TYPE_NONE;
else if (status == SMB_CHG_STATUS_FAST_CHARGE) /* constant current */
chg_type = POWER_SUPPLY_CHARGE_TYPE_FAST;
else if (status == SMB_CHG_STATUS_TAPER_CHARGE) /* constant voltage */
chg_type = POWER_SUPPLY_CHARGE_TYPE_FAST;
else if (status == SMB_CHG_STATUS_PRE_CHARGE)
chg_type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
pr_debug("smb-chg-status=%d=%s.\n", status, smb350_chg_status[status]);
if (dev->chg_status != status) { /* Status changed */
if (status == SMB_CHG_STATUS_NONE) {
pr_debug("Charging stopped.\n");
wake_unlock(&dev->chg_wake_lock);
} else {
pr_debug("Charging started.\n");
wake_lock(&dev->chg_wake_lock);
}
}
dev->chg_status = status;
return chg_type;
}
static void smb350_enable_charging(struct smb350_device *dev, bool enable)
{
int val = !enable; /* active low */
pr_debug("enable=%d.\n", enable);
gpio_set_value_cansleep(dev->chg_en_n_gpio, val);
}
/* When the status bit of a certain condition is read,
* the corresponding IRQ signal is cleared.
*/
static int smb350_clear_irq(struct i2c_client *client)
{
int ret;
ret = smb350_read_reg(client, IRQ_STATUS_A_REG);
if (ret < 0)
return ret;
ret = smb350_read_reg(client, IRQ_STATUS_B_REG);
if (ret < 0)
return ret;
ret = smb350_read_reg(client, IRQ_STATUS_C_REG);
if (ret < 0)
return ret;
ret = smb350_read_reg(client, IRQ_STATUS_D_REG);
if (ret < 0)
return ret;
ret = smb350_read_reg(client, IRQ_STATUS_E_REG);
if (ret < 0)
return ret;
ret = smb350_read_reg(client, IRQ_STATUS_F_REG);
if (ret < 0)
return ret;
return 0;
}
/*
* Do the IRQ work from a thread context rather than interrupt context.
* Read status registers to clear interrupt source.
* Notify the power-supply driver about change detected.
* Relevant events for start/stop charging:
* 1. DC insert/remove
* 2. End-Of-Charging
* 3. Battery insert/remove
* 4. Temperture too hot/cold
* 5. Charging timeout expired.
*/
static void smb350_irq_worker(struct work_struct *work)
{
int ret = 0;
struct smb350_device *dev =
container_of(work, struct smb350_device, irq_work.work);
ret = smb350_clear_irq(dev->client);
if (ret == 0) { /* Cleared ok */
/* Notify Battery-psy about status changed */
pr_debug("Notify power_supply_changed.\n");
power_supply_changed(&dev->dc_psy);
}
}
/*
* The STAT pin is low when charging and high when not charging.
* When the smb350 start/stop charging the STAT pin triggers an interrupt.
* Interrupt is triggered on both rising or falling edge.
*/
static irqreturn_t smb350_irq(int irq, void *dev_id)
{
struct smb350_device *dev = dev_id;
pr_debug("\n");
/* I2C transfers API should not run in interrupt context */
schedule_delayed_work(&dev->irq_work, msecs_to_jiffies(100));
return IRQ_HANDLED;
}
static enum power_supply_property pm_power_props[] = {
/* real time */
POWER_SUPPLY_PROP_PRESENT,
POWER_SUPPLY_PROP_ONLINE,
POWER_SUPPLY_PROP_CHARGE_TYPE,
/* fixed */
POWER_SUPPLY_PROP_MANUFACTURER,
POWER_SUPPLY_PROP_MODEL_NAME,
POWER_SUPPLY_PROP_CURRENT_MAX,
};
static char *pm_power_supplied_to[] = {
"battery",
};
static int smb350_get_property(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
int ret = 0;
struct smb350_device *dev = container_of(psy,
struct smb350_device,
dc_psy);
struct i2c_client *client = dev->client;
switch (psp) {
case POWER_SUPPLY_PROP_PRESENT:
val->intval = smb350_is_charger_present(client);
break;
case POWER_SUPPLY_PROP_ONLINE:
val->intval = smb350_is_dc_present(client);
break;
case POWER_SUPPLY_PROP_CHARGE_TYPE:
val->intval = smb350_get_prop_charge_type(dev);
break;
case POWER_SUPPLY_PROP_MODEL_NAME:
val->strval = SMB350_NAME;
break;
case POWER_SUPPLY_PROP_MANUFACTURER:
val->strval = "Summit Microelectronics";
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
val->intval = dev->chg_current_ma;
break;
default:
pr_err("Invalid prop = %d.\n", psp);
ret = -EINVAL;
break;
}
return ret;
}
static int smb350_set_property(struct power_supply *psy,
enum power_supply_property psp,
const union power_supply_propval *val)
{
int ret = 0;
struct smb350_device *dev =
container_of(psy, struct smb350_device, dc_psy);
switch (psp) {
/*
* Allow a smart battery to Start/Stop charging.
* i.e. when End-Of-Charging detected.
* The SMB350 can be configured to terminate charging
* when charge-current reaching Termination-Current.
*/
case POWER_SUPPLY_PROP_ONLINE:
smb350_enable_charging(dev, val->intval);
break;
default:
pr_err("Invalid prop = %d.\n", psp);
ret = -EINVAL;
}
return ret;
}
static int smb350_set_chg_current(struct i2c_client *client, int current_ma)
{
int ret;
u8 temp;
if ((current_ma < SMB350_FAST_CHG_MIN_MA) ||
(current_ma > SMB350_FAST_CHG_MAX_MA)) {
pr_err("invalid current %d mA.\n", current_ma);
return -EINVAL;
}
temp = (current_ma - SMB350_FAST_CHG_MIN_MA) / SMB350_FAST_CHG_STEP_MA;
pr_debug("fast-chg-current=%d mA setting %02x\n", current_ma, temp);
ret = smb350_masked_write(client, CHG_CURRENT_REG,
FAST_CHG_CURRENT_MASK, temp);
return ret;
}
static int smb350_set_term_current(struct i2c_client *client, int current_ma)
{
int ret;
u8 temp;
if ((current_ma < SMB350_TERM_CUR_MIN_MA) ||
(current_ma > SMB350_TERM_CUR_MAX_MA)) {
pr_err("invalid current %d mA to set\n", current_ma);
return -EINVAL;
}
temp = (current_ma - SMB350_TERM_CUR_MIN_MA) / SMB350_TERM_CUR_STEP_MA;
pr_debug("term-current=%d mA setting %02x\n", current_ma, temp);
ret = smb350_masked_write(client, CHG_OTHER_CURRENT_REG,
TERM_CURRENT_MASK, temp);
return ret;
}
static int smb350_set_reg(void *data, u64 val)
{
u32 addr = (u32) data;
int ret;
struct i2c_client *client = smb350_dev->client;
ret = smb350_write_reg(client, addr, (u8) val);
return ret;
}
static int smb350_get_reg(void *data, u64 *val)
{
u32 addr = (u32) data;
int ret;
struct i2c_client *client = smb350_dev->client;
ret = smb350_read_reg(client, addr);
if (ret < 0)
return ret;
*val = ret;
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(reg_fops, smb350_get_reg, smb350_set_reg, "0x%02llx\n");
static int smb350_create_debugfs_entries(struct smb350_device *dev)
{
int i;
dev->dent = debugfs_create_dir(SMB350_NAME, NULL);
if (IS_ERR(dev->dent)) {
pr_err("smb350 driver couldn't create debugfs dir\n");
return -EFAULT;
}
for (i = 0 ; i < ARRAY_SIZE(smb350_debug_regs) ; i++) {
char *name = smb350_debug_regs[i].name;
u32 reg = smb350_debug_regs[i].reg;
struct dentry *file;
file = debugfs_create_file(name, 0644, dev->dent,
(void *) reg, &reg_fops);
if (IS_ERR(file)) {
pr_err("debugfs_create_file %s failed.\n", name);
return -EFAULT;
}
}
return 0;
}
static int smb350_set_volatile_params(struct smb350_device *dev)
{
int ret;
struct i2c_client *client = dev->client;
pr_debug("\n");
ret = smb350_write_reg(client, CMD_A_REG, CMD_A_VOLATILE_WR_PERM);
if (ret) {
pr_err("Failed to set VOLATILE_WR_PERM ret=%d\n", ret);
return ret;
}
/* Disable SMB350 pulse-IRQ mechanism,
* we use interrupts based on charging-status-transition
*/
/* Enable STATUS output (regardless of IRQ-pulses) */
smb350_masked_write(client, CMD_A_REG, BIT(0), 0);
/* Disable LED blinking - avoid periodic irq */
smb350_masked_write(client, PIN_ENABLE_CTRL_REG, BIT(7), 0);
/* Disable Failure SMB-IRQ */
ret = smb350_write_reg(client, FAULT_IRQ_REG, 0x00);
if (ret) {
pr_err("Failed to set FAULT_IRQ_REG ret=%d\n", ret);
return ret;
}
/* Disable Event IRQ */
ret = smb350_write_reg(client, IRQ_ENABLE_REG, 0x00);
if (ret) {
pr_err("Failed to set IRQ_ENABLE_REG ret=%d\n", ret);
return ret;
}
/* Enable charging/not-charging status output via STAT pin */
smb350_masked_write(client, STAT_TIMER_REG, BIT(5), 0);
/* Disable Automatic Recharge */
smb350_masked_write(client, CHG_CTRL_REG, BIT(7), 1);
/* Set fast-charge current */
ret = smb350_set_chg_current(client, dev->chg_current_ma);
if (ret) {
pr_err("Failed to set FAST_CHG_CURRENT ret=%d\n", ret);
return ret;
}
if (dev->term_current_ma > 0) {
/* Enable Current Termination */
smb350_masked_write(client, CHG_CTRL_REG, BIT(6), 0);
/* Set Termination current */
smb350_set_term_current(client, dev->term_current_ma);
} else {
/* Disable Current Termination */
smb350_masked_write(client, CHG_CTRL_REG, BIT(6), 1);
}
return 0;
}
static int __devinit smb350_register_psy(struct smb350_device *dev)
{
int ret;
dev->dc_psy.name = "dc";
dev->dc_psy.type = POWER_SUPPLY_TYPE_MAINS;
dev->dc_psy.supplied_to = pm_power_supplied_to;
dev->dc_psy.num_supplicants = ARRAY_SIZE(pm_power_supplied_to);
dev->dc_psy.properties = pm_power_props;
dev->dc_psy.num_properties = ARRAY_SIZE(pm_power_props);
dev->dc_psy.get_property = smb350_get_property;
dev->dc_psy.set_property = smb350_set_property;
ret = power_supply_register(&dev->client->dev,
&dev->dc_psy);
if (ret) {
pr_err("failed to register power_supply. ret=%d.\n", ret);
return ret;
}
return 0;
}
static int __devinit smb350_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
const struct smb350_platform_data *pdata;
struct device_node *dev_node = client->dev.of_node;
struct smb350_device *dev;
u8 version;
/* STAT pin change on start/stop charging */
u32 irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_BYTE_DATA)) {
pr_err("i2c func fail.\n");
return -EIO;
}
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev) {
pr_err("alloc fail.\n");
return -ENOMEM;
}
smb350_dev = dev;
dev->client = client;
if (dev_node) {
dev->chg_en_n_gpio =
of_get_named_gpio(dev_node, "summit,chg-en-n-gpio", 0);
pr_debug("chg_en_n_gpio = %d.\n", dev->chg_en_n_gpio);
dev->chg_susp_n_gpio =
of_get_named_gpio(dev_node,
"summit,chg-susp-n-gpio", 0);
pr_debug("chg_susp_n_gpio = %d.\n", dev->chg_susp_n_gpio);
dev->stat_gpio =
of_get_named_gpio(dev_node, "summit,stat-gpio", 0);
pr_debug("stat_gpio = %d.\n", dev->stat_gpio);
ret = of_property_read_u32(dev_node, "summit,chg-current-ma",
&(dev->chg_current_ma));
pr_debug("chg_current_ma = %d.\n", dev->chg_current_ma);
if (ret) {
pr_err("Unable to read chg_current.\n");
return ret;
}
ret = of_property_read_u32(dev_node, "summit,term-current-ma",
&(dev->term_current_ma));
pr_debug("term_current_ma = %d.\n", dev->term_current_ma);
if (ret) {
pr_err("Unable to read term_current_ma.\n");
return ret;
}
} else {
pdata = client->dev.platform_data;
if (pdata == NULL) {
pr_err("no platform data.\n");
return -EINVAL;
}
dev->chg_en_n_gpio = pdata->chg_en_n_gpio;
dev->chg_susp_n_gpio = pdata->chg_susp_n_gpio;
dev->stat_gpio = pdata->stat_gpio;
dev->chg_current_ma = pdata->chg_current_ma;
dev->term_current_ma = pdata->term_current_ma;
}
ret = gpio_request(dev->stat_gpio, "smb350_stat");
if (ret) {
pr_err("gpio_request failed for %d ret=%d\n",
dev->stat_gpio, ret);
goto err_stat_gpio;
}
dev->irq = gpio_to_irq(dev->stat_gpio);
pr_debug("irq#=%d.\n", dev->irq);
ret = gpio_request(dev->chg_susp_n_gpio, "smb350_suspend");
if (ret) {
pr_err("gpio_request failed for %d ret=%d\n",
dev->chg_susp_n_gpio, ret);
goto err_susp_gpio;
}
ret = gpio_request(dev->chg_en_n_gpio, "smb350_charger_enable");
if (ret) {
pr_err("gpio_request failed for %d ret=%d\n",
dev->chg_en_n_gpio, ret);
goto err_en_gpio;
}
i2c_set_clientdata(client, dev);
/* Disable battery charging by default on power up.
* Battery charging is enabled by BMS or Battery-Gauge
* by using the set_property callback.
*/
smb350_enable_charging(dev, false);
msleep(100);
gpio_set_value_cansleep(dev->chg_susp_n_gpio, 1); /* Normal */
msleep(100); /* Allow the device to exist shutdown */
/* I2C transaction allowed only after device exit suspend */
ret = smb350_read_reg(client, I2C_SLAVE_ADDR_REG);
if ((ret>>1) != client->addr) {
pr_err("No device.\n");
ret = -ENODEV;
goto err_no_dev;
}
version = smb350_read_reg(client, HW_VERSION_REG);
version &= 0x0F; /* bits 0..3 */
ret = smb350_set_volatile_params(dev);
if (ret)
goto err_set_params;
ret = smb350_register_psy(dev);
if (ret)
goto err_set_params;
ret = smb350_create_debugfs_entries(dev);
if (ret)
goto err_debugfs;
INIT_DELAYED_WORK(&dev->irq_work, smb350_irq_worker);
wake_lock_init(&dev->chg_wake_lock,
WAKE_LOCK_SUSPEND, SMB350_NAME);
ret = request_irq(dev->irq, smb350_irq, irq_flags,
"smb350_irq", dev);
if (ret) {
pr_err("request_irq %d failed.ret=%d\n", dev->irq, ret);
goto err_irq;
}
pr_info("HW Version = 0x%X.\n", version);
return 0;
err_irq:
err_debugfs:
if (dev->dent)
debugfs_remove_recursive(dev->dent);
err_no_dev:
err_set_params:
gpio_free(dev->chg_en_n_gpio);
err_en_gpio:
gpio_free(dev->chg_susp_n_gpio);
err_susp_gpio:
gpio_free(dev->stat_gpio);
err_stat_gpio:
kfree(smb350_dev);
smb350_dev = NULL;
pr_info("FAIL.\n");
return ret;
}
static int __devexit smb350_remove(struct i2c_client *client)
{
struct smb350_device *dev = i2c_get_clientdata(client);
power_supply_unregister(&dev->dc_psy);
gpio_free(dev->chg_en_n_gpio);
gpio_free(dev->chg_susp_n_gpio);
if (dev->stat_gpio)
gpio_free(dev->stat_gpio);
if (dev->irq)
free_irq(dev->irq, dev);
if (dev->dent)
debugfs_remove_recursive(dev->dent);
kfree(smb350_dev);
smb350_dev = NULL;
return 0;
}
static const struct i2c_device_id smb350_id[] = {
{SMB350_NAME, 0},
{},
};
MODULE_DEVICE_TABLE(i2c, smb350_id);
static const struct of_device_id smb350_match[] = {
{ .compatible = "summit,smb350-charger", },
{ },
};
static struct i2c_driver smb350_driver = {
.driver = {
.name = SMB350_NAME,
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(smb350_match),
},
.probe = smb350_probe,
.remove = __devexit_p(smb350_remove),
.id_table = smb350_id,
};
static int __init smb350_init(void)
{
return i2c_add_driver(&smb350_driver);
}
module_init(smb350_init);
static void __exit smb350_exit(void)
{
return i2c_del_driver(&smb350_driver);
}
module_exit(smb350_exit);
MODULE_DESCRIPTION("Driver for SMB350 charger chip");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("i2c:" SMB350_NAME);