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 scnprintf(buf, PAGE_SIZE, "%u\n",
771 			 bq24257_vovp_map[bq->init_data.vovp]);
772 }
773 
774 static ssize_t bq24257_show_in_dpm_voltage(struct device *dev,
775 					   struct device_attribute *attr,
776 					   char *buf)
777 {
778 	struct power_supply *psy = dev_get_drvdata(dev);
779 	struct bq24257_device *bq = power_supply_get_drvdata(psy);
780 
781 	return scnprintf(buf, PAGE_SIZE, "%u\n",
782 			 bq24257_vindpm_map[bq->init_data.vindpm]);
783 }
784 
785 static ssize_t bq24257_sysfs_show_enable(struct device *dev,
786 					 struct device_attribute *attr,
787 					 char *buf)
788 {
789 	struct power_supply *psy = dev_get_drvdata(dev);
790 	struct bq24257_device *bq = power_supply_get_drvdata(psy);
791 	int ret;
792 
793 	if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
794 		ret = bq24257_field_read(bq, F_HZ_MODE);
795 	else if (strcmp(attr->attr.name, "sysoff_enable") == 0)
796 		ret = bq24257_field_read(bq, F_SYSOFF);
797 	else
798 		return -EINVAL;
799 
800 	if (ret < 0)
801 		return ret;
802 
803 	return scnprintf(buf, PAGE_SIZE, "%d\n", ret);
804 }
805 
806 static ssize_t bq24257_sysfs_set_enable(struct device *dev,
807 					struct device_attribute *attr,
808 					const char *buf,
809 					size_t count)
810 {
811 	struct power_supply *psy = dev_get_drvdata(dev);
812 	struct bq24257_device *bq = power_supply_get_drvdata(psy);
813 	long val;
814 	int ret;
815 
816 	if (kstrtol(buf, 10, &val) < 0)
817 		return -EINVAL;
818 
819 	if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
820 		ret = bq24257_field_write(bq, F_HZ_MODE, (bool)val);
821 	else if (strcmp(attr->attr.name, "sysoff_enable") == 0)
822 		ret = bq24257_field_write(bq, F_SYSOFF, (bool)val);
823 	else
824 		return -EINVAL;
825 
826 	if (ret < 0)
827 		return ret;
828 
829 	return count;
830 }
831 
832 static DEVICE_ATTR(ovp_voltage, S_IRUGO, bq24257_show_ovp_voltage, NULL);
833 static DEVICE_ATTR(in_dpm_voltage, S_IRUGO, bq24257_show_in_dpm_voltage, NULL);
834 static DEVICE_ATTR(high_impedance_enable, S_IWUSR | S_IRUGO,
835 		   bq24257_sysfs_show_enable, bq24257_sysfs_set_enable);
836 static DEVICE_ATTR(sysoff_enable, S_IWUSR | S_IRUGO,
837 		   bq24257_sysfs_show_enable, bq24257_sysfs_set_enable);
838 
839 static struct attribute *bq24257_charger_sysfs_attrs[] = {
840 	&dev_attr_ovp_voltage.attr,
841 	&dev_attr_in_dpm_voltage.attr,
842 	&dev_attr_high_impedance_enable.attr,
843 	&dev_attr_sysoff_enable.attr,
844 	NULL,
845 };
846 
847 ATTRIBUTE_GROUPS(bq24257_charger_sysfs);
848 
849 static int bq24257_power_supply_init(struct bq24257_device *bq)
850 {
851 	struct power_supply_config psy_cfg = { .drv_data = bq, };
852 
853 	psy_cfg.attr_grp = bq24257_charger_sysfs_groups;
854 	psy_cfg.supplied_to = bq24257_charger_supplied_to;
855 	psy_cfg.num_supplicants = ARRAY_SIZE(bq24257_charger_supplied_to);
856 
857 	bq->charger = devm_power_supply_register(bq->dev,
858 						 &bq24257_power_supply_desc,
859 						 &psy_cfg);
860 
861 	return PTR_ERR_OR_ZERO(bq->charger);
862 }
863 
864 static void bq24257_pg_gpio_probe(struct bq24257_device *bq)
865 {
866 	bq->pg = devm_gpiod_get_optional(bq->dev, BQ24257_PG_GPIO, GPIOD_IN);
867 
868 	if (PTR_ERR(bq->pg) == -EPROBE_DEFER) {
869 		dev_info(bq->dev, "probe retry requested for PG pin\n");
870 		return;
871 	} else if (IS_ERR(bq->pg)) {
872 		dev_err(bq->dev, "error probing PG pin\n");
873 		bq->pg = NULL;
874 		return;
875 	}
876 
877 	if (bq->pg)
878 		dev_dbg(bq->dev, "probed PG pin = %d\n", desc_to_gpio(bq->pg));
879 }
880 
881 static int bq24257_fw_probe(struct bq24257_device *bq)
882 {
883 	int ret;
884 	u32 property;
885 
886 	/* Required properties */
887 	ret = device_property_read_u32(bq->dev, "ti,charge-current", &property);
888 	if (ret < 0)
889 		return ret;
890 
891 	bq->init_data.ichg = bq24257_find_idx(property, bq24257_ichg_map,
892 					      BQ24257_ICHG_MAP_SIZE);
893 
894 	ret = device_property_read_u32(bq->dev, "ti,battery-regulation-voltage",
895 				       &property);
896 	if (ret < 0)
897 		return ret;
898 
899 	bq->init_data.vbat = bq24257_find_idx(property, bq24257_vbat_map,
900 					      BQ24257_VBAT_MAP_SIZE);
901 
902 	ret = device_property_read_u32(bq->dev, "ti,termination-current",
903 				       &property);
904 	if (ret < 0)
905 		return ret;
906 
907 	bq->init_data.iterm = bq24257_find_idx(property, bq24257_iterm_map,
908 					       BQ24257_ITERM_MAP_SIZE);
909 
910 	/* Optional properties. If not provided use reasonable default. */
911 	ret = device_property_read_u32(bq->dev, "ti,current-limit",
912 				       &property);
913 	if (ret < 0) {
914 		bq->iilimit_autoset_enable = true;
915 
916 		/*
917 		 * Explicitly set a default value which will be needed for
918 		 * devices that don't support the automatic setting of the input
919 		 * current limit through the charger type detection mechanism.
920 		 */
921 		bq->init_data.iilimit = IILIMIT_500;
922 	} else
923 		bq->init_data.iilimit =
924 				bq24257_find_idx(property,
925 						 bq24257_iilimit_map,
926 						 BQ24257_IILIMIT_MAP_SIZE);
927 
928 	ret = device_property_read_u32(bq->dev, "ti,ovp-voltage",
929 				       &property);
930 	if (ret < 0)
931 		bq->init_data.vovp = VOVP_6500;
932 	else
933 		bq->init_data.vovp = bq24257_find_idx(property,
934 						      bq24257_vovp_map,
935 						      BQ24257_VOVP_MAP_SIZE);
936 
937 	ret = device_property_read_u32(bq->dev, "ti,in-dpm-voltage",
938 				       &property);
939 	if (ret < 0)
940 		bq->init_data.vindpm = VINDPM_4360;
941 	else
942 		bq->init_data.vindpm =
943 				bq24257_find_idx(property,
944 						 bq24257_vindpm_map,
945 						 BQ24257_VINDPM_MAP_SIZE);
946 
947 	return 0;
948 }
949 
950 static int bq24257_probe(struct i2c_client *client,
951 			 const struct i2c_device_id *id)
952 {
953 	struct i2c_adapter *adapter = client->adapter;
954 	struct device *dev = &client->dev;
955 	const struct acpi_device_id *acpi_id;
956 	struct bq24257_device *bq;
957 	int ret;
958 	int i;
959 
960 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
961 		dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
962 		return -ENODEV;
963 	}
964 
965 	bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
966 	if (!bq)
967 		return -ENOMEM;
968 
969 	bq->client = client;
970 	bq->dev = dev;
971 
972 	if (ACPI_HANDLE(dev)) {
973 		acpi_id = acpi_match_device(dev->driver->acpi_match_table,
974 					    &client->dev);
975 		if (!acpi_id) {
976 			dev_err(dev, "Failed to match ACPI device\n");
977 			return -ENODEV;
978 		}
979 		bq->chip = (enum bq2425x_chip)acpi_id->driver_data;
980 	} else {
981 		bq->chip = (enum bq2425x_chip)id->driver_data;
982 	}
983 
984 	mutex_init(&bq->lock);
985 
986 	bq->rmap = devm_regmap_init_i2c(client, &bq24257_regmap_config);
987 	if (IS_ERR(bq->rmap)) {
988 		dev_err(dev, "failed to allocate register map\n");
989 		return PTR_ERR(bq->rmap);
990 	}
991 
992 	for (i = 0; i < ARRAY_SIZE(bq24257_reg_fields); i++) {
993 		const struct reg_field *reg_fields = bq24257_reg_fields;
994 
995 		bq->rmap_fields[i] = devm_regmap_field_alloc(dev, bq->rmap,
996 							     reg_fields[i]);
997 		if (IS_ERR(bq->rmap_fields[i])) {
998 			dev_err(dev, "cannot allocate regmap field\n");
999 			return PTR_ERR(bq->rmap_fields[i]);
1000 		}
1001 	}
1002 
1003 	i2c_set_clientdata(client, bq);
1004 
1005 	if (!dev->platform_data) {
1006 		ret = bq24257_fw_probe(bq);
1007 		if (ret < 0) {
1008 			dev_err(dev, "Cannot read device properties.\n");
1009 			return ret;
1010 		}
1011 	} else {
1012 		return -ENODEV;
1013 	}
1014 
1015 	/*
1016 	 * The BQ24250 doesn't support the D+/D- based charger type detection
1017 	 * used for the automatic setting of the input current limit setting so
1018 	 * explicitly disable that feature.
1019 	 */
1020 	if (bq->chip == BQ24250)
1021 		bq->iilimit_autoset_enable = false;
1022 
1023 	if (bq->iilimit_autoset_enable)
1024 		INIT_DELAYED_WORK(&bq->iilimit_setup_work,
1025 				  bq24257_iilimit_setup_work);
1026 
1027 	/*
1028 	 * The BQ24250 doesn't have a dedicated Power Good (PG) pin so let's
1029 	 * not probe for it and instead use a SW-based approach to determine
1030 	 * the PG state. We also use a SW-based approach for all other devices
1031 	 * if the PG pin is either not defined or can't be probed.
1032 	 */
1033 	if (bq->chip != BQ24250)
1034 		bq24257_pg_gpio_probe(bq);
1035 
1036 	if (PTR_ERR(bq->pg) == -EPROBE_DEFER)
1037 		return PTR_ERR(bq->pg);
1038 	else if (!bq->pg)
1039 		dev_info(bq->dev, "using SW-based power-good detection\n");
1040 
1041 	/* reset all registers to defaults */
1042 	ret = bq24257_field_write(bq, F_RESET, 1);
1043 	if (ret < 0)
1044 		return ret;
1045 
1046 	/*
1047 	 * Put the RESET bit back to 0, in cache. For some reason the HW always
1048 	 * returns 1 on this bit, so this is the only way to avoid resetting the
1049 	 * chip every time we update another field in this register.
1050 	 */
1051 	ret = bq24257_field_write(bq, F_RESET, 0);
1052 	if (ret < 0)
1053 		return ret;
1054 
1055 	ret = bq24257_hw_init(bq);
1056 	if (ret < 0) {
1057 		dev_err(dev, "Cannot initialize the chip.\n");
1058 		return ret;
1059 	}
1060 
1061 	ret = bq24257_power_supply_init(bq);
1062 	if (ret < 0) {
1063 		dev_err(dev, "Failed to register power supply\n");
1064 		return ret;
1065 	}
1066 
1067 	ret = devm_request_threaded_irq(dev, client->irq, NULL,
1068 					bq24257_irq_handler_thread,
1069 					IRQF_TRIGGER_FALLING |
1070 					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1071 					bq2425x_chip_name[bq->chip], bq);
1072 	if (ret) {
1073 		dev_err(dev, "Failed to request IRQ #%d\n", client->irq);
1074 		return ret;
1075 	}
1076 
1077 	return 0;
1078 }
1079 
1080 static int bq24257_remove(struct i2c_client *client)
1081 {
1082 	struct bq24257_device *bq = i2c_get_clientdata(client);
1083 
1084 	if (bq->iilimit_autoset_enable)
1085 		cancel_delayed_work_sync(&bq->iilimit_setup_work);
1086 
1087 	bq24257_field_write(bq, F_RESET, 1); /* reset to defaults */
1088 
1089 	return 0;
1090 }
1091 
1092 #ifdef CONFIG_PM_SLEEP
1093 static int bq24257_suspend(struct device *dev)
1094 {
1095 	struct bq24257_device *bq = dev_get_drvdata(dev);
1096 	int ret = 0;
1097 
1098 	if (bq->iilimit_autoset_enable)
1099 		cancel_delayed_work_sync(&bq->iilimit_setup_work);
1100 
1101 	/* reset all registers to default (and activate standalone mode) */
1102 	ret = bq24257_field_write(bq, F_RESET, 1);
1103 	if (ret < 0)
1104 		dev_err(bq->dev, "Cannot reset chip to standalone mode.\n");
1105 
1106 	return ret;
1107 }
1108 
1109 static int bq24257_resume(struct device *dev)
1110 {
1111 	int ret;
1112 	struct bq24257_device *bq = dev_get_drvdata(dev);
1113 
1114 	ret = regcache_drop_region(bq->rmap, BQ24257_REG_1, BQ24257_REG_7);
1115 	if (ret < 0)
1116 		return ret;
1117 
1118 	ret = bq24257_field_write(bq, F_RESET, 0);
1119 	if (ret < 0)
1120 		return ret;
1121 
1122 	ret = bq24257_hw_init(bq);
1123 	if (ret < 0) {
1124 		dev_err(bq->dev, "Cannot init chip after resume.\n");
1125 		return ret;
1126 	}
1127 
1128 	/* signal userspace, maybe state changed while suspended */
1129 	power_supply_changed(bq->charger);
1130 
1131 	return 0;
1132 }
1133 #endif
1134 
1135 static const struct dev_pm_ops bq24257_pm = {
1136 	SET_SYSTEM_SLEEP_PM_OPS(bq24257_suspend, bq24257_resume)
1137 };
1138 
1139 static const struct i2c_device_id bq24257_i2c_ids[] = {
1140 	{ "bq24250", BQ24250 },
1141 	{ "bq24251", BQ24251 },
1142 	{ "bq24257", BQ24257 },
1143 	{},
1144 };
1145 MODULE_DEVICE_TABLE(i2c, bq24257_i2c_ids);
1146 
1147 static const struct of_device_id bq24257_of_match[] = {
1148 	{ .compatible = "ti,bq24250", },
1149 	{ .compatible = "ti,bq24251", },
1150 	{ .compatible = "ti,bq24257", },
1151 	{ },
1152 };
1153 MODULE_DEVICE_TABLE(of, bq24257_of_match);
1154 
1155 #ifdef CONFIG_ACPI
1156 static const struct acpi_device_id bq24257_acpi_match[] = {
1157 	{ "BQ242500", BQ24250 },
1158 	{ "BQ242510", BQ24251 },
1159 	{ "BQ242570", BQ24257 },
1160 	{},
1161 };
1162 MODULE_DEVICE_TABLE(acpi, bq24257_acpi_match);
1163 #endif
1164 
1165 static struct i2c_driver bq24257_driver = {
1166 	.driver = {
1167 		.name = "bq24257-charger",
1168 		.of_match_table = of_match_ptr(bq24257_of_match),
1169 		.acpi_match_table = ACPI_PTR(bq24257_acpi_match),
1170 		.pm = &bq24257_pm,
1171 	},
1172 	.probe = bq24257_probe,
1173 	.remove = bq24257_remove,
1174 	.id_table = bq24257_i2c_ids,
1175 };
1176 module_i2c_driver(bq24257_driver);
1177 
1178 MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>");
1179 MODULE_DESCRIPTION("bq24257 charger driver");
1180 MODULE_LICENSE("GPL");
1181