antifallobst
/
lineage_kernel_xcoverpro
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
lineage_kernel_xcoverpro/drivers/battery_v2/s2mu106_fuelgauge.c

2721 lines
81 KiB
C
Executable File
Raw Permalink Blame History

/*
* s2mu106_fuelgauge.c - S2MU106 Fuel Gauge Driver
*
* Copyright (C) 2018 Samsung Electronics, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* 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.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#define SINGLE_BYTE 1
#define TABLE_SIZE 22
#include "include/fuelgauge/s2mu106_fuelgauge.h"
#include <linux/of_gpio.h>
//#include "include/sec_charging_common.h"
static enum power_supply_property s2mu106_fuelgauge_props[] = {
POWER_SUPPLY_PROP_ONLINE,
};
#if defined(CONFIG_FUELGAUGE_S2MU106_USE_5MILLIOHM)
static void s2mu106_set_trim_5mohm(struct s2mu106_fuelgauge_data *fuelgauge);
#endif
static int s2mu106_get_vbat(struct s2mu106_fuelgauge_data *fuelgauge);
static int s2mu106_get_ocv(struct s2mu106_fuelgauge_data *fuelgauge);
static int s2mu106_get_current(struct s2mu106_fuelgauge_data *fuelgauge);
static int s2mu106_get_avgcurrent(struct s2mu106_fuelgauge_data *fuelgauge);
static int s2mu106_get_avgvbat(struct s2mu106_fuelgauge_data *fuelgauge);
static int s2mu106_read_reg_byte(struct i2c_client *client, int reg, void *data)
{
int ret = 0;
int cnt = 0;
ret = i2c_smbus_read_byte_data(client, reg);
if (ret < 0) {
while (ret < 0 && cnt < 5) {
ret = i2c_smbus_read_byte_data(client, reg);
cnt++;
dev_err(&client->dev,
"%s: I2C read Incorrect! reg:0x%x, data:0x%x, cnt:%d\n",
__func__, reg, *(u8 *)data, cnt);
}
if (cnt == 5)
dev_err(&client->dev,
"%s: I2C read Failed reg:0x%x, data:0x%x\n",
__func__, reg, *(u8 *)data);
}
*(u8 *)data = (u8)ret;
return ret;
}
static int s2mu106_write_and_verify_reg_byte(struct i2c_client *client, int reg, u8 data)
{
int ret, i = 0;
int i2c_corrupted_cnt = 0;
u8 temp = 0;
ret = i2c_smbus_write_byte_data(client, reg, data);
if (ret < 0) {
for (i = 0; i < 3; i++) {
ret = i2c_smbus_write_byte_data(client, reg, data);
if (ret >= 0)
break;
}
if (i >= 3)
dev_err(&client->dev, "%s: Error(%d)\n", __func__, ret);
}
/* Skip non-writable registers */
if ((reg == 0xee) || (reg == 0xef) || (reg == 0xf2) || (reg == 0xf3) ||
(reg == 0x0C) || (reg == 0x1e) || (reg == 0x1f) || (reg == 0x27)) {
return ret;
}
s2mu106_read_reg_byte(client, reg, &temp);
while ((temp != data) && (i2c_corrupted_cnt < 5)) {
dev_err(&client->dev,
"%s: I2C write Incorrect! REG: 0x%x Expected: 0x%x Real-Value: 0x%x\n",
__func__, reg, data, temp);
ret = i2c_smbus_write_byte_data(client, reg, data);
s2mu106_read_reg_byte(client, reg, &temp);
i2c_corrupted_cnt++;
}
if (i2c_corrupted_cnt == 5)
dev_err(&client->dev,
"%s: I2C write failed REG: 0x%x Expected: 0x%x\n",
__func__, reg, data);
return ret;
}
static int s2mu106_write_reg(struct i2c_client *client, int reg, u8 *buf)
{
#if SINGLE_BYTE
int ret = 0;
s2mu106_write_and_verify_reg_byte(client, reg, buf[0]);
s2mu106_write_and_verify_reg_byte(client, reg+1, buf[1]);
#else
int ret, i = 0;
ret = i2c_smbus_write_i2c_block_data(client, reg, 2, buf);
if (ret < 0) {
for (i = 0; i < 3; i++) {
ret = i2c_smbus_write_i2c_block_data(client, reg, 2, buf);
if (ret >= 0)
break;
}
if (i >= 3)
dev_err(&client->dev, "%s: Error(%d)\n", __func__, ret);
}
#endif
return ret;
}
static int s2mu106_read_reg(struct i2c_client *client, int reg, u8 *buf)
{
#if SINGLE_BYTE
int ret = 0;
u8 data1 = 0, data2 = 0;
s2mu106_read_reg_byte(client, reg, &data1);
s2mu106_read_reg_byte(client, reg+1, &data2);
buf[0] = data1;
buf[1] = data2;
#else
int ret = 0, i = 0;
ret = i2c_smbus_read_i2c_block_data(client, reg, 2, buf);
if (ret < 0) {
for (i = 0; i < 3; i++) {
ret = i2c_smbus_read_i2c_block_data(client, reg, 2, buf);
if (ret >= 0)
break;
}
if (i >= 3)
dev_err(&client->dev, "%s: Error(%d)\n", __func__, ret);
}
#endif
return ret;
}
static int calc_ttf(struct s2mu106_fuelgauge_data *fuelgauge,
union power_supply_propval *val)
{
struct cv_slope *cv_data = fuelgauge->cv_data;
int i, cc_time = 0, cv_time = 0;
int soc = fuelgauge->raw_capacity;
int charge_current = val->intval;
int design_cap = fuelgauge->ttf_capacity;
if (!cv_data || (val->intval <= 0)) {
pr_info("%s: no cv_data or val: %d\n", __func__, val->intval);
return -1;
}
for (i = 0; i < fuelgauge->cv_data_length; i++) {
if (charge_current >= cv_data[i].fg_current)
break;
}
i = i >= fuelgauge->cv_data_length ? fuelgauge->cv_data_length - 1 : i;
if (cv_data[i].soc < soc) {
for (i = 0; i < fuelgauge->cv_data_length; i++) {
if (soc <= cv_data[i].soc)
break;
}
cv_time =
((cv_data[i - 1].time - cv_data[i].time) * (cv_data[i].soc - soc)
/ (cv_data[i].soc - cv_data[i - 1].soc)) + cv_data[i].time;
} else { /* CC mode || NONE */
cv_time = cv_data[i].time;
cc_time =
design_cap * (cv_data[i].soc - soc) / val->intval * 3600 / 1000;
pr_debug("%s: cc_time: %d\n", __func__, cc_time);
if (cc_time < 0)
cc_time = 0;
}
pr_debug("%s: cap: %d, soc: %4d, T: %6d, avg: %4d, cv soc: %4d, i: %4d, val: %d\n",
__func__, design_cap, soc, cv_time + cc_time,
fuelgauge->current_avg, cv_data[i].soc, i, val->intval);
if (cv_time + cc_time >= 0)
return cv_time + cc_time + 60;
else
return 60; /* minimum 1minutes */
}
static void s2mu106_fg_test_read(struct i2c_client *client)
{
static int reg_list[] = {
0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0E, 0x0F,
0x10, 0x11, 0x14, 0x1A, 0x1B, 0x1E, 0x1F, 0x24, 0x25, 0x26,
0x27, 0x28, 0x29, 0x40, 0x41, 0x43, 0x44, 0x45, 0x48, 0x4A,
0x4B, 0x50, 0x51, 0x52, 0x53, 0x58, 0x59, 0x5A, 0x5B, 0x5C,
0x67
};
u8 data = 0;
char str[1016] = {0,};
int i = 0, reg_list_size = 0;
reg_list_size = ARRAY_SIZE(reg_list);
for (i = 0; i < reg_list_size; i++) {
s2mu106_read_reg_byte(client, reg_list[i], &data);
sprintf(str+strlen(str), "0x%02x:0x%02x, ", reg_list[i], data);
}
/* print buffer */
pr_info("[FG]%s: %s\n", __func__, str);
}
static void s2mu106_fg_periodic_read_power(struct s2mu106_fuelgauge_data *fuelgauge)
{
union power_supply_propval value;
int vchgin = 0, vwcin = 0, vsys = 0, ichgin = 0, iwcin = 0, itx = 0;
psy_do_property("s2mu106_pmeter", get, POWER_SUPPLY_PROP_VCHGIN, value);
vchgin = value.intval;
psy_do_property("s2mu106_pmeter", get, POWER_SUPPLY_PROP_VWCIN, value);
vwcin = value.intval;
psy_do_property("s2mu106_pmeter", get, POWER_SUPPLY_PROP_VSYS, value);
vsys = value.intval;
psy_do_property("s2mu106_pmeter", get, POWER_SUPPLY_PROP_ICHGIN, value);
ichgin = value.intval;
psy_do_property("s2mu106_pmeter", get, POWER_SUPPLY_PROP_IWCIN, value);
iwcin = value.intval;
#if defined(CONFIG_WIRELESS_TX_MODE)
psy_do_property("s2mu106_pmeter", get, POWER_SUPPLY_PROP_ITX, value);
itx = value.intval;
#endif
pr_info("%s: vchgin(%dmV),vwcin(%dmV),vsys(%dmV),ichgin(%dmA),iwcin(%dmA),itx(%dmA)\n",
__func__, vchgin, vwcin, vsys, ichgin, iwcin, itx);
}
int s2mu106_fg_check_current_level(struct s2mu106_fuelgauge_data *fuelgauge)
{
int ret_val = 500;
int temp = 0;
if (fuelgauge->cable_type == SEC_BATTERY_CABLE_USB)
return ret_val;
/* topoff current * 1.6 except USB */
temp = fuelgauge->topoff_current * 16;
ret_val = temp / 10;
return ret_val;
}
static void s2mu106_reset_fg(struct s2mu106_fuelgauge_data *fuelgauge)
{
int i;
u8 temp = 0;
mutex_lock(&fuelgauge->fg_lock);
/* step 0: [Surge test] initialize register of FG */
#if defined(CONFIG_BATTERY_AGE_FORECAST)
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x0E,
fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[0]);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x0F,
fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[1]);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x10,
fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[2]);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x11,
fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[3]);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x13,
fuelgauge->age_data_info[fuelgauge->fg_age_step].volt_mode_tuning);
fuelgauge->batcap_0x0E = fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[0];
fuelgauge->batcap_0x0F = fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[1];
#else
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x0E, fuelgauge->info.batcap[0]);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x0F, fuelgauge->info.batcap[1]);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x10, fuelgauge->info.batcap[2]);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x11, fuelgauge->info.batcap[3]);
fuelgauge->batcap_0x0E = fuelgauge->info.batcap[0];
fuelgauge->batcap_0x0F = fuelgauge->info.batcap[1];
#endif
/* After battery capacity update, set BATCAP_OCV_EN(0x0C[6]=1) */
s2mu106_read_reg_byte(fuelgauge->i2c, 0x0C, &temp);
temp |= 0x40;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x0C, temp);
#if defined(CONFIG_BATTERY_AGE_FORECAST)
for (i = 0x92; i <= 0xe9; i++) {
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, i,
fuelgauge->age_data_info[fuelgauge->fg_age_step].battery_table3[i - 0x92]);
}
for (i = 0xea; i <= 0xff; i++) {
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, i,
fuelgauge->age_data_info[fuelgauge->fg_age_step].battery_table4[i - 0xea]);
}
#else
for (i = 0x92; i <= 0xe9; i++)
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, i, fuelgauge->info.battery_table3[i - 0x92]);
for (i = 0xea; i <= 0xff; i++)
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, i, fuelgauge->info.battery_table4[i - 0xea]);
#endif
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x14, 0x67);
#if defined(CONFIG_BATTERY_AGE_FORECAST)
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x44,
fuelgauge->age_data_info[fuelgauge->fg_age_step].accum[0]);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x45, &temp);
temp &= 0xF0;
temp |= fuelgauge->age_data_info[fuelgauge->fg_age_step].accum[1];
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x45, temp);
#else
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x44, fuelgauge->info.accum[0]);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x45, &temp);
temp &= 0xF0;
temp |= fuelgauge->info.accum[1];
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x45, temp);
#endif
s2mu106_read_reg_byte(fuelgauge->i2c, 0x4B, &temp);
temp &= 0x8F;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4B, temp);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4A, 0x10);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x40, 0x08);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x41, 0x04);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x5C, fuelgauge->val_0x5C);
/* Dumpdone. Re-calculate SOC */
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x1E, 0x0F);
msleep(300);
/* If it was voltage mode, recover it */
if (fuelgauge->mode == HIGH_SOC_VOLTAGE_MODE) {
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4A, 0xFF);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x4B, &temp);
temp |= 0x70;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4B, temp);
}
mutex_unlock(&fuelgauge->fg_lock);
pr_info("%s: Reset FG completed\n", __func__);
}
static int s2mu106_fix_rawsoc_reset_fg(struct s2mu106_fuelgauge_data *fuelgauge)
{
int ret = 0, ui_soc = 0, f_soc = 0;
u8 data;
union power_supply_propval value;
if (!fuelgauge->psy_bat)
fuelgauge->psy_bat = power_supply_get_by_name("battery");
if (!fuelgauge->psy_bat)
return -EINVAL;
ret = power_supply_get_property(fuelgauge->psy_bat, POWER_SUPPLY_PROP_CAPACITY, &value);
if (ret < 0)
pr_err("%s: Fail to execute property\n", __func__);
dev_info(&fuelgauge->i2c->dev, "%s: UI SOC = %d\n", __func__, value.intval);
ui_soc = value.intval;
f_soc = (ui_soc << 8) / 100;
if (f_soc > 0xFF)
f_soc = 0xFF;
f_soc |= 0x1;
data = (u8)f_soc;
/* Set rawsoc fix & enable */
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x29, data);
s2mu106_reset_fg(fuelgauge);
/* Disable rawsoc fix */
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x29, 0x00);
dev_info(&fuelgauge->i2c->dev, "%s: Finish\n", __func__);
return ret;
}
static void s2mu106_fg_reset_capacity_by_jig_connection(struct s2mu106_fuelgauge_data *fuelgauge)
{
/* TODO : model data version check */
u8 data = 0;
s2mu106_read_reg_byte(fuelgauge->i2c, S2MU106_REG_FG_ID, &data);
data &= 0xF0;
data |= 0x0F; //set model data version 0xF for next boot up initializing fuelgague
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, S2MU106_REG_FG_ID, data);
pr_info("%s: set Model data version (0x%x)\n", __func__, data & 0x0F);
}
static void s2mu106_restart_gauging(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data[2];
pr_info("%s: Re-calculate SOC and voltage\n", __func__);
mutex_lock(&fuelgauge->fg_lock);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x1E, 0x0F);
msleep(300);
#if (TEMP_COMPEN)
/* Need to re-init temperature compensation */
fuelgauge->init_start = 1;
/* Make saved UI SOC invalid. Set S2MU106_REG_RSOC_R + 1 reg. */
data[0] = 0;
data[1] = 1;
s2mu106_write_reg(fuelgauge->i2c, S2MU106_REG_RSOC_R, data);
#endif
mutex_unlock(&fuelgauge->fg_lock);
}
static void s2mu106_init_regs(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 temp = 0;
pr_info("%s: s2mu106 fuelgauge initialize\n", __func__);
/* Save register values for surge check */
s2mu106_read_reg_byte(fuelgauge->i2c, 0x53, &temp);
fuelgauge->reg_OTP_53 = temp;
s2mu106_read_reg_byte(fuelgauge->i2c, 0x52, &temp);
fuelgauge->reg_OTP_52 = temp;
/* Disable VM3_flag_EN */
s2mu106_read_reg_byte(fuelgauge->i2c, S2MU106_REG_VM, &temp);
temp = temp & 0xFB;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, S2MU106_REG_VM, temp);
#if defined(CONFIG_BATTERY_AGE_FORECAST)
fuelgauge->batcap_0x0E = fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[0];
fuelgauge->batcap_0x0F = fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[1];
#else
fuelgauge->batcap_0x0E = fuelgauge->info.batcap[0];
fuelgauge->batcap_0x0F = fuelgauge->info.batcap[1];
#endif
}
static void s2mu106_alert_init(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data[2];
/* VBAT Threshold setting: 3.55V */
data[0] = 0x00 & 0x0f;
/* SOC Threshold setting */
data[0] = data[0] | (fuelgauge->pdata->fuel_alert_soc << 4);
data[1] = 0x00;
s2mu106_write_reg(fuelgauge->i2c, S2MU106_REG_IRQ_LVL, data);
}
static int s2mu106_set_temperature(struct s2mu106_fuelgauge_data *fuelgauge,
int temperature)
{
/*
* s2mu106 include temperature sensor so,
* do not need to set temperature value.
*/
return temperature;
}
static int s2mu106_get_temperature(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data[2];
u16 compliment;
int temperature = 0;
mutex_lock(&fuelgauge->fg_lock);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, S2MU106_REG_MONOUT_SEL, 0x18);
if (s2mu106_read_reg(fuelgauge->i2c, S2MU106_REG_MONOUT, data) < 0)
goto err;
/* pr_info("%s temp data = 0x%x 0x%x\n", __func__, data[0], data[1]); */
mutex_unlock(&fuelgauge->fg_lock);
compliment = (data[1] << 8) | (data[0]);
/* data[] store 2's compliment format number */
if (compliment & (0x1 << 15)) {
/* Negative */
temperature = -1 * ((~compliment & 0xFFFF) + 1);
} else {
temperature = compliment & 0x7FFF;
}
temperature = ((temperature * 100) >> 8)/10;
pr_info("%s: temperature (%d)\n", __func__, temperature);
return temperature;
err:
mutex_unlock(&fuelgauge->fg_lock);
return -ERANGE;
}
#if (TEMP_COMPEN)
static bool s2mu106_get_vm_status(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data = 0;
s2mu106_read_reg_byte(fuelgauge->i2c, S2MU106_REG_STATUS, &data);
return (data & (1 << 6)) ? true : false;
}
static int s2mu106_get_comp_socr(struct s2mu106_fuelgauge_data *fuelgauge)
{
int comp_socr = 0;
int t_socr = 0;
int i_socr = 0;
if (fuelgauge->temperature <= 0) {
i_socr = (-1) * fuelgauge->i_socr_coeff * fuelgauge->avg_curr;
t_socr = (((-1) * fuelgauge->low_t_compen_coeff) * fuelgauge->temperature
+ fuelgauge->t_socr_coeff) / 1000;
} else if (fuelgauge->temperature <= 200) {
i_socr = (-1) * fuelgauge->i_socr_coeff * fuelgauge->avg_curr;
t_socr = (((-1) * fuelgauge->t_compen_coeff) * fuelgauge->temperature
+ fuelgauge->t_socr_coeff) / 1000;
}
comp_socr = ((t_socr + 1) * i_socr) / 100000;
comp_socr = comp_socr - (comp_socr % 5);
if (comp_socr > 80)
comp_socr = 80;
else if (comp_socr < 0)
comp_socr = 0;
pr_info("%s: SOCr = %d, T_SOCr = %d, I_SOCr = %d\n", __func__,
comp_socr, t_socr, i_socr / 100000);
return comp_socr;
}
static int s2mu106_get_soc_map(struct s2mu106_fuelgauge_data *fuelgauge,
bool bat_charging, int comp_socr)
{
int soc_map = 0;
int curr = s2mu106_get_current(fuelgauge);
if (bat_charging || (fuelgauge->is_charging && curr >= 30)) {
if (fuelgauge->soc0i >= 9950)
soc_map = 10000;
else
soc_map =
((10040 - fuelgauge->socni) * (fuelgauge->rsoc - fuelgauge->soc0i)) /
(10000 - fuelgauge->soc0i) + fuelgauge->socni;
} else {
if (fuelgauge->soc0i < ((100 * comp_socr) + 50 + fuelgauge->soc_map_offset))
soc_map = 0;
else
soc_map =
((fuelgauge->socni - fuelgauge->soc_map_offset)
* (fuelgauge->rsoc - fuelgauge->soc0i))
/ (fuelgauge->soc0i - (100 * comp_socr)
- fuelgauge->soc_map_offset)
+ fuelgauge->socni;
}
if (soc_map > 10000)
soc_map = 10000;
else if (soc_map < 0)
soc_map = 0;
return soc_map;
}
static void s2mu106_temperature_compensation(struct s2mu106_fuelgauge_data *fuelgauge)
{
int soc_map = 0;
int ui_soc = 0;
u8 data[2];
fuelgauge->comp_socr = s2mu106_get_comp_socr(fuelgauge);
if (fuelgauge->init_start) {
fuelgauge->flag_mapping = true;
fuelgauge->pre_comp_socr = fuelgauge->comp_socr;
fuelgauge->pre_vm_status = fuelgauge->vm_status;
}
if ((fuelgauge->pre_comp_socr != fuelgauge->comp_socr) ||
(fuelgauge->pre_bat_charging != fuelgauge->bat_charging) ||
(fuelgauge->pre_vm_status != fuelgauge->vm_status) ||
(fuelgauge->pre_is_charging != fuelgauge->is_charging))
fuelgauge->flag_mapping = true;
if (fuelgauge->flag_mapping == true) {
if (fuelgauge->init_start) {
if (fuelgauge->temperature < fuelgauge->low_temp_limit) {
s2mu106_read_reg(fuelgauge->i2c, S2MU106_REG_RSOC_R, data);
if (data[1] == 0) {
ui_soc = (data[1] << 8) | (data[0]);
pr_info("%s: temperature is low. use saved UI SOC(%d)"
" for mapping, data[1] = 0x%02x, data[0] = 0x%02x\n",
__func__, ui_soc, data[1], data[0]);
fuelgauge->ui_soc = ui_soc;
fuelgauge->capacity_old = ui_soc;
if (fuelgauge->temperature < fuelgauge->low_temp_limit)
fuelgauge->initial_update_of_soc = false;
/* UI SOC unit is 1% */
ui_soc = ui_soc * 100;
fuelgauge->socni = ui_soc;
fuelgauge->soc0i = fuelgauge->rsoc;
} else {
pr_info("%s: temperature is low. but UI SOC is not saved\n",
__func__);
fuelgauge->socni = fuelgauge->rsoc;
fuelgauge->soc0i = fuelgauge->rsoc;
}
} else {
fuelgauge->socni = fuelgauge->rsoc;
fuelgauge->soc0i = fuelgauge->rsoc;
}
} else {
/* If the difference between SOC_M and SOC_R is 1% or more,
* SOC_R is mapped to follow SOC_M
*/
pr_info("%s: socni updated - SOC_M(%d), SOC_R(%d)\n",
__func__, fuelgauge->rsoc, fuelgauge->soc_r);
if (fuelgauge->rsoc > fuelgauge->soc_r + 100)
fuelgauge->soc_r += 10;
else if (fuelgauge->soc_r > fuelgauge->rsoc + 100)
fuelgauge->soc_r -= 10;
fuelgauge->socni = fuelgauge->soc_r;
fuelgauge->soc0i = fuelgauge->rsoc;
}
}
soc_map = s2mu106_get_soc_map(fuelgauge,
fuelgauge->bat_charging, fuelgauge->comp_socr);
if (fuelgauge->flag_mapping == true) {
if (fuelgauge->init_start) {
if (fuelgauge->temperature >= fuelgauge->low_temp_limit ||
((fuelgauge->temperature < fuelgauge->low_temp_limit) && (data[1] != 0))) {
fuelgauge->soc_r = soc_map;
fuelgauge->ui_soc = fuelgauge->soc_r / 100;
pr_info("%s: When Initial Mapping, UI SOC = %d, soc_r = soc_map = %d\n",
__func__, fuelgauge->ui_soc, fuelgauge->soc_r);
fuelgauge->capacity_old = fuelgauge->ui_soc;
}
}
}
#if !defined(INC_OK_EN)
/* Use is_charging flag for prevent SOC increase when not charging */
if ((fuelgauge->is_charging == false) && (soc_map > fuelgauge->soc_r)) {
if (fuelgauge->init_start)
fuelgauge->soc_r = soc_map;
else
pr_info("%s: Not charging, do not reflect SOC increase. soc_map = %d, soc_r = %d\n",
__func__, soc_map, fuelgauge->soc_r);
} else
fuelgauge->soc_r = soc_map;
#else
fuelgauge->soc_r = soc_map;
#endif
if (fuelgauge->vm_status && (fuelgauge->soc_r > fuelgauge->rsoc) &&
(fuelgauge->temperature <= fuelgauge->low_temp_limit))
fuelgauge->soc_r = fuelgauge->rsoc;
#if !(BATCAP_LEARN)
pr_info("%s: SOC_M = %d, Chg_stat = %d, VM = %d, flag_mapping = %d, avgCURR = %d, avgTEMP = %d, "
"SOCni = %d, SOC0i = %d, SOCr = %d, SOC_R = %d\n",
__func__, fuelgauge->rsoc, fuelgauge->bat_charging, fuelgauge->vm_status,
fuelgauge->flag_mapping, fuelgauge->avg_curr, fuelgauge->temperature,
fuelgauge->socni, fuelgauge->soc0i, fuelgauge->comp_socr, fuelgauge->soc_r);
#endif
fuelgauge->init_start = 0;
fuelgauge->pre_comp_socr = fuelgauge->comp_socr;
fuelgauge->pre_vm_status = fuelgauge->vm_status;
fuelgauge->pre_is_charging = fuelgauge->is_charging;
fuelgauge->pre_bat_charging = fuelgauge->bat_charging;
fuelgauge->flag_mapping = false;
/* Save UI SOC for maintain SOC, after low temperature reset */
data[0] = fuelgauge->ui_soc;
data[1] = 0;
s2mu106_write_reg(fuelgauge->i2c, S2MU106_REG_RSOC_R, data);
/* TODO: Print UI SOC & saved value for debugging */
s2mu106_read_reg(fuelgauge->i2c, S2MU106_REG_RSOC_R, data);
ui_soc = (data[1] << 8) | (data[0]);
pr_info("%s: saved UI SOC = %d, data[1] = 0x%02x, data[0] = 0x%02x\n",
__func__, ui_soc, data[1], data[0]);
}
#endif
#if (BATCAP_LEARN)
static int s2mu106_get_batcap_ocv(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data[2];
u32 batcap_ocv = 0;
if (s2mu106_read_reg(fuelgauge->i2c, S2MU106_REG_RBATCAP, data) < 0)
return -EINVAL;
dev_dbg(&fuelgauge->i2c->dev, "%s: data0 (%d) data1 (%d) \n", __func__, data[0], data[1]);
batcap_ocv = (data[0] + (data[1] << 8)) >> 2;
return batcap_ocv;
}
static int s2mu106_get_cycle(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data[2];
u16 compliment, cycle;
mutex_lock(&fuelgauge->fg_lock);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, S2MU106_REG_MONOUT_SEL, 0x27);
usleep_range(1000, 2000);
if (s2mu106_read_reg(fuelgauge->i2c, S2MU106_REG_MONOUT, data) < 0)
goto err;
compliment = (data[1] << 8) | (data[0]);
cycle = compliment;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, S2MU106_REG_MONOUT_SEL, 0x10);
mutex_unlock(&fuelgauge->fg_lock);
return cycle;
err:
mutex_unlock(&fuelgauge->fg_lock);
return -EINVAL;
}
void s2mu106_batcap_learning(struct s2mu106_fuelgauge_data *fuelgauge)
{
int bat_w = 0;
u8 data[2], temp = 0;
int range = (BAT_L_CON[5] == 0) ? 900:800;
int gap_cap = 0;
gap_cap = (fuelgauge->capcc * 1000) / fuelgauge->batcap_ocv;
if ((gap_cap > range) && (gap_cap < 1100)) {
if (BAT_L_CON[6])
bat_w = ((fuelgauge->batcap_ocv * 75) + (fuelgauge->capcc * 25)) / 100;
else
bat_w = ((fuelgauge->batcap_ocv * 90) + (fuelgauge->capcc * 10)) / 100;
if (BAT_L_CON[7]) {
fuelgauge->batcap_ocv_fin = bat_w;
bat_w = bat_w << 2;
data[1] = (u8)((bat_w >> 8) & 0x00ff);
data[0] = (u8)(bat_w & 0x00ff);
mutex_lock(&fuelgauge->fg_lock);
s2mu106_write_reg(fuelgauge->i2c, S2MU106_REG_RBATCAP, data);
/* After battery capacity update, set BATCAP_OCV_EN(0x0C[6]=1) */
s2mu106_read_reg_byte(fuelgauge->i2c, 0x0C, &temp);
temp |= 0x40;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x0C, temp);
mutex_unlock(&fuelgauge->fg_lock);
}
}
pr_info("%s: gap_cap = %d, capcc = %d, batcap_ocv = %d, bat_w = %d\n",
__func__, gap_cap, fuelgauge->capcc, fuelgauge->batcap_ocv, bat_w);
}
static int s2mu106_get_cap_cc(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data1 = 0, data0 = 0;
int cap_cc = 0;
s2mu106_read_reg_byte(fuelgauge->i2c, S2MU106_REG_CAPCC + 1, &data1);
s2mu106_read_reg_byte(fuelgauge->i2c, S2MU106_REG_CAPCC, &data0);
cap_cc = (data1 << 8) | data0;
if (cap_cc & (1 << 15)) {
cap_cc = (~cap_cc) + 1;
cap_cc = cap_cc / 2;
cap_cc = cap_cc * (-1);
}
else
cap_cc /= 2;
return cap_cc;
}
static int s2mu106_get_soh(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data1 = 0, data0 = 0;
int original = 0, ret = -1;
int batcap_ocv = s2mu106_get_batcap_ocv(fuelgauge);
data0 = fuelgauge->batcap_0x0E;
data1 = fuelgauge->batcap_0x0F;
original = (data1 << 8) | data0;
original = original >> 2;
if (original != 0) {
ret = (batcap_ocv * 100) / original;
if (ret > 100)
ret = 100;
} else
ret = 100;
pr_info("%s: original batcap = %d, new_batcap = %d, soh = %d\n",
__func__, original, batcap_ocv, ret);
return ret;
}
#endif
#if (BATCAP_LEARN) || (TEMP_COMPEN)
static bool s2mu106_get_bat_charging(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data = 0;
s2mu106_read_reg_byte(fuelgauge->i2c, S2MU106_REG_STATUS, &data);
return (data & (1 << 5)) ? true : false;
}
#endif
#if (BATCAP_LEARN) && (TEMP_COMPEN)
static int s2mu106_get_fullcharge_cap(struct s2mu106_fuelgauge_data *fuelgauge)
{
int ret = -1;
int batcap_ocv = s2mu106_get_batcap_ocv(fuelgauge);
ret = ((100 - fuelgauge->comp_socr) * batcap_ocv) / 100;
return ret;
}
static int s2mu106_get_remaining_cap(struct s2mu106_fuelgauge_data *fuelgauge)
{
int ret = -1;
int fcc = s2mu106_get_fullcharge_cap(fuelgauge);
ret = (fuelgauge->soc_r) * fcc / 10000;
pr_info("%s: fcc = %d, remaining_cap = %d\n", __func__, fcc, ret);
return ret;
}
#endif
#if defined(CONFIG_FUELGAUGE_S2MU106_USE_5MILLIOHM)
static void s2mu106_set_trim_5mohm(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 temp_58 = 0, temp_59 = 0, temp_5a = 0, temp_5b = 0, temp = 0;
u32 cslope = 0, coffset = 0;
s2mu106_read_reg_byte(fuelgauge->i2c, 0x58, &temp_58);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x59, &temp_59);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x5A, &temp_5a);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x5B, &temp_5b);
cslope = ((temp_5b & 0xF0) << 12) | (temp_59 << 8) | temp_58;
coffset = ((temp_5b & 0x0F) << 8) | temp_5a;
pr_info("%s: before cslope = 0x%x, coffset = 0x%x", __func__,
cslope, coffset);
cslope = (cslope ^ 0xFFFFF) + 1;
cslope = cslope * 2;
cslope = (cslope ^ 0xFFFFF) + 1;
if (coffset & (1 << 11)) {
coffset = (coffset ^ 0xFFF) + 1;
coffset = coffset * 2;
coffset = (coffset ^ 0xFFF) + 1;
} else {
coffset = coffset * 2;
}
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c,
0x58, (cslope & 0xFF));
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c,
0x59, (cslope & 0xFF00) >> 8);
temp = ((cslope & 0xF0000) >> 12) | ((coffset & 0xF00) >> 8);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c,
0x5B, temp);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c,
0x5A, (coffset & 0xFF));
/* Check written value */
s2mu106_read_reg_byte(fuelgauge->i2c, 0x58, &temp_58);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x59, &temp_59);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x5A, &temp_5a);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x5B, &temp_5b);
cslope = ((temp_5b & 0xF0) << 12) | (temp_59 << 8) | temp_58;
coffset = ((temp_5b & 0x0F) << 8) | temp_5a;
pr_info("%s: after cslope = 0x%x, coffset = 0x%x", __func__,
cslope, coffset);
}
#endif
static int s2mu106_get_rawsoc(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data[2], temp = 0;
u16 compliment;
u8 por_state = 0;
u8 reg_1E = 0;
u8 reg_OTP_52 = 0, reg_OTP_53 = 0;
u8 reg_0x67 = 0;
#if defined(CONFIG_CHARGER_S2MU106)
bool charging_enabled = false;
#endif
int ret = 0;
union power_supply_propval value = {0, };
int float_voltage = 0;
int avg_current = 0, avg_vbat = 0, vbat = 0, curr = 0;
u8 fg_mode_reg = 0;
#if (BATCAP_LEARN)
int BATCAP_L_VBAT;
#endif
int is_swelling_status = 0;
static int touch_low_voltage;
static int low_voltage_limit_cnt;
s2mu106_read_reg_byte(fuelgauge->i2c, 0x1F, &por_state);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x53, &reg_OTP_53);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x52, &reg_OTP_52);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x1E, &reg_1E);
dev_err(&fuelgauge->i2c->dev, "%s: OTP 52(%02x) 53(%02x), current 52(%02x) 53(%02x), "
"0x1F(%02x), 0x1E(%02x)\n", __func__, fuelgauge->reg_OTP_52, fuelgauge->reg_OTP_53,
reg_OTP_52, reg_OTP_53, por_state, reg_1E);
#if defined(CONFIG_CHARGER_S2MU106)
if (!fuelgauge->psy_chg)
fuelgauge->psy_chg = power_supply_get_by_name("s2mu106-charger");
if (!fuelgauge->psy_chg) {
dev_err(&fuelgauge->i2c->dev, "%s: s2mu106-charger psy failed\n", __func__);
return -EINVAL;
}
#endif
#if defined(CONFIG_BATTERY_AGE_FORECAST)
if ((((por_state != 0x00) || (reg_1E != 0x03)) && (fuelgauge->age_reset_status == 0)) ||
#else
if (((por_state != 0x00) || (reg_1E != 0x03)) ||
#endif
(fuelgauge->probe_done == true &&
(fuelgauge->reg_OTP_52 != reg_OTP_52 || fuelgauge->reg_OTP_53 != reg_OTP_53))) {
/* check charging enable */
#if defined(CONFIG_CHARGER_S2MU106)
ret = power_supply_get_property(fuelgauge->psy_chg, POWER_SUPPLY_PROP_CHARGING_ENABLED, &value);
if (ret < 0)
pr_err("%s: Fail to execute property\n", __func__);
charging_enabled = value.intval;
value.intval = SEC_BAT_CHG_MODE_CHARGING_OFF;
ret = power_supply_set_property(fuelgauge->psy_chg, POWER_SUPPLY_PROP_CHARGING_ENABLED, &value);
if (ret < 0)
pr_err("%s: Fail to execute property\n", __func__);
#endif
if (fuelgauge->reg_OTP_52 != reg_OTP_52 || fuelgauge->reg_OTP_53 != reg_OTP_53) {
#if defined(CONFIG_CHARGER_S2MU106)
ret = power_supply_set_property(fuelgauge->psy_chg, POWER_SUPPLY_PROP_FUELGAUGE_RESET, &value);
if (ret < 0)
pr_err("%s: Fail to execute property\n", __func__);
#endif
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x1F, 0x40);
msleep(50);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x1F, 0x01);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x53, &reg_OTP_53);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x52, &reg_OTP_52);
dev_err(&fuelgauge->i2c->dev, "1st reset after %s: OTP 52(%02x) 53(%02x) "
"current 52(%02x) 53(%02x)\n", __func__,
fuelgauge->reg_OTP_52, fuelgauge->reg_OTP_53, reg_OTP_52, reg_OTP_53);
if (fuelgauge->reg_OTP_52 != reg_OTP_52 || fuelgauge->reg_OTP_53 != reg_OTP_53) {
#if defined(CONFIG_CHARGER_S2MU106)
ret = power_supply_set_property(fuelgauge->psy_chg, POWER_SUPPLY_PROP_FUELGAUGE_RESET, &value);
if (ret < 0)
pr_err("%s: Fail to execute property\n", __func__);
#endif
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x1F, 0x40);
msleep(50);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x1F, 0x01);
dev_err(&fuelgauge->i2c->dev, "%s : 2nd reset\n", __func__);
}
}
dev_info(&fuelgauge->i2c->dev, "%s: FG reset\n", __func__);
s2mu106_fix_rawsoc_reset_fg(fuelgauge);
por_state = 0x00;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x1F, por_state);
#if defined(CONFIG_FUELGAUGE_S2MU106_USE_5MILLIOHM)
s2mu106_set_trim_5mohm(fuelgauge);
#endif
#if defined(CONFIG_CHARGER_S2MU106)
/* Recover charger status after f.g reset */
if (charging_enabled) {
value.intval = SEC_BAT_CHG_MODE_CHARGING;
ret = power_supply_set_property(fuelgauge->psy_chg, POWER_SUPPLY_PROP_CHARGING_ENABLED, &value);
if (ret < 0)
pr_err("%s: Fail to execute property\n", __func__);
}
#endif
}
mutex_lock(&fuelgauge->fg_lock);
if (s2mu106_read_reg(fuelgauge->i2c, S2MU106_REG_RSOC, data) < 0)
goto err;
mutex_unlock(&fuelgauge->fg_lock);
compliment = (data[1] << 8) | (data[0]);
/* data[] store 2's compliment format number */
if (compliment & (0x1 << 15)) {
/* Negative */
fuelgauge->rsoc = ((~compliment) & 0xFFFF) + 1;
fuelgauge->rsoc = (fuelgauge->rsoc * (-10000)) / (0x1 << 14);
} else {
fuelgauge->rsoc = compliment & 0x7FFF;
fuelgauge->rsoc = ((fuelgauge->rsoc * 10000) / (0x1 << 14));
}
avg_current = s2mu106_get_avgcurrent(fuelgauge);
avg_vbat = s2mu106_get_avgvbat(fuelgauge);
vbat = s2mu106_get_vbat(fuelgauge);
curr = s2mu106_get_current(fuelgauge);
if (!fuelgauge->psy_bat)
fuelgauge->psy_bat = power_supply_get_by_name("battery");
if (!fuelgauge->psy_bat) {
dev_err(&fuelgauge->i2c->dev, "%s: battery psy failed\n", __func__);
return -EINVAL;
}
if (!fuelgauge->init_battery_temp) {
ret = s2mu106_read_reg_byte(fuelgauge->i2c, 0x46, &temp);
if ((temp != 0) && (ret >= 0)) {
fuelgauge->temperature = (temp & (0x1 << 7)) ? (-1 * ((~temp & 0xFF) + 1)) : (temp & 0x7F);
fuelgauge->temperature *= 10;
/* recover default value */
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x46, 0x0);
} else {
fuelgauge->temperature = 300;
}
} else {
/* Get temperature from battery driver */
ret = power_supply_get_property(fuelgauge->psy_bat, POWER_SUPPLY_PROP_TEMP, &value);
if (ret < 0)
pr_err("%s: Fail to execute property\n", __func__);
fuelgauge->temperature = value.intval;
}
/* Get UI SOC from battery driver */
ret = power_supply_get_property(fuelgauge->psy_bat, POWER_SUPPLY_PROP_CAPACITY, &value);
if (ret < 0)
pr_err("%s: Fail to execute property\n", __func__);
fuelgauge->ui_soc = value.intval;
ret = power_supply_get_property(fuelgauge->psy_bat, POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &value);
if (ret < 0)
pr_err("%s: Fail to execute property\n", __func__);
else
is_swelling_status = value.intval;
#if (BATCAP_LEARN) || (TEMP_COMPEN)
fuelgauge->bat_charging = s2mu106_get_bat_charging(fuelgauge);
#endif
#if (TEMP_COMPEN)
fuelgauge->vm_status = s2mu106_get_vm_status(fuelgauge);
fuelgauge->avg_curr = avg_current;
s2mu106_temperature_compensation(fuelgauge);
dev_info(&fuelgauge->i2c->dev, "%s: current_soc (%d), compen_soc (%d), "
"previous_soc (%d), FG_mode(%s)\n",
__func__, fuelgauge->rsoc, fuelgauge->soc_r,
fuelgauge->info.soc, mode_to_str[fuelgauge->mode]);
fuelgauge->info.soc = fuelgauge->soc_r;
#else
dev_info(&fuelgauge->i2c->dev, "%s: current_soc (%d), previous_soc (%d), FG_mode(%s)\n",
__func__, fuelgauge->rsoc, fuelgauge->info.soc, mode_to_str[fuelgauge->mode]);
fuelgauge->info.soc = fuelgauge->rsoc;
#endif
#if defined(CONFIG_CHARGER_S2MU106)
ret = power_supply_get_property(fuelgauge->psy_chg, POWER_SUPPLY_PROP_VOLTAGE_MAX, &value);
if (ret < 0)
pr_err("%s: Fail to execute property\n", __func__);
float_voltage = value.intval;
#else
float_voltage = 4350;
#endif
float_voltage = (float_voltage * 996) / 1000;
s2mu106_read_reg_byte(fuelgauge->i2c, 0x4A, &fg_mode_reg);
dev_info(&fuelgauge->i2c->dev, "%s: UI SOC = %d, is_charging = %d, avg_vbat = %d, "
"float_voltage = %d, avg_current = %d, 0x4A = 0x%02x\n", __func__,
fuelgauge->ui_soc, fuelgauge->is_charging, avg_vbat,
float_voltage, avg_current, fg_mode_reg);
if (is_swelling_status) {
if (fuelgauge->mode == HIGH_SOC_VOLTAGE_MODE) {
fuelgauge->mode = CURRENT_MODE;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4A, 0x10);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x4B, &temp);
temp &= 0x8F;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4B, temp);
dev_info(&fuelgauge->i2c->dev, "%s: FG is in current mode\n", __func__);
}
} else {
if (((fuelgauge->is_charging == true) && (fuelgauge->ui_soc >= 98) && (avg_current > 50)) ||
((fuelgauge->is_charging == true) && (avg_vbat > float_voltage) &&
(avg_current < s2mu106_fg_check_current_level(fuelgauge) && (avg_current > 50)))) {
if (fuelgauge->mode == CURRENT_MODE) { /* switch to VOLTAGE_MODE */
fuelgauge->mode = HIGH_SOC_VOLTAGE_MODE;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4A, 0xFF);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x4B, &temp);
temp |= 0x70;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4B, temp);
dev_info(&fuelgauge->i2c->dev, "%s: FG is in high soc voltage mode\n", __func__);
}
} else if (avg_current < -50 || avg_current >= s2mu106_fg_check_current_level(fuelgauge)) {
if (fuelgauge->mode == HIGH_SOC_VOLTAGE_MODE) {
fuelgauge->mode = CURRENT_MODE;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4A, 0x10);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x4B, &temp);
temp &= 0x8F;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4B, temp);
dev_info(&fuelgauge->i2c->dev, "%s: FG is in current mode\n", __func__);
}
}
}
s2mu106_read_reg_byte(fuelgauge->i2c, 0x67, &reg_0x67);
if ((avg_vbat > 3400) && (fuelgauge->is_charging == true) &&
(fuelgauge->rsoc < 400) && ((reg_0x67 & 0x02) == 0x02)) {
reg_0x67 &= 0xFD;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x67, reg_0x67);
pr_info("%s: 0x67[1] = 0", __func__);
} else if ((fuelgauge->rsoc > 450) && ((reg_0x67 & 0x02) == 0x00)) {
reg_0x67 |= 0x02;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x67, reg_0x67);
pr_info("%s: 0x67[1] = 1", __func__);
}
#if (BATCAP_LEARN)
fuelgauge->capcc = s2mu106_get_cap_cc(fuelgauge);
fuelgauge->batcap_ocv = s2mu106_get_batcap_ocv(fuelgauge); // CC mode capacity
fuelgauge->cycle = s2mu106_get_cycle(fuelgauge);
BATCAP_L_VBAT = (BAT_L_CON[1] == 0) ? 4200:4100;
if (fuelgauge->temperature >= 200) {
if (fuelgauge->learn_start == false) {
if ((fuelgauge->rsoc < 1000) && (fuelgauge->cycle >= BAT_L_CON[0]))
fuelgauge->learn_start = true;
} else {
if ((fuelgauge->cond1_ok == false) && (fuelgauge->bat_charging == false))
goto batcap_learn_init;
if (fuelgauge->cond1_ok == false) {
if (fuelgauge->c1_count >= BAT_L_CON[2]) {
fuelgauge->cond1_ok = true;
fuelgauge->c1_count = 0;
} else {
if ((vbat >= BATCAP_L_VBAT) && (avg_current < BAT_L_CON[4]) &&
(fuelgauge->rsoc >= 9700)) {
fuelgauge->c1_count++;
} else {
fuelgauge->c1_count = 0;
}
}
} else {
if (fuelgauge->c2_count >= BAT_L_CON[3]) {
s2mu106_batcap_learning(fuelgauge);
goto batcap_learn_init;
} else {
if ((vbat >= (BATCAP_L_VBAT - 100)) && (avg_current > -30) &&
(avg_current < 30) && (fuelgauge->rsoc >= 9800)) {
fuelgauge->c2_count++;
} else {
fuelgauge->c2_count = 0;
if (avg_current <= -30)
goto batcap_learn_init;
}
}
}
}
} else {
batcap_learn_init:
fuelgauge->learn_start = false;
fuelgauge->cond1_ok = false;
fuelgauge->c1_count = 0;
fuelgauge->c2_count = 0;
}
#endif
#if (TEMP_COMPEN) && (BATCAP_LEARN)
fuelgauge->soh = s2mu106_get_soh(fuelgauge);
fuelgauge->capcc = s2mu106_get_cap_cc(fuelgauge);
fuelgauge->fcc = s2mu106_get_fullcharge_cap(fuelgauge);
fuelgauge->rmc = s2mu106_get_remaining_cap(fuelgauge);
pr_info("%s: SOC_M = %d, Chg_stat = %d, VM = %d, avbVBAT = %d, avgCURR = %d, avgTEMP = %d, "
"SOCni = %d, SOC0i = %d, SOCr = %d, SOC_R = %d, "
"Learning_start = %d, C1_count = %d/%d, C2_count = %d/%d, "
"BATCAP_OCV_new = %d, SOH = %d, CAP_CC = %d, FCC = %d, RM = %d\n",
__func__,
fuelgauge->rsoc, fuelgauge->bat_charging, fuelgauge->vm_status, avg_vbat, avg_current, fuelgauge->temperature,
fuelgauge->socni, fuelgauge->soc0i, fuelgauge->comp_socr, fuelgauge->soc_r,
fuelgauge->learn_start, fuelgauge->c1_count, BAT_L_CON[2], fuelgauge->c2_count, BAT_L_CON[3],
fuelgauge->batcap_ocv_fin, fuelgauge->soh, fuelgauge->capcc, fuelgauge->fcc, fuelgauge->rmc);
#endif
/* Low voltage W/A, make 0% */
if (fuelgauge->temperature > fuelgauge->low_temp_limit) {
if ((avg_vbat < fuelgauge->low_voltage_limit) &&
(avg_current < -50) && (fuelgauge->rsoc > 300)) {
low_voltage_limit_cnt++;
if (low_voltage_limit_cnt >= fuelgauge->low_voltage_limit_cnt) {
dev_info(&fuelgauge->i2c->dev, "%s: Low voltage WA in normal temperature.\n", __func__);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x29, 0x07);
/* Dumpdone. Re-calculate SOC */
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x1E, 0x0F);
msleep(300);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x29, &temp);
temp &= 0xFE;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x29, temp);
low_voltage_limit_cnt = 0;
#if (TEMP_COMPEN)
fuelgauge->flag_mapping = false;
#endif
}
} else {
low_voltage_limit_cnt = 0;
}
} else {
if ((avg_vbat < fuelgauge->low_voltage_limit_lowtemp) &&
(avg_current < -50) && (fuelgauge->info.soc > 100)) {
dev_info(&fuelgauge->i2c->dev, "%s: Low voltage WA in Low temperature. Make UI SOC 0\n", __func__);
/* Make report SOC 0% */
fuelgauge->info.soc = 0;
#if (TEMP_COMPEN)
fuelgauge->soc_r = 0;
#endif
touch_low_voltage = true;
}
}
/* Low voltage W/A, Maintain UI SOC if battery is relaxing */
if (touch_low_voltage &&
(fuelgauge->soc_r == 0) && (fuelgauge->ui_soc > 5)
&& (avg_vbat > fuelgauge->low_voltage_recover_lowtemp)) {
fuelgauge->soc_r = fuelgauge->ui_soc * 100;
fuelgauge->info.soc = fuelgauge->soc_r;
fuelgauge->init_start = 1;
touch_low_voltage = false;
dev_info(&fuelgauge->i2c->dev,
"%s: Maintain UI SOC by Volt if battery is relaxing SOC_R = %d, info.soc = %d\n",
__func__, fuelgauge->soc_r, fuelgauge->info.soc);
}
#if (TEMP_COMPEN)
/* Low temperature W/A, Maintain UI SOC if battery is relaxing */
if (((fuelgauge->temperature < fuelgauge->low_temp_limit) &&
(fuelgauge->soc_r == 0) && (fuelgauge->ui_soc > 10)) &&
(((avg_current > -60) && (avg_current < 50)) || ((curr > -100) && (curr < 50)))) {
fuelgauge->soc_r = fuelgauge->ui_soc * 100;
fuelgauge->info.soc = fuelgauge->soc_r;
fuelgauge->init_start = 1;
dev_info(&fuelgauge->i2c->dev,
"%s: Maintain UI SOC if battery is relaxing SOC_R = %d, info.soc = %d\n",
__func__, fuelgauge->soc_r, fuelgauge->info.soc);
}
#endif
/* S2MU106 FG debug */
s2mu106_fg_test_read(fuelgauge->i2c);
return min(fuelgauge->info.soc, 10000);
err:
mutex_unlock(&fuelgauge->fg_lock);
return -EINVAL;
}
static int s2mu106_get_current(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data[2];
u16 compliment;
int curr = 0;
if (s2mu106_read_reg(fuelgauge->i2c, S2MU106_REG_RCUR_CC, data) < 0)
return -EINVAL;
compliment = (data[1] << 8) | (data[0]);
dev_dbg(&fuelgauge->i2c->dev, "%s: rCUR_CC(0x%4x)\n", __func__, compliment);
if (compliment & (0x1 << 15)) { /* Charging */
curr = ((~compliment) & 0xFFFF) + 1;
curr = (curr * 1000) >> 12;
} else { /* dischaging */
curr = compliment & 0x7FFF;
curr = (curr * (-1000)) >> 12;
}
dev_info(&fuelgauge->i2c->dev, "%s: current (%d)mA\n", __func__, curr);
return curr;
}
static int s2mu106_get_ocv(struct s2mu106_fuelgauge_data *fuelgauge)
{
/* 22 values of mapping table for EVT1*/
int *soc_arr;
int *ocv_arr;
int soc = fuelgauge->info.soc;
int ocv = 0;
int high_index = TABLE_SIZE - 1;
int low_index = 0;
int mid_index = 0;
#if defined(CONFIG_BATTERY_AGE_FORECAST)
soc_arr = fuelgauge->age_data_info[fuelgauge->fg_age_step].soc_arr_val;
ocv_arr = fuelgauge->age_data_info[fuelgauge->fg_age_step].ocv_arr_val;
#else
soc_arr = fuelgauge->info.soc_arr_val;
ocv_arr = fuelgauge->info.ocv_arr_val;
#endif
dev_err(&fuelgauge->i2c->dev,
"%s: soc (%d) soc_arr[TABLE_SIZE-1] (%d) ocv_arr[TABLE_SIZE-1) (%d)\n",
__func__, soc, soc_arr[TABLE_SIZE-1], ocv_arr[TABLE_SIZE-1]);
if (soc <= soc_arr[high_index]) {
ocv = ocv_arr[high_index];
goto ocv_soc_mapping;
} else if (soc >= soc_arr[low_index]) {
ocv = ocv_arr[low_index];
goto ocv_soc_mapping;
}
while (low_index <= high_index) {
mid_index = (low_index + high_index) >> 1;
if (soc_arr[mid_index] > soc)
low_index = mid_index + 1;
else if (soc_arr[mid_index] < soc)
high_index = mid_index - 1;
else {
ocv = ocv_arr[mid_index];
goto ocv_soc_mapping;
}
}
high_index = (high_index < 0) ? 0 : high_index;
low_index = (low_index > TABLE_SIZE - 1) ? TABLE_SIZE - 1 : low_index;
ocv = ocv_arr[high_index];
ocv += ((ocv_arr[low_index] - ocv_arr[high_index]) *
(soc - soc_arr[high_index])) /
(soc_arr[low_index] - soc_arr[high_index]);
ocv_soc_mapping:
s2mu106_fg_periodic_read_power(fuelgauge);
dev_info(&fuelgauge->i2c->dev, "%s: soc (%d), ocv (%d)\n", __func__, soc, ocv);
return ocv;
}
static int s2mu106_get_avgcurrent(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data[2];
u16 compliment;
int curr = 0;
mutex_lock(&fuelgauge->fg_lock);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, S2MU106_REG_MONOUT_SEL, 0x17);
if (s2mu106_read_reg(fuelgauge->i2c, S2MU106_REG_MONOUT, data) < 0)
goto err;
compliment = (data[1] << 8) | (data[0]);
dev_dbg(&fuelgauge->i2c->dev, "%s: MONOUT(0x%4x)\n", __func__, compliment);
if (compliment & (0x1 << 15)) { /* Charging */
curr = ((~compliment) & 0xFFFF) + 1;
curr = (curr * 1000) >> 12;
} else { /* dischaging */
curr = compliment & 0x7FFF;
curr = (curr * (-1000)) >> 12;
}
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, S2MU106_REG_MONOUT_SEL, 0x10);
mutex_unlock(&fuelgauge->fg_lock);
dev_info(&fuelgauge->i2c->dev, "%s: avg current (%d)mA\n", __func__, curr);
return curr;
err:
mutex_unlock(&fuelgauge->fg_lock);
return -EINVAL;
}
static int s2mu106_maintain_avgcurrent(
struct s2mu106_fuelgauge_data *fuelgauge)
{
static int cnt;
int vcell = 0;
int curr = 0;
curr = s2mu106_get_avgcurrent(fuelgauge);
vcell = s2mu106_get_vbat(fuelgauge);
if ((cnt < 10) && (curr < 0) && (fuelgauge->is_charging) &&
(vcell < 3500)) {
curr = 1;
cnt++;
dev_info(&fuelgauge->i2c->dev, "%s: vcell (%d)mV, modified avg current (%d)mA\n",
__func__, vcell, curr);
}
return curr;
}
static int s2mu106_get_vbat(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data[2];
u32 vbat = 0;
if (s2mu106_read_reg(fuelgauge->i2c, S2MU106_REG_RVBAT, data) < 0)
return -EINVAL;
dev_dbg(&fuelgauge->i2c->dev, "%s: data0 (%d) data1 (%d)\n", __func__, data[0], data[1]);
vbat = ((data[0] + (data[1] << 8)) * 1000) >> 13;
dev_info(&fuelgauge->i2c->dev, "%s: vbat (%d)\n", __func__, vbat);
return vbat;
}
static int s2mu106_get_avgvbat(struct s2mu106_fuelgauge_data *fuelgauge)
{
u8 data[2];
u16 compliment, avg_vbat;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x40, 0x08);
mutex_lock(&fuelgauge->fg_lock);
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, S2MU106_REG_MONOUT_SEL, 0x16);
usleep_range(1000, 2000);
if (s2mu106_read_reg(fuelgauge->i2c, S2MU106_REG_MONOUT, data) < 0)
goto err;
compliment = (data[1] << 8) | (data[0]);
avg_vbat = (compliment * 1000) >> 12;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, S2MU106_REG_MONOUT_SEL, 0x10);
mutex_unlock(&fuelgauge->fg_lock);
dev_info(&fuelgauge->i2c->dev, "%s: avgvbat (%d)\n", __func__, avg_vbat);
return avg_vbat;
err:
mutex_unlock(&fuelgauge->fg_lock);
return -EINVAL;
}
bool s2mu106_fuelgauge_fuelalert_init(struct i2c_client *client, int soc)
{
struct s2mu106_fuelgauge_data *fuelgauge = i2c_get_clientdata(client);
u8 data[2];
fuelgauge->is_fuel_alerted = false;
/* 1. Set s2mu106 alert configuration. */
s2mu106_alert_init(fuelgauge);
if (s2mu106_read_reg(client, S2MU106_REG_IRQ, data) < 0)
return -1;
/*Enable VBAT, SOC */
data[1] &= 0xfc;
/*Disable IDLE_ST, INIT)ST */
data[1] |= 0x0c;
s2mu106_write_reg(client, S2MU106_REG_IRQ, data);
dev_dbg(&client->dev, "%s: irq_reg(%02x%02x) irq(%d)\n",
__func__, data[1], data[0], fuelgauge->pdata->fg_irq);
return true;
}
#if defined(CONFIG_BATTERY_AGE_FORECAST)
static int s2mu106_fg_aging_check(
struct s2mu106_fuelgauge_data *fuelgauge, int step)
{
u8 batcap0 = 0, batcap1 = 0, batcap2 = 0, batcap3 = 0;
u8 por_state = 0;
union power_supply_propval value;
int charging_enabled = false;
fuelgauge->fg_age_step = step;
s2mu106_read_reg_byte(fuelgauge->i2c, 0x0E, &batcap0);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x0F, &batcap1);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x10, &batcap2);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x11, &batcap3);
pr_info("%s: [Long life] orig. batcap : %02x, %02x, %02x, %02x , fg_age_step data : %02x, %02x, %02x, %02x \n",
__func__, batcap0, batcap1, batcap2, batcap3,
fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[0],
fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[1],
fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[2],
fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[3]);
if ((batcap0 != fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[0]) ||
(batcap1 != fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[1]) ||
(batcap2 != fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[2]) ||
(batcap3 != fuelgauge->age_data_info[fuelgauge->fg_age_step].batcap[3])) {
pr_info("%s: [Long life] reset gauge for age forecast , step[%d] \n", __func__, fuelgauge->fg_age_step);
fuelgauge->age_reset_status = 1;
por_state |= 0x10;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x1F, por_state);
/* check charging enable */
psy_do_property("s2mu106-charger", get, POWER_SUPPLY_PROP_CHARGING_ENABLED, value);
charging_enabled = value.intval;
if (charging_enabled == true) {
pr_info("%s: [Long life] disable charger for reset gauge age forecast \n",
__func__);
value.intval = SEC_BAT_CHG_MODE_CHARGING_OFF;
psy_do_property("s2mu106-charger", set, POWER_SUPPLY_PROP_CHARGING_ENABLED, value);
}
s2mu106_reset_fg(fuelgauge);
#if (TEMP_COMPEN)
fuelgauge->init_start = 1;
#endif
if (charging_enabled == true) {
psy_do_property("battery", get, POWER_SUPPLY_PROP_STATUS, value);
charging_enabled = value.intval;
if (charging_enabled == 1) { /* POWER_SUPPLY_STATUS_CHARGING 1 */
pr_info("%s: [Long life] enable charger for reset gauge age forecast \n",
__func__);
value.intval = SEC_BAT_CHG_MODE_CHARGING;
psy_do_property("s2mu106-charger",
set, POWER_SUPPLY_PROP_CHARGING_ENABLED, value);
}
}
por_state &= ~0x10;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x1F, por_state);
fuelgauge->age_reset_status = 0;
return 1;
}
return 0;
}
#endif
/* capacity is 0.1% unit */
static void s2mu106_fg_get_scaled_capacity(
struct s2mu106_fuelgauge_data *fuelgauge,
union power_supply_propval *val)
{
int rawsoc = val->intval;
val->intval = (val->intval < fuelgauge->pdata->capacity_min) ?
0 : ((val->intval - fuelgauge->pdata->capacity_min) * 1000 /
(fuelgauge->capacity_max - fuelgauge->pdata->capacity_min));
dev_info(&fuelgauge->i2c->dev,
"%s: capacity_max(%d) scaled capacity(%d.%d), raw_soc(%d.%d)\n",
__func__, fuelgauge->capacity_max,
val->intval/10, val->intval%10, rawsoc/10, rawsoc%10);
}
/* capacity is integer */
static void s2mu106_fg_get_atomic_capacity(
struct s2mu106_fuelgauge_data *fuelgauge,
union power_supply_propval *val)
{
if (fuelgauge->pdata->capacity_calculation_type &
SEC_FUELGAUGE_CAPACITY_TYPE_ATOMIC) {
if (fuelgauge->capacity_old < val->intval)
val->intval = fuelgauge->capacity_old + 1;
else if (fuelgauge->capacity_old > val->intval)
val->intval = fuelgauge->capacity_old - 1;
}
/* keep SOC stable in abnormal status */
if (fuelgauge->pdata->capacity_calculation_type &
SEC_FUELGAUGE_CAPACITY_TYPE_SKIP_ABNORMAL) {
if (!fuelgauge->is_charging &&
fuelgauge->capacity_old < val->intval) {
dev_err(&fuelgauge->i2c->dev,
"%s: capacity (old %d : new %d)\n",
__func__, fuelgauge->capacity_old, val->intval);
val->intval = fuelgauge->capacity_old;
}
}
/* updated old capacity */
fuelgauge->capacity_old = val->intval;
}
static int s2mu106_fg_check_capacity_max(
struct s2mu106_fuelgauge_data *fuelgauge, int capacity_max)
{
int new_capacity_max = capacity_max;
if (new_capacity_max < (fuelgauge->pdata->capacity_max -
fuelgauge->pdata->capacity_max_margin - 10)) {
new_capacity_max =
(fuelgauge->pdata->capacity_max -
fuelgauge->pdata->capacity_max_margin);
dev_info(&fuelgauge->i2c->dev, "%s: set capacity max(%d --> %d)\n",
__func__, capacity_max, new_capacity_max);
} else if (new_capacity_max > (fuelgauge->pdata->capacity_max +
fuelgauge->pdata->capacity_max_margin)) {
new_capacity_max =
(fuelgauge->pdata->capacity_max +
fuelgauge->pdata->capacity_max_margin);
dev_info(&fuelgauge->i2c->dev, "%s: set capacity max(%d --> %d)\n",
__func__, capacity_max, new_capacity_max);
}
return new_capacity_max;
}
static int s2mu106_fg_calculate_dynamic_scale(
struct s2mu106_fuelgauge_data *fuelgauge, int capacity)
{
union power_supply_propval raw_soc_val;
raw_soc_val.intval = s2mu106_get_rawsoc(fuelgauge) / 10;
if (raw_soc_val.intval <
fuelgauge->pdata->capacity_max -
fuelgauge->pdata->capacity_max_margin) {
pr_info("%s: raw soc(%d) is very low, skip routine\n",
__func__, raw_soc_val.intval);
} else {
fuelgauge->capacity_max =
(raw_soc_val.intval * 100 / (capacity + 1));
fuelgauge->capacity_old = capacity;
fuelgauge->capacity_max =
s2mu106_fg_check_capacity_max(fuelgauge,
fuelgauge->capacity_max);
pr_info("%s: %d is used for capacity_max, capacity(%d)\n",
__func__, fuelgauge->capacity_max, capacity);
}
return fuelgauge->capacity_max;
}
void s2mu106_fg_set_sys_voltage(struct s2mu106_fuelgauge_data *fuelgauge,
int get_sys_vol)
{
u8 temp = 0;
s2mu106_read_reg_byte(fuelgauge->i2c, 0x25, &temp);
temp &= 0xCF;
if (get_sys_vol) /* factory mode : 0x25 [5:4] = b11 (Get SYS voltage) */
temp |= 0x30;
else /* normal mode : 0x25 [5:4] = b01 (Get Battery voltage by I2C Control) */
temp |= 0x10;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x25, temp);
pr_info("%s: SEC_BAT_INBAT_FGSRC_SWITCHING_OFF(%d) : 0x25 = %x\n",
__func__, get_sys_vol, temp);
}
static int s2mu106_fg_get_property(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct s2mu106_fuelgauge_data *fuelgauge =
power_supply_get_drvdata(psy);
switch (psp) {
case POWER_SUPPLY_PROP_STATUS:
case POWER_SUPPLY_PROP_CHARGE_FULL:
return -ENODATA;
case POWER_SUPPLY_PROP_ENERGY_NOW:
switch (val->intval) {
case SEC_BATTERY_CAPACITY_DESIGNED:
val->intval = fuelgauge->pdata->capacity_full;
break;
case SEC_BATTERY_CAPACITY_ABSOLUTE:
val->intval = 0;
break;
case SEC_BATTERY_CAPACITY_TEMPERARY:
val->intval = 0;
break;
case SEC_BATTERY_CAPACITY_CURRENT:
val->intval = 0;
break;
case SEC_BATTERY_CAPACITY_AGEDCELL:
val->intval = 0;
break;
case SEC_BATTERY_CAPACITY_CYCLE:
val->intval = 0;
break;
case SEC_BATTERY_CAPACITY_FULL:
val->intval = fuelgauge->pdata->capacity_full;
break;
}
break;
/* Cell voltage (VCELL, mV) */
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
val->intval = s2mu106_get_vbat(fuelgauge);
break;
/* Additional Voltage Information (mV) */
case POWER_SUPPLY_PROP_VOLTAGE_AVG:
switch (val->intval) {
case SEC_BATTERY_VOLTAGE_AVERAGE:
val->intval = s2mu106_get_avgvbat(fuelgauge);
break;
case SEC_BATTERY_VOLTAGE_OCV:
val->intval = s2mu106_get_ocv(fuelgauge);
break;
}
break;
/* Current (mA) */
case POWER_SUPPLY_PROP_CURRENT_NOW:
if (val->intval == SEC_BATTERY_CURRENT_UA)
val->intval = s2mu106_get_current(fuelgauge) * 1000;
else
val->intval = s2mu106_get_current(fuelgauge);
break;
/* Average Current (mA) */
case POWER_SUPPLY_PROP_CURRENT_AVG:
if (val->intval == SEC_BATTERY_CURRENT_UA)
val->intval = s2mu106_maintain_avgcurrent(fuelgauge) * 1000;
else
fuelgauge->current_avg = val->intval = s2mu106_maintain_avgcurrent(fuelgauge);
break;
case POWER_SUPPLY_PROP_CAPACITY:
if (val->intval == SEC_FUELGAUGE_CAPACITY_TYPE_RAW) {
val->intval = s2mu106_get_rawsoc(fuelgauge);
} else if (val->intval == SEC_FUELGAUGE_CAPACITY_TYPE_CAPACITY_POINT) {
val->intval = fuelgauge->raw_capacity % 10;
} else {
val->intval = s2mu106_get_rawsoc(fuelgauge) / 10;
if (fuelgauge->pdata->capacity_calculation_type &
(SEC_FUELGAUGE_CAPACITY_TYPE_SCALE |
SEC_FUELGAUGE_CAPACITY_TYPE_DYNAMIC_SCALE)) {
s2mu106_fg_get_scaled_capacity(fuelgauge, val);
if (val->intval > 1010) {
pr_info("%s : scaled capacity (%d)\n", __func__, val->intval);
s2mu106_fg_calculate_dynamic_scale(fuelgauge, 100);
}
}
/* capacity should be between 0% and 100%
* (0.1% degree)
*/
if (val->intval > 1000)
val->intval = 1000;
if (val->intval < 0)
val->intval = 0;
fuelgauge->raw_capacity = val->intval;
/* get only integer part */
val->intval /= 10;
/* check whether doing the wake_unlock */
if ((val->intval > fuelgauge->pdata->fuel_alert_soc) &&
fuelgauge->is_fuel_alerted) {
wake_unlock(&fuelgauge->fuel_alert_wake_lock);
s2mu106_fuelgauge_fuelalert_init(fuelgauge->i2c,
fuelgauge->pdata->fuel_alert_soc);
}
/* (Only for atomic capacity)
* In initial time, capacity_old is 0.
* and in resume from sleep,
* capacity_old is too different from actual soc.
* should update capacity_old
* by val->intval in booting or resume.
*/
if (fuelgauge->initial_update_of_soc &&
(fuelgauge->temperature > fuelgauge->low_temp_limit)) {
/* updated old capacity */
fuelgauge->capacity_old = val->intval;
fuelgauge->initial_update_of_soc = false;
break;
}
if (fuelgauge->sleep_initial_update_of_soc) {
/* updated old capacity in case of resume */
if (fuelgauge->is_charging) {
fuelgauge->capacity_old = val->intval;
fuelgauge->sleep_initial_update_of_soc = false;
break;
} else if ((!fuelgauge->is_charging) &&
(fuelgauge->capacity_old >= val->intval)) {
fuelgauge->capacity_old = val->intval;
fuelgauge->sleep_initial_update_of_soc = false;
break;
}
}
if (fuelgauge->pdata->capacity_calculation_type &
(SEC_FUELGAUGE_CAPACITY_TYPE_ATOMIC |
SEC_FUELGAUGE_CAPACITY_TYPE_SKIP_ABNORMAL))
s2mu106_fg_get_atomic_capacity(fuelgauge, val);
}
break;
/* Battery Temperature */
case POWER_SUPPLY_PROP_TEMP:
/* Target Temperature */
case POWER_SUPPLY_PROP_TEMP_AMBIENT:
val->intval = s2mu106_get_temperature(fuelgauge);
break;
case POWER_SUPPLY_PROP_ENERGY_FULL:
#if (BATCAP_LEARN)
fuelgauge->soh = s2mu106_get_soh(fuelgauge);
val->intval = fuelgauge->soh;
#endif
break;
case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
val->intval = fuelgauge->capacity_max;
break;
case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
val->intval = calc_ttf(fuelgauge, val);
break;
case POWER_SUPPLY_PROP_SCOPE:
val->intval = fuelgauge->mode;
break;
case POWER_SUPPLY_PROP_SOH:
#if (BATCAP_LEARN)
fuelgauge->soh = s2mu106_get_soh(fuelgauge);
val->intval = fuelgauge->soh;
#else
/* If battery capacity learning is not enabled,
* return SOH is 100%
*/
val->intval = 100;
#endif
break;
case POWER_SUPPLY_PROP_CHARGE_COUNTER:
val->intval = fuelgauge->pdata->capacity_full * fuelgauge->raw_capacity;
break;
case POWER_SUPPLY_PROP_MODEL_NAME:
val->intval = IC_TYPE_IFPMIC_S2MU106;
break;
default:
return -EINVAL;
}
return 0;
}
static int s2mu106_fg_set_property(struct power_supply *psy,
enum power_supply_property psp,
const union power_supply_propval *val)
{
struct s2mu106_fuelgauge_data *fuelgauge =
power_supply_get_drvdata(psy);
enum power_supply_ext_property ext_psp = (enum power_supply_ext_property) psp;
switch (psp) {
case POWER_SUPPLY_PROP_STATUS:
#if defined(CONFIG_BATTERY_AGE_FORECAST)
if (val->intval == POWER_SUPPLY_STATUS_FULL)
s2mu106_fg_aging_check(fuelgauge, fuelgauge->change_step);
#endif
break;
case POWER_SUPPLY_PROP_CHARGE_FULL:
if (fuelgauge->pdata->capacity_calculation_type &
SEC_FUELGAUGE_CAPACITY_TYPE_DYNAMIC_SCALE) {
s2mu106_fg_calculate_dynamic_scale(fuelgauge, val->intval);
}
break;
case POWER_SUPPLY_PROP_ONLINE:
fuelgauge->cable_type = val->intval;
break;
case POWER_SUPPLY_PROP_CHARGING_ENABLED:
if (val->intval == SEC_BAT_CHG_MODE_CHARGING)
fuelgauge->is_charging = true;
else
fuelgauge->is_charging = false;
break;
case POWER_SUPPLY_PROP_CAPACITY:
if (val->intval == SEC_FUELGAUGE_CAPACITY_TYPE_RESET) {
s2mu106_restart_gauging(fuelgauge);
fuelgauge->initial_update_of_soc = true;
}
break;
case POWER_SUPPLY_PROP_TEMP:
case POWER_SUPPLY_PROP_TEMP_AMBIENT:
s2mu106_set_temperature(fuelgauge, val->intval);
fuelgauge->init_battery_temp = true;
break;
case POWER_SUPPLY_PROP_ENERGY_NOW:
s2mu106_fg_reset_capacity_by_jig_connection(fuelgauge);
break;
case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
dev_info(&fuelgauge->i2c->dev,
"%s: capacity_max changed, %d -> %d\n",
__func__, fuelgauge->capacity_max, val->intval);
fuelgauge->capacity_max = s2mu106_fg_check_capacity_max(fuelgauge, val->intval);
fuelgauge->initial_update_of_soc = true;
break;
case POWER_SUPPLY_PROP_CHARGE_EMPTY:
break;
case POWER_SUPPLY_PROP_ENERGY_AVG:
break;
case POWER_SUPPLY_PROP_CURRENT_FULL:
fuelgauge->topoff_current = val->intval;
break;
case POWER_SUPPLY_PROP_MAX ... POWER_SUPPLY_EXT_PROP_MAX:
switch (ext_psp) {
case POWER_SUPPLY_EXT_PROP_FGSRC_SWITCHING:
if ((val->intval == SEC_BAT_INBAT_FGSRC_SWITCHING_VBAT) ||
(val->intval == SEC_BAT_FGSRC_SWITCHING_VBAT)) {
s2mu106_fg_set_sys_voltage(fuelgauge, 0);
if (val->intval == SEC_BAT_INBAT_FGSRC_SWITCHING_VBAT)
s2mu106_restart_gauging(fuelgauge);
else
msleep(1000);
s2mu106_fg_reset_capacity_by_jig_connection(fuelgauge);
s2mu106_fg_test_read(fuelgauge->i2c);
} else if ((val->intval == SEC_BAT_INBAT_FGSRC_SWITCHING_VSYS) ||
(val->intval == SEC_BAT_FGSRC_SWITCHING_VSYS)) {
s2mu106_fg_set_sys_voltage(fuelgauge, 1);
if (val->intval == SEC_BAT_INBAT_FGSRC_SWITCHING_VSYS)
s2mu106_restart_gauging(fuelgauge);
else
msleep(1000);
s2mu106_fg_reset_capacity_by_jig_connection(fuelgauge);
s2mu106_fg_test_read(fuelgauge->i2c);
}
break;
case POWER_SUPPLY_EXT_PROP_FUELGAUGE_FACTORY:
pr_info("%s:[DEBUG_FAC] fuelgauge\n", __func__);
s2mu106_fg_set_sys_voltage(fuelgauge, 1);
s2mu106_fg_reset_capacity_by_jig_connection(fuelgauge);
break;
#if defined(CONFIG_BATTERY_AGE_FORECAST)
case POWER_SUPPLY_EXT_PROP_UPDATE_BATTERY_DATA:
fuelgauge->change_step = val->intval;
break;
#endif
default:
return -EINVAL;
}
break;
default:
return -EINVAL;
}
return 0;
}
static void s2mu106_fg_isr_work(struct work_struct *work)
{
struct s2mu106_fuelgauge_data *fuelgauge =
container_of(work, struct s2mu106_fuelgauge_data, isr_work.work);
u8 fg_alert_status = 0;
s2mu106_read_reg_byte(fuelgauge->i2c, S2MU106_REG_STATUS, &fg_alert_status);
dev_info(&fuelgauge->i2c->dev, "%s : fg_alert_status(0x%x)\n",
__func__, fg_alert_status);
fg_alert_status &= 0x03;
if (fg_alert_status & 0x01)
pr_info("%s : Battery Level(SOC) is very Low!\n", __func__);
if (fg_alert_status & 0x02) {
int voltage = s2mu106_get_vbat(fuelgauge);
pr_info("%s : Battery Votage is very Low! (%dmV)\n",
__func__, voltage);
}
if (!fg_alert_status) {
fuelgauge->is_fuel_alerted = false;
pr_info("%s : SOC or Voltage is Good!\n", __func__);
wake_unlock(&fuelgauge->fuel_alert_wake_lock);
}
}
static irqreturn_t s2mu106_fg_irq_thread(int irq, void *irq_data)
{
struct s2mu106_fuelgauge_data *fuelgauge = irq_data;
u8 fg_irq = 0;
s2mu106_read_reg_byte(fuelgauge->i2c, S2MU106_REG_IRQ, &fg_irq);
dev_info(&fuelgauge->i2c->dev, "%s: fg_irq(0x%x)\n",
__func__, fg_irq);
if (fuelgauge->is_fuel_alerted) {
return IRQ_HANDLED;
} else {
wake_lock(&fuelgauge->fuel_alert_wake_lock);
fuelgauge->is_fuel_alerted = true;
schedule_delayed_work(&fuelgauge->isr_work, 0);
}
return IRQ_HANDLED;
}
#ifdef CONFIG_OF
static int s2mu106_fuelgauge_parse_dt(struct s2mu106_fuelgauge_data *fuelgauge)
{
struct device_node *np = of_find_node_by_name(NULL, "s2mu106-fuelgauge");
int ret;
const u32 *p;
#if defined(CONFIG_BATTERY_AGE_FORECAST)
int len, i;
#endif
/* reset, irq gpio info */
if (np == NULL) {
pr_err("%s np NULL\n", __func__);
} else {
fuelgauge->pdata->fg_irq = of_get_named_gpio(np, "fuelgauge,fuel_int", 0);
if (fuelgauge->pdata->fg_irq < 0)
pr_err("%s error reading fg_irq = %d\n",
__func__, fuelgauge->pdata->fg_irq);
ret = of_property_read_u32(np, "fuelgauge,fuel_alert_vol",
&fuelgauge->pdata->fuel_alert_vol);
if (ret < 0) {
fuelgauge->pdata->fuel_alert_vol = 3300;
pr_err("%s Default value of fuel_alert_vol : %d\n",
__func__, fuelgauge->pdata->fuel_alert_vol);
}
ret = of_property_read_u32(np, "fuelgauge,fuel_alert_soc",
&fuelgauge->pdata->fuel_alert_soc);
if (ret < 0)
pr_err("%s error reading pdata->fuel_alert_soc %d\n",
__func__, ret);
ret = of_property_read_u32(np, "fuelgauge,capacity_max",
&fuelgauge->pdata->capacity_max);
if (ret < 0)
pr_err("%s error reading capacity_max %d\n", __func__, ret);
ret = of_property_read_u32(np, "fuelgauge,capacity_max_margin",
&fuelgauge->pdata->capacity_max_margin);
if (ret < 0)
pr_err("%s error reading capacity_max_margin %d\n", __func__, ret);
ret = of_property_read_u32(np, "fuelgauge,capacity_min",
&fuelgauge->pdata->capacity_min);
if (ret < 0)
pr_err("%s error reading capacity_min %d\n", __func__, ret);
ret = of_property_read_u32(np, "fuelgauge,capacity_calculation_type",
&fuelgauge->pdata->capacity_calculation_type);
if (ret < 0)
pr_err("%s error reading capacity_calculation_type %d\n",
__func__, ret);
ret = of_property_read_u32(np, "fuelgauge,capacity_full",
&fuelgauge->pdata->capacity_full);
if (ret < 0)
pr_err("%s error reading pdata->capacity_full %d\n",
__func__, ret);
ret = of_property_read_u32(np, "fuelgauge,low_temp_limit",
&fuelgauge->low_temp_limit);
if (ret < 0) {
pr_err("%s There is no low temperature limit. Use default(100)\n",
__func__);
fuelgauge->low_temp_limit = 100;
}
ret = of_property_read_u32(np, "fuelgauge,low_voltage_limit",
&fuelgauge->low_voltage_limit);
if (ret < 0) {
pr_err("%s There is no low voltage limit. Use default(3450)\n",
__func__);
fuelgauge->low_voltage_limit = 3450;
}
ret = of_property_read_u32(np, "fuelgauge,low_voltage_limit_lowtemp",
&fuelgauge->low_voltage_limit_lowtemp);
if (ret < 0) {
pr_err("%s There is no low voltage limit low temp. Use default(3450)\n",
__func__);
fuelgauge->low_voltage_limit_lowtemp = 3450;
}
ret = of_property_read_u32(np, "fuelgauge,low_voltage_recover_lowtemp",
&fuelgauge->low_voltage_recover_lowtemp);
if (ret < 0) {
pr_err("%s There is no low voltage recover low temp. Use default(3600)\n",
__func__);
fuelgauge->low_voltage_recover_lowtemp = 3600;
}
pr_err("%s fuelgauge,low_voltage_limit_lowtemp: %d, recover: %d\n",
__func__, fuelgauge->low_voltage_limit_lowtemp,
fuelgauge->low_voltage_recover_lowtemp);
ret = of_property_read_u32(np, "fuelgauge,i_socr_coeff",
&fuelgauge->i_socr_coeff);
if (ret < 0) {
pr_err("%s There is no i_socr_coeff . Use default(333)\n",
__func__);
fuelgauge->i_socr_coeff = 333;
}
ret = of_property_read_u32(np, "fuelgauge,t_socr_coeff",
&fuelgauge->t_socr_coeff);
if (ret < 0) {
pr_err("%s There is no t_socr_coeff . Use default(15500)\n",
__func__);
fuelgauge->t_socr_coeff = 15500;
}
ret = of_property_read_u32(np, "fuelgauge,t_compen_coeff",
&fuelgauge->t_compen_coeff);
if (ret < 0) {
pr_err("%s There is no t_compen_coeff . Use default(75)\n",
__func__);
fuelgauge->t_compen_coeff = 75;
}
ret = of_property_read_u32(np, "fuelgauge,low_t_compen_coeff",
&fuelgauge->low_t_compen_coeff);
if (ret < 0) {
pr_err("%s There is no low_t_compen_coeff . Use default(223)\n",
__func__);
fuelgauge->low_t_compen_coeff = 223;
}
ret = of_property_read_u32(np, "fuelgauge,soc_map_offset",
&fuelgauge->soc_map_offset);
if (ret < 0) {
pr_err("%s There is no soc_map_offset Use default(0)\n",
__func__);
fuelgauge->soc_map_offset = 0;
}
ret = of_property_read_u32(np, "fuelgauge,val_0x5C",
&fuelgauge->val_0x5C);
if (ret < 0) {
pr_err("%s There is no val_5c . Use default(0x1A)\n",
__func__);
fuelgauge->val_0x5C = 0x1A;
}
ret = of_property_read_u32(np, "fuelgauge,low_voltage_limit_cnt",
&fuelgauge->low_voltage_limit_cnt);
if (ret < 0) {
pr_err("%s There is no low_voltage_limit_cnt . Use default(1)\n",
__func__);
fuelgauge->low_voltage_limit_cnt = 1;
}
ret = of_property_read_u32(np, "fuelgauge,ttf_capacity",
&fuelgauge->ttf_capacity);
if (ret < 0) {
pr_err("%s: error reading ttf_capacity %d\n",
__func__, ret);
fuelgauge->ttf_capacity = fuelgauge->pdata->capacity_full;
}
p = of_get_property(np, "fuelgauge,cv_data", &len);
if (p) {
fuelgauge->cv_data = kzalloc(len, GFP_KERNEL);
fuelgauge->cv_data_length = len / sizeof(struct cv_slope);
pr_err("%s: len= %ld, length= %d, %d\n", __func__,
sizeof(int) * len, len, fuelgauge->cv_data_length);
ret = of_property_read_u32_array(np, "fuelgauge,cv_data",
(u32 *)fuelgauge->cv_data, len / sizeof(u32));
if (ret) {
pr_err("%s: failed to read fuelgauge->cv_data: %d\n",
__func__, ret);
kfree(fuelgauge->cv_data);
fuelgauge->cv_data = NULL;
}
} else {
pr_err("%s: there is not cv_data\n", __func__);
}
/* get topoff info */
np = of_find_node_by_name(NULL, "cable-info");
if (!np) {
pr_err("%s np NULL\n", __func__);
} else {
ret = of_property_read_u32(np, "full_check_current_1st",
&fuelgauge->topoff_current);
if (ret < 0) {
pr_err("%s fail to get topoff current %d\n", __func__, ret);
fuelgauge->topoff_current = 500;
}
}
np = of_find_node_by_name(NULL, "battery");
if (!np) {
pr_err("%s np NULL\n", __func__);
} else {
ret = of_property_read_string(np,
"battery,fuelgauge_name",
(char const **)&fuelgauge->pdata->fuelgauge_name);
if (ret < 0) {
pr_err("%s: there is not fuelgauge_name %d\n", __func__, ret);
fuelgauge->pdata->fuelgauge_name = "s2mu106-fuelgauge";
}
}
/* get battery node */
np = of_find_node_by_name(NULL, "battery_params");
if (!np) {
pr_err("%s battery_params node NULL\n", __func__);
} else {
#if !defined(CONFIG_BATTERY_AGE_FORECAST)
/* get battery_table */
ret = of_property_read_u32_array(np, "battery,battery_table3", fuelgauge->info.battery_table3, 88);
if (ret < 0)
pr_err("%s error reading battery,battery_table3\n", __func__);
ret = of_property_read_u32_array(np, "battery,battery_table4", fuelgauge->info.battery_table4, 22);
if (ret < 0)
pr_err("%s error reading battery,battery_table4\n", __func__);
ret = of_property_read_u32_array(np, "battery,batcap", fuelgauge->info.batcap, 4);
if (ret < 0)
pr_err("%s error reading battery,batcap\n", __func__);
ret = of_property_read_u32_array(np, "battery,accum", fuelgauge->info.accum, 2);
if (ret < 0) {
fuelgauge->info.accum[0]=0x00; // REG 0x44
fuelgauge->info.accum[1]=0x08; // REG 0x45
pr_err("%s There is no accumulative rate value in DT. set to the default value(0x800)\n", __func__);
}
ret = of_property_read_u32_array(np, "battery,soc_arr_val", fuelgauge->info.soc_arr_val, 22);
if (ret < 0)
pr_err("%s error reading battery,soc_arr_val\n", __func__);
ret = of_property_read_u32_array(np, "battery,ocv_arr_val", fuelgauge->info.ocv_arr_val, 22);
if (ret < 0)
pr_err("%s error reading battery,ocv_arr_val\n", __func__);
#else
do {
p = of_get_property(np, "battery,battery_data", &len);
if (p) {
fuelgauge->fg_num_age_step = len / sizeof(fg_age_data_info_t);
fuelgauge->age_data_info = kzalloc(len, GFP_KERNEL);
ret = of_property_read_u32_array(np, "battery,battery_data",
(int *)fuelgauge->age_data_info, len/sizeof(int));
pr_err("%s: [Long life] fuelgauge->fg_num_age_step %d \n",
__func__,fuelgauge->fg_num_age_step);
for (i = 0 ; i < fuelgauge->fg_num_age_step ; i++) {
pr_err("%s: [Long life] age_step = %d, table3[0] %d, table4[0] %d, batcap[0] %02x, accum[0] %02x, soc_arr[0] %d, ocv_arr[0] %d, volt_tun : %02x\n",
__func__, i,
fuelgauge->age_data_info[i].battery_table3[0],
fuelgauge->age_data_info[i].battery_table4[0],
fuelgauge->age_data_info[i].batcap[0],
fuelgauge->age_data_info[i].accum[0],
fuelgauge->age_data_info[i].soc_arr_val[0],
fuelgauge->age_data_info[i].ocv_arr_val[0],
fuelgauge->age_data_info[i].volt_mode_tuning);
}
break;
} else {
pr_err("%s: there is not battery_data\n", __func__);
}
} while ((np = of_find_node_by_name(np, "battery_params")) != NULL);
#endif
}
}
return 0;
}
ssize_t s2mu106_fg_show_attrs(struct device *dev,
struct device_attribute *attr, char *buf);
ssize_t s2mu106_fg_store_attrs(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count);
#define S2MU106_ATTR(_name) \
{ \
.attr = {.name = #_name, .mode = 0664}, \
.show = s2mu106_fg_show_attrs, \
.store = s2mu106_fg_store_attrs, \
}
enum {
CHIP_ID = 0,
DATA
};
static struct device_attribute s2mu106_fg_attrs[] = {
S2MU106_ATTR(chip_id),
S2MU106_ATTR(data),
};
static int s2mu106_fg_create_attrs(struct device *dev)
{
int i, rc;
for (i = 0; i < (int)ARRAY_SIZE(s2mu106_fg_attrs); i++) {
rc = device_create_file(dev, &s2mu106_fg_attrs[i]);
if (rc)
goto create_attrs_failed;
}
return rc;
create_attrs_failed:
dev_err(dev, "%s: failed (%d)\n", __func__, rc);
while (i--)
device_remove_file(dev, &s2mu106_fg_attrs[i]);
return rc;
}
ssize_t s2mu106_fg_show_attrs(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct power_supply *psy = dev_get_drvdata(dev);
struct s2mu106_fuelgauge_data *fuelgauge = power_supply_get_drvdata(psy);
const ptrdiff_t offset = attr - s2mu106_fg_attrs;
int i = 0;
u8 addr = 0, data = 0;
switch (offset) {
case CHIP_ID:
s2mu106_read_reg_byte(fuelgauge->i2c, S2MU106_REG_FG_ID, &data);
i += scnprintf(buf + i, PAGE_SIZE - i,
"0x%02x : 0x%02x\n", S2MU106_REG_FG_ID, data);
break;
case DATA:
for (addr = 0x00; addr <= 0x1F; addr++) {
if (addr == 0x02)
continue;
s2mu106_read_reg_byte(fuelgauge->i2c, addr, &data);
i += scnprintf(buf + i, PAGE_SIZE - i,
"0x%02x:0x%02x\n", addr, data);
}
for (addr = 0x24; addr <= 0x29; addr++) {
s2mu106_read_reg_byte(fuelgauge->i2c, addr, &data);
i += scnprintf(buf + i, PAGE_SIZE - i,
"0x%02x:0x%02x\n", addr, data);
}
for (addr = 0x40; addr <= 0x5C; addr++) {
s2mu106_read_reg_byte(fuelgauge->i2c, addr, &data);
i += scnprintf(buf + i, PAGE_SIZE - i,
"0x%02x:0x%02x\n", addr, data);
}
s2mu106_read_reg_byte(fuelgauge->i2c, S2MU106_REG_FG_ID, &data);
i += scnprintf(buf + i, PAGE_SIZE - i,
"0x%02x:0x%02x\n", S2MU106_REG_FG_ID, data);
break;
default:
return -EINVAL;
}
return i;
}
ssize_t s2mu106_fg_store_attrs(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct power_supply *psy = dev_get_drvdata(dev);
struct s2mu106_fuelgauge_data *fuelgauge = power_supply_get_drvdata(psy);
const ptrdiff_t offset = attr - s2mu106_fg_attrs;
int ret = 0;
int x, y;
switch (offset) {
case CHIP_ID:
ret = count;
break;
case DATA:
if (sscanf(buf, "0x%8x 0x%8x", &x, &y) == 2) {
if (x >= 0x00 && x <= 0x2F) {
u8 addr = x;
u8 data = y;
if (s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, addr, data) < 0) {
dev_info(fuelgauge->dev,
"%s: addr: 0x%x write fail\n", __func__, addr);
}
} else {
dev_info(fuelgauge->dev,
"%s: addr: 0x%x is wrong\n", __func__, x);
}
}
ret = count;
break;
default:
ret = -EINVAL;
}
return ret;
}
static struct of_device_id s2mu106_fuelgauge_match_table[] = {
{ .compatible = "samsung,s2mu106-fuelgauge",},
{},
};
#else
static int s2mu106_fuelgauge_parse_dt(struct s2mu106_fuelgauge_data *fuelgauge)
{
return -ENOSYS;
}
#define s2mu106_fuelgauge_match_table NULL
#endif /* CONFIG_OF */
static const struct power_supply_desc s2mu106_fuelgauge_power_supply_desc = {
.name = "s2mu106-fuelgauge",
.type = POWER_SUPPLY_TYPE_UNKNOWN,
.properties = s2mu106_fuelgauge_props,
.num_properties = ARRAY_SIZE(s2mu106_fuelgauge_props),
.get_property = s2mu106_fg_get_property,
.set_property = s2mu106_fg_set_property,
};
static int s2mu106_fuelgauge_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct s2mu106_fuelgauge_data *fuelgauge;
union power_supply_propval raw_soc_val;
struct power_supply_config fuelgauge_cfg = {};
int ret = 0;
u8 temp = 0;
pr_info("%s: S2MU106 Fuelgauge Driver Loading\n", __func__);
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
return -EIO;
fuelgauge = kzalloc(sizeof(*fuelgauge), GFP_KERNEL);
if (!fuelgauge)
return -ENOMEM;
mutex_init(&fuelgauge->fg_lock);
fuelgauge->i2c = client;
if (client->dev.of_node) {
fuelgauge->pdata = devm_kzalloc(&client->dev, sizeof(*(fuelgauge->pdata)),
GFP_KERNEL);
if (!fuelgauge->pdata) {
dev_err(&client->dev, "Failed to allocate memory\n");
ret = -ENOMEM;
goto err_parse_dt_nomem;
}
ret = s2mu106_fuelgauge_parse_dt(fuelgauge);
if (ret < 0)
goto err_parse_dt;
} else {
fuelgauge->pdata = client->dev.platform_data;
}
i2c_set_clientdata(client, fuelgauge);
fuelgauge->capacity_max = fuelgauge->pdata->capacity_max;
if (fuelgauge->pdata->fuelgauge_name == NULL)
fuelgauge->pdata->fuelgauge_name = "s2mu106-fuelgauge";
fuelgauge_cfg.drv_data = fuelgauge;
fuelgauge->revision = 0;
s2mu106_read_reg_byte(fuelgauge->i2c, 0x48, &temp);
fuelgauge->revision = (temp & 0xF0) >> 4;
pr_info("%s: S2MU106 Fuelgauge revision: 0x%x, reg 0x48 = 0x%x\n",
__func__, fuelgauge->revision, temp);
fuelgauge->info.soc = 0;
/* default CURRENT_MODE setting */
fuelgauge->mode = CURRENT_MODE;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4A, 0x10);
s2mu106_read_reg_byte(fuelgauge->i2c, 0x4B, &temp);
temp &= 0x8F;
s2mu106_write_and_verify_reg_byte(fuelgauge->i2c, 0x4B, temp);
raw_soc_val.intval = s2mu106_get_rawsoc(fuelgauge);
raw_soc_val.intval = raw_soc_val.intval / 10;
if (raw_soc_val.intval > fuelgauge->capacity_max)
s2mu106_fg_calculate_dynamic_scale(fuelgauge, 100);
#if (TEMP_COMPEN)
fuelgauge->init_start = 1;
fuelgauge->flag_mapping = false;
#endif
#if (BATCAP_LEARN)
fuelgauge->learn_start = false;
fuelgauge->cond1_ok = false;
fuelgauge->c1_count = 0;
fuelgauge->c2_count = 0;
#endif
s2mu106_init_regs(fuelgauge);
fuelgauge->psy_fg = power_supply_register(
&client->dev, &s2mu106_fuelgauge_power_supply_desc, &fuelgauge_cfg);
if (!fuelgauge->psy_fg) {
pr_err("%s: Failed to Register psy_fg\n", __func__);
ret = PTR_ERR(fuelgauge->psy_fg);
goto err_data_free;
}
fuelgauge->is_fuel_alerted = false;
if (fuelgauge->pdata->fuel_alert_soc >= 0) {
s2mu106_fuelgauge_fuelalert_init(fuelgauge->i2c,
fuelgauge->pdata->fuel_alert_soc);
wake_lock_init(&fuelgauge->fuel_alert_wake_lock,
WAKE_LOCK_SUSPEND, "fuel_alerted");
if (fuelgauge->pdata->fg_irq > 0) {
INIT_DELAYED_WORK(
&fuelgauge->isr_work, s2mu106_fg_isr_work);
fuelgauge->fg_irq = gpio_to_irq(fuelgauge->pdata->fg_irq);
dev_info(&client->dev,
"%s : fg_irq = %d\n", __func__, fuelgauge->fg_irq);
if (fuelgauge->fg_irq > 0) {
ret = request_threaded_irq(fuelgauge->fg_irq,
NULL, s2mu106_fg_irq_thread,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING
| IRQF_ONESHOT,
"fuelgauge-irq", fuelgauge);
if (ret) {
dev_err(&client->dev,
"%s: Failed to Request IRQ\n", __func__);
goto err_supply_unreg;
}
ret = enable_irq_wake(fuelgauge->fg_irq);
if (ret < 0)
dev_err(&client->dev,
"%s: Failed to Enable Wakeup Source(%d)\n",
__func__, ret);
} else {
dev_err(&client->dev, "%s: Failed gpio_to_irq(%d)\n",
__func__, fuelgauge->fg_irq);
goto err_supply_unreg;
}
}
}
fuelgauge->cable_type = SEC_BATTERY_CABLE_NONE;
fuelgauge->sleep_initial_update_of_soc = false;
fuelgauge->initial_update_of_soc = true;
#if (TEMP_COMPEN) || (BATCAP_LEARN)
fuelgauge->bat_charging = false;
#endif
fuelgauge->probe_done = true;
fuelgauge->psy_chg = power_supply_get_by_name("s2mu106-charger");
fuelgauge->psy_bat = power_supply_get_by_name("battery");
ret = s2mu106_fg_create_attrs(&fuelgauge->psy_fg->dev);
if (ret) {
dev_err(&client->dev,
"%s : Failed to create_attrs\n", __func__);
}
pr_info("%s: S2MU106 Fuelgauge Driver Loaded\n", __func__);
return 0;
err_supply_unreg:
power_supply_unregister(fuelgauge->psy_fg);
err_data_free:
if (client->dev.of_node)
kfree(fuelgauge->pdata);
err_parse_dt:
err_parse_dt_nomem:
mutex_destroy(&fuelgauge->fg_lock);
kfree(fuelgauge);
return ret;
}
static const struct i2c_device_id s2mu106_fuelgauge_id[] = {
{"s2mu106-fuelgauge", 0},
{}
};
static void s2mu106_fuelgauge_shutdown(struct i2c_client *client)
{
}
static int s2mu106_fuelgauge_remove(struct i2c_client *client)
{
struct s2mu106_fuelgauge_data *fuelgauge = i2c_get_clientdata(client);
if (fuelgauge->pdata->fuel_alert_soc >= 0)
wake_lock_destroy(&fuelgauge->fuel_alert_wake_lock);
return 0;
}
#if defined CONFIG_PM
static int s2mu106_fuelgauge_suspend(struct device *dev)
{
return 0;
}
static int s2mu106_fuelgauge_resume(struct device *dev)
{
struct s2mu106_fuelgauge_data *fuelgauge = dev_get_drvdata(dev);
fuelgauge->sleep_initial_update_of_soc = true;
return 0;
}
#else
#define s2mu106_fuelgauge_suspend NULL
#define s2mu106_fuelgauge_resume NULL
#endif
static SIMPLE_DEV_PM_OPS(s2mu106_fuelgauge_pm_ops, s2mu106_fuelgauge_suspend,
s2mu106_fuelgauge_resume);
static struct i2c_driver s2mu106_fuelgauge_driver = {
.driver = {
.name = "s2mu106-fuelgauge",
.owner = THIS_MODULE,
.pm = &s2mu106_fuelgauge_pm_ops,
.of_match_table = s2mu106_fuelgauge_match_table,
},
.probe = s2mu106_fuelgauge_probe,
.remove = s2mu106_fuelgauge_remove,
.shutdown = s2mu106_fuelgauge_shutdown,
.id_table = s2mu106_fuelgauge_id,
};
static int __init s2mu106_fuelgauge_init(void)
{
pr_info("%s: S2MU106 Fuelgauge Init\n", __func__);
return i2c_add_driver(&s2mu106_fuelgauge_driver);
}
static void __exit s2mu106_fuelgauge_exit(void)
{
i2c_del_driver(&s2mu106_fuelgauge_driver);
}
module_init(s2mu106_fuelgauge_init);
module_exit(s2mu106_fuelgauge_exit);
MODULE_DESCRIPTION("Samsung S2MU106 Fuel Gauge Driver");
MODULE_AUTHOR("Samsung Electronics");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink