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
bq24257_is_volatile_reg(struct device * dev,unsigned int reg)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
bq24257_field_read(struct bq24257_device * bq,enum bq24257_fields field_id)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
bq24257_field_write(struct bq24257_device * bq,enum bq24257_fields field_id,u8 val)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
bq24257_find_idx(u32 value,const u32 * map,u8 map_size)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
bq24257_get_input_current_limit(struct bq24257_device * bq,union power_supply_propval * val)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
bq24257_set_input_current_limit(struct bq24257_device * bq,const union power_supply_propval * val)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
bq24257_power_supply_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)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
bq24257_power_supply_set_property(struct power_supply * psy,enum power_supply_property prop,const union power_supply_propval * val)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
bq24257_power_supply_property_is_writeable(struct power_supply * psy,enum power_supply_property psp)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
bq24257_get_chip_state(struct bq24257_device * bq,struct bq24257_state * state)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
bq24257_state_changed(struct bq24257_device * bq,struct bq24257_state * new_state)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
bq24257_iilimit_autoset(struct bq24257_device * bq)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
bq24257_iilimit_setup_work(struct work_struct * work)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
bq24257_handle_state_change(struct bq24257_device * bq,struct bq24257_state * new_state)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
bq24257_irq_handler_thread(int irq,void * private)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
bq24257_hw_init(struct bq24257_device * bq)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
bq24257_show_ovp_voltage(struct device * dev,struct device_attribute * attr,char * buf)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
bq24257_show_in_dpm_voltage(struct device * dev,struct device_attribute * attr,char * buf)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
bq24257_sysfs_show_enable(struct device * dev,struct device_attribute * attr,char * buf)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
bq24257_sysfs_set_enable(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
bq24257_power_supply_init(struct bq24257_device * bq)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
bq24257_pg_gpio_probe(struct bq24257_device * bq)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
bq24257_fw_probe(struct bq24257_device * bq)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
bq24257_probe(struct i2c_client * client)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
bq24257_remove(struct i2c_client * client)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
bq24257_suspend(struct device * dev)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
bq24257_resume(struct device * dev)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