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