1 // SPDX-License-Identifier: GPL-2.0-only
3 * Driver for the TI bq24190 battery charger.
5 * Author: Mark A. Greer <mgreer@animalcreek.com>
8 #include <linux/module.h>
9 #include <linux/interrupt.h>
10 #include <linux/delay.h>
11 #include <linux/of_irq.h>
12 #include <linux/of_device.h>
13 #include <linux/pm_runtime.h>
14 #include <linux/power_supply.h>
15 #include <linux/power/bq24190_charger.h>
16 #include <linux/regulator/driver.h>
17 #include <linux/regulator/machine.h>
18 #include <linux/workqueue.h>
19 #include <linux/gpio.h>
20 #include <linux/i2c.h>
21 #include <linux/extcon-provider.h>
23 #define BQ24190_MANUFACTURER "Texas Instruments"
25 #define BQ24190_REG_ISC 0x00 /* Input Source Control */
26 #define BQ24190_REG_ISC_EN_HIZ_MASK BIT(7)
27 #define BQ24190_REG_ISC_EN_HIZ_SHIFT 7
28 #define BQ24190_REG_ISC_VINDPM_MASK (BIT(6) | BIT(5) | BIT(4) | \
30 #define BQ24190_REG_ISC_VINDPM_SHIFT 3
31 #define BQ24190_REG_ISC_IINLIM_MASK (BIT(2) | BIT(1) | BIT(0))
32 #define BQ24190_REG_ISC_IINLIM_SHIFT 0
34 #define BQ24190_REG_POC 0x01 /* Power-On Configuration */
35 #define BQ24190_REG_POC_RESET_MASK BIT(7)
36 #define BQ24190_REG_POC_RESET_SHIFT 7
37 #define BQ24190_REG_POC_WDT_RESET_MASK BIT(6)
38 #define BQ24190_REG_POC_WDT_RESET_SHIFT 6
39 #define BQ24190_REG_POC_CHG_CONFIG_MASK (BIT(5) | BIT(4))
40 #define BQ24190_REG_POC_CHG_CONFIG_SHIFT 4
41 #define BQ24190_REG_POC_CHG_CONFIG_DISABLE 0x0
42 #define BQ24190_REG_POC_CHG_CONFIG_CHARGE 0x1
43 #define BQ24190_REG_POC_CHG_CONFIG_OTG 0x2
44 #define BQ24190_REG_POC_SYS_MIN_MASK (BIT(3) | BIT(2) | BIT(1))
45 #define BQ24190_REG_POC_SYS_MIN_SHIFT 1
46 #define BQ24190_REG_POC_SYS_MIN_MIN 3000
47 #define BQ24190_REG_POC_SYS_MIN_MAX 3700
48 #define BQ24190_REG_POC_BOOST_LIM_MASK BIT(0)
49 #define BQ24190_REG_POC_BOOST_LIM_SHIFT 0
51 #define BQ24190_REG_CCC 0x02 /* Charge Current Control */
52 #define BQ24190_REG_CCC_ICHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
53 BIT(4) | BIT(3) | BIT(2))
54 #define BQ24190_REG_CCC_ICHG_SHIFT 2
55 #define BQ24190_REG_CCC_FORCE_20PCT_MASK BIT(0)
56 #define BQ24190_REG_CCC_FORCE_20PCT_SHIFT 0
58 #define BQ24190_REG_PCTCC 0x03 /* Pre-charge/Termination Current Cntl */
59 #define BQ24190_REG_PCTCC_IPRECHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
61 #define BQ24190_REG_PCTCC_IPRECHG_SHIFT 4
62 #define BQ24190_REG_PCTCC_IPRECHG_MIN 128
63 #define BQ24190_REG_PCTCC_IPRECHG_MAX 2048
64 #define BQ24190_REG_PCTCC_ITERM_MASK (BIT(3) | BIT(2) | BIT(1) | \
66 #define BQ24190_REG_PCTCC_ITERM_SHIFT 0
67 #define BQ24190_REG_PCTCC_ITERM_MIN 128
68 #define BQ24190_REG_PCTCC_ITERM_MAX 2048
70 #define BQ24190_REG_CVC 0x04 /* Charge Voltage Control */
71 #define BQ24190_REG_CVC_VREG_MASK (BIT(7) | BIT(6) | BIT(5) | \
72 BIT(4) | BIT(3) | BIT(2))
73 #define BQ24190_REG_CVC_VREG_SHIFT 2
74 #define BQ24190_REG_CVC_BATLOWV_MASK BIT(1)
75 #define BQ24190_REG_CVC_BATLOWV_SHIFT 1
76 #define BQ24190_REG_CVC_VRECHG_MASK BIT(0)
77 #define BQ24190_REG_CVC_VRECHG_SHIFT 0
79 #define BQ24190_REG_CTTC 0x05 /* Charge Term/Timer Control */
80 #define BQ24190_REG_CTTC_EN_TERM_MASK BIT(7)
81 #define BQ24190_REG_CTTC_EN_TERM_SHIFT 7
82 #define BQ24190_REG_CTTC_TERM_STAT_MASK BIT(6)
83 #define BQ24190_REG_CTTC_TERM_STAT_SHIFT 6
84 #define BQ24190_REG_CTTC_WATCHDOG_MASK (BIT(5) | BIT(4))
85 #define BQ24190_REG_CTTC_WATCHDOG_SHIFT 4
86 #define BQ24190_REG_CTTC_EN_TIMER_MASK BIT(3)
87 #define BQ24190_REG_CTTC_EN_TIMER_SHIFT 3
88 #define BQ24190_REG_CTTC_CHG_TIMER_MASK (BIT(2) | BIT(1))
89 #define BQ24190_REG_CTTC_CHG_TIMER_SHIFT 1
90 #define BQ24190_REG_CTTC_JEITA_ISET_MASK BIT(0)
91 #define BQ24190_REG_CTTC_JEITA_ISET_SHIFT 0
93 #define BQ24190_REG_ICTRC 0x06 /* IR Comp/Thermal Regulation Control */
94 #define BQ24190_REG_ICTRC_BAT_COMP_MASK (BIT(7) | BIT(6) | BIT(5))
95 #define BQ24190_REG_ICTRC_BAT_COMP_SHIFT 5
96 #define BQ24190_REG_ICTRC_VCLAMP_MASK (BIT(4) | BIT(3) | BIT(2))
97 #define BQ24190_REG_ICTRC_VCLAMP_SHIFT 2
98 #define BQ24190_REG_ICTRC_TREG_MASK (BIT(1) | BIT(0))
99 #define BQ24190_REG_ICTRC_TREG_SHIFT 0
101 #define BQ24190_REG_MOC 0x07 /* Misc. Operation Control */
102 #define BQ24190_REG_MOC_DPDM_EN_MASK BIT(7)
103 #define BQ24190_REG_MOC_DPDM_EN_SHIFT 7
104 #define BQ24190_REG_MOC_TMR2X_EN_MASK BIT(6)
105 #define BQ24190_REG_MOC_TMR2X_EN_SHIFT 6
106 #define BQ24190_REG_MOC_BATFET_DISABLE_MASK BIT(5)
107 #define BQ24190_REG_MOC_BATFET_DISABLE_SHIFT 5
108 #define BQ24190_REG_MOC_JEITA_VSET_MASK BIT(4)
109 #define BQ24190_REG_MOC_JEITA_VSET_SHIFT 4
110 #define BQ24190_REG_MOC_INT_MASK_MASK (BIT(1) | BIT(0))
111 #define BQ24190_REG_MOC_INT_MASK_SHIFT 0
113 #define BQ24190_REG_SS 0x08 /* System Status */
114 #define BQ24190_REG_SS_VBUS_STAT_MASK (BIT(7) | BIT(6))
115 #define BQ24190_REG_SS_VBUS_STAT_SHIFT 6
116 #define BQ24190_REG_SS_CHRG_STAT_MASK (BIT(5) | BIT(4))
117 #define BQ24190_REG_SS_CHRG_STAT_SHIFT 4
118 #define BQ24190_REG_SS_DPM_STAT_MASK BIT(3)
119 #define BQ24190_REG_SS_DPM_STAT_SHIFT 3
120 #define BQ24190_REG_SS_PG_STAT_MASK BIT(2)
121 #define BQ24190_REG_SS_PG_STAT_SHIFT 2
122 #define BQ24190_REG_SS_THERM_STAT_MASK BIT(1)
123 #define BQ24190_REG_SS_THERM_STAT_SHIFT 1
124 #define BQ24190_REG_SS_VSYS_STAT_MASK BIT(0)
125 #define BQ24190_REG_SS_VSYS_STAT_SHIFT 0
127 #define BQ24190_REG_F 0x09 /* Fault */
128 #define BQ24190_REG_F_WATCHDOG_FAULT_MASK BIT(7)
129 #define BQ24190_REG_F_WATCHDOG_FAULT_SHIFT 7
130 #define BQ24190_REG_F_BOOST_FAULT_MASK BIT(6)
131 #define BQ24190_REG_F_BOOST_FAULT_SHIFT 6
132 #define BQ24190_REG_F_CHRG_FAULT_MASK (BIT(5) | BIT(4))
133 #define BQ24190_REG_F_CHRG_FAULT_SHIFT 4
134 #define BQ24190_REG_F_BAT_FAULT_MASK BIT(3)
135 #define BQ24190_REG_F_BAT_FAULT_SHIFT 3
136 #define BQ24190_REG_F_NTC_FAULT_MASK (BIT(2) | BIT(1) | BIT(0))
137 #define BQ24190_REG_F_NTC_FAULT_SHIFT 0
139 #define BQ24190_REG_VPRS 0x0A /* Vendor/Part/Revision Status */
140 #define BQ24190_REG_VPRS_PN_MASK (BIT(5) | BIT(4) | BIT(3))
141 #define BQ24190_REG_VPRS_PN_SHIFT 3
142 #define BQ24190_REG_VPRS_PN_24190 0x4
143 #define BQ24190_REG_VPRS_PN_24192 0x5 /* Also 24193, 24196 */
144 #define BQ24190_REG_VPRS_PN_24192I 0x3
145 #define BQ24190_REG_VPRS_TS_PROFILE_MASK BIT(2)
146 #define BQ24190_REG_VPRS_TS_PROFILE_SHIFT 2
147 #define BQ24190_REG_VPRS_DEV_REG_MASK (BIT(1) | BIT(0))
148 #define BQ24190_REG_VPRS_DEV_REG_SHIFT 0
151 * The FAULT register is latched by the bq24190 (except for NTC_FAULT)
152 * so the first read after a fault returns the latched value and subsequent
153 * reads return the current value. In order to return the fault status
154 * to the user, have the interrupt handler save the reg's value and retrieve
155 * it in the appropriate health/status routine.
157 struct bq24190_dev_info {
158 struct i2c_client *client;
160 struct extcon_dev *edev;
161 struct power_supply *charger;
162 struct power_supply *battery;
163 struct delayed_work input_current_limit_work;
164 char model_name[I2C_NAME_SIZE];
170 struct mutex f_reg_lock;
176 static const unsigned int bq24190_usb_extcon_cable[] = {
182 * The tables below provide a 2-way mapping for the value that goes in
183 * the register field and the real-world value that it represents.
184 * The index of the array is the value that goes in the register; the
185 * number at that index in the array is the real-world value that it
189 /* REG00[2:0] (IINLIM) in uAh */
190 static const int bq24190_isc_iinlim_values[] = {
191 100000, 150000, 500000, 900000, 1200000, 1500000, 2000000, 3000000
194 /* REG02[7:2] (ICHG) in uAh */
195 static const int bq24190_ccc_ichg_values[] = {
196 512000, 576000, 640000, 704000, 768000, 832000, 896000, 960000,
197 1024000, 1088000, 1152000, 1216000, 1280000, 1344000, 1408000, 1472000,
198 1536000, 1600000, 1664000, 1728000, 1792000, 1856000, 1920000, 1984000,
199 2048000, 2112000, 2176000, 2240000, 2304000, 2368000, 2432000, 2496000,
200 2560000, 2624000, 2688000, 2752000, 2816000, 2880000, 2944000, 3008000,
201 3072000, 3136000, 3200000, 3264000, 3328000, 3392000, 3456000, 3520000,
202 3584000, 3648000, 3712000, 3776000, 3840000, 3904000, 3968000, 4032000,
203 4096000, 4160000, 4224000, 4288000, 4352000, 4416000, 4480000, 4544000
206 /* REG04[7:2] (VREG) in uV */
207 static const int bq24190_cvc_vreg_values[] = {
208 3504000, 3520000, 3536000, 3552000, 3568000, 3584000, 3600000, 3616000,
209 3632000, 3648000, 3664000, 3680000, 3696000, 3712000, 3728000, 3744000,
210 3760000, 3776000, 3792000, 3808000, 3824000, 3840000, 3856000, 3872000,
211 3888000, 3904000, 3920000, 3936000, 3952000, 3968000, 3984000, 4000000,
212 4016000, 4032000, 4048000, 4064000, 4080000, 4096000, 4112000, 4128000,
213 4144000, 4160000, 4176000, 4192000, 4208000, 4224000, 4240000, 4256000,
214 4272000, 4288000, 4304000, 4320000, 4336000, 4352000, 4368000, 4384000,
218 /* REG06[1:0] (TREG) in tenths of degrees Celsius */
219 static const int bq24190_ictrc_treg_values[] = {
224 * Return the index in 'tbl' of greatest value that is less than or equal to
225 * 'val'. The index range returned is 0 to 'tbl_size' - 1. Assumes that
226 * the values in 'tbl' are sorted from smallest to largest and 'tbl_size'
229 static u8 bq24190_find_idx(const int tbl[], int tbl_size, int v)
233 for (i = 1; i < tbl_size; i++)
240 /* Basic driver I/O routines */
242 static int bq24190_read(struct bq24190_dev_info *bdi, u8 reg, u8 *data)
246 ret = i2c_smbus_read_byte_data(bdi->client, reg);
254 static int bq24190_write(struct bq24190_dev_info *bdi, u8 reg, u8 data)
256 return i2c_smbus_write_byte_data(bdi->client, reg, data);
259 static int bq24190_read_mask(struct bq24190_dev_info *bdi, u8 reg,
260 u8 mask, u8 shift, u8 *data)
265 ret = bq24190_read(bdi, reg, &v);
276 static int bq24190_write_mask(struct bq24190_dev_info *bdi, u8 reg,
277 u8 mask, u8 shift, u8 data)
282 ret = bq24190_read(bdi, reg, &v);
287 v |= ((data << shift) & mask);
289 return bq24190_write(bdi, reg, v);
292 static int bq24190_get_field_val(struct bq24190_dev_info *bdi,
293 u8 reg, u8 mask, u8 shift,
294 const int tbl[], int tbl_size,
300 ret = bq24190_read_mask(bdi, reg, mask, shift, &v);
304 v = (v >= tbl_size) ? (tbl_size - 1) : v;
310 static int bq24190_set_field_val(struct bq24190_dev_info *bdi,
311 u8 reg, u8 mask, u8 shift,
312 const int tbl[], int tbl_size,
317 idx = bq24190_find_idx(tbl, tbl_size, val);
319 return bq24190_write_mask(bdi, reg, mask, shift, idx);
324 * There are a numerous options that are configurable on the bq24190
325 * that go well beyond what the power_supply properties provide access to.
326 * Provide sysfs access to them so they can be examined and possibly modified
327 * on the fly. They will be provided for the charger power_supply object only
328 * and will be prefixed by 'f_' to make them easier to recognize.
331 #define BQ24190_SYSFS_FIELD(_name, r, f, m, store) \
333 .attr = __ATTR(f_##_name, m, bq24190_sysfs_show, store), \
334 .reg = BQ24190_REG_##r, \
335 .mask = BQ24190_REG_##r##_##f##_MASK, \
336 .shift = BQ24190_REG_##r##_##f##_SHIFT, \
339 #define BQ24190_SYSFS_FIELD_RW(_name, r, f) \
340 BQ24190_SYSFS_FIELD(_name, r, f, S_IWUSR | S_IRUGO, \
343 #define BQ24190_SYSFS_FIELD_RO(_name, r, f) \
344 BQ24190_SYSFS_FIELD(_name, r, f, S_IRUGO, NULL)
346 static ssize_t bq24190_sysfs_show(struct device *dev,
347 struct device_attribute *attr, char *buf);
348 static ssize_t bq24190_sysfs_store(struct device *dev,
349 struct device_attribute *attr, const char *buf, size_t count);
351 struct bq24190_sysfs_field_info {
352 struct device_attribute attr;
358 /* On i386 ptrace-abi.h defines SS that breaks the macro calls below. */
361 static struct bq24190_sysfs_field_info bq24190_sysfs_field_tbl[] = {
362 /* sysfs name reg field in reg */
363 BQ24190_SYSFS_FIELD_RW(en_hiz, ISC, EN_HIZ),
364 BQ24190_SYSFS_FIELD_RW(vindpm, ISC, VINDPM),
365 BQ24190_SYSFS_FIELD_RW(iinlim, ISC, IINLIM),
366 BQ24190_SYSFS_FIELD_RW(chg_config, POC, CHG_CONFIG),
367 BQ24190_SYSFS_FIELD_RW(sys_min, POC, SYS_MIN),
368 BQ24190_SYSFS_FIELD_RW(boost_lim, POC, BOOST_LIM),
369 BQ24190_SYSFS_FIELD_RW(ichg, CCC, ICHG),
370 BQ24190_SYSFS_FIELD_RW(force_20_pct, CCC, FORCE_20PCT),
371 BQ24190_SYSFS_FIELD_RW(iprechg, PCTCC, IPRECHG),
372 BQ24190_SYSFS_FIELD_RW(iterm, PCTCC, ITERM),
373 BQ24190_SYSFS_FIELD_RW(vreg, CVC, VREG),
374 BQ24190_SYSFS_FIELD_RW(batlowv, CVC, BATLOWV),
375 BQ24190_SYSFS_FIELD_RW(vrechg, CVC, VRECHG),
376 BQ24190_SYSFS_FIELD_RW(en_term, CTTC, EN_TERM),
377 BQ24190_SYSFS_FIELD_RW(term_stat, CTTC, TERM_STAT),
378 BQ24190_SYSFS_FIELD_RO(watchdog, CTTC, WATCHDOG),
379 BQ24190_SYSFS_FIELD_RW(en_timer, CTTC, EN_TIMER),
380 BQ24190_SYSFS_FIELD_RW(chg_timer, CTTC, CHG_TIMER),
381 BQ24190_SYSFS_FIELD_RW(jeta_iset, CTTC, JEITA_ISET),
382 BQ24190_SYSFS_FIELD_RW(bat_comp, ICTRC, BAT_COMP),
383 BQ24190_SYSFS_FIELD_RW(vclamp, ICTRC, VCLAMP),
384 BQ24190_SYSFS_FIELD_RW(treg, ICTRC, TREG),
385 BQ24190_SYSFS_FIELD_RW(dpdm_en, MOC, DPDM_EN),
386 BQ24190_SYSFS_FIELD_RW(tmr2x_en, MOC, TMR2X_EN),
387 BQ24190_SYSFS_FIELD_RW(batfet_disable, MOC, BATFET_DISABLE),
388 BQ24190_SYSFS_FIELD_RW(jeita_vset, MOC, JEITA_VSET),
389 BQ24190_SYSFS_FIELD_RO(int_mask, MOC, INT_MASK),
390 BQ24190_SYSFS_FIELD_RO(vbus_stat, SS, VBUS_STAT),
391 BQ24190_SYSFS_FIELD_RO(chrg_stat, SS, CHRG_STAT),
392 BQ24190_SYSFS_FIELD_RO(dpm_stat, SS, DPM_STAT),
393 BQ24190_SYSFS_FIELD_RO(pg_stat, SS, PG_STAT),
394 BQ24190_SYSFS_FIELD_RO(therm_stat, SS, THERM_STAT),
395 BQ24190_SYSFS_FIELD_RO(vsys_stat, SS, VSYS_STAT),
396 BQ24190_SYSFS_FIELD_RO(watchdog_fault, F, WATCHDOG_FAULT),
397 BQ24190_SYSFS_FIELD_RO(boost_fault, F, BOOST_FAULT),
398 BQ24190_SYSFS_FIELD_RO(chrg_fault, F, CHRG_FAULT),
399 BQ24190_SYSFS_FIELD_RO(bat_fault, F, BAT_FAULT),
400 BQ24190_SYSFS_FIELD_RO(ntc_fault, F, NTC_FAULT),
401 BQ24190_SYSFS_FIELD_RO(pn, VPRS, PN),
402 BQ24190_SYSFS_FIELD_RO(ts_profile, VPRS, TS_PROFILE),
403 BQ24190_SYSFS_FIELD_RO(dev_reg, VPRS, DEV_REG),
406 static struct attribute *
407 bq24190_sysfs_attrs[ARRAY_SIZE(bq24190_sysfs_field_tbl) + 1];
409 ATTRIBUTE_GROUPS(bq24190_sysfs);
411 static void bq24190_sysfs_init_attrs(void)
413 int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
415 for (i = 0; i < limit; i++)
416 bq24190_sysfs_attrs[i] = &bq24190_sysfs_field_tbl[i].attr.attr;
418 bq24190_sysfs_attrs[limit] = NULL; /* Has additional entry for this */
421 static struct bq24190_sysfs_field_info *bq24190_sysfs_field_lookup(
424 int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
426 for (i = 0; i < limit; i++)
427 if (!strcmp(name, bq24190_sysfs_field_tbl[i].attr.attr.name))
433 return &bq24190_sysfs_field_tbl[i];
436 static ssize_t bq24190_sysfs_show(struct device *dev,
437 struct device_attribute *attr, char *buf)
439 struct power_supply *psy = dev_get_drvdata(dev);
440 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
441 struct bq24190_sysfs_field_info *info;
446 info = bq24190_sysfs_field_lookup(attr->attr.name);
450 ret = pm_runtime_get_sync(bdi->dev);
454 ret = bq24190_read_mask(bdi, info->reg, info->mask, info->shift, &v);
458 count = scnprintf(buf, PAGE_SIZE, "%hhx\n", v);
460 pm_runtime_mark_last_busy(bdi->dev);
461 pm_runtime_put_autosuspend(bdi->dev);
466 static ssize_t bq24190_sysfs_store(struct device *dev,
467 struct device_attribute *attr, const char *buf, size_t count)
469 struct power_supply *psy = dev_get_drvdata(dev);
470 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
471 struct bq24190_sysfs_field_info *info;
475 info = bq24190_sysfs_field_lookup(attr->attr.name);
479 ret = kstrtou8(buf, 0, &v);
483 ret = pm_runtime_get_sync(bdi->dev);
485 pm_runtime_put_noidle(bdi->dev);
489 ret = bq24190_write_mask(bdi, info->reg, info->mask, info->shift, v);
493 pm_runtime_mark_last_busy(bdi->dev);
494 pm_runtime_put_autosuspend(bdi->dev);
500 #ifdef CONFIG_REGULATOR
501 static int bq24190_set_charge_mode(struct regulator_dev *dev, u8 val)
503 struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
506 ret = pm_runtime_get_sync(bdi->dev);
508 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
509 pm_runtime_put_noidle(bdi->dev);
513 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
514 BQ24190_REG_POC_CHG_CONFIG_MASK,
515 BQ24190_REG_POC_CHG_CONFIG_SHIFT, val);
517 pm_runtime_mark_last_busy(bdi->dev);
518 pm_runtime_put_autosuspend(bdi->dev);
523 static int bq24190_vbus_enable(struct regulator_dev *dev)
525 return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_OTG);
528 static int bq24190_vbus_disable(struct regulator_dev *dev)
530 return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_CHARGE);
533 static int bq24190_vbus_is_enabled(struct regulator_dev *dev)
535 struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
539 ret = pm_runtime_get_sync(bdi->dev);
541 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
542 pm_runtime_put_noidle(bdi->dev);
546 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
547 BQ24190_REG_POC_CHG_CONFIG_MASK,
548 BQ24190_REG_POC_CHG_CONFIG_SHIFT, &val);
550 pm_runtime_mark_last_busy(bdi->dev);
551 pm_runtime_put_autosuspend(bdi->dev);
553 return ret ? ret : val == BQ24190_REG_POC_CHG_CONFIG_OTG;
556 static const struct regulator_ops bq24190_vbus_ops = {
557 .enable = bq24190_vbus_enable,
558 .disable = bq24190_vbus_disable,
559 .is_enabled = bq24190_vbus_is_enabled,
562 static const struct regulator_desc bq24190_vbus_desc = {
563 .name = "usb_otg_vbus",
564 .of_match = "usb-otg-vbus",
565 .type = REGULATOR_VOLTAGE,
566 .owner = THIS_MODULE,
567 .ops = &bq24190_vbus_ops,
572 static const struct regulator_init_data bq24190_vbus_init_data = {
574 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
578 static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
580 struct bq24190_platform_data *pdata = bdi->dev->platform_data;
581 struct regulator_config cfg = { };
582 struct regulator_dev *reg;
586 if (pdata && pdata->regulator_init_data)
587 cfg.init_data = pdata->regulator_init_data;
589 cfg.init_data = &bq24190_vbus_init_data;
590 cfg.driver_data = bdi;
591 reg = devm_regulator_register(bdi->dev, &bq24190_vbus_desc, &cfg);
594 dev_err(bdi->dev, "Can't register regulator: %d\n", ret);
600 static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
606 static int bq24190_set_config(struct bq24190_dev_info *bdi)
611 ret = bq24190_read(bdi, BQ24190_REG_CTTC, &v);
615 bdi->watchdog = ((v & BQ24190_REG_CTTC_WATCHDOG_MASK) >>
616 BQ24190_REG_CTTC_WATCHDOG_SHIFT);
619 * According to the "Host Mode and default Mode" section of the
620 * manual, a write to any register causes the bq24190 to switch
621 * from default mode to host mode. It will switch back to default
622 * mode after a WDT timeout unless the WDT is turned off as well.
623 * So, by simply turning off the WDT, we accomplish both with the
626 v &= ~BQ24190_REG_CTTC_WATCHDOG_MASK;
628 ret = bq24190_write(bdi, BQ24190_REG_CTTC, v);
633 v = bdi->sys_min / 100 - 30; // manual section 9.5.1.2, table 9
634 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
635 BQ24190_REG_POC_SYS_MIN_MASK,
636 BQ24190_REG_POC_SYS_MIN_SHIFT,
643 v = bdi->iprechg / 128 - 1; // manual section 9.5.1.4, table 11
644 ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
645 BQ24190_REG_PCTCC_IPRECHG_MASK,
646 BQ24190_REG_PCTCC_IPRECHG_SHIFT,
653 v = bdi->iterm / 128 - 1; // manual section 9.5.1.4, table 11
654 ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
655 BQ24190_REG_PCTCC_ITERM_MASK,
656 BQ24190_REG_PCTCC_ITERM_SHIFT,
665 static int bq24190_register_reset(struct bq24190_dev_info *bdi)
667 int ret, limit = 100;
671 * This prop. can be passed on device instantiation from platform code:
672 * struct property_entry pe[] =
673 * { PROPERTY_ENTRY_BOOL("disable-reset"), ... };
674 * struct i2c_board_info bi =
675 * { .type = "bq24190", .addr = 0x6b, .properties = pe, .irq = irq };
676 * struct i2c_adapter ad = { ... };
677 * i2c_add_adapter(&ad);
678 * i2c_new_client_device(&ad, &bi);
680 if (device_property_read_bool(bdi->dev, "disable-reset"))
683 /* Reset the registers */
684 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
685 BQ24190_REG_POC_RESET_MASK,
686 BQ24190_REG_POC_RESET_SHIFT,
691 /* Reset bit will be cleared by hardware so poll until it is */
693 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
694 BQ24190_REG_POC_RESET_MASK,
695 BQ24190_REG_POC_RESET_SHIFT,
703 usleep_range(100, 200);
709 /* Charger power supply property routines */
711 static int bq24190_charger_get_charge_type(struct bq24190_dev_info *bdi,
712 union power_supply_propval *val)
717 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
718 BQ24190_REG_POC_CHG_CONFIG_MASK,
719 BQ24190_REG_POC_CHG_CONFIG_SHIFT,
724 /* If POC[CHG_CONFIG] (REG01[5:4]) == 0, charge is disabled */
726 type = POWER_SUPPLY_CHARGE_TYPE_NONE;
728 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
729 BQ24190_REG_CCC_FORCE_20PCT_MASK,
730 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
735 type = (v) ? POWER_SUPPLY_CHARGE_TYPE_TRICKLE :
736 POWER_SUPPLY_CHARGE_TYPE_FAST;
744 static int bq24190_charger_set_charge_type(struct bq24190_dev_info *bdi,
745 const union power_supply_propval *val)
747 u8 chg_config, force_20pct, en_term;
751 * According to the "Termination when REG02[0] = 1" section of
752 * the bq24190 manual, the trickle charge could be less than the
753 * termination current so it recommends turning off the termination
756 * Note: AFAICT from the datasheet, the user will have to manually
757 * turn off the charging when in 20% mode. If its not turned off,
758 * there could be battery damage. So, use this mode at your own risk.
760 switch (val->intval) {
761 case POWER_SUPPLY_CHARGE_TYPE_NONE:
764 case POWER_SUPPLY_CHARGE_TYPE_TRICKLE:
769 case POWER_SUPPLY_CHARGE_TYPE_FAST:
778 if (chg_config) { /* Enabling the charger */
779 ret = bq24190_write_mask(bdi, BQ24190_REG_CCC,
780 BQ24190_REG_CCC_FORCE_20PCT_MASK,
781 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
786 ret = bq24190_write_mask(bdi, BQ24190_REG_CTTC,
787 BQ24190_REG_CTTC_EN_TERM_MASK,
788 BQ24190_REG_CTTC_EN_TERM_SHIFT,
794 return bq24190_write_mask(bdi, BQ24190_REG_POC,
795 BQ24190_REG_POC_CHG_CONFIG_MASK,
796 BQ24190_REG_POC_CHG_CONFIG_SHIFT, chg_config);
799 static int bq24190_charger_get_health(struct bq24190_dev_info *bdi,
800 union power_supply_propval *val)
805 mutex_lock(&bdi->f_reg_lock);
807 mutex_unlock(&bdi->f_reg_lock);
809 if (v & BQ24190_REG_F_NTC_FAULT_MASK) {
810 switch (v >> BQ24190_REG_F_NTC_FAULT_SHIFT & 0x7) {
811 case 0x1: /* TS1 Cold */
812 case 0x3: /* TS2 Cold */
813 case 0x5: /* Both Cold */
814 health = POWER_SUPPLY_HEALTH_COLD;
816 case 0x2: /* TS1 Hot */
817 case 0x4: /* TS2 Hot */
818 case 0x6: /* Both Hot */
819 health = POWER_SUPPLY_HEALTH_OVERHEAT;
822 health = POWER_SUPPLY_HEALTH_UNKNOWN;
824 } else if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
825 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
826 } else if (v & BQ24190_REG_F_CHRG_FAULT_MASK) {
827 switch (v >> BQ24190_REG_F_CHRG_FAULT_SHIFT & 0x3) {
828 case 0x1: /* Input Fault (VBUS OVP or VBAT<VBUS<3.8V) */
830 * This could be over-voltage or under-voltage
831 * and there's no way to tell which. Instead
832 * of looking foolish and returning 'OVERVOLTAGE'
833 * when its really under-voltage, just return
836 health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
838 case 0x2: /* Thermal Shutdown */
839 health = POWER_SUPPLY_HEALTH_OVERHEAT;
841 case 0x3: /* Charge Safety Timer Expiration */
842 health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
844 default: /* prevent compiler warning */
847 } else if (v & BQ24190_REG_F_BOOST_FAULT_MASK) {
849 * This could be over-current or over-voltage but there's
850 * no way to tell which. Return 'OVERVOLTAGE' since there
851 * isn't an 'OVERCURRENT' value defined that we can return
852 * even if it was over-current.
854 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
856 health = POWER_SUPPLY_HEALTH_GOOD;
859 val->intval = health;
864 static int bq24190_charger_get_online(struct bq24190_dev_info *bdi,
865 union power_supply_propval *val)
867 u8 pg_stat, batfet_disable;
870 ret = bq24190_read_mask(bdi, BQ24190_REG_SS,
871 BQ24190_REG_SS_PG_STAT_MASK,
872 BQ24190_REG_SS_PG_STAT_SHIFT, &pg_stat);
876 ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
877 BQ24190_REG_MOC_BATFET_DISABLE_MASK,
878 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
882 val->intval = pg_stat && !batfet_disable;
887 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
888 const union power_supply_propval *val);
889 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
890 union power_supply_propval *val);
891 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
892 union power_supply_propval *val);
893 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
894 const union power_supply_propval *val);
896 static int bq24190_charger_set_online(struct bq24190_dev_info *bdi,
897 const union power_supply_propval *val)
899 return bq24190_battery_set_online(bdi, val);
902 static int bq24190_charger_get_status(struct bq24190_dev_info *bdi,
903 union power_supply_propval *val)
905 return bq24190_battery_get_status(bdi, val);
908 static int bq24190_charger_get_temp_alert_max(struct bq24190_dev_info *bdi,
909 union power_supply_propval *val)
911 return bq24190_battery_get_temp_alert_max(bdi, val);
914 static int bq24190_charger_set_temp_alert_max(struct bq24190_dev_info *bdi,
915 const union power_supply_propval *val)
917 return bq24190_battery_set_temp_alert_max(bdi, val);
920 static int bq24190_charger_get_precharge(struct bq24190_dev_info *bdi,
921 union power_supply_propval *val)
926 ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
927 BQ24190_REG_PCTCC_IPRECHG_MASK,
928 BQ24190_REG_PCTCC_IPRECHG_SHIFT, &v);
932 val->intval = ++v * 128 * 1000;
936 static int bq24190_charger_get_charge_term(struct bq24190_dev_info *bdi,
937 union power_supply_propval *val)
942 ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
943 BQ24190_REG_PCTCC_ITERM_MASK,
944 BQ24190_REG_PCTCC_ITERM_SHIFT, &v);
948 val->intval = ++v * 128 * 1000;
952 static int bq24190_charger_get_current(struct bq24190_dev_info *bdi,
953 union power_supply_propval *val)
958 ret = bq24190_get_field_val(bdi, BQ24190_REG_CCC,
959 BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
960 bq24190_ccc_ichg_values,
961 ARRAY_SIZE(bq24190_ccc_ichg_values), &curr);
965 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
966 BQ24190_REG_CCC_FORCE_20PCT_MASK,
967 BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
971 /* If FORCE_20PCT is enabled, then current is 20% of ICHG value */
979 static int bq24190_charger_get_current_max(struct bq24190_dev_info *bdi,
980 union power_supply_propval *val)
982 int idx = ARRAY_SIZE(bq24190_ccc_ichg_values) - 1;
984 val->intval = bq24190_ccc_ichg_values[idx];
988 static int bq24190_charger_set_current(struct bq24190_dev_info *bdi,
989 const union power_supply_propval *val)
992 int ret, curr = val->intval;
994 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
995 BQ24190_REG_CCC_FORCE_20PCT_MASK,
996 BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
1000 /* If FORCE_20PCT is enabled, have to multiply value passed in by 5 */
1004 return bq24190_set_field_val(bdi, BQ24190_REG_CCC,
1005 BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
1006 bq24190_ccc_ichg_values,
1007 ARRAY_SIZE(bq24190_ccc_ichg_values), curr);
1010 static int bq24190_charger_get_voltage(struct bq24190_dev_info *bdi,
1011 union power_supply_propval *val)
1015 ret = bq24190_get_field_val(bdi, BQ24190_REG_CVC,
1016 BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
1017 bq24190_cvc_vreg_values,
1018 ARRAY_SIZE(bq24190_cvc_vreg_values), &voltage);
1022 val->intval = voltage;
1026 static int bq24190_charger_get_voltage_max(struct bq24190_dev_info *bdi,
1027 union power_supply_propval *val)
1029 int idx = ARRAY_SIZE(bq24190_cvc_vreg_values) - 1;
1031 val->intval = bq24190_cvc_vreg_values[idx];
1035 static int bq24190_charger_set_voltage(struct bq24190_dev_info *bdi,
1036 const union power_supply_propval *val)
1038 return bq24190_set_field_val(bdi, BQ24190_REG_CVC,
1039 BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
1040 bq24190_cvc_vreg_values,
1041 ARRAY_SIZE(bq24190_cvc_vreg_values), val->intval);
1044 static int bq24190_charger_get_iinlimit(struct bq24190_dev_info *bdi,
1045 union power_supply_propval *val)
1049 ret = bq24190_get_field_val(bdi, BQ24190_REG_ISC,
1050 BQ24190_REG_ISC_IINLIM_MASK,
1051 BQ24190_REG_ISC_IINLIM_SHIFT,
1052 bq24190_isc_iinlim_values,
1053 ARRAY_SIZE(bq24190_isc_iinlim_values), &iinlimit);
1057 val->intval = iinlimit;
1061 static int bq24190_charger_set_iinlimit(struct bq24190_dev_info *bdi,
1062 const union power_supply_propval *val)
1064 return bq24190_set_field_val(bdi, BQ24190_REG_ISC,
1065 BQ24190_REG_ISC_IINLIM_MASK,
1066 BQ24190_REG_ISC_IINLIM_SHIFT,
1067 bq24190_isc_iinlim_values,
1068 ARRAY_SIZE(bq24190_isc_iinlim_values), val->intval);
1071 static int bq24190_charger_get_property(struct power_supply *psy,
1072 enum power_supply_property psp, union power_supply_propval *val)
1074 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1077 dev_dbg(bdi->dev, "prop: %d\n", psp);
1079 ret = pm_runtime_get_sync(bdi->dev);
1084 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1085 ret = bq24190_charger_get_charge_type(bdi, val);
1087 case POWER_SUPPLY_PROP_HEALTH:
1088 ret = bq24190_charger_get_health(bdi, val);
1090 case POWER_SUPPLY_PROP_ONLINE:
1091 ret = bq24190_charger_get_online(bdi, val);
1093 case POWER_SUPPLY_PROP_STATUS:
1094 ret = bq24190_charger_get_status(bdi, val);
1096 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1097 ret = bq24190_charger_get_temp_alert_max(bdi, val);
1099 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1100 ret = bq24190_charger_get_precharge(bdi, val);
1102 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1103 ret = bq24190_charger_get_charge_term(bdi, val);
1105 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1106 ret = bq24190_charger_get_current(bdi, val);
1108 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
1109 ret = bq24190_charger_get_current_max(bdi, val);
1111 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1112 ret = bq24190_charger_get_voltage(bdi, val);
1114 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
1115 ret = bq24190_charger_get_voltage_max(bdi, val);
1117 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1118 ret = bq24190_charger_get_iinlimit(bdi, val);
1120 case POWER_SUPPLY_PROP_SCOPE:
1121 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1124 case POWER_SUPPLY_PROP_MODEL_NAME:
1125 val->strval = bdi->model_name;
1128 case POWER_SUPPLY_PROP_MANUFACTURER:
1129 val->strval = BQ24190_MANUFACTURER;
1136 pm_runtime_mark_last_busy(bdi->dev);
1137 pm_runtime_put_autosuspend(bdi->dev);
1142 static int bq24190_charger_set_property(struct power_supply *psy,
1143 enum power_supply_property psp,
1144 const union power_supply_propval *val)
1146 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1149 dev_dbg(bdi->dev, "prop: %d\n", psp);
1151 ret = pm_runtime_get_sync(bdi->dev);
1156 case POWER_SUPPLY_PROP_ONLINE:
1157 ret = bq24190_charger_set_online(bdi, val);
1159 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1160 ret = bq24190_charger_set_temp_alert_max(bdi, val);
1162 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1163 ret = bq24190_charger_set_charge_type(bdi, val);
1165 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1166 ret = bq24190_charger_set_current(bdi, val);
1168 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1169 ret = bq24190_charger_set_voltage(bdi, val);
1171 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1172 ret = bq24190_charger_set_iinlimit(bdi, val);
1178 pm_runtime_mark_last_busy(bdi->dev);
1179 pm_runtime_put_autosuspend(bdi->dev);
1184 static int bq24190_charger_property_is_writeable(struct power_supply *psy,
1185 enum power_supply_property psp)
1188 case POWER_SUPPLY_PROP_ONLINE:
1189 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1190 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1191 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1192 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1193 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1200 static void bq24190_input_current_limit_work(struct work_struct *work)
1202 struct bq24190_dev_info *bdi =
1203 container_of(work, struct bq24190_dev_info,
1204 input_current_limit_work.work);
1206 power_supply_set_input_current_limit_from_supplier(bdi->charger);
1209 /* Sync the input-current-limit with our parent supply (if we have one) */
1210 static void bq24190_charger_external_power_changed(struct power_supply *psy)
1212 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1215 * The Power-Good detection may take up to 220ms, sometimes
1216 * the external charger detection is quicker, and the bq24190 will
1217 * reset to iinlim based on its own charger detection (which is not
1218 * hooked up when using external charger detection) resulting in a
1219 * too low default 500mA iinlim. Delay setting the input-current-limit
1220 * for 300ms to avoid this.
1222 queue_delayed_work(system_wq, &bdi->input_current_limit_work,
1223 msecs_to_jiffies(300));
1226 static enum power_supply_property bq24190_charger_properties[] = {
1227 POWER_SUPPLY_PROP_CHARGE_TYPE,
1228 POWER_SUPPLY_PROP_HEALTH,
1229 POWER_SUPPLY_PROP_ONLINE,
1230 POWER_SUPPLY_PROP_STATUS,
1231 POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1232 POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
1233 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
1234 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1235 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
1236 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1237 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
1238 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1239 POWER_SUPPLY_PROP_SCOPE,
1240 POWER_SUPPLY_PROP_MODEL_NAME,
1241 POWER_SUPPLY_PROP_MANUFACTURER,
1244 static char *bq24190_charger_supplied_to[] = {
1248 static const struct power_supply_desc bq24190_charger_desc = {
1249 .name = "bq24190-charger",
1250 .type = POWER_SUPPLY_TYPE_USB,
1251 .properties = bq24190_charger_properties,
1252 .num_properties = ARRAY_SIZE(bq24190_charger_properties),
1253 .get_property = bq24190_charger_get_property,
1254 .set_property = bq24190_charger_set_property,
1255 .property_is_writeable = bq24190_charger_property_is_writeable,
1256 .external_power_changed = bq24190_charger_external_power_changed,
1259 /* Battery power supply property routines */
1261 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
1262 union power_supply_propval *val)
1264 u8 ss_reg, chrg_fault;
1267 mutex_lock(&bdi->f_reg_lock);
1268 chrg_fault = bdi->f_reg;
1269 mutex_unlock(&bdi->f_reg_lock);
1271 chrg_fault &= BQ24190_REG_F_CHRG_FAULT_MASK;
1272 chrg_fault >>= BQ24190_REG_F_CHRG_FAULT_SHIFT;
1274 ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1279 * The battery must be discharging when any of these are true:
1280 * - there is no good power source;
1281 * - there is a charge fault.
1282 * Could also be discharging when in "supplement mode" but
1283 * there is no way to tell when its in that mode.
1285 if (!(ss_reg & BQ24190_REG_SS_PG_STAT_MASK) || chrg_fault) {
1286 status = POWER_SUPPLY_STATUS_DISCHARGING;
1288 ss_reg &= BQ24190_REG_SS_CHRG_STAT_MASK;
1289 ss_reg >>= BQ24190_REG_SS_CHRG_STAT_SHIFT;
1292 case 0x0: /* Not Charging */
1293 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1295 case 0x1: /* Pre-charge */
1296 case 0x2: /* Fast Charging */
1297 status = POWER_SUPPLY_STATUS_CHARGING;
1299 case 0x3: /* Charge Termination Done */
1300 status = POWER_SUPPLY_STATUS_FULL;
1308 val->intval = status;
1313 static int bq24190_battery_get_health(struct bq24190_dev_info *bdi,
1314 union power_supply_propval *val)
1319 mutex_lock(&bdi->f_reg_lock);
1321 mutex_unlock(&bdi->f_reg_lock);
1323 if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
1324 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1326 v &= BQ24190_REG_F_NTC_FAULT_MASK;
1327 v >>= BQ24190_REG_F_NTC_FAULT_SHIFT;
1330 case 0x0: /* Normal */
1331 health = POWER_SUPPLY_HEALTH_GOOD;
1333 case 0x1: /* TS1 Cold */
1334 case 0x3: /* TS2 Cold */
1335 case 0x5: /* Both Cold */
1336 health = POWER_SUPPLY_HEALTH_COLD;
1338 case 0x2: /* TS1 Hot */
1339 case 0x4: /* TS2 Hot */
1340 case 0x6: /* Both Hot */
1341 health = POWER_SUPPLY_HEALTH_OVERHEAT;
1344 health = POWER_SUPPLY_HEALTH_UNKNOWN;
1348 val->intval = health;
1352 static int bq24190_battery_get_online(struct bq24190_dev_info *bdi,
1353 union power_supply_propval *val)
1358 ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
1359 BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1360 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
1364 val->intval = !batfet_disable;
1368 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
1369 const union power_supply_propval *val)
1371 return bq24190_write_mask(bdi, BQ24190_REG_MOC,
1372 BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1373 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, !val->intval);
1376 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
1377 union power_supply_propval *val)
1381 ret = bq24190_get_field_val(bdi, BQ24190_REG_ICTRC,
1382 BQ24190_REG_ICTRC_TREG_MASK,
1383 BQ24190_REG_ICTRC_TREG_SHIFT,
1384 bq24190_ictrc_treg_values,
1385 ARRAY_SIZE(bq24190_ictrc_treg_values), &temp);
1393 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
1394 const union power_supply_propval *val)
1396 return bq24190_set_field_val(bdi, BQ24190_REG_ICTRC,
1397 BQ24190_REG_ICTRC_TREG_MASK,
1398 BQ24190_REG_ICTRC_TREG_SHIFT,
1399 bq24190_ictrc_treg_values,
1400 ARRAY_SIZE(bq24190_ictrc_treg_values), val->intval);
1403 static int bq24190_battery_get_property(struct power_supply *psy,
1404 enum power_supply_property psp, union power_supply_propval *val)
1406 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1409 dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1410 dev_dbg(bdi->dev, "prop: %d\n", psp);
1412 ret = pm_runtime_get_sync(bdi->dev);
1417 case POWER_SUPPLY_PROP_STATUS:
1418 ret = bq24190_battery_get_status(bdi, val);
1420 case POWER_SUPPLY_PROP_HEALTH:
1421 ret = bq24190_battery_get_health(bdi, val);
1423 case POWER_SUPPLY_PROP_ONLINE:
1424 ret = bq24190_battery_get_online(bdi, val);
1426 case POWER_SUPPLY_PROP_TECHNOLOGY:
1427 /* Could be Li-on or Li-polymer but no way to tell which */
1428 val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
1431 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1432 ret = bq24190_battery_get_temp_alert_max(bdi, val);
1434 case POWER_SUPPLY_PROP_SCOPE:
1435 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1442 pm_runtime_mark_last_busy(bdi->dev);
1443 pm_runtime_put_autosuspend(bdi->dev);
1448 static int bq24190_battery_set_property(struct power_supply *psy,
1449 enum power_supply_property psp,
1450 const union power_supply_propval *val)
1452 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1455 dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1456 dev_dbg(bdi->dev, "prop: %d\n", psp);
1458 ret = pm_runtime_get_sync(bdi->dev);
1463 case POWER_SUPPLY_PROP_ONLINE:
1464 ret = bq24190_battery_set_online(bdi, val);
1466 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1467 ret = bq24190_battery_set_temp_alert_max(bdi, val);
1473 pm_runtime_mark_last_busy(bdi->dev);
1474 pm_runtime_put_autosuspend(bdi->dev);
1479 static int bq24190_battery_property_is_writeable(struct power_supply *psy,
1480 enum power_supply_property psp)
1485 case POWER_SUPPLY_PROP_ONLINE:
1486 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1496 static enum power_supply_property bq24190_battery_properties[] = {
1497 POWER_SUPPLY_PROP_STATUS,
1498 POWER_SUPPLY_PROP_HEALTH,
1499 POWER_SUPPLY_PROP_ONLINE,
1500 POWER_SUPPLY_PROP_TECHNOLOGY,
1501 POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1502 POWER_SUPPLY_PROP_SCOPE,
1505 static const struct power_supply_desc bq24190_battery_desc = {
1506 .name = "bq24190-battery",
1507 .type = POWER_SUPPLY_TYPE_BATTERY,
1508 .properties = bq24190_battery_properties,
1509 .num_properties = ARRAY_SIZE(bq24190_battery_properties),
1510 .get_property = bq24190_battery_get_property,
1511 .set_property = bq24190_battery_set_property,
1512 .property_is_writeable = bq24190_battery_property_is_writeable,
1515 static int bq24190_configure_usb_otg(struct bq24190_dev_info *bdi, u8 ss_reg)
1520 otg_enabled = !!(ss_reg & BQ24190_REG_SS_VBUS_STAT_MASK);
1521 ret = extcon_set_state_sync(bdi->edev, EXTCON_USB, otg_enabled);
1523 dev_err(bdi->dev, "Can't set extcon state to %d: %d\n",
1529 static void bq24190_check_status(struct bq24190_dev_info *bdi)
1531 const u8 battery_mask_ss = BQ24190_REG_SS_CHRG_STAT_MASK;
1532 const u8 battery_mask_f = BQ24190_REG_F_BAT_FAULT_MASK
1533 | BQ24190_REG_F_NTC_FAULT_MASK;
1534 bool alert_charger = false, alert_battery = false;
1535 u8 ss_reg = 0, f_reg = 0;
1538 ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1540 dev_err(bdi->dev, "Can't read SS reg: %d\n", ret);
1546 ret = bq24190_read(bdi, BQ24190_REG_F, &f_reg);
1548 dev_err(bdi->dev, "Can't read F reg: %d\n", ret);
1551 } while (f_reg && ++i < 2);
1553 /* ignore over/under voltage fault after disconnect */
1554 if (f_reg == (1 << BQ24190_REG_F_CHRG_FAULT_SHIFT) &&
1555 !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK))
1558 if (f_reg != bdi->f_reg) {
1560 "Fault: boost %d, charge %d, battery %d, ntc %d\n",
1561 !!(f_reg & BQ24190_REG_F_BOOST_FAULT_MASK),
1562 !!(f_reg & BQ24190_REG_F_CHRG_FAULT_MASK),
1563 !!(f_reg & BQ24190_REG_F_BAT_FAULT_MASK),
1564 !!(f_reg & BQ24190_REG_F_NTC_FAULT_MASK));
1566 mutex_lock(&bdi->f_reg_lock);
1567 if ((bdi->f_reg & battery_mask_f) != (f_reg & battery_mask_f))
1568 alert_battery = true;
1569 if ((bdi->f_reg & ~battery_mask_f) != (f_reg & ~battery_mask_f))
1570 alert_charger = true;
1572 mutex_unlock(&bdi->f_reg_lock);
1575 if (ss_reg != bdi->ss_reg) {
1577 * The device is in host mode so when PG_STAT goes from 1->0
1578 * (i.e., power removed) HIZ needs to be disabled.
1580 if ((bdi->ss_reg & BQ24190_REG_SS_PG_STAT_MASK) &&
1581 !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK)) {
1582 ret = bq24190_write_mask(bdi, BQ24190_REG_ISC,
1583 BQ24190_REG_ISC_EN_HIZ_MASK,
1584 BQ24190_REG_ISC_EN_HIZ_SHIFT,
1587 dev_err(bdi->dev, "Can't access ISC reg: %d\n",
1591 if ((bdi->ss_reg & battery_mask_ss) != (ss_reg & battery_mask_ss))
1592 alert_battery = true;
1593 if ((bdi->ss_reg & ~battery_mask_ss) != (ss_reg & ~battery_mask_ss))
1594 alert_charger = true;
1595 bdi->ss_reg = ss_reg;
1598 if (alert_charger || alert_battery) {
1599 power_supply_changed(bdi->charger);
1600 bq24190_configure_usb_otg(bdi, ss_reg);
1602 if (alert_battery && bdi->battery)
1603 power_supply_changed(bdi->battery);
1605 dev_dbg(bdi->dev, "ss_reg: 0x%02x, f_reg: 0x%02x\n", ss_reg, f_reg);
1608 static irqreturn_t bq24190_irq_handler_thread(int irq, void *data)
1610 struct bq24190_dev_info *bdi = data;
1613 bdi->irq_event = true;
1614 error = pm_runtime_get_sync(bdi->dev);
1616 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1617 pm_runtime_put_noidle(bdi->dev);
1620 bq24190_check_status(bdi);
1621 pm_runtime_mark_last_busy(bdi->dev);
1622 pm_runtime_put_autosuspend(bdi->dev);
1623 bdi->irq_event = false;
1628 static int bq24190_hw_init(struct bq24190_dev_info *bdi)
1633 /* First check that the device really is what its supposed to be */
1634 ret = bq24190_read_mask(bdi, BQ24190_REG_VPRS,
1635 BQ24190_REG_VPRS_PN_MASK,
1636 BQ24190_REG_VPRS_PN_SHIFT,
1642 case BQ24190_REG_VPRS_PN_24190:
1643 case BQ24190_REG_VPRS_PN_24192:
1644 case BQ24190_REG_VPRS_PN_24192I:
1647 dev_err(bdi->dev, "Error unknown model: 0x%02x\n", v);
1651 ret = bq24190_register_reset(bdi);
1655 ret = bq24190_set_config(bdi);
1659 return bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1662 static int bq24190_get_config(struct bq24190_dev_info *bdi)
1664 const char * const s = "ti,system-minimum-microvolt";
1665 struct power_supply_battery_info info = {};
1668 if (device_property_read_u32(bdi->dev, s, &v) == 0) {
1670 if (v >= BQ24190_REG_POC_SYS_MIN_MIN
1671 && v <= BQ24190_REG_POC_SYS_MIN_MAX)
1674 dev_warn(bdi->dev, "invalid value for %s: %u\n", s, v);
1677 if (bdi->dev->of_node &&
1678 !power_supply_get_battery_info(bdi->charger, &info)) {
1679 v = info.precharge_current_ua / 1000;
1680 if (v >= BQ24190_REG_PCTCC_IPRECHG_MIN
1681 && v <= BQ24190_REG_PCTCC_IPRECHG_MAX)
1684 dev_warn(bdi->dev, "invalid value for battery:precharge-current-microamp: %d\n",
1687 v = info.charge_term_current_ua / 1000;
1688 if (v >= BQ24190_REG_PCTCC_ITERM_MIN
1689 && v <= BQ24190_REG_PCTCC_ITERM_MAX)
1692 dev_warn(bdi->dev, "invalid value for battery:charge-term-current-microamp: %d\n",
1699 static int bq24190_probe(struct i2c_client *client,
1700 const struct i2c_device_id *id)
1702 struct i2c_adapter *adapter = client->adapter;
1703 struct device *dev = &client->dev;
1704 struct power_supply_config charger_cfg = {}, battery_cfg = {};
1705 struct bq24190_dev_info *bdi;
1708 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1709 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1713 bdi = devm_kzalloc(dev, sizeof(*bdi), GFP_KERNEL);
1715 dev_err(dev, "Can't alloc bdi struct\n");
1719 bdi->client = client;
1721 strncpy(bdi->model_name, id->name, I2C_NAME_SIZE);
1722 mutex_init(&bdi->f_reg_lock);
1724 bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1725 INIT_DELAYED_WORK(&bdi->input_current_limit_work,
1726 bq24190_input_current_limit_work);
1728 i2c_set_clientdata(client, bdi);
1730 if (client->irq <= 0) {
1731 dev_err(dev, "Can't get irq info\n");
1735 bdi->edev = devm_extcon_dev_allocate(dev, bq24190_usb_extcon_cable);
1736 if (IS_ERR(bdi->edev))
1737 return PTR_ERR(bdi->edev);
1739 ret = devm_extcon_dev_register(dev, bdi->edev);
1743 pm_runtime_enable(dev);
1744 pm_runtime_use_autosuspend(dev);
1745 pm_runtime_set_autosuspend_delay(dev, 600);
1746 ret = pm_runtime_get_sync(dev);
1748 dev_err(dev, "pm_runtime_get failed: %i\n", ret);
1753 bq24190_sysfs_init_attrs();
1754 charger_cfg.attr_grp = bq24190_sysfs_groups;
1757 charger_cfg.drv_data = bdi;
1758 charger_cfg.of_node = dev->of_node;
1759 charger_cfg.supplied_to = bq24190_charger_supplied_to;
1760 charger_cfg.num_supplicants = ARRAY_SIZE(bq24190_charger_supplied_to),
1761 bdi->charger = power_supply_register(dev, &bq24190_charger_desc,
1763 if (IS_ERR(bdi->charger)) {
1764 dev_err(dev, "Can't register charger\n");
1765 ret = PTR_ERR(bdi->charger);
1769 /* the battery class is deprecated and will be removed. */
1770 /* in the interim, this property hides it. */
1771 if (!device_property_read_bool(dev, "omit-battery-class")) {
1772 battery_cfg.drv_data = bdi;
1773 bdi->battery = power_supply_register(dev, &bq24190_battery_desc,
1775 if (IS_ERR(bdi->battery)) {
1776 dev_err(dev, "Can't register battery\n");
1777 ret = PTR_ERR(bdi->battery);
1782 ret = bq24190_get_config(bdi);
1784 dev_err(dev, "Can't get devicetree config\n");
1788 ret = bq24190_hw_init(bdi);
1790 dev_err(dev, "Hardware init failed\n");
1794 ret = bq24190_configure_usb_otg(bdi, bdi->ss_reg);
1798 bdi->initialized = true;
1800 ret = devm_request_threaded_irq(dev, client->irq, NULL,
1801 bq24190_irq_handler_thread,
1802 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1803 "bq24190-charger", bdi);
1805 dev_err(dev, "Can't set up irq handler\n");
1809 ret = bq24190_register_vbus_regulator(bdi);
1813 enable_irq_wake(client->irq);
1815 pm_runtime_mark_last_busy(dev);
1816 pm_runtime_put_autosuspend(dev);
1821 if (!IS_ERR_OR_NULL(bdi->battery))
1822 power_supply_unregister(bdi->battery);
1823 power_supply_unregister(bdi->charger);
1826 pm_runtime_put_sync(dev);
1827 pm_runtime_dont_use_autosuspend(dev);
1828 pm_runtime_disable(dev);
1832 static int bq24190_remove(struct i2c_client *client)
1834 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1837 error = pm_runtime_get_sync(bdi->dev);
1839 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1840 pm_runtime_put_noidle(bdi->dev);
1843 bq24190_register_reset(bdi);
1845 power_supply_unregister(bdi->battery);
1846 power_supply_unregister(bdi->charger);
1848 pm_runtime_put_sync(bdi->dev);
1849 pm_runtime_dont_use_autosuspend(bdi->dev);
1850 pm_runtime_disable(bdi->dev);
1855 static __maybe_unused int bq24190_runtime_suspend(struct device *dev)
1857 struct i2c_client *client = to_i2c_client(dev);
1858 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1860 if (!bdi->initialized)
1863 dev_dbg(bdi->dev, "%s\n", __func__);
1868 static __maybe_unused int bq24190_runtime_resume(struct device *dev)
1870 struct i2c_client *client = to_i2c_client(dev);
1871 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1873 if (!bdi->initialized)
1876 if (!bdi->irq_event) {
1877 dev_dbg(bdi->dev, "checking events on possible wakeirq\n");
1878 bq24190_check_status(bdi);
1884 static __maybe_unused int bq24190_pm_suspend(struct device *dev)
1886 struct i2c_client *client = to_i2c_client(dev);
1887 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1890 error = pm_runtime_get_sync(bdi->dev);
1892 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1893 pm_runtime_put_noidle(bdi->dev);
1896 bq24190_register_reset(bdi);
1899 pm_runtime_mark_last_busy(bdi->dev);
1900 pm_runtime_put_autosuspend(bdi->dev);
1906 static __maybe_unused int bq24190_pm_resume(struct device *dev)
1908 struct i2c_client *client = to_i2c_client(dev);
1909 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1913 bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1915 error = pm_runtime_get_sync(bdi->dev);
1917 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1918 pm_runtime_put_noidle(bdi->dev);
1921 bq24190_register_reset(bdi);
1922 bq24190_set_config(bdi);
1923 bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1926 pm_runtime_mark_last_busy(bdi->dev);
1927 pm_runtime_put_autosuspend(bdi->dev);
1930 /* Things may have changed while suspended so alert upper layer */
1931 power_supply_changed(bdi->charger);
1933 power_supply_changed(bdi->battery);
1938 static const struct dev_pm_ops bq24190_pm_ops = {
1939 SET_RUNTIME_PM_OPS(bq24190_runtime_suspend, bq24190_runtime_resume,
1941 SET_SYSTEM_SLEEP_PM_OPS(bq24190_pm_suspend, bq24190_pm_resume)
1944 static const struct i2c_device_id bq24190_i2c_ids[] = {
1951 MODULE_DEVICE_TABLE(i2c, bq24190_i2c_ids);
1954 static const struct of_device_id bq24190_of_match[] = {
1955 { .compatible = "ti,bq24190", },
1956 { .compatible = "ti,bq24192", },
1957 { .compatible = "ti,bq24192i", },
1958 { .compatible = "ti,bq24196", },
1961 MODULE_DEVICE_TABLE(of, bq24190_of_match);
1963 static const struct of_device_id bq24190_of_match[] = {
1968 static struct i2c_driver bq24190_driver = {
1969 .probe = bq24190_probe,
1970 .remove = bq24190_remove,
1971 .id_table = bq24190_i2c_ids,
1973 .name = "bq24190-charger",
1974 .pm = &bq24190_pm_ops,
1975 .of_match_table = of_match_ptr(bq24190_of_match),
1978 module_i2c_driver(bq24190_driver);
1980 MODULE_LICENSE("GPL");
1981 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
1982 MODULE_DESCRIPTION("TI BQ24190 Charger Driver");