xref: /linux/drivers/power/supply/bq24190_charger.c (revision 06d07429858317ded2db7986113a9e0129cd599b)
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