2 * Driver for the TI bq24190 battery charger.
4 * Author: Mark A. Greer <mgreer@animalcreek.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #include <linux/module.h>
12 #include <linux/interrupt.h>
13 #include <linux/delay.h>
14 #include <linux/extcon.h>
15 #include <linux/of_irq.h>
16 #include <linux/of_device.h>
17 #include <linux/pm_runtime.h>
18 #include <linux/power_supply.h>
19 #include <linux/power/bq24190_charger.h>
20 #include <linux/regulator/driver.h>
21 #include <linux/regulator/machine.h>
22 #include <linux/workqueue.h>
23 #include <linux/gpio.h>
24 #include <linux/i2c.h>
26 #define BQ24190_MANUFACTURER "Texas Instruments"
28 #define BQ24190_REG_ISC 0x00 /* Input Source Control */
29 #define BQ24190_REG_ISC_EN_HIZ_MASK BIT(7)
30 #define BQ24190_REG_ISC_EN_HIZ_SHIFT 7
31 #define BQ24190_REG_ISC_VINDPM_MASK (BIT(6) | BIT(5) | BIT(4) | \
33 #define BQ24190_REG_ISC_VINDPM_SHIFT 3
34 #define BQ24190_REG_ISC_IINLIM_MASK (BIT(2) | BIT(1) | BIT(0))
35 #define BQ24190_REG_ISC_IINLIM_SHIFT 0
37 #define BQ24190_REG_POC 0x01 /* Power-On Configuration */
38 #define BQ24190_REG_POC_RESET_MASK BIT(7)
39 #define BQ24190_REG_POC_RESET_SHIFT 7
40 #define BQ24190_REG_POC_WDT_RESET_MASK BIT(6)
41 #define BQ24190_REG_POC_WDT_RESET_SHIFT 6
42 #define BQ24190_REG_POC_CHG_CONFIG_MASK (BIT(5) | BIT(4))
43 #define BQ24190_REG_POC_CHG_CONFIG_SHIFT 4
44 #define BQ24190_REG_POC_CHG_CONFIG_DISABLE 0x0
45 #define BQ24190_REG_POC_CHG_CONFIG_CHARGE 0x1
46 #define BQ24190_REG_POC_CHG_CONFIG_OTG 0x2
47 #define BQ24190_REG_POC_CHG_CONFIG_OTG_ALT 0x3
48 #define BQ24190_REG_POC_SYS_MIN_MASK (BIT(3) | BIT(2) | BIT(1))
49 #define BQ24190_REG_POC_SYS_MIN_SHIFT 1
50 #define BQ24190_REG_POC_SYS_MIN_MIN 3000
51 #define BQ24190_REG_POC_SYS_MIN_MAX 3700
52 #define BQ24190_REG_POC_BOOST_LIM_MASK BIT(0)
53 #define BQ24190_REG_POC_BOOST_LIM_SHIFT 0
55 #define BQ24190_REG_CCC 0x02 /* Charge Current Control */
56 #define BQ24190_REG_CCC_ICHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
57 BIT(4) | BIT(3) | BIT(2))
58 #define BQ24190_REG_CCC_ICHG_SHIFT 2
59 #define BQ24190_REG_CCC_FORCE_20PCT_MASK BIT(0)
60 #define BQ24190_REG_CCC_FORCE_20PCT_SHIFT 0
62 #define BQ24190_REG_PCTCC 0x03 /* Pre-charge/Termination Current Cntl */
63 #define BQ24190_REG_PCTCC_IPRECHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
65 #define BQ24190_REG_PCTCC_IPRECHG_SHIFT 4
66 #define BQ24190_REG_PCTCC_IPRECHG_MIN 128
67 #define BQ24190_REG_PCTCC_IPRECHG_MAX 2048
68 #define BQ24190_REG_PCTCC_ITERM_MASK (BIT(3) | BIT(2) | BIT(1) | \
70 #define BQ24190_REG_PCTCC_ITERM_SHIFT 0
71 #define BQ24190_REG_PCTCC_ITERM_MIN 128
72 #define BQ24190_REG_PCTCC_ITERM_MAX 2048
74 #define BQ24190_REG_CVC 0x04 /* Charge Voltage Control */
75 #define BQ24190_REG_CVC_VREG_MASK (BIT(7) | BIT(6) | BIT(5) | \
76 BIT(4) | BIT(3) | BIT(2))
77 #define BQ24190_REG_CVC_VREG_SHIFT 2
78 #define BQ24190_REG_CVC_BATLOWV_MASK BIT(1)
79 #define BQ24190_REG_CVC_BATLOWV_SHIFT 1
80 #define BQ24190_REG_CVC_VRECHG_MASK BIT(0)
81 #define BQ24190_REG_CVC_VRECHG_SHIFT 0
83 #define BQ24190_REG_CTTC 0x05 /* Charge Term/Timer Control */
84 #define BQ24190_REG_CTTC_EN_TERM_MASK BIT(7)
85 #define BQ24190_REG_CTTC_EN_TERM_SHIFT 7
86 #define BQ24190_REG_CTTC_TERM_STAT_MASK BIT(6)
87 #define BQ24190_REG_CTTC_TERM_STAT_SHIFT 6
88 #define BQ24190_REG_CTTC_WATCHDOG_MASK (BIT(5) | BIT(4))
89 #define BQ24190_REG_CTTC_WATCHDOG_SHIFT 4
90 #define BQ24190_REG_CTTC_EN_TIMER_MASK BIT(3)
91 #define BQ24190_REG_CTTC_EN_TIMER_SHIFT 3
92 #define BQ24190_REG_CTTC_CHG_TIMER_MASK (BIT(2) | BIT(1))
93 #define BQ24190_REG_CTTC_CHG_TIMER_SHIFT 1
94 #define BQ24190_REG_CTTC_JEITA_ISET_MASK BIT(0)
95 #define BQ24190_REG_CTTC_JEITA_ISET_SHIFT 0
97 #define BQ24190_REG_ICTRC 0x06 /* IR Comp/Thermal Regulation Control */
98 #define BQ24190_REG_ICTRC_BAT_COMP_MASK (BIT(7) | BIT(6) | BIT(5))
99 #define BQ24190_REG_ICTRC_BAT_COMP_SHIFT 5
100 #define BQ24190_REG_ICTRC_VCLAMP_MASK (BIT(4) | BIT(3) | BIT(2))
101 #define BQ24190_REG_ICTRC_VCLAMP_SHIFT 2
102 #define BQ24190_REG_ICTRC_TREG_MASK (BIT(1) | BIT(0))
103 #define BQ24190_REG_ICTRC_TREG_SHIFT 0
105 #define BQ24190_REG_MOC 0x07 /* Misc. Operation Control */
106 #define BQ24190_REG_MOC_DPDM_EN_MASK BIT(7)
107 #define BQ24190_REG_MOC_DPDM_EN_SHIFT 7
108 #define BQ24190_REG_MOC_TMR2X_EN_MASK BIT(6)
109 #define BQ24190_REG_MOC_TMR2X_EN_SHIFT 6
110 #define BQ24190_REG_MOC_BATFET_DISABLE_MASK BIT(5)
111 #define BQ24190_REG_MOC_BATFET_DISABLE_SHIFT 5
112 #define BQ24190_REG_MOC_JEITA_VSET_MASK BIT(4)
113 #define BQ24190_REG_MOC_JEITA_VSET_SHIFT 4
114 #define BQ24190_REG_MOC_INT_MASK_MASK (BIT(1) | BIT(0))
115 #define BQ24190_REG_MOC_INT_MASK_SHIFT 0
117 #define BQ24190_REG_SS 0x08 /* System Status */
118 #define BQ24190_REG_SS_VBUS_STAT_MASK (BIT(7) | BIT(6))
119 #define BQ24190_REG_SS_VBUS_STAT_SHIFT 6
120 #define BQ24190_REG_SS_CHRG_STAT_MASK (BIT(5) | BIT(4))
121 #define BQ24190_REG_SS_CHRG_STAT_SHIFT 4
122 #define BQ24190_REG_SS_DPM_STAT_MASK BIT(3)
123 #define BQ24190_REG_SS_DPM_STAT_SHIFT 3
124 #define BQ24190_REG_SS_PG_STAT_MASK BIT(2)
125 #define BQ24190_REG_SS_PG_STAT_SHIFT 2
126 #define BQ24190_REG_SS_THERM_STAT_MASK BIT(1)
127 #define BQ24190_REG_SS_THERM_STAT_SHIFT 1
128 #define BQ24190_REG_SS_VSYS_STAT_MASK BIT(0)
129 #define BQ24190_REG_SS_VSYS_STAT_SHIFT 0
131 #define BQ24190_REG_F 0x09 /* Fault */
132 #define BQ24190_REG_F_WATCHDOG_FAULT_MASK BIT(7)
133 #define BQ24190_REG_F_WATCHDOG_FAULT_SHIFT 7
134 #define BQ24190_REG_F_BOOST_FAULT_MASK BIT(6)
135 #define BQ24190_REG_F_BOOST_FAULT_SHIFT 6
136 #define BQ24190_REG_F_CHRG_FAULT_MASK (BIT(5) | BIT(4))
137 #define BQ24190_REG_F_CHRG_FAULT_SHIFT 4
138 #define BQ24190_REG_F_BAT_FAULT_MASK BIT(3)
139 #define BQ24190_REG_F_BAT_FAULT_SHIFT 3
140 #define BQ24190_REG_F_NTC_FAULT_MASK (BIT(2) | BIT(1) | BIT(0))
141 #define BQ24190_REG_F_NTC_FAULT_SHIFT 0
143 #define BQ24190_REG_VPRS 0x0A /* Vendor/Part/Revision Status */
144 #define BQ24190_REG_VPRS_PN_MASK (BIT(5) | BIT(4) | BIT(3))
145 #define BQ24190_REG_VPRS_PN_SHIFT 3
146 #define BQ24190_REG_VPRS_PN_24190 0x4
147 #define BQ24190_REG_VPRS_PN_24192 0x5 /* Also 24193 */
148 #define BQ24190_REG_VPRS_PN_24192I 0x3
149 #define BQ24190_REG_VPRS_TS_PROFILE_MASK BIT(2)
150 #define BQ24190_REG_VPRS_TS_PROFILE_SHIFT 2
151 #define BQ24190_REG_VPRS_DEV_REG_MASK (BIT(1) | BIT(0))
152 #define BQ24190_REG_VPRS_DEV_REG_SHIFT 0
155 * The FAULT register is latched by the bq24190 (except for NTC_FAULT)
156 * so the first read after a fault returns the latched value and subsequent
157 * reads return the current value. In order to return the fault status
158 * to the user, have the interrupt handler save the reg's value and retrieve
159 * it in the appropriate health/status routine.
161 struct bq24190_dev_info {
162 struct i2c_client *client;
164 struct power_supply *charger;
165 struct power_supply *battery;
166 struct extcon_dev *extcon;
167 struct notifier_block extcon_nb;
168 struct delayed_work extcon_work;
169 struct delayed_work input_current_limit_work;
170 char model_name[I2C_NAME_SIZE];
176 struct mutex f_reg_lock;
183 * The tables below provide a 2-way mapping for the value that goes in
184 * the register field and the real-world value that it represents.
185 * The index of the array is the value that goes in the register; the
186 * number at that index in the array is the real-world value that it
190 /* REG00[2:0] (IINLIM) in uAh */
191 static const int bq24190_isc_iinlim_values[] = {
192 100000, 150000, 500000, 900000, 1200000, 1500000, 2000000, 3000000
195 /* REG02[7:2] (ICHG) in uAh */
196 static const int bq24190_ccc_ichg_values[] = {
197 512000, 576000, 640000, 704000, 768000, 832000, 896000, 960000,
198 1024000, 1088000, 1152000, 1216000, 1280000, 1344000, 1408000, 1472000,
199 1536000, 1600000, 1664000, 1728000, 1792000, 1856000, 1920000, 1984000,
200 2048000, 2112000, 2176000, 2240000, 2304000, 2368000, 2432000, 2496000,
201 2560000, 2624000, 2688000, 2752000, 2816000, 2880000, 2944000, 3008000,
202 3072000, 3136000, 3200000, 3264000, 3328000, 3392000, 3456000, 3520000,
203 3584000, 3648000, 3712000, 3776000, 3840000, 3904000, 3968000, 4032000,
204 4096000, 4160000, 4224000, 4288000, 4352000, 4416000, 4480000, 4544000
207 /* REG04[7:2] (VREG) in uV */
208 static const int bq24190_cvc_vreg_values[] = {
209 3504000, 3520000, 3536000, 3552000, 3568000, 3584000, 3600000, 3616000,
210 3632000, 3648000, 3664000, 3680000, 3696000, 3712000, 3728000, 3744000,
211 3760000, 3776000, 3792000, 3808000, 3824000, 3840000, 3856000, 3872000,
212 3888000, 3904000, 3920000, 3936000, 3952000, 3968000, 3984000, 4000000,
213 4016000, 4032000, 4048000, 4064000, 4080000, 4096000, 4112000, 4128000,
214 4144000, 4160000, 4176000, 4192000, 4208000, 4224000, 4240000, 4256000,
215 4272000, 4288000, 4304000, 4320000, 4336000, 4352000, 4368000, 4384000,
219 /* REG06[1:0] (TREG) in tenths of degrees Celsius */
220 static const int bq24190_ictrc_treg_values[] = {
225 * Return the index in 'tbl' of greatest value that is less than or equal to
226 * 'val'. The index range returned is 0 to 'tbl_size' - 1. Assumes that
227 * the values in 'tbl' are sorted from smallest to largest and 'tbl_size'
230 static u8 bq24190_find_idx(const int tbl[], int tbl_size, int v)
234 for (i = 1; i < tbl_size; i++)
241 /* Basic driver I/O routines */
243 static int bq24190_read(struct bq24190_dev_info *bdi, u8 reg, u8 *data)
247 ret = i2c_smbus_read_byte_data(bdi->client, reg);
255 static int bq24190_write(struct bq24190_dev_info *bdi, u8 reg, u8 data)
257 return i2c_smbus_write_byte_data(bdi->client, reg, data);
260 static int bq24190_read_mask(struct bq24190_dev_info *bdi, u8 reg,
261 u8 mask, u8 shift, u8 *data)
266 ret = bq24190_read(bdi, reg, &v);
277 static int bq24190_write_mask(struct bq24190_dev_info *bdi, u8 reg,
278 u8 mask, u8 shift, u8 data)
283 ret = bq24190_read(bdi, reg, &v);
288 v |= ((data << shift) & mask);
290 return bq24190_write(bdi, reg, v);
293 static int bq24190_get_field_val(struct bq24190_dev_info *bdi,
294 u8 reg, u8 mask, u8 shift,
295 const int tbl[], int tbl_size,
301 ret = bq24190_read_mask(bdi, reg, mask, shift, &v);
305 v = (v >= tbl_size) ? (tbl_size - 1) : v;
311 static int bq24190_set_field_val(struct bq24190_dev_info *bdi,
312 u8 reg, u8 mask, u8 shift,
313 const int tbl[], int tbl_size,
318 idx = bq24190_find_idx(tbl, tbl_size, val);
320 return bq24190_write_mask(bdi, reg, mask, shift, idx);
325 * There are a numerous options that are configurable on the bq24190
326 * that go well beyond what the power_supply properties provide access to.
327 * Provide sysfs access to them so they can be examined and possibly modified
328 * on the fly. They will be provided for the charger power_supply object only
329 * and will be prefixed by 'f_' to make them easier to recognize.
332 #define BQ24190_SYSFS_FIELD(_name, r, f, m, store) \
334 .attr = __ATTR(f_##_name, m, bq24190_sysfs_show, store), \
335 .reg = BQ24190_REG_##r, \
336 .mask = BQ24190_REG_##r##_##f##_MASK, \
337 .shift = BQ24190_REG_##r##_##f##_SHIFT, \
340 #define BQ24190_SYSFS_FIELD_RW(_name, r, f) \
341 BQ24190_SYSFS_FIELD(_name, r, f, S_IWUSR | S_IRUGO, \
344 #define BQ24190_SYSFS_FIELD_RO(_name, r, f) \
345 BQ24190_SYSFS_FIELD(_name, r, f, S_IRUGO, NULL)
347 static ssize_t bq24190_sysfs_show(struct device *dev,
348 struct device_attribute *attr, char *buf);
349 static ssize_t bq24190_sysfs_store(struct device *dev,
350 struct device_attribute *attr, const char *buf, size_t count);
352 struct bq24190_sysfs_field_info {
353 struct device_attribute attr;
359 /* On i386 ptrace-abi.h defines SS that breaks the macro calls below. */
362 static struct bq24190_sysfs_field_info bq24190_sysfs_field_tbl[] = {
363 /* sysfs name reg field in reg */
364 BQ24190_SYSFS_FIELD_RW(en_hiz, ISC, EN_HIZ),
365 BQ24190_SYSFS_FIELD_RW(vindpm, ISC, VINDPM),
366 BQ24190_SYSFS_FIELD_RW(iinlim, ISC, IINLIM),
367 BQ24190_SYSFS_FIELD_RW(chg_config, POC, CHG_CONFIG),
368 BQ24190_SYSFS_FIELD_RW(sys_min, POC, SYS_MIN),
369 BQ24190_SYSFS_FIELD_RW(boost_lim, POC, BOOST_LIM),
370 BQ24190_SYSFS_FIELD_RW(ichg, CCC, ICHG),
371 BQ24190_SYSFS_FIELD_RW(force_20_pct, CCC, FORCE_20PCT),
372 BQ24190_SYSFS_FIELD_RW(iprechg, PCTCC, IPRECHG),
373 BQ24190_SYSFS_FIELD_RW(iterm, PCTCC, ITERM),
374 BQ24190_SYSFS_FIELD_RW(vreg, CVC, VREG),
375 BQ24190_SYSFS_FIELD_RW(batlowv, CVC, BATLOWV),
376 BQ24190_SYSFS_FIELD_RW(vrechg, CVC, VRECHG),
377 BQ24190_SYSFS_FIELD_RW(en_term, CTTC, EN_TERM),
378 BQ24190_SYSFS_FIELD_RW(term_stat, CTTC, TERM_STAT),
379 BQ24190_SYSFS_FIELD_RO(watchdog, CTTC, WATCHDOG),
380 BQ24190_SYSFS_FIELD_RW(en_timer, CTTC, EN_TIMER),
381 BQ24190_SYSFS_FIELD_RW(chg_timer, CTTC, CHG_TIMER),
382 BQ24190_SYSFS_FIELD_RW(jeta_iset, CTTC, JEITA_ISET),
383 BQ24190_SYSFS_FIELD_RW(bat_comp, ICTRC, BAT_COMP),
384 BQ24190_SYSFS_FIELD_RW(vclamp, ICTRC, VCLAMP),
385 BQ24190_SYSFS_FIELD_RW(treg, ICTRC, TREG),
386 BQ24190_SYSFS_FIELD_RW(dpdm_en, MOC, DPDM_EN),
387 BQ24190_SYSFS_FIELD_RW(tmr2x_en, MOC, TMR2X_EN),
388 BQ24190_SYSFS_FIELD_RW(batfet_disable, MOC, BATFET_DISABLE),
389 BQ24190_SYSFS_FIELD_RW(jeita_vset, MOC, JEITA_VSET),
390 BQ24190_SYSFS_FIELD_RO(int_mask, MOC, INT_MASK),
391 BQ24190_SYSFS_FIELD_RO(vbus_stat, SS, VBUS_STAT),
392 BQ24190_SYSFS_FIELD_RO(chrg_stat, SS, CHRG_STAT),
393 BQ24190_SYSFS_FIELD_RO(dpm_stat, SS, DPM_STAT),
394 BQ24190_SYSFS_FIELD_RO(pg_stat, SS, PG_STAT),
395 BQ24190_SYSFS_FIELD_RO(therm_stat, SS, THERM_STAT),
396 BQ24190_SYSFS_FIELD_RO(vsys_stat, SS, VSYS_STAT),
397 BQ24190_SYSFS_FIELD_RO(watchdog_fault, F, WATCHDOG_FAULT),
398 BQ24190_SYSFS_FIELD_RO(boost_fault, F, BOOST_FAULT),
399 BQ24190_SYSFS_FIELD_RO(chrg_fault, F, CHRG_FAULT),
400 BQ24190_SYSFS_FIELD_RO(bat_fault, F, BAT_FAULT),
401 BQ24190_SYSFS_FIELD_RO(ntc_fault, F, NTC_FAULT),
402 BQ24190_SYSFS_FIELD_RO(pn, VPRS, PN),
403 BQ24190_SYSFS_FIELD_RO(ts_profile, VPRS, TS_PROFILE),
404 BQ24190_SYSFS_FIELD_RO(dev_reg, VPRS, DEV_REG),
407 static struct attribute *
408 bq24190_sysfs_attrs[ARRAY_SIZE(bq24190_sysfs_field_tbl) + 1];
410 static const struct attribute_group bq24190_sysfs_attr_group = {
411 .attrs = bq24190_sysfs_attrs,
414 static void bq24190_sysfs_init_attrs(void)
416 int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
418 for (i = 0; i < limit; i++)
419 bq24190_sysfs_attrs[i] = &bq24190_sysfs_field_tbl[i].attr.attr;
421 bq24190_sysfs_attrs[limit] = NULL; /* Has additional entry for this */
424 static struct bq24190_sysfs_field_info *bq24190_sysfs_field_lookup(
427 int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
429 for (i = 0; i < limit; i++)
430 if (!strcmp(name, bq24190_sysfs_field_tbl[i].attr.attr.name))
436 return &bq24190_sysfs_field_tbl[i];
439 static ssize_t bq24190_sysfs_show(struct device *dev,
440 struct device_attribute *attr, char *buf)
442 struct power_supply *psy = dev_get_drvdata(dev);
443 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
444 struct bq24190_sysfs_field_info *info;
449 info = bq24190_sysfs_field_lookup(attr->attr.name);
453 ret = pm_runtime_get_sync(bdi->dev);
455 pm_runtime_put_noidle(bdi->dev);
459 ret = bq24190_read_mask(bdi, info->reg, info->mask, info->shift, &v);
463 count = scnprintf(buf, PAGE_SIZE, "%hhx\n", v);
465 pm_runtime_mark_last_busy(bdi->dev);
466 pm_runtime_put_autosuspend(bdi->dev);
471 static ssize_t bq24190_sysfs_store(struct device *dev,
472 struct device_attribute *attr, const char *buf, size_t count)
474 struct power_supply *psy = dev_get_drvdata(dev);
475 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
476 struct bq24190_sysfs_field_info *info;
480 info = bq24190_sysfs_field_lookup(attr->attr.name);
484 ret = kstrtou8(buf, 0, &v);
488 ret = pm_runtime_get_sync(bdi->dev);
492 ret = bq24190_write_mask(bdi, info->reg, info->mask, info->shift, v);
496 pm_runtime_mark_last_busy(bdi->dev);
497 pm_runtime_put_autosuspend(bdi->dev);
502 static int bq24190_sysfs_create_group(struct bq24190_dev_info *bdi)
504 bq24190_sysfs_init_attrs();
506 return sysfs_create_group(&bdi->charger->dev.kobj,
507 &bq24190_sysfs_attr_group);
510 static void bq24190_sysfs_remove_group(struct bq24190_dev_info *bdi)
512 sysfs_remove_group(&bdi->charger->dev.kobj, &bq24190_sysfs_attr_group);
515 static int bq24190_sysfs_create_group(struct bq24190_dev_info *bdi)
520 static inline void bq24190_sysfs_remove_group(struct bq24190_dev_info *bdi) {}
523 #ifdef CONFIG_REGULATOR
524 static int bq24190_set_charge_mode(struct regulator_dev *dev, u8 val)
526 struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
529 ret = pm_runtime_get_sync(bdi->dev);
531 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
532 pm_runtime_put_noidle(bdi->dev);
536 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
537 BQ24190_REG_POC_CHG_CONFIG_MASK,
538 BQ24190_REG_POC_CHG_CONFIG_SHIFT, val);
540 pm_runtime_mark_last_busy(bdi->dev);
541 pm_runtime_put_autosuspend(bdi->dev);
546 static int bq24190_vbus_enable(struct regulator_dev *dev)
548 return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_OTG);
551 static int bq24190_vbus_disable(struct regulator_dev *dev)
553 return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_CHARGE);
556 static int bq24190_vbus_is_enabled(struct regulator_dev *dev)
558 struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
562 ret = pm_runtime_get_sync(bdi->dev);
564 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
565 pm_runtime_put_noidle(bdi->dev);
569 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
570 BQ24190_REG_POC_CHG_CONFIG_MASK,
571 BQ24190_REG_POC_CHG_CONFIG_SHIFT, &val);
573 pm_runtime_mark_last_busy(bdi->dev);
574 pm_runtime_put_autosuspend(bdi->dev);
579 return (val == BQ24190_REG_POC_CHG_CONFIG_OTG ||
580 val == BQ24190_REG_POC_CHG_CONFIG_OTG_ALT);
583 static const struct regulator_ops bq24190_vbus_ops = {
584 .enable = bq24190_vbus_enable,
585 .disable = bq24190_vbus_disable,
586 .is_enabled = bq24190_vbus_is_enabled,
589 static const struct regulator_desc bq24190_vbus_desc = {
590 .name = "usb_otg_vbus",
591 .type = REGULATOR_VOLTAGE,
592 .owner = THIS_MODULE,
593 .ops = &bq24190_vbus_ops,
598 static const struct regulator_init_data bq24190_vbus_init_data = {
600 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
604 static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
606 struct bq24190_platform_data *pdata = bdi->dev->platform_data;
607 struct regulator_config cfg = { };
608 struct regulator_dev *reg;
612 if (pdata && pdata->regulator_init_data)
613 cfg.init_data = pdata->regulator_init_data;
615 cfg.init_data = &bq24190_vbus_init_data;
616 cfg.driver_data = bdi;
617 reg = devm_regulator_register(bdi->dev, &bq24190_vbus_desc, &cfg);
620 dev_err(bdi->dev, "Can't register regulator: %d\n", ret);
626 static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
632 static int bq24190_set_config(struct bq24190_dev_info *bdi)
637 ret = bq24190_read(bdi, BQ24190_REG_CTTC, &v);
641 bdi->watchdog = ((v & BQ24190_REG_CTTC_WATCHDOG_MASK) >>
642 BQ24190_REG_CTTC_WATCHDOG_SHIFT);
645 * According to the "Host Mode and default Mode" section of the
646 * manual, a write to any register causes the bq24190 to switch
647 * from default mode to host mode. It will switch back to default
648 * mode after a WDT timeout unless the WDT is turned off as well.
649 * So, by simply turning off the WDT, we accomplish both with the
652 v &= ~BQ24190_REG_CTTC_WATCHDOG_MASK;
654 ret = bq24190_write(bdi, BQ24190_REG_CTTC, v);
659 v = bdi->sys_min / 100 - 30; // manual section 9.5.1.2, table 9
660 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
661 BQ24190_REG_POC_SYS_MIN_MASK,
662 BQ24190_REG_POC_SYS_MIN_SHIFT,
669 v = bdi->iprechg / 128 - 1; // manual section 9.5.1.4, table 11
670 ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
671 BQ24190_REG_PCTCC_IPRECHG_MASK,
672 BQ24190_REG_PCTCC_IPRECHG_SHIFT,
679 v = bdi->iterm / 128 - 1; // manual section 9.5.1.4, table 11
680 ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
681 BQ24190_REG_PCTCC_ITERM_MASK,
682 BQ24190_REG_PCTCC_ITERM_SHIFT,
691 static int bq24190_register_reset(struct bq24190_dev_info *bdi)
693 int ret, limit = 100;
696 if (device_property_read_bool(bdi->dev, "disable-reset"))
699 /* Reset the registers */
700 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
701 BQ24190_REG_POC_RESET_MASK,
702 BQ24190_REG_POC_RESET_SHIFT,
707 /* Reset bit will be cleared by hardware so poll until it is */
709 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
710 BQ24190_REG_POC_RESET_MASK,
711 BQ24190_REG_POC_RESET_SHIFT,
719 usleep_range(100, 200);
725 /* Charger power supply property routines */
727 static int bq24190_charger_get_charge_type(struct bq24190_dev_info *bdi,
728 union power_supply_propval *val)
733 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
734 BQ24190_REG_POC_CHG_CONFIG_MASK,
735 BQ24190_REG_POC_CHG_CONFIG_SHIFT,
740 /* If POC[CHG_CONFIG] (REG01[5:4]) == 0, charge is disabled */
742 type = POWER_SUPPLY_CHARGE_TYPE_NONE;
744 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
745 BQ24190_REG_CCC_FORCE_20PCT_MASK,
746 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
751 type = (v) ? POWER_SUPPLY_CHARGE_TYPE_TRICKLE :
752 POWER_SUPPLY_CHARGE_TYPE_FAST;
760 static int bq24190_charger_set_charge_type(struct bq24190_dev_info *bdi,
761 const union power_supply_propval *val)
763 u8 chg_config, force_20pct, en_term;
767 * According to the "Termination when REG02[0] = 1" section of
768 * the bq24190 manual, the trickle charge could be less than the
769 * termination current so it recommends turning off the termination
772 * Note: AFAICT from the datasheet, the user will have to manually
773 * turn off the charging when in 20% mode. If its not turned off,
774 * there could be battery damage. So, use this mode at your own risk.
776 switch (val->intval) {
777 case POWER_SUPPLY_CHARGE_TYPE_NONE:
780 case POWER_SUPPLY_CHARGE_TYPE_TRICKLE:
785 case POWER_SUPPLY_CHARGE_TYPE_FAST:
794 if (chg_config) { /* Enabling the charger */
795 ret = bq24190_write_mask(bdi, BQ24190_REG_CCC,
796 BQ24190_REG_CCC_FORCE_20PCT_MASK,
797 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
802 ret = bq24190_write_mask(bdi, BQ24190_REG_CTTC,
803 BQ24190_REG_CTTC_EN_TERM_MASK,
804 BQ24190_REG_CTTC_EN_TERM_SHIFT,
810 return bq24190_write_mask(bdi, BQ24190_REG_POC,
811 BQ24190_REG_POC_CHG_CONFIG_MASK,
812 BQ24190_REG_POC_CHG_CONFIG_SHIFT, chg_config);
815 static int bq24190_charger_get_health(struct bq24190_dev_info *bdi,
816 union power_supply_propval *val)
821 mutex_lock(&bdi->f_reg_lock);
823 mutex_unlock(&bdi->f_reg_lock);
825 if (v & BQ24190_REG_F_NTC_FAULT_MASK) {
826 switch (v >> BQ24190_REG_F_NTC_FAULT_SHIFT & 0x7) {
827 case 0x1: /* TS1 Cold */
828 case 0x3: /* TS2 Cold */
829 case 0x5: /* Both Cold */
830 health = POWER_SUPPLY_HEALTH_COLD;
832 case 0x2: /* TS1 Hot */
833 case 0x4: /* TS2 Hot */
834 case 0x6: /* Both Hot */
835 health = POWER_SUPPLY_HEALTH_OVERHEAT;
838 health = POWER_SUPPLY_HEALTH_UNKNOWN;
840 } else if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
841 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
842 } else if (v & BQ24190_REG_F_CHRG_FAULT_MASK) {
843 switch (v >> BQ24190_REG_F_CHRG_FAULT_SHIFT & 0x3) {
844 case 0x1: /* Input Fault (VBUS OVP or VBAT<VBUS<3.8V) */
846 * This could be over-voltage or under-voltage
847 * and there's no way to tell which. Instead
848 * of looking foolish and returning 'OVERVOLTAGE'
849 * when its really under-voltage, just return
852 health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
854 case 0x2: /* Thermal Shutdown */
855 health = POWER_SUPPLY_HEALTH_OVERHEAT;
857 case 0x3: /* Charge Safety Timer Expiration */
858 health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
860 default: /* prevent compiler warning */
863 } else if (v & BQ24190_REG_F_BOOST_FAULT_MASK) {
865 * This could be over-current or over-voltage but there's
866 * no way to tell which. Return 'OVERVOLTAGE' since there
867 * isn't an 'OVERCURRENT' value defined that we can return
868 * even if it was over-current.
870 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
872 health = POWER_SUPPLY_HEALTH_GOOD;
875 val->intval = health;
880 static int bq24190_charger_get_online(struct bq24190_dev_info *bdi,
881 union power_supply_propval *val)
883 u8 pg_stat, batfet_disable;
886 ret = bq24190_read_mask(bdi, BQ24190_REG_SS,
887 BQ24190_REG_SS_PG_STAT_MASK,
888 BQ24190_REG_SS_PG_STAT_SHIFT, &pg_stat);
892 ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
893 BQ24190_REG_MOC_BATFET_DISABLE_MASK,
894 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
898 val->intval = pg_stat && !batfet_disable;
903 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
904 const union power_supply_propval *val);
905 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
906 union power_supply_propval *val);
907 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
908 union power_supply_propval *val);
909 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
910 const union power_supply_propval *val);
912 static int bq24190_charger_set_online(struct bq24190_dev_info *bdi,
913 const union power_supply_propval *val)
915 return bq24190_battery_set_online(bdi, val);
918 static int bq24190_charger_get_status(struct bq24190_dev_info *bdi,
919 union power_supply_propval *val)
921 return bq24190_battery_get_status(bdi, val);
924 static int bq24190_charger_get_temp_alert_max(struct bq24190_dev_info *bdi,
925 union power_supply_propval *val)
927 return bq24190_battery_get_temp_alert_max(bdi, val);
930 static int bq24190_charger_set_temp_alert_max(struct bq24190_dev_info *bdi,
931 const union power_supply_propval *val)
933 return bq24190_battery_set_temp_alert_max(bdi, val);
936 static int bq24190_charger_get_precharge(struct bq24190_dev_info *bdi,
937 union power_supply_propval *val)
942 ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
943 BQ24190_REG_PCTCC_IPRECHG_MASK,
944 BQ24190_REG_PCTCC_IPRECHG_SHIFT, &v);
948 val->intval = ++v * 128 * 1000;
952 static int bq24190_charger_get_charge_term(struct bq24190_dev_info *bdi,
953 union power_supply_propval *val)
958 ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
959 BQ24190_REG_PCTCC_ITERM_MASK,
960 BQ24190_REG_PCTCC_ITERM_SHIFT, &v);
964 val->intval = ++v * 128 * 1000;
968 static int bq24190_charger_get_current(struct bq24190_dev_info *bdi,
969 union power_supply_propval *val)
974 ret = bq24190_get_field_val(bdi, BQ24190_REG_CCC,
975 BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
976 bq24190_ccc_ichg_values,
977 ARRAY_SIZE(bq24190_ccc_ichg_values), &curr);
981 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
982 BQ24190_REG_CCC_FORCE_20PCT_MASK,
983 BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
987 /* If FORCE_20PCT is enabled, then current is 20% of ICHG value */
995 static int bq24190_charger_get_current_max(struct bq24190_dev_info *bdi,
996 union power_supply_propval *val)
998 int idx = ARRAY_SIZE(bq24190_ccc_ichg_values) - 1;
1000 val->intval = bq24190_ccc_ichg_values[idx];
1004 static int bq24190_charger_set_current(struct bq24190_dev_info *bdi,
1005 const union power_supply_propval *val)
1008 int ret, curr = val->intval;
1010 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
1011 BQ24190_REG_CCC_FORCE_20PCT_MASK,
1012 BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
1016 /* If FORCE_20PCT is enabled, have to multiply value passed in by 5 */
1020 return bq24190_set_field_val(bdi, BQ24190_REG_CCC,
1021 BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
1022 bq24190_ccc_ichg_values,
1023 ARRAY_SIZE(bq24190_ccc_ichg_values), curr);
1026 static int bq24190_charger_get_voltage(struct bq24190_dev_info *bdi,
1027 union power_supply_propval *val)
1031 ret = bq24190_get_field_val(bdi, BQ24190_REG_CVC,
1032 BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
1033 bq24190_cvc_vreg_values,
1034 ARRAY_SIZE(bq24190_cvc_vreg_values), &voltage);
1038 val->intval = voltage;
1042 static int bq24190_charger_get_voltage_max(struct bq24190_dev_info *bdi,
1043 union power_supply_propval *val)
1045 int idx = ARRAY_SIZE(bq24190_cvc_vreg_values) - 1;
1047 val->intval = bq24190_cvc_vreg_values[idx];
1051 static int bq24190_charger_set_voltage(struct bq24190_dev_info *bdi,
1052 const union power_supply_propval *val)
1054 return bq24190_set_field_val(bdi, BQ24190_REG_CVC,
1055 BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
1056 bq24190_cvc_vreg_values,
1057 ARRAY_SIZE(bq24190_cvc_vreg_values), val->intval);
1060 static int bq24190_charger_get_iinlimit(struct bq24190_dev_info *bdi,
1061 union power_supply_propval *val)
1065 ret = bq24190_get_field_val(bdi, BQ24190_REG_ISC,
1066 BQ24190_REG_ISC_IINLIM_MASK,
1067 BQ24190_REG_ISC_IINLIM_SHIFT,
1068 bq24190_isc_iinlim_values,
1069 ARRAY_SIZE(bq24190_isc_iinlim_values), &iinlimit);
1073 val->intval = iinlimit;
1077 static int bq24190_charger_set_iinlimit(struct bq24190_dev_info *bdi,
1078 const union power_supply_propval *val)
1080 return bq24190_set_field_val(bdi, BQ24190_REG_ISC,
1081 BQ24190_REG_ISC_IINLIM_MASK,
1082 BQ24190_REG_ISC_IINLIM_SHIFT,
1083 bq24190_isc_iinlim_values,
1084 ARRAY_SIZE(bq24190_isc_iinlim_values), val->intval);
1087 static int bq24190_charger_get_property(struct power_supply *psy,
1088 enum power_supply_property psp, union power_supply_propval *val)
1090 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1093 dev_dbg(bdi->dev, "prop: %d\n", psp);
1095 ret = pm_runtime_get_sync(bdi->dev);
1097 pm_runtime_put_noidle(bdi->dev);
1102 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1103 ret = bq24190_charger_get_charge_type(bdi, val);
1105 case POWER_SUPPLY_PROP_HEALTH:
1106 ret = bq24190_charger_get_health(bdi, val);
1108 case POWER_SUPPLY_PROP_ONLINE:
1109 ret = bq24190_charger_get_online(bdi, val);
1111 case POWER_SUPPLY_PROP_STATUS:
1112 ret = bq24190_charger_get_status(bdi, val);
1114 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1115 ret = bq24190_charger_get_temp_alert_max(bdi, val);
1117 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1118 ret = bq24190_charger_get_precharge(bdi, val);
1120 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1121 ret = bq24190_charger_get_charge_term(bdi, val);
1123 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1124 ret = bq24190_charger_get_current(bdi, val);
1126 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
1127 ret = bq24190_charger_get_current_max(bdi, val);
1129 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1130 ret = bq24190_charger_get_voltage(bdi, val);
1132 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
1133 ret = bq24190_charger_get_voltage_max(bdi, val);
1135 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1136 ret = bq24190_charger_get_iinlimit(bdi, val);
1138 case POWER_SUPPLY_PROP_SCOPE:
1139 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1142 case POWER_SUPPLY_PROP_MODEL_NAME:
1143 val->strval = bdi->model_name;
1146 case POWER_SUPPLY_PROP_MANUFACTURER:
1147 val->strval = BQ24190_MANUFACTURER;
1154 pm_runtime_mark_last_busy(bdi->dev);
1155 pm_runtime_put_autosuspend(bdi->dev);
1160 static int bq24190_charger_set_property(struct power_supply *psy,
1161 enum power_supply_property psp,
1162 const union power_supply_propval *val)
1164 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1167 dev_dbg(bdi->dev, "prop: %d\n", psp);
1169 ret = pm_runtime_get_sync(bdi->dev);
1171 pm_runtime_put_noidle(bdi->dev);
1176 case POWER_SUPPLY_PROP_ONLINE:
1177 ret = bq24190_charger_set_online(bdi, val);
1179 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1180 ret = bq24190_charger_set_temp_alert_max(bdi, val);
1182 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1183 ret = bq24190_charger_set_charge_type(bdi, val);
1185 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1186 ret = bq24190_charger_set_current(bdi, val);
1188 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1189 ret = bq24190_charger_set_voltage(bdi, val);
1191 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1192 ret = bq24190_charger_set_iinlimit(bdi, val);
1198 pm_runtime_mark_last_busy(bdi->dev);
1199 pm_runtime_put_autosuspend(bdi->dev);
1204 static int bq24190_charger_property_is_writeable(struct power_supply *psy,
1205 enum power_supply_property psp)
1210 case POWER_SUPPLY_PROP_ONLINE:
1211 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1212 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1213 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1214 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1215 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1225 static void bq24190_input_current_limit_work(struct work_struct *work)
1227 struct bq24190_dev_info *bdi =
1228 container_of(work, struct bq24190_dev_info,
1229 input_current_limit_work.work);
1231 power_supply_set_input_current_limit_from_supplier(bdi->charger);
1234 /* Sync the input-current-limit with our parent supply (if we have one) */
1235 static void bq24190_charger_external_power_changed(struct power_supply *psy)
1237 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1240 * The Power-Good detection may take up to 220ms, sometimes
1241 * the external charger detection is quicker, and the bq24190 will
1242 * reset to iinlim based on its own charger detection (which is not
1243 * hooked up when using external charger detection) resulting in a
1244 * too low default 500mA iinlim. Delay setting the input-current-limit
1245 * for 300ms to avoid this.
1247 queue_delayed_work(system_wq, &bdi->input_current_limit_work,
1248 msecs_to_jiffies(300));
1251 static enum power_supply_property bq24190_charger_properties[] = {
1252 POWER_SUPPLY_PROP_CHARGE_TYPE,
1253 POWER_SUPPLY_PROP_HEALTH,
1254 POWER_SUPPLY_PROP_ONLINE,
1255 POWER_SUPPLY_PROP_STATUS,
1256 POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1257 POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
1258 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
1259 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1260 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
1261 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1262 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
1263 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1264 POWER_SUPPLY_PROP_SCOPE,
1265 POWER_SUPPLY_PROP_MODEL_NAME,
1266 POWER_SUPPLY_PROP_MANUFACTURER,
1269 static char *bq24190_charger_supplied_to[] = {
1273 static const struct power_supply_desc bq24190_charger_desc = {
1274 .name = "bq24190-charger",
1275 .type = POWER_SUPPLY_TYPE_USB,
1276 .properties = bq24190_charger_properties,
1277 .num_properties = ARRAY_SIZE(bq24190_charger_properties),
1278 .get_property = bq24190_charger_get_property,
1279 .set_property = bq24190_charger_set_property,
1280 .property_is_writeable = bq24190_charger_property_is_writeable,
1281 .external_power_changed = bq24190_charger_external_power_changed,
1284 /* Battery power supply property routines */
1286 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
1287 union power_supply_propval *val)
1289 u8 ss_reg, chrg_fault;
1292 mutex_lock(&bdi->f_reg_lock);
1293 chrg_fault = bdi->f_reg;
1294 mutex_unlock(&bdi->f_reg_lock);
1296 chrg_fault &= BQ24190_REG_F_CHRG_FAULT_MASK;
1297 chrg_fault >>= BQ24190_REG_F_CHRG_FAULT_SHIFT;
1299 ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1304 * The battery must be discharging when any of these are true:
1305 * - there is no good power source;
1306 * - there is a charge fault.
1307 * Could also be discharging when in "supplement mode" but
1308 * there is no way to tell when its in that mode.
1310 if (!(ss_reg & BQ24190_REG_SS_PG_STAT_MASK) || chrg_fault) {
1311 status = POWER_SUPPLY_STATUS_DISCHARGING;
1313 ss_reg &= BQ24190_REG_SS_CHRG_STAT_MASK;
1314 ss_reg >>= BQ24190_REG_SS_CHRG_STAT_SHIFT;
1317 case 0x0: /* Not Charging */
1318 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1320 case 0x1: /* Pre-charge */
1321 case 0x2: /* Fast Charging */
1322 status = POWER_SUPPLY_STATUS_CHARGING;
1324 case 0x3: /* Charge Termination Done */
1325 status = POWER_SUPPLY_STATUS_FULL;
1333 val->intval = status;
1338 static int bq24190_battery_get_health(struct bq24190_dev_info *bdi,
1339 union power_supply_propval *val)
1344 mutex_lock(&bdi->f_reg_lock);
1346 mutex_unlock(&bdi->f_reg_lock);
1348 if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
1349 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1351 v &= BQ24190_REG_F_NTC_FAULT_MASK;
1352 v >>= BQ24190_REG_F_NTC_FAULT_SHIFT;
1355 case 0x0: /* Normal */
1356 health = POWER_SUPPLY_HEALTH_GOOD;
1358 case 0x1: /* TS1 Cold */
1359 case 0x3: /* TS2 Cold */
1360 case 0x5: /* Both Cold */
1361 health = POWER_SUPPLY_HEALTH_COLD;
1363 case 0x2: /* TS1 Hot */
1364 case 0x4: /* TS2 Hot */
1365 case 0x6: /* Both Hot */
1366 health = POWER_SUPPLY_HEALTH_OVERHEAT;
1369 health = POWER_SUPPLY_HEALTH_UNKNOWN;
1373 val->intval = health;
1377 static int bq24190_battery_get_online(struct bq24190_dev_info *bdi,
1378 union power_supply_propval *val)
1383 ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
1384 BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1385 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
1389 val->intval = !batfet_disable;
1393 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
1394 const union power_supply_propval *val)
1396 return bq24190_write_mask(bdi, BQ24190_REG_MOC,
1397 BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1398 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, !val->intval);
1401 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
1402 union power_supply_propval *val)
1406 ret = bq24190_get_field_val(bdi, BQ24190_REG_ICTRC,
1407 BQ24190_REG_ICTRC_TREG_MASK,
1408 BQ24190_REG_ICTRC_TREG_SHIFT,
1409 bq24190_ictrc_treg_values,
1410 ARRAY_SIZE(bq24190_ictrc_treg_values), &temp);
1418 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
1419 const union power_supply_propval *val)
1421 return bq24190_set_field_val(bdi, BQ24190_REG_ICTRC,
1422 BQ24190_REG_ICTRC_TREG_MASK,
1423 BQ24190_REG_ICTRC_TREG_SHIFT,
1424 bq24190_ictrc_treg_values,
1425 ARRAY_SIZE(bq24190_ictrc_treg_values), val->intval);
1428 static int bq24190_battery_get_property(struct power_supply *psy,
1429 enum power_supply_property psp, union power_supply_propval *val)
1431 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1434 dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1435 dev_dbg(bdi->dev, "prop: %d\n", psp);
1437 ret = pm_runtime_get_sync(bdi->dev);
1439 pm_runtime_put_noidle(bdi->dev);
1444 case POWER_SUPPLY_PROP_STATUS:
1445 ret = bq24190_battery_get_status(bdi, val);
1447 case POWER_SUPPLY_PROP_HEALTH:
1448 ret = bq24190_battery_get_health(bdi, val);
1450 case POWER_SUPPLY_PROP_ONLINE:
1451 ret = bq24190_battery_get_online(bdi, val);
1453 case POWER_SUPPLY_PROP_TECHNOLOGY:
1454 /* Could be Li-on or Li-polymer but no way to tell which */
1455 val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
1458 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1459 ret = bq24190_battery_get_temp_alert_max(bdi, val);
1461 case POWER_SUPPLY_PROP_SCOPE:
1462 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1469 pm_runtime_mark_last_busy(bdi->dev);
1470 pm_runtime_put_autosuspend(bdi->dev);
1475 static int bq24190_battery_set_property(struct power_supply *psy,
1476 enum power_supply_property psp,
1477 const union power_supply_propval *val)
1479 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1482 dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1483 dev_dbg(bdi->dev, "prop: %d\n", psp);
1485 ret = pm_runtime_get_sync(bdi->dev);
1487 pm_runtime_put_noidle(bdi->dev);
1492 case POWER_SUPPLY_PROP_ONLINE:
1493 ret = bq24190_battery_set_online(bdi, val);
1495 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1496 ret = bq24190_battery_set_temp_alert_max(bdi, val);
1502 pm_runtime_mark_last_busy(bdi->dev);
1503 pm_runtime_put_autosuspend(bdi->dev);
1508 static int bq24190_battery_property_is_writeable(struct power_supply *psy,
1509 enum power_supply_property psp)
1514 case POWER_SUPPLY_PROP_ONLINE:
1515 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1525 static enum power_supply_property bq24190_battery_properties[] = {
1526 POWER_SUPPLY_PROP_STATUS,
1527 POWER_SUPPLY_PROP_HEALTH,
1528 POWER_SUPPLY_PROP_ONLINE,
1529 POWER_SUPPLY_PROP_TECHNOLOGY,
1530 POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1531 POWER_SUPPLY_PROP_SCOPE,
1534 static const struct power_supply_desc bq24190_battery_desc = {
1535 .name = "bq24190-battery",
1536 .type = POWER_SUPPLY_TYPE_BATTERY,
1537 .properties = bq24190_battery_properties,
1538 .num_properties = ARRAY_SIZE(bq24190_battery_properties),
1539 .get_property = bq24190_battery_get_property,
1540 .set_property = bq24190_battery_set_property,
1541 .property_is_writeable = bq24190_battery_property_is_writeable,
1544 static void bq24190_check_status(struct bq24190_dev_info *bdi)
1546 const u8 battery_mask_ss = BQ24190_REG_SS_CHRG_STAT_MASK;
1547 const u8 battery_mask_f = BQ24190_REG_F_BAT_FAULT_MASK
1548 | BQ24190_REG_F_NTC_FAULT_MASK;
1549 bool alert_charger = false, alert_battery = false;
1550 u8 ss_reg = 0, f_reg = 0;
1553 ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1555 dev_err(bdi->dev, "Can't read SS reg: %d\n", ret);
1561 ret = bq24190_read(bdi, BQ24190_REG_F, &f_reg);
1563 dev_err(bdi->dev, "Can't read F reg: %d\n", ret);
1566 } while (f_reg && ++i < 2);
1568 /* ignore over/under voltage fault after disconnect */
1569 if (f_reg == (1 << BQ24190_REG_F_CHRG_FAULT_SHIFT) &&
1570 !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK))
1573 if (f_reg != bdi->f_reg) {
1575 "Fault: boost %d, charge %d, battery %d, ntc %d\n",
1576 !!(f_reg & BQ24190_REG_F_BOOST_FAULT_MASK),
1577 !!(f_reg & BQ24190_REG_F_CHRG_FAULT_MASK),
1578 !!(f_reg & BQ24190_REG_F_BAT_FAULT_MASK),
1579 !!(f_reg & BQ24190_REG_F_NTC_FAULT_MASK));
1581 mutex_lock(&bdi->f_reg_lock);
1582 if ((bdi->f_reg & battery_mask_f) != (f_reg & battery_mask_f))
1583 alert_battery = true;
1584 if ((bdi->f_reg & ~battery_mask_f) != (f_reg & ~battery_mask_f))
1585 alert_charger = true;
1587 mutex_unlock(&bdi->f_reg_lock);
1590 if (ss_reg != bdi->ss_reg) {
1592 * The device is in host mode so when PG_STAT goes from 1->0
1593 * (i.e., power removed) HIZ needs to be disabled.
1595 if ((bdi->ss_reg & BQ24190_REG_SS_PG_STAT_MASK) &&
1596 !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK)) {
1597 ret = bq24190_write_mask(bdi, BQ24190_REG_ISC,
1598 BQ24190_REG_ISC_EN_HIZ_MASK,
1599 BQ24190_REG_ISC_EN_HIZ_SHIFT,
1602 dev_err(bdi->dev, "Can't access ISC reg: %d\n",
1606 if ((bdi->ss_reg & battery_mask_ss) != (ss_reg & battery_mask_ss))
1607 alert_battery = true;
1608 if ((bdi->ss_reg & ~battery_mask_ss) != (ss_reg & ~battery_mask_ss))
1609 alert_charger = true;
1610 bdi->ss_reg = ss_reg;
1613 if (alert_charger || alert_battery)
1614 power_supply_changed(bdi->charger);
1615 if (alert_battery && bdi->battery)
1616 power_supply_changed(bdi->battery);
1618 dev_dbg(bdi->dev, "ss_reg: 0x%02x, f_reg: 0x%02x\n", ss_reg, f_reg);
1621 static irqreturn_t bq24190_irq_handler_thread(int irq, void *data)
1623 struct bq24190_dev_info *bdi = data;
1626 bdi->irq_event = true;
1627 error = pm_runtime_get_sync(bdi->dev);
1629 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1630 pm_runtime_put_noidle(bdi->dev);
1633 bq24190_check_status(bdi);
1634 pm_runtime_mark_last_busy(bdi->dev);
1635 pm_runtime_put_autosuspend(bdi->dev);
1636 bdi->irq_event = false;
1641 static void bq24190_extcon_work(struct work_struct *work)
1643 struct bq24190_dev_info *bdi =
1644 container_of(work, struct bq24190_dev_info, extcon_work.work);
1645 int error, iinlim = 0;
1648 error = pm_runtime_get_sync(bdi->dev);
1650 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1651 pm_runtime_put_noidle(bdi->dev);
1655 if (extcon_get_state(bdi->extcon, EXTCON_CHG_USB_SDP) == 1)
1657 else if (extcon_get_state(bdi->extcon, EXTCON_CHG_USB_CDP) == 1 ||
1658 extcon_get_state(bdi->extcon, EXTCON_CHG_USB_ACA) == 1)
1660 else if (extcon_get_state(bdi->extcon, EXTCON_CHG_USB_DCP) == 1)
1664 error = bq24190_set_field_val(bdi, BQ24190_REG_ISC,
1665 BQ24190_REG_ISC_IINLIM_MASK,
1666 BQ24190_REG_ISC_IINLIM_SHIFT,
1667 bq24190_isc_iinlim_values,
1668 ARRAY_SIZE(bq24190_isc_iinlim_values),
1671 dev_err(bdi->dev, "Can't set IINLIM: %d\n", error);
1674 /* if no charger found and in USB host mode, set OTG 5V boost, else normal */
1675 if (!iinlim && extcon_get_state(bdi->extcon, EXTCON_USB_HOST) == 1)
1676 v = BQ24190_REG_POC_CHG_CONFIG_OTG;
1678 v = BQ24190_REG_POC_CHG_CONFIG_CHARGE;
1680 error = bq24190_write_mask(bdi, BQ24190_REG_POC,
1681 BQ24190_REG_POC_CHG_CONFIG_MASK,
1682 BQ24190_REG_POC_CHG_CONFIG_SHIFT,
1685 dev_err(bdi->dev, "Can't set CHG_CONFIG: %d\n", error);
1687 pm_runtime_mark_last_busy(bdi->dev);
1688 pm_runtime_put_autosuspend(bdi->dev);
1691 static int bq24190_extcon_event(struct notifier_block *nb, unsigned long event,
1694 struct bq24190_dev_info *bdi =
1695 container_of(nb, struct bq24190_dev_info, extcon_nb);
1698 * The Power-Good detection may take up to 220ms, sometimes
1699 * the external charger detection is quicker, and the bq24190 will
1700 * reset to iinlim based on its own charger detection (which is not
1701 * hooked up when using external charger detection) resulting in
1702 * a too low default 500mA iinlim. Delay applying the extcon value
1703 * for 300ms to avoid this.
1705 queue_delayed_work(system_wq, &bdi->extcon_work, msecs_to_jiffies(300));
1710 static int bq24190_hw_init(struct bq24190_dev_info *bdi)
1715 /* First check that the device really is what its supposed to be */
1716 ret = bq24190_read_mask(bdi, BQ24190_REG_VPRS,
1717 BQ24190_REG_VPRS_PN_MASK,
1718 BQ24190_REG_VPRS_PN_SHIFT,
1723 if (v != BQ24190_REG_VPRS_PN_24190 &&
1724 v != BQ24190_REG_VPRS_PN_24192I) {
1725 dev_err(bdi->dev, "Error unknown model: 0x%02x\n", v);
1729 ret = bq24190_register_reset(bdi);
1733 ret = bq24190_set_config(bdi);
1737 return bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1740 static int bq24190_get_config(struct bq24190_dev_info *bdi)
1742 const char * const s = "ti,system-minimum-microvolt";
1743 struct power_supply_battery_info info = {};
1746 if (device_property_read_u32(bdi->dev, s, &v) == 0) {
1748 if (v >= BQ24190_REG_POC_SYS_MIN_MIN
1749 && v <= BQ24190_REG_POC_SYS_MIN_MAX)
1752 dev_warn(bdi->dev, "invalid value for %s: %u\n", s, v);
1755 if (bdi->dev->of_node &&
1756 !power_supply_get_battery_info(bdi->charger, &info)) {
1757 v = info.precharge_current_ua / 1000;
1758 if (v >= BQ24190_REG_PCTCC_IPRECHG_MIN
1759 && v <= BQ24190_REG_PCTCC_IPRECHG_MAX)
1762 dev_warn(bdi->dev, "invalid value for battery:precharge-current-microamp: %d\n",
1765 v = info.charge_term_current_ua / 1000;
1766 if (v >= BQ24190_REG_PCTCC_ITERM_MIN
1767 && v <= BQ24190_REG_PCTCC_ITERM_MAX)
1770 dev_warn(bdi->dev, "invalid value for battery:charge-term-current-microamp: %d\n",
1777 static int bq24190_probe(struct i2c_client *client,
1778 const struct i2c_device_id *id)
1780 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
1781 struct device *dev = &client->dev;
1782 struct power_supply_config charger_cfg = {}, battery_cfg = {};
1783 struct bq24190_dev_info *bdi;
1787 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1788 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1792 bdi = devm_kzalloc(dev, sizeof(*bdi), GFP_KERNEL);
1794 dev_err(dev, "Can't alloc bdi struct\n");
1798 bdi->client = client;
1800 strncpy(bdi->model_name, id->name, I2C_NAME_SIZE);
1801 mutex_init(&bdi->f_reg_lock);
1803 bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1804 INIT_DELAYED_WORK(&bdi->input_current_limit_work,
1805 bq24190_input_current_limit_work);
1807 i2c_set_clientdata(client, bdi);
1809 if (client->irq <= 0) {
1810 dev_err(dev, "Can't get irq info\n");
1815 * Devicetree platforms should get extcon via phandle (not yet supported).
1816 * On ACPI platforms, extcon clients may invoke us with:
1817 * struct property_entry pe[] =
1818 * { PROPERTY_ENTRY_STRING("extcon-name", client_name), ... };
1819 * struct i2c_board_info bi =
1820 * { .type = "bq24190", .addr = 0x6b, .properties = pe, .irq = irq };
1821 * struct i2c_adapter ad = { ... };
1822 * i2c_add_adapter(&ad);
1823 * i2c_new_device(&ad, &bi);
1825 if (device_property_read_string(dev, "extcon-name", &name) == 0) {
1826 bdi->extcon = extcon_get_extcon_dev(name);
1828 return -EPROBE_DEFER;
1830 dev_info(bdi->dev, "using extcon device %s\n", name);
1833 pm_runtime_enable(dev);
1834 pm_runtime_use_autosuspend(dev);
1835 pm_runtime_set_autosuspend_delay(dev, 600);
1836 ret = pm_runtime_get_sync(dev);
1838 dev_err(dev, "pm_runtime_get failed: %i\n", ret);
1842 charger_cfg.drv_data = bdi;
1843 charger_cfg.of_node = dev->of_node;
1844 charger_cfg.supplied_to = bq24190_charger_supplied_to;
1845 charger_cfg.num_supplicants = ARRAY_SIZE(bq24190_charger_supplied_to),
1846 bdi->charger = power_supply_register(dev, &bq24190_charger_desc,
1848 if (IS_ERR(bdi->charger)) {
1849 dev_err(dev, "Can't register charger\n");
1850 ret = PTR_ERR(bdi->charger);
1854 /* the battery class is deprecated and will be removed. */
1855 /* in the interim, this property hides it. */
1856 if (!device_property_read_bool(dev, "omit-battery-class")) {
1857 battery_cfg.drv_data = bdi;
1858 bdi->battery = power_supply_register(dev, &bq24190_battery_desc,
1860 if (IS_ERR(bdi->battery)) {
1861 dev_err(dev, "Can't register battery\n");
1862 ret = PTR_ERR(bdi->battery);
1867 ret = bq24190_get_config(bdi);
1869 dev_err(dev, "Can't get devicetree config\n");
1873 ret = bq24190_hw_init(bdi);
1875 dev_err(dev, "Hardware init failed\n");
1879 ret = bq24190_sysfs_create_group(bdi);
1881 dev_err(dev, "Can't create sysfs entries\n");
1885 bdi->initialized = true;
1887 ret = devm_request_threaded_irq(dev, client->irq, NULL,
1888 bq24190_irq_handler_thread,
1889 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1890 "bq24190-charger", bdi);
1892 dev_err(dev, "Can't set up irq handler\n");
1896 ret = bq24190_register_vbus_regulator(bdi);
1901 INIT_DELAYED_WORK(&bdi->extcon_work, bq24190_extcon_work);
1902 bdi->extcon_nb.notifier_call = bq24190_extcon_event;
1903 ret = devm_extcon_register_notifier_all(dev, bdi->extcon,
1906 dev_err(dev, "Can't register extcon\n");
1910 /* Sync initial cable state */
1911 queue_delayed_work(system_wq, &bdi->extcon_work, 0);
1914 enable_irq_wake(client->irq);
1916 pm_runtime_mark_last_busy(dev);
1917 pm_runtime_put_autosuspend(dev);
1922 bq24190_sysfs_remove_group(bdi);
1925 if (!IS_ERR_OR_NULL(bdi->battery))
1926 power_supply_unregister(bdi->battery);
1927 power_supply_unregister(bdi->charger);
1930 pm_runtime_put_sync(dev);
1931 pm_runtime_dont_use_autosuspend(dev);
1932 pm_runtime_disable(dev);
1936 static int bq24190_remove(struct i2c_client *client)
1938 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1941 error = pm_runtime_get_sync(bdi->dev);
1943 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1944 pm_runtime_put_noidle(bdi->dev);
1947 bq24190_register_reset(bdi);
1948 bq24190_sysfs_remove_group(bdi);
1950 power_supply_unregister(bdi->battery);
1951 power_supply_unregister(bdi->charger);
1953 pm_runtime_put_sync(bdi->dev);
1954 pm_runtime_dont_use_autosuspend(bdi->dev);
1955 pm_runtime_disable(bdi->dev);
1960 static __maybe_unused int bq24190_runtime_suspend(struct device *dev)
1962 struct i2c_client *client = to_i2c_client(dev);
1963 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1965 if (!bdi->initialized)
1968 dev_dbg(bdi->dev, "%s\n", __func__);
1973 static __maybe_unused int bq24190_runtime_resume(struct device *dev)
1975 struct i2c_client *client = to_i2c_client(dev);
1976 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1978 if (!bdi->initialized)
1981 if (!bdi->irq_event) {
1982 dev_dbg(bdi->dev, "checking events on possible wakeirq\n");
1983 bq24190_check_status(bdi);
1989 static __maybe_unused int bq24190_pm_suspend(struct device *dev)
1991 struct i2c_client *client = to_i2c_client(dev);
1992 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1995 error = pm_runtime_get_sync(bdi->dev);
1997 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1998 pm_runtime_put_noidle(bdi->dev);
2001 bq24190_register_reset(bdi);
2004 pm_runtime_mark_last_busy(bdi->dev);
2005 pm_runtime_put_autosuspend(bdi->dev);
2011 static __maybe_unused int bq24190_pm_resume(struct device *dev)
2013 struct i2c_client *client = to_i2c_client(dev);
2014 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
2018 bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
2020 error = pm_runtime_get_sync(bdi->dev);
2022 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
2023 pm_runtime_put_noidle(bdi->dev);
2026 bq24190_register_reset(bdi);
2027 bq24190_set_config(bdi);
2028 bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
2031 pm_runtime_mark_last_busy(bdi->dev);
2032 pm_runtime_put_autosuspend(bdi->dev);
2035 /* Things may have changed while suspended so alert upper layer */
2036 power_supply_changed(bdi->charger);
2038 power_supply_changed(bdi->battery);
2043 static const struct dev_pm_ops bq24190_pm_ops = {
2044 SET_RUNTIME_PM_OPS(bq24190_runtime_suspend, bq24190_runtime_resume,
2046 SET_SYSTEM_SLEEP_PM_OPS(bq24190_pm_suspend, bq24190_pm_resume)
2049 static const struct i2c_device_id bq24190_i2c_ids[] = {
2054 MODULE_DEVICE_TABLE(i2c, bq24190_i2c_ids);
2057 static const struct of_device_id bq24190_of_match[] = {
2058 { .compatible = "ti,bq24190", },
2059 { .compatible = "ti,bq24192i", },
2062 MODULE_DEVICE_TABLE(of, bq24190_of_match);
2064 static const struct of_device_id bq24190_of_match[] = {
2069 static struct i2c_driver bq24190_driver = {
2070 .probe = bq24190_probe,
2071 .remove = bq24190_remove,
2072 .id_table = bq24190_i2c_ids,
2074 .name = "bq24190-charger",
2075 .pm = &bq24190_pm_ops,
2076 .of_match_table = of_match_ptr(bq24190_of_match),
2079 module_i2c_driver(bq24190_driver);
2081 MODULE_LICENSE("GPL");
2082 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
2083 MODULE_DESCRIPTION("TI BQ24190 Charger Driver");