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