/* * Battery power supply driver for X-Powers AXP20X and AXP22X PMICs * * Copyright 2016 Free Electrons NextThing Co. * Quentin Schulz * * This driver is based on a previous upstreaming attempt by: * Bruno PrĂ©mont * * This file is subject to the terms and conditions of the GNU General * Public License. See the file "COPYING" in the main directory of this * archive for more details. * * 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. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define AXP20X_PWR_STATUS_BAT_CHARGING BIT(2) #define AXP717_PWR_STATUS_MASK GENMASK(6, 5) #define AXP717_PWR_STATUS_BAT_STANDBY 0 #define AXP717_PWR_STATUS_BAT_CHRG 1 #define AXP717_PWR_STATUS_BAT_DISCHRG 2 #define AXP20X_PWR_OP_BATT_PRESENT BIT(5) #define AXP20X_PWR_OP_BATT_ACTIVATED BIT(3) #define AXP717_PWR_OP_BATT_PRESENT BIT(3) #define AXP717_BATT_PMU_FAULT_MASK GENMASK(2, 0) #define AXP717_BATT_UVLO_2_5V BIT(2) #define AXP717_BATT_OVER_TEMP BIT(1) #define AXP717_BATT_UNDER_TEMP BIT(0) #define AXP209_FG_PERCENT GENMASK(6, 0) #define AXP22X_FG_VALID BIT(7) #define AXP20X_CHRG_CTRL1_ENABLE BIT(7) #define AXP20X_CHRG_CTRL1_TGT_VOLT GENMASK(6, 5) #define AXP20X_CHRG_CTRL1_TGT_4_1V (0 << 5) #define AXP20X_CHRG_CTRL1_TGT_4_15V (1 << 5) #define AXP20X_CHRG_CTRL1_TGT_4_2V (2 << 5) #define AXP20X_CHRG_CTRL1_TGT_4_36V (3 << 5) #define AXP22X_CHRG_CTRL1_TGT_4_22V (1 << 5) #define AXP22X_CHRG_CTRL1_TGT_4_24V (3 << 5) #define AXP717_CHRG_ENABLE BIT(1) #define AXP717_CHRG_CV_VOLT_MASK GENMASK(2, 0) #define AXP717_CHRG_CV_4_0V 0 #define AXP717_CHRG_CV_4_1V 1 #define AXP717_CHRG_CV_4_2V 2 #define AXP717_CHRG_CV_4_35V 3 #define AXP717_CHRG_CV_4_4V 4 /* Values 5 and 6 reserved. */ #define AXP717_CHRG_CV_5_0V 7 #define AXP813_CHRG_CTRL1_TGT_4_35V (3 << 5) #define AXP20X_CHRG_CTRL1_TGT_CURR GENMASK(3, 0) #define AXP717_ICC_CHARGER_LIM_MASK GENMASK(5, 0) #define AXP717_ITERM_CHG_LIM_MASK GENMASK(3, 0) #define AXP717_ITERM_CC_STEP 64000 #define AXP20X_V_OFF_MASK GENMASK(2, 0) #define AXP717_V_OFF_MASK GENMASK(6, 4) #define AXP717_BAT_VMIN_MIN_UV 2600000 #define AXP717_BAT_VMIN_MAX_UV 3300000 #define AXP717_BAT_VMIN_STEP 100000 #define AXP717_BAT_CV_MIN_UV 4000000 #define AXP717_BAT_CV_MAX_UV 5000000 #define AXP717_BAT_CC_MIN_UA 0 #define AXP717_BAT_CC_MAX_UA 3008000 struct axp20x_batt_ps; struct axp_data { int ccc_scale; int ccc_offset; unsigned int ccc_reg; unsigned int ccc_mask; bool has_fg_valid; const struct power_supply_desc *bat_ps_desc; int (*get_max_voltage)(struct axp20x_batt_ps *batt, int *val); int (*set_max_voltage)(struct axp20x_batt_ps *batt, int val); int (*cfg_iio_chan)(struct platform_device *pdev, struct axp20x_batt_ps *axp_batt); void (*set_bat_info)(struct platform_device *pdev, struct axp20x_batt_ps *axp_batt, struct power_supply_battery_info *info); }; struct axp20x_batt_ps { struct regmap *regmap; struct power_supply *batt; struct device *dev; struct iio_channel *batt_chrg_i; struct iio_channel *batt_dischrg_i; struct iio_channel *batt_v; /* Maximum constant charge current */ unsigned int max_ccc; const struct axp_data *data; }; static int axp20x_battery_get_max_voltage(struct axp20x_batt_ps *axp20x_batt, int *val) { int ret, reg; ret = regmap_read(axp20x_batt->regmap, AXP20X_CHRG_CTRL1, ®); if (ret) return ret; switch (reg & AXP20X_CHRG_CTRL1_TGT_VOLT) { case AXP20X_CHRG_CTRL1_TGT_4_1V: *val = 4100000; break; case AXP20X_CHRG_CTRL1_TGT_4_15V: *val = 4150000; break; case AXP20X_CHRG_CTRL1_TGT_4_2V: *val = 4200000; break; case AXP20X_CHRG_CTRL1_TGT_4_36V: *val = 4360000; break; default: return -EINVAL; } return 0; } static int axp22x_battery_get_max_voltage(struct axp20x_batt_ps *axp20x_batt, int *val) { int ret, reg; ret = regmap_read(axp20x_batt->regmap, AXP20X_CHRG_CTRL1, ®); if (ret) return ret; switch (reg & AXP20X_CHRG_CTRL1_TGT_VOLT) { case AXP20X_CHRG_CTRL1_TGT_4_1V: *val = 4100000; break; case AXP20X_CHRG_CTRL1_TGT_4_2V: *val = 4200000; break; case AXP22X_CHRG_CTRL1_TGT_4_22V: *val = 4220000; break; case AXP22X_CHRG_CTRL1_TGT_4_24V: *val = 4240000; break; default: return -EINVAL; } return 0; } static int axp717_battery_get_max_voltage(struct axp20x_batt_ps *axp20x_batt, int *val) { int ret, reg; ret = regmap_read(axp20x_batt->regmap, AXP717_CV_CHG_SET, ®); if (ret) return ret; switch (reg & AXP717_CHRG_CV_VOLT_MASK) { case AXP717_CHRG_CV_4_0V: *val = 4000000; return 0; case AXP717_CHRG_CV_4_1V: *val = 4100000; return 0; case AXP717_CHRG_CV_4_2V: *val = 4200000; return 0; case AXP717_CHRG_CV_4_35V: *val = 4350000; return 0; case AXP717_CHRG_CV_4_4V: *val = 4400000; return 0; case AXP717_CHRG_CV_5_0V: *val = 5000000; return 0; default: return -EINVAL; } } static int axp813_battery_get_max_voltage(struct axp20x_batt_ps *axp20x_batt, int *val) { int ret, reg; ret = regmap_read(axp20x_batt->regmap, AXP20X_CHRG_CTRL1, ®); if (ret) return ret; switch (reg & AXP20X_CHRG_CTRL1_TGT_VOLT) { case AXP20X_CHRG_CTRL1_TGT_4_1V: *val = 4100000; break; case AXP20X_CHRG_CTRL1_TGT_4_15V: *val = 4150000; break; case AXP20X_CHRG_CTRL1_TGT_4_2V: *val = 4200000; break; case AXP813_CHRG_CTRL1_TGT_4_35V: *val = 4350000; break; default: return -EINVAL; } return 0; } static int axp20x_get_constant_charge_current(struct axp20x_batt_ps *axp, int *val) { int ret; ret = regmap_read(axp->regmap, AXP20X_CHRG_CTRL1, val); if (ret) return ret; *val &= AXP20X_CHRG_CTRL1_TGT_CURR; *val = *val * axp->data->ccc_scale + axp->data->ccc_offset; return 0; } static int axp717_get_constant_charge_current(struct axp20x_batt_ps *axp, int *val) { int ret; ret = regmap_read(axp->regmap, AXP717_ICC_CHG_SET, val); if (ret) return ret; *val = FIELD_GET(AXP717_ICC_CHARGER_LIM_MASK, *val) * axp->data->ccc_scale; return 0; } static int axp20x_battery_get_prop(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct axp20x_batt_ps *axp20x_batt = power_supply_get_drvdata(psy); int ret = 0, reg, val1; switch (psp) { case POWER_SUPPLY_PROP_PRESENT: case POWER_SUPPLY_PROP_ONLINE: ret = regmap_read(axp20x_batt->regmap, AXP20X_PWR_OP_MODE, ®); if (ret) return ret; val->intval = !!(reg & AXP20X_PWR_OP_BATT_PRESENT); break; case POWER_SUPPLY_PROP_STATUS: ret = regmap_read(axp20x_batt->regmap, AXP20X_PWR_INPUT_STATUS, ®); if (ret) return ret; if (reg & AXP20X_PWR_STATUS_BAT_CHARGING) { val->intval = POWER_SUPPLY_STATUS_CHARGING; return 0; } ret = iio_read_channel_processed(axp20x_batt->batt_dischrg_i, &val1); if (ret) return ret; if (val1) { val->intval = POWER_SUPPLY_STATUS_DISCHARGING; return 0; } ret = regmap_read(axp20x_batt->regmap, AXP20X_FG_RES, &val1); if (ret) return ret; /* * Fuel Gauge data takes 7 bits but the stored value seems to be * directly the raw percentage without any scaling to 7 bits. */ if ((val1 & AXP209_FG_PERCENT) == 100) val->intval = POWER_SUPPLY_STATUS_FULL; else val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; break; case POWER_SUPPLY_PROP_HEALTH: ret = regmap_read(axp20x_batt->regmap, AXP20X_PWR_OP_MODE, &val1); if (ret) return ret; if (val1 & AXP20X_PWR_OP_BATT_ACTIVATED) { val->intval = POWER_SUPPLY_HEALTH_DEAD; return 0; } val->intval = POWER_SUPPLY_HEALTH_GOOD; break; case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: ret = axp20x_get_constant_charge_current(axp20x_batt, &val->intval); if (ret) return ret; break; case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: val->intval = axp20x_batt->max_ccc; break; case POWER_SUPPLY_PROP_CURRENT_NOW: ret = regmap_read(axp20x_batt->regmap, AXP20X_PWR_INPUT_STATUS, ®); if (ret) return ret; /* IIO framework gives mA but Power Supply framework gives uA */ if (reg & AXP20X_PWR_STATUS_BAT_CHARGING) { ret = iio_read_channel_processed_scale(axp20x_batt->batt_chrg_i, &val->intval, 1000); } else { ret = iio_read_channel_processed_scale(axp20x_batt->batt_dischrg_i, &val1, 1000); val->intval = -val1; } if (ret) return ret; break; case POWER_SUPPLY_PROP_CAPACITY: /* When no battery is present, return capacity is 100% */ ret = regmap_read(axp20x_batt->regmap, AXP20X_PWR_OP_MODE, ®); if (ret) return ret; if (!(reg & AXP20X_PWR_OP_BATT_PRESENT)) { val->intval = 100; return 0; } ret = regmap_read(axp20x_batt->regmap, AXP20X_FG_RES, ®); if (ret) return ret; if (axp20x_batt->data->has_fg_valid && !(reg & AXP22X_FG_VALID)) return -EINVAL; /* * Fuel Gauge data takes 7 bits but the stored value seems to be * directly the raw percentage without any scaling to 7 bits. */ val->intval = reg & AXP209_FG_PERCENT; break; case POWER_SUPPLY_PROP_VOLTAGE_MAX: return axp20x_batt->data->get_max_voltage(axp20x_batt, &val->intval); case POWER_SUPPLY_PROP_VOLTAGE_MIN: ret = regmap_read(axp20x_batt->regmap, AXP20X_V_OFF, ®); if (ret) return ret; val->intval = 2600000 + 100000 * (reg & AXP20X_V_OFF_MASK); break; case POWER_SUPPLY_PROP_VOLTAGE_NOW: /* IIO framework gives mV but Power Supply framework gives uV */ ret = iio_read_channel_processed_scale(axp20x_batt->batt_v, &val->intval, 1000); if (ret) return ret; break; default: return -EINVAL; } return 0; } static int axp717_battery_get_prop(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct axp20x_batt_ps *axp20x_batt = power_supply_get_drvdata(psy); int ret = 0, reg; switch (psp) { case POWER_SUPPLY_PROP_PRESENT: case POWER_SUPPLY_PROP_ONLINE: ret = regmap_read(axp20x_batt->regmap, AXP717_ON_INDICATE, ®); if (ret) return ret; val->intval = FIELD_GET(AXP717_PWR_OP_BATT_PRESENT, reg); return 0; case POWER_SUPPLY_PROP_STATUS: ret = regmap_read(axp20x_batt->regmap, AXP717_PMU_STATUS_2, ®); if (ret) return ret; switch (FIELD_GET(AXP717_PWR_STATUS_MASK, reg)) { case AXP717_PWR_STATUS_BAT_STANDBY: val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; return 0; case AXP717_PWR_STATUS_BAT_CHRG: val->intval = POWER_SUPPLY_STATUS_CHARGING; return 0; case AXP717_PWR_STATUS_BAT_DISCHRG: val->intval = POWER_SUPPLY_STATUS_DISCHARGING; return 0; default: val->intval = POWER_SUPPLY_STATUS_UNKNOWN; return 0; } /* * If a fault is detected it must also be cleared; if the * condition persists it should reappear (This is an * assumption, it's actually not documented). A restart was * not sufficient to clear the bit in testing despite the * register listed as POR. */ case POWER_SUPPLY_PROP_HEALTH: ret = regmap_read(axp20x_batt->regmap, AXP717_PMU_FAULT, ®); if (ret) return ret; switch (reg & AXP717_BATT_PMU_FAULT_MASK) { case AXP717_BATT_UVLO_2_5V: val->intval = POWER_SUPPLY_HEALTH_DEAD; regmap_update_bits(axp20x_batt->regmap, AXP717_PMU_FAULT, AXP717_BATT_UVLO_2_5V, AXP717_BATT_UVLO_2_5V); return 0; case AXP717_BATT_OVER_TEMP: val->intval = POWER_SUPPLY_HEALTH_HOT; regmap_update_bits(axp20x_batt->regmap, AXP717_PMU_FAULT, AXP717_BATT_OVER_TEMP, AXP717_BATT_OVER_TEMP); return 0; case AXP717_BATT_UNDER_TEMP: val->intval = POWER_SUPPLY_HEALTH_COLD; regmap_update_bits(axp20x_batt->regmap, AXP717_PMU_FAULT, AXP717_BATT_UNDER_TEMP, AXP717_BATT_UNDER_TEMP); return 0; default: val->intval = POWER_SUPPLY_HEALTH_GOOD; return 0; } case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: ret = axp717_get_constant_charge_current(axp20x_batt, &val->intval); if (ret) return ret; return 0; case POWER_SUPPLY_PROP_CURRENT_NOW: /* * The offset of this value is currently unknown and is * not documented in the datasheet. Based on * observation it's assumed to be somewhere around * 450ma. I will leave the value raw for now. Note that * IIO framework gives mA but Power Supply framework * gives uA. */ ret = iio_read_channel_processed_scale(axp20x_batt->batt_chrg_i, &val->intval, 1000); if (ret) return ret; return 0; case POWER_SUPPLY_PROP_CAPACITY: ret = regmap_read(axp20x_batt->regmap, AXP717_ON_INDICATE, ®); if (ret) return ret; if (!FIELD_GET(AXP717_PWR_OP_BATT_PRESENT, reg)) return -ENODEV; ret = regmap_read(axp20x_batt->regmap, AXP717_BATT_PERCENT_DATA, ®); if (ret) return ret; /* * Fuel Gauge data takes 7 bits but the stored value seems to be * directly the raw percentage without any scaling to 7 bits. */ val->intval = reg & AXP209_FG_PERCENT; return 0; case POWER_SUPPLY_PROP_VOLTAGE_MAX: return axp20x_batt->data->get_max_voltage(axp20x_batt, &val->intval); case POWER_SUPPLY_PROP_VOLTAGE_MIN: ret = regmap_read(axp20x_batt->regmap, AXP717_VSYS_V_POWEROFF, ®); if (ret) return ret; val->intval = AXP717_BAT_VMIN_MIN_UV + AXP717_BAT_VMIN_STEP * (reg & AXP717_V_OFF_MASK); return 0; case POWER_SUPPLY_PROP_VOLTAGE_NOW: /* IIO framework gives mV but Power Supply framework gives uV */ ret = iio_read_channel_processed_scale(axp20x_batt->batt_v, &val->intval, 1000); if (ret) return ret; return 0; case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: ret = regmap_read(axp20x_batt->regmap, AXP717_ITERM_CHG_SET, ®); if (ret) return ret; val->intval = (reg & AXP717_ITERM_CHG_LIM_MASK) * AXP717_ITERM_CC_STEP; return 0; default: return -EINVAL; } } static int axp22x_battery_set_max_voltage(struct axp20x_batt_ps *axp20x_batt, int val) { switch (val) { case 4100000: val = AXP20X_CHRG_CTRL1_TGT_4_1V; break; case 4200000: val = AXP20X_CHRG_CTRL1_TGT_4_2V; break; default: /* * AXP20x max voltage can be set to 4.36V and AXP22X max voltage * can be set to 4.22V and 4.24V, but these voltages are too * high for Lithium based batteries (AXP PMICs are supposed to * be used with these kinds of battery). */ return -EINVAL; } return regmap_update_bits(axp20x_batt->regmap, AXP20X_CHRG_CTRL1, AXP20X_CHRG_CTRL1_TGT_VOLT, val); } static int axp20x_battery_set_max_voltage(struct axp20x_batt_ps *axp20x_batt, int val) { switch (val) { case 4100000: val = AXP20X_CHRG_CTRL1_TGT_4_1V; break; case 4150000: val = AXP20X_CHRG_CTRL1_TGT_4_15V; break; case 4200000: val = AXP20X_CHRG_CTRL1_TGT_4_2V; break; default: /* * AXP20x max voltage can be set to 4.36V and AXP22X max voltage * can be set to 4.22V and 4.24V, but these voltages are too * high for Lithium based batteries (AXP PMICs are supposed to * be used with these kinds of battery). */ return -EINVAL; } return regmap_update_bits(axp20x_batt->regmap, AXP20X_CHRG_CTRL1, AXP20X_CHRG_CTRL1_TGT_VOLT, val); } static int axp717_battery_set_max_voltage(struct axp20x_batt_ps *axp20x_batt, int val) { switch (val) { case 4000000: val = AXP717_CHRG_CV_4_0V; break; case 4100000: val = AXP717_CHRG_CV_4_1V; break; case 4200000: val = AXP717_CHRG_CV_4_2V; break; default: /* * AXP717 can go up to 4.35, 4.4, and 5.0 volts which * seem too high for lithium batteries, so do not allow. */ return -EINVAL; } return regmap_update_bits(axp20x_batt->regmap, AXP717_CV_CHG_SET, AXP717_CHRG_CV_VOLT_MASK, val); } static int axp20x_set_constant_charge_current(struct axp20x_batt_ps *axp_batt, int charge_current) { if (charge_current > axp_batt->max_ccc) return -EINVAL; charge_current = (charge_current - axp_batt->data->ccc_offset) / axp_batt->data->ccc_scale; if (charge_current > AXP20X_CHRG_CTRL1_TGT_CURR || charge_current < 0) return -EINVAL; return regmap_update_bits(axp_batt->regmap, AXP20X_CHRG_CTRL1, AXP20X_CHRG_CTRL1_TGT_CURR, charge_current); } static int axp717_set_constant_charge_current(struct axp20x_batt_ps *axp, int charge_current) { int val; if (charge_current > axp->max_ccc) return -EINVAL; if (charge_current > AXP717_BAT_CC_MAX_UA || charge_current < 0) return -EINVAL; val = (charge_current - axp->data->ccc_offset) / axp->data->ccc_scale; return regmap_update_bits(axp->regmap, AXP717_ICC_CHG_SET, AXP717_ICC_CHARGER_LIM_MASK, val); } static int axp20x_set_max_constant_charge_current(struct axp20x_batt_ps *axp, int charge_current) { bool lower_max = false; charge_current = (charge_current - axp->data->ccc_offset) / axp->data->ccc_scale; if (charge_current > AXP20X_CHRG_CTRL1_TGT_CURR || charge_current < 0) return -EINVAL; charge_current = charge_current * axp->data->ccc_scale + axp->data->ccc_offset; if (charge_current > axp->max_ccc) dev_warn(axp->dev, "Setting max constant charge current higher than previously defined. Note that increasing the constant charge current may damage your battery.\n"); else lower_max = true; axp->max_ccc = charge_current; if (lower_max) { int current_cc; axp20x_get_constant_charge_current(axp, ¤t_cc); if (current_cc > charge_current) axp20x_set_constant_charge_current(axp, charge_current); } return 0; } static int axp20x_set_voltage_min_design(struct axp20x_batt_ps *axp_batt, int min_voltage) { int val1 = (min_voltage - 2600000) / 100000; if (val1 < 0 || val1 > AXP20X_V_OFF_MASK) return -EINVAL; return regmap_update_bits(axp_batt->regmap, AXP20X_V_OFF, AXP20X_V_OFF_MASK, val1); } static int axp717_set_voltage_min_design(struct axp20x_batt_ps *axp_batt, int min_voltage) { int val1 = (min_voltage - AXP717_BAT_VMIN_MIN_UV) / AXP717_BAT_VMIN_STEP; if (val1 < 0 || val1 > AXP717_V_OFF_MASK) return -EINVAL; return regmap_update_bits(axp_batt->regmap, AXP717_VSYS_V_POWEROFF, AXP717_V_OFF_MASK, val1); } static int axp20x_battery_set_prop(struct power_supply *psy, enum power_supply_property psp, const union power_supply_propval *val) { struct axp20x_batt_ps *axp20x_batt = power_supply_get_drvdata(psy); switch (psp) { case POWER_SUPPLY_PROP_VOLTAGE_MIN: return axp20x_set_voltage_min_design(axp20x_batt, val->intval); case POWER_SUPPLY_PROP_VOLTAGE_MAX: return axp20x_batt->data->set_max_voltage(axp20x_batt, val->intval); case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: return axp20x_set_constant_charge_current(axp20x_batt, val->intval); case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: return axp20x_set_max_constant_charge_current(axp20x_batt, val->intval); case POWER_SUPPLY_PROP_STATUS: switch (val->intval) { case POWER_SUPPLY_STATUS_CHARGING: return regmap_update_bits(axp20x_batt->regmap, AXP20X_CHRG_CTRL1, AXP20X_CHRG_CTRL1_ENABLE, AXP20X_CHRG_CTRL1_ENABLE); case POWER_SUPPLY_STATUS_DISCHARGING: case POWER_SUPPLY_STATUS_NOT_CHARGING: return regmap_update_bits(axp20x_batt->regmap, AXP20X_CHRG_CTRL1, AXP20X_CHRG_CTRL1_ENABLE, 0); } fallthrough; default: return -EINVAL; } } static int axp717_battery_set_prop(struct power_supply *psy, enum power_supply_property psp, const union power_supply_propval *val) { struct axp20x_batt_ps *axp20x_batt = power_supply_get_drvdata(psy); switch (psp) { case POWER_SUPPLY_PROP_VOLTAGE_MIN: return axp717_set_voltage_min_design(axp20x_batt, val->intval); case POWER_SUPPLY_PROP_VOLTAGE_MAX: return axp20x_batt->data->set_max_voltage(axp20x_batt, val->intval); case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: return axp717_set_constant_charge_current(axp20x_batt, val->intval); case POWER_SUPPLY_PROP_STATUS: switch (val->intval) { case POWER_SUPPLY_STATUS_CHARGING: return regmap_update_bits(axp20x_batt->regmap, AXP717_MODULE_EN_CONTROL_2, AXP717_CHRG_ENABLE, AXP717_CHRG_ENABLE); case POWER_SUPPLY_STATUS_DISCHARGING: case POWER_SUPPLY_STATUS_NOT_CHARGING: return regmap_update_bits(axp20x_batt->regmap, AXP717_MODULE_EN_CONTROL_2, AXP717_CHRG_ENABLE, 0); } return -EINVAL; default: return -EINVAL; } } static enum power_supply_property axp20x_battery_props[] = { POWER_SUPPLY_PROP_PRESENT, POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_CURRENT_NOW, POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_PROP_VOLTAGE_MAX, POWER_SUPPLY_PROP_VOLTAGE_MIN, POWER_SUPPLY_PROP_CAPACITY, }; static enum power_supply_property axp717_battery_props[] = { POWER_SUPPLY_PROP_PRESENT, POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_CURRENT_NOW, POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_PROP_VOLTAGE_MAX, POWER_SUPPLY_PROP_VOLTAGE_MIN, POWER_SUPPLY_PROP_CAPACITY, POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, }; static int axp20x_battery_prop_writeable(struct power_supply *psy, enum power_supply_property psp) { return psp == POWER_SUPPLY_PROP_STATUS || psp == POWER_SUPPLY_PROP_VOLTAGE_MIN || psp == POWER_SUPPLY_PROP_VOLTAGE_MAX || psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT || psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX; } static int axp717_battery_prop_writeable(struct power_supply *psy, enum power_supply_property psp) { return psp == POWER_SUPPLY_PROP_STATUS || psp == POWER_SUPPLY_PROP_VOLTAGE_MIN || psp == POWER_SUPPLY_PROP_VOLTAGE_MAX || psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX; } static const struct power_supply_desc axp209_batt_ps_desc = { .name = "axp20x-battery", .type = POWER_SUPPLY_TYPE_BATTERY, .properties = axp20x_battery_props, .num_properties = ARRAY_SIZE(axp20x_battery_props), .property_is_writeable = axp20x_battery_prop_writeable, .get_property = axp20x_battery_get_prop, .set_property = axp20x_battery_set_prop, }; static const struct power_supply_desc axp717_batt_ps_desc = { .name = "axp20x-battery", .type = POWER_SUPPLY_TYPE_BATTERY, .properties = axp717_battery_props, .num_properties = ARRAY_SIZE(axp717_battery_props), .property_is_writeable = axp717_battery_prop_writeable, .get_property = axp717_battery_get_prop, .set_property = axp717_battery_set_prop, }; static int axp209_bat_cfg_iio_channels(struct platform_device *pdev, struct axp20x_batt_ps *axp_batt) { axp_batt->batt_v = devm_iio_channel_get(&pdev->dev, "batt_v"); if (IS_ERR(axp_batt->batt_v)) { if (PTR_ERR(axp_batt->batt_v) == -ENODEV) return -EPROBE_DEFER; return PTR_ERR(axp_batt->batt_v); } axp_batt->batt_chrg_i = devm_iio_channel_get(&pdev->dev, "batt_chrg_i"); if (IS_ERR(axp_batt->batt_chrg_i)) { if (PTR_ERR(axp_batt->batt_chrg_i) == -ENODEV) return -EPROBE_DEFER; return PTR_ERR(axp_batt->batt_chrg_i); } axp_batt->batt_dischrg_i = devm_iio_channel_get(&pdev->dev, "batt_dischrg_i"); if (IS_ERR(axp_batt->batt_dischrg_i)) { if (PTR_ERR(axp_batt->batt_dischrg_i) == -ENODEV) return -EPROBE_DEFER; return PTR_ERR(axp_batt->batt_dischrg_i); } return 0; } static int axp717_bat_cfg_iio_channels(struct platform_device *pdev, struct axp20x_batt_ps *axp_batt) { axp_batt->batt_v = devm_iio_channel_get(&pdev->dev, "batt_v"); if (IS_ERR(axp_batt->batt_v)) { if (PTR_ERR(axp_batt->batt_v) == -ENODEV) return -EPROBE_DEFER; return PTR_ERR(axp_batt->batt_v); } axp_batt->batt_chrg_i = devm_iio_channel_get(&pdev->dev, "batt_chrg_i"); if (IS_ERR(axp_batt->batt_chrg_i)) { if (PTR_ERR(axp_batt->batt_chrg_i) == -ENODEV) return -EPROBE_DEFER; return PTR_ERR(axp_batt->batt_chrg_i); } return 0; } static void axp209_set_battery_info(struct platform_device *pdev, struct axp20x_batt_ps *axp_batt, struct power_supply_battery_info *info) { int vmin = info->voltage_min_design_uv; int ccc = info->constant_charge_current_max_ua; if (vmin > 0 && axp20x_set_voltage_min_design(axp_batt, vmin)) dev_err(&pdev->dev, "couldn't set voltage_min_design\n"); /* Set max to unverified value to be able to set CCC */ axp_batt->max_ccc = ccc; if (ccc <= 0 || axp20x_set_constant_charge_current(axp_batt, ccc)) { dev_err(&pdev->dev, "couldn't set ccc from DT: fallback to min value\n"); ccc = 300000; axp_batt->max_ccc = ccc; axp20x_set_constant_charge_current(axp_batt, ccc); } } static void axp717_set_battery_info(struct platform_device *pdev, struct axp20x_batt_ps *axp_batt, struct power_supply_battery_info *info) { int vmin = info->voltage_min_design_uv; int vmax = info->voltage_max_design_uv; int ccc = info->constant_charge_current_max_ua; int val; if (vmin > 0 && axp717_set_voltage_min_design(axp_batt, vmin)) dev_err(&pdev->dev, "couldn't set voltage_min_design\n"); if (vmax > 0 && axp717_battery_set_max_voltage(axp_batt, vmax)) dev_err(&pdev->dev, "couldn't set voltage_max_design\n"); axp717_get_constant_charge_current(axp_batt, &val); axp_batt->max_ccc = ccc; if (ccc <= 0 || axp717_set_constant_charge_current(axp_batt, ccc)) { dev_err(&pdev->dev, "couldn't set ccc from DT: current ccc is %d\n", val); } } static const struct axp_data axp209_data = { .ccc_scale = 100000, .ccc_offset = 300000, .ccc_reg = AXP20X_CHRG_CTRL1, .ccc_mask = AXP20X_CHRG_CTRL1_TGT_CURR, .bat_ps_desc = &axp209_batt_ps_desc, .get_max_voltage = axp20x_battery_get_max_voltage, .set_max_voltage = axp20x_battery_set_max_voltage, .cfg_iio_chan = axp209_bat_cfg_iio_channels, .set_bat_info = axp209_set_battery_info, }; static const struct axp_data axp221_data = { .ccc_scale = 150000, .ccc_offset = 300000, .ccc_reg = AXP20X_CHRG_CTRL1, .ccc_mask = AXP20X_CHRG_CTRL1_TGT_CURR, .has_fg_valid = true, .bat_ps_desc = &axp209_batt_ps_desc, .get_max_voltage = axp22x_battery_get_max_voltage, .set_max_voltage = axp22x_battery_set_max_voltage, .cfg_iio_chan = axp209_bat_cfg_iio_channels, .set_bat_info = axp209_set_battery_info, }; static const struct axp_data axp717_data = { .ccc_scale = 64000, .ccc_offset = 0, .ccc_reg = AXP717_ICC_CHG_SET, .ccc_mask = AXP717_ICC_CHARGER_LIM_MASK, .bat_ps_desc = &axp717_batt_ps_desc, .get_max_voltage = axp717_battery_get_max_voltage, .set_max_voltage = axp717_battery_set_max_voltage, .cfg_iio_chan = axp717_bat_cfg_iio_channels, .set_bat_info = axp717_set_battery_info, }; static const struct axp_data axp813_data = { .ccc_scale = 200000, .ccc_offset = 200000, .ccc_reg = AXP20X_CHRG_CTRL1, .ccc_mask = AXP20X_CHRG_CTRL1_TGT_CURR, .has_fg_valid = true, .bat_ps_desc = &axp209_batt_ps_desc, .get_max_voltage = axp813_battery_get_max_voltage, .set_max_voltage = axp20x_battery_set_max_voltage, .cfg_iio_chan = axp209_bat_cfg_iio_channels, .set_bat_info = axp209_set_battery_info, }; static const struct of_device_id axp20x_battery_ps_id[] = { { .compatible = "x-powers,axp209-battery-power-supply", .data = (void *)&axp209_data, }, { .compatible = "x-powers,axp221-battery-power-supply", .data = (void *)&axp221_data, }, { .compatible = "x-powers,axp717-battery-power-supply", .data = (void *)&axp717_data, }, { .compatible = "x-powers,axp813-battery-power-supply", .data = (void *)&axp813_data, }, { /* sentinel */ }, }; MODULE_DEVICE_TABLE(of, axp20x_battery_ps_id); static int axp20x_power_probe(struct platform_device *pdev) { struct axp20x_batt_ps *axp20x_batt; struct power_supply_config psy_cfg = {}; struct power_supply_battery_info *info; struct device *dev = &pdev->dev; int ret; if (!of_device_is_available(pdev->dev.of_node)) return -ENODEV; axp20x_batt = devm_kzalloc(&pdev->dev, sizeof(*axp20x_batt), GFP_KERNEL); if (!axp20x_batt) return -ENOMEM; axp20x_batt->dev = &pdev->dev; axp20x_batt->regmap = dev_get_regmap(pdev->dev.parent, NULL); platform_set_drvdata(pdev, axp20x_batt); psy_cfg.drv_data = axp20x_batt; psy_cfg.of_node = pdev->dev.of_node; axp20x_batt->data = (struct axp_data *)of_device_get_match_data(dev); ret = axp20x_batt->data->cfg_iio_chan(pdev, axp20x_batt); if (ret) return ret; axp20x_batt->batt = devm_power_supply_register(&pdev->dev, axp20x_batt->data->bat_ps_desc, &psy_cfg); if (IS_ERR(axp20x_batt->batt)) { dev_err(&pdev->dev, "failed to register power supply: %ld\n", PTR_ERR(axp20x_batt->batt)); return PTR_ERR(axp20x_batt->batt); } if (!power_supply_get_battery_info(axp20x_batt->batt, &info)) { axp20x_batt->data->set_bat_info(pdev, axp20x_batt, info); power_supply_put_battery_info(axp20x_batt->batt, info); } /* * Update max CCC to a valid value if battery info is present or set it * to current register value by default. */ axp20x_get_constant_charge_current(axp20x_batt, &axp20x_batt->max_ccc); return 0; } static struct platform_driver axp20x_batt_driver = { .probe = axp20x_power_probe, .driver = { .name = "axp20x-battery-power-supply", .of_match_table = axp20x_battery_ps_id, }, }; module_platform_driver(axp20x_batt_driver); MODULE_DESCRIPTION("Battery power supply driver for AXP20X and AXP22X PMICs"); MODULE_AUTHOR("Quentin Schulz "); MODULE_LICENSE("GPL");