redonkable
/
remarkable-linux
1
0
Fork 0
Code Releases Activity
remarkable-linux/drivers/power/supply/max77818_battery.c

1985 lines
52 KiB
C
Raw Blame History

/*
* Fuel gauge driver for Maxim 77818
* Note that Maxim 77818 is mfd and this is its subdevice.
*
* Copyright (C) 2011 Samsung Electronics
* MyungJoo Ham <myungjoo.ham@samsung.com>
*
* Copyright (C) 2019 reMarkable AS - http://www.remarkable.com/
*
* Author: Steinar Bakkemo <steinar.bakkemo@remarkable.com>
* Author: Shawn Guo <shawn.guo@linaro.org>
* Author: Lars Ivar Miljeteig <lars.ivar.miljeteig@remarkable.com>
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* It is based on max17042_battery driver.
*/
#include <linux/acpi.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/pm.h>
#include <linux/mod_devicetable.h>
#include <linux/power_supply.h>
#include <linux/power/max17042_battery.h>
#include <linux/power/max77818_battery_utils.h>
#include <linux/of.h>
#include <linux/regmap.h>
#include <linux/mfd/max77818/max77818.h>
#include <linux/platform_device.h>
#include <linux/usb/phy.h>
/* Status register bits */
#define STATUS_POR_BIT (1 << 1)
#define STATUS_BST_BIT (1 << 3)
#define STATUS_VMN_BIT (1 << 8)
#define STATUS_TMN_BIT (1 << 9)
#define STATUS_SMN_BIT (1 << 10)
#define STATUS_BI_BIT (1 << 11)
#define STATUS_VMX_BIT (1 << 12)
#define STATUS_TMX_BIT (1 << 13)
#define STATUS_SMX_BIT (1 << 14)
#define STATUS_BR_BIT (1 << 15)
/* Interrupt mask bits */
#define CONFIG_ALRT_BIT_ENBL (1 << 2)
#define STATUS_INTR_SOCMIN_BIT (1 << 10)
#define STATUS_INTR_SOCMAX_BIT (1 << 14)
/* Config2 register bits */
#define CONFIG2_LDMDL (1 << 5)
#define VFSOC0_LOCK 0x0000
#define VFSOC0_UNLOCK 0x0080
#define MODEL_UNLOCK1 0X0059
#define MODEL_UNLOCK2 0X00C4
#define MODEL_LOCK1 0X0000
#define MODEL_LOCK2 0X0000
#define dQ_ACC_DIV 0x4
#define dP_ACC_100 0x1900
#define dP_ACC_200 0x3200
#define MAX77818_VMAX_TOLERANCE 50 /* 50 mV */
#define SYNC_SET_FLAG(flag, lock) ( \
{ \
mutex_lock(lock); \
flag = true; \
mutex_unlock(lock); \
} \
)
#define SYNC_CLEAR_FLAG(flag, lock) ( \
{ \
mutex_lock(lock); \
flag = false; \
mutex_unlock(lock); \
} \
)
#define SYNC_GET_FLAG(flag, lock) ( \
{ \
bool state; \
mutex_lock(lock); \
state = flag; \
mutex_unlock(lock); \
state; \
} \
)
/* Parameter to be given from u-boot after doing update
* in order to verify that all custom FG parameters
* are configured according to DT */
static char config_update_param[255] = "verify";
module_param_string(config_update,
config_update_param,
sizeof(config_update_param),
0644);
MODULE_PARM_DESC(config_update,
"Optional parameter indicating the following config update mode:"
"- complete FG update (config_update=\"complete\")"
"- partial update (config_update=\"partial\")"
"- verification against current DT (config_update=\"verify\")"
"\n"
"By default, the verify mode is set."
"\n"
"Scripts may set the config_update param in order to re-config "
"the device if required, depending on versioning scheme or other "
"means of determining if a complete or partial update is required.");
struct max77818_chip {
struct device *dev;
struct max77818_dev *max77818_dev;
int fg_irq;
int chg_irq;
int chg_chgin_irq;
int chg_wcin_irq;
struct regmap *regmap;
struct power_supply *battery;
struct max17042_platform_data *pdata;
struct work_struct init_work;
struct work_struct chg_isr_work;
bool init_complete;
struct power_supply *charger;
struct usb_phy *usb_phy[2];
struct notifier_block charger_detection_nb[2];
struct work_struct charger_detection_work[2];
int status_ex;
int usb_safe_max_current;
struct work_struct initial_charger_sync_work;
struct completion init_completion;
struct mutex lock;
};
static enum power_supply_property max77818_battery_props[] = {
POWER_SUPPLY_PROP_STATUS,
POWER_SUPPLY_PROP_STATUS_EX,
POWER_SUPPLY_PROP_PRESENT,
POWER_SUPPLY_PROP_CYCLE_COUNT,
POWER_SUPPLY_PROP_VOLTAGE_MAX,
POWER_SUPPLY_PROP_VOLTAGE_MIN,
POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
POWER_SUPPLY_PROP_VOLTAGE_NOW,
POWER_SUPPLY_PROP_VOLTAGE_AVG,
POWER_SUPPLY_PROP_VOLTAGE_OCV,
POWER_SUPPLY_PROP_CAPACITY,
POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN,
POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX,
POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
POWER_SUPPLY_PROP_CHARGE_FULL,
POWER_SUPPLY_PROP_CHARGE_NOW,
POWER_SUPPLY_PROP_CHARGE_COUNTER,
POWER_SUPPLY_PROP_TEMP,
POWER_SUPPLY_PROP_TEMP_ALERT_MIN,
POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
POWER_SUPPLY_PROP_HEALTH,
POWER_SUPPLY_PROP_CURRENT_NOW,
POWER_SUPPLY_PROP_CURRENT_AVG,
POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
POWER_SUPPLY_PROP_CHARGER_MODE,
};
static const char * const max77818_status_ex_text[] = {
"Charger not connected", "POGO connected", "USB-C connected",
"POGO/USB-C connected", "Changing", "Unknown"
};
struct max77818_of_property {
const char *property_name;
u8 register_addr;
int (*reg_write_op)(struct regmap *map,
unsigned int reg,
unsigned int value);
bool skip_verify;
bool require_lock;
};
static void max77818_do_init_completion(struct max77818_chip *chip)
{
/* Clear flag used by power supply callbacks to check
* if it is safe to do property read/write */
SYNC_SET_FLAG(chip->init_complete, &chip->lock);
/* Signal to worker(s) waiting for initiation to be complete before
* doing final steps */
complete(&chip->init_completion);
}
static bool max77818_do_complete_update(struct max77818_chip *chip)
{
if (strncmp(config_update_param, "complete", 8) == 0) {
dev_dbg(chip->dev, "config_update='complete'\n");
return true;
}
else {
return false;
}
}
static bool max77818_do_partial_update(struct max77818_chip *chip)
{
if (strncmp(config_update_param, "partial", 7) == 0) {
dev_dbg(chip->dev, "config_update='partial'\n");
return true;
}
else {
return false;
}
}
static bool max77818_do_param_verification(struct max77818_chip *chip)
{
if (strncmp(config_update_param, "verify", 6) == 0) {
dev_dbg(chip->dev, "config_update='verify'\n");
return true;
}
else {
return false;
}
}
static int max77818_get_temperature(struct max77818_chip *chip, int *temp)
{
struct regmap *map = chip->regmap;
u32 data;
int ret;
ret = regmap_read(map, MAX17042_TEMP, &data);
if (ret < 0)
return ret;
*temp = sign_extend32(data, 15);
/* The value is converted into deci-centigrade scale */
/* Units of LSB = 1 / 256 degree Celsius */
*temp = *temp * 10 / 256;
return 0;
}
static int max77818_get_status(struct max77818_chip *chip, int *status)
{
int ret, charge_full, charge_now;
ret = power_supply_am_i_supplied(chip->battery);
if (ret < 0) {
*status = POWER_SUPPLY_STATUS_UNKNOWN;
return 0;
}
if (ret == 0) {
*status = POWER_SUPPLY_STATUS_DISCHARGING;
return 0;
}
/*
* The MAX170xx has builtin end-of-charge detection and will update
* FullCAP to match RepCap when it detects end of charging.
*
* When this cycle the battery gets charged to a higher (calculated)
* capacity then the previous cycle then FullCAP will get updated
* contineously once end-of-charge detection kicks in, so allow the
* 2 to differ a bit.
*/
ret = regmap_read(chip->regmap, MAX17042_FullCAP, &charge_full);
if (ret < 0)
return ret;
ret = regmap_read(chip->regmap, MAX17042_RepCap, &charge_now);
if (ret < 0)
return ret;
if ((charge_full - charge_now) <= MAX17042_FULL_THRESHOLD)
*status = POWER_SUPPLY_STATUS_FULL;
else
*status = POWER_SUPPLY_STATUS_CHARGING;
return 0;
}
static void max77818_update_status_ex(struct max77818_chip *chip)
{
union power_supply_propval val;
int ret = 0;
ret = MAX77818_DO_NON_FGCC_OP(
chip->max77818_dev,
power_supply_get_property(chip->charger,
POWER_SUPPLY_PROP_STATUS_EX,
&val),
"Requesting status_ex from charger");
if (ret) {
dev_err(chip->dev,
"Failed to read status_ex from charger, setting "
"status_ex = UNKNOWN\n");
chip->status_ex = POWER_SUPPLY_STATUS_EX_UNKNOWN;
}
else {
if (val.intval < (sizeof(max77818_status_ex_text)/
sizeof(max77818_status_ex_text[0])))
dev_dbg(chip->dev,
"Setting status_ex = %s\n",
max77818_status_ex_text[val.intval]);
else
dev_dbg(chip->dev,
"Unknown status_ex (%d) returned\n",
val.intval);
chip->status_ex = val.intval;
}
dev_dbg(chip->dev, "Sending status_ex change notification\n");
sysfs_notify(&chip->battery->dev.kobj, NULL, "status_ex");
}
static int max77818_get_battery_health(struct max77818_chip *chip, int *health)
{
int temp, vavg, vbatt, ret;
u32 val;
ret = regmap_read(chip->regmap, MAX17042_AvgVCELL, &val);
if (ret < 0)
goto health_error;
/* bits [0-3] unused */
vavg = val * 625 / 8;
/* Convert to millivolts */
vavg /= 1000;
ret = regmap_read(chip->regmap, MAX17042_VCELL, &val);
if (ret < 0)
goto health_error;
/* bits [0-3] unused */
vbatt = val * 625 / 8;
/* Convert to millivolts */
vbatt /= 1000;
if (vavg < chip->pdata->vmin) {
*health = POWER_SUPPLY_HEALTH_DEAD;
goto out;
}
if (vbatt > chip->pdata->vmax + MAX77818_VMAX_TOLERANCE) {
*health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
goto out;
}
ret = max77818_get_temperature(chip, &temp);
if (ret < 0)
goto health_error;
if (temp < chip->pdata->temp_min) {
*health = POWER_SUPPLY_HEALTH_COLD;
goto out;
}
if (temp > chip->pdata->temp_max) {
*health = POWER_SUPPLY_HEALTH_OVERHEAT;
goto out;
}
*health = POWER_SUPPLY_HEALTH_GOOD;
out:
return 0;
health_error:
return ret;
}
static int max77818_set_charger_mode(struct max77818_chip *chip,
const union power_supply_propval *val)
{
int ret;
if (!chip->charger)
return -ENODEV;
ret = MAX77818_DO_NON_FGCC_OP(
chip->max77818_dev,
power_supply_set_property(chip->charger,
POWER_SUPPLY_PROP_CHARGER_MODE,
val),
"Setting charger mode through charger driver");
if (ret)
dev_err(chip->dev,
"Failed to forward charger mode to charger driver\n");
return ret;
}
static int max77818_get_charger_mode(struct max77818_chip *chip,
int *charger_mode)
{
union power_supply_propval val;
int ret;
if (!chip->charger)
return -ENODEV;
ret = MAX77818_DO_NON_FGCC_OP(
chip->max77818_dev,
power_supply_get_property(chip->charger,
POWER_SUPPLY_PROP_CHARGER_MODE,
&val),
"Reading charger mode from charger driver");
if (ret)
dev_err(chip->dev,
"Failed to read charger mode from charger driver\n");
else
*charger_mode = val.intval;
return ret;
}
static int max77818_get_property(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct max77818_chip *chip = power_supply_get_drvdata(psy);
struct regmap *map = chip->regmap;
int temp;
int ret;
u32 data;
u64 data64;
if (!SYNC_GET_FLAG(chip->init_complete, &chip->lock))
return -EAGAIN;
switch (psp) {
case POWER_SUPPLY_PROP_STATUS:
ret = max77818_get_status(chip, &val->intval);
if (ret < 0)
return ret;
break;
case POWER_SUPPLY_PROP_STATUS_EX:
/* status_ex is just a shadow value of the status_ex prop
* reported by the charger driver, updated upon receiving
* a connection change interrupt from the charger */
val->intval = chip->status_ex;
break;
case POWER_SUPPLY_PROP_PRESENT:
/*
* MAX17042_STATUS_BattAbsent bit is not working for some
* reason unknown yet. We are working around the issue here by
* reading temperature register, in which a negative value
* indicates absence of battery.
*/
ret = max77818_get_temperature(chip, &temp);
if (ret < 0)
return ret;
if (temp < 0)
val->intval = 0;
else
val->intval = 1;
break;
case POWER_SUPPLY_PROP_CYCLE_COUNT:
ret = regmap_read(map, MAX17042_Cycles, &data);
if (ret < 0)
return ret;
val->intval = data;
break;
case POWER_SUPPLY_PROP_VOLTAGE_MAX:
ret = regmap_read(map, MAX17042_MinMaxVolt, &data);
if (ret < 0)
return ret;
val->intval = data >> 8;
val->intval *= 20000; /* Units of LSB = 20mV */
break;
case POWER_SUPPLY_PROP_VOLTAGE_MIN:
ret = regmap_read(map, MAX17042_MinMaxVolt, &data);
if (ret < 0)
return ret;
val->intval = (data & 0xff) * 20000; /* Units of 20mV */
break;
case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
ret = regmap_read(map, MAX17047_V_empty, &data);
if (ret < 0)
return ret;
val->intval = data >> 7;
val->intval *= 10000; /* Units of LSB = 10mV */
break;
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
ret = regmap_read(map, MAX17042_VCELL, &data);
if (ret < 0)
return ret;
val->intval = data * 625 / 8;
break;
case POWER_SUPPLY_PROP_VOLTAGE_AVG:
ret = regmap_read(map, MAX17042_AvgVCELL, &data);
if (ret < 0)
return ret;
val->intval = data * 625 / 8;
break;
case POWER_SUPPLY_PROP_VOLTAGE_OCV:
ret = regmap_read(map, MAX17042_OCVInternal, &data);
if (ret < 0)
return ret;
val->intval = data * 625 / 8;
break;
case POWER_SUPPLY_PROP_CAPACITY:
ret = regmap_read(map, MAX17042_RepSOC, &data);
if (ret < 0)
return ret;
val->intval = data >> 8;
break;
case POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN:
ret = regmap_read(map, MAX17042_SALRT_Th, &data);
if (ret < 0)
return ret;
val->intval = data & 0xff;
break;
case POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX:
ret = regmap_read(map, MAX17042_SALRT_Th, &data);
if (ret < 0)
return ret;
val->intval = data >> 8;
break;
case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
ret = regmap_read(map, MAX17042_DesignCap, &data);
if (ret < 0)
return ret;
data64 = data * 5000000ll;
do_div(data64, chip->pdata->r_sns);
val->intval = data64;
break;
case POWER_SUPPLY_PROP_CHARGE_FULL:
ret = regmap_read(map, MAX17042_FullCAP, &data);
if (ret < 0)
return ret;
data64 = data * 5000000ll;
do_div(data64, chip->pdata->r_sns);
val->intval = data64;
break;
case POWER_SUPPLY_PROP_CHARGE_NOW:
ret = regmap_read(map, MAX17042_RepCap, &data);
if (ret < 0)
return ret;
data64 = data * 5000000ll;
do_div(data64, chip->pdata->r_sns);
val->intval = data64;
break;
case POWER_SUPPLY_PROP_CHARGE_COUNTER:
ret = regmap_read(map, MAX17042_QH, &data);
if (ret < 0)
return ret;
val->intval = data * 1000 / 2;
break;
case POWER_SUPPLY_PROP_TEMP:
ret = max77818_get_temperature(chip, &val->intval);
if (ret < 0)
return ret;
break;
case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
ret = regmap_read(map, MAX17042_TALRT_Th, &data);
if (ret < 0)
return ret;
/* LSB is Alert Minimum. In deci-centigrade */
val->intval = sign_extend32(data & 0xff, 7) * 10;
break;
case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
ret = regmap_read(map, MAX17042_TALRT_Th, &data);
if (ret < 0)
return ret;
/* MSB is Alert Maximum. In deci-centigrade */
val->intval = sign_extend32(data >> 8, 7) * 10;
break;
case POWER_SUPPLY_PROP_HEALTH:
ret = max77818_get_battery_health(chip, &val->intval);
if (ret < 0)
return ret;
break;
case POWER_SUPPLY_PROP_CURRENT_NOW:
ret = regmap_read(map, MAX17042_Current, &data);
if (ret < 0)
return ret;
val->intval = sign_extend32(data, 15);
val->intval *= 1562500 / chip->pdata->r_sns;
break;
case POWER_SUPPLY_PROP_CURRENT_AVG:
ret = regmap_read(map, MAX17042_AvgCurrent, &data);
if (ret < 0)
return ret;
val->intval = sign_extend32(data, 15);
val->intval *= 1562500 / chip->pdata->r_sns;
break;
case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
ret = regmap_read(map, MAX17042_TTE, &data);
val->intval = data * 5625 / 1000;
break;
case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
ret = regmap_read(map, MAX77818_TTF, &data);
val->intval = data * 5625 / 1000;
break;
case POWER_SUPPLY_PROP_CHARGER_MODE:
ret = max77818_get_charger_mode(chip, &val->intval);
if (ret)
return ret;
break;
default:
return -EINVAL;
}
return 0;
}
static int max77818_set_property(struct power_supply *psy,
enum power_supply_property psp,
const union power_supply_propval *val)
{
struct max77818_chip *chip = power_supply_get_drvdata(psy);
struct regmap *map = chip->regmap;
int ret = 0;
u32 data;
int8_t temp;
switch (psp) {
case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
ret = regmap_read(map, MAX17042_TALRT_Th, &data);
if (ret < 0)
return ret;
/* Input in deci-centigrade, convert to centigrade */
temp = val->intval / 10;
/* force min < max */
if (temp >= (int8_t)(data >> 8))
temp = (int8_t)(data >> 8) - 1;
/* Write both MAX and MIN ALERT */
data = (data & 0xff00) + temp;
ret = regmap_write(map, MAX17042_TALRT_Th, data);
break;
case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
ret = regmap_read(map, MAX17042_TALRT_Th, &data);
if (ret < 0)
return ret;
/* Input in Deci-Centigrade, convert to centigrade */
temp = val->intval / 10;
/* force max > min */
if (temp <= (int8_t)(data & 0xff))
temp = (int8_t)(data & 0xff) + 1;
/* Write both MAX and MIN ALERT */
data = (data & 0xff) + (temp << 8);
ret = regmap_write(map, MAX17042_TALRT_Th, data);
break;
case POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN:
if (val->intval < 0 || val->intval > 100) {
ret = -EINVAL;
break;
}
ret = regmap_update_bits(map, MAX17042_SALRT_Th,
0xff, val->intval);
break;
case POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX:
if ((val->intval < 0 || val->intval > 100) &&
val->intval != 255) {
ret = -EINVAL;
break;
}
ret = regmap_update_bits(map, MAX17042_SALRT_Th,
0xff00, val->intval << 8);
break;
case POWER_SUPPLY_PROP_CHARGER_MODE:
if ((val->intval < 0) || (val->intval > 2)) {
ret = -EINVAL;
break;
}
ret = max77818_set_charger_mode(chip, val);
break;
default:
ret = -EINVAL;
}
return ret;
}
static int max77818_property_is_writeable(struct power_supply *psy,
enum power_supply_property psp)
{
int ret;
switch (psp) {
case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
case POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN:
case POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX:
case POWER_SUPPLY_PROP_CHARGER_MODE:
ret = 1;
break;
default:
ret = 0;
}
return ret;
}
static void max77818_external_power_changed(struct power_supply *psy)
{
power_supply_changed(psy);
}
static int max77818_write_and_verify_reg(struct regmap *map, unsigned int reg, unsigned int value)
{
int retries = 8;
u32 read_value;
int ret;
do {
retries--;
ret = regmap_write(map, reg, value);
if (ret) {
continue;
}
ret = regmap_read(map, reg, &read_value);
if (ret) {
continue;
}
if (read_value != value) {
ret = -EIO;
}
} while (retries && read_value != value);
if (ret < 0)
pr_err("%s: err %d\n", __func__, ret);
return ret;
}
static inline int max77818_unlock_model(struct max77818_chip *chip)
{
struct regmap *map = chip->regmap;
int ret;
ret = regmap_write(map, MAX17042_MLOCKReg1, MODEL_UNLOCK1);
if (ret)
return ret;
return regmap_write(map, MAX17042_MLOCKReg2, MODEL_UNLOCK2);
}
static inline int max77818_lock_model(struct max77818_chip *chip)
{
struct regmap *map = chip->regmap;
int ret;
ret = regmap_write(map, MAX17042_MLOCKReg1, MODEL_LOCK1);
if (ret)
return ret;
return regmap_write(map, MAX17042_MLOCKReg2, MODEL_LOCK2);
}
static inline int max77818_write_model_data(struct max77818_chip *chip,
u16 *data, int count)
{
struct regmap *map = chip->regmap;
int i, ret;
for (i = 0; i < count; i++) {
ret = regmap_write(map, MAX17042_MODELChrTbl + i, data[i]);
if (ret)
return ret;
}
return 0;
}
static inline int max77818_read_model_data(struct max77818_chip *chip,
u16 *data, int count)
{
struct regmap *map = chip->regmap;
u32 tmp;
int ret, i;
for (i = 0; i < count; i++) {
ret = regmap_read(map, MAX17042_MODELChrTbl + i, &tmp);
if (ret)
return ret;
data[i] = (u16)tmp;
}
return 0;
}
static inline int max77818_model_data_compare(struct max77818_chip *chip,
u16 *expected, u16 *compareto, int size)
{
int i;
if (memcmp(expected, compareto, size)) {
dev_err(chip->dev, "%s compare failed\n", __func__);
for (i = 0; i < size; i++)
dev_info(chip->dev,
"%03d: Expected: 0x%x, read: 0x%x\n",
i,
expected[i],
compareto[i]);
return -EINVAL;
}
return 0;
}
static int max77818_init_model(struct max77818_chip *chip)
{
struct device_node *np = chip->dev->of_node;
u16 *data, *rdata;
int count;
int ret;
count = of_property_count_u16_elems(np, "maxim,cell-model-data");
if (count < 0 || count != MAX17042_CHARACTERIZATION_DATA_SIZE) {
dev_err(chip->dev, "invalid or missing maxim,cell-model-data: %d\n",
count);
return -EINVAL;
}
data = kcalloc(count, sizeof(*data), GFP_KERNEL);
if (!data) {
dev_err(chip->dev, "failed to kcalloc for data\n");
return -ENOMEM;
}
/* Read cell model data */
of_property_read_u16_array(np, "maxim,cell-model-data", data, count);
rdata = kcalloc(count, sizeof(*rdata), GFP_KERNEL);
if (!rdata) {
dev_err(chip->dev, "failed to kcalloc for rdata\n");
ret = -ENOMEM;
goto free_data;
}
ret = max77818_unlock_model(chip);
if (ret) {
dev_err(chip->dev, "unable to unlock model data: %d\n", ret);
goto free_rdata;
}
ret = max77818_write_model_data(chip, data, count);
if (ret) {
dev_err(chip->dev, "unable to write model data: %d\n", ret);
goto lock_model;
}
ret = max77818_read_model_data(chip, rdata, count);
if (ret) {
dev_err(chip->dev, "unable to read model data: %d\n", ret);
goto lock_model;
}
ret = max77818_model_data_compare(chip, data, rdata, count);
if (ret)
dev_err(chip->dev, "model data compare failed: %d\n", ret);
lock_model:
max77818_lock_model(chip);
free_rdata:
kfree(rdata);
free_data:
kfree(data);
return ret;
}
static int max77818_verify_model_lock(struct max77818_chip *chip)
{
int count = MAX17042_CHARACTERIZATION_DATA_SIZE;
u16 *data;
int ret = 0;
int i;
data = kcalloc(count, sizeof(*data), GFP_KERNEL);
if (!data)
return -ENOMEM;
ret = max77818_read_model_data(chip, data, count);
if (ret)
goto done;
for (i = 0; i < count; i++) {
if (data[i]) {
ret = -EINVAL;
goto done;
}
}
done:
kfree(data);
return ret;
}
static int max77818_model_loading(struct max77818_chip *chip)
{
unsigned long timeout = jiffies + msecs_to_jiffies(400);
struct regmap *map = chip->regmap;
u32 config2;
int ret;
/* Setting LdMdl bit */
ret = regmap_read(map, MAX77818_Config2, &config2);
if (ret)
return ret;
ret = regmap_write(map, MAX77818_Config2, config2 | CONFIG2_LDMDL);
if (ret)
return ret;
/* Poll LdMdl bit to be 0 under 400ms */
do {
ret = regmap_read(map, MAX77818_Config2, &config2);
if (ret)
break;
if ((config2 & CONFIG2_LDMDL) == 0)
break;
if (time_after(jiffies, timeout))
break;
} while (1);
ret = regmap_read(map, MAX77818_Config2, &config2);
if (ret)
return ret;
return (config2 & CONFIG2_LDMDL) ? -ETIMEDOUT : 0;
}
static inline int max77818_read_of_property(struct max77818_chip *chip,
const char *param,
u16 *value)
{
struct device_node *np = chip->dev->of_node;
int ret;
u16 read_value = 0;
ret = of_property_read_u16(np, param, &read_value);
if (!ret)
*value = read_value;
return ret;
}
static int max77818_write_of_param_if_mismatch(struct max77818_chip *chip,
struct max77818_of_property *prop)
{
u16 read_param = 0;
int read_cur_value = 0;
bool param_mismatch = false;
int ret;
ret = max77818_read_of_property(chip, prop->property_name, &read_param);
if(!ret) {
dev_dbg(chip->dev, "Verifying '%s' (reg 0x%02x) = 0x%04x\n",
prop->property_name,
prop->register_addr,
read_param);
if (prop->require_lock) {
dev_dbg(chip->dev, "Applying lock\n");
mutex_lock(&chip->max77818_dev->lock);
}
ret = regmap_read(chip->regmap,
prop->register_addr,
&read_cur_value);
if(ret) {
dev_warn(chip->dev,
"Failed to read '%s' from reg 0x%02x)\n",
prop->property_name,
prop->register_addr);
param_mismatch = true;
}
if ((read_param != read_cur_value) || param_mismatch) {
dev_dbg(chip->dev,
"Read '%s' (reg 0x%02x) = 0x%04x from device, "
"expected 0x%04x\n",
prop->property_name,
prop->register_addr,
read_cur_value,
read_param);
param_mismatch = true;
}
if (param_mismatch) {
dev_dbg(chip->dev, "Writing '%s' (reg 0x%02x): 0x%04x\n",
prop->property_name,
prop->register_addr,
read_param);
ret = prop->reg_write_op(chip->regmap,
prop->register_addr,
read_param);
if (ret) {
dev_err(chip->dev,
"Failed to write '%s' (reg 0x%02x): 0x%04x\n",
prop->property_name,
prop->register_addr,
read_param);
}
}
if (prop->require_lock) {
dev_dbg(chip->dev, "Releasing lock\n");
mutex_unlock(&chip->max77818_dev->lock);
}
}
else if (ret == -EINVAL)
dev_warn(chip->dev,
"'%s' property not given in DT, using default value\n",
prop->property_name);
else
dev_warn(chip->dev,
"Failed to read '%s' param from DT, check value\n",
prop->property_name);
return ret;
}
static int max77818_read_of_param_and_write(struct max77818_chip *chip,
struct max77818_of_property *prop)
{
u16 read_param;
int ret;
ret = max77818_read_of_property(chip, prop->property_name, &read_param);
if (!ret) {
dev_dbg(chip->dev, "Writing '%s' (reg 0x%02x): 0x%04x\n",
prop->property_name,
prop->register_addr,
read_param);
if (prop->require_lock) {
dev_dbg(chip->dev, "Applying lock\n");
mutex_lock(&chip->max77818_dev->lock);
}
ret = prop->reg_write_op(chip->regmap,
prop->register_addr,
read_param);
if (ret) {
dev_warn(chip->dev,
"Failed to write '%s' property read from DT\n",
prop->property_name);
}
if (prop->require_lock) {
dev_dbg(chip->dev, "Releasing lock\n");
mutex_unlock(&chip->max77818_dev->lock);
}
}
else if (ret == -EINVAL)
dev_warn(chip->dev,
"'%s' property not given in DT, using default value\n",
prop->property_name);
else
dev_warn(chip->dev,
"Failed to read '%s' param from DT, check value\n",
prop->property_name);
return ret;
}
static int max77818_unlock_extra_config_registers(struct max77818_chip *chip)
{
struct regmap *map = chip->regmap;
u32 value;
int ret;
ret = regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_UNLOCK);
if (ret) {
dev_warn(chip->dev,
"Failed to write VFSOC0Enable to unlock: %d\n", ret);
return ret;
}
ret = regmap_read(map, MAX17042_VFSOC, &value);
if (ret) {
dev_warn(chip->dev, "Failed to read VFSOC: %d\n", ret);
return ret;
}
return max77818_write_and_verify_reg(map, MAX17042_VFSOC0, value);
}
static int max77818_lock_extra_config_registers(struct max77818_chip *chip)
{
struct regmap *map = chip->regmap;
int ret;
ret = regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_LOCK);
if (ret)
dev_warn(chip->dev,
"Failed to write VFSOC0Enable to lock: %d\n", ret);
return ret;
}
static struct max77818_of_property max77818_relax_cfg =
{"maxim,relax-cfg", MAX17042_RelaxCFG, regmap_write, true, false };
static struct max77818_of_property max77818_custom_param_list [] = {
{ "maxim,learn-cfg", MAX17042_LearnCFG, regmap_write, true, false },
/* Verified and restored if required after reboot to ensure FGCC=1 */
/* Also marked to require lock */
{ "maxim,config", MAX17042_CONFIG, regmap_write, false, true},
{ "maxim,config2", MAX77818_Config2, regmap_write, true },
{ "maxim,full-soc-threshold", MAX17047_FullSOCThr, regmap_write, true, false },
/* learned value, skipped during verify/write operation at boot */
{ "maxim,fullcaprep", MAX17042_FullCAP0, max77818_write_and_verify_reg, true, false },
{ "maxim,design-cap", MAX17042_DesignCap, regmap_write, true, false },
/* learned values, skipped during verify/write operation at boot */
{ "maxim,dpacc", MAX17042_dPacc, max77818_write_and_verify_reg, true, false },
{ "maxim,dqacc", MAX17042_dQacc, max77818_write_and_verify_reg, true, false },
{ "maxim,fullcapnom", MAX17042_FullCAPNom, max77818_write_and_verify_reg, true, false },
{ "maxim,misc-cfg", MAX17042_MiscCFG, regmap_write, true, false },
{ "maxim,v-empty", MAX17047_V_empty, regmap_write, true, false },
{ "maxim,qresidual00", MAX17047_QRTbl00, max77818_write_and_verify_reg, true, false },
{ "maxim,qresidual10", MAX17047_QRTbl10, max77818_write_and_verify_reg, true, false },
{ "maxim,qresidual20", MAX17047_QRTbl20, max77818_write_and_verify_reg, true, false },
{ "maxim,qresidual30", MAX17047_QRTbl30, max77818_write_and_verify_reg, true, false },
/* learned value, skipped during verify/write operation at boot */
{ "maxim,rcomp0", MAX17042_RCOMP0, max77818_write_and_verify_reg, true, false },
{ "maxim,tempco", MAX17042_TempCo, max77818_write_and_verify_reg, true, false },
{ "maxim,ichg-term", MAX17042_ICHGTerm, regmap_write, true, false },
{ "maxim,filter-cfg", MAX17042_FilterCFG, regmap_write, true, false },
/* learned value, skipped during verify/write operation at boot */
{ "maxim,iavg-empty", MAX17042_LAvg_empty, regmap_write, true, false },
{ "maxim,tgain", MAX17042_TGAIN, regmap_write, false, false },
{ "maxim,toff", MAx17042_TOFF, regmap_write, false, false },
{ "maxim,tcurve", MAX77818_TCURVE, regmap_write, false, false },
{ "maxim,talrt-th", MAX17042_TALRT_Th, regmap_write, false, false },
{ "maxim,talrt-th2", MAX77818_TALRT_Th2, regmap_write, false, false },
{ "maxim,jeita-curr", MAX77818_JEITA_Curr, regmap_write, false, false },
{ "maxim,jeita-volt", MAX77818_JEITA_Volt, regmap_write, false, false },
{ "maxim,chargestate0", MAX77818_ChargeState0, regmap_write, false, false },
{ "maxim,chargestate1", MAX77818_ChargeState1, regmap_write, false, false },
{ "maxim,chargestate2", MAX77818_ChargeState2, regmap_write, false, false },
{ "maxim,chargestate3", MAX77818_ChargeState3, regmap_write, false, false },
{ "maxim,chargestate4", MAX77818_ChargeState4, regmap_write, false, false },
{ "maxim,chargestate5", MAX77818_ChargeState5, regmap_write, false, false },
{ "maxim,chargestate6", MAX77818_ChargeState6, regmap_write, false, false },
{ "maxim,chargestate7", MAX77818_ChargeState7, regmap_write, false, false },
/* The order of the following ones should be respected */
{ "maxim,at-rate", MAX17042_AtRate, regmap_write, true, false },
{ "maxim,smart-chg-cfg", MAX77818_SmartChgCfg, regmap_write, false, false },
{ "maxim,convgcfg", MAX77818_ConvgCfg, regmap_write, true, false },
};
static bool max77818_write_mismatched_custom_params(struct max77818_chip *chip)
{
int i;
int ret;
bool is_success = true;
dev_dbg(chip->dev, "Verifying custom params\n");
if (max77818_relax_cfg.skip_verify) {
dev_dbg(chip->dev,
"Skipping verify/write for register '%s'\n",
max77818_relax_cfg.property_name);
}
else {
ret = max77818_write_of_param_if_mismatch(chip, &max77818_relax_cfg);
if (ret)
is_success = false;
}
ret = max77818_unlock_extra_config_registers(chip);
if (ret)
is_success = false;
for(i = 0; i < ARRAY_SIZE(max77818_custom_param_list); i++) {
if (max77818_custom_param_list[i].skip_verify) {
dev_dbg(chip->dev,
"Skipping verify/write for register '%s'\n",
max77818_custom_param_list[i].property_name);
continue;
}
ret = max77818_write_of_param_if_mismatch(chip,
&max77818_custom_param_list[i]);
if (ret)
is_success = false;
}
max77818_lock_extra_config_registers(chip);
return is_success;
}
static bool max77818_write_all_custom_params(struct max77818_chip *chip)
{
struct regmap *map = chip->regmap;
int ret, i;
bool is_success = true;
dev_dbg(chip->dev, "Writing custom params\n");
ret = regmap_write(map, MAX17042_RepCap, 0);
if (ret) {
dev_warn(chip->dev, "Failed to write RepCap: %d\n", ret);
is_success = false;
}
ret = max77818_read_of_param_and_write(chip, &max77818_relax_cfg);
if (ret)
is_success = false;
ret = max77818_unlock_extra_config_registers(chip);
if (ret)
is_success = false;
for(i = 0; i < ARRAY_SIZE(max77818_custom_param_list); i++) {
ret = max77818_read_of_param_and_write(chip,
&max77818_custom_param_list[i]);
if (ret)
is_success = false;
}
max77818_lock_extra_config_registers(chip);
return is_success;
}
static int max77818_init_chip(struct max77818_chip *chip)
{
struct regmap *map = chip->regmap;
int ret;
bool is_success;
/* Write cell characterization data */
ret = max77818_init_model(chip);
if (ret) {
dev_err(chip->dev, "init model failed: %d\n", ret);
return ret;
}
ret = max77818_verify_model_lock(chip);
if (ret) {
dev_err(chip->dev, "lock verify failed: %d\n", ret);
return ret;
}
/* Write custom parameters from device tree */
is_success = max77818_write_all_custom_params(chip);
/* Initiate model loading for MAX77818 */
ret = max77818_model_loading(chip);
if (ret) {
dev_err(chip->dev, "initiate model loading failed: %d\n", ret);
return ret;
}
/* Wait 500 ms for SOC to be calculated from the new parameters */
msleep(500);
/* Init complete, Clear the POR bit if successful */
if (is_success)
regmap_update_bits(map, MAX17042_STATUS, STATUS_POR_BIT, 0x0);
return 0;
}
static void max77818_do_initial_charger_sync_worker(struct work_struct *work)
{
struct max77818_chip *chip =
container_of(work, struct max77818_chip, initial_charger_sync_work);
struct max77818_dev *max77818 = chip->max77818_dev;
struct device *dev = max77818->dev;
union power_supply_propval val;
int ret;
/* Wait for other initiation to be completed before running these
* final steps */
dev_dbg(dev, "Waiting for other initiation to complete before doing "
"final charger driver sync. steps \n");
ret = wait_for_completion_interruptible_timeout(&chip->init_completion,
10 * HZ);
if (ret == 0) {
dev_err(dev, "Timeout while waiting for other init to complete, "
"trying to do final charger driver sync anyway\n");
}
else {
dev_dbg(dev, "Other init completed, starting final charger "
"driver sync stepd\n");
}
val.intval = 0;
ret = MAX77818_DO_NON_FGCC_OP(
max77818,
power_supply_set_property(chip->charger,
POWER_SUPPLY_PROP_CURRENT_MAX,
&val),
"Setting chgin max current\n");
if (ret) {
dev_err(dev,
"Failed to set max current in charger driver\n");
}
ret = MAX77818_DO_NON_FGCC_OP(
max77818,
power_supply_get_property(chip->charger,
POWER_SUPPLY_PROP_STATUS_EX,
&val),
"Reading initial status_ex from charger\n");
if (ret) {
dev_err(chip->dev,
"Failed to read status_ex from charger driver while"
"doing initial charger driver sync\n");
}
/* Do an initial max current adjustment according to max current
* currently configured in USB PHY, in case this was updated before
* this driver was loaded.
*
* As the charger detection handling is normally done i a worker,
* the initial calls done here are queued on the same work queue as the
* async event workers, in order to prevent conflict with possible
* ongoing event handling if called directly from here */
dev_dbg(chip->dev,
"Scheduling initial max current adjustment for chgin interface ");
schedule_work(&chip->charger_detection_work[0]);
dev_dbg(chip->dev,
"Scheduling initial max current adjustment for wcin interface ");
schedule_work(&chip->charger_detection_work[1]);
}
static irqreturn_t max77818_fg_isr(int id, void *dev)
{
struct max77818_chip *chip = dev;
u32 val;
regmap_read(chip->regmap, MAX17042_STATUS, &val);
if (val & STATUS_INTR_SOCMIN_BIT) {
dev_info(chip->dev, "MIN SOC alert\n");
sysfs_notify(&chip->battery->dev.kobj, NULL,
"capacity_alert_min");
}
if (val & STATUS_INTR_SOCMAX_BIT) {
dev_info(chip->dev, "MAX SOC alert\n");
sysfs_notify(&chip->battery->dev.kobj, NULL,
"capacity_alert_max");
}
power_supply_changed(chip->battery);
return IRQ_HANDLED;
}
static void max77818_charger_isr_work(struct work_struct *work)
{
struct max77818_chip *chip =
container_of(work, struct max77818_chip, chg_isr_work);
dev_dbg(chip->dev, "Changing status_ex -> CHANGING\n");
chip->status_ex = POWER_SUPPLY_STATUS_EX_CHANGING;
dev_dbg(chip->dev, "Sending status_ex change notification\n");
sysfs_notify(&chip->battery->dev.kobj, NULL, "status_ex");
dev_dbg(chip->dev, "Reading updated connection state from charger\n");
max77818_update_status_ex(chip);
}
static irqreturn_t max77818_charger_connection_change_isr(int irq, void *data)
{
struct max77818_chip *chip = data;
schedule_work(&chip->chg_isr_work);
return IRQ_HANDLED;
}
static irqreturn_t max77818_charger_isr(int irq, void *data)
{
/*
* This IRQ handler needs to do nothing, as it's here only for
* manipulate top max77818 mfd irq_chip to handle BIT_CHGR_INT.
*/
return IRQ_HANDLED;
}
static void max77818_init_worker(struct work_struct *work)
{
struct max77818_chip *chip = container_of(work, struct max77818_chip,
init_work);
int ret;
dev_dbg(chip->dev, "Doing complete re-config\n");
ret = max77818_init_chip(chip);
if (ret) {
dev_err(chip->dev, "failed to init chip: %d\n", ret);
}
max77818_do_init_completion(chip);
}
static struct max17042_platform_data *
max77818_get_pdata(struct max77818_chip *chip)
{
struct max17042_platform_data *pdata;
struct device *dev = chip->dev;
struct device_node *np = dev->of_node;
pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return NULL;
if (of_property_read_u32(np, "maxim,rsns-microohm", &pdata->r_sns))
pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR;
if (of_property_read_s32(np, "maxim,cold-temp", &pdata->temp_min))
pdata->temp_min = INT_MIN;
if (of_property_read_s32(np, "maxim,over-heat-temp", &pdata->temp_max))
pdata->temp_max = INT_MAX;
if (of_property_read_s32(np, "maxim,dead-volt", &pdata->vmin))
pdata->vmin = INT_MIN;
if (of_property_read_s32(np, "maxim,over-volt", &pdata->vmax))
pdata->vmax = INT_MAX;
return pdata;
}
static void max77818_get_driver_config(struct max77818_chip *chip)
{
struct device_node *np = chip->dev->of_node;
int read_value;
int ret;
ret = of_property_read_u32(np, "usb_safe_max_current", &read_value);
if (ret) {
dev_err(chip->dev,
"Failed to read usb_safe_max_current from DT\n");
chip->usb_safe_max_current = 100;
}
else {
dev_dbg(chip->dev,
"Read usb_safe_max_current: %d\n",
read_value);
chip->usb_safe_max_current = read_value;
}
}
static const struct regmap_config max77818_regmap_config = {
.reg_bits = 8,
.val_bits = 16,
.val_format_endian = REGMAP_ENDIAN_NATIVE,
};
static const struct power_supply_desc max77818_psy_desc = {
.name = "max77818_battery",
.type = POWER_SUPPLY_TYPE_BATTERY,
.get_property = max77818_get_property,
.set_property = max77818_set_property,
.property_is_writeable = max77818_property_is_writeable,
.external_power_changed = max77818_external_power_changed,
.properties = max77818_battery_props,
.num_properties = ARRAY_SIZE(max77818_battery_props),
};
static void max77818_charger_detection_worker_chgin(struct work_struct *work)
{
struct max77818_chip *chip = container_of(work,
struct max77818_chip,
charger_detection_work[0]);
/*
unsigned int min_current, max_current;
*/
union power_supply_propval val;
int ret;
mutex_lock(&chip->lock);
dev_dbg(chip->dev, "Doing charger detection work for chgin interface..\n");
if (!chip->charger) {
dev_err(chip->dev,
"Cannot access charger device, unable to set max current for chgin interface\n");
goto done;
}
/*
dev_dbg(chip->dev, "Getting max/min current configured for given USB PHY\n");
usb_phy_get_charger_current(chip->usb_phy[0], &min_current, &max_current);
if (max_current == 0)
val.intval = chip->usb_safe_max_current;
else
val.intval = max_current;
*/
val.intval = 0;
ret = MAX77818_DO_NON_FGCC_OP(
chip->max77818_dev,
power_supply_set_property(chip->charger,
POWER_SUPPLY_PROP_CURRENT_MAX,
&val),
"Setting max chgin current through charger driver");
if (ret)
dev_err(chip->dev,
"Failed to set max chgin current in charger driver\n");
done:
mutex_unlock(&chip->lock);
}
static void max77818_charger_detection_worker_wcin(struct work_struct *work)
{
struct max77818_chip *chip = container_of(work,
struct max77818_chip,
charger_detection_work[1]);
unsigned int min_current, max_current;
union power_supply_propval val;
int ret;
mutex_lock(&chip->lock);
dev_dbg(chip->dev, "Doing charger detection work for wcin interface..\n");
if (!chip->charger) {
dev_err(chip->dev,
"Cannot access charger device, unable to set max current for wcin interface\n");
goto done;
}
dev_dbg(chip->dev, "Getting max/min current configured for given USB PHY (wcin)\n");
usb_phy_get_charger_current(chip->usb_phy[1], &min_current, &max_current);
if (max_current == 0)
val.intval = 500;
else
val.intval = max_current;
ret = MAX77818_DO_NON_FGCC_OP(
chip->max77818_dev,
power_supply_set_property(chip->charger,
POWER_SUPPLY_PROP_CURRENT_MAX2,
&val),
"Setting max wcin current through charger driver");
if (ret)
dev_err(chip->dev,
"Failed to set max wcin current in charger driver\n");
done:
mutex_unlock(&chip->lock);
}
static int max77818_charger_detection_notifier_call_chgin(struct notifier_block *nb,
unsigned long val, void *v)
{
struct max77818_chip *chip = container_of(nb,
struct max77818_chip,
charger_detection_nb[0]);
dev_dbg(chip->dev,
"Handling charger detection notification from chgin interface "
"(max current: %lu)\n", val);
schedule_work(&chip->charger_detection_work[0]);
return NOTIFY_OK;
}
static int max77818_charger_detection_notifier_call_wcin(struct notifier_block *nb,
unsigned long val, void *v)
{
struct max77818_chip *chip = container_of(nb,
struct max77818_chip,
charger_detection_nb[1]);
dev_dbg(chip->dev,
"Handling charger detection notification from wcin interface "
"(max current: %lu)\n", val);
schedule_work(&chip->charger_detection_work[1]);
return NOTIFY_OK;
}
static int max77818_init_otg_supply(struct max77818_chip *chip)
{
struct device *dev = chip->dev;
dev_dbg(dev, "Trying to reference charger (expecting charger as"
"first supply in given list of supplies)\n");
if (chip->battery->num_supplies > 0) {
chip->charger = power_supply_get_by_name(
chip->battery->supplied_from[0]);
if (!chip->charger) {
dev_warn(dev, "Failed to reference charger, "
"OTG/charger IRQ handling will not"
"be available - verify DT config\n");
}
}
return 0;
}
static int max77818_init_charger_detection(struct max77818_chip *chip)
{
struct device *dev = chip->dev;
int ret;
dev_dbg(dev,
"Trying to reference usb-phy1 (for receiving charger "
"detection notifications for chgin interface\n");
chip->usb_phy[0]= devm_usb_get_phy_by_phandle(dev, "usb-phy1", 0);
if (IS_ERR(chip->usb_phy[0])) {
ret = PTR_ERR(chip->usb_phy[0]);
dev_err(dev, "usb_get_phy failed: %d\n", ret);
return ret;
}
dev_dbg(dev,
"Trying to reference usb-phy2 (for receiving charger "
"detection notifications for wcin interface\n");
chip->usb_phy[1]= devm_usb_get_phy_by_phandle(dev, "usb-phy2", 0);
if (IS_ERR(chip->usb_phy[1])) {
ret = PTR_ERR(chip->usb_phy[1]);
dev_err(dev, "usb_get_phy failed: %d\n", ret);
return ret;
}
dev_dbg(dev,
"Trying to register notification handler (worker) for "
"chgin interface charger detection notifications \n");
INIT_WORK(&chip->charger_detection_work[0],
max77818_charger_detection_worker_chgin);
chip->charger_detection_nb[0].notifier_call =
max77818_charger_detection_notifier_call_chgin;
ret = usb_register_notifier(chip->usb_phy[0],
&chip->charger_detection_nb[0]);
if (ret) {
dev_err(dev, "usb_register_notifier failed: %d\n", ret);
return ret;
}
dev_dbg(dev,
"Trying to register notification handler (worker) for "
"wcin interface charger detection notifications \n");
INIT_WORK(&chip->charger_detection_work[1],
max77818_charger_detection_worker_wcin);
chip->charger_detection_nb[1].notifier_call =
max77818_charger_detection_notifier_call_wcin;
ret = usb_register_notifier(chip->usb_phy[1],
&chip->charger_detection_nb[1]);
if (ret) {
dev_err(dev, "usb_register_notifier failed: %d\n", ret);
goto unreg_usb_phy0_notifier;
}
return 0;
unreg_usb_phy0_notifier:
usb_unregister_notifier(chip->usb_phy[0],
&chip->charger_detection_nb[0]);
return ret;
}
static int max77818_init_fg_interrupt_handling(struct max77818_dev *max77818,
struct max77818_chip *chip)
{
struct device *dev = chip->dev;
int ret;
/* Disable max SOC alert and set min SOC alert as 10% by default */
regmap_write(chip->regmap, MAX17042_SALRT_Th, (0xff << 8) | 0x0a );
/* Register irq handler for the FG interrupt */
chip->fg_irq = regmap_irq_get_virq(max77818->irqc_intsrc,
MAX77818_FG_INT);
if (chip->fg_irq <= 0) {
dev_err(dev, "failed to get virq: %d\n", chip->fg_irq);
return -ENODEV;
}
ret = devm_request_threaded_irq(dev, chip->fg_irq, NULL,
max77818_fg_isr, 0,
chip->battery->desc->name,
chip);
if (ret) {
dev_err(dev, "failed to request irq: %d\n", ret);
return ret;
}
return 0;
}
static int max77818_init_chg_interrupt_handling(struct max77818_dev *max77818,
struct max77818_chip *chip)
{
struct device *dev = chip->dev;
bool fgcc_restore_state;
bool skip_final_fgcc_op_finish = false;
int ret;
/* Init worker to be used by the charger interrupt handler */
INIT_WORK(&chip->chg_isr_work, max77818_charger_isr_work);
/* Disable FGCC during charger device irq handler registration */
ret = MAX77818_START_NON_FGCC_OP(
max77818,
fgcc_restore_state,
"Starting registration of irq handlers for the charger "
"interrupts\n");
if (ret) {
dev_err(dev,
"Failed to disable FGCC before charger device irq "
"handler registration\n");
return ret;
}
/* Register irq handler for the charger interrupt */
chip->chg_irq = regmap_irq_get_virq(max77818->irqc_intsrc,
MAX77818_CHGR_INT);
if (chip->chg_irq <= 0) {
dev_err(dev, "failed to get virq: %d\n", chip->chg_irq);
ret = -ENODEV;
goto finish_fgcc_op;
}
ret = devm_request_threaded_irq(dev, chip->chg_irq, NULL,
max77818_charger_isr, 0,
"charger", chip);
if (ret) {
dev_err(dev, "failed to request charger irq: %d\n", ret);
goto finish_fgcc_op;
}
/* Register irq handler for the CHGIN interrupt */
chip->chg_chgin_irq = regmap_irq_get_virq(max77818->irqc_chg,
CHG_IRQ_CHGIN_I);
if (chip->chg_chgin_irq <= 0) {
dev_err(dev, "failed to get chgin virq: %d\n",
chip->chg_chgin_irq);
ret = -ENODEV;
goto free_chg_irq;
}
dev_dbg(dev, "chgin irq: %d\n", chip->chg_chgin_irq);
ret = devm_request_threaded_irq(dev, chip->chg_chgin_irq, NULL,
max77818_charger_connection_change_isr,
0, "charger-chgin", chip);
if (ret) {
dev_err(dev, "failed to reqeust chgin irq: %d\n", ret);
goto free_chg_irq;
}
/* Register irq handler for the WCIN interrupt */
chip->chg_wcin_irq = regmap_irq_get_virq(max77818->irqc_chg,
CHG_IRQ_WCIN_I);
if (chip->chg_wcin_irq <= 0) {
dev_err(dev, "failed to get wcin virq: %d\n", chip->chg_wcin_irq);
ret = -ENODEV;
goto free_chgin_irq;
}
dev_dbg(dev, "wcin irq: %d\n", chip->chg_wcin_irq);
ret = devm_request_threaded_irq(dev, chip->chg_wcin_irq, NULL,
max77818_charger_connection_change_isr,
0, "charger-wcin", chip);
if (ret) {
dev_err(dev, "failed to reqeust wcin irq: %d\n", ret);
goto free_chgin_irq;
}
ret = MAX77818_FINISH_NON_FGCC_OP(
max77818,
fgcc_restore_state,
"Finishing registration of irq handlers for the charger "
"interrupts\n");
if (ret) {
dev_err(dev,
"Failed to re-enable FGCC after charger device irq "
"handler registration\n");
skip_final_fgcc_op_finish = true;
goto free_wcin_irq;
}
return 0;
free_wcin_irq:
free_irq(chip->chg_wcin_irq, NULL);
free_chgin_irq:
free_irq(chip->chg_chgin_irq, NULL);
free_chg_irq:
free_irq(chip->chg_irq, NULL);
finish_fgcc_op:
if (!skip_final_fgcc_op_finish)
if (MAX77818_FINISH_NON_FGCC_OP(
max77818,
fgcc_restore_state,
"Finishing (failed) registration of irq handlers "
"for the charger interrupts\n"))
dev_err(dev,
"Failed to re-enable FGCC after failed charger device "
"irq handler registration\n");
return ret;
}
static int max77818_probe(struct platform_device *pdev)
{
struct max77818_dev *max77818 = dev_get_drvdata(pdev->dev.parent);
struct power_supply_config psy_cfg = {};
struct device *dev = &pdev->dev;
struct max77818_chip *chip;
u32 val;
int ret;
chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
if (!chip)
return -ENOMEM;
mutex_init(&chip->lock);
chip->max77818_dev = max77818;
chip->dev = dev;
chip->regmap = max77818->regmap_fg;
chip->pdata = max77818_get_pdata(chip);
if (!chip->pdata) {
dev_err(dev, "no platform data provided\n");
return -EINVAL;
}
/* Get non device related driver config from DT */
max77818_get_driver_config(chip);
platform_set_drvdata(pdev, chip);
psy_cfg.drv_data = chip;
psy_cfg.of_node = dev->of_node;
SYNC_CLEAR_FLAG(chip->init_complete, &chip->lock);
chip->battery = devm_power_supply_register(dev, &max77818_psy_desc,
&psy_cfg);
if (IS_ERR(chip->battery)) {
ret = PTR_ERR(chip->battery);
dev_err(dev, "failed to register supply: %d \n", ret);
return ret;
}
max77818_init_otg_supply(chip);
ret = max77818_init_charger_detection(chip);
if (ret) {
dev_err(dev, "Failed to init charger detection\n");
goto unreg_supply;
}
ret = max77818_init_fg_interrupt_handling(max77818, chip);
if (ret) {
dev_err(dev, "Failed to init FG interrupt handling\n");
goto unreg_chg_det;
}
ret = max77818_init_chg_interrupt_handling(max77818, chip);
if (ret) {
dev_err(dev, "Failed to init charger interrupt handling\n");
goto unreg_fg_irq;
}
/* A completion object is initiated in order for init to be run after
* completed initiation of this driver is kept waiting until all is done
* here.
*
* Also a worker is scheduled to run which will wait for this until
* performing final charger sync. */
init_completion(&chip->init_completion);
INIT_WORK(&chip->initial_charger_sync_work,
max77818_do_initial_charger_sync_worker);
schedule_work(&chip->initial_charger_sync_work);
/* Read the POR bit set when the device boots from a total power loss.
* If this bit is set, the device is given its initial config read from
* DT.
*
* If the POR is not set, but the module parameter 'config_update' is
* set to 'complete' when booting (by image update scripts typically),
* a complete re-config of the FG device is performed in order to apply
* battery model parameters in addition to custom params read
* from updated DT.
*
* If the POR is not set, but the module parameter 'config_update' is
* set to 'partial' when booting (by image update scripts typically),
* a partial re-config of the custom params is performed in order to apply
* only custom parameters read from updated DT. */
regmap_read(chip->regmap, MAX17042_STATUS, &val);
if ((val & STATUS_POR_BIT) || max77818_do_complete_update(chip)) {
INIT_WORK(&chip->init_work, max77818_init_worker);
schedule_work(&chip->init_work);
} else if (max77818_do_partial_update(chip)) {
max77818_write_all_custom_params(chip);
max77818_do_init_completion(chip);
} else if (max77818_do_param_verification(chip)) {
max77818_write_mismatched_custom_params(chip);
max77818_do_init_completion(chip);
}
else {
dev_dbg(chip->dev, "No config change\n");
max77818_do_init_completion(chip);
}
return 0;
unreg_fg_irq:
free_irq(chip->fg_irq, NULL);
unreg_chg_det:
usb_unregister_notifier(chip->usb_phy[0],
&chip->charger_detection_nb[0]);
usb_unregister_notifier(chip->usb_phy[1],
&chip->charger_detection_nb[1]);
unreg_supply:
power_supply_unregister(chip->battery);
return ret;
}
static struct platform_driver max77818_fg_driver = {
.driver = {
.name = MAX77818_FUELGAUGE_NAME,
.owner = THIS_MODULE,
},
.probe = max77818_probe,
};
module_platform_driver(max77818_fg_driver);
MODULE_DESCRIPTION("MAX77818 Fuel Gauge");
MODULE_LICENSE("GPL");
View Git Blame Copy Permalink