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/of_irq.h>
15 #include <linux/of_device.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/power_supply.h>
18 #include <linux/power/bq24190_charger.h>
19 #include <linux/regulator/driver.h>
20 #include <linux/regulator/machine.h>
21 #include <linux/workqueue.h>
22 #include <linux/gpio.h>
23 #include <linux/i2c.h>
24 #include <linux/extcon-provider.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_SYS_MIN_MASK (BIT(3) | BIT(2) | BIT(1))
48 #define BQ24190_REG_POC_SYS_MIN_SHIFT 1
49 #define BQ24190_REG_POC_SYS_MIN_MIN 3000
50 #define BQ24190_REG_POC_SYS_MIN_MAX 3700
51 #define BQ24190_REG_POC_BOOST_LIM_MASK BIT(0)
52 #define BQ24190_REG_POC_BOOST_LIM_SHIFT 0
54 #define BQ24190_REG_CCC 0x02 /* Charge Current Control */
55 #define BQ24190_REG_CCC_ICHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
56 BIT(4) | BIT(3) | BIT(2))
57 #define BQ24190_REG_CCC_ICHG_SHIFT 2
58 #define BQ24190_REG_CCC_FORCE_20PCT_MASK BIT(0)
59 #define BQ24190_REG_CCC_FORCE_20PCT_SHIFT 0
61 #define BQ24190_REG_PCTCC 0x03 /* Pre-charge/Termination Current Cntl */
62 #define BQ24190_REG_PCTCC_IPRECHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
64 #define BQ24190_REG_PCTCC_IPRECHG_SHIFT 4
65 #define BQ24190_REG_PCTCC_IPRECHG_MIN 128
66 #define BQ24190_REG_PCTCC_IPRECHG_MAX 2048
67 #define BQ24190_REG_PCTCC_ITERM_MASK (BIT(3) | BIT(2) | BIT(1) | \
69 #define BQ24190_REG_PCTCC_ITERM_SHIFT 0
70 #define BQ24190_REG_PCTCC_ITERM_MIN 128
71 #define BQ24190_REG_PCTCC_ITERM_MAX 2048
73 #define BQ24190_REG_CVC 0x04 /* Charge Voltage Control */
74 #define BQ24190_REG_CVC_VREG_MASK (BIT(7) | BIT(6) | BIT(5) | \
75 BIT(4) | BIT(3) | BIT(2))
76 #define BQ24190_REG_CVC_VREG_SHIFT 2
77 #define BQ24190_REG_CVC_BATLOWV_MASK BIT(1)
78 #define BQ24190_REG_CVC_BATLOWV_SHIFT 1
79 #define BQ24190_REG_CVC_VRECHG_MASK BIT(0)
80 #define BQ24190_REG_CVC_VRECHG_SHIFT 0
82 #define BQ24190_REG_CTTC 0x05 /* Charge Term/Timer Control */
83 #define BQ24190_REG_CTTC_EN_TERM_MASK BIT(7)
84 #define BQ24190_REG_CTTC_EN_TERM_SHIFT 7
85 #define BQ24190_REG_CTTC_TERM_STAT_MASK BIT(6)
86 #define BQ24190_REG_CTTC_TERM_STAT_SHIFT 6
87 #define BQ24190_REG_CTTC_WATCHDOG_MASK (BIT(5) | BIT(4))
88 #define BQ24190_REG_CTTC_WATCHDOG_SHIFT 4
89 #define BQ24190_REG_CTTC_EN_TIMER_MASK BIT(3)
90 #define BQ24190_REG_CTTC_EN_TIMER_SHIFT 3
91 #define BQ24190_REG_CTTC_CHG_TIMER_MASK (BIT(2) | BIT(1))
92 #define BQ24190_REG_CTTC_CHG_TIMER_SHIFT 1
93 #define BQ24190_REG_CTTC_JEITA_ISET_MASK BIT(0)
94 #define BQ24190_REG_CTTC_JEITA_ISET_SHIFT 0
96 #define BQ24190_REG_ICTRC 0x06 /* IR Comp/Thermal Regulation Control */
97 #define BQ24190_REG_ICTRC_BAT_COMP_MASK (BIT(7) | BIT(6) | BIT(5))
98 #define BQ24190_REG_ICTRC_BAT_COMP_SHIFT 5
99 #define BQ24190_REG_ICTRC_VCLAMP_MASK (BIT(4) | BIT(3) | BIT(2))
100 #define BQ24190_REG_ICTRC_VCLAMP_SHIFT 2
101 #define BQ24190_REG_ICTRC_TREG_MASK (BIT(1) | BIT(0))
102 #define BQ24190_REG_ICTRC_TREG_SHIFT 0
104 #define BQ24190_REG_MOC 0x07 /* Misc. Operation Control */
105 #define BQ24190_REG_MOC_DPDM_EN_MASK BIT(7)
106 #define BQ24190_REG_MOC_DPDM_EN_SHIFT 7
107 #define BQ24190_REG_MOC_TMR2X_EN_MASK BIT(6)
108 #define BQ24190_REG_MOC_TMR2X_EN_SHIFT 6
109 #define BQ24190_REG_MOC_BATFET_DISABLE_MASK BIT(5)
110 #define BQ24190_REG_MOC_BATFET_DISABLE_SHIFT 5
111 #define BQ24190_REG_MOC_JEITA_VSET_MASK BIT(4)
112 #define BQ24190_REG_MOC_JEITA_VSET_SHIFT 4
113 #define BQ24190_REG_MOC_INT_MASK_MASK (BIT(1) | BIT(0))
114 #define BQ24190_REG_MOC_INT_MASK_SHIFT 0
116 #define BQ24190_REG_SS 0x08 /* System Status */
117 #define BQ24190_REG_SS_VBUS_STAT_MASK (BIT(7) | BIT(6))
118 #define BQ24190_REG_SS_VBUS_STAT_SHIFT 6
119 #define BQ24190_REG_SS_CHRG_STAT_MASK (BIT(5) | BIT(4))
120 #define BQ24190_REG_SS_CHRG_STAT_SHIFT 4
121 #define BQ24190_REG_SS_DPM_STAT_MASK BIT(3)
122 #define BQ24190_REG_SS_DPM_STAT_SHIFT 3
123 #define BQ24190_REG_SS_PG_STAT_MASK BIT(2)
124 #define BQ24190_REG_SS_PG_STAT_SHIFT 2
125 #define BQ24190_REG_SS_THERM_STAT_MASK BIT(1)
126 #define BQ24190_REG_SS_THERM_STAT_SHIFT 1
127 #define BQ24190_REG_SS_VSYS_STAT_MASK BIT(0)
128 #define BQ24190_REG_SS_VSYS_STAT_SHIFT 0
130 #define BQ24190_REG_F 0x09 /* Fault */
131 #define BQ24190_REG_F_WATCHDOG_FAULT_MASK BIT(7)
132 #define BQ24190_REG_F_WATCHDOG_FAULT_SHIFT 7
133 #define BQ24190_REG_F_BOOST_FAULT_MASK BIT(6)
134 #define BQ24190_REG_F_BOOST_FAULT_SHIFT 6
135 #define BQ24190_REG_F_CHRG_FAULT_MASK (BIT(5) | BIT(4))
136 #define BQ24190_REG_F_CHRG_FAULT_SHIFT 4
137 #define BQ24190_REG_F_BAT_FAULT_MASK BIT(3)
138 #define BQ24190_REG_F_BAT_FAULT_SHIFT 3
139 #define BQ24190_REG_F_NTC_FAULT_MASK (BIT(2) | BIT(1) | BIT(0))
140 #define BQ24190_REG_F_NTC_FAULT_SHIFT 0
142 #define BQ24190_REG_VPRS 0x0A /* Vendor/Part/Revision Status */
143 #define BQ24190_REG_VPRS_PN_MASK (BIT(5) | BIT(4) | BIT(3))
144 #define BQ24190_REG_VPRS_PN_SHIFT 3
145 #define BQ24190_REG_VPRS_PN_24190 0x4
146 #define BQ24190_REG_VPRS_PN_24192 0x5 /* Also 24193, 24196 */
147 #define BQ24190_REG_VPRS_PN_24192I 0x3
148 #define BQ24190_REG_VPRS_TS_PROFILE_MASK BIT(2)
149 #define BQ24190_REG_VPRS_TS_PROFILE_SHIFT 2
150 #define BQ24190_REG_VPRS_DEV_REG_MASK (BIT(1) | BIT(0))
151 #define BQ24190_REG_VPRS_DEV_REG_SHIFT 0
154 * The FAULT register is latched by the bq24190 (except for NTC_FAULT)
155 * so the first read after a fault returns the latched value and subsequent
156 * reads return the current value. In order to return the fault status
157 * to the user, have the interrupt handler save the reg's value and retrieve
158 * it in the appropriate health/status routine.
160 struct bq24190_dev_info
{
161 struct i2c_client
*client
;
163 struct extcon_dev
*edev
;
164 struct power_supply
*charger
;
165 struct power_supply
*battery
;
166 struct delayed_work input_current_limit_work
;
167 char model_name
[I2C_NAME_SIZE
];
173 struct mutex f_reg_lock
;
179 static const unsigned int bq24190_usb_extcon_cable
[] = {
185 * The tables below provide a 2-way mapping for the value that goes in
186 * the register field and the real-world value that it represents.
187 * The index of the array is the value that goes in the register; the
188 * number at that index in the array is the real-world value that it
192 /* REG00[2:0] (IINLIM) in uAh */
193 static const int bq24190_isc_iinlim_values
[] = {
194 100000, 150000, 500000, 900000, 1200000, 1500000, 2000000, 3000000
197 /* REG02[7:2] (ICHG) in uAh */
198 static const int bq24190_ccc_ichg_values
[] = {
199 512000, 576000, 640000, 704000, 768000, 832000, 896000, 960000,
200 1024000, 1088000, 1152000, 1216000, 1280000, 1344000, 1408000, 1472000,
201 1536000, 1600000, 1664000, 1728000, 1792000, 1856000, 1920000, 1984000,
202 2048000, 2112000, 2176000, 2240000, 2304000, 2368000, 2432000, 2496000,
203 2560000, 2624000, 2688000, 2752000, 2816000, 2880000, 2944000, 3008000,
204 3072000, 3136000, 3200000, 3264000, 3328000, 3392000, 3456000, 3520000,
205 3584000, 3648000, 3712000, 3776000, 3840000, 3904000, 3968000, 4032000,
206 4096000, 4160000, 4224000, 4288000, 4352000, 4416000, 4480000, 4544000
209 /* REG04[7:2] (VREG) in uV */
210 static const int bq24190_cvc_vreg_values
[] = {
211 3504000, 3520000, 3536000, 3552000, 3568000, 3584000, 3600000, 3616000,
212 3632000, 3648000, 3664000, 3680000, 3696000, 3712000, 3728000, 3744000,
213 3760000, 3776000, 3792000, 3808000, 3824000, 3840000, 3856000, 3872000,
214 3888000, 3904000, 3920000, 3936000, 3952000, 3968000, 3984000, 4000000,
215 4016000, 4032000, 4048000, 4064000, 4080000, 4096000, 4112000, 4128000,
216 4144000, 4160000, 4176000, 4192000, 4208000, 4224000, 4240000, 4256000,
217 4272000, 4288000, 4304000, 4320000, 4336000, 4352000, 4368000, 4384000,
221 /* REG06[1:0] (TREG) in tenths of degrees Celsius */
222 static const int bq24190_ictrc_treg_values
[] = {
227 * Return the index in 'tbl' of greatest value that is less than or equal to
228 * 'val'. The index range returned is 0 to 'tbl_size' - 1. Assumes that
229 * the values in 'tbl' are sorted from smallest to largest and 'tbl_size'
232 static u8
bq24190_find_idx(const int tbl
[], int tbl_size
, int v
)
236 for (i
= 1; i
< tbl_size
; i
++)
243 /* Basic driver I/O routines */
245 static int bq24190_read(struct bq24190_dev_info
*bdi
, u8 reg
, u8
*data
)
249 ret
= i2c_smbus_read_byte_data(bdi
->client
, reg
);
257 static int bq24190_write(struct bq24190_dev_info
*bdi
, u8 reg
, u8 data
)
259 return i2c_smbus_write_byte_data(bdi
->client
, reg
, data
);
262 static int bq24190_read_mask(struct bq24190_dev_info
*bdi
, u8 reg
,
263 u8 mask
, u8 shift
, u8
*data
)
268 ret
= bq24190_read(bdi
, reg
, &v
);
279 static int bq24190_write_mask(struct bq24190_dev_info
*bdi
, u8 reg
,
280 u8 mask
, u8 shift
, u8 data
)
285 ret
= bq24190_read(bdi
, reg
, &v
);
290 v
|= ((data
<< shift
) & mask
);
292 return bq24190_write(bdi
, reg
, v
);
295 static int bq24190_get_field_val(struct bq24190_dev_info
*bdi
,
296 u8 reg
, u8 mask
, u8 shift
,
297 const int tbl
[], int tbl_size
,
303 ret
= bq24190_read_mask(bdi
, reg
, mask
, shift
, &v
);
307 v
= (v
>= tbl_size
) ? (tbl_size
- 1) : v
;
313 static int bq24190_set_field_val(struct bq24190_dev_info
*bdi
,
314 u8 reg
, u8 mask
, u8 shift
,
315 const int tbl
[], int tbl_size
,
320 idx
= bq24190_find_idx(tbl
, tbl_size
, val
);
322 return bq24190_write_mask(bdi
, reg
, mask
, shift
, idx
);
327 * There are a numerous options that are configurable on the bq24190
328 * that go well beyond what the power_supply properties provide access to.
329 * Provide sysfs access to them so they can be examined and possibly modified
330 * on the fly. They will be provided for the charger power_supply object only
331 * and will be prefixed by 'f_' to make them easier to recognize.
334 #define BQ24190_SYSFS_FIELD(_name, r, f, m, store) \
336 .attr = __ATTR(f_##_name, m, bq24190_sysfs_show, store), \
337 .reg = BQ24190_REG_##r, \
338 .mask = BQ24190_REG_##r##_##f##_MASK, \
339 .shift = BQ24190_REG_##r##_##f##_SHIFT, \
342 #define BQ24190_SYSFS_FIELD_RW(_name, r, f) \
343 BQ24190_SYSFS_FIELD(_name, r, f, S_IWUSR | S_IRUGO, \
346 #define BQ24190_SYSFS_FIELD_RO(_name, r, f) \
347 BQ24190_SYSFS_FIELD(_name, r, f, S_IRUGO, NULL)
349 static ssize_t
bq24190_sysfs_show(struct device
*dev
,
350 struct device_attribute
*attr
, char *buf
);
351 static ssize_t
bq24190_sysfs_store(struct device
*dev
,
352 struct device_attribute
*attr
, const char *buf
, size_t count
);
354 struct bq24190_sysfs_field_info
{
355 struct device_attribute attr
;
361 /* On i386 ptrace-abi.h defines SS that breaks the macro calls below. */
364 static struct bq24190_sysfs_field_info bq24190_sysfs_field_tbl
[] = {
365 /* sysfs name reg field in reg */
366 BQ24190_SYSFS_FIELD_RW(en_hiz
, ISC
, EN_HIZ
),
367 BQ24190_SYSFS_FIELD_RW(vindpm
, ISC
, VINDPM
),
368 BQ24190_SYSFS_FIELD_RW(iinlim
, ISC
, IINLIM
),
369 BQ24190_SYSFS_FIELD_RW(chg_config
, POC
, CHG_CONFIG
),
370 BQ24190_SYSFS_FIELD_RW(sys_min
, POC
, SYS_MIN
),
371 BQ24190_SYSFS_FIELD_RW(boost_lim
, POC
, BOOST_LIM
),
372 BQ24190_SYSFS_FIELD_RW(ichg
, CCC
, ICHG
),
373 BQ24190_SYSFS_FIELD_RW(force_20_pct
, CCC
, FORCE_20PCT
),
374 BQ24190_SYSFS_FIELD_RW(iprechg
, PCTCC
, IPRECHG
),
375 BQ24190_SYSFS_FIELD_RW(iterm
, PCTCC
, ITERM
),
376 BQ24190_SYSFS_FIELD_RW(vreg
, CVC
, VREG
),
377 BQ24190_SYSFS_FIELD_RW(batlowv
, CVC
, BATLOWV
),
378 BQ24190_SYSFS_FIELD_RW(vrechg
, CVC
, VRECHG
),
379 BQ24190_SYSFS_FIELD_RW(en_term
, CTTC
, EN_TERM
),
380 BQ24190_SYSFS_FIELD_RW(term_stat
, CTTC
, TERM_STAT
),
381 BQ24190_SYSFS_FIELD_RO(watchdog
, CTTC
, WATCHDOG
),
382 BQ24190_SYSFS_FIELD_RW(en_timer
, CTTC
, EN_TIMER
),
383 BQ24190_SYSFS_FIELD_RW(chg_timer
, CTTC
, CHG_TIMER
),
384 BQ24190_SYSFS_FIELD_RW(jeta_iset
, CTTC
, JEITA_ISET
),
385 BQ24190_SYSFS_FIELD_RW(bat_comp
, ICTRC
, BAT_COMP
),
386 BQ24190_SYSFS_FIELD_RW(vclamp
, ICTRC
, VCLAMP
),
387 BQ24190_SYSFS_FIELD_RW(treg
, ICTRC
, TREG
),
388 BQ24190_SYSFS_FIELD_RW(dpdm_en
, MOC
, DPDM_EN
),
389 BQ24190_SYSFS_FIELD_RW(tmr2x_en
, MOC
, TMR2X_EN
),
390 BQ24190_SYSFS_FIELD_RW(batfet_disable
, MOC
, BATFET_DISABLE
),
391 BQ24190_SYSFS_FIELD_RW(jeita_vset
, MOC
, JEITA_VSET
),
392 BQ24190_SYSFS_FIELD_RO(int_mask
, MOC
, INT_MASK
),
393 BQ24190_SYSFS_FIELD_RO(vbus_stat
, SS
, VBUS_STAT
),
394 BQ24190_SYSFS_FIELD_RO(chrg_stat
, SS
, CHRG_STAT
),
395 BQ24190_SYSFS_FIELD_RO(dpm_stat
, SS
, DPM_STAT
),
396 BQ24190_SYSFS_FIELD_RO(pg_stat
, SS
, PG_STAT
),
397 BQ24190_SYSFS_FIELD_RO(therm_stat
, SS
, THERM_STAT
),
398 BQ24190_SYSFS_FIELD_RO(vsys_stat
, SS
, VSYS_STAT
),
399 BQ24190_SYSFS_FIELD_RO(watchdog_fault
, F
, WATCHDOG_FAULT
),
400 BQ24190_SYSFS_FIELD_RO(boost_fault
, F
, BOOST_FAULT
),
401 BQ24190_SYSFS_FIELD_RO(chrg_fault
, F
, CHRG_FAULT
),
402 BQ24190_SYSFS_FIELD_RO(bat_fault
, F
, BAT_FAULT
),
403 BQ24190_SYSFS_FIELD_RO(ntc_fault
, F
, NTC_FAULT
),
404 BQ24190_SYSFS_FIELD_RO(pn
, VPRS
, PN
),
405 BQ24190_SYSFS_FIELD_RO(ts_profile
, VPRS
, TS_PROFILE
),
406 BQ24190_SYSFS_FIELD_RO(dev_reg
, VPRS
, DEV_REG
),
409 static struct attribute
*
410 bq24190_sysfs_attrs
[ARRAY_SIZE(bq24190_sysfs_field_tbl
) + 1];
412 ATTRIBUTE_GROUPS(bq24190_sysfs
);
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
);
457 ret
= bq24190_read_mask(bdi
, info
->reg
, info
->mask
, info
->shift
, &v
);
461 count
= scnprintf(buf
, PAGE_SIZE
, "%hhx\n", v
);
463 pm_runtime_mark_last_busy(bdi
->dev
);
464 pm_runtime_put_autosuspend(bdi
->dev
);
469 static ssize_t
bq24190_sysfs_store(struct device
*dev
,
470 struct device_attribute
*attr
, const char *buf
, size_t count
)
472 struct power_supply
*psy
= dev_get_drvdata(dev
);
473 struct bq24190_dev_info
*bdi
= power_supply_get_drvdata(psy
);
474 struct bq24190_sysfs_field_info
*info
;
478 info
= bq24190_sysfs_field_lookup(attr
->attr
.name
);
482 ret
= kstrtou8(buf
, 0, &v
);
486 ret
= pm_runtime_get_sync(bdi
->dev
);
490 ret
= bq24190_write_mask(bdi
, info
->reg
, info
->mask
, info
->shift
, v
);
494 pm_runtime_mark_last_busy(bdi
->dev
);
495 pm_runtime_put_autosuspend(bdi
->dev
);
501 #ifdef CONFIG_REGULATOR
502 static int bq24190_set_charge_mode(struct regulator_dev
*dev
, u8 val
)
504 struct bq24190_dev_info
*bdi
= rdev_get_drvdata(dev
);
507 ret
= pm_runtime_get_sync(bdi
->dev
);
509 dev_warn(bdi
->dev
, "pm_runtime_get failed: %i\n", ret
);
510 pm_runtime_put_noidle(bdi
->dev
);
514 ret
= bq24190_write_mask(bdi
, BQ24190_REG_POC
,
515 BQ24190_REG_POC_CHG_CONFIG_MASK
,
516 BQ24190_REG_POC_CHG_CONFIG_SHIFT
, val
);
518 pm_runtime_mark_last_busy(bdi
->dev
);
519 pm_runtime_put_autosuspend(bdi
->dev
);
524 static int bq24190_vbus_enable(struct regulator_dev
*dev
)
526 return bq24190_set_charge_mode(dev
, BQ24190_REG_POC_CHG_CONFIG_OTG
);
529 static int bq24190_vbus_disable(struct regulator_dev
*dev
)
531 return bq24190_set_charge_mode(dev
, BQ24190_REG_POC_CHG_CONFIG_CHARGE
);
534 static int bq24190_vbus_is_enabled(struct regulator_dev
*dev
)
536 struct bq24190_dev_info
*bdi
= rdev_get_drvdata(dev
);
540 ret
= pm_runtime_get_sync(bdi
->dev
);
542 dev_warn(bdi
->dev
, "pm_runtime_get failed: %i\n", ret
);
543 pm_runtime_put_noidle(bdi
->dev
);
547 ret
= bq24190_read_mask(bdi
, BQ24190_REG_POC
,
548 BQ24190_REG_POC_CHG_CONFIG_MASK
,
549 BQ24190_REG_POC_CHG_CONFIG_SHIFT
, &val
);
551 pm_runtime_mark_last_busy(bdi
->dev
);
552 pm_runtime_put_autosuspend(bdi
->dev
);
554 return ret
? ret
: val
== BQ24190_REG_POC_CHG_CONFIG_OTG
;
557 static const struct regulator_ops bq24190_vbus_ops
= {
558 .enable
= bq24190_vbus_enable
,
559 .disable
= bq24190_vbus_disable
,
560 .is_enabled
= bq24190_vbus_is_enabled
,
563 static const struct regulator_desc bq24190_vbus_desc
= {
564 .name
= "usb_otg_vbus",
565 .of_match
= "usb-otg-vbus",
566 .type
= REGULATOR_VOLTAGE
,
567 .owner
= THIS_MODULE
,
568 .ops
= &bq24190_vbus_ops
,
573 static const struct regulator_init_data bq24190_vbus_init_data
= {
575 .valid_ops_mask
= REGULATOR_CHANGE_STATUS
,
579 static int bq24190_register_vbus_regulator(struct bq24190_dev_info
*bdi
)
581 struct bq24190_platform_data
*pdata
= bdi
->dev
->platform_data
;
582 struct regulator_config cfg
= { };
583 struct regulator_dev
*reg
;
587 if (pdata
&& pdata
->regulator_init_data
)
588 cfg
.init_data
= pdata
->regulator_init_data
;
590 cfg
.init_data
= &bq24190_vbus_init_data
;
591 cfg
.driver_data
= bdi
;
592 reg
= devm_regulator_register(bdi
->dev
, &bq24190_vbus_desc
, &cfg
);
595 dev_err(bdi
->dev
, "Can't register regulator: %d\n", ret
);
601 static int bq24190_register_vbus_regulator(struct bq24190_dev_info
*bdi
)
607 static int bq24190_set_config(struct bq24190_dev_info
*bdi
)
612 ret
= bq24190_read(bdi
, BQ24190_REG_CTTC
, &v
);
616 bdi
->watchdog
= ((v
& BQ24190_REG_CTTC_WATCHDOG_MASK
) >>
617 BQ24190_REG_CTTC_WATCHDOG_SHIFT
);
620 * According to the "Host Mode and default Mode" section of the
621 * manual, a write to any register causes the bq24190 to switch
622 * from default mode to host mode. It will switch back to default
623 * mode after a WDT timeout unless the WDT is turned off as well.
624 * So, by simply turning off the WDT, we accomplish both with the
627 v
&= ~BQ24190_REG_CTTC_WATCHDOG_MASK
;
629 ret
= bq24190_write(bdi
, BQ24190_REG_CTTC
, v
);
634 v
= bdi
->sys_min
/ 100 - 30; // manual section 9.5.1.2, table 9
635 ret
= bq24190_write_mask(bdi
, BQ24190_REG_POC
,
636 BQ24190_REG_POC_SYS_MIN_MASK
,
637 BQ24190_REG_POC_SYS_MIN_SHIFT
,
644 v
= bdi
->iprechg
/ 128 - 1; // manual section 9.5.1.4, table 11
645 ret
= bq24190_write_mask(bdi
, BQ24190_REG_PCTCC
,
646 BQ24190_REG_PCTCC_IPRECHG_MASK
,
647 BQ24190_REG_PCTCC_IPRECHG_SHIFT
,
654 v
= bdi
->iterm
/ 128 - 1; // manual section 9.5.1.4, table 11
655 ret
= bq24190_write_mask(bdi
, BQ24190_REG_PCTCC
,
656 BQ24190_REG_PCTCC_ITERM_MASK
,
657 BQ24190_REG_PCTCC_ITERM_SHIFT
,
666 static int bq24190_register_reset(struct bq24190_dev_info
*bdi
)
668 int ret
, limit
= 100;
672 * This prop. can be passed on device instantiation from platform code:
673 * struct property_entry pe[] =
674 * { PROPERTY_ENTRY_BOOL("disable-reset"), ... };
675 * struct i2c_board_info bi =
676 * { .type = "bq24190", .addr = 0x6b, .properties = pe, .irq = irq };
677 * struct i2c_adapter ad = { ... };
678 * i2c_add_adapter(&ad);
679 * i2c_new_device(&ad, &bi);
681 if (device_property_read_bool(bdi
->dev
, "disable-reset"))
684 /* Reset the registers */
685 ret
= bq24190_write_mask(bdi
, BQ24190_REG_POC
,
686 BQ24190_REG_POC_RESET_MASK
,
687 BQ24190_REG_POC_RESET_SHIFT
,
692 /* Reset bit will be cleared by hardware so poll until it is */
694 ret
= bq24190_read_mask(bdi
, BQ24190_REG_POC
,
695 BQ24190_REG_POC_RESET_MASK
,
696 BQ24190_REG_POC_RESET_SHIFT
,
704 usleep_range(100, 200);
710 /* Charger power supply property routines */
712 static int bq24190_charger_get_charge_type(struct bq24190_dev_info
*bdi
,
713 union power_supply_propval
*val
)
718 ret
= bq24190_read_mask(bdi
, BQ24190_REG_POC
,
719 BQ24190_REG_POC_CHG_CONFIG_MASK
,
720 BQ24190_REG_POC_CHG_CONFIG_SHIFT
,
725 /* If POC[CHG_CONFIG] (REG01[5:4]) == 0, charge is disabled */
727 type
= POWER_SUPPLY_CHARGE_TYPE_NONE
;
729 ret
= bq24190_read_mask(bdi
, BQ24190_REG_CCC
,
730 BQ24190_REG_CCC_FORCE_20PCT_MASK
,
731 BQ24190_REG_CCC_FORCE_20PCT_SHIFT
,
736 type
= (v
) ? POWER_SUPPLY_CHARGE_TYPE_TRICKLE
:
737 POWER_SUPPLY_CHARGE_TYPE_FAST
;
745 static int bq24190_charger_set_charge_type(struct bq24190_dev_info
*bdi
,
746 const union power_supply_propval
*val
)
748 u8 chg_config
, force_20pct
, en_term
;
752 * According to the "Termination when REG02[0] = 1" section of
753 * the bq24190 manual, the trickle charge could be less than the
754 * termination current so it recommends turning off the termination
757 * Note: AFAICT from the datasheet, the user will have to manually
758 * turn off the charging when in 20% mode. If its not turned off,
759 * there could be battery damage. So, use this mode at your own risk.
761 switch (val
->intval
) {
762 case POWER_SUPPLY_CHARGE_TYPE_NONE
:
765 case POWER_SUPPLY_CHARGE_TYPE_TRICKLE
:
770 case POWER_SUPPLY_CHARGE_TYPE_FAST
:
779 if (chg_config
) { /* Enabling the charger */
780 ret
= bq24190_write_mask(bdi
, BQ24190_REG_CCC
,
781 BQ24190_REG_CCC_FORCE_20PCT_MASK
,
782 BQ24190_REG_CCC_FORCE_20PCT_SHIFT
,
787 ret
= bq24190_write_mask(bdi
, BQ24190_REG_CTTC
,
788 BQ24190_REG_CTTC_EN_TERM_MASK
,
789 BQ24190_REG_CTTC_EN_TERM_SHIFT
,
795 return bq24190_write_mask(bdi
, BQ24190_REG_POC
,
796 BQ24190_REG_POC_CHG_CONFIG_MASK
,
797 BQ24190_REG_POC_CHG_CONFIG_SHIFT
, chg_config
);
800 static int bq24190_charger_get_health(struct bq24190_dev_info
*bdi
,
801 union power_supply_propval
*val
)
806 mutex_lock(&bdi
->f_reg_lock
);
808 mutex_unlock(&bdi
->f_reg_lock
);
810 if (v
& BQ24190_REG_F_NTC_FAULT_MASK
) {
811 switch (v
>> BQ24190_REG_F_NTC_FAULT_SHIFT
& 0x7) {
812 case 0x1: /* TS1 Cold */
813 case 0x3: /* TS2 Cold */
814 case 0x5: /* Both Cold */
815 health
= POWER_SUPPLY_HEALTH_COLD
;
817 case 0x2: /* TS1 Hot */
818 case 0x4: /* TS2 Hot */
819 case 0x6: /* Both Hot */
820 health
= POWER_SUPPLY_HEALTH_OVERHEAT
;
823 health
= POWER_SUPPLY_HEALTH_UNKNOWN
;
825 } else if (v
& BQ24190_REG_F_BAT_FAULT_MASK
) {
826 health
= POWER_SUPPLY_HEALTH_OVERVOLTAGE
;
827 } else if (v
& BQ24190_REG_F_CHRG_FAULT_MASK
) {
828 switch (v
>> BQ24190_REG_F_CHRG_FAULT_SHIFT
& 0x3) {
829 case 0x1: /* Input Fault (VBUS OVP or VBAT<VBUS<3.8V) */
831 * This could be over-voltage or under-voltage
832 * and there's no way to tell which. Instead
833 * of looking foolish and returning 'OVERVOLTAGE'
834 * when its really under-voltage, just return
837 health
= POWER_SUPPLY_HEALTH_UNSPEC_FAILURE
;
839 case 0x2: /* Thermal Shutdown */
840 health
= POWER_SUPPLY_HEALTH_OVERHEAT
;
842 case 0x3: /* Charge Safety Timer Expiration */
843 health
= POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE
;
845 default: /* prevent compiler warning */
848 } else if (v
& BQ24190_REG_F_BOOST_FAULT_MASK
) {
850 * This could be over-current or over-voltage but there's
851 * no way to tell which. Return 'OVERVOLTAGE' since there
852 * isn't an 'OVERCURRENT' value defined that we can return
853 * even if it was over-current.
855 health
= POWER_SUPPLY_HEALTH_OVERVOLTAGE
;
857 health
= POWER_SUPPLY_HEALTH_GOOD
;
860 val
->intval
= health
;
865 static int bq24190_charger_get_online(struct bq24190_dev_info
*bdi
,
866 union power_supply_propval
*val
)
868 u8 pg_stat
, batfet_disable
;
871 ret
= bq24190_read_mask(bdi
, BQ24190_REG_SS
,
872 BQ24190_REG_SS_PG_STAT_MASK
,
873 BQ24190_REG_SS_PG_STAT_SHIFT
, &pg_stat
);
877 ret
= bq24190_read_mask(bdi
, BQ24190_REG_MOC
,
878 BQ24190_REG_MOC_BATFET_DISABLE_MASK
,
879 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT
, &batfet_disable
);
883 val
->intval
= pg_stat
&& !batfet_disable
;
888 static int bq24190_battery_set_online(struct bq24190_dev_info
*bdi
,
889 const union power_supply_propval
*val
);
890 static int bq24190_battery_get_status(struct bq24190_dev_info
*bdi
,
891 union power_supply_propval
*val
);
892 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info
*bdi
,
893 union power_supply_propval
*val
);
894 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info
*bdi
,
895 const union power_supply_propval
*val
);
897 static int bq24190_charger_set_online(struct bq24190_dev_info
*bdi
,
898 const union power_supply_propval
*val
)
900 return bq24190_battery_set_online(bdi
, val
);
903 static int bq24190_charger_get_status(struct bq24190_dev_info
*bdi
,
904 union power_supply_propval
*val
)
906 return bq24190_battery_get_status(bdi
, val
);
909 static int bq24190_charger_get_temp_alert_max(struct bq24190_dev_info
*bdi
,
910 union power_supply_propval
*val
)
912 return bq24190_battery_get_temp_alert_max(bdi
, val
);
915 static int bq24190_charger_set_temp_alert_max(struct bq24190_dev_info
*bdi
,
916 const union power_supply_propval
*val
)
918 return bq24190_battery_set_temp_alert_max(bdi
, val
);
921 static int bq24190_charger_get_precharge(struct bq24190_dev_info
*bdi
,
922 union power_supply_propval
*val
)
927 ret
= bq24190_read_mask(bdi
, BQ24190_REG_PCTCC
,
928 BQ24190_REG_PCTCC_IPRECHG_MASK
,
929 BQ24190_REG_PCTCC_IPRECHG_SHIFT
, &v
);
933 val
->intval
= ++v
* 128 * 1000;
937 static int bq24190_charger_get_charge_term(struct bq24190_dev_info
*bdi
,
938 union power_supply_propval
*val
)
943 ret
= bq24190_read_mask(bdi
, BQ24190_REG_PCTCC
,
944 BQ24190_REG_PCTCC_ITERM_MASK
,
945 BQ24190_REG_PCTCC_ITERM_SHIFT
, &v
);
949 val
->intval
= ++v
* 128 * 1000;
953 static int bq24190_charger_get_current(struct bq24190_dev_info
*bdi
,
954 union power_supply_propval
*val
)
959 ret
= bq24190_get_field_val(bdi
, BQ24190_REG_CCC
,
960 BQ24190_REG_CCC_ICHG_MASK
, BQ24190_REG_CCC_ICHG_SHIFT
,
961 bq24190_ccc_ichg_values
,
962 ARRAY_SIZE(bq24190_ccc_ichg_values
), &curr
);
966 ret
= bq24190_read_mask(bdi
, BQ24190_REG_CCC
,
967 BQ24190_REG_CCC_FORCE_20PCT_MASK
,
968 BQ24190_REG_CCC_FORCE_20PCT_SHIFT
, &v
);
972 /* If FORCE_20PCT is enabled, then current is 20% of ICHG value */
980 static int bq24190_charger_get_current_max(struct bq24190_dev_info
*bdi
,
981 union power_supply_propval
*val
)
983 int idx
= ARRAY_SIZE(bq24190_ccc_ichg_values
) - 1;
985 val
->intval
= bq24190_ccc_ichg_values
[idx
];
989 static int bq24190_charger_set_current(struct bq24190_dev_info
*bdi
,
990 const union power_supply_propval
*val
)
993 int ret
, curr
= val
->intval
;
995 ret
= bq24190_read_mask(bdi
, BQ24190_REG_CCC
,
996 BQ24190_REG_CCC_FORCE_20PCT_MASK
,
997 BQ24190_REG_CCC_FORCE_20PCT_SHIFT
, &v
);
1001 /* If FORCE_20PCT is enabled, have to multiply value passed in by 5 */
1005 return bq24190_set_field_val(bdi
, BQ24190_REG_CCC
,
1006 BQ24190_REG_CCC_ICHG_MASK
, BQ24190_REG_CCC_ICHG_SHIFT
,
1007 bq24190_ccc_ichg_values
,
1008 ARRAY_SIZE(bq24190_ccc_ichg_values
), curr
);
1011 static int bq24190_charger_get_voltage(struct bq24190_dev_info
*bdi
,
1012 union power_supply_propval
*val
)
1016 ret
= bq24190_get_field_val(bdi
, BQ24190_REG_CVC
,
1017 BQ24190_REG_CVC_VREG_MASK
, BQ24190_REG_CVC_VREG_SHIFT
,
1018 bq24190_cvc_vreg_values
,
1019 ARRAY_SIZE(bq24190_cvc_vreg_values
), &voltage
);
1023 val
->intval
= voltage
;
1027 static int bq24190_charger_get_voltage_max(struct bq24190_dev_info
*bdi
,
1028 union power_supply_propval
*val
)
1030 int idx
= ARRAY_SIZE(bq24190_cvc_vreg_values
) - 1;
1032 val
->intval
= bq24190_cvc_vreg_values
[idx
];
1036 static int bq24190_charger_set_voltage(struct bq24190_dev_info
*bdi
,
1037 const union power_supply_propval
*val
)
1039 return bq24190_set_field_val(bdi
, BQ24190_REG_CVC
,
1040 BQ24190_REG_CVC_VREG_MASK
, BQ24190_REG_CVC_VREG_SHIFT
,
1041 bq24190_cvc_vreg_values
,
1042 ARRAY_SIZE(bq24190_cvc_vreg_values
), val
->intval
);
1045 static int bq24190_charger_get_iinlimit(struct bq24190_dev_info
*bdi
,
1046 union power_supply_propval
*val
)
1050 ret
= bq24190_get_field_val(bdi
, BQ24190_REG_ISC
,
1051 BQ24190_REG_ISC_IINLIM_MASK
,
1052 BQ24190_REG_ISC_IINLIM_SHIFT
,
1053 bq24190_isc_iinlim_values
,
1054 ARRAY_SIZE(bq24190_isc_iinlim_values
), &iinlimit
);
1058 val
->intval
= iinlimit
;
1062 static int bq24190_charger_set_iinlimit(struct bq24190_dev_info
*bdi
,
1063 const union power_supply_propval
*val
)
1065 return bq24190_set_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
), val
->intval
);
1072 static int bq24190_charger_get_property(struct power_supply
*psy
,
1073 enum power_supply_property psp
, union power_supply_propval
*val
)
1075 struct bq24190_dev_info
*bdi
= power_supply_get_drvdata(psy
);
1078 dev_dbg(bdi
->dev
, "prop: %d\n", psp
);
1080 ret
= pm_runtime_get_sync(bdi
->dev
);
1085 case POWER_SUPPLY_PROP_CHARGE_TYPE
:
1086 ret
= bq24190_charger_get_charge_type(bdi
, val
);
1088 case POWER_SUPPLY_PROP_HEALTH
:
1089 ret
= bq24190_charger_get_health(bdi
, val
);
1091 case POWER_SUPPLY_PROP_ONLINE
:
1092 ret
= bq24190_charger_get_online(bdi
, val
);
1094 case POWER_SUPPLY_PROP_STATUS
:
1095 ret
= bq24190_charger_get_status(bdi
, val
);
1097 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX
:
1098 ret
= bq24190_charger_get_temp_alert_max(bdi
, val
);
1100 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT
:
1101 ret
= bq24190_charger_get_precharge(bdi
, val
);
1103 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT
:
1104 ret
= bq24190_charger_get_charge_term(bdi
, val
);
1106 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT
:
1107 ret
= bq24190_charger_get_current(bdi
, val
);
1109 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX
:
1110 ret
= bq24190_charger_get_current_max(bdi
, val
);
1112 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE
:
1113 ret
= bq24190_charger_get_voltage(bdi
, val
);
1115 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX
:
1116 ret
= bq24190_charger_get_voltage_max(bdi
, val
);
1118 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT
:
1119 ret
= bq24190_charger_get_iinlimit(bdi
, val
);
1121 case POWER_SUPPLY_PROP_SCOPE
:
1122 val
->intval
= POWER_SUPPLY_SCOPE_SYSTEM
;
1125 case POWER_SUPPLY_PROP_MODEL_NAME
:
1126 val
->strval
= bdi
->model_name
;
1129 case POWER_SUPPLY_PROP_MANUFACTURER
:
1130 val
->strval
= BQ24190_MANUFACTURER
;
1137 pm_runtime_mark_last_busy(bdi
->dev
);
1138 pm_runtime_put_autosuspend(bdi
->dev
);
1143 static int bq24190_charger_set_property(struct power_supply
*psy
,
1144 enum power_supply_property psp
,
1145 const union power_supply_propval
*val
)
1147 struct bq24190_dev_info
*bdi
= power_supply_get_drvdata(psy
);
1150 dev_dbg(bdi
->dev
, "prop: %d\n", psp
);
1152 ret
= pm_runtime_get_sync(bdi
->dev
);
1157 case POWER_SUPPLY_PROP_ONLINE
:
1158 ret
= bq24190_charger_set_online(bdi
, val
);
1160 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX
:
1161 ret
= bq24190_charger_set_temp_alert_max(bdi
, val
);
1163 case POWER_SUPPLY_PROP_CHARGE_TYPE
:
1164 ret
= bq24190_charger_set_charge_type(bdi
, val
);
1166 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT
:
1167 ret
= bq24190_charger_set_current(bdi
, val
);
1169 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE
:
1170 ret
= bq24190_charger_set_voltage(bdi
, val
);
1172 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT
:
1173 ret
= bq24190_charger_set_iinlimit(bdi
, val
);
1179 pm_runtime_mark_last_busy(bdi
->dev
);
1180 pm_runtime_put_autosuspend(bdi
->dev
);
1185 static int bq24190_charger_property_is_writeable(struct power_supply
*psy
,
1186 enum power_supply_property psp
)
1189 case POWER_SUPPLY_PROP_ONLINE
:
1190 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX
:
1191 case POWER_SUPPLY_PROP_CHARGE_TYPE
:
1192 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT
:
1193 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE
:
1194 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT
:
1201 static void bq24190_input_current_limit_work(struct work_struct
*work
)
1203 struct bq24190_dev_info
*bdi
=
1204 container_of(work
, struct bq24190_dev_info
,
1205 input_current_limit_work
.work
);
1207 power_supply_set_input_current_limit_from_supplier(bdi
->charger
);
1210 /* Sync the input-current-limit with our parent supply (if we have one) */
1211 static void bq24190_charger_external_power_changed(struct power_supply
*psy
)
1213 struct bq24190_dev_info
*bdi
= power_supply_get_drvdata(psy
);
1216 * The Power-Good detection may take up to 220ms, sometimes
1217 * the external charger detection is quicker, and the bq24190 will
1218 * reset to iinlim based on its own charger detection (which is not
1219 * hooked up when using external charger detection) resulting in a
1220 * too low default 500mA iinlim. Delay setting the input-current-limit
1221 * for 300ms to avoid this.
1223 queue_delayed_work(system_wq
, &bdi
->input_current_limit_work
,
1224 msecs_to_jiffies(300));
1227 static enum power_supply_property bq24190_charger_properties
[] = {
1228 POWER_SUPPLY_PROP_CHARGE_TYPE
,
1229 POWER_SUPPLY_PROP_HEALTH
,
1230 POWER_SUPPLY_PROP_ONLINE
,
1231 POWER_SUPPLY_PROP_STATUS
,
1232 POWER_SUPPLY_PROP_TEMP_ALERT_MAX
,
1233 POWER_SUPPLY_PROP_PRECHARGE_CURRENT
,
1234 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT
,
1235 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT
,
1236 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX
,
1237 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE
,
1238 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX
,
1239 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT
,
1240 POWER_SUPPLY_PROP_SCOPE
,
1241 POWER_SUPPLY_PROP_MODEL_NAME
,
1242 POWER_SUPPLY_PROP_MANUFACTURER
,
1245 static char *bq24190_charger_supplied_to
[] = {
1249 static const struct power_supply_desc bq24190_charger_desc
= {
1250 .name
= "bq24190-charger",
1251 .type
= POWER_SUPPLY_TYPE_USB
,
1252 .properties
= bq24190_charger_properties
,
1253 .num_properties
= ARRAY_SIZE(bq24190_charger_properties
),
1254 .get_property
= bq24190_charger_get_property
,
1255 .set_property
= bq24190_charger_set_property
,
1256 .property_is_writeable
= bq24190_charger_property_is_writeable
,
1257 .external_power_changed
= bq24190_charger_external_power_changed
,
1260 /* Battery power supply property routines */
1262 static int bq24190_battery_get_status(struct bq24190_dev_info
*bdi
,
1263 union power_supply_propval
*val
)
1265 u8 ss_reg
, chrg_fault
;
1268 mutex_lock(&bdi
->f_reg_lock
);
1269 chrg_fault
= bdi
->f_reg
;
1270 mutex_unlock(&bdi
->f_reg_lock
);
1272 chrg_fault
&= BQ24190_REG_F_CHRG_FAULT_MASK
;
1273 chrg_fault
>>= BQ24190_REG_F_CHRG_FAULT_SHIFT
;
1275 ret
= bq24190_read(bdi
, BQ24190_REG_SS
, &ss_reg
);
1280 * The battery must be discharging when any of these are true:
1281 * - there is no good power source;
1282 * - there is a charge fault.
1283 * Could also be discharging when in "supplement mode" but
1284 * there is no way to tell when its in that mode.
1286 if (!(ss_reg
& BQ24190_REG_SS_PG_STAT_MASK
) || chrg_fault
) {
1287 status
= POWER_SUPPLY_STATUS_DISCHARGING
;
1289 ss_reg
&= BQ24190_REG_SS_CHRG_STAT_MASK
;
1290 ss_reg
>>= BQ24190_REG_SS_CHRG_STAT_SHIFT
;
1293 case 0x0: /* Not Charging */
1294 status
= POWER_SUPPLY_STATUS_NOT_CHARGING
;
1296 case 0x1: /* Pre-charge */
1297 case 0x2: /* Fast Charging */
1298 status
= POWER_SUPPLY_STATUS_CHARGING
;
1300 case 0x3: /* Charge Termination Done */
1301 status
= POWER_SUPPLY_STATUS_FULL
;
1309 val
->intval
= status
;
1314 static int bq24190_battery_get_health(struct bq24190_dev_info
*bdi
,
1315 union power_supply_propval
*val
)
1320 mutex_lock(&bdi
->f_reg_lock
);
1322 mutex_unlock(&bdi
->f_reg_lock
);
1324 if (v
& BQ24190_REG_F_BAT_FAULT_MASK
) {
1325 health
= POWER_SUPPLY_HEALTH_OVERVOLTAGE
;
1327 v
&= BQ24190_REG_F_NTC_FAULT_MASK
;
1328 v
>>= BQ24190_REG_F_NTC_FAULT_SHIFT
;
1331 case 0x0: /* Normal */
1332 health
= POWER_SUPPLY_HEALTH_GOOD
;
1334 case 0x1: /* TS1 Cold */
1335 case 0x3: /* TS2 Cold */
1336 case 0x5: /* Both Cold */
1337 health
= POWER_SUPPLY_HEALTH_COLD
;
1339 case 0x2: /* TS1 Hot */
1340 case 0x4: /* TS2 Hot */
1341 case 0x6: /* Both Hot */
1342 health
= POWER_SUPPLY_HEALTH_OVERHEAT
;
1345 health
= POWER_SUPPLY_HEALTH_UNKNOWN
;
1349 val
->intval
= health
;
1353 static int bq24190_battery_get_online(struct bq24190_dev_info
*bdi
,
1354 union power_supply_propval
*val
)
1359 ret
= bq24190_read_mask(bdi
, BQ24190_REG_MOC
,
1360 BQ24190_REG_MOC_BATFET_DISABLE_MASK
,
1361 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT
, &batfet_disable
);
1365 val
->intval
= !batfet_disable
;
1369 static int bq24190_battery_set_online(struct bq24190_dev_info
*bdi
,
1370 const union power_supply_propval
*val
)
1372 return bq24190_write_mask(bdi
, BQ24190_REG_MOC
,
1373 BQ24190_REG_MOC_BATFET_DISABLE_MASK
,
1374 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT
, !val
->intval
);
1377 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info
*bdi
,
1378 union power_supply_propval
*val
)
1382 ret
= bq24190_get_field_val(bdi
, BQ24190_REG_ICTRC
,
1383 BQ24190_REG_ICTRC_TREG_MASK
,
1384 BQ24190_REG_ICTRC_TREG_SHIFT
,
1385 bq24190_ictrc_treg_values
,
1386 ARRAY_SIZE(bq24190_ictrc_treg_values
), &temp
);
1394 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info
*bdi
,
1395 const union power_supply_propval
*val
)
1397 return bq24190_set_field_val(bdi
, BQ24190_REG_ICTRC
,
1398 BQ24190_REG_ICTRC_TREG_MASK
,
1399 BQ24190_REG_ICTRC_TREG_SHIFT
,
1400 bq24190_ictrc_treg_values
,
1401 ARRAY_SIZE(bq24190_ictrc_treg_values
), val
->intval
);
1404 static int bq24190_battery_get_property(struct power_supply
*psy
,
1405 enum power_supply_property psp
, union power_supply_propval
*val
)
1407 struct bq24190_dev_info
*bdi
= power_supply_get_drvdata(psy
);
1410 dev_warn(bdi
->dev
, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1411 dev_dbg(bdi
->dev
, "prop: %d\n", psp
);
1413 ret
= pm_runtime_get_sync(bdi
->dev
);
1418 case POWER_SUPPLY_PROP_STATUS
:
1419 ret
= bq24190_battery_get_status(bdi
, val
);
1421 case POWER_SUPPLY_PROP_HEALTH
:
1422 ret
= bq24190_battery_get_health(bdi
, val
);
1424 case POWER_SUPPLY_PROP_ONLINE
:
1425 ret
= bq24190_battery_get_online(bdi
, val
);
1427 case POWER_SUPPLY_PROP_TECHNOLOGY
:
1428 /* Could be Li-on or Li-polymer but no way to tell which */
1429 val
->intval
= POWER_SUPPLY_TECHNOLOGY_UNKNOWN
;
1432 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX
:
1433 ret
= bq24190_battery_get_temp_alert_max(bdi
, val
);
1435 case POWER_SUPPLY_PROP_SCOPE
:
1436 val
->intval
= POWER_SUPPLY_SCOPE_SYSTEM
;
1443 pm_runtime_mark_last_busy(bdi
->dev
);
1444 pm_runtime_put_autosuspend(bdi
->dev
);
1449 static int bq24190_battery_set_property(struct power_supply
*psy
,
1450 enum power_supply_property psp
,
1451 const union power_supply_propval
*val
)
1453 struct bq24190_dev_info
*bdi
= power_supply_get_drvdata(psy
);
1456 dev_warn(bdi
->dev
, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1457 dev_dbg(bdi
->dev
, "prop: %d\n", psp
);
1459 ret
= pm_runtime_get_sync(bdi
->dev
);
1464 case POWER_SUPPLY_PROP_ONLINE
:
1465 ret
= bq24190_battery_set_online(bdi
, val
);
1467 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX
:
1468 ret
= bq24190_battery_set_temp_alert_max(bdi
, val
);
1474 pm_runtime_mark_last_busy(bdi
->dev
);
1475 pm_runtime_put_autosuspend(bdi
->dev
);
1480 static int bq24190_battery_property_is_writeable(struct power_supply
*psy
,
1481 enum power_supply_property psp
)
1486 case POWER_SUPPLY_PROP_ONLINE
:
1487 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX
:
1497 static enum power_supply_property bq24190_battery_properties
[] = {
1498 POWER_SUPPLY_PROP_STATUS
,
1499 POWER_SUPPLY_PROP_HEALTH
,
1500 POWER_SUPPLY_PROP_ONLINE
,
1501 POWER_SUPPLY_PROP_TECHNOLOGY
,
1502 POWER_SUPPLY_PROP_TEMP_ALERT_MAX
,
1503 POWER_SUPPLY_PROP_SCOPE
,
1506 static const struct power_supply_desc bq24190_battery_desc
= {
1507 .name
= "bq24190-battery",
1508 .type
= POWER_SUPPLY_TYPE_BATTERY
,
1509 .properties
= bq24190_battery_properties
,
1510 .num_properties
= ARRAY_SIZE(bq24190_battery_properties
),
1511 .get_property
= bq24190_battery_get_property
,
1512 .set_property
= bq24190_battery_set_property
,
1513 .property_is_writeable
= bq24190_battery_property_is_writeable
,
1516 static int bq24190_configure_usb_otg(struct bq24190_dev_info
*bdi
, u8 ss_reg
)
1521 otg_enabled
= !!(ss_reg
& BQ24190_REG_SS_VBUS_STAT_MASK
);
1522 ret
= extcon_set_state_sync(bdi
->edev
, EXTCON_USB
, otg_enabled
);
1524 dev_err(bdi
->dev
, "Can't set extcon state to %d: %d\n",
1530 static void bq24190_check_status(struct bq24190_dev_info
*bdi
)
1532 const u8 battery_mask_ss
= BQ24190_REG_SS_CHRG_STAT_MASK
;
1533 const u8 battery_mask_f
= BQ24190_REG_F_BAT_FAULT_MASK
1534 | BQ24190_REG_F_NTC_FAULT_MASK
;
1535 bool alert_charger
= false, alert_battery
= false;
1536 u8 ss_reg
= 0, f_reg
= 0;
1539 ret
= bq24190_read(bdi
, BQ24190_REG_SS
, &ss_reg
);
1541 dev_err(bdi
->dev
, "Can't read SS reg: %d\n", ret
);
1547 ret
= bq24190_read(bdi
, BQ24190_REG_F
, &f_reg
);
1549 dev_err(bdi
->dev
, "Can't read F reg: %d\n", ret
);
1552 } while (f_reg
&& ++i
< 2);
1554 /* ignore over/under voltage fault after disconnect */
1555 if (f_reg
== (1 << BQ24190_REG_F_CHRG_FAULT_SHIFT
) &&
1556 !(ss_reg
& BQ24190_REG_SS_PG_STAT_MASK
))
1559 if (f_reg
!= bdi
->f_reg
) {
1561 "Fault: boost %d, charge %d, battery %d, ntc %d\n",
1562 !!(f_reg
& BQ24190_REG_F_BOOST_FAULT_MASK
),
1563 !!(f_reg
& BQ24190_REG_F_CHRG_FAULT_MASK
),
1564 !!(f_reg
& BQ24190_REG_F_BAT_FAULT_MASK
),
1565 !!(f_reg
& BQ24190_REG_F_NTC_FAULT_MASK
));
1567 mutex_lock(&bdi
->f_reg_lock
);
1568 if ((bdi
->f_reg
& battery_mask_f
) != (f_reg
& battery_mask_f
))
1569 alert_battery
= true;
1570 if ((bdi
->f_reg
& ~battery_mask_f
) != (f_reg
& ~battery_mask_f
))
1571 alert_charger
= true;
1573 mutex_unlock(&bdi
->f_reg_lock
);
1576 if (ss_reg
!= bdi
->ss_reg
) {
1578 * The device is in host mode so when PG_STAT goes from 1->0
1579 * (i.e., power removed) HIZ needs to be disabled.
1581 if ((bdi
->ss_reg
& BQ24190_REG_SS_PG_STAT_MASK
) &&
1582 !(ss_reg
& BQ24190_REG_SS_PG_STAT_MASK
)) {
1583 ret
= bq24190_write_mask(bdi
, BQ24190_REG_ISC
,
1584 BQ24190_REG_ISC_EN_HIZ_MASK
,
1585 BQ24190_REG_ISC_EN_HIZ_SHIFT
,
1588 dev_err(bdi
->dev
, "Can't access ISC reg: %d\n",
1592 if ((bdi
->ss_reg
& battery_mask_ss
) != (ss_reg
& battery_mask_ss
))
1593 alert_battery
= true;
1594 if ((bdi
->ss_reg
& ~battery_mask_ss
) != (ss_reg
& ~battery_mask_ss
))
1595 alert_charger
= true;
1596 bdi
->ss_reg
= ss_reg
;
1599 if (alert_charger
|| alert_battery
) {
1600 power_supply_changed(bdi
->charger
);
1601 bq24190_configure_usb_otg(bdi
, ss_reg
);
1603 if (alert_battery
&& bdi
->battery
)
1604 power_supply_changed(bdi
->battery
);
1606 dev_dbg(bdi
->dev
, "ss_reg: 0x%02x, f_reg: 0x%02x\n", ss_reg
, f_reg
);
1609 static irqreturn_t
bq24190_irq_handler_thread(int irq
, void *data
)
1611 struct bq24190_dev_info
*bdi
= data
;
1614 bdi
->irq_event
= true;
1615 error
= pm_runtime_get_sync(bdi
->dev
);
1617 dev_warn(bdi
->dev
, "pm_runtime_get failed: %i\n", error
);
1618 pm_runtime_put_noidle(bdi
->dev
);
1621 bq24190_check_status(bdi
);
1622 pm_runtime_mark_last_busy(bdi
->dev
);
1623 pm_runtime_put_autosuspend(bdi
->dev
);
1624 bdi
->irq_event
= false;
1629 static int bq24190_hw_init(struct bq24190_dev_info
*bdi
)
1634 /* First check that the device really is what its supposed to be */
1635 ret
= bq24190_read_mask(bdi
, BQ24190_REG_VPRS
,
1636 BQ24190_REG_VPRS_PN_MASK
,
1637 BQ24190_REG_VPRS_PN_SHIFT
,
1643 case BQ24190_REG_VPRS_PN_24190
:
1644 case BQ24190_REG_VPRS_PN_24192
:
1645 case BQ24190_REG_VPRS_PN_24192I
:
1648 dev_err(bdi
->dev
, "Error unknown model: 0x%02x\n", v
);
1652 ret
= bq24190_register_reset(bdi
);
1656 ret
= bq24190_set_config(bdi
);
1660 return bq24190_read(bdi
, BQ24190_REG_SS
, &bdi
->ss_reg
);
1663 static int bq24190_get_config(struct bq24190_dev_info
*bdi
)
1665 const char * const s
= "ti,system-minimum-microvolt";
1666 struct power_supply_battery_info info
= {};
1669 if (device_property_read_u32(bdi
->dev
, s
, &v
) == 0) {
1671 if (v
>= BQ24190_REG_POC_SYS_MIN_MIN
1672 && v
<= BQ24190_REG_POC_SYS_MIN_MAX
)
1675 dev_warn(bdi
->dev
, "invalid value for %s: %u\n", s
, v
);
1678 if (bdi
->dev
->of_node
&&
1679 !power_supply_get_battery_info(bdi
->charger
, &info
)) {
1680 v
= info
.precharge_current_ua
/ 1000;
1681 if (v
>= BQ24190_REG_PCTCC_IPRECHG_MIN
1682 && v
<= BQ24190_REG_PCTCC_IPRECHG_MAX
)
1685 dev_warn(bdi
->dev
, "invalid value for battery:precharge-current-microamp: %d\n",
1688 v
= info
.charge_term_current_ua
/ 1000;
1689 if (v
>= BQ24190_REG_PCTCC_ITERM_MIN
1690 && v
<= BQ24190_REG_PCTCC_ITERM_MAX
)
1693 dev_warn(bdi
->dev
, "invalid value for battery:charge-term-current-microamp: %d\n",
1700 static int bq24190_probe(struct i2c_client
*client
,
1701 const struct i2c_device_id
*id
)
1703 struct i2c_adapter
*adapter
= to_i2c_adapter(client
->dev
.parent
);
1704 struct device
*dev
= &client
->dev
;
1705 struct power_supply_config charger_cfg
= {}, battery_cfg
= {};
1706 struct bq24190_dev_info
*bdi
;
1709 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
)) {
1710 dev_err(dev
, "No support for SMBUS_BYTE_DATA\n");
1714 bdi
= devm_kzalloc(dev
, sizeof(*bdi
), GFP_KERNEL
);
1716 dev_err(dev
, "Can't alloc bdi struct\n");
1720 bdi
->client
= client
;
1722 strncpy(bdi
->model_name
, id
->name
, I2C_NAME_SIZE
);
1723 mutex_init(&bdi
->f_reg_lock
);
1725 bdi
->ss_reg
= BQ24190_REG_SS_VBUS_STAT_MASK
; /* impossible state */
1726 INIT_DELAYED_WORK(&bdi
->input_current_limit_work
,
1727 bq24190_input_current_limit_work
);
1729 i2c_set_clientdata(client
, bdi
);
1731 if (client
->irq
<= 0) {
1732 dev_err(dev
, "Can't get irq info\n");
1736 bdi
->edev
= devm_extcon_dev_allocate(dev
, bq24190_usb_extcon_cable
);
1737 if (IS_ERR(bdi
->edev
))
1738 return PTR_ERR(bdi
->edev
);
1740 ret
= devm_extcon_dev_register(dev
, bdi
->edev
);
1744 pm_runtime_enable(dev
);
1745 pm_runtime_use_autosuspend(dev
);
1746 pm_runtime_set_autosuspend_delay(dev
, 600);
1747 ret
= pm_runtime_get_sync(dev
);
1749 dev_err(dev
, "pm_runtime_get failed: %i\n", ret
);
1754 bq24190_sysfs_init_attrs();
1755 charger_cfg
.attr_grp
= bq24190_sysfs_groups
;
1758 charger_cfg
.drv_data
= bdi
;
1759 charger_cfg
.of_node
= dev
->of_node
;
1760 charger_cfg
.supplied_to
= bq24190_charger_supplied_to
;
1761 charger_cfg
.num_supplicants
= ARRAY_SIZE(bq24190_charger_supplied_to
),
1762 bdi
->charger
= power_supply_register(dev
, &bq24190_charger_desc
,
1764 if (IS_ERR(bdi
->charger
)) {
1765 dev_err(dev
, "Can't register charger\n");
1766 ret
= PTR_ERR(bdi
->charger
);
1770 /* the battery class is deprecated and will be removed. */
1771 /* in the interim, this property hides it. */
1772 if (!device_property_read_bool(dev
, "omit-battery-class")) {
1773 battery_cfg
.drv_data
= bdi
;
1774 bdi
->battery
= power_supply_register(dev
, &bq24190_battery_desc
,
1776 if (IS_ERR(bdi
->battery
)) {
1777 dev_err(dev
, "Can't register battery\n");
1778 ret
= PTR_ERR(bdi
->battery
);
1783 ret
= bq24190_get_config(bdi
);
1785 dev_err(dev
, "Can't get devicetree config\n");
1789 ret
= bq24190_hw_init(bdi
);
1791 dev_err(dev
, "Hardware init failed\n");
1795 ret
= bq24190_configure_usb_otg(bdi
, bdi
->ss_reg
);
1799 bdi
->initialized
= true;
1801 ret
= devm_request_threaded_irq(dev
, client
->irq
, NULL
,
1802 bq24190_irq_handler_thread
,
1803 IRQF_TRIGGER_FALLING
| IRQF_ONESHOT
,
1804 "bq24190-charger", bdi
);
1806 dev_err(dev
, "Can't set up irq handler\n");
1810 ret
= bq24190_register_vbus_regulator(bdi
);
1814 enable_irq_wake(client
->irq
);
1816 pm_runtime_mark_last_busy(dev
);
1817 pm_runtime_put_autosuspend(dev
);
1822 if (!IS_ERR_OR_NULL(bdi
->battery
))
1823 power_supply_unregister(bdi
->battery
);
1824 power_supply_unregister(bdi
->charger
);
1827 pm_runtime_put_sync(dev
);
1828 pm_runtime_dont_use_autosuspend(dev
);
1829 pm_runtime_disable(dev
);
1833 static int bq24190_remove(struct i2c_client
*client
)
1835 struct bq24190_dev_info
*bdi
= i2c_get_clientdata(client
);
1838 error
= pm_runtime_get_sync(bdi
->dev
);
1840 dev_warn(bdi
->dev
, "pm_runtime_get failed: %i\n", error
);
1841 pm_runtime_put_noidle(bdi
->dev
);
1844 bq24190_register_reset(bdi
);
1846 power_supply_unregister(bdi
->battery
);
1847 power_supply_unregister(bdi
->charger
);
1849 pm_runtime_put_sync(bdi
->dev
);
1850 pm_runtime_dont_use_autosuspend(bdi
->dev
);
1851 pm_runtime_disable(bdi
->dev
);
1856 static __maybe_unused
int bq24190_runtime_suspend(struct device
*dev
)
1858 struct i2c_client
*client
= to_i2c_client(dev
);
1859 struct bq24190_dev_info
*bdi
= i2c_get_clientdata(client
);
1861 if (!bdi
->initialized
)
1864 dev_dbg(bdi
->dev
, "%s\n", __func__
);
1869 static __maybe_unused
int bq24190_runtime_resume(struct device
*dev
)
1871 struct i2c_client
*client
= to_i2c_client(dev
);
1872 struct bq24190_dev_info
*bdi
= i2c_get_clientdata(client
);
1874 if (!bdi
->initialized
)
1877 if (!bdi
->irq_event
) {
1878 dev_dbg(bdi
->dev
, "checking events on possible wakeirq\n");
1879 bq24190_check_status(bdi
);
1885 static __maybe_unused
int bq24190_pm_suspend(struct device
*dev
)
1887 struct i2c_client
*client
= to_i2c_client(dev
);
1888 struct bq24190_dev_info
*bdi
= i2c_get_clientdata(client
);
1891 error
= pm_runtime_get_sync(bdi
->dev
);
1893 dev_warn(bdi
->dev
, "pm_runtime_get failed: %i\n", error
);
1894 pm_runtime_put_noidle(bdi
->dev
);
1897 bq24190_register_reset(bdi
);
1900 pm_runtime_mark_last_busy(bdi
->dev
);
1901 pm_runtime_put_autosuspend(bdi
->dev
);
1907 static __maybe_unused
int bq24190_pm_resume(struct device
*dev
)
1909 struct i2c_client
*client
= to_i2c_client(dev
);
1910 struct bq24190_dev_info
*bdi
= i2c_get_clientdata(client
);
1914 bdi
->ss_reg
= BQ24190_REG_SS_VBUS_STAT_MASK
; /* impossible state */
1916 error
= pm_runtime_get_sync(bdi
->dev
);
1918 dev_warn(bdi
->dev
, "pm_runtime_get failed: %i\n", error
);
1919 pm_runtime_put_noidle(bdi
->dev
);
1922 bq24190_register_reset(bdi
);
1923 bq24190_set_config(bdi
);
1924 bq24190_read(bdi
, BQ24190_REG_SS
, &bdi
->ss_reg
);
1927 pm_runtime_mark_last_busy(bdi
->dev
);
1928 pm_runtime_put_autosuspend(bdi
->dev
);
1931 /* Things may have changed while suspended so alert upper layer */
1932 power_supply_changed(bdi
->charger
);
1934 power_supply_changed(bdi
->battery
);
1939 static const struct dev_pm_ops bq24190_pm_ops
= {
1940 SET_RUNTIME_PM_OPS(bq24190_runtime_suspend
, bq24190_runtime_resume
,
1942 SET_SYSTEM_SLEEP_PM_OPS(bq24190_pm_suspend
, bq24190_pm_resume
)
1945 static const struct i2c_device_id bq24190_i2c_ids
[] = {
1952 MODULE_DEVICE_TABLE(i2c
, bq24190_i2c_ids
);
1955 static const struct of_device_id bq24190_of_match
[] = {
1956 { .compatible
= "ti,bq24190", },
1957 { .compatible
= "ti,bq24192", },
1958 { .compatible
= "ti,bq24192i", },
1959 { .compatible
= "ti,bq24196", },
1962 MODULE_DEVICE_TABLE(of
, bq24190_of_match
);
1964 static const struct of_device_id bq24190_of_match
[] = {
1969 static struct i2c_driver bq24190_driver
= {
1970 .probe
= bq24190_probe
,
1971 .remove
= bq24190_remove
,
1972 .id_table
= bq24190_i2c_ids
,
1974 .name
= "bq24190-charger",
1975 .pm
= &bq24190_pm_ops
,
1976 .of_match_table
= of_match_ptr(bq24190_of_match
),
1979 module_i2c_driver(bq24190_driver
);
1981 MODULE_LICENSE("GPL");
1982 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
1983 MODULE_DESCRIPTION("TI BQ24190 Charger Driver");