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