?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
power: supply: bq24190_charger: Add disable-reset device-property
[linux/fpc-iii.git] / drivers / power / supply / bq24190_charger.c
blob8ed2782d1bb1b228390c472a8e022f96522fab54
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/gpio.h>
19 #include <linux/i2c.h>
20
21 #include <linux/power/bq24190_charger.h>
22
23
24 #define BQ24190_MANUFACTURER "Texas Instruments"
25
26 #define BQ24190_REG_ISC 0x00 /* Input Source Control */
27 #define BQ24190_REG_ISC_EN_HIZ_MASK BIT(7)
28 #define BQ24190_REG_ISC_EN_HIZ_SHIFT 7
29 #define BQ24190_REG_ISC_VINDPM_MASK (BIT(6) | BIT(5) | BIT(4) | \
30 BIT(3))
31 #define BQ24190_REG_ISC_VINDPM_SHIFT 3
32 #define BQ24190_REG_ISC_IINLIM_MASK (BIT(2) | BIT(1) | BIT(0))
33 #define BQ24190_REG_ISC_IINLIM_SHIFT 0
34
35 #define BQ24190_REG_POC 0x01 /* Power-On Configuration */
36 #define BQ24190_REG_POC_RESET_MASK BIT(7)
37 #define BQ24190_REG_POC_RESET_SHIFT 7
38 #define BQ24190_REG_POC_WDT_RESET_MASK BIT(6)
39 #define BQ24190_REG_POC_WDT_RESET_SHIFT 6
40 #define BQ24190_REG_POC_CHG_CONFIG_MASK (BIT(5) | BIT(4))
41 #define BQ24190_REG_POC_CHG_CONFIG_SHIFT 4
42 #define BQ24190_REG_POC_SYS_MIN_MASK (BIT(3) | BIT(2) | BIT(1))
43 #define BQ24190_REG_POC_SYS_MIN_SHIFT 1
44 #define BQ24190_REG_POC_BOOST_LIM_MASK BIT(0)
45 #define BQ24190_REG_POC_BOOST_LIM_SHIFT 0
46
47 #define BQ24190_REG_CCC 0x02 /* Charge Current Control */
48 #define BQ24190_REG_CCC_ICHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
49 BIT(4) | BIT(3) | BIT(2))
50 #define BQ24190_REG_CCC_ICHG_SHIFT 2
51 #define BQ24190_REG_CCC_FORCE_20PCT_MASK BIT(0)
52 #define BQ24190_REG_CCC_FORCE_20PCT_SHIFT 0
53
54 #define BQ24190_REG_PCTCC 0x03 /* Pre-charge/Termination Current Cntl */
55 #define BQ24190_REG_PCTCC_IPRECHG_MASK (BIT(7) | BIT(6) | BIT(5) | \
56 BIT(4))
57 #define BQ24190_REG_PCTCC_IPRECHG_SHIFT 4
58 #define BQ24190_REG_PCTCC_ITERM_MASK (BIT(3) | BIT(2) | BIT(1) | \
59 BIT(0))
60 #define BQ24190_REG_PCTCC_ITERM_SHIFT 0
61
62 #define BQ24190_REG_CVC 0x04 /* Charge Voltage Control */
63 #define BQ24190_REG_CVC_VREG_MASK (BIT(7) | BIT(6) | BIT(5) | \
64 BIT(4) | BIT(3) | BIT(2))
65 #define BQ24190_REG_CVC_VREG_SHIFT 2
66 #define BQ24190_REG_CVC_BATLOWV_MASK BIT(1)
67 #define BQ24190_REG_CVC_BATLOWV_SHIFT 1
68 #define BQ24190_REG_CVC_VRECHG_MASK BIT(0)
69 #define BQ24190_REG_CVC_VRECHG_SHIFT 0
70
71 #define BQ24190_REG_CTTC 0x05 /* Charge Term/Timer Control */
72 #define BQ24190_REG_CTTC_EN_TERM_MASK BIT(7)
73 #define BQ24190_REG_CTTC_EN_TERM_SHIFT 7
74 #define BQ24190_REG_CTTC_TERM_STAT_MASK BIT(6)
75 #define BQ24190_REG_CTTC_TERM_STAT_SHIFT 6
76 #define BQ24190_REG_CTTC_WATCHDOG_MASK (BIT(5) | BIT(4))
77 #define BQ24190_REG_CTTC_WATCHDOG_SHIFT 4
78 #define BQ24190_REG_CTTC_EN_TIMER_MASK BIT(3)
79 #define BQ24190_REG_CTTC_EN_TIMER_SHIFT 3
80 #define BQ24190_REG_CTTC_CHG_TIMER_MASK (BIT(2) | BIT(1))
81 #define BQ24190_REG_CTTC_CHG_TIMER_SHIFT 1
82 #define BQ24190_REG_CTTC_JEITA_ISET_MASK BIT(0)
83 #define BQ24190_REG_CTTC_JEITA_ISET_SHIFT 0
84
85 #define BQ24190_REG_ICTRC 0x06 /* IR Comp/Thermal Regulation Control */
86 #define BQ24190_REG_ICTRC_BAT_COMP_MASK (BIT(7) | BIT(6) | BIT(5))
87 #define BQ24190_REG_ICTRC_BAT_COMP_SHIFT 5
88 #define BQ24190_REG_ICTRC_VCLAMP_MASK (BIT(4) | BIT(3) | BIT(2))
89 #define BQ24190_REG_ICTRC_VCLAMP_SHIFT 2
90 #define BQ24190_REG_ICTRC_TREG_MASK (BIT(1) | BIT(0))
91 #define BQ24190_REG_ICTRC_TREG_SHIFT 0
92
93 #define BQ24190_REG_MOC 0x07 /* Misc. Operation Control */
94 #define BQ24190_REG_MOC_DPDM_EN_MASK BIT(7)
95 #define BQ24190_REG_MOC_DPDM_EN_SHIFT 7
96 #define BQ24190_REG_MOC_TMR2X_EN_MASK BIT(6)
97 #define BQ24190_REG_MOC_TMR2X_EN_SHIFT 6
98 #define BQ24190_REG_MOC_BATFET_DISABLE_MASK BIT(5)
99 #define BQ24190_REG_MOC_BATFET_DISABLE_SHIFT 5
100 #define BQ24190_REG_MOC_JEITA_VSET_MASK BIT(4)
101 #define BQ24190_REG_MOC_JEITA_VSET_SHIFT 4
102 #define BQ24190_REG_MOC_INT_MASK_MASK (BIT(1) | BIT(0))
103 #define BQ24190_REG_MOC_INT_MASK_SHIFT 0
104
105 #define BQ24190_REG_SS 0x08 /* System Status */
106 #define BQ24190_REG_SS_VBUS_STAT_MASK (BIT(7) | BIT(6))
107 #define BQ24190_REG_SS_VBUS_STAT_SHIFT 6
108 #define BQ24190_REG_SS_CHRG_STAT_MASK (BIT(5) | BIT(4))
109 #define BQ24190_REG_SS_CHRG_STAT_SHIFT 4
110 #define BQ24190_REG_SS_DPM_STAT_MASK BIT(3)
111 #define BQ24190_REG_SS_DPM_STAT_SHIFT 3
112 #define BQ24190_REG_SS_PG_STAT_MASK BIT(2)
113 #define BQ24190_REG_SS_PG_STAT_SHIFT 2
114 #define BQ24190_REG_SS_THERM_STAT_MASK BIT(1)
115 #define BQ24190_REG_SS_THERM_STAT_SHIFT 1
116 #define BQ24190_REG_SS_VSYS_STAT_MASK BIT(0)
117 #define BQ24190_REG_SS_VSYS_STAT_SHIFT 0
118
119 #define BQ24190_REG_F 0x09 /* Fault */
120 #define BQ24190_REG_F_WATCHDOG_FAULT_MASK BIT(7)
121 #define BQ24190_REG_F_WATCHDOG_FAULT_SHIFT 7
122 #define BQ24190_REG_F_BOOST_FAULT_MASK BIT(6)
123 #define BQ24190_REG_F_BOOST_FAULT_SHIFT 6
124 #define BQ24190_REG_F_CHRG_FAULT_MASK (BIT(5) | BIT(4))
125 #define BQ24190_REG_F_CHRG_FAULT_SHIFT 4
126 #define BQ24190_REG_F_BAT_FAULT_MASK BIT(3)
127 #define BQ24190_REG_F_BAT_FAULT_SHIFT 3
128 #define BQ24190_REG_F_NTC_FAULT_MASK (BIT(2) | BIT(1) | BIT(0))
129 #define BQ24190_REG_F_NTC_FAULT_SHIFT 0
130
131 #define BQ24190_REG_VPRS 0x0A /* Vendor/Part/Revision Status */
132 #define BQ24190_REG_VPRS_PN_MASK (BIT(5) | BIT(4) | BIT(3))
133 #define BQ24190_REG_VPRS_PN_SHIFT 3
134 #define BQ24190_REG_VPRS_PN_24190 0x4
135 #define BQ24190_REG_VPRS_PN_24192 0x5 /* Also 24193 */
136 #define BQ24190_REG_VPRS_PN_24192I 0x3
137 #define BQ24190_REG_VPRS_TS_PROFILE_MASK BIT(2)
138 #define BQ24190_REG_VPRS_TS_PROFILE_SHIFT 2
139 #define BQ24190_REG_VPRS_DEV_REG_MASK (BIT(1) | BIT(0))
140 #define BQ24190_REG_VPRS_DEV_REG_SHIFT 0
141
142 /*
143 * The FAULT register is latched by the bq24190 (except for NTC_FAULT)
144 * so the first read after a fault returns the latched value and subsequent
145 * reads return the current value. In order to return the fault status
146 * to the user, have the interrupt handler save the reg's value and retrieve
147 * it in the appropriate health/status routine.
148 */
149 struct bq24190_dev_info {
150 struct i2c_client *client;
151 struct device *dev;
152 struct power_supply *charger;
153 struct power_supply *battery;
154 char model_name[I2C_NAME_SIZE];
155 kernel_ulong_t model;
156 unsigned int gpio_int;
157 unsigned int irq;
158 struct mutex f_reg_lock;
159 u8 f_reg;
160 u8 ss_reg;
161 u8 watchdog;
162 };
163
164 /*
165 * The tables below provide a 2-way mapping for the value that goes in
166 * the register field and the real-world value that it represents.
167 * The index of the array is the value that goes in the register; the
168 * number at that index in the array is the real-world value that it
169 * represents.
170 */
171 /* REG02[7:2] (ICHG) in uAh */
172 static const int bq24190_ccc_ichg_values[] = {
173 512000, 576000, 640000, 704000, 768000, 832000, 896000, 960000,
174 1024000, 1088000, 1152000, 1216000, 1280000, 1344000, 1408000, 1472000,
175 1536000, 1600000, 1664000, 1728000, 1792000, 1856000, 1920000, 1984000,
176 2048000, 2112000, 2176000, 2240000, 2304000, 2368000, 2432000, 2496000,
177 2560000, 2624000, 2688000, 2752000, 2816000, 2880000, 2944000, 3008000,
178 3072000, 3136000, 3200000, 3264000, 3328000, 3392000, 3456000, 3520000,
179 3584000, 3648000, 3712000, 3776000, 3840000, 3904000, 3968000, 4032000,
180 4096000, 4160000, 4224000, 4288000, 4352000, 4416000, 4480000, 4544000
181 };
182
183 /* REG04[7:2] (VREG) in uV */
184 static const int bq24190_cvc_vreg_values[] = {
185 3504000, 3520000, 3536000, 3552000, 3568000, 3584000, 3600000, 3616000,
186 3632000, 3648000, 3664000, 3680000, 3696000, 3712000, 3728000, 3744000,
187 3760000, 3776000, 3792000, 3808000, 3824000, 3840000, 3856000, 3872000,
188 3888000, 3904000, 3920000, 3936000, 3952000, 3968000, 3984000, 4000000,
189 4016000, 4032000, 4048000, 4064000, 4080000, 4096000, 4112000, 4128000,
190 4144000, 4160000, 4176000, 4192000, 4208000, 4224000, 4240000, 4256000,
191 4272000, 4288000, 4304000, 4320000, 4336000, 4352000, 4368000, 4384000,
192 4400000
193 };
194
195 /* REG06[1:0] (TREG) in tenths of degrees Celcius */
196 static const int bq24190_ictrc_treg_values[] = {
197 600, 800, 1000, 1200
198 };
199
200 /*
201 * Return the index in 'tbl' of greatest value that is less than or equal to
202 * 'val'. The index range returned is 0 to 'tbl_size' - 1. Assumes that
203 * the values in 'tbl' are sorted from smallest to largest and 'tbl_size'
204 * is less than 2^8.
205 */
206 static u8 bq24190_find_idx(const int tbl[], int tbl_size, int v)
207 {
208 int i;
209
210 for (i = 1; i < tbl_size; i++)
211 if (v < tbl[i])
212 break;
213
214 return i - 1;
215 }
216
217 /* Basic driver I/O routines */
218
219 static int bq24190_read(struct bq24190_dev_info *bdi, u8 reg, u8 *data)
220 {
221 int ret;
222
223 ret = i2c_smbus_read_byte_data(bdi->client, reg);
224 if (ret < 0)
225 return ret;
226
227 *data = ret;
228 return 0;
229 }
230
231 static int bq24190_write(struct bq24190_dev_info *bdi, u8 reg, u8 data)
232 {
233 return i2c_smbus_write_byte_data(bdi->client, reg, data);
234 }
235
236 static int bq24190_read_mask(struct bq24190_dev_info *bdi, u8 reg,
237 u8 mask, u8 shift, u8 *data)
238 {
239 u8 v;
240 int ret;
241
242 ret = bq24190_read(bdi, reg, &v);
243 if (ret < 0)
244 return ret;
245
246 v &= mask;
247 v >>= shift;
248 *data = v;
249
250 return 0;
251 }
252
253 static int bq24190_write_mask(struct bq24190_dev_info *bdi, u8 reg,
254 u8 mask, u8 shift, u8 data)
255 {
256 u8 v;
257 int ret;
258
259 ret = bq24190_read(bdi, reg, &v);
260 if (ret < 0)
261 return ret;
262
263 v &= ~mask;
264 v |= ((data << shift) & mask);
265
266 return bq24190_write(bdi, reg, v);
267 }
268
269 static int bq24190_get_field_val(struct bq24190_dev_info *bdi,
270 u8 reg, u8 mask, u8 shift,
271 const int tbl[], int tbl_size,
272 int *val)
273 {
274 u8 v;
275 int ret;
276
277 ret = bq24190_read_mask(bdi, reg, mask, shift, &v);
278 if (ret < 0)
279 return ret;
280
281 v = (v >= tbl_size) ? (tbl_size - 1) : v;
282 *val = tbl[v];
283
284 return 0;
285 }
286
287 static int bq24190_set_field_val(struct bq24190_dev_info *bdi,
288 u8 reg, u8 mask, u8 shift,
289 const int tbl[], int tbl_size,
290 int val)
291 {
292 u8 idx;
293
294 idx = bq24190_find_idx(tbl, tbl_size, val);
295
296 return bq24190_write_mask(bdi, reg, mask, shift, idx);
297 }
298
299 #ifdef CONFIG_SYSFS
300 /*
301 * There are a numerous options that are configurable on the bq24190
302 * that go well beyond what the power_supply properties provide access to.
303 * Provide sysfs access to them so they can be examined and possibly modified
304 * on the fly. They will be provided for the charger power_supply object only
305 * and will be prefixed by 'f_' to make them easier to recognize.
306 */
307
308 #define BQ24190_SYSFS_FIELD(_name, r, f, m, store) \
309 { \
310 .attr = __ATTR(f_##_name, m, bq24190_sysfs_show, store), \
311 .reg = BQ24190_REG_##r, \
312 .mask = BQ24190_REG_##r##_##f##_MASK, \
313 .shift = BQ24190_REG_##r##_##f##_SHIFT, \
314 }
315
316 #define BQ24190_SYSFS_FIELD_RW(_name, r, f) \
317 BQ24190_SYSFS_FIELD(_name, r, f, S_IWUSR | S_IRUGO, \
318 bq24190_sysfs_store)
319
320 #define BQ24190_SYSFS_FIELD_RO(_name, r, f) \
321 BQ24190_SYSFS_FIELD(_name, r, f, S_IRUGO, NULL)
322
323 static ssize_t bq24190_sysfs_show(struct device *dev,
324 struct device_attribute *attr, char *buf);
325 static ssize_t bq24190_sysfs_store(struct device *dev,
326 struct device_attribute *attr, const char *buf, size_t count);
327
328 struct bq24190_sysfs_field_info {
329 struct device_attribute attr;
330 u8 reg;
331 u8 mask;
332 u8 shift;
333 };
334
335 /* On i386 ptrace-abi.h defines SS that breaks the macro calls below. */
336 #undef SS
337
338 static struct bq24190_sysfs_field_info bq24190_sysfs_field_tbl[] = {
339 /* sysfs name reg field in reg */
340 BQ24190_SYSFS_FIELD_RW(en_hiz, ISC, EN_HIZ),
341 BQ24190_SYSFS_FIELD_RW(vindpm, ISC, VINDPM),
342 BQ24190_SYSFS_FIELD_RW(iinlim, ISC, IINLIM),
343 BQ24190_SYSFS_FIELD_RW(chg_config, POC, CHG_CONFIG),
344 BQ24190_SYSFS_FIELD_RW(sys_min, POC, SYS_MIN),
345 BQ24190_SYSFS_FIELD_RW(boost_lim, POC, BOOST_LIM),
346 BQ24190_SYSFS_FIELD_RW(ichg, CCC, ICHG),
347 BQ24190_SYSFS_FIELD_RW(force_20_pct, CCC, FORCE_20PCT),
348 BQ24190_SYSFS_FIELD_RW(iprechg, PCTCC, IPRECHG),
349 BQ24190_SYSFS_FIELD_RW(iterm, PCTCC, ITERM),
350 BQ24190_SYSFS_FIELD_RW(vreg, CVC, VREG),
351 BQ24190_SYSFS_FIELD_RW(batlowv, CVC, BATLOWV),
352 BQ24190_SYSFS_FIELD_RW(vrechg, CVC, VRECHG),
353 BQ24190_SYSFS_FIELD_RW(en_term, CTTC, EN_TERM),
354 BQ24190_SYSFS_FIELD_RW(term_stat, CTTC, TERM_STAT),
355 BQ24190_SYSFS_FIELD_RO(watchdog, CTTC, WATCHDOG),
356 BQ24190_SYSFS_FIELD_RW(en_timer, CTTC, EN_TIMER),
357 BQ24190_SYSFS_FIELD_RW(chg_timer, CTTC, CHG_TIMER),
358 BQ24190_SYSFS_FIELD_RW(jeta_iset, CTTC, JEITA_ISET),
359 BQ24190_SYSFS_FIELD_RW(bat_comp, ICTRC, BAT_COMP),
360 BQ24190_SYSFS_FIELD_RW(vclamp, ICTRC, VCLAMP),
361 BQ24190_SYSFS_FIELD_RW(treg, ICTRC, TREG),
362 BQ24190_SYSFS_FIELD_RW(dpdm_en, MOC, DPDM_EN),
363 BQ24190_SYSFS_FIELD_RW(tmr2x_en, MOC, TMR2X_EN),
364 BQ24190_SYSFS_FIELD_RW(batfet_disable, MOC, BATFET_DISABLE),
365 BQ24190_SYSFS_FIELD_RW(jeita_vset, MOC, JEITA_VSET),
366 BQ24190_SYSFS_FIELD_RO(int_mask, MOC, INT_MASK),
367 BQ24190_SYSFS_FIELD_RO(vbus_stat, SS, VBUS_STAT),
368 BQ24190_SYSFS_FIELD_RO(chrg_stat, SS, CHRG_STAT),
369 BQ24190_SYSFS_FIELD_RO(dpm_stat, SS, DPM_STAT),
370 BQ24190_SYSFS_FIELD_RO(pg_stat, SS, PG_STAT),
371 BQ24190_SYSFS_FIELD_RO(therm_stat, SS, THERM_STAT),
372 BQ24190_SYSFS_FIELD_RO(vsys_stat, SS, VSYS_STAT),
373 BQ24190_SYSFS_FIELD_RO(watchdog_fault, F, WATCHDOG_FAULT),
374 BQ24190_SYSFS_FIELD_RO(boost_fault, F, BOOST_FAULT),
375 BQ24190_SYSFS_FIELD_RO(chrg_fault, F, CHRG_FAULT),
376 BQ24190_SYSFS_FIELD_RO(bat_fault, F, BAT_FAULT),
377 BQ24190_SYSFS_FIELD_RO(ntc_fault, F, NTC_FAULT),
378 BQ24190_SYSFS_FIELD_RO(pn, VPRS, PN),
379 BQ24190_SYSFS_FIELD_RO(ts_profile, VPRS, TS_PROFILE),
380 BQ24190_SYSFS_FIELD_RO(dev_reg, VPRS, DEV_REG),
381 };
382
383 static struct attribute *
384 bq24190_sysfs_attrs[ARRAY_SIZE(bq24190_sysfs_field_tbl) + 1];
385
386 static const struct attribute_group bq24190_sysfs_attr_group = {
387 .attrs = bq24190_sysfs_attrs,
388 };
389
390 static void bq24190_sysfs_init_attrs(void)
391 {
392 int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
393
394 for (i = 0; i < limit; i++)
395 bq24190_sysfs_attrs[i] = &bq24190_sysfs_field_tbl[i].attr.attr;
396
397 bq24190_sysfs_attrs[limit] = NULL; /* Has additional entry for this */
398 }
399
400 static struct bq24190_sysfs_field_info *bq24190_sysfs_field_lookup(
401 const char *name)
402 {
403 int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
404
405 for (i = 0; i < limit; i++)
406 if (!strcmp(name, bq24190_sysfs_field_tbl[i].attr.attr.name))
407 break;
408
409 if (i >= limit)
410 return NULL;
411
412 return &bq24190_sysfs_field_tbl[i];
413 }
414
415 static ssize_t bq24190_sysfs_show(struct device *dev,
416 struct device_attribute *attr, char *buf)
417 {
418 struct power_supply *psy = dev_get_drvdata(dev);
419 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
420 struct bq24190_sysfs_field_info *info;
421 int ret;
422 u8 v;
423
424 info = bq24190_sysfs_field_lookup(attr->attr.name);
425 if (!info)
426 return -EINVAL;
427
428 ret = bq24190_read_mask(bdi, info->reg, info->mask, info->shift, &v);
429 if (ret)
430 return ret;
431
432 return scnprintf(buf, PAGE_SIZE, "%hhx\n", v);
433 }
434
435 static ssize_t bq24190_sysfs_store(struct device *dev,
436 struct device_attribute *attr, const char *buf, size_t count)
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 int ret;
442 u8 v;
443
444 info = bq24190_sysfs_field_lookup(attr->attr.name);
445 if (!info)
446 return -EINVAL;
447
448 ret = kstrtou8(buf, 0, &v);
449 if (ret < 0)
450 return ret;
451
452 ret = bq24190_write_mask(bdi, info->reg, info->mask, info->shift, v);
453 if (ret)
454 return ret;
455
456 return count;
457 }
458
459 static int bq24190_sysfs_create_group(struct bq24190_dev_info *bdi)
460 {
461 bq24190_sysfs_init_attrs();
462
463 return sysfs_create_group(&bdi->charger->dev.kobj,
464 &bq24190_sysfs_attr_group);
465 }
466
467 static void bq24190_sysfs_remove_group(struct bq24190_dev_info *bdi)
468 {
469 sysfs_remove_group(&bdi->charger->dev.kobj, &bq24190_sysfs_attr_group);
470 }
471 #else
472 static int bq24190_sysfs_create_group(struct bq24190_dev_info *bdi)
473 {
474 return 0;
475 }
476
477 static inline void bq24190_sysfs_remove_group(struct bq24190_dev_info *bdi) {}
478 #endif
479
480 /*
481 * According to the "Host Mode and default Mode" section of the
482 * manual, a write to any register causes the bq24190 to switch
483 * from default mode to host mode. It will switch back to default
484 * mode after a WDT timeout unless the WDT is turned off as well.
485 * So, by simply turning off the WDT, we accomplish both with the
486 * same write.
487 */
488 static int bq24190_set_mode_host(struct bq24190_dev_info *bdi)
489 {
490 int ret;
491 u8 v;
492
493 ret = bq24190_read(bdi, BQ24190_REG_CTTC, &v);
494 if (ret < 0)
495 return ret;
496
497 bdi->watchdog = ((v & BQ24190_REG_CTTC_WATCHDOG_MASK) >>
498 BQ24190_REG_CTTC_WATCHDOG_SHIFT);
499 v &= ~BQ24190_REG_CTTC_WATCHDOG_MASK;
500
501 return bq24190_write(bdi, BQ24190_REG_CTTC, v);
502 }
503
504 static int bq24190_register_reset(struct bq24190_dev_info *bdi)
505 {
506 int ret, limit = 100;
507 u8 v;
508
509 if (device_property_read_bool(bdi->dev, "disable-reset"))
510 return 0;
511
512 /* Reset the registers */
513 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
514 BQ24190_REG_POC_RESET_MASK,
515 BQ24190_REG_POC_RESET_SHIFT,
516 0x1);
517 if (ret < 0)
518 return ret;
519
520 /* Reset bit will be cleared by hardware so poll until it is */
521 do {
522 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
523 BQ24190_REG_POC_RESET_MASK,
524 BQ24190_REG_POC_RESET_SHIFT,
525 &v);
526 if (ret < 0)
527 return ret;
528
529 if (!v)
530 break;
531
532 udelay(10);
533 } while (--limit);
534
535 if (!limit)
536 return -EIO;
537
538 return 0;
539 }
540
541 /* Charger power supply property routines */
542
543 static int bq24190_charger_get_charge_type(struct bq24190_dev_info *bdi,
544 union power_supply_propval *val)
545 {
546 u8 v;
547 int type, ret;
548
549 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
550 BQ24190_REG_POC_CHG_CONFIG_MASK,
551 BQ24190_REG_POC_CHG_CONFIG_SHIFT,
552 &v);
553 if (ret < 0)
554 return ret;
555
556 /* If POC[CHG_CONFIG] (REG01[5:4]) == 0, charge is disabled */
557 if (!v) {
558 type = POWER_SUPPLY_CHARGE_TYPE_NONE;
559 } else {
560 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
561 BQ24190_REG_CCC_FORCE_20PCT_MASK,
562 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
563 &v);
564 if (ret < 0)
565 return ret;
566
567 type = (v) ? POWER_SUPPLY_CHARGE_TYPE_TRICKLE :
568 POWER_SUPPLY_CHARGE_TYPE_FAST;
569 }
570
571 val->intval = type;
572
573 return 0;
574 }
575
576 static int bq24190_charger_set_charge_type(struct bq24190_dev_info *bdi,
577 const union power_supply_propval *val)
578 {
579 u8 chg_config, force_20pct, en_term;
580 int ret;
581
582 /*
583 * According to the "Termination when REG02[0] = 1" section of
584 * the bq24190 manual, the trickle charge could be less than the
585 * termination current so it recommends turning off the termination
586 * function.
587 *
588 * Note: AFAICT from the datasheet, the user will have to manually
589 * turn off the charging when in 20% mode. If its not turned off,
590 * there could be battery damage. So, use this mode at your own risk.
591 */
592 switch (val->intval) {
593 case POWER_SUPPLY_CHARGE_TYPE_NONE:
594 chg_config = 0x0;
595 break;
596 case POWER_SUPPLY_CHARGE_TYPE_TRICKLE:
597 chg_config = 0x1;
598 force_20pct = 0x1;
599 en_term = 0x0;
600 break;
601 case POWER_SUPPLY_CHARGE_TYPE_FAST:
602 chg_config = 0x1;
603 force_20pct = 0x0;
604 en_term = 0x1;
605 break;
606 default:
607 return -EINVAL;
608 }
609
610 if (chg_config) { /* Enabling the charger */
611 ret = bq24190_write_mask(bdi, BQ24190_REG_CCC,
612 BQ24190_REG_CCC_FORCE_20PCT_MASK,
613 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
614 force_20pct);
615 if (ret < 0)
616 return ret;
617
618 ret = bq24190_write_mask(bdi, BQ24190_REG_CTTC,
619 BQ24190_REG_CTTC_EN_TERM_MASK,
620 BQ24190_REG_CTTC_EN_TERM_SHIFT,
621 en_term);
622 if (ret < 0)
623 return ret;
624 }
625
626 return bq24190_write_mask(bdi, BQ24190_REG_POC,
627 BQ24190_REG_POC_CHG_CONFIG_MASK,
628 BQ24190_REG_POC_CHG_CONFIG_SHIFT, chg_config);
629 }
630
631 static int bq24190_charger_get_health(struct bq24190_dev_info *bdi,
632 union power_supply_propval *val)
633 {
634 u8 v;
635 int health;
636
637 mutex_lock(&bdi->f_reg_lock);
638 v = bdi->f_reg;
639 mutex_unlock(&bdi->f_reg_lock);
640
641 if (v & BQ24190_REG_F_BOOST_FAULT_MASK) {
642 /*
643 * This could be over-current or over-voltage but there's
644 * no way to tell which. Return 'OVERVOLTAGE' since there
645 * isn't an 'OVERCURRENT' value defined that we can return
646 * even if it was over-current.
647 */
648 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
649 } else {
650 v &= BQ24190_REG_F_CHRG_FAULT_MASK;
651 v >>= BQ24190_REG_F_CHRG_FAULT_SHIFT;
652
653 switch (v) {
654 case 0x0: /* Normal */
655 health = POWER_SUPPLY_HEALTH_GOOD;
656 break;
657 case 0x1: /* Input Fault (VBUS OVP or VBAT<VBUS<3.8V) */
658 /*
659 * This could be over-voltage or under-voltage
660 * and there's no way to tell which. Instead
661 * of looking foolish and returning 'OVERVOLTAGE'
662 * when its really under-voltage, just return
663 * 'UNSPEC_FAILURE'.
664 */
665 health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
666 break;
667 case 0x2: /* Thermal Shutdown */
668 health = POWER_SUPPLY_HEALTH_OVERHEAT;
669 break;
670 case 0x3: /* Charge Safety Timer Expiration */
671 health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
672 break;
673 default:
674 health = POWER_SUPPLY_HEALTH_UNKNOWN;
675 }
676 }
677
678 val->intval = health;
679
680 return 0;
681 }
682
683 static int bq24190_charger_get_online(struct bq24190_dev_info *bdi,
684 union power_supply_propval *val)
685 {
686 u8 v;
687 int ret;
688
689 ret = bq24190_read_mask(bdi, BQ24190_REG_SS,
690 BQ24190_REG_SS_PG_STAT_MASK,
691 BQ24190_REG_SS_PG_STAT_SHIFT, &v);
692 if (ret < 0)
693 return ret;
694
695 val->intval = v;
696 return 0;
697 }
698
699 static int bq24190_charger_get_current(struct bq24190_dev_info *bdi,
700 union power_supply_propval *val)
701 {
702 u8 v;
703 int curr, ret;
704
705 ret = bq24190_get_field_val(bdi, BQ24190_REG_CCC,
706 BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
707 bq24190_ccc_ichg_values,
708 ARRAY_SIZE(bq24190_ccc_ichg_values), &curr);
709 if (ret < 0)
710 return ret;
711
712 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
713 BQ24190_REG_CCC_FORCE_20PCT_MASK,
714 BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
715 if (ret < 0)
716 return ret;
717
718 /* If FORCE_20PCT is enabled, then current is 20% of ICHG value */
719 if (v)
720 curr /= 5;
721
722 val->intval = curr;
723 return 0;
724 }
725
726 static int bq24190_charger_get_current_max(struct bq24190_dev_info *bdi,
727 union power_supply_propval *val)
728 {
729 int idx = ARRAY_SIZE(bq24190_ccc_ichg_values) - 1;
730
731 val->intval = bq24190_ccc_ichg_values[idx];
732 return 0;
733 }
734
735 static int bq24190_charger_set_current(struct bq24190_dev_info *bdi,
736 const union power_supply_propval *val)
737 {
738 u8 v;
739 int ret, curr = val->intval;
740
741 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
742 BQ24190_REG_CCC_FORCE_20PCT_MASK,
743 BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
744 if (ret < 0)
745 return ret;
746
747 /* If FORCE_20PCT is enabled, have to multiply value passed in by 5 */
748 if (v)
749 curr *= 5;
750
751 return bq24190_set_field_val(bdi, BQ24190_REG_CCC,
752 BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
753 bq24190_ccc_ichg_values,
754 ARRAY_SIZE(bq24190_ccc_ichg_values), curr);
755 }
756
757 static int bq24190_charger_get_voltage(struct bq24190_dev_info *bdi,
758 union power_supply_propval *val)
759 {
760 int voltage, ret;
761
762 ret = bq24190_get_field_val(bdi, BQ24190_REG_CVC,
763 BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
764 bq24190_cvc_vreg_values,
765 ARRAY_SIZE(bq24190_cvc_vreg_values), &voltage);
766 if (ret < 0)
767 return ret;
768
769 val->intval = voltage;
770 return 0;
771 }
772
773 static int bq24190_charger_get_voltage_max(struct bq24190_dev_info *bdi,
774 union power_supply_propval *val)
775 {
776 int idx = ARRAY_SIZE(bq24190_cvc_vreg_values) - 1;
777
778 val->intval = bq24190_cvc_vreg_values[idx];
779 return 0;
780 }
781
782 static int bq24190_charger_set_voltage(struct bq24190_dev_info *bdi,
783 const union power_supply_propval *val)
784 {
785 return bq24190_set_field_val(bdi, BQ24190_REG_CVC,
786 BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
787 bq24190_cvc_vreg_values,
788 ARRAY_SIZE(bq24190_cvc_vreg_values), val->intval);
789 }
790
791 static int bq24190_charger_get_property(struct power_supply *psy,
792 enum power_supply_property psp, union power_supply_propval *val)
793 {
794 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
795 int ret;
796
797 dev_dbg(bdi->dev, "prop: %d\n", psp);
798
799 pm_runtime_get_sync(bdi->dev);
800
801 switch (psp) {
802 case POWER_SUPPLY_PROP_CHARGE_TYPE:
803 ret = bq24190_charger_get_charge_type(bdi, val);
804 break;
805 case POWER_SUPPLY_PROP_HEALTH:
806 ret = bq24190_charger_get_health(bdi, val);
807 break;
808 case POWER_SUPPLY_PROP_ONLINE:
809 ret = bq24190_charger_get_online(bdi, val);
810 break;
811 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
812 ret = bq24190_charger_get_current(bdi, val);
813 break;
814 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
815 ret = bq24190_charger_get_current_max(bdi, val);
816 break;
817 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
818 ret = bq24190_charger_get_voltage(bdi, val);
819 break;
820 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
821 ret = bq24190_charger_get_voltage_max(bdi, val);
822 break;
823 case POWER_SUPPLY_PROP_SCOPE:
824 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
825 ret = 0;
826 break;
827 case POWER_SUPPLY_PROP_MODEL_NAME:
828 val->strval = bdi->model_name;
829 ret = 0;
830 break;
831 case POWER_SUPPLY_PROP_MANUFACTURER:
832 val->strval = BQ24190_MANUFACTURER;
833 ret = 0;
834 break;
835 default:
836 ret = -ENODATA;
837 }
838
839 pm_runtime_put_sync(bdi->dev);
840 return ret;
841 }
842
843 static int bq24190_charger_set_property(struct power_supply *psy,
844 enum power_supply_property psp,
845 const union power_supply_propval *val)
846 {
847 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
848 int ret;
849
850 dev_dbg(bdi->dev, "prop: %d\n", psp);
851
852 pm_runtime_get_sync(bdi->dev);
853
854 switch (psp) {
855 case POWER_SUPPLY_PROP_CHARGE_TYPE:
856 ret = bq24190_charger_set_charge_type(bdi, val);
857 break;
858 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
859 ret = bq24190_charger_set_current(bdi, val);
860 break;
861 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
862 ret = bq24190_charger_set_voltage(bdi, val);
863 break;
864 default:
865 ret = -EINVAL;
866 }
867
868 pm_runtime_put_sync(bdi->dev);
869 return ret;
870 }
871
872 static int bq24190_charger_property_is_writeable(struct power_supply *psy,
873 enum power_supply_property psp)
874 {
875 int ret;
876
877 switch (psp) {
878 case POWER_SUPPLY_PROP_CHARGE_TYPE:
879 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
880 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
881 ret = 1;
882 break;
883 default:
884 ret = 0;
885 }
886
887 return ret;
888 }
889
890 static enum power_supply_property bq24190_charger_properties[] = {
891 POWER_SUPPLY_PROP_CHARGE_TYPE,
892 POWER_SUPPLY_PROP_HEALTH,
893 POWER_SUPPLY_PROP_ONLINE,
894 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
895 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
896 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
897 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
898 POWER_SUPPLY_PROP_SCOPE,
899 POWER_SUPPLY_PROP_MODEL_NAME,
900 POWER_SUPPLY_PROP_MANUFACTURER,
901 };
902
903 static char *bq24190_charger_supplied_to[] = {
904 "main-battery",
905 };
906
907 static const struct power_supply_desc bq24190_charger_desc = {
908 .name = "bq24190-charger",
909 .type = POWER_SUPPLY_TYPE_USB,
910 .properties = bq24190_charger_properties,
911 .num_properties = ARRAY_SIZE(bq24190_charger_properties),
912 .get_property = bq24190_charger_get_property,
913 .set_property = bq24190_charger_set_property,
914 .property_is_writeable = bq24190_charger_property_is_writeable,
915 };
916
917 /* Battery power supply property routines */
918
919 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
920 union power_supply_propval *val)
921 {
922 u8 ss_reg, chrg_fault;
923 int status, ret;
924
925 mutex_lock(&bdi->f_reg_lock);
926 chrg_fault = bdi->f_reg;
927 mutex_unlock(&bdi->f_reg_lock);
928
929 chrg_fault &= BQ24190_REG_F_CHRG_FAULT_MASK;
930 chrg_fault >>= BQ24190_REG_F_CHRG_FAULT_SHIFT;
931
932 ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
933 if (ret < 0)
934 return ret;
935
936 /*
937 * The battery must be discharging when any of these are true:
938 * - there is no good power source;
939 * - there is a charge fault.
940 * Could also be discharging when in "supplement mode" but
941 * there is no way to tell when its in that mode.
942 */
943 if (!(ss_reg & BQ24190_REG_SS_PG_STAT_MASK) || chrg_fault) {
944 status = POWER_SUPPLY_STATUS_DISCHARGING;
945 } else {
946 ss_reg &= BQ24190_REG_SS_CHRG_STAT_MASK;
947 ss_reg >>= BQ24190_REG_SS_CHRG_STAT_SHIFT;
948
949 switch (ss_reg) {
950 case 0x0: /* Not Charging */
951 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
952 break;
953 case 0x1: /* Pre-charge */
954 case 0x2: /* Fast Charging */
955 status = POWER_SUPPLY_STATUS_CHARGING;
956 break;
957 case 0x3: /* Charge Termination Done */
958 status = POWER_SUPPLY_STATUS_FULL;
959 break;
960 default:
961 ret = -EIO;
962 }
963 }
964
965 if (!ret)
966 val->intval = status;
967
968 return ret;
969 }
970
971 static int bq24190_battery_get_health(struct bq24190_dev_info *bdi,
972 union power_supply_propval *val)
973 {
974 u8 v;
975 int health;
976
977 mutex_lock(&bdi->f_reg_lock);
978 v = bdi->f_reg;
979 mutex_unlock(&bdi->f_reg_lock);
980
981 if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
982 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
983 } else {
984 v &= BQ24190_REG_F_NTC_FAULT_MASK;
985 v >>= BQ24190_REG_F_NTC_FAULT_SHIFT;
986
987 switch (v) {
988 case 0x0: /* Normal */
989 health = POWER_SUPPLY_HEALTH_GOOD;
990 break;
991 case 0x1: /* TS1 Cold */
992 case 0x3: /* TS2 Cold */
993 case 0x5: /* Both Cold */
994 health = POWER_SUPPLY_HEALTH_COLD;
995 break;
996 case 0x2: /* TS1 Hot */
997 case 0x4: /* TS2 Hot */
998 case 0x6: /* Both Hot */
999 health = POWER_SUPPLY_HEALTH_OVERHEAT;
1000 break;
1001 default:
1002 health = POWER_SUPPLY_HEALTH_UNKNOWN;
1003 }
1004 }
1005
1006 val->intval = health;
1007 return 0;
1008 }
1009
1010 static int bq24190_battery_get_online(struct bq24190_dev_info *bdi,
1011 union power_supply_propval *val)
1012 {
1013 u8 batfet_disable;
1014 int ret;
1015
1016 ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
1017 BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1018 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
1019 if (ret < 0)
1020 return ret;
1021
1022 val->intval = !batfet_disable;
1023 return 0;
1024 }
1025
1026 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
1027 const union power_supply_propval *val)
1028 {
1029 return bq24190_write_mask(bdi, BQ24190_REG_MOC,
1030 BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1031 BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, !val->intval);
1032 }
1033
1034 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
1035 union power_supply_propval *val)
1036 {
1037 int temp, ret;
1038
1039 ret = bq24190_get_field_val(bdi, BQ24190_REG_ICTRC,
1040 BQ24190_REG_ICTRC_TREG_MASK,
1041 BQ24190_REG_ICTRC_TREG_SHIFT,
1042 bq24190_ictrc_treg_values,
1043 ARRAY_SIZE(bq24190_ictrc_treg_values), &temp);
1044 if (ret < 0)
1045 return ret;
1046
1047 val->intval = temp;
1048 return 0;
1049 }
1050
1051 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
1052 const union power_supply_propval *val)
1053 {
1054 return bq24190_set_field_val(bdi, BQ24190_REG_ICTRC,
1055 BQ24190_REG_ICTRC_TREG_MASK,
1056 BQ24190_REG_ICTRC_TREG_SHIFT,
1057 bq24190_ictrc_treg_values,
1058 ARRAY_SIZE(bq24190_ictrc_treg_values), val->intval);
1059 }
1060
1061 static int bq24190_battery_get_property(struct power_supply *psy,
1062 enum power_supply_property psp, union power_supply_propval *val)
1063 {
1064 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1065 int ret;
1066
1067 dev_dbg(bdi->dev, "prop: %d\n", psp);
1068
1069 pm_runtime_get_sync(bdi->dev);
1070
1071 switch (psp) {
1072 case POWER_SUPPLY_PROP_STATUS:
1073 ret = bq24190_battery_get_status(bdi, val);
1074 break;
1075 case POWER_SUPPLY_PROP_HEALTH:
1076 ret = bq24190_battery_get_health(bdi, val);
1077 break;
1078 case POWER_SUPPLY_PROP_ONLINE:
1079 ret = bq24190_battery_get_online(bdi, val);
1080 break;
1081 case POWER_SUPPLY_PROP_TECHNOLOGY:
1082 /* Could be Li-on or Li-polymer but no way to tell which */
1083 val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
1084 ret = 0;
1085 break;
1086 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1087 ret = bq24190_battery_get_temp_alert_max(bdi, val);
1088 break;
1089 case POWER_SUPPLY_PROP_SCOPE:
1090 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1091 ret = 0;
1092 break;
1093 default:
1094 ret = -ENODATA;
1095 }
1096
1097 pm_runtime_put_sync(bdi->dev);
1098 return ret;
1099 }
1100
1101 static int bq24190_battery_set_property(struct power_supply *psy,
1102 enum power_supply_property psp,
1103 const union power_supply_propval *val)
1104 {
1105 struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1106 int ret;
1107
1108 dev_dbg(bdi->dev, "prop: %d\n", psp);
1109
1110 pm_runtime_get_sync(bdi->dev);
1111
1112 switch (psp) {
1113 case POWER_SUPPLY_PROP_ONLINE:
1114 ret = bq24190_battery_set_online(bdi, val);
1115 break;
1116 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1117 ret = bq24190_battery_set_temp_alert_max(bdi, val);
1118 break;
1119 default:
1120 ret = -EINVAL;
1121 }
1122
1123 pm_runtime_put_sync(bdi->dev);
1124 return ret;
1125 }
1126
1127 static int bq24190_battery_property_is_writeable(struct power_supply *psy,
1128 enum power_supply_property psp)
1129 {
1130 int ret;
1131
1132 switch (psp) {
1133 case POWER_SUPPLY_PROP_ONLINE:
1134 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1135 ret = 1;
1136 break;
1137 default:
1138 ret = 0;
1139 }
1140
1141 return ret;
1142 }
1143
1144 static enum power_supply_property bq24190_battery_properties[] = {
1145 POWER_SUPPLY_PROP_STATUS,
1146 POWER_SUPPLY_PROP_HEALTH,
1147 POWER_SUPPLY_PROP_ONLINE,
1148 POWER_SUPPLY_PROP_TECHNOLOGY,
1149 POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1150 POWER_SUPPLY_PROP_SCOPE,
1151 };
1152
1153 static const struct power_supply_desc bq24190_battery_desc = {
1154 .name = "bq24190-battery",
1155 .type = POWER_SUPPLY_TYPE_BATTERY,
1156 .properties = bq24190_battery_properties,
1157 .num_properties = ARRAY_SIZE(bq24190_battery_properties),
1158 .get_property = bq24190_battery_get_property,
1159 .set_property = bq24190_battery_set_property,
1160 .property_is_writeable = bq24190_battery_property_is_writeable,
1161 };
1162
1163 static irqreturn_t bq24190_irq_handler_thread(int irq, void *data)
1164 {
1165 struct bq24190_dev_info *bdi = data;
1166 const u8 battery_mask_ss = BQ24190_REG_SS_CHRG_STAT_MASK;
1167 const u8 battery_mask_f = BQ24190_REG_F_BAT_FAULT_MASK
1168 | BQ24190_REG_F_NTC_FAULT_MASK;
1169 bool alert_charger = false, alert_battery = false;
1170 u8 ss_reg = 0, f_reg = 0;
1171 int i, ret;
1172
1173 pm_runtime_get_sync(bdi->dev);
1174
1175 ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1176 if (ret < 0) {
1177 dev_err(bdi->dev, "Can't read SS reg: %d\n", ret);
1178 goto out;
1179 }
1180
1181 i = 0;
1182 do {
1183 ret = bq24190_read(bdi, BQ24190_REG_F, &f_reg);
1184 if (ret < 0) {
1185 dev_err(bdi->dev, "Can't read F reg: %d\n", ret);
1186 goto out;
1187 }
1188 } while (f_reg && ++i < 2);
1189
1190 /* ignore over/under voltage fault after disconnect */
1191 if (f_reg == (1 << BQ24190_REG_F_CHRG_FAULT_SHIFT) &&
1192 !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK))
1193 f_reg = 0;
1194
1195 if (f_reg != bdi->f_reg) {
1196 dev_warn(bdi->dev,
1197 "Fault: boost %d, charge %d, battery %d, ntc %d\n",
1198 !!(f_reg & BQ24190_REG_F_BOOST_FAULT_MASK),
1199 !!(f_reg & BQ24190_REG_F_CHRG_FAULT_MASK),
1200 !!(f_reg & BQ24190_REG_F_BAT_FAULT_MASK),
1201 !!(f_reg & BQ24190_REG_F_NTC_FAULT_MASK));
1202
1203 mutex_lock(&bdi->f_reg_lock);
1204 if ((bdi->f_reg & battery_mask_f) != (f_reg & battery_mask_f))
1205 alert_battery = true;
1206 if ((bdi->f_reg & ~battery_mask_f) != (f_reg & ~battery_mask_f))
1207 alert_charger = true;
1208 bdi->f_reg = f_reg;
1209 mutex_unlock(&bdi->f_reg_lock);
1210 }
1211
1212 if (ss_reg != bdi->ss_reg) {
1213 /*
1214 * The device is in host mode so when PG_STAT goes from 1->0
1215 * (i.e., power removed) HIZ needs to be disabled.
1216 */
1217 if ((bdi->ss_reg & BQ24190_REG_SS_PG_STAT_MASK) &&
1218 !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK)) {
1219 ret = bq24190_write_mask(bdi, BQ24190_REG_ISC,
1220 BQ24190_REG_ISC_EN_HIZ_MASK,
1221 BQ24190_REG_ISC_EN_HIZ_SHIFT,
1222 0);
1223 if (ret < 0)
1224 dev_err(bdi->dev, "Can't access ISC reg: %d\n",
1225 ret);
1226 }
1227
1228 if ((bdi->ss_reg & battery_mask_ss) != (ss_reg & battery_mask_ss))
1229 alert_battery = true;
1230 if ((bdi->ss_reg & ~battery_mask_ss) != (ss_reg & ~battery_mask_ss))
1231 alert_charger = true;
1232 bdi->ss_reg = ss_reg;
1233 }
1234
1235 if (alert_charger)
1236 power_supply_changed(bdi->charger);
1237 if (alert_battery)
1238 power_supply_changed(bdi->battery);
1239
1240 out:
1241 pm_runtime_put_sync(bdi->dev);
1242
1243 dev_dbg(bdi->dev, "ss_reg: 0x%02x, f_reg: 0x%02x\n", ss_reg, f_reg);
1244
1245 return IRQ_HANDLED;
1246 }
1247
1248 static int bq24190_hw_init(struct bq24190_dev_info *bdi)
1249 {
1250 u8 v;
1251 int ret;
1252
1253 pm_runtime_get_sync(bdi->dev);
1254
1255 /* First check that the device really is what its supposed to be */
1256 ret = bq24190_read_mask(bdi, BQ24190_REG_VPRS,
1257 BQ24190_REG_VPRS_PN_MASK,
1258 BQ24190_REG_VPRS_PN_SHIFT,
1259 &v);
1260 if (ret < 0)
1261 goto out;
1262
1263 if (v != bdi->model) {
1264 ret = -ENODEV;
1265 goto out;
1266 }
1267
1268 ret = bq24190_register_reset(bdi);
1269 if (ret < 0)
1270 goto out;
1271
1272 ret = bq24190_set_mode_host(bdi);
1273 if (ret < 0)
1274 goto out;
1275
1276 ret = bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1277 out:
1278 pm_runtime_put_sync(bdi->dev);
1279 return ret;
1280 }
1281
1282 #ifdef CONFIG_OF
1283 static int bq24190_setup_dt(struct bq24190_dev_info *bdi)
1284 {
1285 bdi->irq = irq_of_parse_and_map(bdi->dev->of_node, 0);
1286 if (bdi->irq <= 0)
1287 return -1;
1288
1289 return 0;
1290 }
1291 #else
1292 static int bq24190_setup_dt(struct bq24190_dev_info *bdi)
1293 {
1294 return -1;
1295 }
1296 #endif
1297
1298 static int bq24190_setup_pdata(struct bq24190_dev_info *bdi,
1299 struct bq24190_platform_data *pdata)
1300 {
1301 int ret;
1302
1303 if (!gpio_is_valid(pdata->gpio_int))
1304 return -1;
1305
1306 ret = gpio_request(pdata->gpio_int, dev_name(bdi->dev));
1307 if (ret < 0)
1308 return -1;
1309
1310 ret = gpio_direction_input(pdata->gpio_int);
1311 if (ret < 0)
1312 goto out;
1313
1314 bdi->irq = gpio_to_irq(pdata->gpio_int);
1315 if (!bdi->irq)
1316 goto out;
1317
1318 bdi->gpio_int = pdata->gpio_int;
1319 return 0;
1320
1321 out:
1322 gpio_free(pdata->gpio_int);
1323 return -1;
1324 }
1325
1326 static int bq24190_probe(struct i2c_client *client,
1327 const struct i2c_device_id *id)
1328 {
1329 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
1330 struct device *dev = &client->dev;
1331 struct bq24190_platform_data *pdata = client->dev.platform_data;
1332 struct power_supply_config charger_cfg = {}, battery_cfg = {};
1333 struct bq24190_dev_info *bdi;
1334 int ret;
1335
1336 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1337 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1338 return -ENODEV;
1339 }
1340
1341 bdi = devm_kzalloc(dev, sizeof(*bdi), GFP_KERNEL);
1342 if (!bdi) {
1343 dev_err(dev, "Can't alloc bdi struct\n");
1344 return -ENOMEM;
1345 }
1346
1347 bdi->client = client;
1348 bdi->dev = dev;
1349 bdi->model = id->driver_data;
1350 strncpy(bdi->model_name, id->name, I2C_NAME_SIZE);
1351 mutex_init(&bdi->f_reg_lock);
1352 bdi->f_reg = 0;
1353 bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1354
1355 i2c_set_clientdata(client, bdi);
1356
1357 if (dev->of_node)
1358 ret = bq24190_setup_dt(bdi);
1359 else
1360 ret = bq24190_setup_pdata(bdi, pdata);
1361
1362 if (ret) {
1363 dev_err(dev, "Can't get irq info\n");
1364 return -EINVAL;
1365 }
1366
1367 pm_runtime_enable(dev);
1368 pm_runtime_resume(dev);
1369
1370 ret = bq24190_hw_init(bdi);
1371 if (ret < 0) {
1372 dev_err(dev, "Hardware init failed\n");
1373 goto out1;
1374 }
1375
1376 charger_cfg.drv_data = bdi;
1377 charger_cfg.supplied_to = bq24190_charger_supplied_to;
1378 charger_cfg.num_supplicants = ARRAY_SIZE(bq24190_charger_supplied_to),
1379 bdi->charger = power_supply_register(dev, &bq24190_charger_desc,
1380 &charger_cfg);
1381 if (IS_ERR(bdi->charger)) {
1382 dev_err(dev, "Can't register charger\n");
1383 ret = PTR_ERR(bdi->charger);
1384 goto out1;
1385 }
1386
1387 battery_cfg.drv_data = bdi;
1388 bdi->battery = power_supply_register(dev, &bq24190_battery_desc,
1389 &battery_cfg);
1390 if (IS_ERR(bdi->battery)) {
1391 dev_err(dev, "Can't register battery\n");
1392 ret = PTR_ERR(bdi->battery);
1393 goto out2;
1394 }
1395
1396 ret = bq24190_sysfs_create_group(bdi);
1397 if (ret) {
1398 dev_err(dev, "Can't create sysfs entries\n");
1399 goto out3;
1400 }
1401
1402 ret = devm_request_threaded_irq(dev, bdi->irq, NULL,
1403 bq24190_irq_handler_thread,
1404 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1405 "bq24190-charger", bdi);
1406 if (ret < 0) {
1407 dev_err(dev, "Can't set up irq handler\n");
1408 goto out4;
1409 }
1410
1411 return 0;
1412
1413 out4:
1414 bq24190_sysfs_remove_group(bdi);
1415 out3:
1416 power_supply_unregister(bdi->battery);
1417 out2:
1418 power_supply_unregister(bdi->charger);
1419 out1:
1420 pm_runtime_disable(dev);
1421 if (bdi->gpio_int)
1422 gpio_free(bdi->gpio_int);
1423
1424 return ret;
1425 }
1426
1427 static int bq24190_remove(struct i2c_client *client)
1428 {
1429 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1430
1431 pm_runtime_get_sync(bdi->dev);
1432 bq24190_register_reset(bdi);
1433 pm_runtime_put_sync(bdi->dev);
1434
1435 bq24190_sysfs_remove_group(bdi);
1436 power_supply_unregister(bdi->battery);
1437 power_supply_unregister(bdi->charger);
1438 pm_runtime_disable(bdi->dev);
1439
1440 if (bdi->gpio_int)
1441 gpio_free(bdi->gpio_int);
1442
1443 return 0;
1444 }
1445
1446 #ifdef CONFIG_PM_SLEEP
1447 static int bq24190_pm_suspend(struct device *dev)
1448 {
1449 struct i2c_client *client = to_i2c_client(dev);
1450 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1451
1452 pm_runtime_get_sync(bdi->dev);
1453 bq24190_register_reset(bdi);
1454 pm_runtime_put_sync(bdi->dev);
1455
1456 return 0;
1457 }
1458
1459 static int bq24190_pm_resume(struct device *dev)
1460 {
1461 struct i2c_client *client = to_i2c_client(dev);
1462 struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1463
1464 bdi->f_reg = 0;
1465 bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1466
1467 pm_runtime_get_sync(bdi->dev);
1468 bq24190_register_reset(bdi);
1469 bq24190_set_mode_host(bdi);
1470 bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1471 pm_runtime_put_sync(bdi->dev);
1472
1473 /* Things may have changed while suspended so alert upper layer */
1474 power_supply_changed(bdi->charger);
1475 power_supply_changed(bdi->battery);
1476
1477 return 0;
1478 }
1479 #endif
1480
1481 static SIMPLE_DEV_PM_OPS(bq24190_pm_ops, bq24190_pm_suspend, bq24190_pm_resume);
1482
1483 /*
1484 * Only support the bq24190 right now. The bq24192, bq24192i, and bq24193
1485 * are similar but not identical so the driver needs to be extended to
1486 * support them.
1487 */
1488 static const struct i2c_device_id bq24190_i2c_ids[] = {
1489 { "bq24190", BQ24190_REG_VPRS_PN_24190 },
1490 { },
1491 };
1492 MODULE_DEVICE_TABLE(i2c, bq24190_i2c_ids);
1493
1494 #ifdef CONFIG_OF
1495 static const struct of_device_id bq24190_of_match[] = {
1496 { .compatible = "ti,bq24190", },
1497 { },
1498 };
1499 MODULE_DEVICE_TABLE(of, bq24190_of_match);
1500 #else
1501 static const struct of_device_id bq24190_of_match[] = {
1502 { },
1503 };
1504 #endif
1505
1506 static struct i2c_driver bq24190_driver = {
1507 .probe = bq24190_probe,
1508 .remove = bq24190_remove,
1509 .id_table = bq24190_i2c_ids,
1510 .driver = {
1511 .name = "bq24190-charger",
1512 .pm = &bq24190_pm_ops,
1513 .of_match_table = of_match_ptr(bq24190_of_match),
1514 },
1515 };
1516 module_i2c_driver(bq24190_driver);
1517
1518 MODULE_LICENSE("GPL");
1519 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
1520 MODULE_DESCRIPTION("TI BQ24190 Charger Driver");
Linux with added FPC-III support