1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * TI BQ24257 charger driver
4  *
5  * Copyright (C) 2015 Intel Corporation
6  *
7  * Datasheets:
8  * https://www.ti.com/product/bq24250
9  * https://www.ti.com/product/bq24251
10  * https://www.ti.com/product/bq24257
11  */
12 
13 #include <linux/module.h>
14 #include <linux/i2c.h>
15 #include <linux/power_supply.h>
16 #include <linux/regmap.h>
17 #include <linux/types.h>
18 #include <linux/gpio/consumer.h>
19 #include <linux/interrupt.h>
20 #include <linux/delay.h>
21 
22 #include <linux/acpi.h>
23 #include <linux/of.h>
24 
25 #define BQ24257_REG_1			0x00
26 #define BQ24257_REG_2			0x01
27 #define BQ24257_REG_3			0x02
28 #define BQ24257_REG_4			0x03
29 #define BQ24257_REG_5			0x04
30 #define BQ24257_REG_6			0x05
31 #define BQ24257_REG_7			0x06
32 
33 #define BQ24257_MANUFACTURER		"Texas Instruments"
34 #define BQ24257_PG_GPIO			"pg"
35 
36 #define BQ24257_ILIM_SET_DELAY		1000	/* msec */
37 
38 /*
39  * When adding support for new devices make sure that enum bq2425x_chip and
40  * bq2425x_chip_name[] always stay in sync!
41  */
42 enum bq2425x_chip {
43 	BQ24250,
44 	BQ24251,
45 	BQ24257,
46 };
47 
48 static const char *const bq2425x_chip_name[] = {
49 	"bq24250",
50 	"bq24251",
51 	"bq24257",
52 };
53 
54 enum bq24257_fields {
55 	F_WD_FAULT, F_WD_EN, F_STAT, F_FAULT,			    /* REG 1 */
56 	F_RESET, F_IILIMIT, F_EN_STAT, F_EN_TERM, F_CE, F_HZ_MODE,  /* REG 2 */
57 	F_VBAT, F_USB_DET,					    /* REG 3 */
58 	F_ICHG, F_ITERM,					    /* REG 4 */
59 	F_LOOP_STATUS, F_LOW_CHG, F_DPDM_EN, F_CE_STATUS, F_VINDPM, /* REG 5 */
60 	F_X2_TMR_EN, F_TMR, F_SYSOFF, F_TS_EN, F_TS_STAT,	    /* REG 6 */
61 	F_VOVP, F_CLR_VDP, F_FORCE_BATDET, F_FORCE_PTM,		    /* REG 7 */
62 
63 	F_MAX_FIELDS
64 };
65 
66 /* initial field values, converted from uV/uA */
67 struct bq24257_init_data {
68 	u8 ichg;	/* charge current      */
69 	u8 vbat;	/* regulation voltage  */
70 	u8 iterm;	/* termination current */
71 	u8 iilimit;	/* input current limit */
72 	u8 vovp;	/* over voltage protection voltage */
73 	u8 vindpm;	/* VDMP input threshold voltage */
74 };
75 
76 struct bq24257_state {
77 	u8 status;
78 	u8 fault;
79 	bool power_good;
80 };
81 
82 struct bq24257_device {
83 	struct i2c_client *client;
84 	struct device *dev;
85 	struct power_supply *charger;
86 
87 	enum bq2425x_chip chip;
88 
89 	struct regmap *rmap;
90 	struct regmap_field *rmap_fields[F_MAX_FIELDS];
91 
92 	struct gpio_desc *pg;
93 
94 	struct delayed_work iilimit_setup_work;
95 
96 	struct bq24257_init_data init_data;
97 	struct bq24257_state state;
98 
99 	struct mutex lock; /* protect state data */
100 
101 	bool iilimit_autoset_enable;
102 };
103 
104 static bool bq24257_is_volatile_reg(struct device *dev, unsigned int reg)
105 {
106 	switch (reg) {
107 	case BQ24257_REG_2:
108 	case BQ24257_REG_4:
109 		return false;
110 
111 	default:
112 		return true;
113 	}
114 }
115 
116 static const struct regmap_config bq24257_regmap_config = {
117 	.reg_bits = 8,
118 	.val_bits = 8,
119 
120 	.max_register = BQ24257_REG_7,
121 	.cache_type = REGCACHE_RBTREE,
122 
123 	.volatile_reg = bq24257_is_volatile_reg,
124 };
125 
126 static const struct reg_field bq24257_reg_fields[] = {
127 	/* REG 1 */
128 	[F_WD_FAULT]		= REG_FIELD(BQ24257_REG_1, 7, 7),
129 	[F_WD_EN]		= REG_FIELD(BQ24257_REG_1, 6, 6),
130 	[F_STAT]		= REG_FIELD(BQ24257_REG_1, 4, 5),
131 	[F_FAULT]		= REG_FIELD(BQ24257_REG_1, 0, 3),
132 	/* REG 2 */
133 	[F_RESET]		= REG_FIELD(BQ24257_REG_2, 7, 7),
134 	[F_IILIMIT]		= REG_FIELD(BQ24257_REG_2, 4, 6),
135 	[F_EN_STAT]		= REG_FIELD(BQ24257_REG_2, 3, 3),
136 	[F_EN_TERM]		= REG_FIELD(BQ24257_REG_2, 2, 2),
137 	[F_CE]			= REG_FIELD(BQ24257_REG_2, 1, 1),
138 	[F_HZ_MODE]		= REG_FIELD(BQ24257_REG_2, 0, 0),
139 	/* REG 3 */
140 	[F_VBAT]		= REG_FIELD(BQ24257_REG_3, 2, 7),
141 	[F_USB_DET]		= REG_FIELD(BQ24257_REG_3, 0, 1),
142 	/* REG 4 */
143 	[F_ICHG]		= REG_FIELD(BQ24257_REG_4, 3, 7),
144 	[F_ITERM]		= REG_FIELD(BQ24257_REG_4, 0, 2),
145 	/* REG 5 */
146 	[F_LOOP_STATUS]		= REG_FIELD(BQ24257_REG_5, 6, 7),
147 	[F_LOW_CHG]		= REG_FIELD(BQ24257_REG_5, 5, 5),
148 	[F_DPDM_EN]		= REG_FIELD(BQ24257_REG_5, 4, 4),
149 	[F_CE_STATUS]		= REG_FIELD(BQ24257_REG_5, 3, 3),
150 	[F_VINDPM]		= REG_FIELD(BQ24257_REG_5, 0, 2),
151 	/* REG 6 */
152 	[F_X2_TMR_EN]		= REG_FIELD(BQ24257_REG_6, 7, 7),
153 	[F_TMR]			= REG_FIELD(BQ24257_REG_6, 5, 6),
154 	[F_SYSOFF]		= REG_FIELD(BQ24257_REG_6, 4, 4),
155 	[F_TS_EN]		= REG_FIELD(BQ24257_REG_6, 3, 3),
156 	[F_TS_STAT]		= REG_FIELD(BQ24257_REG_6, 0, 2),
157 	/* REG 7 */
158 	[F_VOVP]		= REG_FIELD(BQ24257_REG_7, 5, 7),
159 	[F_CLR_VDP]		= REG_FIELD(BQ24257_REG_7, 4, 4),
160 	[F_FORCE_BATDET]	= REG_FIELD(BQ24257_REG_7, 3, 3),
161 	[F_FORCE_PTM]		= REG_FIELD(BQ24257_REG_7, 2, 2)
162 };
163 
164 static const u32 bq24257_vbat_map[] = {
165 	3500000, 3520000, 3540000, 3560000, 3580000, 3600000, 3620000, 3640000,
166 	3660000, 3680000, 3700000, 3720000, 3740000, 3760000, 3780000, 3800000,
167 	3820000, 3840000, 3860000, 3880000, 3900000, 3920000, 3940000, 3960000,
168 	3980000, 4000000, 4020000, 4040000, 4060000, 4080000, 4100000, 4120000,
169 	4140000, 4160000, 4180000, 4200000, 4220000, 4240000, 4260000, 4280000,
170 	4300000, 4320000, 4340000, 4360000, 4380000, 4400000, 4420000, 4440000
171 };
172 
173 #define BQ24257_VBAT_MAP_SIZE		ARRAY_SIZE(bq24257_vbat_map)
174 
175 static const u32 bq24257_ichg_map[] = {
176 	500000, 550000, 600000, 650000, 700000, 750000, 800000, 850000, 900000,
177 	950000, 1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000,
178 	1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
179 	1750000, 1800000, 1850000, 1900000, 1950000, 2000000
180 };
181 
182 #define BQ24257_ICHG_MAP_SIZE		ARRAY_SIZE(bq24257_ichg_map)
183 
184 static const u32 bq24257_iterm_map[] = {
185 	50000, 75000, 100000, 125000, 150000, 175000, 200000, 225000
186 };
187 
188 #define BQ24257_ITERM_MAP_SIZE		ARRAY_SIZE(bq24257_iterm_map)
189 
190 static const u32 bq24257_iilimit_map[] = {
191 	100000, 150000, 500000, 900000, 1500000, 2000000
192 };
193 
194 #define BQ24257_IILIMIT_MAP_SIZE	ARRAY_SIZE(bq24257_iilimit_map)
195 
196 static const u32 bq24257_vovp_map[] = {
197 	6000000, 6500000, 7000000, 8000000, 9000000, 9500000, 10000000,
198 	10500000
199 };
200 
201 #define BQ24257_VOVP_MAP_SIZE		ARRAY_SIZE(bq24257_vovp_map)
202 
203 static const u32 bq24257_vindpm_map[] = {
204 	4200000, 4280000, 4360000, 4440000, 4520000, 4600000, 4680000,
205 	4760000
206 };
207 
208 #define BQ24257_VINDPM_MAP_SIZE		ARRAY_SIZE(bq24257_vindpm_map)
209 
210 static int bq24257_field_read(struct bq24257_device *bq,
211 			      enum bq24257_fields field_id)
212 {
213 	int ret;
214 	int val;
215 
216 	ret = regmap_field_read(bq->rmap_fields[field_id], &val);
217 	if (ret < 0)
218 		return ret;
219 
220 	return val;
221 }
222 
223 static int bq24257_field_write(struct bq24257_device *bq,
224 			       enum bq24257_fields field_id, u8 val)
225 {
226 	return regmap_field_write(bq->rmap_fields[field_id], val);
227 }
228 
229 static u8 bq24257_find_idx(u32 value, const u32 *map, u8 map_size)
230 {
231 	u8 idx;
232 
233 	for (idx = 1; idx < map_size; idx++)
234 		if (value < map[idx])
235 			break;
236 
237 	return idx - 1;
238 }
239 
240 enum bq24257_status {
241 	STATUS_READY,
242 	STATUS_CHARGE_IN_PROGRESS,
243 	STATUS_CHARGE_DONE,
244 	STATUS_FAULT,
245 };
246 
247 enum bq24257_fault {
248 	FAULT_NORMAL,
249 	FAULT_INPUT_OVP,
250 	FAULT_INPUT_UVLO,
251 	FAULT_SLEEP,
252 	FAULT_BAT_TS,
253 	FAULT_BAT_OVP,
254 	FAULT_TS,
255 	FAULT_TIMER,
256 	FAULT_NO_BAT,
257 	FAULT_ISET,
258 	FAULT_INPUT_LDO_LOW,
259 };
260 
261 static int bq24257_get_input_current_limit(struct bq24257_device *bq,
262 					   union power_supply_propval *val)
263 {
264 	int ret;
265 
266 	ret = bq24257_field_read(bq, F_IILIMIT);
267 	if (ret < 0)
268 		return ret;
269 
270 	/*
271 	 * The "External ILIM" and "Production & Test" modes are not exposed
272 	 * through this driver and not being covered by the lookup table.
273 	 * Should such a mode have become active let's return an error rather
274 	 * than exceeding the bounds of the lookup table and returning
275 	 * garbage.
276 	 */
277 	if (ret >= BQ24257_IILIMIT_MAP_SIZE)
278 		return -ENODATA;
279 
280 	val->intval = bq24257_iilimit_map[ret];
281 
282 	return 0;
283 }
284 
285 static int bq24257_set_input_current_limit(struct bq24257_device *bq,
286 					const union power_supply_propval *val)
287 {
288 	/*
289 	 * Address the case where the user manually sets an input current limit
290 	 * while the charger auto-detection mechanism is active. In this
291 	 * case we want to abort and go straight to the user-specified value.
292 	 */
293 	if (bq->iilimit_autoset_enable)
294 		cancel_delayed_work_sync(&bq->iilimit_setup_work);
295 
296 	return bq24257_field_write(bq, F_IILIMIT,
297 				   bq24257_find_idx(val->intval,
298 						    bq24257_iilimit_map,
299 						    BQ24257_IILIMIT_MAP_SIZE));
300 }
301 
302 static int bq24257_power_supply_get_property(struct power_supply *psy,
303 					     enum power_supply_property psp,
304 					     union power_supply_propval *val)
305 {
306 	struct bq24257_device *bq = power_supply_get_drvdata(psy);
307 	struct bq24257_state state;
308 
309 	mutex_lock(&bq->lock);
310 	state = bq->state;
311 	mutex_unlock(&bq->lock);
312 
313 	switch (psp) {
314 	case POWER_SUPPLY_PROP_STATUS:
315 		if (!state.power_good)
316 			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
317 		else if (state.status == STATUS_READY)
318 			val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
319 		else if (state.status == STATUS_CHARGE_IN_PROGRESS)
320 			val->intval = POWER_SUPPLY_STATUS_CHARGING;
321 		else if (state.status == STATUS_CHARGE_DONE)
322 			val->intval = POWER_SUPPLY_STATUS_FULL;
323 		else
324 			val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
325 		break;
326 
327 	case POWER_SUPPLY_PROP_MANUFACTURER:
328 		val->strval = BQ24257_MANUFACTURER;
329 		break;
330 
331 	case POWER_SUPPLY_PROP_MODEL_NAME:
332 		val->strval = bq2425x_chip_name[bq->chip];
333 		break;
334 
335 	case POWER_SUPPLY_PROP_ONLINE:
336 		val->intval = state.power_good;
337 		break;
338 
339 	case POWER_SUPPLY_PROP_HEALTH:
340 		switch (state.fault) {
341 		case FAULT_NORMAL:
342 			val->intval = POWER_SUPPLY_HEALTH_GOOD;
343 			break;
344 
345 		case FAULT_INPUT_OVP:
346 		case FAULT_BAT_OVP:
347 			val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
348 			break;
349 
350 		case FAULT_TS:
351 		case FAULT_BAT_TS:
352 			val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
353 			break;
354 
355 		case FAULT_TIMER:
356 			val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
357 			break;
358 
359 		default:
360 			val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
361 			break;
362 		}
363 
364 		break;
365 
366 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
367 		val->intval = bq24257_ichg_map[bq->init_data.ichg];
368 		break;
369 
370 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
371 		val->intval = bq24257_ichg_map[BQ24257_ICHG_MAP_SIZE - 1];
372 		break;
373 
374 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
375 		val->intval = bq24257_vbat_map[bq->init_data.vbat];
376 		break;
377 
378 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
379 		val->intval = bq24257_vbat_map[BQ24257_VBAT_MAP_SIZE - 1];
380 		break;
381 
382 	case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
383 		val->intval = bq24257_iterm_map[bq->init_data.iterm];
384 		break;
385 
386 	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
387 		return bq24257_get_input_current_limit(bq, val);
388 
389 	default:
390 		return -EINVAL;
391 	}
392 
393 	return 0;
394 }
395 
396 static int bq24257_power_supply_set_property(struct power_supply *psy,
397 					enum power_supply_property prop,
398 					const union power_supply_propval *val)
399 {
400 	struct bq24257_device *bq = power_supply_get_drvdata(psy);
401 
402 	switch (prop) {
403 	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
404 		return bq24257_set_input_current_limit(bq, val);
405 	default:
406 		return -EINVAL;
407 	}
408 }
409 
410 static int bq24257_power_supply_property_is_writeable(struct power_supply *psy,
411 					enum power_supply_property psp)
412 {
413 	switch (psp) {
414 	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
415 		return true;
416 	default:
417 		return false;
418 	}
419 }
420 
421 static int bq24257_get_chip_state(struct bq24257_device *bq,
422 				  struct bq24257_state *state)
423 {
424 	int ret;
425 
426 	ret = bq24257_field_read(bq, F_STAT);
427 	if (ret < 0)
428 		return ret;
429 
430 	state->status = ret;
431 
432 	ret = bq24257_field_read(bq, F_FAULT);
433 	if (ret < 0)
434 		return ret;
435 
436 	state->fault = ret;
437 
438 	if (bq->pg)
439 		state->power_good = !gpiod_get_value_cansleep(bq->pg);
440 	else
441 		/*
442 		 * If we have a chip without a dedicated power-good GPIO or
443 		 * some other explicit bit that would provide this information
444 		 * assume the power is good if there is no supply related
445 		 * fault - and not good otherwise. There is a possibility for
446 		 * other errors to mask that power in fact is not good but this
447 		 * is probably the best we can do here.
448 		 */
449 		switch (state->fault) {
450 		case FAULT_INPUT_OVP:
451 		case FAULT_INPUT_UVLO:
452 		case FAULT_INPUT_LDO_LOW:
453 			state->power_good = false;
454 			break;
455 		default:
456 			state->power_good = true;
457 		}
458 
459 	return 0;
460 }
461 
462 static bool bq24257_state_changed(struct bq24257_device *bq,
463 				  struct bq24257_state *new_state)
464 {
465 	int ret;
466 
467 	mutex_lock(&bq->lock);
468 	ret = (bq->state.status != new_state->status ||
469 	       bq->state.fault != new_state->fault ||
470 	       bq->state.power_good != new_state->power_good);
471 	mutex_unlock(&bq->lock);
472 
473 	return ret;
474 }
475 
476 enum bq24257_loop_status {
477 	LOOP_STATUS_NONE,
478 	LOOP_STATUS_IN_DPM,
479 	LOOP_STATUS_IN_CURRENT_LIMIT,
480 	LOOP_STATUS_THERMAL,
481 };
482 
483 enum bq24257_in_ilimit {
484 	IILIMIT_100,
485 	IILIMIT_150,
486 	IILIMIT_500,
487 	IILIMIT_900,
488 	IILIMIT_1500,
489 	IILIMIT_2000,
490 	IILIMIT_EXT,
491 	IILIMIT_NONE,
492 };
493 
494 enum bq24257_vovp {
495 	VOVP_6000,
496 	VOVP_6500,
497 	VOVP_7000,
498 	VOVP_8000,
499 	VOVP_9000,
500 	VOVP_9500,
501 	VOVP_10000,
502 	VOVP_10500
503 };
504 
505 enum bq24257_vindpm {
506 	VINDPM_4200,
507 	VINDPM_4280,
508 	VINDPM_4360,
509 	VINDPM_4440,
510 	VINDPM_4520,
511 	VINDPM_4600,
512 	VINDPM_4680,
513 	VINDPM_4760
514 };
515 
516 enum bq24257_port_type {
517 	PORT_TYPE_DCP,		/* Dedicated Charging Port */
518 	PORT_TYPE_CDP,		/* Charging Downstream Port */
519 	PORT_TYPE_SDP,		/* Standard Downstream Port */
520 	PORT_TYPE_NON_STANDARD,
521 };
522 
523 enum bq24257_safety_timer {
524 	SAFETY_TIMER_45,
525 	SAFETY_TIMER_360,
526 	SAFETY_TIMER_540,
527 	SAFETY_TIMER_NONE,
528 };
529 
530 static int bq24257_iilimit_autoset(struct bq24257_device *bq)
531 {
532 	int loop_status;
533 	int iilimit;
534 	int port_type;
535 	int ret;
536 	const u8 new_iilimit[] = {
537 		[PORT_TYPE_DCP] = IILIMIT_2000,
538 		[PORT_TYPE_CDP] = IILIMIT_2000,
539 		[PORT_TYPE_SDP] = IILIMIT_500,
540 		[PORT_TYPE_NON_STANDARD] = IILIMIT_500
541 	};
542 
543 	ret = bq24257_field_read(bq, F_LOOP_STATUS);
544 	if (ret < 0)
545 		goto error;
546 
547 	loop_status = ret;
548 
549 	ret = bq24257_field_read(bq, F_IILIMIT);
550 	if (ret < 0)
551 		goto error;
552 
553 	iilimit = ret;
554 
555 	/*
556 	 * All USB ports should be able to handle 500mA. If not, DPM will lower
557 	 * the charging current to accommodate the power source. No need to set
558 	 * a lower IILIMIT value.
559 	 */
560 	if (loop_status == LOOP_STATUS_IN_DPM && iilimit == IILIMIT_500)
561 		return 0;
562 
563 	ret = bq24257_field_read(bq, F_USB_DET);
564 	if (ret < 0)
565 		goto error;
566 
567 	port_type = ret;
568 
569 	ret = bq24257_field_write(bq, F_IILIMIT, new_iilimit[port_type]);
570 	if (ret < 0)
571 		goto error;
572 
573 	ret = bq24257_field_write(bq, F_TMR, SAFETY_TIMER_360);
574 	if (ret < 0)
575 		goto error;
576 
577 	ret = bq24257_field_write(bq, F_CLR_VDP, 1);
578 	if (ret < 0)
579 		goto error;
580 
581 	dev_dbg(bq->dev, "port/loop = %d/%d -> iilimit = %d\n",
582 		port_type, loop_status, new_iilimit[port_type]);
583 
584 	return 0;
585 
586 error:
587 	dev_err(bq->dev, "%s: Error communicating with the chip.\n", __func__);
588 	return ret;
589 }
590 
591 static void bq24257_iilimit_setup_work(struct work_struct *work)
592 {
593 	struct bq24257_device *bq = container_of(work, struct bq24257_device,
594 						 iilimit_setup_work.work);
595 
596 	bq24257_iilimit_autoset(bq);
597 }
598 
599 static void bq24257_handle_state_change(struct bq24257_device *bq,
600 					struct bq24257_state *new_state)
601 {
602 	int ret;
603 	struct bq24257_state old_state;
604 
605 	mutex_lock(&bq->lock);
606 	old_state = bq->state;
607 	mutex_unlock(&bq->lock);
608 
609 	/*
610 	 * Handle BQ2425x state changes observing whether the D+/D- based input
611 	 * current limit autoset functionality is enabled.
612 	 */
613 	if (!new_state->power_good) {
614 		dev_dbg(bq->dev, "Power removed\n");
615 		if (bq->iilimit_autoset_enable) {
616 			cancel_delayed_work_sync(&bq->iilimit_setup_work);
617 
618 			/* activate D+/D- port detection algorithm */
619 			ret = bq24257_field_write(bq, F_DPDM_EN, 1);
620 			if (ret < 0)
621 				goto error;
622 		}
623 		/*
624 		 * When power is removed always return to the default input
625 		 * current limit as configured during probe.
626 		 */
627 		ret = bq24257_field_write(bq, F_IILIMIT, bq->init_data.iilimit);
628 		if (ret < 0)
629 			goto error;
630 	} else if (!old_state.power_good) {
631 		dev_dbg(bq->dev, "Power inserted\n");
632 
633 		if (bq->iilimit_autoset_enable)
634 			/* configure input current limit */
635 			schedule_delayed_work(&bq->iilimit_setup_work,
636 				      msecs_to_jiffies(BQ24257_ILIM_SET_DELAY));
637 	} else if (new_state->fault == FAULT_NO_BAT) {
638 		dev_warn(bq->dev, "Battery removed\n");
639 	} else if (new_state->fault == FAULT_TIMER) {
640 		dev_err(bq->dev, "Safety timer expired! Battery dead?\n");
641 	}
642 
643 	return;
644 
645 error:
646 	dev_err(bq->dev, "%s: Error communicating with the chip.\n", __func__);
647 }
648 
649 static irqreturn_t bq24257_irq_handler_thread(int irq, void *private)
650 {
651 	int ret;
652 	struct bq24257_device *bq = private;
653 	struct bq24257_state state;
654 
655 	ret = bq24257_get_chip_state(bq, &state);
656 	if (ret < 0)
657 		return IRQ_HANDLED;
658 
659 	if (!bq24257_state_changed(bq, &state))
660 		return IRQ_HANDLED;
661 
662 	dev_dbg(bq->dev, "irq(state changed): status/fault/pg = %d/%d/%d\n",
663 		state.status, state.fault, state.power_good);
664 
665 	bq24257_handle_state_change(bq, &state);
666 
667 	mutex_lock(&bq->lock);
668 	bq->state = state;
669 	mutex_unlock(&bq->lock);
670 
671 	power_supply_changed(bq->charger);
672 
673 	return IRQ_HANDLED;
674 }
675 
676 static int bq24257_hw_init(struct bq24257_device *bq)
677 {
678 	int ret;
679 	int i;
680 	struct bq24257_state state;
681 
682 	const struct {
683 		int field;
684 		u32 value;
685 	} init_data[] = {
686 		{F_ICHG, bq->init_data.ichg},
687 		{F_VBAT, bq->init_data.vbat},
688 		{F_ITERM, bq->init_data.iterm},
689 		{F_VOVP, bq->init_data.vovp},
690 		{F_VINDPM, bq->init_data.vindpm},
691 	};
692 
693 	/*
694 	 * Disable the watchdog timer to prevent the IC from going back to
695 	 * default settings after 50 seconds of I2C inactivity.
696 	 */
697 	ret = bq24257_field_write(bq, F_WD_EN, 0);
698 	if (ret < 0)
699 		return ret;
700 
701 	/* configure the charge currents and voltages */
702 	for (i = 0; i < ARRAY_SIZE(init_data); i++) {
703 		ret = bq24257_field_write(bq, init_data[i].field,
704 					  init_data[i].value);
705 		if (ret < 0)
706 			return ret;
707 	}
708 
709 	ret = bq24257_get_chip_state(bq, &state);
710 	if (ret < 0)
711 		return ret;
712 
713 	mutex_lock(&bq->lock);
714 	bq->state = state;
715 	mutex_unlock(&bq->lock);
716 
717 	if (!bq->iilimit_autoset_enable) {
718 		dev_dbg(bq->dev, "manually setting iilimit = %u\n",
719 			bq->init_data.iilimit);
720 
721 		/* program fixed input current limit */
722 		ret = bq24257_field_write(bq, F_IILIMIT,
723 					  bq->init_data.iilimit);
724 		if (ret < 0)
725 			return ret;
726 	} else if (!state.power_good)
727 		/* activate D+/D- detection algorithm */
728 		ret = bq24257_field_write(bq, F_DPDM_EN, 1);
729 	else if (state.fault != FAULT_NO_BAT)
730 		ret = bq24257_iilimit_autoset(bq);
731 
732 	return ret;
733 }
734 
735 static enum power_supply_property bq24257_power_supply_props[] = {
736 	POWER_SUPPLY_PROP_MANUFACTURER,
737 	POWER_SUPPLY_PROP_MODEL_NAME,
738 	POWER_SUPPLY_PROP_STATUS,
739 	POWER_SUPPLY_PROP_ONLINE,
740 	POWER_SUPPLY_PROP_HEALTH,
741 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
742 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
743 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
744 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
745 	POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
746 	POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
747 };
748 
749 static char *bq24257_charger_supplied_to[] = {
750 	"main-battery",
751 };
752 
753 static const struct power_supply_desc bq24257_power_supply_desc = {
754 	.name = "bq24257-charger",
755 	.type = POWER_SUPPLY_TYPE_USB,
756 	.properties = bq24257_power_supply_props,
757 	.num_properties = ARRAY_SIZE(bq24257_power_supply_props),
758 	.get_property = bq24257_power_supply_get_property,
759 	.set_property = bq24257_power_supply_set_property,
760 	.property_is_writeable = bq24257_power_supply_property_is_writeable,
761 };
762 
763 static ssize_t bq24257_show_ovp_voltage(struct device *dev,
764 					struct device_attribute *attr,
765 					char *buf)
766 {
767 	struct power_supply *psy = dev_get_drvdata(dev);
768 	struct bq24257_device *bq = power_supply_get_drvdata(psy);
769 
770 	return sysfs_emit(buf, "%u\n", bq24257_vovp_map[bq->init_data.vovp]);
771 }
772 
773 static ssize_t bq24257_show_in_dpm_voltage(struct device *dev,
774 					   struct device_attribute *attr,
775 					   char *buf)
776 {
777 	struct power_supply *psy = dev_get_drvdata(dev);
778 	struct bq24257_device *bq = power_supply_get_drvdata(psy);
779 
780 	return sysfs_emit(buf, "%u\n", bq24257_vindpm_map[bq->init_data.vindpm]);
781 }
782 
783 static ssize_t bq24257_sysfs_show_enable(struct device *dev,
784 					 struct device_attribute *attr,
785 					 char *buf)
786 {
787 	struct power_supply *psy = dev_get_drvdata(dev);
788 	struct bq24257_device *bq = power_supply_get_drvdata(psy);
789 	int ret;
790 
791 	if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
792 		ret = bq24257_field_read(bq, F_HZ_MODE);
793 	else if (strcmp(attr->attr.name, "sysoff_enable") == 0)
794 		ret = bq24257_field_read(bq, F_SYSOFF);
795 	else
796 		return -EINVAL;
797 
798 	if (ret < 0)
799 		return ret;
800 
801 	return sysfs_emit(buf, "%d\n", ret);
802 }
803 
804 static ssize_t bq24257_sysfs_set_enable(struct device *dev,
805 					struct device_attribute *attr,
806 					const char *buf,
807 					size_t count)
808 {
809 	struct power_supply *psy = dev_get_drvdata(dev);
810 	struct bq24257_device *bq = power_supply_get_drvdata(psy);
811 	long val;
812 	int ret;
813 
814 	if (kstrtol(buf, 10, &val) < 0)
815 		return -EINVAL;
816 
817 	if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
818 		ret = bq24257_field_write(bq, F_HZ_MODE, (bool)val);
819 	else if (strcmp(attr->attr.name, "sysoff_enable") == 0)
820 		ret = bq24257_field_write(bq, F_SYSOFF, (bool)val);
821 	else
822 		return -EINVAL;
823 
824 	if (ret < 0)
825 		return ret;
826 
827 	return count;
828 }
829 
830 static DEVICE_ATTR(ovp_voltage, S_IRUGO, bq24257_show_ovp_voltage, NULL);
831 static DEVICE_ATTR(in_dpm_voltage, S_IRUGO, bq24257_show_in_dpm_voltage, NULL);
832 static DEVICE_ATTR(high_impedance_enable, S_IWUSR | S_IRUGO,
833 		   bq24257_sysfs_show_enable, bq24257_sysfs_set_enable);
834 static DEVICE_ATTR(sysoff_enable, S_IWUSR | S_IRUGO,
835 		   bq24257_sysfs_show_enable, bq24257_sysfs_set_enable);
836 
837 static struct attribute *bq24257_charger_sysfs_attrs[] = {
838 	&dev_attr_ovp_voltage.attr,
839 	&dev_attr_in_dpm_voltage.attr,
840 	&dev_attr_high_impedance_enable.attr,
841 	&dev_attr_sysoff_enable.attr,
842 	NULL,
843 };
844 
845 ATTRIBUTE_GROUPS(bq24257_charger_sysfs);
846 
847 static int bq24257_power_supply_init(struct bq24257_device *bq)
848 {
849 	struct power_supply_config psy_cfg = { .drv_data = bq, };
850 
851 	psy_cfg.attr_grp = bq24257_charger_sysfs_groups;
852 	psy_cfg.supplied_to = bq24257_charger_supplied_to;
853 	psy_cfg.num_supplicants = ARRAY_SIZE(bq24257_charger_supplied_to);
854 
855 	bq->charger = devm_power_supply_register(bq->dev,
856 						 &bq24257_power_supply_desc,
857 						 &psy_cfg);
858 
859 	return PTR_ERR_OR_ZERO(bq->charger);
860 }
861 
862 static void bq24257_pg_gpio_probe(struct bq24257_device *bq)
863 {
864 	bq->pg = devm_gpiod_get_optional(bq->dev, BQ24257_PG_GPIO, GPIOD_IN);
865 
866 	if (PTR_ERR(bq->pg) == -EPROBE_DEFER) {
867 		dev_info(bq->dev, "probe retry requested for PG pin\n");
868 		return;
869 	} else if (IS_ERR(bq->pg)) {
870 		dev_err(bq->dev, "error probing PG pin\n");
871 		bq->pg = NULL;
872 		return;
873 	}
874 
875 	if (bq->pg)
876 		dev_dbg(bq->dev, "probed PG pin = %d\n", desc_to_gpio(bq->pg));
877 }
878 
879 static int bq24257_fw_probe(struct bq24257_device *bq)
880 {
881 	int ret;
882 	u32 property;
883 
884 	/* Required properties */
885 	ret = device_property_read_u32(bq->dev, "ti,charge-current", &property);
886 	if (ret < 0)
887 		return ret;
888 
889 	bq->init_data.ichg = bq24257_find_idx(property, bq24257_ichg_map,
890 					      BQ24257_ICHG_MAP_SIZE);
891 
892 	ret = device_property_read_u32(bq->dev, "ti,battery-regulation-voltage",
893 				       &property);
894 	if (ret < 0)
895 		return ret;
896 
897 	bq->init_data.vbat = bq24257_find_idx(property, bq24257_vbat_map,
898 					      BQ24257_VBAT_MAP_SIZE);
899 
900 	ret = device_property_read_u32(bq->dev, "ti,termination-current",
901 				       &property);
902 	if (ret < 0)
903 		return ret;
904 
905 	bq->init_data.iterm = bq24257_find_idx(property, bq24257_iterm_map,
906 					       BQ24257_ITERM_MAP_SIZE);
907 
908 	/* Optional properties. If not provided use reasonable default. */
909 	ret = device_property_read_u32(bq->dev, "ti,current-limit",
910 				       &property);
911 	if (ret < 0) {
912 		bq->iilimit_autoset_enable = true;
913 
914 		/*
915 		 * Explicitly set a default value which will be needed for
916 		 * devices that don't support the automatic setting of the input
917 		 * current limit through the charger type detection mechanism.
918 		 */
919 		bq->init_data.iilimit = IILIMIT_500;
920 	} else
921 		bq->init_data.iilimit =
922 				bq24257_find_idx(property,
923 						 bq24257_iilimit_map,
924 						 BQ24257_IILIMIT_MAP_SIZE);
925 
926 	ret = device_property_read_u32(bq->dev, "ti,ovp-voltage",
927 				       &property);
928 	if (ret < 0)
929 		bq->init_data.vovp = VOVP_6500;
930 	else
931 		bq->init_data.vovp = bq24257_find_idx(property,
932 						      bq24257_vovp_map,
933 						      BQ24257_VOVP_MAP_SIZE);
934 
935 	ret = device_property_read_u32(bq->dev, "ti,in-dpm-voltage",
936 				       &property);
937 	if (ret < 0)
938 		bq->init_data.vindpm = VINDPM_4360;
939 	else
940 		bq->init_data.vindpm =
941 				bq24257_find_idx(property,
942 						 bq24257_vindpm_map,
943 						 BQ24257_VINDPM_MAP_SIZE);
944 
945 	return 0;
946 }
947 
948 static int bq24257_probe(struct i2c_client *client)
949 {
950 	const struct i2c_device_id *id = i2c_client_get_device_id(client);
951 	struct i2c_adapter *adapter = client->adapter;
952 	struct device *dev = &client->dev;
953 	const struct acpi_device_id *acpi_id;
954 	struct bq24257_device *bq;
955 	int ret;
956 	int i;
957 
958 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
959 		dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
960 		return -ENODEV;
961 	}
962 
963 	bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
964 	if (!bq)
965 		return -ENOMEM;
966 
967 	bq->client = client;
968 	bq->dev = dev;
969 
970 	if (ACPI_HANDLE(dev)) {
971 		acpi_id = acpi_match_device(dev->driver->acpi_match_table,
972 					    &client->dev);
973 		if (!acpi_id) {
974 			dev_err(dev, "Failed to match ACPI device\n");
975 			return -ENODEV;
976 		}
977 		bq->chip = (enum bq2425x_chip)acpi_id->driver_data;
978 	} else {
979 		bq->chip = (enum bq2425x_chip)id->driver_data;
980 	}
981 
982 	mutex_init(&bq->lock);
983 
984 	bq->rmap = devm_regmap_init_i2c(client, &bq24257_regmap_config);
985 	if (IS_ERR(bq->rmap)) {
986 		dev_err(dev, "failed to allocate register map\n");
987 		return PTR_ERR(bq->rmap);
988 	}
989 
990 	for (i = 0; i < ARRAY_SIZE(bq24257_reg_fields); i++) {
991 		const struct reg_field *reg_fields = bq24257_reg_fields;
992 
993 		bq->rmap_fields[i] = devm_regmap_field_alloc(dev, bq->rmap,
994 							     reg_fields[i]);
995 		if (IS_ERR(bq->rmap_fields[i])) {
996 			dev_err(dev, "cannot allocate regmap field\n");
997 			return PTR_ERR(bq->rmap_fields[i]);
998 		}
999 	}
1000 
1001 	i2c_set_clientdata(client, bq);
1002 
1003 	if (!dev->platform_data) {
1004 		ret = bq24257_fw_probe(bq);
1005 		if (ret < 0) {
1006 			dev_err(dev, "Cannot read device properties.\n");
1007 			return ret;
1008 		}
1009 	} else {
1010 		return -ENODEV;
1011 	}
1012 
1013 	/*
1014 	 * The BQ24250 doesn't support the D+/D- based charger type detection
1015 	 * used for the automatic setting of the input current limit setting so
1016 	 * explicitly disable that feature.
1017 	 */
1018 	if (bq->chip == BQ24250)
1019 		bq->iilimit_autoset_enable = false;
1020 
1021 	if (bq->iilimit_autoset_enable)
1022 		INIT_DELAYED_WORK(&bq->iilimit_setup_work,
1023 				  bq24257_iilimit_setup_work);
1024 
1025 	/*
1026 	 * The BQ24250 doesn't have a dedicated Power Good (PG) pin so let's
1027 	 * not probe for it and instead use a SW-based approach to determine
1028 	 * the PG state. We also use a SW-based approach for all other devices
1029 	 * if the PG pin is either not defined or can't be probed.
1030 	 */
1031 	if (bq->chip != BQ24250)
1032 		bq24257_pg_gpio_probe(bq);
1033 
1034 	if (PTR_ERR(bq->pg) == -EPROBE_DEFER)
1035 		return PTR_ERR(bq->pg);
1036 	else if (!bq->pg)
1037 		dev_info(bq->dev, "using SW-based power-good detection\n");
1038 
1039 	/* reset all registers to defaults */
1040 	ret = bq24257_field_write(bq, F_RESET, 1);
1041 	if (ret < 0)
1042 		return ret;
1043 
1044 	/*
1045 	 * Put the RESET bit back to 0, in cache. For some reason the HW always
1046 	 * returns 1 on this bit, so this is the only way to avoid resetting the
1047 	 * chip every time we update another field in this register.
1048 	 */
1049 	ret = bq24257_field_write(bq, F_RESET, 0);
1050 	if (ret < 0)
1051 		return ret;
1052 
1053 	ret = bq24257_hw_init(bq);
1054 	if (ret < 0) {
1055 		dev_err(dev, "Cannot initialize the chip.\n");
1056 		return ret;
1057 	}
1058 
1059 	ret = bq24257_power_supply_init(bq);
1060 	if (ret < 0) {
1061 		dev_err(dev, "Failed to register power supply\n");
1062 		return ret;
1063 	}
1064 
1065 	ret = devm_request_threaded_irq(dev, client->irq, NULL,
1066 					bq24257_irq_handler_thread,
1067 					IRQF_TRIGGER_FALLING |
1068 					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1069 					bq2425x_chip_name[bq->chip], bq);
1070 	if (ret) {
1071 		dev_err(dev, "Failed to request IRQ #%d\n", client->irq);
1072 		return ret;
1073 	}
1074 
1075 	return 0;
1076 }
1077 
1078 static void bq24257_remove(struct i2c_client *client)
1079 {
1080 	struct bq24257_device *bq = i2c_get_clientdata(client);
1081 
1082 	if (bq->iilimit_autoset_enable)
1083 		cancel_delayed_work_sync(&bq->iilimit_setup_work);
1084 
1085 	bq24257_field_write(bq, F_RESET, 1); /* reset to defaults */
1086 }
1087 
1088 #ifdef CONFIG_PM_SLEEP
1089 static int bq24257_suspend(struct device *dev)
1090 {
1091 	struct bq24257_device *bq = dev_get_drvdata(dev);
1092 	int ret = 0;
1093 
1094 	if (bq->iilimit_autoset_enable)
1095 		cancel_delayed_work_sync(&bq->iilimit_setup_work);
1096 
1097 	/* reset all registers to default (and activate standalone mode) */
1098 	ret = bq24257_field_write(bq, F_RESET, 1);
1099 	if (ret < 0)
1100 		dev_err(bq->dev, "Cannot reset chip to standalone mode.\n");
1101 
1102 	return ret;
1103 }
1104 
1105 static int bq24257_resume(struct device *dev)
1106 {
1107 	int ret;
1108 	struct bq24257_device *bq = dev_get_drvdata(dev);
1109 
1110 	ret = regcache_drop_region(bq->rmap, BQ24257_REG_1, BQ24257_REG_7);
1111 	if (ret < 0)
1112 		return ret;
1113 
1114 	ret = bq24257_field_write(bq, F_RESET, 0);
1115 	if (ret < 0)
1116 		return ret;
1117 
1118 	ret = bq24257_hw_init(bq);
1119 	if (ret < 0) {
1120 		dev_err(bq->dev, "Cannot init chip after resume.\n");
1121 		return ret;
1122 	}
1123 
1124 	/* signal userspace, maybe state changed while suspended */
1125 	power_supply_changed(bq->charger);
1126 
1127 	return 0;
1128 }
1129 #endif
1130 
1131 static const struct dev_pm_ops bq24257_pm = {
1132 	SET_SYSTEM_SLEEP_PM_OPS(bq24257_suspend, bq24257_resume)
1133 };
1134 
1135 static const struct i2c_device_id bq24257_i2c_ids[] = {
1136 	{ "bq24250", BQ24250 },
1137 	{ "bq24251", BQ24251 },
1138 	{ "bq24257", BQ24257 },
1139 	{},
1140 };
1141 MODULE_DEVICE_TABLE(i2c, bq24257_i2c_ids);
1142 
1143 static const struct of_device_id bq24257_of_match[] __maybe_unused = {
1144 	{ .compatible = "ti,bq24250", },
1145 	{ .compatible = "ti,bq24251", },
1146 	{ .compatible = "ti,bq24257", },
1147 	{ },
1148 };
1149 MODULE_DEVICE_TABLE(of, bq24257_of_match);
1150 
1151 #ifdef CONFIG_ACPI
1152 static const struct acpi_device_id bq24257_acpi_match[] = {
1153 	{ "BQ242500", BQ24250 },
1154 	{ "BQ242510", BQ24251 },
1155 	{ "BQ242570", BQ24257 },
1156 	{},
1157 };
1158 MODULE_DEVICE_TABLE(acpi, bq24257_acpi_match);
1159 #endif
1160 
1161 static struct i2c_driver bq24257_driver = {
1162 	.driver = {
1163 		.name = "bq24257-charger",
1164 		.of_match_table = of_match_ptr(bq24257_of_match),
1165 		.acpi_match_table = ACPI_PTR(bq24257_acpi_match),
1166 		.pm = &bq24257_pm,
1167 	},
1168 	.probe = bq24257_probe,
1169 	.remove = bq24257_remove,
1170 	.id_table = bq24257_i2c_ids,
1171 };
1172 module_i2c_driver(bq24257_driver);
1173 
1174 MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>");
1175 MODULE_DESCRIPTION("bq24257 charger driver");
1176 MODULE_LICENSE("GPL");
1177