1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * TI BQ24257 charger driver
5 * Copyright (C) 2015 Intel Corporation
8 * https://www.ti.com/product/bq24250
9 * https://www.ti.com/product/bq24251
10 * https://www.ti.com/product/bq24257
13 #include <linux/module.h>
14 #include <linux/i2c.h>
15 #include <linux/power_supply.h>
16 #include <linux/regmap.h>
17 #include <linux/types.h>
18 #include <linux/gpio/consumer.h>
19 #include <linux/interrupt.h>
20 #include <linux/delay.h>
22 #include <linux/acpi.h>
25 #define BQ24257_REG_1 0x00
26 #define BQ24257_REG_2 0x01
27 #define BQ24257_REG_3 0x02
28 #define BQ24257_REG_4 0x03
29 #define BQ24257_REG_5 0x04
30 #define BQ24257_REG_6 0x05
31 #define BQ24257_REG_7 0x06
33 #define BQ24257_MANUFACTURER "Texas Instruments"
34 #define BQ24257_PG_GPIO "pg"
36 #define BQ24257_ILIM_SET_DELAY 1000 /* msec */
39 * When adding support for new devices make sure that enum bq2425x_chip and
40 * bq2425x_chip_name[] always stay in sync!
48 static const char *const bq2425x_chip_name[] = {
55 F_WD_FAULT, F_WD_EN, F_STAT, F_FAULT, /* REG 1 */
56 F_RESET, F_IILIMIT, F_EN_STAT, F_EN_TERM, F_CE, F_HZ_MODE, /* REG 2 */
57 F_VBAT, F_USB_DET, /* REG 3 */
58 F_ICHG, F_ITERM, /* REG 4 */
59 F_LOOP_STATUS, F_LOW_CHG, F_DPDM_EN, F_CE_STATUS, F_VINDPM, /* REG 5 */
60 F_X2_TMR_EN, F_TMR, F_SYSOFF, F_TS_EN, F_TS_STAT, /* REG 6 */
61 F_VOVP, F_CLR_VDP, F_FORCE_BATDET, F_FORCE_PTM, /* REG 7 */
66 /* initial field values, converted from uV/uA */
67 struct bq24257_init_data {
68 u8 ichg; /* charge current */
69 u8 vbat; /* regulation voltage */
70 u8 iterm; /* termination current */
71 u8 iilimit; /* input current limit */
72 u8 vovp; /* over voltage protection voltage */
73 u8 vindpm; /* VDMP input threshold voltage */
76 struct bq24257_state {
82 struct bq24257_device {
83 struct i2c_client *client;
85 struct power_supply *charger;
87 enum bq2425x_chip chip;
90 struct regmap_field *rmap_fields[F_MAX_FIELDS];
94 struct delayed_work iilimit_setup_work;
96 struct bq24257_init_data init_data;
97 struct bq24257_state state;
99 struct mutex lock; /* protect state data */
101 bool iilimit_autoset_enable;
104 static bool bq24257_is_volatile_reg(struct device *dev, unsigned int reg)
116 static const struct regmap_config bq24257_regmap_config = {
120 .max_register = BQ24257_REG_7,
121 .cache_type = REGCACHE_RBTREE,
123 .volatile_reg = bq24257_is_volatile_reg,
126 static const struct reg_field bq24257_reg_fields[] = {
128 [F_WD_FAULT] = REG_FIELD(BQ24257_REG_1, 7, 7),
129 [F_WD_EN] = REG_FIELD(BQ24257_REG_1, 6, 6),
130 [F_STAT] = REG_FIELD(BQ24257_REG_1, 4, 5),
131 [F_FAULT] = REG_FIELD(BQ24257_REG_1, 0, 3),
133 [F_RESET] = REG_FIELD(BQ24257_REG_2, 7, 7),
134 [F_IILIMIT] = REG_FIELD(BQ24257_REG_2, 4, 6),
135 [F_EN_STAT] = REG_FIELD(BQ24257_REG_2, 3, 3),
136 [F_EN_TERM] = REG_FIELD(BQ24257_REG_2, 2, 2),
137 [F_CE] = REG_FIELD(BQ24257_REG_2, 1, 1),
138 [F_HZ_MODE] = REG_FIELD(BQ24257_REG_2, 0, 0),
140 [F_VBAT] = REG_FIELD(BQ24257_REG_3, 2, 7),
141 [F_USB_DET] = REG_FIELD(BQ24257_REG_3, 0, 1),
143 [F_ICHG] = REG_FIELD(BQ24257_REG_4, 3, 7),
144 [F_ITERM] = REG_FIELD(BQ24257_REG_4, 0, 2),
146 [F_LOOP_STATUS] = REG_FIELD(BQ24257_REG_5, 6, 7),
147 [F_LOW_CHG] = REG_FIELD(BQ24257_REG_5, 5, 5),
148 [F_DPDM_EN] = REG_FIELD(BQ24257_REG_5, 4, 4),
149 [F_CE_STATUS] = REG_FIELD(BQ24257_REG_5, 3, 3),
150 [F_VINDPM] = REG_FIELD(BQ24257_REG_5, 0, 2),
152 [F_X2_TMR_EN] = REG_FIELD(BQ24257_REG_6, 7, 7),
153 [F_TMR] = REG_FIELD(BQ24257_REG_6, 5, 6),
154 [F_SYSOFF] = REG_FIELD(BQ24257_REG_6, 4, 4),
155 [F_TS_EN] = REG_FIELD(BQ24257_REG_6, 3, 3),
156 [F_TS_STAT] = REG_FIELD(BQ24257_REG_6, 0, 2),
158 [F_VOVP] = REG_FIELD(BQ24257_REG_7, 5, 7),
159 [F_CLR_VDP] = REG_FIELD(BQ24257_REG_7, 4, 4),
160 [F_FORCE_BATDET] = REG_FIELD(BQ24257_REG_7, 3, 3),
161 [F_FORCE_PTM] = REG_FIELD(BQ24257_REG_7, 2, 2)
164 static const u32 bq24257_vbat_map[] = {
165 3500000, 3520000, 3540000, 3560000, 3580000, 3600000, 3620000, 3640000,
166 3660000, 3680000, 3700000, 3720000, 3740000, 3760000, 3780000, 3800000,
167 3820000, 3840000, 3860000, 3880000, 3900000, 3920000, 3940000, 3960000,
168 3980000, 4000000, 4020000, 4040000, 4060000, 4080000, 4100000, 4120000,
169 4140000, 4160000, 4180000, 4200000, 4220000, 4240000, 4260000, 4280000,
170 4300000, 4320000, 4340000, 4360000, 4380000, 4400000, 4420000, 4440000
173 #define BQ24257_VBAT_MAP_SIZE ARRAY_SIZE(bq24257_vbat_map)
175 static const u32 bq24257_ichg_map[] = {
176 500000, 550000, 600000, 650000, 700000, 750000, 800000, 850000, 900000,
177 950000, 1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000,
178 1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
179 1750000, 1800000, 1850000, 1900000, 1950000, 2000000
182 #define BQ24257_ICHG_MAP_SIZE ARRAY_SIZE(bq24257_ichg_map)
184 static const u32 bq24257_iterm_map[] = {
185 50000, 75000, 100000, 125000, 150000, 175000, 200000, 225000
188 #define BQ24257_ITERM_MAP_SIZE ARRAY_SIZE(bq24257_iterm_map)
190 static const u32 bq24257_iilimit_map[] = {
191 100000, 150000, 500000, 900000, 1500000, 2000000
194 #define BQ24257_IILIMIT_MAP_SIZE ARRAY_SIZE(bq24257_iilimit_map)
196 static const u32 bq24257_vovp_map[] = {
197 6000000, 6500000, 7000000, 8000000, 9000000, 9500000, 10000000,
201 #define BQ24257_VOVP_MAP_SIZE ARRAY_SIZE(bq24257_vovp_map)
203 static const u32 bq24257_vindpm_map[] = {
204 4200000, 4280000, 4360000, 4440000, 4520000, 4600000, 4680000,
208 #define BQ24257_VINDPM_MAP_SIZE ARRAY_SIZE(bq24257_vindpm_map)
210 static int bq24257_field_read(struct bq24257_device *bq,
211 enum bq24257_fields field_id)
216 ret = regmap_field_read(bq->rmap_fields[field_id], &val);
223 static int bq24257_field_write(struct bq24257_device *bq,
224 enum bq24257_fields field_id, u8 val)
226 return regmap_field_write(bq->rmap_fields[field_id], val);
229 static u8 bq24257_find_idx(u32 value, const u32 *map, u8 map_size)
233 for (idx = 1; idx < map_size; idx++)
234 if (value < map[idx])
240 enum bq24257_status {
242 STATUS_CHARGE_IN_PROGRESS,
261 static int bq24257_get_input_current_limit(struct bq24257_device *bq,
262 union power_supply_propval *val)
266 ret = bq24257_field_read(bq, F_IILIMIT);
271 * The "External ILIM" and "Production & Test" modes are not exposed
272 * through this driver and not being covered by the lookup table.
273 * Should such a mode have become active let's return an error rather
274 * than exceeding the bounds of the lookup table and returning
277 if (ret >= BQ24257_IILIMIT_MAP_SIZE)
280 val->intval = bq24257_iilimit_map[ret];
285 static int bq24257_set_input_current_limit(struct bq24257_device *bq,
286 const union power_supply_propval *val)
289 * Address the case where the user manually sets an input current limit
290 * while the charger auto-detection mechanism is active. In this
291 * case we want to abort and go straight to the user-specified value.
293 if (bq->iilimit_autoset_enable)
294 cancel_delayed_work_sync(&bq->iilimit_setup_work);
296 return bq24257_field_write(bq, F_IILIMIT,
297 bq24257_find_idx(val->intval,
299 BQ24257_IILIMIT_MAP_SIZE));
302 static int bq24257_power_supply_get_property(struct power_supply *psy,
303 enum power_supply_property psp,
304 union power_supply_propval *val)
306 struct bq24257_device *bq = power_supply_get_drvdata(psy);
307 struct bq24257_state state;
309 mutex_lock(&bq->lock);
311 mutex_unlock(&bq->lock);
314 case POWER_SUPPLY_PROP_STATUS:
315 if (!state.power_good)
316 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
317 else if (state.status == STATUS_READY)
318 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
319 else if (state.status == STATUS_CHARGE_IN_PROGRESS)
320 val->intval = POWER_SUPPLY_STATUS_CHARGING;
321 else if (state.status == STATUS_CHARGE_DONE)
322 val->intval = POWER_SUPPLY_STATUS_FULL;
324 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
327 case POWER_SUPPLY_PROP_MANUFACTURER:
328 val->strval = BQ24257_MANUFACTURER;
331 case POWER_SUPPLY_PROP_MODEL_NAME:
332 val->strval = bq2425x_chip_name[bq->chip];
335 case POWER_SUPPLY_PROP_ONLINE:
336 val->intval = state.power_good;
339 case POWER_SUPPLY_PROP_HEALTH:
340 switch (state.fault) {
342 val->intval = POWER_SUPPLY_HEALTH_GOOD;
345 case FAULT_INPUT_OVP:
347 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
352 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
356 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
360 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
366 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
367 val->intval = bq24257_ichg_map[bq->init_data.ichg];
370 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
371 val->intval = bq24257_ichg_map[BQ24257_ICHG_MAP_SIZE - 1];
374 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
375 val->intval = bq24257_vbat_map[bq->init_data.vbat];
378 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
379 val->intval = bq24257_vbat_map[BQ24257_VBAT_MAP_SIZE - 1];
382 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
383 val->intval = bq24257_iterm_map[bq->init_data.iterm];
386 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
387 return bq24257_get_input_current_limit(bq, val);
396 static int bq24257_power_supply_set_property(struct power_supply *psy,
397 enum power_supply_property prop,
398 const union power_supply_propval *val)
400 struct bq24257_device *bq = power_supply_get_drvdata(psy);
403 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
404 return bq24257_set_input_current_limit(bq, val);
410 static int bq24257_power_supply_property_is_writeable(struct power_supply *psy,
411 enum power_supply_property psp)
414 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
421 static int bq24257_get_chip_state(struct bq24257_device *bq,
422 struct bq24257_state *state)
426 ret = bq24257_field_read(bq, F_STAT);
432 ret = bq24257_field_read(bq, F_FAULT);
439 state->power_good = !gpiod_get_value_cansleep(bq->pg);
442 * If we have a chip without a dedicated power-good GPIO or
443 * some other explicit bit that would provide this information
444 * assume the power is good if there is no supply related
445 * fault - and not good otherwise. There is a possibility for
446 * other errors to mask that power in fact is not good but this
447 * is probably the best we can do here.
449 switch (state->fault) {
450 case FAULT_INPUT_OVP:
451 case FAULT_INPUT_UVLO:
452 case FAULT_INPUT_LDO_LOW:
453 state->power_good = false;
456 state->power_good = true;
462 static bool bq24257_state_changed(struct bq24257_device *bq,
463 struct bq24257_state *new_state)
467 mutex_lock(&bq->lock);
468 ret = (bq->state.status != new_state->status ||
469 bq->state.fault != new_state->fault ||
470 bq->state.power_good != new_state->power_good);
471 mutex_unlock(&bq->lock);
476 enum bq24257_loop_status {
479 LOOP_STATUS_IN_CURRENT_LIMIT,
483 enum bq24257_in_ilimit {
505 enum bq24257_vindpm {
516 enum bq24257_port_type {
517 PORT_TYPE_DCP, /* Dedicated Charging Port */
518 PORT_TYPE_CDP, /* Charging Downstream Port */
519 PORT_TYPE_SDP, /* Standard Downstream Port */
520 PORT_TYPE_NON_STANDARD,
523 enum bq24257_safety_timer {
530 static int bq24257_iilimit_autoset(struct bq24257_device *bq)
536 const u8 new_iilimit[] = {
537 [PORT_TYPE_DCP] = IILIMIT_2000,
538 [PORT_TYPE_CDP] = IILIMIT_2000,
539 [PORT_TYPE_SDP] = IILIMIT_500,
540 [PORT_TYPE_NON_STANDARD] = IILIMIT_500
543 ret = bq24257_field_read(bq, F_LOOP_STATUS);
549 ret = bq24257_field_read(bq, F_IILIMIT);
556 * All USB ports should be able to handle 500mA. If not, DPM will lower
557 * the charging current to accommodate the power source. No need to set
558 * a lower IILIMIT value.
560 if (loop_status == LOOP_STATUS_IN_DPM && iilimit == IILIMIT_500)
563 ret = bq24257_field_read(bq, F_USB_DET);
569 ret = bq24257_field_write(bq, F_IILIMIT, new_iilimit[port_type]);
573 ret = bq24257_field_write(bq, F_TMR, SAFETY_TIMER_360);
577 ret = bq24257_field_write(bq, F_CLR_VDP, 1);
581 dev_dbg(bq->dev, "port/loop = %d/%d -> iilimit = %d\n",
582 port_type, loop_status, new_iilimit[port_type]);
587 dev_err(bq->dev, "%s: Error communicating with the chip.\n", __func__);
591 static void bq24257_iilimit_setup_work(struct work_struct *work)
593 struct bq24257_device *bq = container_of(work, struct bq24257_device,
594 iilimit_setup_work.work);
596 bq24257_iilimit_autoset(bq);
599 static void bq24257_handle_state_change(struct bq24257_device *bq,
600 struct bq24257_state *new_state)
603 struct bq24257_state old_state;
605 mutex_lock(&bq->lock);
606 old_state = bq->state;
607 mutex_unlock(&bq->lock);
610 * Handle BQ2425x state changes observing whether the D+/D- based input
611 * current limit autoset functionality is enabled.
613 if (!new_state->power_good) {
614 dev_dbg(bq->dev, "Power removed\n");
615 if (bq->iilimit_autoset_enable) {
616 cancel_delayed_work_sync(&bq->iilimit_setup_work);
618 /* activate D+/D- port detection algorithm */
619 ret = bq24257_field_write(bq, F_DPDM_EN, 1);
624 * When power is removed always return to the default input
625 * current limit as configured during probe.
627 ret = bq24257_field_write(bq, F_IILIMIT, bq->init_data.iilimit);
630 } else if (!old_state.power_good) {
631 dev_dbg(bq->dev, "Power inserted\n");
633 if (bq->iilimit_autoset_enable)
634 /* configure input current limit */
635 schedule_delayed_work(&bq->iilimit_setup_work,
636 msecs_to_jiffies(BQ24257_ILIM_SET_DELAY));
637 } else if (new_state->fault == FAULT_NO_BAT) {
638 dev_warn(bq->dev, "Battery removed\n");
639 } else if (new_state->fault == FAULT_TIMER) {
640 dev_err(bq->dev, "Safety timer expired! Battery dead?\n");
646 dev_err(bq->dev, "%s: Error communicating with the chip.\n", __func__);
649 static irqreturn_t bq24257_irq_handler_thread(int irq, void *private)
652 struct bq24257_device *bq = private;
653 struct bq24257_state state;
655 ret = bq24257_get_chip_state(bq, &state);
659 if (!bq24257_state_changed(bq, &state))
662 dev_dbg(bq->dev, "irq(state changed): status/fault/pg = %d/%d/%d\n",
663 state.status, state.fault, state.power_good);
665 bq24257_handle_state_change(bq, &state);
667 mutex_lock(&bq->lock);
669 mutex_unlock(&bq->lock);
671 power_supply_changed(bq->charger);
676 static int bq24257_hw_init(struct bq24257_device *bq)
680 struct bq24257_state state;
686 {F_ICHG, bq->init_data.ichg},
687 {F_VBAT, bq->init_data.vbat},
688 {F_ITERM, bq->init_data.iterm},
689 {F_VOVP, bq->init_data.vovp},
690 {F_VINDPM, bq->init_data.vindpm},
694 * Disable the watchdog timer to prevent the IC from going back to
695 * default settings after 50 seconds of I2C inactivity.
697 ret = bq24257_field_write(bq, F_WD_EN, 0);
701 /* configure the charge currents and voltages */
702 for (i = 0; i < ARRAY_SIZE(init_data); i++) {
703 ret = bq24257_field_write(bq, init_data[i].field,
709 ret = bq24257_get_chip_state(bq, &state);
713 mutex_lock(&bq->lock);
715 mutex_unlock(&bq->lock);
717 if (!bq->iilimit_autoset_enable) {
718 dev_dbg(bq->dev, "manually setting iilimit = %u\n",
719 bq->init_data.iilimit);
721 /* program fixed input current limit */
722 ret = bq24257_field_write(bq, F_IILIMIT,
723 bq->init_data.iilimit);
726 } else if (!state.power_good)
727 /* activate D+/D- detection algorithm */
728 ret = bq24257_field_write(bq, F_DPDM_EN, 1);
729 else if (state.fault != FAULT_NO_BAT)
730 ret = bq24257_iilimit_autoset(bq);
735 static enum power_supply_property bq24257_power_supply_props[] = {
736 POWER_SUPPLY_PROP_MANUFACTURER,
737 POWER_SUPPLY_PROP_MODEL_NAME,
738 POWER_SUPPLY_PROP_STATUS,
739 POWER_SUPPLY_PROP_ONLINE,
740 POWER_SUPPLY_PROP_HEALTH,
741 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
742 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
743 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
744 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
745 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
746 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
749 static char *bq24257_charger_supplied_to[] = {
753 static const struct power_supply_desc bq24257_power_supply_desc = {
754 .name = "bq24257-charger",
755 .type = POWER_SUPPLY_TYPE_USB,
756 .properties = bq24257_power_supply_props,
757 .num_properties = ARRAY_SIZE(bq24257_power_supply_props),
758 .get_property = bq24257_power_supply_get_property,
759 .set_property = bq24257_power_supply_set_property,
760 .property_is_writeable = bq24257_power_supply_property_is_writeable,
763 static ssize_t bq24257_show_ovp_voltage(struct device *dev,
764 struct device_attribute *attr,
767 struct power_supply *psy = dev_get_drvdata(dev);
768 struct bq24257_device *bq = power_supply_get_drvdata(psy);
770 return sysfs_emit(buf, "%u\n", bq24257_vovp_map[bq->init_data.vovp]);
773 static ssize_t bq24257_show_in_dpm_voltage(struct device *dev,
774 struct device_attribute *attr,
777 struct power_supply *psy = dev_get_drvdata(dev);
778 struct bq24257_device *bq = power_supply_get_drvdata(psy);
780 return sysfs_emit(buf, "%u\n", bq24257_vindpm_map[bq->init_data.vindpm]);
783 static ssize_t bq24257_sysfs_show_enable(struct device *dev,
784 struct device_attribute *attr,
787 struct power_supply *psy = dev_get_drvdata(dev);
788 struct bq24257_device *bq = power_supply_get_drvdata(psy);
791 if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
792 ret = bq24257_field_read(bq, F_HZ_MODE);
793 else if (strcmp(attr->attr.name, "sysoff_enable") == 0)
794 ret = bq24257_field_read(bq, F_SYSOFF);
801 return sysfs_emit(buf, "%d\n", ret);
804 static ssize_t bq24257_sysfs_set_enable(struct device *dev,
805 struct device_attribute *attr,
809 struct power_supply *psy = dev_get_drvdata(dev);
810 struct bq24257_device *bq = power_supply_get_drvdata(psy);
814 if (kstrtol(buf, 10, &val) < 0)
817 if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
818 ret = bq24257_field_write(bq, F_HZ_MODE, (bool)val);
819 else if (strcmp(attr->attr.name, "sysoff_enable") == 0)
820 ret = bq24257_field_write(bq, F_SYSOFF, (bool)val);
830 static DEVICE_ATTR(ovp_voltage, S_IRUGO, bq24257_show_ovp_voltage, NULL);
831 static DEVICE_ATTR(in_dpm_voltage, S_IRUGO, bq24257_show_in_dpm_voltage, NULL);
832 static DEVICE_ATTR(high_impedance_enable, S_IWUSR | S_IRUGO,
833 bq24257_sysfs_show_enable, bq24257_sysfs_set_enable);
834 static DEVICE_ATTR(sysoff_enable, S_IWUSR | S_IRUGO,
835 bq24257_sysfs_show_enable, bq24257_sysfs_set_enable);
837 static struct attribute *bq24257_charger_sysfs_attrs[] = {
838 &dev_attr_ovp_voltage.attr,
839 &dev_attr_in_dpm_voltage.attr,
840 &dev_attr_high_impedance_enable.attr,
841 &dev_attr_sysoff_enable.attr,
845 ATTRIBUTE_GROUPS(bq24257_charger_sysfs);
847 static int bq24257_power_supply_init(struct bq24257_device *bq)
849 struct power_supply_config psy_cfg = { .drv_data = bq, };
851 psy_cfg.attr_grp = bq24257_charger_sysfs_groups;
852 psy_cfg.supplied_to = bq24257_charger_supplied_to;
853 psy_cfg.num_supplicants = ARRAY_SIZE(bq24257_charger_supplied_to);
855 bq->charger = devm_power_supply_register(bq->dev,
856 &bq24257_power_supply_desc,
859 return PTR_ERR_OR_ZERO(bq->charger);
862 static void bq24257_pg_gpio_probe(struct bq24257_device *bq)
864 bq->pg = devm_gpiod_get_optional(bq->dev, BQ24257_PG_GPIO, GPIOD_IN);
866 if (PTR_ERR(bq->pg) == -EPROBE_DEFER) {
867 dev_info(bq->dev, "probe retry requested for PG pin\n");
869 } else if (IS_ERR(bq->pg)) {
870 dev_err(bq->dev, "error probing PG pin\n");
876 dev_dbg(bq->dev, "probed PG pin = %d\n", desc_to_gpio(bq->pg));
879 static int bq24257_fw_probe(struct bq24257_device *bq)
884 /* Required properties */
885 ret = device_property_read_u32(bq->dev, "ti,charge-current", &property);
889 bq->init_data.ichg = bq24257_find_idx(property, bq24257_ichg_map,
890 BQ24257_ICHG_MAP_SIZE);
892 ret = device_property_read_u32(bq->dev, "ti,battery-regulation-voltage",
897 bq->init_data.vbat = bq24257_find_idx(property, bq24257_vbat_map,
898 BQ24257_VBAT_MAP_SIZE);
900 ret = device_property_read_u32(bq->dev, "ti,termination-current",
905 bq->init_data.iterm = bq24257_find_idx(property, bq24257_iterm_map,
906 BQ24257_ITERM_MAP_SIZE);
908 /* Optional properties. If not provided use reasonable default. */
909 ret = device_property_read_u32(bq->dev, "ti,current-limit",
912 bq->iilimit_autoset_enable = true;
915 * Explicitly set a default value which will be needed for
916 * devices that don't support the automatic setting of the input
917 * current limit through the charger type detection mechanism.
919 bq->init_data.iilimit = IILIMIT_500;
921 bq->init_data.iilimit =
922 bq24257_find_idx(property,
924 BQ24257_IILIMIT_MAP_SIZE);
926 ret = device_property_read_u32(bq->dev, "ti,ovp-voltage",
929 bq->init_data.vovp = VOVP_6500;
931 bq->init_data.vovp = bq24257_find_idx(property,
933 BQ24257_VOVP_MAP_SIZE);
935 ret = device_property_read_u32(bq->dev, "ti,in-dpm-voltage",
938 bq->init_data.vindpm = VINDPM_4360;
940 bq->init_data.vindpm =
941 bq24257_find_idx(property,
943 BQ24257_VINDPM_MAP_SIZE);
948 static int bq24257_probe(struct i2c_client *client)
950 const struct i2c_device_id *id = i2c_client_get_device_id(client);
951 struct i2c_adapter *adapter = client->adapter;
952 struct device *dev = &client->dev;
953 const struct acpi_device_id *acpi_id;
954 struct bq24257_device *bq;
958 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
959 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
963 bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
970 if (ACPI_HANDLE(dev)) {
971 acpi_id = acpi_match_device(dev->driver->acpi_match_table,
974 dev_err(dev, "Failed to match ACPI device\n");
977 bq->chip = (enum bq2425x_chip)acpi_id->driver_data;
979 bq->chip = (enum bq2425x_chip)id->driver_data;
982 mutex_init(&bq->lock);
984 bq->rmap = devm_regmap_init_i2c(client, &bq24257_regmap_config);
985 if (IS_ERR(bq->rmap)) {
986 dev_err(dev, "failed to allocate register map\n");
987 return PTR_ERR(bq->rmap);
990 for (i = 0; i < ARRAY_SIZE(bq24257_reg_fields); i++) {
991 const struct reg_field *reg_fields = bq24257_reg_fields;
993 bq->rmap_fields[i] = devm_regmap_field_alloc(dev, bq->rmap,
995 if (IS_ERR(bq->rmap_fields[i])) {
996 dev_err(dev, "cannot allocate regmap field\n");
997 return PTR_ERR(bq->rmap_fields[i]);
1001 i2c_set_clientdata(client, bq);
1003 if (!dev->platform_data) {
1004 ret = bq24257_fw_probe(bq);
1006 dev_err(dev, "Cannot read device properties.\n");
1014 * The BQ24250 doesn't support the D+/D- based charger type detection
1015 * used for the automatic setting of the input current limit setting so
1016 * explicitly disable that feature.
1018 if (bq->chip == BQ24250)
1019 bq->iilimit_autoset_enable = false;
1021 if (bq->iilimit_autoset_enable)
1022 INIT_DELAYED_WORK(&bq->iilimit_setup_work,
1023 bq24257_iilimit_setup_work);
1026 * The BQ24250 doesn't have a dedicated Power Good (PG) pin so let's
1027 * not probe for it and instead use a SW-based approach to determine
1028 * the PG state. We also use a SW-based approach for all other devices
1029 * if the PG pin is either not defined or can't be probed.
1031 if (bq->chip != BQ24250)
1032 bq24257_pg_gpio_probe(bq);
1034 if (PTR_ERR(bq->pg) == -EPROBE_DEFER)
1035 return PTR_ERR(bq->pg);
1037 dev_info(bq->dev, "using SW-based power-good detection\n");
1039 /* reset all registers to defaults */
1040 ret = bq24257_field_write(bq, F_RESET, 1);
1045 * Put the RESET bit back to 0, in cache. For some reason the HW always
1046 * returns 1 on this bit, so this is the only way to avoid resetting the
1047 * chip every time we update another field in this register.
1049 ret = bq24257_field_write(bq, F_RESET, 0);
1053 ret = bq24257_hw_init(bq);
1055 dev_err(dev, "Cannot initialize the chip.\n");
1059 ret = bq24257_power_supply_init(bq);
1061 dev_err(dev, "Failed to register power supply\n");
1065 ret = devm_request_threaded_irq(dev, client->irq, NULL,
1066 bq24257_irq_handler_thread,
1067 IRQF_TRIGGER_FALLING |
1068 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1069 bq2425x_chip_name[bq->chip], bq);
1071 dev_err(dev, "Failed to request IRQ #%d\n", client->irq);
1078 static void bq24257_remove(struct i2c_client *client)
1080 struct bq24257_device *bq = i2c_get_clientdata(client);
1082 if (bq->iilimit_autoset_enable)
1083 cancel_delayed_work_sync(&bq->iilimit_setup_work);
1085 bq24257_field_write(bq, F_RESET, 1); /* reset to defaults */
1088 #ifdef CONFIG_PM_SLEEP
1089 static int bq24257_suspend(struct device *dev)
1091 struct bq24257_device *bq = dev_get_drvdata(dev);
1094 if (bq->iilimit_autoset_enable)
1095 cancel_delayed_work_sync(&bq->iilimit_setup_work);
1097 /* reset all registers to default (and activate standalone mode) */
1098 ret = bq24257_field_write(bq, F_RESET, 1);
1100 dev_err(bq->dev, "Cannot reset chip to standalone mode.\n");
1105 static int bq24257_resume(struct device *dev)
1108 struct bq24257_device *bq = dev_get_drvdata(dev);
1110 ret = regcache_drop_region(bq->rmap, BQ24257_REG_1, BQ24257_REG_7);
1114 ret = bq24257_field_write(bq, F_RESET, 0);
1118 ret = bq24257_hw_init(bq);
1120 dev_err(bq->dev, "Cannot init chip after resume.\n");
1124 /* signal userspace, maybe state changed while suspended */
1125 power_supply_changed(bq->charger);
1131 static const struct dev_pm_ops bq24257_pm = {
1132 SET_SYSTEM_SLEEP_PM_OPS(bq24257_suspend, bq24257_resume)
1135 static const struct i2c_device_id bq24257_i2c_ids[] = {
1136 { "bq24250", BQ24250 },
1137 { "bq24251", BQ24251 },
1138 { "bq24257", BQ24257 },
1141 MODULE_DEVICE_TABLE(i2c, bq24257_i2c_ids);
1143 static const struct of_device_id bq24257_of_match[] __maybe_unused = {
1144 { .compatible = "ti,bq24250", },
1145 { .compatible = "ti,bq24251", },
1146 { .compatible = "ti,bq24257", },
1149 MODULE_DEVICE_TABLE(of, bq24257_of_match);
1152 static const struct acpi_device_id bq24257_acpi_match[] = {
1153 { "BQ242500", BQ24250 },
1154 { "BQ242510", BQ24251 },
1155 { "BQ242570", BQ24257 },
1158 MODULE_DEVICE_TABLE(acpi, bq24257_acpi_match);
1161 static struct i2c_driver bq24257_driver = {
1163 .name = "bq24257-charger",
1164 .of_match_table = of_match_ptr(bq24257_of_match),
1165 .acpi_match_table = ACPI_PTR(bq24257_acpi_match),
1168 .probe = bq24257_probe,
1169 .remove = bq24257_remove,
1170 .id_table = bq24257_i2c_ids,
1172 module_i2c_driver(bq24257_driver);
1174 MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>");
1175 MODULE_DESCRIPTION("bq24257 charger driver");
1176 MODULE_LICENSE("GPL");