superrob1500
/
mirror-linux
mirror of https://github.com/torvalds/linux
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
mirror-linux/drivers/power/supply/bd71828-power.c

1050 lines
27 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0-or-later
/* ROHM BD71815, BD71828 and BD71878 Charger driver */
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/mfd/rohm-bd71815.h>
#include <linux/mfd/rohm-bd71828.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/platform_device.h>
#include <linux/property.h>
#include <linux/power_supply.h>
#include <linux/slab.h>
/* common defines */
#define BD7182x_MASK_VBAT_U 0x1f
#define BD7182x_MASK_VDCIN_U 0x0f
#define BD7182x_MASK_IBAT_U 0x3f
#define BD7182x_MASK_CURDIR_DISCHG 0x80
#define BD7182x_MASK_CHG_STATE 0x7f
#define BD7182x_MASK_BAT_TEMP 0x07
#define BD7182x_MASK_DCIN_DET BIT(0)
#define BD7182x_MASK_CONF_PON BIT(0)
#define BD71815_MASK_CONF_XSTB BIT(1)
#define BD7182x_MASK_BAT_STAT 0x3f
#define BD7182x_MASK_DCIN_STAT 0x07
#define BD7182x_MASK_WDT_AUTO 0x40
#define BD7182x_MASK_VBAT_ALM_LIMIT_U 0x01
#define BD7182x_MASK_CHG_EN 0x01
#define BD7182x_DCIN_COLLAPSE_DEFAULT 0x36
#define MAX_CURRENT_DEFAULT 890000 /* uA */
#define AC_NAME "bd71828_ac"
#define BAT_NAME "bd71828_bat"
#define BAT_OPEN 0x7
/*
* VBAT Low voltage detection Threshold
* 0x00D4*16mV = 212*0.016 = 3.392v
*/
#define VBAT_LOW_TH 0x00D4
struct pwr_regs {
u8 vbat_avg;
u8 ibat;
u8 ibat_avg;
u8 btemp_vth;
u8 chg_state;
u8 bat_temp;
u8 dcin_stat;
u8 dcin_collapse_limit;
u8 chg_set1;
u8 chg_en;
u8 vbat_alm_limit_u;
u8 conf;
u8 vdcin;
};
static const struct pwr_regs pwr_regs_bd71828 = {
.vbat_avg = BD71828_REG_VBAT_U,
.ibat = BD71828_REG_IBAT_U,
.ibat_avg = BD71828_REG_IBAT_AVG_U,
.btemp_vth = BD71828_REG_VM_BTMP_U,
.chg_state = BD71828_REG_CHG_STATE,
.bat_temp = BD71828_REG_BAT_TEMP,
.dcin_stat = BD71828_REG_DCIN_STAT,
.dcin_collapse_limit = BD71828_REG_DCIN_CLPS,
.chg_set1 = BD71828_REG_CHG_SET1,
.chg_en = BD71828_REG_CHG_EN,
.vbat_alm_limit_u = BD71828_REG_ALM_VBAT_LIMIT_U,
.conf = BD71828_REG_CONF,
.vdcin = BD71828_REG_VDCIN_U,
};
static const struct pwr_regs pwr_regs_bd71815 = {
.vbat_avg = BD71815_REG_VM_SA_VBAT_U,
/* BD71815 does not have separate current and current avg */
.ibat = BD71815_REG_CC_CURCD_U,
.ibat_avg = BD71815_REG_CC_CURCD_U,
.btemp_vth = BD71815_REG_VM_BTMP,
.chg_state = BD71815_REG_CHG_STATE,
.bat_temp = BD71815_REG_BAT_TEMP,
.dcin_stat = BD71815_REG_DCIN_STAT,
.dcin_collapse_limit = BD71815_REG_DCIN_CLPS,
.chg_set1 = BD71815_REG_CHG_SET1,
.chg_en = BD71815_REG_CHG_SET1,
.vbat_alm_limit_u = BD71815_REG_ALM_VBAT_TH_U,
.conf = BD71815_REG_CONF,
.vdcin = BD71815_REG_VM_DCIN_U,
};
struct bd71828_power {
struct regmap *regmap;
enum rohm_chip_type chip_type;
struct device *dev;
struct power_supply *ac;
struct power_supply *bat;
const struct pwr_regs *regs;
/* Reg val to uA */
int curr_factor;
int rsens;
int (*get_temp)(struct bd71828_power *pwr, int *temp);
int (*bat_inserted)(struct bd71828_power *pwr);
};
static int bd7182x_write16(struct bd71828_power *pwr, int reg, u16 val)
{
__be16 tmp;
tmp = cpu_to_be16(val);
return regmap_bulk_write(pwr->regmap, reg, &tmp, sizeof(tmp));
}
static int bd7182x_read16_himask(struct bd71828_power *pwr, int reg, int himask,
u16 *val)
{
struct regmap *regmap = pwr->regmap;
int ret;
__be16 rvals;
u8 *tmp = (u8 *)&rvals;
ret = regmap_bulk_read(regmap, reg, &rvals, sizeof(*val));
if (!ret) {
*tmp &= himask;
*val = be16_to_cpu(rvals);
}
return ret;
}
static int bd71828_get_vbat(struct bd71828_power *pwr, int *vcell)
{
u16 tmp_vcell;
int ret;
ret = bd7182x_read16_himask(pwr, pwr->regs->vbat_avg,
BD7182x_MASK_VBAT_U, &tmp_vcell);
if (ret)
dev_err(pwr->dev, "Failed to read battery average voltage\n");
else
*vcell = ((int)tmp_vcell) * 1000;
return ret;
}
static int bd71828_get_current_ds_adc(struct bd71828_power *pwr, int *curr, int *curr_avg)
{
__be16 tmp_curr;
char *tmp = (char *)&tmp_curr;
int dir = 1;
int regs[] = { pwr->regs->ibat, pwr->regs->ibat_avg };
int *vals[] = { curr, curr_avg };
int ret, i;
for (dir = 1, i = 0; i < ARRAY_SIZE(regs); i++) {
ret = regmap_bulk_read(pwr->regmap, regs[i], &tmp_curr,
sizeof(tmp_curr));
if (ret)
break;
if (*tmp & BD7182x_MASK_CURDIR_DISCHG)
dir = -1;
*tmp &= BD7182x_MASK_IBAT_U;
*vals[i] = dir * ((int)be16_to_cpu(tmp_curr)) * pwr->curr_factor;
}
return ret;
}
/* Unit is tenths of degree C */
static int bd71815_get_temp(struct bd71828_power *pwr, int *temp)
{
struct regmap *regmap = pwr->regmap;
int ret;
int t;
ret = regmap_read(regmap, pwr->regs->btemp_vth, &t);
if (ret)
return ret;
t = 200 - t;
if (t > 200) {
dev_err(pwr->dev, "Failed to read battery temperature\n");
return -ENODATA;
}
return 0;
}
/* Unit is tenths of degree C */
static int bd71828_get_temp(struct bd71828_power *pwr, int *temp)
{
u16 t;
int ret;
int tmp = 200 * 10000;
ret = bd7182x_read16_himask(pwr, pwr->regs->btemp_vth,
BD71828_MASK_VM_BTMP_U, &t);
if (ret)
return ret;
if (t > 3200) {
dev_err(pwr->dev,
"Failed to read battery temperature\n");
return -ENODATA;
}
tmp -= 625ULL * (unsigned int)t;
*temp = tmp / 1000;
return ret;
}
static int bd71828_charge_status(struct bd71828_power *pwr,
int *s, int *h)
{
unsigned int state;
int status, health;
int ret = 1;
ret = regmap_read(pwr->regmap, pwr->regs->chg_state, &state);
if (ret) {
dev_err(pwr->dev, "charger status reading failed (%d)\n", ret);
return ret;
}
state &= BD7182x_MASK_CHG_STATE;
dev_dbg(pwr->dev, "CHG_STATE %d\n", state);
switch (state) {
case 0x00:
status = POWER_SUPPLY_STATUS_DISCHARGING;
health = POWER_SUPPLY_HEALTH_GOOD;
break;
case 0x01:
case 0x02:
case 0x03:
case 0x0E:
status = POWER_SUPPLY_STATUS_CHARGING;
health = POWER_SUPPLY_HEALTH_GOOD;
break;
case 0x0F:
status = POWER_SUPPLY_STATUS_FULL;
health = POWER_SUPPLY_HEALTH_GOOD;
break;
case 0x10:
case 0x11:
case 0x12:
case 0x13:
case 0x14:
case 0x20:
case 0x21:
case 0x22:
case 0x23:
case 0x24:
status = POWER_SUPPLY_STATUS_NOT_CHARGING;
health = POWER_SUPPLY_HEALTH_OVERHEAT;
break;
case 0x30:
case 0x31:
case 0x32:
case 0x40:
status = POWER_SUPPLY_STATUS_DISCHARGING;
health = POWER_SUPPLY_HEALTH_GOOD;
break;
case 0x7f:
default:
status = POWER_SUPPLY_STATUS_NOT_CHARGING;
health = POWER_SUPPLY_HEALTH_DEAD;
break;
}
if (s)
*s = status;
if (h)
*h = health;
return ret;
}
static int get_chg_online(struct bd71828_power *pwr, int *chg_online)
{
int r, ret;
ret = regmap_read(pwr->regmap, pwr->regs->dcin_stat, &r);
if (ret) {
dev_err(pwr->dev, "Failed to read DCIN status\n");
return ret;
}
*chg_online = ((r & BD7182x_MASK_DCIN_DET) != 0);
return 0;
}
static int get_bat_online(struct bd71828_power *pwr, int *bat_online)
{
int r, ret;
ret = regmap_read(pwr->regmap, pwr->regs->bat_temp, &r);
if (ret) {
dev_err(pwr->dev, "Failed to read battery temperature\n");
return ret;
}
*bat_online = ((r & BD7182x_MASK_BAT_TEMP) != BAT_OPEN);
return 0;
}
static int bd71828_bat_inserted(struct bd71828_power *pwr)
{
int ret, val;
ret = regmap_read(pwr->regmap, pwr->regs->conf, &val);
if (ret) {
dev_err(pwr->dev, "Failed to read CONF register\n");
return 0;
}
ret = val & BD7182x_MASK_CONF_PON;
if (ret)
regmap_update_bits(pwr->regmap, pwr->regs->conf,
BD7182x_MASK_CONF_PON, 0);
return ret;
}
static int bd71815_bat_inserted(struct bd71828_power *pwr)
{
int ret, val;
ret = regmap_read(pwr->regmap, pwr->regs->conf, &val);
if (ret) {
dev_err(pwr->dev, "Failed to read CONF register\n");
return ret;
}
ret = !(val & BD71815_MASK_CONF_XSTB);
if (ret)
regmap_write(pwr->regmap, pwr->regs->conf, val |
BD71815_MASK_CONF_XSTB);
return ret;
}
static int bd71828_init_hardware(struct bd71828_power *pwr)
{
int ret;
/* TODO: Collapse limit should come from device-tree ? */
ret = regmap_write(pwr->regmap, pwr->regs->dcin_collapse_limit,
BD7182x_DCIN_COLLAPSE_DEFAULT);
if (ret) {
dev_err(pwr->dev, "Failed to write DCIN collapse limit\n");
return ret;
}
ret = pwr->bat_inserted(pwr);
if (ret < 0)
return ret;
if (ret) {
/* WDT_FST auto set */
ret = regmap_update_bits(pwr->regmap, pwr->regs->chg_set1,
BD7182x_MASK_WDT_AUTO,
BD7182x_MASK_WDT_AUTO);
if (ret)
return ret;
ret = bd7182x_write16(pwr, pwr->regs->vbat_alm_limit_u,
VBAT_LOW_TH);
if (ret)
return ret;
/*
* On BD71815 "we mask the power-state" from relax detection.
* I am unsure what the impact of the power-state would be if
* we didn't - but this is what the vendor driver did - and
* that driver has been used in few projects so I just assume
* this is needed.
*/
if (pwr->chip_type == ROHM_CHIP_TYPE_BD71815) {
ret = regmap_set_bits(pwr->regmap,
BD71815_REG_REX_CTRL_1,
REX_PMU_STATE_MASK);
if (ret)
return ret;
}
}
return 0;
}
static int bd71828_charger_get_property(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct bd71828_power *pwr = dev_get_drvdata(psy->dev.parent);
u32 vot;
u16 tmp;
int online;
int ret;
switch (psp) {
case POWER_SUPPLY_PROP_ONLINE:
ret = get_chg_online(pwr, &online);
if (!ret)
val->intval = online;
break;
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
ret = bd7182x_read16_himask(pwr, pwr->regs->vdcin,
BD7182x_MASK_VDCIN_U, &tmp);
if (ret)
return ret;
vot = tmp;
/* 5 milli volt steps */
val->intval = 5000 * vot;
break;
default:
return -EINVAL;
}
return 0;
}
static int bd71828_battery_get_property(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct bd71828_power *pwr = dev_get_drvdata(psy->dev.parent);
int ret = 0;
int status, health, tmp, curr, curr_avg, chg_en;
if (psp == POWER_SUPPLY_PROP_STATUS ||
psp == POWER_SUPPLY_PROP_HEALTH ||
psp == POWER_SUPPLY_PROP_CHARGE_TYPE)
ret = bd71828_charge_status(pwr, &status, &health);
else if (psp == POWER_SUPPLY_PROP_CURRENT_AVG ||
psp == POWER_SUPPLY_PROP_CURRENT_NOW)
ret = bd71828_get_current_ds_adc(pwr, &curr, &curr_avg);
if (ret)
return ret;
switch (psp) {
case POWER_SUPPLY_PROP_STATUS:
val->intval = status;
break;
case POWER_SUPPLY_PROP_HEALTH:
val->intval = health;
break;
case POWER_SUPPLY_PROP_PRESENT:
ret = get_bat_online(pwr, &tmp);
if (!ret)
val->intval = tmp;
break;
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
ret = bd71828_get_vbat(pwr, &tmp);
val->intval = tmp;
break;
case POWER_SUPPLY_PROP_TECHNOLOGY:
val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
break;
case POWER_SUPPLY_PROP_CURRENT_AVG:
val->intval = curr_avg;
break;
case POWER_SUPPLY_PROP_CURRENT_NOW:
val->intval = curr;
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
val->intval = MAX_CURRENT_DEFAULT;
break;
case POWER_SUPPLY_PROP_TEMP:
ret = pwr->get_temp(pwr, &val->intval);
break;
case POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR:
ret = regmap_read(pwr->regmap, pwr->regs->chg_en, &chg_en);
if (ret)
return ret;
val->intval = (chg_en & BD7182x_MASK_CHG_EN) ?
POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO :
POWER_SUPPLY_CHARGE_BEHAVIOUR_INHIBIT_CHARGE;
break;
default:
ret = -EINVAL;
break;
}
return ret;
}
static int bd71828_battery_set_property(struct power_supply *psy,
enum power_supply_property psp,
const union power_supply_propval *val)
{
struct bd71828_power *pwr = dev_get_drvdata(psy->dev.parent);
int ret = 0;
switch (psp) {
case POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR:
if (val->intval == POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO)
ret = regmap_update_bits(pwr->regmap, pwr->regs->chg_en,
BD7182x_MASK_CHG_EN,
BD7182x_MASK_CHG_EN);
else
ret = regmap_update_bits(pwr->regmap, pwr->regs->chg_en,
BD7182x_MASK_CHG_EN,
0);
break;
default:
return -EINVAL;
}
return ret;
}
static int bd71828_battery_property_is_writeable(struct power_supply *psy,
enum power_supply_property psp)
{
switch (psp) {
case POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR:
return true;
default:
return false;
}
}
/** @brief ac properties */
static const enum power_supply_property bd71828_charger_props[] = {
POWER_SUPPLY_PROP_ONLINE,
POWER_SUPPLY_PROP_VOLTAGE_NOW,
};
static const enum power_supply_property bd71828_battery_props[] = {
POWER_SUPPLY_PROP_STATUS,
POWER_SUPPLY_PROP_HEALTH,
POWER_SUPPLY_PROP_VOLTAGE_NOW,
POWER_SUPPLY_PROP_HEALTH,
POWER_SUPPLY_PROP_PRESENT,
POWER_SUPPLY_PROP_TECHNOLOGY,
POWER_SUPPLY_PROP_TEMP,
POWER_SUPPLY_PROP_CURRENT_AVG,
POWER_SUPPLY_PROP_CURRENT_NOW,
POWER_SUPPLY_PROP_CURRENT_MAX,
POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR,
};
/** @brief powers supplied by bd71828_ac */
static char *bd71828_ac_supplied_to[] = {
BAT_NAME,
};
static const struct power_supply_desc bd71828_ac_desc = {
.name = AC_NAME,
.type = POWER_SUPPLY_TYPE_MAINS,
.properties = bd71828_charger_props,
.num_properties = ARRAY_SIZE(bd71828_charger_props),
.get_property = bd71828_charger_get_property,
};
static const struct power_supply_desc bd71828_bat_desc = {
.name = BAT_NAME,
.type = POWER_SUPPLY_TYPE_BATTERY,
.charge_behaviours = BIT(POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO) |
BIT(POWER_SUPPLY_CHARGE_BEHAVIOUR_INHIBIT_CHARGE),
.properties = bd71828_battery_props,
.num_properties = ARRAY_SIZE(bd71828_battery_props),
.get_property = bd71828_battery_get_property,
.set_property = bd71828_battery_set_property,
.property_is_writeable = bd71828_battery_property_is_writeable,
};
#define RSENS_CURR 10000000LLU
#define BD_ISR_NAME(name) \
bd7181x_##name##_isr
#define BD_ISR_BAT(name, print, run_gauge) \
static irqreturn_t BD_ISR_NAME(name)(int irq, void *data) \
{ \
struct bd71828_power *pwr = (struct bd71828_power *)data; \
\
dev_dbg(pwr->dev, "%s\n", print); \
power_supply_changed(pwr->bat); \
\
return IRQ_HANDLED; \
}
#define BD_ISR_AC(name, print, run_gauge) \
static irqreturn_t BD_ISR_NAME(name)(int irq, void *data) \
{ \
struct bd71828_power *pwr = (struct bd71828_power *)data; \
\
power_supply_changed(pwr->ac); \
dev_dbg(pwr->dev, "%s\n", print); \
power_supply_changed(pwr->bat); \
\
return IRQ_HANDLED; \
}
#define BD_ISR_DUMMY(name, print) \
static irqreturn_t BD_ISR_NAME(name)(int irq, void *data) \
{ \
struct bd71828_power *pwr = (struct bd71828_power *)data; \
\
dev_dbg(pwr->dev, "%s\n", print); \
\
return IRQ_HANDLED; \
}
BD_ISR_BAT(chg_state_changed, "CHG state changed", true)
/* DCIN voltage changes */
BD_ISR_AC(dcin_removed, "DCIN removed", true)
BD_ISR_AC(clps_out, "DCIN voltage back to normal", true)
BD_ISR_AC(clps_in, "DCIN voltage collapsed", false)
BD_ISR_AC(dcin_ovp_res, "DCIN voltage normal", true)
BD_ISR_AC(dcin_ovp_det, "DCIN OVER VOLTAGE", true)
BD_ISR_DUMMY(dcin_mon_det, "DCIN voltage below threshold")
BD_ISR_DUMMY(dcin_mon_res, "DCIN voltage above threshold")
BD_ISR_DUMMY(vsys_uv_res, "VSYS under-voltage cleared")
BD_ISR_DUMMY(vsys_uv_det, "VSYS under-voltage")
BD_ISR_DUMMY(vsys_low_res, "'VSYS low' cleared")
BD_ISR_DUMMY(vsys_low_det, "VSYS low")
BD_ISR_DUMMY(vsys_mon_res, "VSYS mon - resumed")
BD_ISR_DUMMY(vsys_mon_det, "VSYS mon - detected")
BD_ISR_BAT(chg_wdg_temp, "charger temperature watchdog triggered", true)
BD_ISR_BAT(chg_wdg, "charging watchdog triggered", true)
BD_ISR_BAT(bat_removed, "Battery removed", true)
BD_ISR_BAT(bat_det, "Battery detected", true)
/* TODO: Verify the meaning of these interrupts */
BD_ISR_BAT(rechg_det, "Recharging", true)
BD_ISR_BAT(rechg_res, "Recharge ending", true)
BD_ISR_DUMMY(temp_transit, "Temperature transition")
BD_ISR_BAT(therm_rmv, "bd71815-therm-rmv", false)
BD_ISR_BAT(therm_det, "bd71815-therm-det", true)
BD_ISR_BAT(bat_dead, "bd71815-bat-dead", false)
BD_ISR_BAT(bat_short_res, "bd71815-bat-short-res", true)
BD_ISR_BAT(bat_short, "bd71815-bat-short-det", false)
BD_ISR_BAT(bat_low_res, "bd71815-bat-low-res", true)
BD_ISR_BAT(bat_low, "bd71815-bat-low-det", true)
BD_ISR_BAT(bat_ov_res, "bd71815-bat-over-res", true)
/* What should we do here? */
BD_ISR_BAT(bat_ov, "bd71815-bat-over-det", false)
BD_ISR_BAT(bat_mon_res, "bd71815-bat-mon-res", true)
BD_ISR_BAT(bat_mon, "bd71815-bat-mon-det", true)
BD_ISR_BAT(bat_cc_mon, "bd71815-bat-cc-mon2", false)
BD_ISR_BAT(bat_oc1_res, "bd71815-bat-oc1-res", true)
BD_ISR_BAT(bat_oc1, "bd71815-bat-oc1-det", false)
BD_ISR_BAT(bat_oc2_res, "bd71815-bat-oc2-res", true)
BD_ISR_BAT(bat_oc2, "bd71815-bat-oc2-det", false)
BD_ISR_BAT(bat_oc3_res, "bd71815-bat-oc3-res", true)
BD_ISR_BAT(bat_oc3, "bd71815-bat-oc3-det", false)
BD_ISR_BAT(temp_bat_low_res, "bd71815-temp-bat-low-res", true)
BD_ISR_BAT(temp_bat_low, "bd71815-temp-bat-low-det", true)
BD_ISR_BAT(temp_bat_hi_res, "bd71815-temp-bat-hi-res", true)
BD_ISR_BAT(temp_bat_hi, "bd71815-temp-bat-hi-det", true)
static irqreturn_t bd7182x_dcin_removed(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
power_supply_changed(pwr->ac);
dev_dbg(pwr->dev, "DCIN removed\n");
return IRQ_HANDLED;
}
static irqreturn_t bd718x7_chg_done(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
power_supply_changed(pwr->bat);
return IRQ_HANDLED;
}
static irqreturn_t bd7182x_dcin_detected(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
dev_dbg(pwr->dev, "DCIN inserted\n");
power_supply_changed(pwr->ac);
return IRQ_HANDLED;
}
static irqreturn_t bd71828_vbat_low_res(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
dev_dbg(pwr->dev, "VBAT LOW Resumed\n");
return IRQ_HANDLED;
}
static irqreturn_t bd71828_vbat_low_det(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
dev_dbg(pwr->dev, "VBAT LOW Detected\n");
return IRQ_HANDLED;
}
static irqreturn_t bd71828_temp_bat_hi_det(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
dev_warn(pwr->dev, "Overtemp Detected\n");
power_supply_changed(pwr->bat);
return IRQ_HANDLED;
}
static irqreturn_t bd71828_temp_bat_hi_res(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
dev_dbg(pwr->dev, "Overtemp Resumed\n");
power_supply_changed(pwr->bat);
return IRQ_HANDLED;
}
static irqreturn_t bd71828_temp_bat_low_det(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
dev_dbg(pwr->dev, "Lowtemp Detected\n");
power_supply_changed(pwr->bat);
return IRQ_HANDLED;
}
static irqreturn_t bd71828_temp_bat_low_res(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
dev_dbg(pwr->dev, "Lowtemp Resumed\n");
power_supply_changed(pwr->bat);
return IRQ_HANDLED;
}
static irqreturn_t bd71828_temp_vf_det(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
dev_dbg(pwr->dev, "VF Detected\n");
power_supply_changed(pwr->bat);
return IRQ_HANDLED;
}
static irqreturn_t bd71828_temp_vf_res(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
dev_dbg(pwr->dev, "VF Resumed\n");
power_supply_changed(pwr->bat);
return IRQ_HANDLED;
}
static irqreturn_t bd71828_temp_vf125_det(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
dev_dbg(pwr->dev, "VF125 Detected\n");
power_supply_changed(pwr->bat);
return IRQ_HANDLED;
}
static irqreturn_t bd71828_temp_vf125_res(int irq, void *data)
{
struct bd71828_power *pwr = (struct bd71828_power *)data;
dev_dbg(pwr->dev, "VF125 Resumed\n");
power_supply_changed(pwr->bat);
return IRQ_HANDLED;
}
struct bd7182x_irq_res {
const char *name;
irq_handler_t handler;
};
#define BDIRQ(na, hn) { .name = (na), .handler = (hn) }
static int bd7182x_get_irqs(struct platform_device *pdev,
struct bd71828_power *pwr)
{
int i, irq, ret;
static const struct bd7182x_irq_res bd71815_irqs[] = {
BDIRQ("bd71815-dcin-rmv", BD_ISR_NAME(dcin_removed)),
BDIRQ("bd71815-dcin-clps-out", BD_ISR_NAME(clps_out)),
BDIRQ("bd71815-dcin-clps-in", BD_ISR_NAME(clps_in)),
BDIRQ("bd71815-dcin-ovp-res", BD_ISR_NAME(dcin_ovp_res)),
BDIRQ("bd71815-dcin-ovp-det", BD_ISR_NAME(dcin_ovp_det)),
BDIRQ("bd71815-dcin-mon-res", BD_ISR_NAME(dcin_mon_res)),
BDIRQ("bd71815-dcin-mon-det", BD_ISR_NAME(dcin_mon_det)),
BDIRQ("bd71815-vsys-uv-res", BD_ISR_NAME(vsys_uv_res)),
BDIRQ("bd71815-vsys-uv-det", BD_ISR_NAME(vsys_uv_det)),
BDIRQ("bd71815-vsys-low-res", BD_ISR_NAME(vsys_low_res)),
BDIRQ("bd71815-vsys-low-det", BD_ISR_NAME(vsys_low_det)),
BDIRQ("bd71815-vsys-mon-res", BD_ISR_NAME(vsys_mon_res)),
BDIRQ("bd71815-vsys-mon-det", BD_ISR_NAME(vsys_mon_det)),
BDIRQ("bd71815-chg-wdg-temp", BD_ISR_NAME(chg_wdg_temp)),
BDIRQ("bd71815-chg-wdg", BD_ISR_NAME(chg_wdg)),
BDIRQ("bd71815-rechg-det", BD_ISR_NAME(rechg_det)),
BDIRQ("bd71815-rechg-res", BD_ISR_NAME(rechg_res)),
BDIRQ("bd71815-ranged-temp-transit", BD_ISR_NAME(temp_transit)),
BDIRQ("bd71815-chg-state-change", BD_ISR_NAME(chg_state_changed)),
BDIRQ("bd71815-bat-temp-normal", bd71828_temp_bat_hi_res),
BDIRQ("bd71815-bat-temp-erange", bd71828_temp_bat_hi_det),
BDIRQ("bd71815-bat-rmv", BD_ISR_NAME(bat_removed)),
BDIRQ("bd71815-bat-det", BD_ISR_NAME(bat_det)),
/* Add ISRs for these */
BDIRQ("bd71815-therm-rmv", BD_ISR_NAME(therm_rmv)),
BDIRQ("bd71815-therm-det", BD_ISR_NAME(therm_det)),
BDIRQ("bd71815-bat-dead", BD_ISR_NAME(bat_dead)),
BDIRQ("bd71815-bat-short-res", BD_ISR_NAME(bat_short_res)),
BDIRQ("bd71815-bat-short-det", BD_ISR_NAME(bat_short)),
BDIRQ("bd71815-bat-low-res", BD_ISR_NAME(bat_low_res)),
BDIRQ("bd71815-bat-low-det", BD_ISR_NAME(bat_low)),
BDIRQ("bd71815-bat-over-res", BD_ISR_NAME(bat_ov_res)),
BDIRQ("bd71815-bat-over-det", BD_ISR_NAME(bat_ov)),
BDIRQ("bd71815-bat-mon-res", BD_ISR_NAME(bat_mon_res)),
BDIRQ("bd71815-bat-mon-det", BD_ISR_NAME(bat_mon)),
/* cc-mon 1 & 3 ? */
BDIRQ("bd71815-bat-cc-mon2", BD_ISR_NAME(bat_cc_mon)),
BDIRQ("bd71815-bat-oc1-res", BD_ISR_NAME(bat_oc1_res)),
BDIRQ("bd71815-bat-oc1-det", BD_ISR_NAME(bat_oc1)),
BDIRQ("bd71815-bat-oc2-res", BD_ISR_NAME(bat_oc2_res)),
BDIRQ("bd71815-bat-oc2-det", BD_ISR_NAME(bat_oc2)),
BDIRQ("bd71815-bat-oc3-res", BD_ISR_NAME(bat_oc3_res)),
BDIRQ("bd71815-bat-oc3-det", BD_ISR_NAME(bat_oc3)),
BDIRQ("bd71815-temp-bat-low-res", BD_ISR_NAME(temp_bat_low_res)),
BDIRQ("bd71815-temp-bat-low-det", BD_ISR_NAME(temp_bat_low)),
BDIRQ("bd71815-temp-bat-hi-res", BD_ISR_NAME(temp_bat_hi_res)),
BDIRQ("bd71815-temp-bat-hi-det", BD_ISR_NAME(temp_bat_hi)),
/*
* TODO: add rest of the IRQs and re-check the handling.
* Check the bd71815-bat-cc-mon1, bd71815-bat-cc-mon3,
* bd71815-bat-low-res, bd71815-bat-low-det,
* bd71815-bat-hi-res, bd71815-bat-hi-det.
*/
};
static const struct bd7182x_irq_res bd71828_irqs[] = {
BDIRQ("bd71828-chg-done", bd718x7_chg_done),
BDIRQ("bd71828-pwr-dcin-in", bd7182x_dcin_detected),
BDIRQ("bd71828-pwr-dcin-out", bd7182x_dcin_removed),
BDIRQ("bd71828-vbat-normal", bd71828_vbat_low_res),
BDIRQ("bd71828-vbat-low", bd71828_vbat_low_det),
BDIRQ("bd71828-btemp-hi", bd71828_temp_bat_hi_det),
BDIRQ("bd71828-btemp-cool", bd71828_temp_bat_hi_res),
BDIRQ("bd71828-btemp-lo", bd71828_temp_bat_low_det),
BDIRQ("bd71828-btemp-warm", bd71828_temp_bat_low_res),
BDIRQ("bd71828-temp-hi", bd71828_temp_vf_det),
BDIRQ("bd71828-temp-norm", bd71828_temp_vf_res),
BDIRQ("bd71828-temp-125-over", bd71828_temp_vf125_det),
BDIRQ("bd71828-temp-125-under", bd71828_temp_vf125_res),
};
int num_irqs;
const struct bd7182x_irq_res *irqs;
switch (pwr->chip_type) {
case ROHM_CHIP_TYPE_BD71828:
irqs = &bd71828_irqs[0];
num_irqs = ARRAY_SIZE(bd71828_irqs);
break;
case ROHM_CHIP_TYPE_BD71815:
irqs = &bd71815_irqs[0];
num_irqs = ARRAY_SIZE(bd71815_irqs);
break;
default:
return -EINVAL;
}
for (i = 0; i < num_irqs; i++) {
irq = platform_get_irq_byname(pdev, irqs[i].name);
ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
irqs[i].handler, 0,
irqs[i].name, pwr);
if (ret)
break;
}
return ret;
}
#define RSENS_DEFAULT_30MOHM 30000 /* 30 mOhm in uOhms*/
static int bd7182x_get_rsens(struct bd71828_power *pwr)
{
u64 tmp = RSENS_CURR;
int rsens_ohm = RSENS_DEFAULT_30MOHM;
struct fwnode_handle *node = NULL;
if (pwr->dev->parent)
node = dev_fwnode(pwr->dev->parent);
if (node) {
int ret;
u32 rs;
ret = fwnode_property_read_u32(node,
"rohm,charger-sense-resistor-micro-ohms",
&rs);
if (ret) {
if (ret == -EINVAL) {
rs = RSENS_DEFAULT_30MOHM;
} else {
dev_err(pwr->dev, "Bad RSENS dt property\n");
return ret;
}
}
if (!rs) {
dev_err(pwr->dev, "Bad RSENS value\n");
return -EINVAL;
}
rsens_ohm = (int)rs;
}
/* Reg val to uA */
do_div(tmp, rsens_ohm);
pwr->curr_factor = tmp;
pwr->rsens = rsens_ohm;
dev_dbg(pwr->dev, "Setting rsens to %u micro ohm\n", pwr->rsens);
dev_dbg(pwr->dev, "Setting curr-factor to %u\n", pwr->curr_factor);
return 0;
}
static int bd71828_power_probe(struct platform_device *pdev)
{
struct bd71828_power *pwr;
struct power_supply_config ac_cfg = {};
struct power_supply_config bat_cfg = {};
int ret;
struct regmap *regmap;
regmap = dev_get_regmap(pdev->dev.parent, NULL);
if (!regmap) {
dev_err(&pdev->dev, "No parent regmap\n");
return -EINVAL;
}
pwr = devm_kzalloc(&pdev->dev, sizeof(*pwr), GFP_KERNEL);
if (!pwr)
return -ENOMEM;
pwr->regmap = regmap;
pwr->dev = &pdev->dev;
pwr->chip_type = platform_get_device_id(pdev)->driver_data;
switch (pwr->chip_type) {
case ROHM_CHIP_TYPE_BD71828:
pwr->bat_inserted = bd71828_bat_inserted;
pwr->get_temp = bd71828_get_temp;
pwr->regs = &pwr_regs_bd71828;
break;
case ROHM_CHIP_TYPE_BD71815:
pwr->bat_inserted = bd71815_bat_inserted;
pwr->get_temp = bd71815_get_temp;
pwr->regs = &pwr_regs_bd71815;
break;
default:
dev_err(pwr->dev, "Unknown PMIC\n");
return -EINVAL;
}
ret = bd7182x_get_rsens(pwr);
if (ret)
return dev_err_probe(&pdev->dev, ret, "sense resistor missing\n");
dev_set_drvdata(&pdev->dev, pwr);
bd71828_init_hardware(pwr);
bat_cfg.drv_data = pwr;
bat_cfg.fwnode = dev_fwnode(&pdev->dev);
ac_cfg.supplied_to = bd71828_ac_supplied_to;
ac_cfg.num_supplicants = ARRAY_SIZE(bd71828_ac_supplied_to);
ac_cfg.drv_data = pwr;
pwr->ac = devm_power_supply_register(&pdev->dev, &bd71828_ac_desc,
&ac_cfg);
if (IS_ERR(pwr->ac))
return dev_err_probe(&pdev->dev, PTR_ERR(pwr->ac),
"failed to register ac\n");
pwr->bat = devm_power_supply_register(&pdev->dev, &bd71828_bat_desc,
&bat_cfg);
if (IS_ERR(pwr->bat))
return dev_err_probe(&pdev->dev, PTR_ERR(pwr->bat),
"failed to register bat\n");
ret = bd7182x_get_irqs(pdev, pwr);
if (ret)
return dev_err_probe(&pdev->dev, ret, "failed to request IRQs");
/* Configure wakeup capable */
device_set_wakeup_capable(pwr->dev, 1);
device_set_wakeup_enable(pwr->dev, 1);
return 0;
}
static const struct platform_device_id bd71828_charger_id[] = {
{ "bd71815-power", ROHM_CHIP_TYPE_BD71815 },
{ "bd71828-power", ROHM_CHIP_TYPE_BD71828 },
{ },
};
MODULE_DEVICE_TABLE(platform, bd71828_charger_id);
static struct platform_driver bd71828_power_driver = {
.driver = {
.name = "bd718xx-power",
},
.probe = bd71828_power_probe,
.id_table = bd71828_charger_id,
};
module_platform_driver(bd71828_power_driver);
MODULE_AUTHOR("Cong Pham <cpham2403@gmail.com>");
MODULE_DESCRIPTION("ROHM BD718(15/28/78) PMIC Battery Charger driver");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink