blob: fc3277fe7ba507ef9e37ab310d7dd9dcdd25ae9e [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/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/power_supply.h>
#include <linux/slab.h>
struct smb137c_chip {
struct i2c_client *client;
struct power_supply psy;
struct power_supply *usb_psy;
struct mutex lock;
int charge_current_limit_ua;
int input_current_limit_ua;
int term_current_ua;
bool charging_enabled;
bool otg_mode_enabled;
bool charging_allowed;
bool usb_suspend_enabled;
};
struct input_current_config {
int current_limit_ua;
u8 cmd_b_reg;
u8 var_func_reg;
u8 input_cur_reg;
};
struct term_current_config {
int term_current_ua;
u8 charge_cur_reg;
};
#define INPUT_CURRENT(_current_limit_ua, _cmd_b_reg, _var_func_reg, \
_input_cur_reg) \
{ \
.current_limit_ua = _current_limit_ua, \
.cmd_b_reg = _cmd_b_reg, \
.var_func_reg = _var_func_reg, \
.input_cur_reg = _input_cur_reg, \
}
#define CHARGE_CURRENT_REG 0x00
#define CHARGE_CURRENT_FAST_CHG_MASK 0xE0
#define CHARGE_CURRENT_FAST_CHG_SHIFT 5
#define CHARGE_CURRENT_PRE_CHG_MASK 0x18
#define CHARGE_CURRENT_PRE_CHG_SHIFT 3
#define CHARGE_CURRENT_TERM_CUR_MASK 0x06
#define INPUT_CURRENT_REG 0x01
#define INPUT_CURRENT_LIMIT_MASK 0xE0
#define FLOAT_VOLTAGE_REG 0x02
#define FLOAT_VOLTAGE_MASK 0x7F
#define FLOAT_VOLTAGE_SHIFT 0
#define CTRL_A_REG 0x03
#define CTRL_A_AUTO_RECHARGE_MASK 0x80
#define CTRL_A_AUTO_RECHARGE_ENABLED 0x00
#define CTRL_A_AUTO_RECHARGE_DISABLED 0x80
#define CTRL_A_TERM_CUR_MASK 0x40
#define CTRL_A_TERM_CUR_ENABLED 0x00
#define CTRL_A_TERM_CUR_DISABLED 0x40
#define CTRL_A_THRESH_VOLTAGE_MASK 0x38
#define CTRL_A_THRESH_VOLTAGE_SHIFT 3
#define CTRL_A_VOUTL_MASK 0x02
#define CTRL_A_VOUTL_4250MV 0x00
#define CTRL_A_VOUTL_4460MV 0x02
#define CTRL_A_THERM_MONITOR_MASK 0x01
#define CTRL_A_THERM_MONITOR_ENABLED 0x01
#define CTRL_A_THERM_MONITOR_DISABLED 0x00
#define PIN_CTRL_REG 0x05
#define PIN_CTRL_DEAD_BATT_CHG_MASK 0x80
#define PIN_CTRL_DEAD_BATT_CHG_ENABLED 0x80
#define PIN_CTRL_DEAD_BATT_CHG_DISABLED 0x00
#define PIN_CTRL_OTG_LBR_MASK 0x20
#define PIN_CTRL_OTG 0x00
#define PIN_CTRL_LBR 0x20
#define PIN_CTRL_USB_CUR_LIMIT_MASK 0x10
#define PIN_CTRL_USB_CUR_LIMIT_REG 0x00
#define PIN_CTRL_USB_CUR_LIMIT_PIN 0x10
#define PIN_CTRL_CHG_EN_MASK 0x0C
#define PIN_CTRL_CHG_EN_REG_LOW 0x00
#define PIN_CTRL_CHG_EN_REG_HIGH 0x04
#define PIN_CTRL_CHG_EN_PIN_LOW 0x08
#define PIN_CTRL_CHG_EN_PIN_HIGH 0x0C
#define PIN_CTRL_OTG_CTRL_MASK 0x02
#define PIN_CTRL_OTG_CTRL_REG 0x00
#define PIN_CTRL_OTG_CTRL_PIN 0x02
#define OTG_CTRL_REG 0x06
#define OTG_CTRL_BMD_MASK 0x80
#define OTG_CTRL_BMD_ENABLED 0x80
#define OTG_CTRL_BMD_DISABLED 0x00
#define OTG_CTRL_AUTO_RECHARGE_MASK 0x40
#define OTG_CTRL_AUTO_RECHARGE_75MV 0x00
#define OTG_CTRL_AUTO_RECHARGE_120MV 0x40
#define TEMP_MON_REG 0x08
#define TEMP_MON_THERM_CURRENT_MASK 0xC0
#define TEMP_MON_THERM_CURRENT_SHIFT 6
#define TEMP_MON_TEMP_LOW_MASK 0x38
#define TEMP_MON_TEMP_LOW_SHIFT 3
#define TEMP_MON_TEMP_HIGH_MASK 0x07
#define TEMP_MON_TEMP_HIGH_SHIFT 0
#define SAFETY_TIMER_REG 0x09
#define SAFETY_TIMER_RELOAD_MASK 0x40
#define SAFETY_TIMER_RELOAD_ENABLED 0x40
#define SAFETY_TIMER_RELOAD_DISABLED 0x00
#define SAFETY_TIMER_CHG_TIMEOUT_MASK 0x0C
#define SAFETY_TIMER_CHG_TIMEOUT_SHIFT 2
#define SAFETY_TIMER_PRE_CHG_TIME_MASK 0x03
#define SAFETY_TIMER_PRE_CHG_TIME_SHIFT 0
#define VAR_FUNC_REG 0x0C
#define VAR_FUNC_USB_MODE_MASK 0x80
#define VAR_FUNC_USB_SUSPEND_CTRL_MASK 0x20
#define VAR_FUNC_USB_SUSPEND_CTRL_REG 0x00
#define VAR_FUNC_USB_SUSPEND_CTRL_PIN 0x20
#define VAR_FUNC_BMD_MASK 0x0C
#define VAR_FUNC_BMD_DISABLED 0x00
#define VAR_FUNC_BMD_ALGO_PERIODIC 0x04
#define VAR_FUNC_BMD_ALGO 0x08
#define VAR_FUNC_BMD_THERM 0x0C
#define CMD_A_REG 0x30
#define CMD_A_VOLATILE_WRITE_MASK 0x80
#define CMD_A_VOLATILE_WRITE_ALLOW 0x80
#define CMD_A_VOLATILE_WRITE_DISALLOW 0x00
#define CMD_A_FAST_CHG_MASK 0x40
#define CMD_A_FAST_CHG_ALLOW 0x40
#define CMD_A_FAST_CHG_DISALLOW 0x00
#define CMD_A_OTG_MASK 0x10
#define CMD_A_OTG_ENABLED 0x10
#define CMD_A_OTG_DISABLED 0x00
#define CMD_A_USB_SUSPEND_MASK 0x04
#define CMD_A_USB_SUSPEND_DISABLED 0x00
#define CMD_A_USB_SUSPEND_ENABLED 0x04
#define CMD_A_CHARGING_MASK 0x02
#define CMD_A_CHARGING_ENABLED 0x00
#define CMD_A_CHARGING_DISABLED 0x02
#define CMD_B_REG 0x31
#define CMD_B_USB_MODE_MASK 0x03
#define DEV_ID_REG 0x33
#define DEV_ID_PART_MASK 0x80
#define DEV_ID_PART_SMB137C 0x00
#define DEV_ID_GUI_REV_MASK 0x70
#define DEV_ID_GUI_REV_SHIFT 4
#define DEV_ID_SILICON_REV_MASK 0x0F
#define DEV_ID_SILICON_REV_SHIFT 0
#define IRQ_STAT_A_REG 0x35
#define IRQ_STAT_A_BATT_HOT 0x40
#define IRQ_STAT_A_BATT_COLD 0x10
#define IRQ_STAT_B_REG 0x36
#define IRQ_STAT_B_BATT_OVERVOLT 0x40
#define IRQ_STAT_B_BATT_MISSING 0x10
#define IRQ_STAT_B_BATT_UNDERVOLT 0x04
#define STAT_C_REG 0x3D
#define STAT_C_CHG_ERROR 0x40
#define STAT_C_VBATT_LEVEL_BELOW_2P1V 0x10
#define STAT_C_CHG_STAT_MASK 0x06
#define STAT_C_CHG_STAT_SHIFT 1
#define STAT_C_CHG_ENABLED 0x01
/* Charge status register values */
enum smb137c_charge_status {
CHARGE_STAT_NO_CHG = 0,
CHARGE_STAT_PRE_CHG = 1,
CHARGE_STAT_FAST_CHG = 2,
CHARGE_STAT_TAPER_CHG = 3,
};
#define PRE_CHARGE_CURRENT_MIN_UA 50000
#define PRE_CHARGE_CURRENT_MAX_UA 200000
#define PRE_CHARGE_CURRENT_STEP_UA 50000
#define FLOAT_VOLTAGE_MIN_UV 3460000
#define FLOAT_VOLTAGE_MAX_UV 4730000
#define FLOAT_VOLTAGE_STEP_UV 10000
#define PRE_CHG_THRESH_VOLTAGE_MIN_UV 2400000
#define PRE_CHG_THRESH_VOLTAGE_MAX_UV 3100000
#define PRE_CHG_THRESH_VOLTAGE_STEP_UV 100000
#define USB_MIN_CURRENT_UA 100000
static int smb137c_read_reg(struct smb137c_chip *chip, u8 reg, u8 *val)
{
int rc;
rc = i2c_smbus_read_byte_data(chip->client, reg);
if (rc < 0) {
pr_err("i2c_smbus_read_byte_data failed. reg=0x%02X, rc=%d\n",
reg, rc);
} else {
*val = rc;
rc = 0;
pr_debug("read(0x%02X)=0x%02X\n", reg, *val);
}
return rc;
}
static int smb137c_write_reg(struct smb137c_chip *chip, u8 reg, u8 val)
{
int rc;
rc = i2c_smbus_write_byte_data(chip->client, reg, val);
if (rc < 0)
pr_err("i2c_smbus_write_byte_data failed. reg=0x%02X, rc=%d\n",
reg, rc);
else
pr_debug("write(0x%02X)=0x%02X\n", reg, val);
return rc;
}
static int smb137c_masked_write_reg(struct smb137c_chip *chip, u8 reg, u8 mask,
u8 val)
{
u8 reg_val;
int rc;
pr_debug("masked write(0x%02X), mask=0x%02X, value=0x%02X\n", reg, mask,
val);
rc = smb137c_read_reg(chip, reg, &reg_val);
if (rc < 0)
return rc;
val = (reg_val & ~mask) | (val & mask);
if (val != reg_val)
rc = smb137c_write_reg(chip, reg, val);
return rc;
}
static int smb137c_enable_charging(struct smb137c_chip *chip)
{
int rc = 0;
chip->charging_allowed = true;
if (!chip->charging_enabled && chip->charge_current_limit_ua > 0) {
rc = smb137c_masked_write_reg(chip, CMD_A_REG,
CMD_A_CHARGING_MASK, CMD_A_CHARGING_ENABLED);
if (!rc)
chip->charging_enabled = true;
}
if (!rc)
dev_dbg(&chip->client->dev, "%s\n", __func__);
return rc;
}
static int smb137c_disable_charging(struct smb137c_chip *chip)
{
int rc = 0;
chip->charging_allowed = false;
if (chip->charging_enabled) {
rc = smb137c_masked_write_reg(chip, CMD_A_REG,
CMD_A_CHARGING_MASK, CMD_A_CHARGING_DISABLED);
if (!rc)
chip->charging_enabled = false;
}
if (!rc)
dev_dbg(&chip->client->dev, "%s\n", __func__);
return rc;
}
static int smb137c_enable_otg_mode(struct smb137c_chip *chip)
{
int rc = 0;
if (!chip->otg_mode_enabled) {
rc = smb137c_masked_write_reg(chip, CMD_A_REG, CMD_A_OTG_MASK,
CMD_A_OTG_ENABLED);
if (!rc)
chip->otg_mode_enabled = true;
}
if (!rc)
dev_dbg(&chip->client->dev, "%s\n", __func__);
return rc;
}
static int smb137c_disable_otg_mode(struct smb137c_chip *chip)
{
int rc = 0;
if (chip->otg_mode_enabled) {
rc = smb137c_masked_write_reg(chip, CMD_A_REG, CMD_A_OTG_MASK,
CMD_A_OTG_DISABLED);
if (!rc)
chip->otg_mode_enabled = false;
}
if (!rc)
dev_dbg(&chip->client->dev, "%s\n", __func__);
return rc;
}
static int smb137c_enable_usb_suspend(struct smb137c_chip *chip)
{
int rc = 0;
if (!chip->usb_suspend_enabled) {
rc = smb137c_masked_write_reg(chip, CMD_A_REG,
CMD_A_USB_SUSPEND_MASK, CMD_A_USB_SUSPEND_ENABLED);
if (!rc)
chip->usb_suspend_enabled = true;
}
if (!rc)
dev_dbg(&chip->client->dev, "%s\n", __func__);
return rc;
}
static int smb137c_disable_usb_suspend(struct smb137c_chip *chip)
{
int rc = 0;
if (chip->input_current_limit_ua > 0 && chip->usb_suspend_enabled) {
rc = smb137c_masked_write_reg(chip, CMD_A_REG,
CMD_A_USB_SUSPEND_MASK, CMD_A_USB_SUSPEND_DISABLED);
if (!rc)
chip->usb_suspend_enabled = false;
}
if (!rc)
dev_dbg(&chip->client->dev, "%s\n", __func__);
return rc;
}
static struct input_current_config supported_input_current[] = {
INPUT_CURRENT(100000, 0x00, 0x00, 0x00),
INPUT_CURRENT(150000, 0x00, 0x80, 0x00),
INPUT_CURRENT(500000, 0x02, 0x00, 0x00),
INPUT_CURRENT(700000, 0x01, 0x00, 0x00),
INPUT_CURRENT(800000, 0x01, 0x00, 0x20),
INPUT_CURRENT(900000, 0x01, 0x00, 0x40),
INPUT_CURRENT(1000000, 0x01, 0x00, 0x60),
INPUT_CURRENT(1100000, 0x01, 0x00, 0x80),
INPUT_CURRENT(1200000, 0x01, 0x00, 0xA0),
INPUT_CURRENT(1300000, 0x01, 0x00, 0xC0),
INPUT_CURRENT(1500000, 0x01, 0x00, 0xE0),
};
static int smb137c_set_usb_input_current_limit(struct smb137c_chip *chip,
int current_limit_ua)
{
struct input_current_config *config = NULL;
int rc = 0;
int i;
for (i = ARRAY_SIZE(supported_input_current) - 1; i >= 0; i--) {
if (current_limit_ua
>= supported_input_current[i].current_limit_ua) {
config = &supported_input_current[i];
break;
}
}
if (config) {
if (chip->input_current_limit_ua != config->current_limit_ua) {
rc = smb137c_masked_write_reg(chip, INPUT_CURRENT_REG,
INPUT_CURRENT_LIMIT_MASK, config->input_cur_reg);
if (rc)
return rc;
rc = smb137c_masked_write_reg(chip, VAR_FUNC_REG,
VAR_FUNC_USB_MODE_MASK, config->var_func_reg);
if (rc)
return rc;
rc = smb137c_masked_write_reg(chip, CMD_B_REG,
CMD_B_USB_MODE_MASK, config->cmd_b_reg);
if (rc)
return rc;
chip->input_current_limit_ua = config->current_limit_ua;
}
rc = smb137c_disable_usb_suspend(chip);
} else {
chip->input_current_limit_ua = 0;
rc = smb137c_enable_usb_suspend(chip);
}
if (!rc)
dev_dbg(&chip->client->dev, "%s: current=%d uA\n", __func__,
chip->input_current_limit_ua);
return rc;
}
static int fast_charge_current_ua[] = {
500000,
650000,
750000,
850000,
950000,
1100000,
1300000,
1500000,
};
static int smb137c_set_charge_current_limit(struct smb137c_chip *chip,
int current_limit_ua)
{
int fast_charge_limit_ua = 0;
int rc = 0;
u8 val = 0;
int i;
for (i = ARRAY_SIZE(fast_charge_current_ua) - 1; i >= 0; i--) {
if (current_limit_ua >= fast_charge_current_ua[i]) {
val = i << CHARGE_CURRENT_FAST_CHG_SHIFT;
fast_charge_limit_ua = fast_charge_current_ua[i];
break;
}
}
if (fast_charge_limit_ua
&& chip->charge_current_limit_ua != fast_charge_limit_ua)
rc = smb137c_masked_write_reg(chip, CHARGE_CURRENT_REG,
CHARGE_CURRENT_FAST_CHG_MASK, val);
else if (fast_charge_limit_ua == 0)
rc = smb137c_disable_charging(chip);
chip->charge_current_limit_ua = fast_charge_limit_ua;
if (!rc)
dev_dbg(&chip->client->dev, "%s: current=%d uA\n", __func__,
fast_charge_limit_ua);
return rc;
}
static int smb137c_get_charge_current_limit(struct smb137c_chip *chip)
{
int fast_charge_limit_ua = 0;
u8 val = 0;
int rc, i;
rc = smb137c_read_reg(chip, CHARGE_CURRENT_REG, &val);
if (rc)
return rc;
i = (val & CHARGE_CURRENT_FAST_CHG_MASK)
>> CHARGE_CURRENT_FAST_CHG_SHIFT;
if (i >= 0 && i < ARRAY_SIZE(fast_charge_current_ua))
fast_charge_limit_ua = fast_charge_current_ua[i];
dev_dbg(&chip->client->dev, "%s: current=%d uA\n", __func__,
fast_charge_limit_ua);
return fast_charge_limit_ua;
}
static struct term_current_config term_current_ua[] = {
{ 35000, 0x06},
{ 50000, 0x00},
{100000, 0x02},
{150000, 0x04},
};
static int smb137c_set_term_current(struct smb137c_chip *chip,
int current_limit_ua)
{
int term_current_limit_ua = 0;
int rc = 0;
u8 val = 0;
int i;
for (i = ARRAY_SIZE(term_current_ua) - 1; i >= 0; i--) {
if (current_limit_ua >= term_current_ua[i].term_current_ua) {
val = term_current_ua[i].charge_cur_reg;
term_current_limit_ua
= term_current_ua[i].term_current_ua;
break;
}
}
if (term_current_limit_ua) {
rc = smb137c_masked_write_reg(chip, CHARGE_CURRENT_REG,
CHARGE_CURRENT_TERM_CUR_MASK, val);
if (rc)
return rc;
rc = smb137c_masked_write_reg(chip, CTRL_A_REG,
CTRL_A_TERM_CUR_MASK, CTRL_A_TERM_CUR_ENABLED);
} else {
rc = smb137c_masked_write_reg(chip, CTRL_A_REG,
CTRL_A_TERM_CUR_MASK, CTRL_A_TERM_CUR_DISABLED);
}
if (!rc)
dev_dbg(&chip->client->dev, "%s: current=%d uA\n", __func__,
term_current_limit_ua);
return rc;
}
static int smb137c_set_pre_charge_current_limit(struct smb137c_chip *chip,
int current_limit_ua)
{
int setpoint, rc;
u8 val;
if (current_limit_ua < PRE_CHARGE_CURRENT_MIN_UA ||
current_limit_ua > PRE_CHARGE_CURRENT_MAX_UA) {
dev_err(&chip->client->dev, "%s: current limit out of bounds: %d\n",
__func__, current_limit_ua);
return -EINVAL;
}
setpoint = (current_limit_ua - PRE_CHARGE_CURRENT_MIN_UA)
/ PRE_CHARGE_CURRENT_STEP_UA;
val = setpoint << CHARGE_CURRENT_PRE_CHG_SHIFT;
rc = smb137c_masked_write_reg(chip, CHARGE_CURRENT_REG,
CHARGE_CURRENT_PRE_CHG_MASK, val);
if (!rc)
dev_dbg(&chip->client->dev, "%s: current=%d uA\n", __func__,
setpoint * PRE_CHARGE_CURRENT_STEP_UA
+ PRE_CHARGE_CURRENT_MIN_UA);
return rc;
}
static int smb137c_set_float_voltage(struct smb137c_chip *chip, int voltage_uv)
{
int setpoint, rc;
u8 val;
if (voltage_uv < FLOAT_VOLTAGE_MIN_UV ||
voltage_uv > FLOAT_VOLTAGE_MAX_UV) {
dev_err(&chip->client->dev, "%s: voltage out of bounds: %d\n",
__func__, voltage_uv);
return -EINVAL;
}
setpoint = (voltage_uv - FLOAT_VOLTAGE_MIN_UV) / FLOAT_VOLTAGE_STEP_UV;
val = setpoint << FLOAT_VOLTAGE_SHIFT;
rc = smb137c_masked_write_reg(chip, FLOAT_VOLTAGE_REG,
FLOAT_VOLTAGE_MASK, val);
if (!rc)
dev_dbg(&chip->client->dev, "%s: voltage=%d uV\n", __func__,
setpoint * FLOAT_VOLTAGE_STEP_UV + FLOAT_VOLTAGE_MIN_UV);
return rc;
}
static int smb137c_set_pre_charge_threshold_voltage(struct smb137c_chip *chip,
int voltage_uv)
{
int setpoint, rc;
u8 val;
if (voltage_uv < PRE_CHG_THRESH_VOLTAGE_MIN_UV ||
voltage_uv > PRE_CHG_THRESH_VOLTAGE_MAX_UV) {
dev_err(&chip->client->dev, "%s: voltage out of bounds: %d\n",
__func__, voltage_uv);
return -EINVAL;
}
setpoint = (voltage_uv - PRE_CHG_THRESH_VOLTAGE_MIN_UV)
/ PRE_CHG_THRESH_VOLTAGE_STEP_UV;
val = setpoint << CTRL_A_THRESH_VOLTAGE_SHIFT;
rc = smb137c_masked_write_reg(chip, CTRL_A_REG,
CTRL_A_THRESH_VOLTAGE_MASK, val);
if (!rc)
dev_dbg(&chip->client->dev, "%s: voltage=%d uV\n", __func__,
setpoint * PRE_CHG_THRESH_VOLTAGE_STEP_UV
+ PRE_CHG_THRESH_VOLTAGE_MIN_UV);
return rc;
}
static int smb137c_set_recharge_threshold_voltage(struct smb137c_chip *chip,
int voltage_uv)
{
int rc;
u8 val;
if (voltage_uv == 75000) {
val = OTG_CTRL_AUTO_RECHARGE_75MV;
} else if (voltage_uv == 120000) {
val = OTG_CTRL_AUTO_RECHARGE_120MV;
} else {
dev_err(&chip->client->dev, "%s: voltage out of bounds: %d\n",
__func__, voltage_uv);
return -EINVAL;
}
rc = smb137c_masked_write_reg(chip, OTG_CTRL_REG,
OTG_CTRL_AUTO_RECHARGE_MASK, val);
if (!rc)
dev_dbg(&chip->client->dev, "%s: voltage=%d uV\n", __func__,
voltage_uv);
return rc;
}
static int smb137c_set_system_voltage(struct smb137c_chip *chip, int voltage_uv)
{
int rc;
u8 val;
if (voltage_uv == 4250000) {
val = CTRL_A_VOUTL_4250MV;
} else if (voltage_uv == 4460000) {
val = CTRL_A_VOUTL_4460MV;
} else {
dev_err(&chip->client->dev, "%s: voltage out of bounds: %d\n",
__func__, voltage_uv);
return -EINVAL;
}
rc = smb137c_masked_write_reg(chip, CTRL_A_REG, CTRL_A_VOUTL_MASK, val);
if (!rc)
dev_dbg(&chip->client->dev, "%s: voltage=%d uV\n", __func__,
voltage_uv);
return rc;
}
static int charging_timeout[] = {
382,
764,
1527,
};
static int smb137c_set_charging_timeout(struct smb137c_chip *chip, int timeout)
{
int timeout_chosen = 0;
u8 val = 3 << SAFETY_TIMER_CHG_TIMEOUT_SHIFT;
int rc, i;
for (i = ARRAY_SIZE(charging_timeout) - 1; i >= 0; i--) {
if (timeout >= charging_timeout[i]) {
val = i << SAFETY_TIMER_CHG_TIMEOUT_SHIFT;
timeout_chosen = charging_timeout[i];
break;
}
}
rc = smb137c_masked_write_reg(chip, SAFETY_TIMER_REG,
SAFETY_TIMER_CHG_TIMEOUT_MASK, val);
if (!rc)
dev_dbg(&chip->client->dev, "%s: timeout=%d min\n", __func__,
timeout_chosen);
return rc;
}
static int pre_charge_timeout[] = {
48,
95,
191,
};
static int smb137c_set_pre_charge_timeout(struct smb137c_chip *chip,
int timeout)
{
int timeout_chosen = 0;
u8 val = 3 << SAFETY_TIMER_PRE_CHG_TIME_SHIFT;
int rc, i;
for (i = ARRAY_SIZE(pre_charge_timeout) - 1; i >= 0; i--) {
if (timeout >= pre_charge_timeout[i]) {
val = i << SAFETY_TIMER_PRE_CHG_TIME_SHIFT;
timeout_chosen = pre_charge_timeout[i];
break;
}
}
rc = smb137c_masked_write_reg(chip, SAFETY_TIMER_REG,
SAFETY_TIMER_PRE_CHG_TIME_MASK, val);
if (!rc)
dev_dbg(&chip->client->dev, "%s: timeout=%d min\n", __func__,
timeout_chosen);
return rc;
}
static int thermistor_current[] = {
100,
40,
20,
10,
};
static int smb137c_set_thermistor_current(struct smb137c_chip *chip,
int current_ua)
{
bool found = false;
u8 val = 0;
int rc, i;
for (i = 0; i < ARRAY_SIZE(thermistor_current); i++) {
if (current_ua == thermistor_current[i]) {
found = true;
val = i << TEMP_MON_THERM_CURRENT_SHIFT;
}
}
if (!found) {
dev_err(&chip->client->dev, "%s: current out of bounds: %d\n",
__func__, current_ua);
return -EINVAL;
}
rc = smb137c_masked_write_reg(chip, TEMP_MON_REG,
TEMP_MON_THERM_CURRENT_MASK, val);
if (!rc)
dev_dbg(&chip->client->dev, "%s: current=%d uA\n", __func__,
current_ua);
return 0;
}
static int smb137c_set_temperature_low_limit(struct smb137c_chip *chip,
int value)
{
int rc;
if (value < 0 || value > 7) {
dev_err(&chip->client->dev, "%s: temperature value out of bounds: %d\n",
__func__, value);
return -EINVAL;
}
rc = smb137c_masked_write_reg(chip, TEMP_MON_REG,
TEMP_MON_TEMP_LOW_MASK, value << TEMP_MON_TEMP_LOW_SHIFT);
if (!rc)
dev_dbg(&chip->client->dev, "%s: temperature value=%d\n",
__func__, value);
return rc;
}
static int smb137c_set_temperature_high_limit(struct smb137c_chip *chip,
int value)
{
int rc;
if (value < 0 || value > 7) {
dev_err(&chip->client->dev, "%s: temperature value out of bounds: %d\n",
__func__, value);
return -EINVAL;
}
rc = smb137c_masked_write_reg(chip, TEMP_MON_REG,
TEMP_MON_TEMP_HIGH_MASK, value << TEMP_MON_TEMP_HIGH_SHIFT);
if (!rc)
dev_dbg(&chip->client->dev, "%s: temperature value=%d\n",
__func__, value);
return rc;
}
static int charge_status_type_map[] = {
[CHARGE_STAT_NO_CHG] = POWER_SUPPLY_CHARGE_TYPE_NONE,
[CHARGE_STAT_PRE_CHG] = POWER_SUPPLY_CHARGE_TYPE_TRICKLE,
[CHARGE_STAT_FAST_CHG] = POWER_SUPPLY_CHARGE_TYPE_FAST,
[CHARGE_STAT_TAPER_CHG] = POWER_SUPPLY_CHARGE_TYPE_FAST,
};
static const char * const charge_status_name[] = {
[CHARGE_STAT_NO_CHG] = "none",
[CHARGE_STAT_PRE_CHG] = "pre-charge",
[CHARGE_STAT_FAST_CHG] = "fast-charge",
[CHARGE_STAT_TAPER_CHG] = "taper-charge",
};
static int smb137c_get_property_status(struct smb137c_chip *chip)
{
int status = POWER_SUPPLY_STATUS_DISCHARGING;
enum smb137c_charge_status charging_status;
bool charging_enabled;
bool charging_error;
int rc;
u8 val;
rc = smb137c_read_reg(chip, STAT_C_REG, &val);
if (rc)
return POWER_SUPPLY_STATUS_UNKNOWN;
charging_enabled = val & STAT_C_CHG_ENABLED;
charging_error = val & STAT_C_CHG_ERROR;
charging_status = (val & STAT_C_CHG_STAT_MASK) >> STAT_C_CHG_STAT_SHIFT;
if (charging_enabled && !charging_error
&& charging_status != CHARGE_STAT_NO_CHG)
status = POWER_SUPPLY_STATUS_CHARGING;
dev_dbg(&chip->client->dev, "%s: status=%s\n", __func__,
(status == POWER_SUPPLY_STATUS_CHARGING ? "charging"
: "discharging"));
return status;
}
static int smb137c_get_property_battery_present(struct smb137c_chip *chip)
{
int rc;
u8 val;
rc = smb137c_read_reg(chip, IRQ_STAT_B_REG, &val);
if (rc || (val & IRQ_STAT_B_BATT_MISSING))
return 0;
/* Treat battery voltage less than 2.1 V as battery not present. */
rc = smb137c_read_reg(chip, STAT_C_REG, &val);
if (rc || (val & STAT_C_VBATT_LEVEL_BELOW_2P1V))
return 0;
return 1;
}
static int smb137c_get_property_battery_health(struct smb137c_chip *chip)
{
int rc;
u8 val;
/* The health of a disconnected battery is unknown. */
if (!smb137c_get_property_battery_present(chip))
return POWER_SUPPLY_HEALTH_UNKNOWN;
rc = smb137c_read_reg(chip, IRQ_STAT_B_REG, &val);
if (rc)
return POWER_SUPPLY_HEALTH_UNKNOWN;
if (val & IRQ_STAT_B_BATT_OVERVOLT)
return POWER_SUPPLY_HEALTH_OVERVOLTAGE;
else if (val & IRQ_STAT_B_BATT_UNDERVOLT)
return POWER_SUPPLY_HEALTH_DEAD;
rc = smb137c_read_reg(chip, IRQ_STAT_A_REG, &val);
if (rc)
return POWER_SUPPLY_HEALTH_UNKNOWN;
if (val & IRQ_STAT_A_BATT_HOT)
return POWER_SUPPLY_HEALTH_OVERHEAT;
else if (val & IRQ_STAT_A_BATT_COLD)
return POWER_SUPPLY_HEALTH_COLD;
return POWER_SUPPLY_HEALTH_GOOD;
}
static int smb137c_get_property_charge_type(struct smb137c_chip *chip)
{
enum smb137c_charge_status status;
int charge_type = POWER_SUPPLY_CHARGE_TYPE_NONE;
bool charging_enabled;
bool charging_error;
int rc;
u8 val;
rc = smb137c_read_reg(chip, STAT_C_REG, &val);
if (rc)
return POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
charging_enabled = val & STAT_C_CHG_ENABLED;
charging_error = val & STAT_C_CHG_ERROR;
status = (val & STAT_C_CHG_STAT_MASK) >> STAT_C_CHG_STAT_SHIFT;
if (!charging_enabled) {
dev_dbg(&chip->client->dev, "%s: not charging\n", __func__);
} else if (charging_error) {
dev_warn(&chip->client->dev, "%s: charger error detected\n",
__func__);
} else {
charge_type = charge_status_type_map[status];
}
dev_dbg(&chip->client->dev, "%s: charging status=%s\n", __func__,
charge_status_name[status]);
return charge_type;
}
static enum power_supply_property smb137c_power_properties[] = {
POWER_SUPPLY_PROP_STATUS,
POWER_SUPPLY_PROP_HEALTH,
POWER_SUPPLY_PROP_PRESENT,
POWER_SUPPLY_PROP_CHARGING_ENABLED,
POWER_SUPPLY_PROP_CHARGE_TYPE,
POWER_SUPPLY_PROP_CURRENT_MAX,
POWER_SUPPLY_PROP_TECHNOLOGY,
POWER_SUPPLY_PROP_MODEL_NAME,
POWER_SUPPLY_PROP_MANUFACTURER,
};
static int smb137c_property_is_writeable(struct power_supply *psy,
enum power_supply_property psp)
{
switch (psp) {
case POWER_SUPPLY_PROP_CHARGING_ENABLED:
case POWER_SUPPLY_PROP_CURRENT_MAX:
return 1;
default:
break;
}
return 0;
}
static int smb137c_power_set_property(struct power_supply *psy,
enum power_supply_property psp,
const union power_supply_propval *val)
{
struct smb137c_chip *chip = container_of(psy, struct smb137c_chip, psy);
mutex_lock(&chip->lock);
switch (psp) {
case POWER_SUPPLY_PROP_CHARGING_ENABLED:
if (val->intval)
smb137c_enable_charging(chip);
else
smb137c_disable_charging(chip);
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
smb137c_set_charge_current_limit(chip, val->intval);
break;
default:
mutex_unlock(&chip->lock);
return -EINVAL;
}
mutex_unlock(&chip->lock);
power_supply_changed(&chip->psy);
return 0;
}
static int smb137c_power_get_property(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct smb137c_chip *chip = container_of(psy, struct smb137c_chip, psy);
mutex_lock(&chip->lock);
switch (psp) {
case POWER_SUPPLY_PROP_STATUS:
val->intval = smb137c_get_property_status(chip);
break;
case POWER_SUPPLY_PROP_HEALTH:
val->intval = smb137c_get_property_battery_health(chip);
break;
case POWER_SUPPLY_PROP_PRESENT:
val->intval = smb137c_get_property_battery_present(chip);
break;
case POWER_SUPPLY_PROP_CHARGING_ENABLED:
val->intval = chip->charging_enabled;
break;
case POWER_SUPPLY_PROP_CHARGE_TYPE:
val->intval = smb137c_get_property_charge_type(chip);
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
val->intval = chip->charge_current_limit_ua;
break;
case POWER_SUPPLY_PROP_TECHNOLOGY:
val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
break;
case POWER_SUPPLY_PROP_MODEL_NAME:
val->strval = "SMB137C";
break;
case POWER_SUPPLY_PROP_MANUFACTURER:
val->strval = "Summit Microelectronics";
break;
default:
mutex_unlock(&chip->lock);
return -EINVAL;
}
mutex_unlock(&chip->lock);
return 0;
}
static void smb137c_external_power_changed(struct power_supply *psy)
{
struct smb137c_chip *chip = container_of(psy, struct smb137c_chip, psy);
union power_supply_propval prop = {0,};
int scope = POWER_SUPPLY_SCOPE_DEVICE;
int current_limit = 0;
int online = 0;
int rc;
mutex_lock(&chip->lock);
dev_dbg(&chip->client->dev, "%s: start\n", __func__);
rc = chip->usb_psy->get_property(chip->usb_psy,
POWER_SUPPLY_PROP_ONLINE, &prop);
if (rc)
dev_err(&chip->client->dev, "%s: could not read USB online property, rc=%d\n",
__func__, rc);
else
online = prop.intval;
rc = chip->usb_psy->get_property(chip->usb_psy, POWER_SUPPLY_PROP_SCOPE,
&prop);
if (rc)
dev_err(&chip->client->dev, "%s: could not read USB scope property, rc=%d\n",
__func__, rc);
else
scope = prop.intval;
rc = chip->usb_psy->get_property(chip->usb_psy,
POWER_SUPPLY_PROP_CURRENT_MAX, &prop);
if (rc)
dev_err(&chip->client->dev, "%s: could not read USB current_max property, rc=%d\n",
__func__, rc);
else
current_limit = prop.intval;
if (scope == POWER_SUPPLY_SCOPE_SYSTEM) {
/* USB host mode */
smb137c_disable_charging(chip);
smb137c_enable_otg_mode(chip);
} else if (online) {
/* USB online in device mode */
smb137c_set_usb_input_current_limit(chip, current_limit);
smb137c_enable_charging(chip);
smb137c_disable_otg_mode(chip);
} else {
/* USB offline */
smb137c_disable_charging(chip);
smb137c_disable_otg_mode(chip);
smb137c_set_usb_input_current_limit(chip,
min(current_limit, USB_MIN_CURRENT_UA));
}
dev_dbg(&chip->client->dev, "%s: end\n", __func__);
mutex_unlock(&chip->lock);
power_supply_changed(&chip->psy);
}
static int __devinit smb137c_set_register_defaults(struct smb137c_chip *chip)
{
int rc;
u8 val, mask;
/* Allow volatile register writes. */
rc = smb137c_masked_write_reg(chip, CMD_A_REG,
CMD_A_VOLATILE_WRITE_MASK, CMD_A_VOLATILE_WRITE_ALLOW);
if (rc)
return rc;
/* Do not reset register values on USB reinsertion. */
rc = smb137c_masked_write_reg(chip, SAFETY_TIMER_REG,
SAFETY_TIMER_RELOAD_MASK, SAFETY_TIMER_RELOAD_DISABLED);
if (rc)
return rc;
/* Set various default control parameters. */
val = PIN_CTRL_DEAD_BATT_CHG_ENABLED | PIN_CTRL_OTG
| PIN_CTRL_USB_CUR_LIMIT_REG | PIN_CTRL_CHG_EN_REG_LOW
| PIN_CTRL_OTG_CTRL_REG;
mask = PIN_CTRL_DEAD_BATT_CHG_MASK | PIN_CTRL_OTG_LBR_MASK
| PIN_CTRL_USB_CUR_LIMIT_MASK | PIN_CTRL_CHG_EN_MASK
| PIN_CTRL_OTG_CTRL_MASK;
rc = smb137c_masked_write_reg(chip, PIN_CTRL_REG, mask, val);
if (rc)
return rc;
/* Disable charging, disable OTG mode, and allow fast-charge current. */
val = CMD_A_CHARGING_DISABLED | CMD_A_OTG_DISABLED
| CMD_A_FAST_CHG_ALLOW;
mask = CMD_A_CHARGING_MASK | CMD_A_OTG_MASK | CMD_A_FAST_CHG_MASK;
rc = smb137c_masked_write_reg(chip, CMD_A_REG, mask, val);
if (rc)
return rc;
/* Enable auto recharging and full-time THERM monitor. */
val = CTRL_A_AUTO_RECHARGE_ENABLED | CTRL_A_THERM_MONITOR_ENABLED;
mask = CTRL_A_AUTO_RECHARGE_MASK | CTRL_A_THERM_MONITOR_MASK;
rc = smb137c_masked_write_reg(chip, CTRL_A_REG, mask, val);
if (rc)
return rc;
/* Use register value instead of pin to control USB suspend. */
rc = smb137c_masked_write_reg(chip, VAR_FUNC_REG,
VAR_FUNC_USB_SUSPEND_CTRL_MASK, VAR_FUNC_USB_SUSPEND_CTRL_REG);
if (rc)
return rc;
return rc;
}
static int __devinit smb137c_apply_dt_configs(struct smb137c_chip *chip)
{
struct device *dev = &chip->client->dev;
struct device_node *node = chip->client->dev.of_node;
int ret, current_ma, voltage_mv, timeout, value;
int rc = 0;
/*
* All device tree parameters are optional so it is ok if read calls
* fail.
*/
ret = of_property_read_u32(node, "summit,chg-current-ma", &current_ma);
if (ret == 0) {
rc = smb137c_set_charge_current_limit(chip, current_ma * 1000);
if (rc) {
dev_err(dev, "%s: Failed to set charge current, rc=%d\n",
__func__, rc);
return rc;
}
} else {
chip->charge_current_limit_ua
= smb137c_get_charge_current_limit(chip);
rc = chip->charge_current_limit_ua;
if (rc < 0) {
dev_err(dev, "%s: Failed to get charge current, rc=%d\n",
__func__, rc);
return rc;
}
}
ret = of_property_read_u32(node, "summit,term-current-ma", &current_ma);
if (ret == 0) {
rc = smb137c_set_term_current(chip, current_ma * 1000);
if (rc) {
dev_err(dev, "%s: Failed to set termination current, rc=%d\n",
__func__, rc);
return rc;
}
}
ret = of_property_read_u32(node, "summit,pre-chg-current-ma",
&current_ma);
if (ret == 0) {
rc = smb137c_set_pre_charge_current_limit(chip,
current_ma * 1000);
if (rc) {
dev_err(dev, "%s: Failed to set pre-charge current limit, rc=%d\n",
__func__, rc);
return rc;
}
}
ret = of_property_read_u32(node, "summit,float-voltage-mv",
&voltage_mv);
if (ret == 0) {
rc = smb137c_set_float_voltage(chip, voltage_mv * 1000);
if (rc) {
dev_err(dev, "%s: Failed to set float voltage, rc=%d\n",
__func__, rc);
return rc;
}
}
ret = of_property_read_u32(node, "summit,thresh-voltage-mv",
&voltage_mv);
if (ret == 0) {
rc = smb137c_set_pre_charge_threshold_voltage(chip,
voltage_mv * 1000);
if (rc) {
dev_err(dev, "%s: Failed to set fast-charge threshold voltage, rc=%d\n",
__func__, rc);
return rc;
}
}
ret = of_property_read_u32(node, "summit,recharge-thresh-mv",
&voltage_mv);
if (ret == 0) {
rc = smb137c_set_recharge_threshold_voltage(chip,
voltage_mv * 1000);
if (rc) {
dev_err(dev, "%s: Failed to set recharge threshold voltage, rc=%d\n",
__func__, rc);
return rc;
}
}
ret = of_property_read_u32(node, "summit,system-voltage-mv",
&voltage_mv);
if (ret == 0) {
rc = smb137c_set_system_voltage(chip, voltage_mv * 1000);
if (rc) {
dev_err(dev, "%s: Failed to set system voltage, rc=%d\n",
__func__, rc);
return rc;
}
}
ret = of_property_read_u32(node, "summit,charging-timeout", &timeout);
if (ret == 0) {
rc = smb137c_set_charging_timeout(chip, timeout);
if (rc) {
dev_err(dev, "%s: Failed to set charging timeout, rc=%d\n",
__func__, rc);
return rc;
}
}
ret = of_property_read_u32(node, "summit,pre-charge-timeout", &timeout);
if (ret == 0) {
rc = smb137c_set_pre_charge_timeout(chip, timeout);
if (rc) {
dev_err(dev, "%s: Failed to set pre-charge timeout, rc=%d\n",
__func__, rc);
return rc;
}
}
ret = of_property_read_u32(node, "summit,therm-current-ua", &value);
if (ret == 0) {
rc = smb137c_set_thermistor_current(chip, value);
if (rc) {
dev_err(dev, "%s: Failed to set thermistor current, rc=%d\n",
__func__, rc);
return rc;
}
}
ret = of_property_read_u32(node, "summit,temperature-min", &value);
if (ret == 0) {
rc = smb137c_set_temperature_low_limit(chip, value);
if (rc) {
dev_err(dev, "%s: Failed to set low temperature limit, rc=%d\n",
__func__, rc);
return rc;
}
}
ret = of_property_read_u32(node, "summit,temperature-max", &value);
if (ret == 0) {
rc = smb137c_set_temperature_high_limit(chip, value);
if (rc) {
dev_err(dev, "%s: Failed to set high temperature limit, rc=%d\n",
__func__, rc);
return rc;
}
}
return rc;
}
static int __devinit smb137c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct smb137c_chip *chip;
struct device *dev = &client->dev;
struct device_node *node = client->dev.of_node;
int rc = 0;
int gui_rev, silicon_rev;
u8 dev_id;
if (!node) {
dev_err(dev, "%s: device tree information missing\n", __func__);
return -ENODEV;
}
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_BYTE_DATA)) {
dev_err(dev, "%s: SMBUS_BYTE_DATA unsupported\n", __func__);
return -EIO;
}
chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
if (!chip) {
dev_err(dev, "%s: devm_kzalloc failed\n", __func__);
return -ENOMEM;
}
mutex_init(&chip->lock);
chip->client = client;
i2c_set_clientdata(client, chip);
chip->usb_psy = power_supply_get_by_name("usb");
if (!chip->usb_psy) {
dev_dbg(dev, "%s: USB supply not found; deferring charger probe\n",
__func__);
return -EPROBE_DEFER;
}
rc = smb137c_read_reg(chip, DEV_ID_REG, &dev_id);
if (rc)
return rc;
if ((dev_id & DEV_ID_PART_MASK) != DEV_ID_PART_SMB137C) {
dev_err(dev, "%s: invalid device ID=0x%02X\n", __func__,
dev_id);
return -ENODEV;
}
gui_rev = (dev_id & DEV_ID_GUI_REV_MASK) >> DEV_ID_GUI_REV_SHIFT;
silicon_rev = (dev_id & DEV_ID_SILICON_REV_MASK)
>> DEV_ID_SILICON_REV_SHIFT;
rc = smb137c_set_register_defaults(chip);
if (rc)
return rc;
rc = smb137c_apply_dt_configs(chip);
if (rc)
return rc;
chip->psy.name = "battery";
chip->psy.type = POWER_SUPPLY_TYPE_BATTERY;
chip->psy.properties = smb137c_power_properties;
chip->psy.num_properties = ARRAY_SIZE(smb137c_power_properties);
chip->psy.get_property = smb137c_power_get_property;
chip->psy.set_property = smb137c_power_set_property;
chip->psy.property_is_writeable = smb137c_property_is_writeable;
chip->psy.external_power_changed = smb137c_external_power_changed;
rc = power_supply_register(dev, &chip->psy);
if (rc < 0) {
dev_err(dev, "%s: power_supply_register failed, rc=%d\n",
__func__, rc);
return rc;
}
smb137c_external_power_changed(&chip->psy);
dev_info(dev, "%s: SMB137C charger probed successfully, gui_rev=%d, silicon_rev=%d\n",
__func__, gui_rev, silicon_rev);
return rc;
}
static int __devexit smb137c_remove(struct i2c_client *client)
{
return 0;
}
static const struct i2c_device_id smb137c_id[] = {
{ .name = "smb137c", },
{},
};
MODULE_DEVICE_TABLE(i2c, smb137c_id);
static const struct of_device_id smb137c_match[] = {
{ .compatible = "summit,smb137c", },
{ },
};
static struct i2c_driver smb137c_driver = {
.driver = {
.name = "smb137c",
.owner = THIS_MODULE,
.of_match_table = smb137c_match,
},
.probe = smb137c_probe,
.remove = __devexit_p(smb137c_remove),
.id_table = smb137c_id,
};
static int __init smb137c_init(void)
{
return i2c_add_driver(&smb137c_driver);
}
module_init(smb137c_init);
static void __exit smb137c_exit(void)
{
return i2c_del_driver(&smb137c_driver);
}
module_exit(smb137c_exit);
MODULE_DESCRIPTION("SMB137C Charger");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("i2c:smb137c");