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