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