Lines Matching refs:bq
361 static int bq25890_field_read(struct bq25890_device *bq,
367 ret = regmap_field_read(bq->rmap_fields[field_id], &val);
374 static int bq25890_field_write(struct bq25890_device *bq,
377 return regmap_field_write(bq->rmap_fields[field_id], val);
454 static irqreturn_t __bq25890_handle_irq(struct bq25890_device *bq);
456 static int bq25890_get_vbus_voltage(struct bq25890_device *bq)
460 ret = bq25890_field_read(bq, F_VBUSV);
467 static void bq25890_update_state(struct bq25890_device *bq,
474 mutex_lock(&bq->lock);
476 __bq25890_handle_irq(bq);
477 *state = bq->state;
480 bq25890_field_write(bq, F_CONV_START, 1);
481 mutex_unlock(&bq->lock);
484 regmap_field_read_poll_timeout(bq->rmap_fields[F_CONV_START],
492 struct bq25890_device *bq = power_supply_get_drvdata(psy);
496 bq25890_update_state(bq, psp, &state);
532 val->strval = bq25890_chip_name[bq->chip_version];
553 val->intval = bq25890_find_val(bq->init_data.iprechg, TBL_ITERM);
557 val->intval = bq25890_find_val(bq->init_data.iterm, TBL_ITERM);
561 ret = bq25890_field_read(bq, F_IINLIM);
576 ret = bq25890_field_read(bq, F_ICHGR); /* read measured value */
595 ret = bq25890_field_read(bq, F_ICHG);
601 if (bq->state.ntc_fault == NTC_FAULT_COOL) {
602 ret = bq25890_field_read(bq, F_JEITA_ISET);
621 val->intval = bq25890_find_val(bq->init_data.ichg, TBL_ICHG);
632 ret = bq25890_field_read(bq, F_BATV); /* read measured value */
651 ret = bq25890_field_read(bq, F_VREG);
666 val->intval = bq25890_find_val(bq->init_data.vreg, TBL_VREG);
670 ret = bq25890_field_read(bq, F_TSPCT);
689 struct bq25890_device *bq = power_supply_get_drvdata(psy);
696 maxval = bq25890_find_val(bq->init_data.ichg, TBL_ICHG);
698 return bq25890_field_write(bq, F_ICHG, lval);
700 maxval = bq25890_find_val(bq->init_data.vreg, TBL_VREG);
702 return bq25890_field_write(bq, F_VREG, lval);
705 return bq25890_field_write(bq, F_IINLIM, lval);
707 ret = bq25890_field_write(bq, F_EN_HIZ, !val->intval);
709 bq->force_hiz = !val->intval;
710 bq25890_update_state(bq, psp, &state);
734 * to the bq->iinlim_percentage setting.
736 static int bq25890_charger_get_scaled_iinlim_regval(struct bq25890_device *bq,
739 iinlim_ua = iinlim_ua * bq->iinlim_percentage / 100;
746 struct bq25890_device *bq = power_supply_get_drvdata(psy);
750 if (bq->chip_version != BQ25892)
761 input_current_limit = bq25890_charger_get_scaled_iinlim_regval(bq, 2000000);
762 if (bq->pump_express_vbus_max) {
764 &bq->pump_express_work,
770 input_current_limit = bq25890_charger_get_scaled_iinlim_regval(bq, 1500000);
774 input_current_limit = bq25890_charger_get_scaled_iinlim_regval(bq, 500000);
777 bq25890_field_write(bq, F_IINLIM, input_current_limit);
781 static int bq25890_get_chip_state(struct bq25890_device *bq,
801 ret = bq25890_field_read(bq, state_fields[i].id);
808 dev_dbg(bq->dev, "S:CHG/PG/HIZ/VSYS=%d/%d/%d/%d, F:CHG/BOOST/BAT/NTC=%d/%d/%d/%d\n",
817 static irqreturn_t __bq25890_handle_irq(struct bq25890_device *bq)
823 ret = bq25890_get_chip_state(bq, &new_state);
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;
846 ret = bq25890_field_write(bq, F_CONV_RATE, new_adc_conv_rate);
851 bq->state = new_state;
852 power_supply_changed(bq->charger);
856 dev_err(bq->dev, "Error communicating with the chip: %pe\n",
863 struct bq25890_device *bq = private;
866 mutex_lock(&bq->lock);
867 ret = __bq25890_handle_irq(bq);
868 mutex_unlock(&bq->lock);
873 static int bq25890_chip_reset(struct bq25890_device *bq)
878 ret = bq25890_field_write(bq, F_REG_RST, 1);
883 ret = bq25890_field_read(bq, F_REG_RST);
896 static int bq25890_rw_init_data(struct bq25890_device *bq)
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},
922 ret = bq25890_field_write(bq, init_data[i].id,
925 ret = bq25890_field_read(bq, init_data[i].id);
930 dev_dbg(bq->dev, "Accessing init data failed %d\n", ret);
938 static int bq25890_hw_init(struct bq25890_device *bq)
942 if (!bq->skip_reset) {
943 ret = bq25890_chip_reset(bq);
945 dev_dbg(bq->dev, "Reset failed %d\n", ret);
954 ret = bq25890_field_write(bq, F_CHG_CFG, 1);
956 dev_dbg(bq->dev, "Enabling charging failed %d\n", ret);
962 ret = bq25890_field_write(bq, F_WD, 0);
964 dev_dbg(bq->dev, "Disabling watchdog failed %d\n", ret);
969 ret = bq25890_rw_init_data(bq);
973 ret = bq25890_get_chip_state(bq, &bq->state);
975 dev_dbg(bq->dev, "Get state failed %d\n", ret);
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);
1022 static int bq25890_power_supply_init(struct bq25890_device *bq)
1024 struct power_supply_config psy_cfg = { .drv_data = bq, };
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);
1045 static int bq25890_set_otg_cfg(struct bq25890_device *bq, u8 val)
1049 ret = bq25890_field_write(bq, F_OTG_CFG, val);
1051 dev_err(bq->dev, "Error switching to boost/charger mode: %d\n", ret);
1058 struct bq25890_device *bq =
1063 dev_dbg(bq->dev, "Start to request input voltage increasing\n");
1066 if (bq->secondary_chrg) {
1068 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &value);
1072 ret = bq25890_field_write(bq, F_PUMPX_EN, 1);
1077 voltage = bq25890_get_vbus_voltage(bq);
1080 dev_dbg(bq->dev, "input voltage = %d uV\n", voltage);
1083 bq->pump_express_vbus_max)
1086 ret = bq25890_field_write(bq, F_PUMPX_UP, 1);
1091 ret = regmap_field_read_poll_timeout(bq->rmap_fields[F_PUMPX_UP],
1100 bq25890_field_write(bq, F_PUMPX_EN, 0);
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);
1114 bq25890_field_write(bq, F_PUMPX_EN, 0);
1115 dev_err(bq->dev, "Failed to request hi-voltage charging\n");
1121 struct bq25890_device *bq =
1124 switch (bq->usb_event) {
1127 bq25890_set_otg_cfg(bq, 1);
1132 ret = bq25890_set_otg_cfg(bq, 0);
1134 power_supply_changed(bq->charger);
1142 struct bq25890_device *bq =
1145 bq->usb_event = val;
1146 queue_work(system_power_efficient_wq, &bq->usb_work);
1154 struct bq25890_device *bq = rdev_get_drvdata(rdev);
1164 if (bq->secondary_chrg)
1165 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &val);
1167 return bq25890_set_otg_cfg(bq, 1);
1172 struct bq25890_device *bq = rdev_get_drvdata(rdev);
1178 ret = bq25890_set_otg_cfg(bq, 0);
1182 if (bq->secondary_chrg)
1183 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &val);
1190 struct bq25890_device *bq = rdev_get_drvdata(rdev);
1192 return bq25890_field_read(bq, F_OTG_CFG);
1197 struct bq25890_device *bq = rdev_get_drvdata(rdev);
1199 return bq25890_get_vbus_voltage(bq);
1204 struct bq25890_device *bq = rdev_get_drvdata(rdev);
1208 ret = bq25890_field_read(bq, F_SYSV); /* read measured value */
1243 static int bq25890_register_regulator(struct bq25890_device *bq)
1245 struct bq25890_platform_data *pdata = dev_get_platdata(bq->dev);
1247 .dev = bq->dev,
1248 .driver_data = bq,
1255 reg = devm_regulator_register(bq->dev, &bq25890_vbus_desc, &cfg);
1257 return dev_err_probe(bq->dev, PTR_ERR(reg),
1263 reg = devm_regulator_register(bq->dev, &bq25890_vsys_desc, &cfg);
1265 return dev_err_probe(bq->dev, PTR_ERR(reg),
1273 bq25890_register_regulator(struct bq25890_device *bq)
1279 static int bq25890_get_chip_version(struct bq25890_device *bq)
1283 id = bq25890_field_read(bq, F_PN);
1285 dev_err(bq->dev, "Cannot read chip ID: %d\n", id);
1289 rev = bq25890_field_read(bq, F_DEV_REV);
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);
1329 static int bq25890_irq_probe(struct bq25890_device *bq)
1333 irq = devm_gpiod_get(bq->dev, BQ25890_IRQ_PIN, GPIOD_IN);
1335 return dev_err_probe(bq->dev, PTR_ERR(irq),
1341 static int bq25890_fw_read_u32_props(struct bq25890_device *bq)
1346 struct bq25890_init_data *init = &bq->init_data;
1373 ret = device_property_read_u32(bq->dev, props[i].name,
1379 dev_err(bq->dev, "Unable to read property %d %s\n", ret,
1392 static int bq25890_fw_probe(struct bq25890_device *bq)
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)
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);
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,
1424 if (bq->read_back_init_data)
1427 ret = bq25890_fw_read_u32_props(bq);
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");
1439 struct bq25890_device *bq = data;
1441 cancel_delayed_work_sync(&bq->pump_express_work);
1443 if (bq->id >= 0) {
1445 idr_remove(&bq25890_id, bq->id);
1453 struct bq25890_device *bq;
1456 bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
1457 if (!bq)
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,
1477 i2c_set_clientdata(client, bq);
1479 ret = bq25890_get_chip_version(bq);
1485 ret = bq25890_fw_probe(bq);
1489 ret = bq25890_hw_init(bq);
1496 client->irq = bq25890_irq_probe(bq);
1504 bq->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
1510 ret = devm_add_action_or_reset(dev, bq25890_non_devm_cleanup, bq);
1514 ret = bq25890_register_regulator(bq);
1518 ret = bq25890_power_supply_init(bq);
1525 BQ25890_IRQ_PIN, bq);
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);
1540 struct bq25890_device *bq = i2c_get_clientdata(client);
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) {
1549 bq25890_chip_reset(bq);
1555 struct bq25890_device *bq = i2c_get_clientdata(client);
1562 if (!IS_ERR_OR_NULL(bq->usb_phy))
1572 bq25890_set_otg_cfg(bq, 0);
1578 struct bq25890_device *bq = dev_get_drvdata(dev);
1584 return bq25890_field_write(bq, F_CONV_RATE, 0);
1590 struct bq25890_device *bq = dev_get_drvdata(dev);
1592 mutex_lock(&bq->lock);
1594 ret = bq25890_get_chip_state(bq, &bq->state);
1599 if (bq->state.online) {
1600 ret = bq25890_field_write(bq, F_CONV_RATE, 1);
1606 power_supply_changed(bq->charger);
1609 mutex_unlock(&bq->lock);