Lines Matching +full:enable +full:- +full:usb +full:- +full:charging
1 // SPDX-License-Identifier: GPL-2.0-or-later
18 #include <linux/usb/phy.h>
90 u8 ilim_en; /* enable ILIM pin */
113 char name[28]; /* "bq25890-charger-%d" */
272 * Most of the val -> idx conversions can be computed, given the minimum,
322 0, -10, -20, -30, -40, -60, -70, -80,
323 -90, -10, -120, -140, -150, -170, -190, -210,
367 ret = regmap_field_read(bq->rmap_fields[field_id], &val);
377 return regmap_field_write(bq->rmap_fields[field_id], val);
394 rtbl_size = (rtbl->max - rtbl->min) / rtbl->step + 1;
397 idx < rtbl_size && (idx * rtbl->step + rtbl->min <= value);
402 return idx - 1;
416 return (rtbl->min + idx * rtbl->step);
474 mutex_lock(&bq->lock);
477 *state = bq->state;
478 do_adc_conv = (!state->online || state->hiz) && bq25890_is_adc_property(psp);
481 mutex_unlock(&bq->lock);
484 regmap_field_read_poll_timeout(bq->rmap_fields[F_CONV_START],
501 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
503 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
506 val->intval = POWER_SUPPLY_STATUS_CHARGING;
508 val->intval = POWER_SUPPLY_STATUS_FULL;
510 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
518 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
520 val->intval = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
522 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
524 val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
528 val->strval = BQ25890_MANUFACTURER;
532 val->strval = bq25890_chip_name[bq->chip_version];
536 val->intval = state.online && !state.hiz;
541 val->intval = POWER_SUPPLY_HEALTH_GOOD;
543 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
545 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
547 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
549 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
553 val->intval = bq25890_find_val(bq->init_data.iprechg, TBL_ITERM);
557 val->intval = bq25890_find_val(bq->init_data.iterm, TBL_ITERM);
565 val->intval = bq25890_find_val(ret, TBL_IINLIM);
570 * This is ADC-sampled immediate charge current supplied
573 * Documentation/ABI/testing/sysfs-class-power
581 val->intval = ret * -50000;
586 * This is user-configured constant charge current supplied
587 * from charger to battery in first phase of charging, when
598 val->intval = bq25890_find_val(ret, TBL_ICHG);
601 if (bq->state.ntc_fault == NTC_FAULT_COOL) {
607 val->intval /= 5;
609 val->intval /= 2;
616 * from charger to battery in first phase of charging, when
621 val->intval = bq25890_find_val(bq->init_data.ichg, TBL_ICHG);
626 * This is ADC-sampled immediate charge voltage supplied
629 * Documentation/ABI/testing/sysfs-class-power
637 val->intval = 2304000 + ret * 20000;
642 * This is user-configured constant charge voltage supplied
643 * from charger to battery in second phase of charging, when
655 val->intval = bq25890_find_val(ret, TBL_VREG);
661 * from charger to battery in second phase of charging, when
666 val->intval = bq25890_find_val(bq->init_data.vreg, TBL_VREG);
675 val->intval = bq25890_find_val(ret, TBL_TSPCT);
679 return -EINVAL;
696 maxval = bq25890_find_val(bq->init_data.ichg, TBL_ICHG);
697 lval = bq25890_find_idx(min(val->intval, maxval), TBL_ICHG);
700 maxval = bq25890_find_val(bq->init_data.vreg, TBL_VREG);
701 lval = bq25890_find_idx(min(val->intval, maxval), TBL_VREG);
704 lval = bq25890_find_idx(val->intval, TBL_IINLIM);
707 ret = bq25890_field_write(bq, F_EN_HIZ, !val->intval);
709 bq->force_hiz = !val->intval;
713 return -EINVAL;
732 * If there are multiple chargers the maximum current the external power-supply
734 * to the bq->iinlim_percentage setting.
739 iinlim_ua = iinlim_ua * bq->iinlim_percentage / 100;
743 /* On the BQ25892 try to get charger-type info from our supplier */
750 if (bq->chip_version != BQ25892)
762 if (bq->pump_express_vbus_max) {
764 &bq->pump_express_work,
790 {F_CHG_STAT, &state->chrg_status},
791 {F_PG_STAT, &state->online},
792 {F_EN_HIZ, &state->hiz},
793 {F_VSYS_STAT, &state->vsys_status},
794 {F_BOOST_FAULT, &state->boost_fault},
795 {F_BAT_FAULT, &state->bat_fault},
796 {F_CHG_FAULT, &state->chrg_fault},
797 {F_NTC_FAULT, &state->ntc_fault}
808 dev_dbg(bq->dev, "S:CHG/PG/HIZ/VSYS=%d/%d/%d/%d, F:CHG/BOOST/BAT/NTC=%d/%d/%d/%d\n",
809 state->chrg_status, state->online,
810 state->hiz, state->vsys_status,
811 state->chrg_fault, state->boost_fault,
812 state->bat_fault, state->ntc_fault);
827 if (!memcmp(&bq->state, &new_state, sizeof(new_state)))
834 if (new_state.online && !bq->state.online && bq->force_hiz) {
835 ret = bq25890_field_write(bq, F_EN_HIZ, bq->force_hiz);
842 adc_conv_rate = bq->state.online && !bq->state.hiz;
851 bq->state = new_state;
852 power_supply_changed(bq->charger);
856 dev_err(bq->dev, "Error communicating with the chip: %pe\n",
866 mutex_lock(&bq->lock);
868 mutex_unlock(&bq->lock);
888 } while (ret == 1 && --rst_check_counter);
891 return -ETIMEDOUT;
898 bool write = !bq->read_back_init_data;
906 {F_ICHG, &bq->init_data.ichg},
907 {F_VREG, &bq->init_data.vreg},
908 {F_ITERM, &bq->init_data.iterm},
909 {F_IPRECHG, &bq->init_data.iprechg},
910 {F_SYSVMIN, &bq->init_data.sysvmin},
911 {F_BOOSTV, &bq->init_data.boostv},
912 {F_BOOSTI, &bq->init_data.boosti},
913 {F_BOOSTF, &bq->init_data.boostf},
914 {F_EN_ILIM, &bq->init_data.ilim_en},
915 {F_TREG, &bq->init_data.treg},
916 {F_BATCMP, &bq->init_data.rbatcomp},
917 {F_VCLAMP, &bq->init_data.vclamp},
930 dev_dbg(bq->dev, "Accessing init data failed %d\n", ret);
942 if (!bq->skip_reset) {
945 dev_dbg(bq->dev, "Reset failed %d\n", ret);
950 * Ensure charging is enabled, on some boards where the fw
956 dev_dbg(bq->dev, "Enabling charging failed %d\n", ret);
964 dev_dbg(bq->dev, "Disabling watchdog failed %d\n", ret);
973 ret = bq25890_get_chip_state(bq, &bq->state);
975 dev_dbg(bq->dev, "Get state failed %d\n", ret);
979 /* Configure ADC for continuous conversions when charging */
980 ret = bq25890_field_write(bq, F_CONV_RATE, bq->state.online && !bq->state.hiz);
982 dev_dbg(bq->dev, "Config ADC failed %d\n", ret);
1009 "main-battery",
1028 bq->id = idr_alloc(&bq25890_id, bq, 0, 0, GFP_KERNEL);
1030 if (bq->id < 0)
1031 return bq->id;
1033 snprintf(bq->name, sizeof(bq->name), "bq25890-charger-%d", bq->id);
1034 bq->desc = bq25890_power_supply_desc;
1035 bq->desc.name = bq->name;
1040 bq->charger = devm_power_supply_register(bq->dev, &bq->desc, &psy_cfg);
1042 return PTR_ERR_OR_ZERO(bq->charger);
1051 dev_err(bq->dev, "Error switching to boost/charger mode: %d\n", ret);
1063 dev_dbg(bq->dev, "Start to request input voltage increasing\n");
1065 /* If there is a second charger put in Hi-Z mode */
1066 if (bq->secondary_chrg) {
1068 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &value);
1071 /* Enable current pulse voltage control protocol */
1080 dev_dbg(bq->dev, "input voltage = %d uV\n", voltage);
1083 bq->pump_express_vbus_max)
1090 /* Note a single PUMPX up pulse-sequence takes 2.1s */
1091 ret = regmap_field_read_poll_timeout(bq->rmap_fields[F_PUMPX_UP],
1102 if (bq->secondary_chrg) {
1104 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &value);
1107 dev_info(bq->dev, "Hi-voltage charging requested, input voltage is %d mV\n",
1110 power_supply_changed(bq->charger);
1115 dev_err(bq->dev, "Failed to request hi-voltage charging\n");
1124 switch (bq->usb_event) {
1126 /* Enable boost mode */
1134 power_supply_changed(bq->charger);
1145 bq->usb_event = val;
1146 queue_work(system_power_efficient_wq, &bq->usb_work);
1161 * charger in Hi-Z mode to avoid it trying to charge the secondary
1164 if (bq->secondary_chrg)
1165 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &val);
1182 if (bq->secondary_chrg)
1183 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &val);
1217 .enable = bq25890_vbus_enable,
1225 .of_match = "usb-otg-vbus",
1245 struct bq25890_platform_data *pdata = dev_get_platdata(bq->dev);
1247 .dev = bq->dev,
1253 cfg.init_data = pdata->regulator_init_data;
1255 reg = devm_regulator_register(bq->dev, &bq25890_vbus_desc, &cfg);
1257 return dev_err_probe(bq->dev, PTR_ERR(reg),
1261 /* pdata->regulator_init_data is for vbus only */
1263 reg = devm_regulator_register(bq->dev, &bq25890_vsys_desc, &cfg);
1265 return dev_err_probe(bq->dev, PTR_ERR(reg),
1285 dev_err(bq->dev, "Cannot read chip ID: %d\n", id);
1291 dev_err(bq->dev, "Cannot read chip revision: %d\n", rev);
1297 bq->chip_version = BQ25890;
1304 bq->chip_version = BQ25896;
1307 bq->chip_version = BQ25892;
1310 dev_err(bq->dev,
1313 bq->chip_version = BQ25892;
1318 bq->chip_version = BQ25895;
1322 dev_err(bq->dev, "Unknown chip ID %d\n", id);
1323 return -ENODEV;
1333 irq = devm_gpiod_get(bq->dev, BQ25890_IRQ_PIN, GPIOD_IN);
1335 return dev_err_probe(bq->dev, PTR_ERR(irq),
1346 struct bq25890_init_data *init = &bq->init_data;
1354 {"ti,charge-current", false, TBL_ICHG, &init->ichg},
1355 {"ti,battery-regulation-voltage", false, TBL_VREG, &init->vreg},
1356 {"ti,termination-current", false, TBL_ITERM, &init->iterm},
1357 {"ti,precharge-current", false, TBL_ITERM, &init->iprechg},
1358 {"ti,minimum-sys-voltage", false, TBL_SYSVMIN, &init->sysvmin},
1359 {"ti,boost-voltage", false, TBL_BOOSTV, &init->boostv},
1360 {"ti,boost-max-current", false, TBL_BOOSTI, &init->boosti},
1363 {"ti,thermal-regulation-threshold", true, TBL_TREG, &init->treg},
1364 {"ti,ibatcomp-micro-ohms", true, TBL_RBATCOMP, &init->rbatcomp},
1365 {"ti,ibatcomp-clamp-microvolt", true, TBL_VBATCOMP, &init->vclamp},
1369 init->treg = 3; /* 120 degrees Celsius */
1370 init->rbatcomp = init->vclamp = 0; /* IBAT compensation disabled */
1373 ret = device_property_read_u32(bq->dev, props[i].name,
1379 dev_err(bq->dev, "Unable to read property %d %s\n", ret,
1395 struct bq25890_init_data *init = &bq->init_data;
1399 ret = device_property_read_string(bq->dev, "linux,secondary-charger-name", &str);
1401 bq->secondary_chrg = power_supply_get_by_name(str);
1402 if (!bq->secondary_chrg)
1403 return -EPROBE_DEFER;
1407 device_property_read_u32(bq->dev, "linux,pump-express-vbus-max",
1408 &bq->pump_express_vbus_max);
1410 ret = device_property_read_u32(bq->dev, "linux,iinlim-percentage", &val);
1413 dev_err(bq->dev, "Error linux,iinlim-percentage %u > 100\n", val);
1414 return -EINVAL;
1416 bq->iinlim_percentage = val;
1418 bq->iinlim_percentage = 100;
1421 bq->skip_reset = device_property_read_bool(bq->dev, "linux,skip-reset");
1422 bq->read_back_init_data = device_property_read_bool(bq->dev,
1423 "linux,read-back-settings");
1424 if (bq->read_back_init_data)
1431 init->ilim_en = device_property_read_bool(bq->dev, "ti,use-ilim-pin");
1432 init->boostf = device_property_read_bool(bq->dev, "ti,boost-low-freq");
1441 cancel_delayed_work_sync(&bq->pump_express_work);
1443 if (bq->id >= 0) {
1445 idr_remove(&bq25890_id, bq->id);
1452 struct device *dev = &client->dev;
1458 return -ENOMEM;
1460 bq->client = client;
1461 bq->dev = dev;
1462 bq->id = -1;
1464 mutex_init(&bq->lock);
1465 INIT_DELAYED_WORK(&bq->pump_express_work, bq25890_pump_express_work);
1467 bq->rmap = devm_regmap_init_i2c(client, &bq25890_regmap_config);
1468 if (IS_ERR(bq->rmap))
1469 return dev_err_probe(dev, PTR_ERR(bq->rmap),
1472 ret = devm_regmap_field_bulk_alloc(dev, bq->rmap, bq->rmap_fields,
1495 if (client->irq <= 0)
1496 client->irq = bq25890_irq_probe(bq);
1498 if (client->irq < 0) {
1500 return client->irq;
1504 bq->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
1522 ret = devm_request_threaded_irq(dev, client->irq, NULL,
1529 if (!IS_ERR_OR_NULL(bq->usb_phy)) {
1530 INIT_WORK(&bq->usb_work, bq25890_usb_work);
1531 bq->usb_nb.notifier_call = bq25890_usb_notifier;
1532 usb_register_notifier(bq->usb_phy, &bq->usb_nb);
1542 if (!IS_ERR_OR_NULL(bq->usb_phy)) {
1543 usb_unregister_notifier(bq->usb_phy, &bq->usb_nb);
1544 cancel_work_sync(&bq->usb_work);
1547 if (!bq->skip_reset) {
1559 * introduce a function change for boards using the usb-phy framework.
1562 if (!IS_ERR_OR_NULL(bq->usb_phy))
1567 * Micro-USB or Type-C USB port. Leaving this on drains power and
1568 * this avoids the PMIC on some device-models seeing this as Vbus
1570 * power-up again.
1592 mutex_lock(&bq->lock);
1594 ret = bq25890_get_chip_state(bq, &bq->state);
1598 /* Re-enable ADC only if charger is plugged in. */
1599 if (bq->state.online) {
1606 power_supply_changed(bq->charger);
1609 mutex_unlock(&bq->lock);
1647 .name = "bq25890-charger",