--- a/drivers/iio/adc/qcom-spmi-vadc.c +++ b/drivers/iio/adc/qcom-spmi-vadc.c @@ -563,7 +563,7 @@ VADC_CHAN_NO_SCALE(SPARE1_03, 1) VADC_CHAN_NO_SCALE(USB_ID_MV, 1) VADC_CHAN_VOLT(VCOIN, 1, SCALE_DEFAULT) - VADC_CHAN_NO_SCALE(VBAT_SNS, 1) + VADC_CHAN_VOLT(VBAT_SNS, 1, SCALE_DEFAULT) VADC_CHAN_VOLT(VSYS, 1, SCALE_DEFAULT) VADC_CHAN_TEMP(DIE_TEMP, 0, SCALE_PMIC_THERM) VADC_CHAN_VOLT(REF_625MV, 0, SCALE_DEFAULT) --- a/drivers/power/supply/pm8916_lbc.c +++ b/drivers/power/supply/pm8916_lbc.c @@ -13,6 +13,13 @@ #include #include #include +#include +#include +#include +#include +#include +#include +#include /* Two bytes: type + subtype */ #define PM8916_PERPH_TYPE 0x04 @@ -42,6 +49,25 @@ #define PM8916_LBC_CHGR_CHG_CTRL 0x49 #define PM8916_LBC_CHGR_CHG_EN BIT(7) #define PM8916_LBC_CHGR_PSTG_EN BIT(5) +#define PM8916_LBC_CHGR_FORCE_BATT_ON BIT(0) +#define PM8916_LBC_CHGR_EN_MASK (PM8916_LBC_CHGR_CHG_EN | PM8916_LBC_CHGR_FORCE_BATT_ON) + +#define PM8916_LBC_CHGR_CHG_FAILED 0x4a +#define PM8916_LBC_CHGR_CHG_FAILED_BIT BIT(7) + +/* USB_CHGPTH 0x08: 0x02 while the charge path is on, 0x01 after end of charge (observed, not documented) */ +#define PM8916_LBC_USB_PATH_STS 0x08 +#define PM8916_LBC_USB_PATH_ON BIT(1) + +/* Aurora B10B-3 recharge supervisor */ +#define PM8916_LBC_SUPV_PERIOD_MS 30000 +#define PM8916_LBC_SUPV_DONE_POLLS 2 +#define PM8916_LBC_SUPV_LOW_POLLS 3 +#define PM8916_LBC_SUPV_OVP_UV 4250000 +#define PM8916_LBC_TIMEOUT_DEFAULT_MIN 512 +#define PM8916_LBC_TIMEOUT_STEP_MIN 4 +#define PM8916_LBC_TIMEOUT_MAX_MIN 512 +#define PM8916_LBC_SUPV_LOG 16 #define PM8916_LBC_CHGR_MIN_CURRENT 90000 #define PM8916_LBC_CHGR_MAX_CURRENT 1440000 @@ -65,6 +91,55 @@ unsigned int charge_voltage_safe; unsigned int charge_current_max; unsigned int charge_current_safe; + + /* recharge supervisor */ + struct iio_channel *vbat_chan; + struct delayed_work supv_work; + struct mutex supv_lock; + int state; + int fault_reason; + unsigned int recharge_uv; /* production threshold from monitored-battery */ + unsigned int timeout_min; + int vbat_uv; + int done_polls; + int low_polls; + unsigned int n_terminated; + unsigned int n_recharge; + struct { + time64_t t; + int from, to, vbat; + const char *why; + } log[PM8916_LBC_SUPV_LOG]; + unsigned int log_n; + struct dentry *debugfs; +}; + +enum { + LBC_ST_INIT = 0, + LBC_ST_NO_USB, + LBC_ST_CHARGING, + LBC_ST_TERMINATED, + LBC_ST_FAULT, +}; + +static const char * const lbc_state_name[] = { + [LBC_ST_INIT] = "INIT", + [LBC_ST_NO_USB] = "NO_USB", + [LBC_ST_CHARGING] = "CHARGING", + [LBC_ST_TERMINATED] = "TERMINATED", + [LBC_ST_FAULT] = "FAULT", +}; + +enum { + LBC_FAULT_NONE = 0, + LBC_FAULT_TIMER, + LBC_FAULT_OVP, +}; + +static const char * const lbc_fault_name[] = { + [LBC_FAULT_NONE] = "none", + [LBC_FAULT_TIMER] = "safety-timer (CHG_FAILED)", + [LBC_FAULT_OVP] = "vbat-overvoltage", }; static const unsigned int pm8916_lbc_charger_cable[] = { @@ -79,7 +154,7 @@ LBC_MISC, }; -static int pm8916_lbc_charger_configure(struct pm8916_lbc_charger *chg) +static int pm8916_lbc_charger_configure(struct pm8916_lbc_charger *chg, bool set_ctrl) { int ret = 0; unsigned int tmp; @@ -107,10 +182,16 @@ if (ret) goto error; - ret = regmap_write(chg->regmap, chg->reg[LBC_CHGR] + PM8916_LBC_CHGR_CHG_CTRL, - PM8916_LBC_CHGR_CHG_EN | PM8916_LBC_CHGR_PSTG_EN); - if (ret) - goto error; + /* + * CHG_CTRL is written only at probe. Afterwards the recharge supervisor owns CHG_EN, so a + * constant_charge_current update must not re-enable charging in TERMINATED/FAULT. + */ + if (set_ctrl) { + ret = regmap_write(chg->regmap, chg->reg[LBC_CHGR] + PM8916_LBC_CHGR_CHG_CTRL, + PM8916_LBC_CHGR_CHG_EN | PM8916_LBC_CHGR_PSTG_EN); + if (ret) + goto error; + } return ret; @@ -126,6 +207,23 @@ struct pm8916_lbc_charger *chg = power_supply_get_drvdata(psy); switch (psp) { + case POWER_SUPPLY_PROP_STATUS: + switch (chg->state) { + case LBC_ST_CHARGING: + val->intval = POWER_SUPPLY_STATUS_CHARGING; + break; + case LBC_ST_TERMINATED: + val->intval = POWER_SUPPLY_STATUS_FULL; + break; + case LBC_ST_NO_USB: + val->intval = POWER_SUPPLY_STATUS_DISCHARGING; + break; + default: + val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; + break; + } + return 0; + case POWER_SUPPLY_PROP_ONLINE: val->intval = chg->online; return 0; @@ -152,7 +250,7 @@ switch (prop) { case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: chg->charge_current_max = val->intval; - return pm8916_lbc_charger_configure(chg); + return pm8916_lbc_charger_configure(chg, false); default: return -EINVAL; } @@ -170,11 +268,208 @@ } static enum power_supply_property pm8916_lbc_charger_properties[] = { + POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, }; + +/* + * Aurora B10B-3 recharge supervisor. + * The LBC ends a charge cycle in hardware (end-of-charge latch: CHG_STATUS 00, USB path 01, USB input ~0) and then + * stays off until software gives CHG_EN a 0 -> 1 edge (downstream qpnp-linear-charger did this from BMS SOC / + * VBAT_DET IRQ). Verified on Aurora (B10B-3 ram1): CHG_CTRL 0x21 -> 0xa0 releases the latch. + * Also verified: writing CHG_EN = 0 does NOT stop the charger (USB input stays ~0.36 A), so the supervisor never + * uses CHG_CTRL to "turn charging off"; TERMINATED is only the hardware latch, observed after CHARGING. + * The supervisor polls the VADC VBAT every 30 s and restarts charging when VBAT stays below the monitored-battery + * re-charge-voltage-microvolt for 3 consecutive polls. + */ +static void lbc_supv_log(struct pm8916_lbc_charger *chg, int to, const char *why) +{ + unsigned int i = chg->log_n++ % PM8916_LBC_SUPV_LOG; + + chg->log[i].t = ktime_get_seconds(); + chg->log[i].from = chg->state; + chg->log[i].to = to; + chg->log[i].vbat = chg->vbat_uv; + chg->log[i].why = why; + dev_info(chg->dev, "supervisor %s -> %s (%s), vbat %d uV\n", lbc_state_name[chg->state], + lbc_state_name[to], why, chg->vbat_uv); + chg->state = to; +} + +static int lbc_charge_enable(struct pm8916_lbc_charger *chg, bool en) +{ + /* stock-style: enabled = CHG_EN, disabled = FORCE_BATT_ON */ + return regmap_update_bits(chg->regmap, chg->reg[LBC_CHGR] + PM8916_LBC_CHGR_CHG_CTRL, + PM8916_LBC_CHGR_EN_MASK, + en ? PM8916_LBC_CHGR_CHG_EN : PM8916_LBC_CHGR_FORCE_BATT_ON); +} + +/* the verified restart: CHG_CTRL 0x21 (CHG_EN 0) -> 20 ms -> 0xa0 (CHG_EN 1); on (re)insert also clear CHG_FAILED */ +static int lbc_charge_restart(struct pm8916_lbc_charger *chg, bool clear_failed) +{ + int ret; + + if (clear_failed) { + ret = regmap_write(chg->regmap, chg->reg[LBC_CHGR] + PM8916_LBC_CHGR_CHG_FAILED, + PM8916_LBC_CHGR_CHG_FAILED_BIT); + if (ret) + return ret; + } + ret = lbc_charge_enable(chg, false); + if (ret) + return ret; + msleep(20); + return lbc_charge_enable(chg, true); +} + +static void lbc_supv_work(struct work_struct *work) +{ + struct pm8916_lbc_charger *chg = container_of(work, struct pm8916_lbc_charger, supv_work.work); + unsigned int usb_rt, sts, path, failed; + int ret, uv; + + mutex_lock(&chg->supv_lock); + + ret = regmap_read(chg->regmap, chg->reg[LBC_USB] + PM8916_INT_RT_STS, &usb_rt); + ret = ret ?: regmap_read(chg->regmap, chg->reg[LBC_CHGR] + PM8916_LBC_CHGR_CHG_STATUS, &sts); + ret = ret ?: regmap_read(chg->regmap, chg->reg[LBC_USB] + PM8916_LBC_USB_PATH_STS, &path); + ret = ret ?: regmap_read(chg->regmap, chg->reg[LBC_CHGR] + PM8916_LBC_CHGR_CHG_FAILED, &failed); + if (ret) { + dev_err(chg->dev, "supervisor: register read failed: %d\n", ret); + goto out; + } + if (!iio_read_channel_processed(chg->vbat_chan, &uv)) + chg->vbat_uv = uv; + else + chg->vbat_uv = -1; + + if (!(usb_rt & PM8916_LBC_USB_USBIN_VALID)) { + /* CHG_CTRL untouched; the next insert restarts with the verified edge */ + if (chg->state != LBC_ST_NO_USB) { + chg->fault_reason = LBC_FAULT_NONE; + lbc_supv_log(chg, LBC_ST_NO_USB, "usb removed"); + } + goto out; + } + + switch (chg->state) { + case LBC_ST_INIT: + case LBC_ST_NO_USB: + /* probe or USB insert: always start a cycle, like stock's usbin path */ + chg->done_polls = 0; + chg->low_polls = 0; + chg->fault_reason = LBC_FAULT_NONE; + if (!lbc_charge_restart(chg, true)) + lbc_supv_log(chg, LBC_ST_CHARGING, + chg->state == LBC_ST_INIT ? "probe, usb present" : "usb inserted"); + break; + + case LBC_ST_CHARGING: + /* + * Safety timer expiry: the hardware stops and sets CHG_FAILED. Latch FAULT so the supervisor never + * restarts; no register write (CHG_EN = 0 is not a verified way to stop the charger). + */ + if (failed & PM8916_LBC_CHGR_CHG_FAILED_BIT) { + chg->fault_reason = LBC_FAULT_TIMER; + lbc_supv_log(chg, LBC_ST_FAULT, "CHG_FAILED (safety timer)"); + break; + } + if (chg->vbat_uv > PM8916_LBC_SUPV_OVP_UV) { + /* defence only: VDD_MAX regulates in hardware; latch FAULT = no further restarts */ + chg->fault_reason = LBC_FAULT_OVP; + lbc_supv_log(chg, LBC_ST_FAULT, "vbat > 4.25 V"); + break; + } + /* TERMINATED = hardware end-of-charge latch only; CHG_CTRL is not changed */ + if (sts == 0 && !(path & PM8916_LBC_USB_PATH_ON)) + chg->done_polls++; + else + chg->done_polls = 0; + if (chg->done_polls >= PM8916_LBC_SUPV_DONE_POLLS) { + chg->n_terminated++; + chg->low_polls = 0; + lbc_supv_log(chg, LBC_ST_TERMINATED, "hardware end of charge"); + } + break; + + case LBC_ST_TERMINATED: + if (!chg->recharge_uv || chg->vbat_uv < 0) + break; + if ((unsigned int)chg->vbat_uv < chg->recharge_uv) + chg->low_polls++; + else + chg->low_polls = 0; + if (chg->low_polls >= PM8916_LBC_SUPV_LOW_POLLS) { + chg->done_polls = 0; + chg->low_polls = 0; + if (!lbc_charge_restart(chg, false)) { + chg->n_recharge++; + lbc_supv_log(chg, LBC_ST_CHARGING, "recharge"); + } + } + break; + + case LBC_ST_FAULT: + /* latched: left only by USB removal/insert or reboot */ + break; + } + +out: + mutex_unlock(&chg->supv_lock); + power_supply_changed(chg->charger); + queue_delayed_work(system_freezable_wq, &chg->supv_work, + msecs_to_jiffies(PM8916_LBC_SUPV_PERIOD_MS)); +} + +static int lbc_state_show(struct seq_file *s, void *unused) +{ + struct pm8916_lbc_charger *chg = s->private; + static const struct { const char *n; int blk; unsigned int off; } regs[] = { + { "CHG_STATUS", LBC_CHGR, PM8916_LBC_CHGR_CHG_STATUS }, + { "CHGR_RT", LBC_CHGR, PM8916_INT_RT_STS }, + { "CHG_CTRL", LBC_CHGR, PM8916_LBC_CHGR_CHG_CTRL }, + { "CHG_FAILED", LBC_CHGR, PM8916_LBC_CHGR_CHG_FAILED }, + { "VDD_MAX", LBC_CHGR, PM8916_LBC_CHGR_VDD_MAX }, + { "IBAT_MAX", LBC_CHGR, PM8916_LBC_CHGR_IBAT_MAX }, + { "TCHG_MAX_EN", LBC_CHGR, PM8916_LBC_CHGR_TCHG_MAX_EN }, + { "TCHG_MAX", LBC_CHGR, PM8916_LBC_CHGR_TCHG_MAX }, + { "USB_PATH", LBC_USB, PM8916_LBC_USB_PATH_STS }, + { "USB_RT", LBC_USB, PM8916_INT_RT_STS }, + { "BAT_RT", LBC_BAT_IF, PM8916_INT_RT_STS }, + }; + unsigned int i, v; + + mutex_lock(&chg->supv_lock); + seq_printf(s, "state %s fault %s vbat_uv %d\n", lbc_state_name[chg->state], + lbc_fault_name[chg->fault_reason], chg->vbat_uv); + seq_printf(s, "recharge_uv %u done_polls %d low_polls %d timeout_min %u\n", + chg->recharge_uv, chg->done_polls, chg->low_polls, chg->timeout_min); + seq_printf(s, "n_terminated %u n_recharge %u\n", chg->n_terminated, chg->n_recharge); + for (i = 0; i < ARRAY_SIZE(regs); i++) { + if (regmap_read(chg->regmap, chg->reg[regs[i].blk] + regs[i].off, &v)) + v = 0xffff; + seq_printf(s, "%s %02x\n", regs[i].n, v); + } + for (i = chg->log_n > PM8916_LBC_SUPV_LOG ? chg->log_n - PM8916_LBC_SUPV_LOG : 0; i < chg->log_n; i++) { + unsigned int j = i % PM8916_LBC_SUPV_LOG; + + seq_printf(s, "log %u t=%lld %s->%s vbat=%d %s\n", i, chg->log[j].t, + lbc_state_name[chg->log[j].from], lbc_state_name[chg->log[j].to], + chg->log[j].vbat, chg->log[j].why); + } + mutex_unlock(&chg->supv_lock); + return 0; +} +DEFINE_SHOW_ATTRIBUTE(lbc_state); + +static void lbc_debugfs_remove(void *data) +{ + debugfs_remove_recursive(data); +} + static irqreturn_t pm8916_lbc_charger_state_changed_irq(int irq, void *data) { struct pm8916_lbc_charger *chg = data; @@ -190,6 +485,9 @@ power_supply_changed(chg->charger); + if (chg->vbat_chan) + mod_delayed_work(system_freezable_wq, &chg->supv_work, 0); + return IRQ_HANDLED; } @@ -230,10 +528,35 @@ if (ret) return ret; - /* Disable charger timeout. */ + /* + * Keep the charger safety timer running (upstream disabled it). Same sequence as the + * downstream qpnp-linear-charger: timer off, TCHG_MAX = minutes / 4 - 1 (4..512 min), timer on. + */ + chg->timeout_min = PM8916_LBC_TIMEOUT_DEFAULT_MIN; + device_property_read_u32(dev, "qcom,charge-timeout-minutes", &chg->timeout_min); + chg->timeout_min = clamp_t(u32, chg->timeout_min, PM8916_LBC_TIMEOUT_STEP_MIN, + PM8916_LBC_TIMEOUT_MAX_MIN); + chg->timeout_min -= chg->timeout_min % PM8916_LBC_TIMEOUT_STEP_MIN; + ret = regmap_write(chg->regmap, chg->reg[LBC_CHGR] + PM8916_LBC_CHGR_TCHG_MAX_EN, 0x00); if (ret) return ret; + tmp = chg->timeout_min / PM8916_LBC_TIMEOUT_STEP_MIN - 1; + ret = regmap_write(chg->regmap, chg->reg[LBC_CHGR] + PM8916_LBC_CHGR_TCHG_MAX, tmp); + if (ret) + return ret; + ret = regmap_write(chg->regmap, chg->reg[LBC_CHGR] + PM8916_LBC_CHGR_TCHG_MAX_EN, + PM8916_LBC_CHGR_TCHG_MAX_ENABLED); + if (ret) + return ret; + + ret = regmap_read(chg->regmap, chg->reg[LBC_CHGR] + PM8916_LBC_CHGR_TCHG_MAX, &tmp); + if (ret) + return ret; + if (tmp != chg->timeout_min / PM8916_LBC_TIMEOUT_STEP_MIN - 1) + return dev_err_probe(dev, -EIO, "TCHG_MAX readback 0x%x != 0x%x\n", tmp, + chg->timeout_min / PM8916_LBC_TIMEOUT_STEP_MIN - 1); + dev_info(dev, "safety timer %u min (TCHG_MAX 0x%02x), enabled\n", chg->timeout_min, tmp); return ret; } @@ -309,7 +632,7 @@ ret = pm8916_lbc_charger_probe_dt(chg); if (ret) - dev_err_probe(dev, ret, "Error while parsing device tree\n"); + return dev_err_probe(dev, ret, "Error while parsing device tree\n"); psy_cfg.drv_data = chg; psy_cfg.fwnode = dev_fwnode(dev); @@ -322,6 +645,22 @@ if (ret) return dev_err_probe(dev, ret, "Unable to get battery info\n"); + chg->vbat_chan = devm_iio_channel_get(dev, "vbat"); + if (IS_ERR(chg->vbat_chan)) + return dev_err_probe(dev, PTR_ERR(chg->vbat_chan), "no VADC vbat channel\n"); + + { + struct device_node *bat = of_parse_phandle(dev->of_node, "monitored-battery", 0); + + if (!bat || of_property_read_u32(bat, "re-charge-voltage-microvolt", &chg->recharge_uv)) + dev_warn(dev, "no re-charge-voltage-microvolt: automatic recharge disabled\n"); + of_node_put(bat); + } + mutex_init(&chg->supv_lock); + ret = devm_delayed_work_autocancel(dev, &chg->supv_work, lbc_supv_work); + if (ret) + return ret; + irq = platform_get_irq_byname(pdev, "usb_vbus"); if (irq < 0) return irq; @@ -347,10 +686,21 @@ extcon_set_state_sync(chg->edev, EXTCON_USB, chg->online); chg->charge_voltage_max = chg->info->voltage_max_design_uv; - ret = pm8916_lbc_charger_configure(chg); + ret = pm8916_lbc_charger_configure(chg, true); if (ret) return ret; + chg->debugfs = debugfs_create_dir("pm8916_lbc", NULL); + debugfs_create_file("state", 0444, chg->debugfs, chg, &lbc_state_fops); + ret = devm_add_action_or_reset(dev, lbc_debugfs_remove, chg->debugfs); + if (ret) + return ret; + + dev_info(dev, "recharge supervisor: threshold %u uV, %d x %d ms below, ovp %d uV\n", + chg->recharge_uv, PM8916_LBC_SUPV_LOW_POLLS, PM8916_LBC_SUPV_PERIOD_MS, + PM8916_LBC_SUPV_OVP_UV); + queue_delayed_work(system_freezable_wq, &chg->supv_work, 0); + return 0; comm_error: