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