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