1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Driver for the TI bq24190 battery charger.
4 *
5 * Author: Mark A. Greer <mgreer@animalcreek.com>
6 */
7
8 #include <linux/module.h>
9 #include <linux/interrupt.h>
10 #include <linux/delay.h>
11 #include <linux/of_irq.h>
12 #include <linux/of_device.h>
13 #include <linux/pm_runtime.h>
14 #include <linux/power_supply.h>
15 #include <linux/power/bq24190_charger.h>
16 #include <linux/regulator/driver.h>
17 #include <linux/regulator/machine.h>
18 #include <linux/workqueue.h>
19 #include <linux/gpio.h>
20 #include <linux/i2c.h>
21 #include <linux/extcon-provider.h>
22
23 #define BQ24190_MANUFACTURER "Texas Instruments"
24
25 #define BQ24190_REG_ISC 0x00 /* Input Source Control */
26 #define BQ24190_REG_ISC_EN_HIZ_MASK BIT(7)
27 #define BQ24190_REG_ISC_EN_HIZ_SHIFT 7
28 #define BQ24190_REG_ISC_VINDPM_MASK (BIT(6) | BIT(5) | BIT(4) | \
29 BIT(3))
30 #define BQ24190_REG_ISC_VINDPM_SHIFT 3
31 #define BQ24190_REG_ISC_IINLIM_MASK (BIT(2) | BIT(1) | BIT(0))
32 #define BQ24190_REG_ISC_IINLIM_SHIFT 0
33
34 #define BQ24190_REG_POC 0x01 /* Power-On Configuration */
35 #define BQ24190_REG_POC_RESET_MASK BIT(7)
36 #define BQ24190_REG_POC_RESET_SHIFT 7
37 #define BQ24190_REG_POC_WDT_RESET_MASK BIT(6)
38 #define BQ24190_REG_POC_WDT_RESET_SHIFT 6
39 #define BQ24190_REG_POC_CHG_CONFIG_MASK (BIT(5) | BIT(4))
40 #define BQ24190_REG_POC_CHG_CONFIG_SHIFT 4
41 #define BQ24190_REG_POC_CHG_CONFIG_DISABLE 0x0
42 #define BQ24190_REG_POC_CHG_CONFIG_CHARGE 0x1
43 #define BQ24190_REG_POC_CHG_CONFIG_OTG 0x2
44 #define BQ24190_REG_POC_CHG_CONFIG_OTG_ALT 0x3
45 #define BQ24190_REG_POC_SYS_MIN_MASK (BIT(3) | BIT(2) | BIT(1))
46 #define BQ24190_REG_POC_SYS_MIN_SHIFT 1
47 #define BQ24190_REG_POC_SYS_MIN_MIN 3000
48 #define BQ24190_REG_POC_SYS_MIN_MAX 3700
49 #define BQ24190_REG_POC_BOOST_LIM_MASK BIT(0)
50 #define BQ24190_REG_POC_BOOST_LIM_SHIFT 0
51
52 #define BQ24190_REG_CCC 0x02 /* Charge Current Control */
53 #define BQ24190_REG_CCC_ICHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
54 BIT(4) | BIT(3) | BIT(2))
55 #define BQ24190_REG_CCC_ICHG_SHIFT 2
56 #define BQ24190_REG_CCC_FORCE_20PCT_MASK BIT(0)
57 #define BQ24190_REG_CCC_FORCE_20PCT_SHIFT 0
58
59 #define BQ24190_REG_PCTCC 0x03 /* Pre-charge/Termination Current Cntl */
60 #define BQ24190_REG_PCTCC_IPRECHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
61 BIT(4))
62 #define BQ24190_REG_PCTCC_IPRECHG_SHIFT 4
63 #define BQ24190_REG_PCTCC_IPRECHG_MIN 128
64 #define BQ24190_REG_PCTCC_IPRECHG_MAX 2048
65 #define BQ24190_REG_PCTCC_ITERM_MASK (BIT(3) | BIT(2) | BIT(1) | \
66 BIT(0))
67 #define BQ24190_REG_PCTCC_ITERM_SHIFT 0
68 #define BQ24190_REG_PCTCC_ITERM_MIN 128
69 #define BQ24190_REG_PCTCC_ITERM_MAX 2048
70
71 #define BQ24190_REG_CVC 0x04 /* Charge Voltage Control */
72 #define BQ24190_REG_CVC_VREG_MASK (BIT(7) | BIT(6) | BIT(5) | \
73 BIT(4) | BIT(3) | BIT(2))
74 #define BQ24190_REG_CVC_VREG_SHIFT 2
75 #define BQ24190_REG_CVC_BATLOWV_MASK BIT(1)
76 #define BQ24190_REG_CVC_BATLOWV_SHIFT 1
77 #define BQ24190_REG_CVC_VRECHG_MASK BIT(0)
78 #define BQ24190_REG_CVC_VRECHG_SHIFT 0
79
80 #define BQ24190_REG_CTTC 0x05 /* Charge Term/Timer Control */
81 #define BQ24190_REG_CTTC_EN_TERM_MASK BIT(7)
82 #define BQ24190_REG_CTTC_EN_TERM_SHIFT 7
83 #define BQ24190_REG_CTTC_TERM_STAT_MASK BIT(6)
84 #define BQ24190_REG_CTTC_TERM_STAT_SHIFT 6
85 #define BQ24190_REG_CTTC_WATCHDOG_MASK (BIT(5) | BIT(4))
86 #define BQ24190_REG_CTTC_WATCHDOG_SHIFT 4
87 #define BQ24190_REG_CTTC_EN_TIMER_MASK BIT(3)
88 #define BQ24190_REG_CTTC_EN_TIMER_SHIFT 3
89 #define BQ24190_REG_CTTC_CHG_TIMER_MASK (BIT(2) | BIT(1))
90 #define BQ24190_REG_CTTC_CHG_TIMER_SHIFT 1
91 #define BQ24190_REG_CTTC_JEITA_ISET_MASK BIT(0)
92 #define BQ24190_REG_CTTC_JEITA_ISET_SHIFT 0
93
94 #define BQ24190_REG_ICTRC 0x06 /* IR Comp/Thermal Regulation Control */
95 #define BQ24190_REG_ICTRC_BAT_COMP_MASK (BIT(7) | BIT(6) | BIT(5))
96 #define BQ24190_REG_ICTRC_BAT_COMP_SHIFT 5
97 #define BQ24190_REG_ICTRC_VCLAMP_MASK (BIT(4) | BIT(3) | BIT(2))
98 #define BQ24190_REG_ICTRC_VCLAMP_SHIFT 2
99 #define BQ24190_REG_ICTRC_TREG_MASK (BIT(1) | BIT(0))
100 #define BQ24190_REG_ICTRC_TREG_SHIFT 0
101
102 #define BQ24190_REG_MOC 0x07 /* Misc. Operation Control */
103 #define BQ24190_REG_MOC_DPDM_EN_MASK BIT(7)
104 #define BQ24190_REG_MOC_DPDM_EN_SHIFT 7
105 #define BQ24190_REG_MOC_TMR2X_EN_MASK BIT(6)
106 #define BQ24190_REG_MOC_TMR2X_EN_SHIFT 6
107 #define BQ24190_REG_MOC_BATFET_DISABLE_MASK BIT(5)
108 #define BQ24190_REG_MOC_BATFET_DISABLE_SHIFT 5
109 #define BQ24190_REG_MOC_JEITA_VSET_MASK BIT(4)
110 #define BQ24190_REG_MOC_JEITA_VSET_SHIFT 4
111 #define BQ24190_REG_MOC_INT_MASK_MASK (BIT(1) | BIT(0))
112 #define BQ24190_REG_MOC_INT_MASK_SHIFT 0
113
114 #define BQ24190_REG_SS 0x08 /* System Status */
115 #define BQ24190_REG_SS_VBUS_STAT_MASK (BIT(7) | BIT(6))
116 #define BQ24190_REG_SS_VBUS_STAT_SHIFT 6
117 #define BQ24190_REG_SS_CHRG_STAT_MASK (BIT(5) | BIT(4))
118 #define BQ24190_REG_SS_CHRG_STAT_SHIFT 4
119 #define BQ24190_REG_SS_DPM_STAT_MASK BIT(3)
120 #define BQ24190_REG_SS_DPM_STAT_SHIFT 3
121 #define BQ24190_REG_SS_PG_STAT_MASK BIT(2)
122 #define BQ24190_REG_SS_PG_STAT_SHIFT 2
123 #define BQ24190_REG_SS_THERM_STAT_MASK BIT(1)
124 #define BQ24190_REG_SS_THERM_STAT_SHIFT 1
125 #define BQ24190_REG_SS_VSYS_STAT_MASK BIT(0)
126 #define BQ24190_REG_SS_VSYS_STAT_SHIFT 0
127
128 #define BQ24190_REG_F 0x09 /* Fault */
129 #define BQ24190_REG_F_WATCHDOG_FAULT_MASK BIT(7)
130 #define BQ24190_REG_F_WATCHDOG_FAULT_SHIFT 7
131 #define BQ24190_REG_F_BOOST_FAULT_MASK BIT(6)
132 #define BQ24190_REG_F_BOOST_FAULT_SHIFT 6
133 #define BQ24190_REG_F_CHRG_FAULT_MASK (BIT(5) | BIT(4))
134 #define BQ24190_REG_F_CHRG_FAULT_SHIFT 4
135 #define BQ24190_REG_F_BAT_FAULT_MASK BIT(3)
136 #define BQ24190_REG_F_BAT_FAULT_SHIFT 3
137 #define BQ24190_REG_F_NTC_FAULT_MASK (BIT(2) | BIT(1) | BIT(0))
138 #define BQ24190_REG_F_NTC_FAULT_SHIFT 0
139
140 #define BQ24190_REG_VPRS 0x0A /* Vendor/Part/Revision Status */
141 #define BQ24190_REG_VPRS_PN_MASK (BIT(5) | BIT(4) | BIT(3))
142 #define BQ24190_REG_VPRS_PN_SHIFT 3
143 #define BQ24190_REG_VPRS_PN_24190 0x4
144 #define BQ24190_REG_VPRS_PN_24192 0x5 /* Also 24193, 24196 */
145 #define BQ24190_REG_VPRS_PN_24192I 0x3
146 #define BQ24190_REG_VPRS_TS_PROFILE_MASK BIT(2)
147 #define BQ24190_REG_VPRS_TS_PROFILE_SHIFT 2
148 #define BQ24190_REG_VPRS_DEV_REG_MASK (BIT(1) | BIT(0))
149 #define BQ24190_REG_VPRS_DEV_REG_SHIFT 0
150
151 /*
152 * The FAULT register is latched by the bq24190 (except for NTC_FAULT)
153 * so the first read after a fault returns the latched value and subsequent
154 * reads return the current value. In order to return the fault status
155 * to the user, have the interrupt handler save the reg's value and retrieve
156 * it in the appropriate health/status routine.
157 */
158 struct bq24190_dev_info {
159 struct i2c_client *client;
160 struct device *dev;
161 struct extcon_dev *edev;
162 struct power_supply *charger;
163 struct power_supply *battery;
164 struct delayed_work input_current_limit_work;
165 char model_name[I2C_NAME_SIZE];
166 bool initialized;
167 bool irq_event;
168 u16 sys_min;
169 u16 iprechg;
170 u16 iterm;
171 struct mutex f_reg_lock;
172 u8 f_reg;
173 u8 ss_reg;
174 u8 watchdog;
175 };
176
177 static const unsigned int bq24190_usb_extcon_cable[] = {
178 EXTCON_USB,
179 EXTCON_NONE,
180 };
181
182 /*
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
187 * represents.
188 */
189
190 /* REG00[2:0] (IINLIM) in uAh */
191 static const int bq24190_isc_iinlim_values[] = {
192 100000, 150000, 500000, 900000, 1200000, 1500000, 2000000, 3000000
193 };
194
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
205 };
206
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,
216 4400000
217 };
218
219 /* REG06[1:0] (TREG) in tenths of degrees Celsius */
220 static const int bq24190_ictrc_treg_values[] = {
221 600, 800, 1000, 1200
222 };
223
224 /*
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'
228 * is less than 2^8.
229 */
bq24190_find_idx(const int tbl[],int tbl_size,int v)230 static u8 bq24190_find_idx(const int tbl[], int tbl_size, int v)
231 {
232 int i;
233
234 for (i = 1; i < tbl_size; i++)
235 if (v < tbl[i])
236 break;
237
238 return i - 1;
239 }
240
241 /* Basic driver I/O routines */
242
bq24190_read(struct bq24190_dev_info * bdi,u8 reg,u8 * data)243 static int bq24190_read(struct bq24190_dev_info *bdi, u8 reg, u8 *data)
244 {
245 int ret;
246
247 ret = i2c_smbus_read_byte_data(bdi->client, reg);
248 if (ret < 0)
249 return ret;
250
251 *data = ret;
252 return 0;
253 }
254
bq24190_write(struct bq24190_dev_info * bdi,u8 reg,u8 data)255 static int bq24190_write(struct bq24190_dev_info *bdi, u8 reg, u8 data)
256 {
257 return i2c_smbus_write_byte_data(bdi->client, reg, data);
258 }
259
bq24190_read_mask(struct bq24190_dev_info * bdi,u8 reg,u8 mask,u8 shift,u8 * data)260 static int bq24190_read_mask(struct bq24190_dev_info *bdi, u8 reg,
261 u8 mask, u8 shift, u8 *data)
262 {
263 u8 v;
264 int ret;
265
266 ret = bq24190_read(bdi, reg, &v);
267 if (ret < 0)
268 return ret;
269
270 v &= mask;
271 v >>= shift;
272 *data = v;
273
274 return 0;
275 }
276
bq24190_write_mask(struct bq24190_dev_info * bdi,u8 reg,u8 mask,u8 shift,u8 data)277 static int bq24190_write_mask(struct bq24190_dev_info *bdi, u8 reg,
278 u8 mask, u8 shift, u8 data)
279 {
280 u8 v;
281 int ret;
282
283 ret = bq24190_read(bdi, reg, &v);
284 if (ret < 0)
285 return ret;
286
287 v &= ~mask;
288 v |= ((data << shift) & mask);
289
290 return bq24190_write(bdi, reg, v);
291 }
292
bq24190_get_field_val(struct bq24190_dev_info * bdi,u8 reg,u8 mask,u8 shift,const int tbl[],int tbl_size,int * val)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,
296 int *val)
297 {
298 u8 v;
299 int ret;
300
301 ret = bq24190_read_mask(bdi, reg, mask, shift, &v);
302 if (ret < 0)
303 return ret;
304
305 v = (v >= tbl_size) ? (tbl_size - 1) : v;
306 *val = tbl[v];
307
308 return 0;
309 }
310
bq24190_set_field_val(struct bq24190_dev_info * bdi,u8 reg,u8 mask,u8 shift,const int tbl[],int tbl_size,int val)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,
314 int val)
315 {
316 u8 idx;
317
318 idx = bq24190_find_idx(tbl, tbl_size, val);
319
320 return bq24190_write_mask(bdi, reg, mask, shift, idx);
321 }
322
323 #ifdef CONFIG_SYSFS
324 /*
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.
330 */
331
332 #define BQ24190_SYSFS_FIELD(_name, r, f, m, store) \
333 { \
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, \
338 }
339
340 #define BQ24190_SYSFS_FIELD_RW(_name, r, f) \
341 BQ24190_SYSFS_FIELD(_name, r, f, S_IWUSR | S_IRUGO, \
342 bq24190_sysfs_store)
343
344 #define BQ24190_SYSFS_FIELD_RO(_name, r, f) \
345 BQ24190_SYSFS_FIELD(_name, r, f, S_IRUGO, NULL)
346
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);
351
352 struct bq24190_sysfs_field_info {
353 struct device_attribute attr;
354 u8 reg;
355 u8 mask;
356 u8 shift;
357 };
358
359 /* On i386 ptrace-abi.h defines SS that breaks the macro calls below. */
360 #undef SS
361
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),
405 };
406
407 static struct attribute *
408 bq24190_sysfs_attrs[ARRAY_SIZE(bq24190_sysfs_field_tbl) + 1];
409
410 ATTRIBUTE_GROUPS(bq24190_sysfs);
411
bq24190_sysfs_init_attrs(void)412 static void bq24190_sysfs_init_attrs(void)
413 {
414 int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
415
416 for (i = 0; i < limit; i++)
417 bq24190_sysfs_attrs[i] = &bq24190_sysfs_field_tbl[i].attr.attr;
418
419 bq24190_sysfs_attrs[limit] = NULL; /* Has additional entry for this */
420 }
421
bq24190_sysfs_field_lookup(const char * name)422 static struct bq24190_sysfs_field_info *bq24190_sysfs_field_lookup(
423 const char *name)
424 {
425 int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
426
427 for (i = 0; i < limit; i++)
428 if (!strcmp(name, bq24190_sysfs_field_tbl[i].attr.attr.name))
429 break;
430
431 if (i >= limit)
432 return NULL;
433
434 return &bq24190_sysfs_field_tbl[i];
435 }
436
bq24190_sysfs_show(struct device * dev,struct device_attribute * attr,char * buf)437 static ssize_t bq24190_sysfs_show(struct device *dev,
438 struct device_attribute *attr, char *buf)
439 {
440 struct power_supply *psy = dev_get_drvdata(dev);
441 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
442 struct bq24190_sysfs_field_info *info;
443 ssize_t count;
444 int ret;
445 u8 v;
446
447 info = bq24190_sysfs_field_lookup(attr->attr.name);
448 if (!info)
449 return -EINVAL;
450
451 ret = pm_runtime_get_sync(bdi->dev);
452 if (ret < 0) {
453 pm_runtime_put_noidle(bdi->dev);
454 return ret;
455 }
456
457 ret = bq24190_read_mask(bdi, info->reg, info->mask, info->shift, &v);
458 if (ret)
459 count = ret;
460 else
461 count = scnprintf(buf, PAGE_SIZE, "%hhx\n", v);
462
463 pm_runtime_mark_last_busy(bdi->dev);
464 pm_runtime_put_autosuspend(bdi->dev);
465
466 return count;
467 }
468
bq24190_sysfs_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)469 static ssize_t bq24190_sysfs_store(struct device *dev,
470 struct device_attribute *attr, const char *buf, size_t count)
471 {
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;
475 int ret;
476 u8 v;
477
478 info = bq24190_sysfs_field_lookup(attr->attr.name);
479 if (!info)
480 return -EINVAL;
481
482 ret = kstrtou8(buf, 0, &v);
483 if (ret < 0)
484 return ret;
485
486 ret = pm_runtime_get_sync(bdi->dev);
487 if (ret < 0) {
488 pm_runtime_put_noidle(bdi->dev);
489 return ret;
490 }
491
492 ret = bq24190_write_mask(bdi, info->reg, info->mask, info->shift, v);
493 if (ret)
494 count = ret;
495
496 pm_runtime_mark_last_busy(bdi->dev);
497 pm_runtime_put_autosuspend(bdi->dev);
498
499 return count;
500 }
501 #endif
502
503 #ifdef CONFIG_REGULATOR
bq24190_set_charge_mode(struct regulator_dev * dev,u8 val)504 static int bq24190_set_charge_mode(struct regulator_dev *dev, u8 val)
505 {
506 struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
507 int ret;
508
509 ret = pm_runtime_get_sync(bdi->dev);
510 if (ret < 0) {
511 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
512 pm_runtime_put_noidle(bdi->dev);
513 return ret;
514 }
515
516 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
517 BQ24190_REG_POC_CHG_CONFIG_MASK,
518 BQ24190_REG_POC_CHG_CONFIG_SHIFT, val);
519
520 pm_runtime_mark_last_busy(bdi->dev);
521 pm_runtime_put_autosuspend(bdi->dev);
522
523 return ret;
524 }
525
bq24190_vbus_enable(struct regulator_dev * dev)526 static int bq24190_vbus_enable(struct regulator_dev *dev)
527 {
528 return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_OTG);
529 }
530
bq24190_vbus_disable(struct regulator_dev * dev)531 static int bq24190_vbus_disable(struct regulator_dev *dev)
532 {
533 return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_CHARGE);
534 }
535
bq24190_vbus_is_enabled(struct regulator_dev * dev)536 static int bq24190_vbus_is_enabled(struct regulator_dev *dev)
537 {
538 struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
539 int ret;
540 u8 val;
541
542 ret = pm_runtime_get_sync(bdi->dev);
543 if (ret < 0) {
544 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
545 pm_runtime_put_noidle(bdi->dev);
546 return ret;
547 }
548
549 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
550 BQ24190_REG_POC_CHG_CONFIG_MASK,
551 BQ24190_REG_POC_CHG_CONFIG_SHIFT, &val);
552
553 pm_runtime_mark_last_busy(bdi->dev);
554 pm_runtime_put_autosuspend(bdi->dev);
555
556 if (ret)
557 return ret;
558
559 return (val == BQ24190_REG_POC_CHG_CONFIG_OTG ||
560 val == BQ24190_REG_POC_CHG_CONFIG_OTG_ALT);
561 }
562
563 static const struct regulator_ops bq24190_vbus_ops = {
564 .enable = bq24190_vbus_enable,
565 .disable = bq24190_vbus_disable,
566 .is_enabled = bq24190_vbus_is_enabled,
567 };
568
569 static const struct regulator_desc bq24190_vbus_desc = {
570 .name = "usb_otg_vbus",
571 .of_match = "usb-otg-vbus",
572 .type = REGULATOR_VOLTAGE,
573 .owner = THIS_MODULE,
574 .ops = &bq24190_vbus_ops,
575 .fixed_uV = 5000000,
576 .n_voltages = 1,
577 };
578
579 static const struct regulator_init_data bq24190_vbus_init_data = {
580 .constraints = {
581 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
582 },
583 };
584
bq24190_register_vbus_regulator(struct bq24190_dev_info * bdi)585 static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
586 {
587 struct bq24190_platform_data *pdata = bdi->dev->platform_data;
588 struct regulator_config cfg = { };
589 struct regulator_dev *reg;
590 int ret = 0;
591
592 cfg.dev = bdi->dev;
593 if (pdata && pdata->regulator_init_data)
594 cfg.init_data = pdata->regulator_init_data;
595 else
596 cfg.init_data = &bq24190_vbus_init_data;
597 cfg.driver_data = bdi;
598 reg = devm_regulator_register(bdi->dev, &bq24190_vbus_desc, &cfg);
599 if (IS_ERR(reg)) {
600 ret = PTR_ERR(reg);
601 dev_err(bdi->dev, "Can't register regulator: %d\n", ret);
602 }
603
604 return ret;
605 }
606 #else
bq24190_register_vbus_regulator(struct bq24190_dev_info * bdi)607 static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
608 {
609 return 0;
610 }
611 #endif
612
bq24190_set_config(struct bq24190_dev_info * bdi)613 static int bq24190_set_config(struct bq24190_dev_info *bdi)
614 {
615 int ret;
616 u8 v;
617
618 ret = bq24190_read(bdi, BQ24190_REG_CTTC, &v);
619 if (ret < 0)
620 return ret;
621
622 bdi->watchdog = ((v & BQ24190_REG_CTTC_WATCHDOG_MASK) >>
623 BQ24190_REG_CTTC_WATCHDOG_SHIFT);
624
625 /*
626 * According to the "Host Mode and default Mode" section of the
627 * manual, a write to any register causes the bq24190 to switch
628 * from default mode to host mode. It will switch back to default
629 * mode after a WDT timeout unless the WDT is turned off as well.
630 * So, by simply turning off the WDT, we accomplish both with the
631 * same write.
632 */
633 v &= ~BQ24190_REG_CTTC_WATCHDOG_MASK;
634
635 ret = bq24190_write(bdi, BQ24190_REG_CTTC, v);
636 if (ret < 0)
637 return ret;
638
639 if (bdi->sys_min) {
640 v = bdi->sys_min / 100 - 30; // manual section 9.5.1.2, table 9
641 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
642 BQ24190_REG_POC_SYS_MIN_MASK,
643 BQ24190_REG_POC_SYS_MIN_SHIFT,
644 v);
645 if (ret < 0)
646 return ret;
647 }
648
649 if (bdi->iprechg) {
650 v = bdi->iprechg / 128 - 1; // manual section 9.5.1.4, table 11
651 ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
652 BQ24190_REG_PCTCC_IPRECHG_MASK,
653 BQ24190_REG_PCTCC_IPRECHG_SHIFT,
654 v);
655 if (ret < 0)
656 return ret;
657 }
658
659 if (bdi->iterm) {
660 v = bdi->iterm / 128 - 1; // manual section 9.5.1.4, table 11
661 ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
662 BQ24190_REG_PCTCC_ITERM_MASK,
663 BQ24190_REG_PCTCC_ITERM_SHIFT,
664 v);
665 if (ret < 0)
666 return ret;
667 }
668
669 return 0;
670 }
671
bq24190_register_reset(struct bq24190_dev_info * bdi)672 static int bq24190_register_reset(struct bq24190_dev_info *bdi)
673 {
674 int ret, limit = 100;
675 u8 v;
676
677 /*
678 * This prop. can be passed on device instantiation from platform code:
679 * struct property_entry pe[] =
680 * { PROPERTY_ENTRY_BOOL("disable-reset"), ... };
681 * struct i2c_board_info bi =
682 * { .type = "bq24190", .addr = 0x6b, .properties = pe, .irq = irq };
683 * struct i2c_adapter ad = { ... };
684 * i2c_add_adapter(&ad);
685 * i2c_new_client_device(&ad, &bi);
686 */
687 if (device_property_read_bool(bdi->dev, "disable-reset"))
688 return 0;
689
690 /* Reset the registers */
691 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
692 BQ24190_REG_POC_RESET_MASK,
693 BQ24190_REG_POC_RESET_SHIFT,
694 0x1);
695 if (ret < 0)
696 return ret;
697
698 /* Reset bit will be cleared by hardware so poll until it is */
699 do {
700 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
701 BQ24190_REG_POC_RESET_MASK,
702 BQ24190_REG_POC_RESET_SHIFT,
703 &v);
704 if (ret < 0)
705 return ret;
706
707 if (v == 0)
708 return 0;
709
710 usleep_range(100, 200);
711 } while (--limit);
712
713 return -EIO;
714 }
715
716 /* Charger power supply property routines */
717
bq24190_charger_get_charge_type(struct bq24190_dev_info * bdi,union power_supply_propval * val)718 static int bq24190_charger_get_charge_type(struct bq24190_dev_info *bdi,
719 union power_supply_propval *val)
720 {
721 u8 v;
722 int type, ret;
723
724 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
725 BQ24190_REG_POC_CHG_CONFIG_MASK,
726 BQ24190_REG_POC_CHG_CONFIG_SHIFT,
727 &v);
728 if (ret < 0)
729 return ret;
730
731 /* If POC[CHG_CONFIG] (REG01[5:4]) == 0, charge is disabled */
732 if (!v) {
733 type = POWER_SUPPLY_CHARGE_TYPE_NONE;
734 } else {
735 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
736 BQ24190_REG_CCC_FORCE_20PCT_MASK,
737 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
738 &v);
739 if (ret < 0)
740 return ret;
741
742 type = (v) ? POWER_SUPPLY_CHARGE_TYPE_TRICKLE :
743 POWER_SUPPLY_CHARGE_TYPE_FAST;
744 }
745
746 val->intval = type;
747
748 return 0;
749 }
750
bq24190_charger_set_charge_type(struct bq24190_dev_info * bdi,const union power_supply_propval * val)751 static int bq24190_charger_set_charge_type(struct bq24190_dev_info *bdi,
752 const union power_supply_propval *val)
753 {
754 u8 chg_config, force_20pct, en_term;
755 int ret;
756
757 /*
758 * According to the "Termination when REG02[0] = 1" section of
759 * the bq24190 manual, the trickle charge could be less than the
760 * termination current so it recommends turning off the termination
761 * function.
762 *
763 * Note: AFAICT from the datasheet, the user will have to manually
764 * turn off the charging when in 20% mode. If its not turned off,
765 * there could be battery damage. So, use this mode at your own risk.
766 */
767 switch (val->intval) {
768 case POWER_SUPPLY_CHARGE_TYPE_NONE:
769 chg_config = 0x0;
770 break;
771 case POWER_SUPPLY_CHARGE_TYPE_TRICKLE:
772 chg_config = 0x1;
773 force_20pct = 0x1;
774 en_term = 0x0;
775 break;
776 case POWER_SUPPLY_CHARGE_TYPE_FAST:
777 chg_config = 0x1;
778 force_20pct = 0x0;
779 en_term = 0x1;
780 break;
781 default:
782 return -EINVAL;
783 }
784
785 if (chg_config) { /* Enabling the charger */
786 ret = bq24190_write_mask(bdi, BQ24190_REG_CCC,
787 BQ24190_REG_CCC_FORCE_20PCT_MASK,
788 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
789 force_20pct);
790 if (ret < 0)
791 return ret;
792
793 ret = bq24190_write_mask(bdi, BQ24190_REG_CTTC,
794 BQ24190_REG_CTTC_EN_TERM_MASK,
795 BQ24190_REG_CTTC_EN_TERM_SHIFT,
796 en_term);
797 if (ret < 0)
798 return ret;
799 }
800
801 return bq24190_write_mask(bdi, BQ24190_REG_POC,
802 BQ24190_REG_POC_CHG_CONFIG_MASK,
803 BQ24190_REG_POC_CHG_CONFIG_SHIFT, chg_config);
804 }
805
bq24190_charger_get_health(struct bq24190_dev_info * bdi,union power_supply_propval * val)806 static int bq24190_charger_get_health(struct bq24190_dev_info *bdi,
807 union power_supply_propval *val)
808 {
809 u8 v;
810 int health;
811
812 mutex_lock(&bdi->f_reg_lock);
813 v = bdi->f_reg;
814 mutex_unlock(&bdi->f_reg_lock);
815
816 if (v & BQ24190_REG_F_NTC_FAULT_MASK) {
817 switch (v >> BQ24190_REG_F_NTC_FAULT_SHIFT & 0x7) {
818 case 0x1: /* TS1 Cold */
819 case 0x3: /* TS2 Cold */
820 case 0x5: /* Both Cold */
821 health = POWER_SUPPLY_HEALTH_COLD;
822 break;
823 case 0x2: /* TS1 Hot */
824 case 0x4: /* TS2 Hot */
825 case 0x6: /* Both Hot */
826 health = POWER_SUPPLY_HEALTH_OVERHEAT;
827 break;
828 default:
829 health = POWER_SUPPLY_HEALTH_UNKNOWN;
830 }
831 } else if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
832 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
833 } else if (v & BQ24190_REG_F_CHRG_FAULT_MASK) {
834 switch (v >> BQ24190_REG_F_CHRG_FAULT_SHIFT & 0x3) {
835 case 0x1: /* Input Fault (VBUS OVP or VBAT<VBUS<3.8V) */
836 /*
837 * This could be over-voltage or under-voltage
838 * and there's no way to tell which. Instead
839 * of looking foolish and returning 'OVERVOLTAGE'
840 * when its really under-voltage, just return
841 * 'UNSPEC_FAILURE'.
842 */
843 health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
844 break;
845 case 0x2: /* Thermal Shutdown */
846 health = POWER_SUPPLY_HEALTH_OVERHEAT;
847 break;
848 case 0x3: /* Charge Safety Timer Expiration */
849 health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
850 break;
851 default: /* prevent compiler warning */
852 health = -1;
853 }
854 } else if (v & BQ24190_REG_F_BOOST_FAULT_MASK) {
855 /*
856 * This could be over-current or over-voltage but there's
857 * no way to tell which. Return 'OVERVOLTAGE' since there
858 * isn't an 'OVERCURRENT' value defined that we can return
859 * even if it was over-current.
860 */
861 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
862 } else {
863 health = POWER_SUPPLY_HEALTH_GOOD;
864 }
865
866 val->intval = health;
867
868 return 0;
869 }
870
bq24190_charger_get_online(struct bq24190_dev_info * bdi,union power_supply_propval * val)871 static int bq24190_charger_get_online(struct bq24190_dev_info *bdi,
872 union power_supply_propval *val)
873 {
874 u8 pg_stat, batfet_disable;
875 int ret;
876
877 ret = bq24190_read_mask(bdi, BQ24190_REG_SS,
878 BQ24190_REG_SS_PG_STAT_MASK,
879 BQ24190_REG_SS_PG_STAT_SHIFT, &pg_stat);
880 if (ret < 0)
881 return ret;
882
883 ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
884 BQ24190_REG_MOC_BATFET_DISABLE_MASK,
885 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
886 if (ret < 0)
887 return ret;
888
889 val->intval = pg_stat && !batfet_disable;
890
891 return 0;
892 }
893
894 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
895 const union power_supply_propval *val);
896 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
897 union power_supply_propval *val);
898 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
899 union power_supply_propval *val);
900 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
901 const union power_supply_propval *val);
902
bq24190_charger_set_online(struct bq24190_dev_info * bdi,const union power_supply_propval * val)903 static int bq24190_charger_set_online(struct bq24190_dev_info *bdi,
904 const union power_supply_propval *val)
905 {
906 return bq24190_battery_set_online(bdi, val);
907 }
908
bq24190_charger_get_status(struct bq24190_dev_info * bdi,union power_supply_propval * val)909 static int bq24190_charger_get_status(struct bq24190_dev_info *bdi,
910 union power_supply_propval *val)
911 {
912 return bq24190_battery_get_status(bdi, val);
913 }
914
bq24190_charger_get_temp_alert_max(struct bq24190_dev_info * bdi,union power_supply_propval * val)915 static int bq24190_charger_get_temp_alert_max(struct bq24190_dev_info *bdi,
916 union power_supply_propval *val)
917 {
918 return bq24190_battery_get_temp_alert_max(bdi, val);
919 }
920
bq24190_charger_set_temp_alert_max(struct bq24190_dev_info * bdi,const union power_supply_propval * val)921 static int bq24190_charger_set_temp_alert_max(struct bq24190_dev_info *bdi,
922 const union power_supply_propval *val)
923 {
924 return bq24190_battery_set_temp_alert_max(bdi, val);
925 }
926
bq24190_charger_get_precharge(struct bq24190_dev_info * bdi,union power_supply_propval * val)927 static int bq24190_charger_get_precharge(struct bq24190_dev_info *bdi,
928 union power_supply_propval *val)
929 {
930 u8 v;
931 int ret;
932
933 ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
934 BQ24190_REG_PCTCC_IPRECHG_MASK,
935 BQ24190_REG_PCTCC_IPRECHG_SHIFT, &v);
936 if (ret < 0)
937 return ret;
938
939 val->intval = ++v * 128 * 1000;
940 return 0;
941 }
942
bq24190_charger_get_charge_term(struct bq24190_dev_info * bdi,union power_supply_propval * val)943 static int bq24190_charger_get_charge_term(struct bq24190_dev_info *bdi,
944 union power_supply_propval *val)
945 {
946 u8 v;
947 int ret;
948
949 ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
950 BQ24190_REG_PCTCC_ITERM_MASK,
951 BQ24190_REG_PCTCC_ITERM_SHIFT, &v);
952 if (ret < 0)
953 return ret;
954
955 val->intval = ++v * 128 * 1000;
956 return 0;
957 }
958
bq24190_charger_get_current(struct bq24190_dev_info * bdi,union power_supply_propval * val)959 static int bq24190_charger_get_current(struct bq24190_dev_info *bdi,
960 union power_supply_propval *val)
961 {
962 u8 v;
963 int curr, ret;
964
965 ret = bq24190_get_field_val(bdi, BQ24190_REG_CCC,
966 BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
967 bq24190_ccc_ichg_values,
968 ARRAY_SIZE(bq24190_ccc_ichg_values), &curr);
969 if (ret < 0)
970 return ret;
971
972 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
973 BQ24190_REG_CCC_FORCE_20PCT_MASK,
974 BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
975 if (ret < 0)
976 return ret;
977
978 /* If FORCE_20PCT is enabled, then current is 20% of ICHG value */
979 if (v)
980 curr /= 5;
981
982 val->intval = curr;
983 return 0;
984 }
985
bq24190_charger_get_current_max(struct bq24190_dev_info * bdi,union power_supply_propval * val)986 static int bq24190_charger_get_current_max(struct bq24190_dev_info *bdi,
987 union power_supply_propval *val)
988 {
989 int idx = ARRAY_SIZE(bq24190_ccc_ichg_values) - 1;
990
991 val->intval = bq24190_ccc_ichg_values[idx];
992 return 0;
993 }
994
bq24190_charger_set_current(struct bq24190_dev_info * bdi,const union power_supply_propval * val)995 static int bq24190_charger_set_current(struct bq24190_dev_info *bdi,
996 const union power_supply_propval *val)
997 {
998 u8 v;
999 int ret, curr = val->intval;
1000
1001 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
1002 BQ24190_REG_CCC_FORCE_20PCT_MASK,
1003 BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
1004 if (ret < 0)
1005 return ret;
1006
1007 /* If FORCE_20PCT is enabled, have to multiply value passed in by 5 */
1008 if (v)
1009 curr *= 5;
1010
1011 return bq24190_set_field_val(bdi, BQ24190_REG_CCC,
1012 BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
1013 bq24190_ccc_ichg_values,
1014 ARRAY_SIZE(bq24190_ccc_ichg_values), curr);
1015 }
1016
bq24190_charger_get_voltage(struct bq24190_dev_info * bdi,union power_supply_propval * val)1017 static int bq24190_charger_get_voltage(struct bq24190_dev_info *bdi,
1018 union power_supply_propval *val)
1019 {
1020 int voltage, ret;
1021
1022 ret = bq24190_get_field_val(bdi, BQ24190_REG_CVC,
1023 BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
1024 bq24190_cvc_vreg_values,
1025 ARRAY_SIZE(bq24190_cvc_vreg_values), &voltage);
1026 if (ret < 0)
1027 return ret;
1028
1029 val->intval = voltage;
1030 return 0;
1031 }
1032
bq24190_charger_get_voltage_max(struct bq24190_dev_info * bdi,union power_supply_propval * val)1033 static int bq24190_charger_get_voltage_max(struct bq24190_dev_info *bdi,
1034 union power_supply_propval *val)
1035 {
1036 int idx = ARRAY_SIZE(bq24190_cvc_vreg_values) - 1;
1037
1038 val->intval = bq24190_cvc_vreg_values[idx];
1039 return 0;
1040 }
1041
bq24190_charger_set_voltage(struct bq24190_dev_info * bdi,const union power_supply_propval * val)1042 static int bq24190_charger_set_voltage(struct bq24190_dev_info *bdi,
1043 const union power_supply_propval *val)
1044 {
1045 return bq24190_set_field_val(bdi, BQ24190_REG_CVC,
1046 BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
1047 bq24190_cvc_vreg_values,
1048 ARRAY_SIZE(bq24190_cvc_vreg_values), val->intval);
1049 }
1050
bq24190_charger_get_iinlimit(struct bq24190_dev_info * bdi,union power_supply_propval * val)1051 static int bq24190_charger_get_iinlimit(struct bq24190_dev_info *bdi,
1052 union power_supply_propval *val)
1053 {
1054 int iinlimit, ret;
1055
1056 ret = bq24190_get_field_val(bdi, BQ24190_REG_ISC,
1057 BQ24190_REG_ISC_IINLIM_MASK,
1058 BQ24190_REG_ISC_IINLIM_SHIFT,
1059 bq24190_isc_iinlim_values,
1060 ARRAY_SIZE(bq24190_isc_iinlim_values), &iinlimit);
1061 if (ret < 0)
1062 return ret;
1063
1064 val->intval = iinlimit;
1065 return 0;
1066 }
1067
bq24190_charger_set_iinlimit(struct bq24190_dev_info * bdi,const union power_supply_propval * val)1068 static int bq24190_charger_set_iinlimit(struct bq24190_dev_info *bdi,
1069 const union power_supply_propval *val)
1070 {
1071 return bq24190_set_field_val(bdi, BQ24190_REG_ISC,
1072 BQ24190_REG_ISC_IINLIM_MASK,
1073 BQ24190_REG_ISC_IINLIM_SHIFT,
1074 bq24190_isc_iinlim_values,
1075 ARRAY_SIZE(bq24190_isc_iinlim_values), val->intval);
1076 }
1077
bq24190_charger_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)1078 static int bq24190_charger_get_property(struct power_supply *psy,
1079 enum power_supply_property psp, union power_supply_propval *val)
1080 {
1081 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1082 int ret;
1083
1084 dev_dbg(bdi->dev, "prop: %d\n", psp);
1085
1086 ret = pm_runtime_get_sync(bdi->dev);
1087 if (ret < 0) {
1088 pm_runtime_put_noidle(bdi->dev);
1089 return ret;
1090 }
1091
1092 switch (psp) {
1093 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1094 ret = bq24190_charger_get_charge_type(bdi, val);
1095 break;
1096 case POWER_SUPPLY_PROP_HEALTH:
1097 ret = bq24190_charger_get_health(bdi, val);
1098 break;
1099 case POWER_SUPPLY_PROP_ONLINE:
1100 ret = bq24190_charger_get_online(bdi, val);
1101 break;
1102 case POWER_SUPPLY_PROP_STATUS:
1103 ret = bq24190_charger_get_status(bdi, val);
1104 break;
1105 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1106 ret = bq24190_charger_get_temp_alert_max(bdi, val);
1107 break;
1108 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1109 ret = bq24190_charger_get_precharge(bdi, val);
1110 break;
1111 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1112 ret = bq24190_charger_get_charge_term(bdi, val);
1113 break;
1114 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1115 ret = bq24190_charger_get_current(bdi, val);
1116 break;
1117 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
1118 ret = bq24190_charger_get_current_max(bdi, val);
1119 break;
1120 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1121 ret = bq24190_charger_get_voltage(bdi, val);
1122 break;
1123 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
1124 ret = bq24190_charger_get_voltage_max(bdi, val);
1125 break;
1126 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1127 ret = bq24190_charger_get_iinlimit(bdi, val);
1128 break;
1129 case POWER_SUPPLY_PROP_SCOPE:
1130 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1131 ret = 0;
1132 break;
1133 case POWER_SUPPLY_PROP_MODEL_NAME:
1134 val->strval = bdi->model_name;
1135 ret = 0;
1136 break;
1137 case POWER_SUPPLY_PROP_MANUFACTURER:
1138 val->strval = BQ24190_MANUFACTURER;
1139 ret = 0;
1140 break;
1141 default:
1142 ret = -ENODATA;
1143 }
1144
1145 pm_runtime_mark_last_busy(bdi->dev);
1146 pm_runtime_put_autosuspend(bdi->dev);
1147
1148 return ret;
1149 }
1150
bq24190_charger_set_property(struct power_supply * psy,enum power_supply_property psp,const union power_supply_propval * val)1151 static int bq24190_charger_set_property(struct power_supply *psy,
1152 enum power_supply_property psp,
1153 const union power_supply_propval *val)
1154 {
1155 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1156 int ret;
1157
1158 dev_dbg(bdi->dev, "prop: %d\n", psp);
1159
1160 ret = pm_runtime_get_sync(bdi->dev);
1161 if (ret < 0) {
1162 pm_runtime_put_noidle(bdi->dev);
1163 return ret;
1164 }
1165
1166 switch (psp) {
1167 case POWER_SUPPLY_PROP_ONLINE:
1168 ret = bq24190_charger_set_online(bdi, val);
1169 break;
1170 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1171 ret = bq24190_charger_set_temp_alert_max(bdi, val);
1172 break;
1173 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1174 ret = bq24190_charger_set_charge_type(bdi, val);
1175 break;
1176 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1177 ret = bq24190_charger_set_current(bdi, val);
1178 break;
1179 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1180 ret = bq24190_charger_set_voltage(bdi, val);
1181 break;
1182 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1183 ret = bq24190_charger_set_iinlimit(bdi, val);
1184 break;
1185 default:
1186 ret = -EINVAL;
1187 }
1188
1189 pm_runtime_mark_last_busy(bdi->dev);
1190 pm_runtime_put_autosuspend(bdi->dev);
1191
1192 return ret;
1193 }
1194
bq24190_charger_property_is_writeable(struct power_supply * psy,enum power_supply_property psp)1195 static int bq24190_charger_property_is_writeable(struct power_supply *psy,
1196 enum power_supply_property psp)
1197 {
1198 switch (psp) {
1199 case POWER_SUPPLY_PROP_ONLINE:
1200 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1201 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1202 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1203 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1204 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1205 return 1;
1206 default:
1207 return 0;
1208 }
1209 }
1210
bq24190_input_current_limit_work(struct work_struct * work)1211 static void bq24190_input_current_limit_work(struct work_struct *work)
1212 {
1213 struct bq24190_dev_info *bdi =
1214 container_of(work, struct bq24190_dev_info,
1215 input_current_limit_work.work);
1216
1217 power_supply_set_input_current_limit_from_supplier(bdi->charger);
1218 }
1219
1220 /* Sync the input-current-limit with our parent supply (if we have one) */
bq24190_charger_external_power_changed(struct power_supply * psy)1221 static void bq24190_charger_external_power_changed(struct power_supply *psy)
1222 {
1223 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1224
1225 /*
1226 * The Power-Good detection may take up to 220ms, sometimes
1227 * the external charger detection is quicker, and the bq24190 will
1228 * reset to iinlim based on its own charger detection (which is not
1229 * hooked up when using external charger detection) resulting in a
1230 * too low default 500mA iinlim. Delay setting the input-current-limit
1231 * for 300ms to avoid this.
1232 */
1233 queue_delayed_work(system_wq, &bdi->input_current_limit_work,
1234 msecs_to_jiffies(300));
1235 }
1236
1237 static enum power_supply_property bq24190_charger_properties[] = {
1238 POWER_SUPPLY_PROP_CHARGE_TYPE,
1239 POWER_SUPPLY_PROP_HEALTH,
1240 POWER_SUPPLY_PROP_ONLINE,
1241 POWER_SUPPLY_PROP_STATUS,
1242 POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1243 POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
1244 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
1245 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1246 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
1247 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1248 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
1249 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1250 POWER_SUPPLY_PROP_SCOPE,
1251 POWER_SUPPLY_PROP_MODEL_NAME,
1252 POWER_SUPPLY_PROP_MANUFACTURER,
1253 };
1254
1255 static char *bq24190_charger_supplied_to[] = {
1256 "main-battery",
1257 };
1258
1259 static const struct power_supply_desc bq24190_charger_desc = {
1260 .name = "bq24190-charger",
1261 .type = POWER_SUPPLY_TYPE_USB,
1262 .properties = bq24190_charger_properties,
1263 .num_properties = ARRAY_SIZE(bq24190_charger_properties),
1264 .get_property = bq24190_charger_get_property,
1265 .set_property = bq24190_charger_set_property,
1266 .property_is_writeable = bq24190_charger_property_is_writeable,
1267 .external_power_changed = bq24190_charger_external_power_changed,
1268 };
1269
1270 /* Battery power supply property routines */
1271
bq24190_battery_get_status(struct bq24190_dev_info * bdi,union power_supply_propval * val)1272 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
1273 union power_supply_propval *val)
1274 {
1275 u8 ss_reg, chrg_fault;
1276 int status, ret;
1277
1278 mutex_lock(&bdi->f_reg_lock);
1279 chrg_fault = bdi->f_reg;
1280 mutex_unlock(&bdi->f_reg_lock);
1281
1282 chrg_fault &= BQ24190_REG_F_CHRG_FAULT_MASK;
1283 chrg_fault >>= BQ24190_REG_F_CHRG_FAULT_SHIFT;
1284
1285 ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1286 if (ret < 0)
1287 return ret;
1288
1289 /*
1290 * The battery must be discharging when any of these are true:
1291 * - there is no good power source;
1292 * - there is a charge fault.
1293 * Could also be discharging when in "supplement mode" but
1294 * there is no way to tell when its in that mode.
1295 */
1296 if (!(ss_reg & BQ24190_REG_SS_PG_STAT_MASK) || chrg_fault) {
1297 status = POWER_SUPPLY_STATUS_DISCHARGING;
1298 } else {
1299 ss_reg &= BQ24190_REG_SS_CHRG_STAT_MASK;
1300 ss_reg >>= BQ24190_REG_SS_CHRG_STAT_SHIFT;
1301
1302 switch (ss_reg) {
1303 case 0x0: /* Not Charging */
1304 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1305 break;
1306 case 0x1: /* Pre-charge */
1307 case 0x2: /* Fast Charging */
1308 status = POWER_SUPPLY_STATUS_CHARGING;
1309 break;
1310 case 0x3: /* Charge Termination Done */
1311 status = POWER_SUPPLY_STATUS_FULL;
1312 break;
1313 default:
1314 ret = -EIO;
1315 }
1316 }
1317
1318 if (!ret)
1319 val->intval = status;
1320
1321 return ret;
1322 }
1323
bq24190_battery_get_health(struct bq24190_dev_info * bdi,union power_supply_propval * val)1324 static int bq24190_battery_get_health(struct bq24190_dev_info *bdi,
1325 union power_supply_propval *val)
1326 {
1327 u8 v;
1328 int health;
1329
1330 mutex_lock(&bdi->f_reg_lock);
1331 v = bdi->f_reg;
1332 mutex_unlock(&bdi->f_reg_lock);
1333
1334 if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
1335 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1336 } else {
1337 v &= BQ24190_REG_F_NTC_FAULT_MASK;
1338 v >>= BQ24190_REG_F_NTC_FAULT_SHIFT;
1339
1340 switch (v) {
1341 case 0x0: /* Normal */
1342 health = POWER_SUPPLY_HEALTH_GOOD;
1343 break;
1344 case 0x1: /* TS1 Cold */
1345 case 0x3: /* TS2 Cold */
1346 case 0x5: /* Both Cold */
1347 health = POWER_SUPPLY_HEALTH_COLD;
1348 break;
1349 case 0x2: /* TS1 Hot */
1350 case 0x4: /* TS2 Hot */
1351 case 0x6: /* Both Hot */
1352 health = POWER_SUPPLY_HEALTH_OVERHEAT;
1353 break;
1354 default:
1355 health = POWER_SUPPLY_HEALTH_UNKNOWN;
1356 }
1357 }
1358
1359 val->intval = health;
1360 return 0;
1361 }
1362
bq24190_battery_get_online(struct bq24190_dev_info * bdi,union power_supply_propval * val)1363 static int bq24190_battery_get_online(struct bq24190_dev_info *bdi,
1364 union power_supply_propval *val)
1365 {
1366 u8 batfet_disable;
1367 int ret;
1368
1369 ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
1370 BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1371 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
1372 if (ret < 0)
1373 return ret;
1374
1375 val->intval = !batfet_disable;
1376 return 0;
1377 }
1378
bq24190_battery_set_online(struct bq24190_dev_info * bdi,const union power_supply_propval * val)1379 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
1380 const union power_supply_propval *val)
1381 {
1382 return bq24190_write_mask(bdi, BQ24190_REG_MOC,
1383 BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1384 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, !val->intval);
1385 }
1386
bq24190_battery_get_temp_alert_max(struct bq24190_dev_info * bdi,union power_supply_propval * val)1387 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
1388 union power_supply_propval *val)
1389 {
1390 int temp, ret;
1391
1392 ret = bq24190_get_field_val(bdi, BQ24190_REG_ICTRC,
1393 BQ24190_REG_ICTRC_TREG_MASK,
1394 BQ24190_REG_ICTRC_TREG_SHIFT,
1395 bq24190_ictrc_treg_values,
1396 ARRAY_SIZE(bq24190_ictrc_treg_values), &temp);
1397 if (ret < 0)
1398 return ret;
1399
1400 val->intval = temp;
1401 return 0;
1402 }
1403
bq24190_battery_set_temp_alert_max(struct bq24190_dev_info * bdi,const union power_supply_propval * val)1404 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
1405 const union power_supply_propval *val)
1406 {
1407 return bq24190_set_field_val(bdi, BQ24190_REG_ICTRC,
1408 BQ24190_REG_ICTRC_TREG_MASK,
1409 BQ24190_REG_ICTRC_TREG_SHIFT,
1410 bq24190_ictrc_treg_values,
1411 ARRAY_SIZE(bq24190_ictrc_treg_values), val->intval);
1412 }
1413
bq24190_battery_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)1414 static int bq24190_battery_get_property(struct power_supply *psy,
1415 enum power_supply_property psp, union power_supply_propval *val)
1416 {
1417 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1418 int ret;
1419
1420 dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1421 dev_dbg(bdi->dev, "prop: %d\n", psp);
1422
1423 ret = pm_runtime_get_sync(bdi->dev);
1424 if (ret < 0) {
1425 pm_runtime_put_noidle(bdi->dev);
1426 return ret;
1427 }
1428
1429 switch (psp) {
1430 case POWER_SUPPLY_PROP_STATUS:
1431 ret = bq24190_battery_get_status(bdi, val);
1432 break;
1433 case POWER_SUPPLY_PROP_HEALTH:
1434 ret = bq24190_battery_get_health(bdi, val);
1435 break;
1436 case POWER_SUPPLY_PROP_ONLINE:
1437 ret = bq24190_battery_get_online(bdi, val);
1438 break;
1439 case POWER_SUPPLY_PROP_TECHNOLOGY:
1440 /* Could be Li-on or Li-polymer but no way to tell which */
1441 val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
1442 ret = 0;
1443 break;
1444 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1445 ret = bq24190_battery_get_temp_alert_max(bdi, val);
1446 break;
1447 case POWER_SUPPLY_PROP_SCOPE:
1448 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1449 ret = 0;
1450 break;
1451 default:
1452 ret = -ENODATA;
1453 }
1454
1455 pm_runtime_mark_last_busy(bdi->dev);
1456 pm_runtime_put_autosuspend(bdi->dev);
1457
1458 return ret;
1459 }
1460
bq24190_battery_set_property(struct power_supply * psy,enum power_supply_property psp,const union power_supply_propval * val)1461 static int bq24190_battery_set_property(struct power_supply *psy,
1462 enum power_supply_property psp,
1463 const union power_supply_propval *val)
1464 {
1465 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1466 int ret;
1467
1468 dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1469 dev_dbg(bdi->dev, "prop: %d\n", psp);
1470
1471 ret = pm_runtime_get_sync(bdi->dev);
1472 if (ret < 0) {
1473 pm_runtime_put_noidle(bdi->dev);
1474 return ret;
1475 }
1476
1477 switch (psp) {
1478 case POWER_SUPPLY_PROP_ONLINE:
1479 ret = bq24190_battery_set_online(bdi, val);
1480 break;
1481 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1482 ret = bq24190_battery_set_temp_alert_max(bdi, val);
1483 break;
1484 default:
1485 ret = -EINVAL;
1486 }
1487
1488 pm_runtime_mark_last_busy(bdi->dev);
1489 pm_runtime_put_autosuspend(bdi->dev);
1490
1491 return ret;
1492 }
1493
bq24190_battery_property_is_writeable(struct power_supply * psy,enum power_supply_property psp)1494 static int bq24190_battery_property_is_writeable(struct power_supply *psy,
1495 enum power_supply_property psp)
1496 {
1497 int ret;
1498
1499 switch (psp) {
1500 case POWER_SUPPLY_PROP_ONLINE:
1501 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1502 ret = 1;
1503 break;
1504 default:
1505 ret = 0;
1506 }
1507
1508 return ret;
1509 }
1510
1511 static enum power_supply_property bq24190_battery_properties[] = {
1512 POWER_SUPPLY_PROP_STATUS,
1513 POWER_SUPPLY_PROP_HEALTH,
1514 POWER_SUPPLY_PROP_ONLINE,
1515 POWER_SUPPLY_PROP_TECHNOLOGY,
1516 POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1517 POWER_SUPPLY_PROP_SCOPE,
1518 };
1519
1520 static const struct power_supply_desc bq24190_battery_desc = {
1521 .name = "bq24190-battery",
1522 .type = POWER_SUPPLY_TYPE_BATTERY,
1523 .properties = bq24190_battery_properties,
1524 .num_properties = ARRAY_SIZE(bq24190_battery_properties),
1525 .get_property = bq24190_battery_get_property,
1526 .set_property = bq24190_battery_set_property,
1527 .property_is_writeable = bq24190_battery_property_is_writeable,
1528 };
1529
bq24190_configure_usb_otg(struct bq24190_dev_info * bdi,u8 ss_reg)1530 static int bq24190_configure_usb_otg(struct bq24190_dev_info *bdi, u8 ss_reg)
1531 {
1532 bool otg_enabled;
1533 int ret;
1534
1535 otg_enabled = !!(ss_reg & BQ24190_REG_SS_VBUS_STAT_MASK);
1536 ret = extcon_set_state_sync(bdi->edev, EXTCON_USB, otg_enabled);
1537 if (ret < 0)
1538 dev_err(bdi->dev, "Can't set extcon state to %d: %d\n",
1539 otg_enabled, ret);
1540
1541 return ret;
1542 }
1543
bq24190_check_status(struct bq24190_dev_info * bdi)1544 static void bq24190_check_status(struct bq24190_dev_info *bdi)
1545 {
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;
1551 int i, ret;
1552
1553 ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1554 if (ret < 0) {
1555 dev_err(bdi->dev, "Can't read SS reg: %d\n", ret);
1556 return;
1557 }
1558
1559 i = 0;
1560 do {
1561 ret = bq24190_read(bdi, BQ24190_REG_F, &f_reg);
1562 if (ret < 0) {
1563 dev_err(bdi->dev, "Can't read F reg: %d\n", ret);
1564 return;
1565 }
1566 } while (f_reg && ++i < 2);
1567
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))
1571 f_reg = 0;
1572
1573 if (f_reg != bdi->f_reg) {
1574 dev_warn(bdi->dev,
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));
1580
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;
1586 bdi->f_reg = f_reg;
1587 mutex_unlock(&bdi->f_reg_lock);
1588 }
1589
1590 if (ss_reg != bdi->ss_reg) {
1591 /*
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.
1594 */
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,
1600 0);
1601 if (ret < 0)
1602 dev_err(bdi->dev, "Can't access ISC reg: %d\n",
1603 ret);
1604 }
1605
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;
1611 }
1612
1613 if (alert_charger || alert_battery) {
1614 power_supply_changed(bdi->charger);
1615 bq24190_configure_usb_otg(bdi, ss_reg);
1616 }
1617 if (alert_battery && bdi->battery)
1618 power_supply_changed(bdi->battery);
1619
1620 dev_dbg(bdi->dev, "ss_reg: 0x%02x, f_reg: 0x%02x\n", ss_reg, f_reg);
1621 }
1622
bq24190_irq_handler_thread(int irq,void * data)1623 static irqreturn_t bq24190_irq_handler_thread(int irq, void *data)
1624 {
1625 struct bq24190_dev_info *bdi = data;
1626 int error;
1627
1628 bdi->irq_event = true;
1629 error = pm_runtime_get_sync(bdi->dev);
1630 if (error < 0) {
1631 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1632 pm_runtime_put_noidle(bdi->dev);
1633 return IRQ_NONE;
1634 }
1635 bq24190_check_status(bdi);
1636 pm_runtime_mark_last_busy(bdi->dev);
1637 pm_runtime_put_autosuspend(bdi->dev);
1638 bdi->irq_event = false;
1639
1640 return IRQ_HANDLED;
1641 }
1642
bq24190_hw_init(struct bq24190_dev_info * bdi)1643 static int bq24190_hw_init(struct bq24190_dev_info *bdi)
1644 {
1645 u8 v;
1646 int ret;
1647
1648 /* First check that the device really is what its supposed to be */
1649 ret = bq24190_read_mask(bdi, BQ24190_REG_VPRS,
1650 BQ24190_REG_VPRS_PN_MASK,
1651 BQ24190_REG_VPRS_PN_SHIFT,
1652 &v);
1653 if (ret < 0)
1654 return ret;
1655
1656 switch (v) {
1657 case BQ24190_REG_VPRS_PN_24190:
1658 case BQ24190_REG_VPRS_PN_24192:
1659 case BQ24190_REG_VPRS_PN_24192I:
1660 break;
1661 default:
1662 dev_err(bdi->dev, "Error unknown model: 0x%02x\n", v);
1663 return -ENODEV;
1664 }
1665
1666 ret = bq24190_register_reset(bdi);
1667 if (ret < 0)
1668 return ret;
1669
1670 ret = bq24190_set_config(bdi);
1671 if (ret < 0)
1672 return ret;
1673
1674 return bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1675 }
1676
bq24190_get_config(struct bq24190_dev_info * bdi)1677 static int bq24190_get_config(struct bq24190_dev_info *bdi)
1678 {
1679 const char * const s = "ti,system-minimum-microvolt";
1680 struct power_supply_battery_info info = {};
1681 int v;
1682
1683 if (device_property_read_u32(bdi->dev, s, &v) == 0) {
1684 v /= 1000;
1685 if (v >= BQ24190_REG_POC_SYS_MIN_MIN
1686 && v <= BQ24190_REG_POC_SYS_MIN_MAX)
1687 bdi->sys_min = v;
1688 else
1689 dev_warn(bdi->dev, "invalid value for %s: %u\n", s, v);
1690 }
1691
1692 if (bdi->dev->of_node &&
1693 !power_supply_get_battery_info(bdi->charger, &info)) {
1694 v = info.precharge_current_ua / 1000;
1695 if (v >= BQ24190_REG_PCTCC_IPRECHG_MIN
1696 && v <= BQ24190_REG_PCTCC_IPRECHG_MAX)
1697 bdi->iprechg = v;
1698 else
1699 dev_warn(bdi->dev, "invalid value for battery:precharge-current-microamp: %d\n",
1700 v);
1701
1702 v = info.charge_term_current_ua / 1000;
1703 if (v >= BQ24190_REG_PCTCC_ITERM_MIN
1704 && v <= BQ24190_REG_PCTCC_ITERM_MAX)
1705 bdi->iterm = v;
1706 else
1707 dev_warn(bdi->dev, "invalid value for battery:charge-term-current-microamp: %d\n",
1708 v);
1709 }
1710
1711 return 0;
1712 }
1713
bq24190_probe(struct i2c_client * client,const struct i2c_device_id * id)1714 static int bq24190_probe(struct i2c_client *client,
1715 const struct i2c_device_id *id)
1716 {
1717 struct i2c_adapter *adapter = client->adapter;
1718 struct device *dev = &client->dev;
1719 struct power_supply_config charger_cfg = {}, battery_cfg = {};
1720 struct bq24190_dev_info *bdi;
1721 int ret;
1722
1723 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1724 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1725 return -ENODEV;
1726 }
1727
1728 bdi = devm_kzalloc(dev, sizeof(*bdi), GFP_KERNEL);
1729 if (!bdi) {
1730 dev_err(dev, "Can't alloc bdi struct\n");
1731 return -ENOMEM;
1732 }
1733
1734 bdi->client = client;
1735 bdi->dev = dev;
1736 strncpy(bdi->model_name, id->name, I2C_NAME_SIZE);
1737 mutex_init(&bdi->f_reg_lock);
1738 bdi->f_reg = 0;
1739 bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1740 INIT_DELAYED_WORK(&bdi->input_current_limit_work,
1741 bq24190_input_current_limit_work);
1742
1743 i2c_set_clientdata(client, bdi);
1744
1745 if (client->irq <= 0) {
1746 dev_err(dev, "Can't get irq info\n");
1747 return -EINVAL;
1748 }
1749
1750 bdi->edev = devm_extcon_dev_allocate(dev, bq24190_usb_extcon_cable);
1751 if (IS_ERR(bdi->edev))
1752 return PTR_ERR(bdi->edev);
1753
1754 ret = devm_extcon_dev_register(dev, bdi->edev);
1755 if (ret < 0)
1756 return ret;
1757
1758 pm_runtime_enable(dev);
1759 pm_runtime_use_autosuspend(dev);
1760 pm_runtime_set_autosuspend_delay(dev, 600);
1761 ret = pm_runtime_get_sync(dev);
1762 if (ret < 0) {
1763 dev_err(dev, "pm_runtime_get failed: %i\n", ret);
1764 goto out_pmrt;
1765 }
1766
1767 #ifdef CONFIG_SYSFS
1768 bq24190_sysfs_init_attrs();
1769 charger_cfg.attr_grp = bq24190_sysfs_groups;
1770 #endif
1771
1772 charger_cfg.drv_data = bdi;
1773 charger_cfg.of_node = dev->of_node;
1774 charger_cfg.supplied_to = bq24190_charger_supplied_to;
1775 charger_cfg.num_supplicants = ARRAY_SIZE(bq24190_charger_supplied_to),
1776 bdi->charger = power_supply_register(dev, &bq24190_charger_desc,
1777 &charger_cfg);
1778 if (IS_ERR(bdi->charger)) {
1779 dev_err(dev, "Can't register charger\n");
1780 ret = PTR_ERR(bdi->charger);
1781 goto out_pmrt;
1782 }
1783
1784 /* the battery class is deprecated and will be removed. */
1785 /* in the interim, this property hides it. */
1786 if (!device_property_read_bool(dev, "omit-battery-class")) {
1787 battery_cfg.drv_data = bdi;
1788 bdi->battery = power_supply_register(dev, &bq24190_battery_desc,
1789 &battery_cfg);
1790 if (IS_ERR(bdi->battery)) {
1791 dev_err(dev, "Can't register battery\n");
1792 ret = PTR_ERR(bdi->battery);
1793 goto out_charger;
1794 }
1795 }
1796
1797 ret = bq24190_get_config(bdi);
1798 if (ret < 0) {
1799 dev_err(dev, "Can't get devicetree config\n");
1800 goto out_charger;
1801 }
1802
1803 ret = bq24190_hw_init(bdi);
1804 if (ret < 0) {
1805 dev_err(dev, "Hardware init failed\n");
1806 goto out_charger;
1807 }
1808
1809 ret = bq24190_configure_usb_otg(bdi, bdi->ss_reg);
1810 if (ret < 0)
1811 goto out_charger;
1812
1813 bdi->initialized = true;
1814
1815 ret = devm_request_threaded_irq(dev, client->irq, NULL,
1816 bq24190_irq_handler_thread,
1817 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1818 "bq24190-charger", bdi);
1819 if (ret < 0) {
1820 dev_err(dev, "Can't set up irq handler\n");
1821 goto out_charger;
1822 }
1823
1824 ret = bq24190_register_vbus_regulator(bdi);
1825 if (ret < 0)
1826 goto out_charger;
1827
1828 enable_irq_wake(client->irq);
1829
1830 pm_runtime_mark_last_busy(dev);
1831 pm_runtime_put_autosuspend(dev);
1832
1833 return 0;
1834
1835 out_charger:
1836 if (!IS_ERR_OR_NULL(bdi->battery))
1837 power_supply_unregister(bdi->battery);
1838 power_supply_unregister(bdi->charger);
1839
1840 out_pmrt:
1841 pm_runtime_put_sync(dev);
1842 pm_runtime_dont_use_autosuspend(dev);
1843 pm_runtime_disable(dev);
1844 return ret;
1845 }
1846
bq24190_remove(struct i2c_client * client)1847 static int bq24190_remove(struct i2c_client *client)
1848 {
1849 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1850 int error;
1851
1852 error = pm_runtime_get_sync(bdi->dev);
1853 if (error < 0) {
1854 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1855 pm_runtime_put_noidle(bdi->dev);
1856 }
1857
1858 bq24190_register_reset(bdi);
1859 if (bdi->battery)
1860 power_supply_unregister(bdi->battery);
1861 power_supply_unregister(bdi->charger);
1862 if (error >= 0)
1863 pm_runtime_put_sync(bdi->dev);
1864 pm_runtime_dont_use_autosuspend(bdi->dev);
1865 pm_runtime_disable(bdi->dev);
1866
1867 return 0;
1868 }
1869
bq24190_runtime_suspend(struct device * dev)1870 static __maybe_unused int bq24190_runtime_suspend(struct device *dev)
1871 {
1872 struct i2c_client *client = to_i2c_client(dev);
1873 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1874
1875 if (!bdi->initialized)
1876 return 0;
1877
1878 dev_dbg(bdi->dev, "%s\n", __func__);
1879
1880 return 0;
1881 }
1882
bq24190_runtime_resume(struct device * dev)1883 static __maybe_unused int bq24190_runtime_resume(struct device *dev)
1884 {
1885 struct i2c_client *client = to_i2c_client(dev);
1886 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1887
1888 if (!bdi->initialized)
1889 return 0;
1890
1891 if (!bdi->irq_event) {
1892 dev_dbg(bdi->dev, "checking events on possible wakeirq\n");
1893 bq24190_check_status(bdi);
1894 }
1895
1896 return 0;
1897 }
1898
bq24190_pm_suspend(struct device * dev)1899 static __maybe_unused int bq24190_pm_suspend(struct device *dev)
1900 {
1901 struct i2c_client *client = to_i2c_client(dev);
1902 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1903 int error;
1904
1905 error = pm_runtime_get_sync(bdi->dev);
1906 if (error < 0) {
1907 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1908 pm_runtime_put_noidle(bdi->dev);
1909 }
1910
1911 bq24190_register_reset(bdi);
1912
1913 if (error >= 0) {
1914 pm_runtime_mark_last_busy(bdi->dev);
1915 pm_runtime_put_autosuspend(bdi->dev);
1916 }
1917
1918 return 0;
1919 }
1920
bq24190_pm_resume(struct device * dev)1921 static __maybe_unused int bq24190_pm_resume(struct device *dev)
1922 {
1923 struct i2c_client *client = to_i2c_client(dev);
1924 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1925 int error;
1926
1927 bdi->f_reg = 0;
1928 bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1929
1930 error = pm_runtime_get_sync(bdi->dev);
1931 if (error < 0) {
1932 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1933 pm_runtime_put_noidle(bdi->dev);
1934 }
1935
1936 bq24190_register_reset(bdi);
1937 bq24190_set_config(bdi);
1938 bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1939
1940 if (error >= 0) {
1941 pm_runtime_mark_last_busy(bdi->dev);
1942 pm_runtime_put_autosuspend(bdi->dev);
1943 }
1944
1945 /* Things may have changed while suspended so alert upper layer */
1946 power_supply_changed(bdi->charger);
1947 if (bdi->battery)
1948 power_supply_changed(bdi->battery);
1949
1950 return 0;
1951 }
1952
1953 static const struct dev_pm_ops bq24190_pm_ops = {
1954 SET_RUNTIME_PM_OPS(bq24190_runtime_suspend, bq24190_runtime_resume,
1955 NULL)
1956 SET_SYSTEM_SLEEP_PM_OPS(bq24190_pm_suspend, bq24190_pm_resume)
1957 };
1958
1959 static const struct i2c_device_id bq24190_i2c_ids[] = {
1960 { "bq24190" },
1961 { "bq24192" },
1962 { "bq24192i" },
1963 { "bq24196" },
1964 { },
1965 };
1966 MODULE_DEVICE_TABLE(i2c, bq24190_i2c_ids);
1967
1968 #ifdef CONFIG_OF
1969 static const struct of_device_id bq24190_of_match[] = {
1970 { .compatible = "ti,bq24190", },
1971 { .compatible = "ti,bq24192", },
1972 { .compatible = "ti,bq24192i", },
1973 { .compatible = "ti,bq24196", },
1974 { },
1975 };
1976 MODULE_DEVICE_TABLE(of, bq24190_of_match);
1977 #else
1978 static const struct of_device_id bq24190_of_match[] = {
1979 { },
1980 };
1981 #endif
1982
1983 static struct i2c_driver bq24190_driver = {
1984 .probe = bq24190_probe,
1985 .remove = bq24190_remove,
1986 .id_table = bq24190_i2c_ids,
1987 .driver = {
1988 .name = "bq24190-charger",
1989 .pm = &bq24190_pm_ops,
1990 .of_match_table = of_match_ptr(bq24190_of_match),
1991 },
1992 };
1993 module_i2c_driver(bq24190_driver);
1994
1995 MODULE_LICENSE("GPL");
1996 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
1997 MODULE_DESCRIPTION("TI BQ24190 Charger Driver");
1998