projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
power: bq24257: Allow manual setting of input current limit
[linux-2.6-block.git] / drivers / power / bq24257_charger.c
CommitLineData
2219a935
LP		 1/*
2 * TI BQ24257 charger driver
3 *
4 * Copyright (C) 2015 Intel Corporation
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
bf02dca9
AD		 16 * Datasheets:
17 * http://www.ti.com/product/bq24250
18 * http://www.ti.com/product/bq24251
19 * http://www.ti.com/product/bq24257
2219a935
LP		 20 */
21
22#include <linux/module.h>
23#include <linux/i2c.h>
24#include <linux/power_supply.h>
25#include <linux/regmap.h>
26#include <linux/types.h>
27#include <linux/gpio/consumer.h>
28#include <linux/interrupt.h>
29#include <linux/delay.h>
30
31#include <linux/acpi.h>
32#include <linux/of.h>
33
34#define BQ24257_REG_1 0x00
35#define BQ24257_REG_2 0x01
36#define BQ24257_REG_3 0x02
37#define BQ24257_REG_4 0x03
38#define BQ24257_REG_5 0x04
39#define BQ24257_REG_6 0x05
40#define BQ24257_REG_7 0x06
41
42#define BQ24257_MANUFACTURER "Texas Instruments"
2219a935
LP		 43#define BQ24257_PG_GPIO "pg"
44
45#define BQ24257_ILIM_SET_DELAY 1000 /* msec */
46
bf02dca9
AD		 47/*
48 * When adding support for new devices make sure that enum bq2425x_chip and
49 * bq2425x_chip_name[] always stay in sync!
50 */
51enum bq2425x_chip {
52 BQ24250,
53 BQ24251,
54 BQ24257,
55};
56
57static const char *const bq2425x_chip_name[] = {
58 "bq24250",
59 "bq24251",
60 "bq24257",
61};
62
2219a935
LP		 63enum bq24257_fields {
64 F_WD_FAULT, F_WD_EN, F_STAT, F_FAULT, /* REG 1 */
65 F_RESET, F_IILIMIT, F_EN_STAT, F_EN_TERM, F_CE, F_HZ_MODE, /* REG 2 */
66 F_VBAT, F_USB_DET, /* REG 3 */
67 F_ICHG, F_ITERM, /* REG 4 */
68 F_LOOP_STATUS, F_LOW_CHG, F_DPDM_EN, F_CE_STATUS, F_VINDPM, /* REG 5 */
7ef62365 69 F_X2_TMR_EN, F_TMR, F_SYSOFF, F_TS_EN, F_TS_STAT, /* REG 6 */
2219a935
LP		 70 F_VOVP, F_CLR_VDP, F_FORCE_BATDET, F_FORCE_PTM, /* REG 7 */
71
72 F_MAX_FIELDS
73};
74
75/* initial field values, converted from uV/uA */
76struct bq24257_init_data {
77 u8 ichg; /* charge current */
78 u8 vbat; /* regulation voltage */
79 u8 iterm; /* termination current */
eb9fbcc6 80 u8 iilimit; /* input current limit */
2219a935
LP		 81};
82
83struct bq24257_state {
84 u8 status;
85 u8 fault;
86 bool power_good;
87};
88
89struct bq24257_device {
90 struct i2c_client *client;
91 struct device *dev;
92 struct power_supply *charger;
93
bf02dca9
AD		 94 enum bq2425x_chip chip;
95
2219a935
LP		 96 struct regmap *rmap;
97 struct regmap_field *rmap_fields[F_MAX_FIELDS];
98
99 struct gpio_desc *pg;
100
101 struct delayed_work iilimit_setup_work;
102
103 struct bq24257_init_data init_data;
104 struct bq24257_state state;
105
106 struct mutex lock; /* protect state data */
eb9fbcc6
AD		 107
108 bool iilimit_autoset_enable;
2219a935
LP		 109};
110
111static bool bq24257_is_volatile_reg(struct device *dev, unsigned int reg)
112{
113 switch (reg) {
114 case BQ24257_REG_2:
115 case BQ24257_REG_4:
116 return false;
117
118 default:
119 return true;
120 }
121}
122
123static const struct regmap_config bq24257_regmap_config = {
124 .reg_bits = 8,
125 .val_bits = 8,
126
127 .max_register = BQ24257_REG_7,
128 .cache_type = REGCACHE_RBTREE,
129
130 .volatile_reg = bq24257_is_volatile_reg,
131};
132
133static const struct reg_field bq24257_reg_fields[] = {
134 /* REG 1 */
135 [F_WD_FAULT] = REG_FIELD(BQ24257_REG_1, 7, 7),
136 [F_WD_EN] = REG_FIELD(BQ24257_REG_1, 6, 6),
137 [F_STAT] = REG_FIELD(BQ24257_REG_1, 4, 5),
138 [F_FAULT] = REG_FIELD(BQ24257_REG_1, 0, 3),
139 /* REG 2 */
140 [F_RESET] = REG_FIELD(BQ24257_REG_2, 7, 7),
141 [F_IILIMIT] = REG_FIELD(BQ24257_REG_2, 4, 6),
142 [F_EN_STAT] = REG_FIELD(BQ24257_REG_2, 3, 3),
143 [F_EN_TERM] = REG_FIELD(BQ24257_REG_2, 2, 2),
144 [F_CE] = REG_FIELD(BQ24257_REG_2, 1, 1),
145 [F_HZ_MODE] = REG_FIELD(BQ24257_REG_2, 0, 0),
146 /* REG 3 */
147 [F_VBAT] = REG_FIELD(BQ24257_REG_3, 2, 7),
148 [F_USB_DET] = REG_FIELD(BQ24257_REG_3, 0, 1),
149 /* REG 4 */
150 [F_ICHG] = REG_FIELD(BQ24257_REG_4, 3, 7),
151 [F_ITERM] = REG_FIELD(BQ24257_REG_4, 0, 2),
152 /* REG 5 */
153 [F_LOOP_STATUS] = REG_FIELD(BQ24257_REG_5, 6, 7),
154 [F_LOW_CHG] = REG_FIELD(BQ24257_REG_5, 5, 5),
155 [F_DPDM_EN] = REG_FIELD(BQ24257_REG_5, 4, 4),
156 [F_CE_STATUS] = REG_FIELD(BQ24257_REG_5, 3, 3),
157 [F_VINDPM] = REG_FIELD(BQ24257_REG_5, 0, 2),
158 /* REG 6 */
159 [F_X2_TMR_EN] = REG_FIELD(BQ24257_REG_6, 7, 7),
160 [F_TMR] = REG_FIELD(BQ24257_REG_6, 5, 6),
161 [F_SYSOFF] = REG_FIELD(BQ24257_REG_6, 4, 4),
7ef62365 162 [F_TS_EN] = REG_FIELD(BQ24257_REG_6, 3, 3),
2219a935
LP		 163 [F_TS_STAT] = REG_FIELD(BQ24257_REG_6, 0, 2),
164 /* REG 7 */
165 [F_VOVP] = REG_FIELD(BQ24257_REG_7, 5, 7),
166 [F_CLR_VDP] = REG_FIELD(BQ24257_REG_7, 4, 4),
167 [F_FORCE_BATDET] = REG_FIELD(BQ24257_REG_7, 3, 3),
168 [F_FORCE_PTM] = REG_FIELD(BQ24257_REG_7, 2, 2)
169};
170
171static const u32 bq24257_vbat_map[] = {
172 3500000, 3520000, 3540000, 3560000, 3580000, 3600000, 3620000, 3640000,
173 3660000, 3680000, 3700000, 3720000, 3740000, 3760000, 3780000, 3800000,
174 3820000, 3840000, 3860000, 3880000, 3900000, 3920000, 3940000, 3960000,
175 3980000, 4000000, 4020000, 4040000, 4060000, 4080000, 4100000, 4120000,
176 4140000, 4160000, 4180000, 4200000, 4220000, 4240000, 4260000, 4280000,
177 4300000, 4320000, 4340000, 4360000, 4380000, 4400000, 4420000, 4440000
178};
179
180#define BQ24257_VBAT_MAP_SIZE ARRAY_SIZE(bq24257_vbat_map)
181
182static const u32 bq24257_ichg_map[] = {
183 500000, 550000, 600000, 650000, 700000, 750000, 800000, 850000, 900000,
184 950000, 1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000,
185 1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
186 1750000, 1800000, 1850000, 1900000, 1950000, 2000000
187};
188
189#define BQ24257_ICHG_MAP_SIZE ARRAY_SIZE(bq24257_ichg_map)
190
191static const u32 bq24257_iterm_map[] = {
192 50000, 75000, 100000, 125000, 150000, 175000, 200000, 225000
193};
194
195#define BQ24257_ITERM_MAP_SIZE ARRAY_SIZE(bq24257_iterm_map)
196
eb9fbcc6
AD		 197static const u32 bq24257_iilimit_map[] = {
198 100000, 150000, 500000, 900000, 1500000, 2000000
199};
200
201#define BQ24257_IILIMIT_MAP_SIZE ARRAY_SIZE(bq24257_iilimit_map)
202
2219a935
LP		 203static int bq24257_field_read(struct bq24257_device *bq,
204 enum bq24257_fields field_id)
205{
206 int ret;
207 int val;
208
209 ret = regmap_field_read(bq->rmap_fields[field_id], &val);
210 if (ret < 0)
211 return ret;
212
213 return val;
214}
215
216static int bq24257_field_write(struct bq24257_device *bq,
217 enum bq24257_fields field_id, u8 val)
218{
219 return regmap_field_write(bq->rmap_fields[field_id], val);
220}
221
222static u8 bq24257_find_idx(u32 value, const u32 *map, u8 map_size)
223{
224 u8 idx;
225
226 for (idx = 1; idx < map_size; idx++)
227 if (value < map[idx])
228 break;
229
230 return idx - 1;
231}
232
233enum bq24257_status {
234 STATUS_READY,
235 STATUS_CHARGE_IN_PROGRESS,
236 STATUS_CHARGE_DONE,
237 STATUS_FAULT,
238};
239
240enum bq24257_fault {
241 FAULT_NORMAL,
242 FAULT_INPUT_OVP,
243 FAULT_INPUT_UVLO,
244 FAULT_SLEEP,
245 FAULT_BAT_TS,
246 FAULT_BAT_OVP,
247 FAULT_TS,
248 FAULT_TIMER,
249 FAULT_NO_BAT,
250 FAULT_ISET,
251 FAULT_INPUT_LDO_LOW,
252};
253
254static int bq24257_power_supply_get_property(struct power_supply *psy,
255 enum power_supply_property psp,
256 union power_supply_propval *val)
257{
258 struct bq24257_device *bq = power_supply_get_drvdata(psy);
259 struct bq24257_state state;
260
261 mutex_lock(&bq->lock);
262 state = bq->state;
263 mutex_unlock(&bq->lock);
264
265 switch (psp) {
266 case POWER_SUPPLY_PROP_STATUS:
267 if (!state.power_good)
268 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
269 else if (state.status == STATUS_READY)
270 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
271 else if (state.status == STATUS_CHARGE_IN_PROGRESS)
272 val->intval = POWER_SUPPLY_STATUS_CHARGING;
273 else if (state.status == STATUS_CHARGE_DONE)
274 val->intval = POWER_SUPPLY_STATUS_FULL;
275 else
276 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
277 break;
278
279 case POWER_SUPPLY_PROP_MANUFACTURER:
280 val->strval = BQ24257_MANUFACTURER;
281 break;
282
bf02dca9
AD		 283 case POWER_SUPPLY_PROP_MODEL_NAME:
284 val->strval = bq2425x_chip_name[bq->chip];
285 break;
286
2219a935
LP		 287 case POWER_SUPPLY_PROP_ONLINE:
288 val->intval = state.power_good;
289 break;
290
291 case POWER_SUPPLY_PROP_HEALTH:
292 switch (state.fault) {
293 case FAULT_NORMAL:
294 val->intval = POWER_SUPPLY_HEALTH_GOOD;
295 break;
296
297 case FAULT_INPUT_OVP:
298 case FAULT_BAT_OVP:
299 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
300 break;
301
302 case FAULT_TS:
303 case FAULT_BAT_TS:
304 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
305 break;
306
307 case FAULT_TIMER:
308 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
309 break;
310
311 default:
312 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
313 break;
314 }
315
316 break;
317
318 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
319 val->intval = bq24257_ichg_map[bq->init_data.ichg];
320 break;
321
322 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
323 val->intval = bq24257_ichg_map[BQ24257_ICHG_MAP_SIZE - 1];
324 break;
325
326 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
327 val->intval = bq24257_vbat_map[bq->init_data.vbat];
328 break;
329
330 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
331 val->intval = bq24257_vbat_map[BQ24257_VBAT_MAP_SIZE - 1];
332 break;
333
334 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
335 val->intval = bq24257_iterm_map[bq->init_data.iterm];
336 break;
337
338 default:
339 return -EINVAL;
340 }
341
342 return 0;
343}
344
345static int bq24257_get_chip_state(struct bq24257_device *bq,
346 struct bq24257_state *state)
347{
348 int ret;
349
350 ret = bq24257_field_read(bq, F_STAT);
351 if (ret < 0)
352 return ret;
353
354 state->status = ret;
355
356 ret = bq24257_field_read(bq, F_FAULT);
357 if (ret < 0)
358 return ret;
359
360 state->fault = ret;
361
362 state->power_good = !gpiod_get_value_cansleep(bq->pg);
363
364 return 0;
365}
366
367static bool bq24257_state_changed(struct bq24257_device *bq,
368 struct bq24257_state *new_state)
369{
370 int ret;
371
372 mutex_lock(&bq->lock);
373 ret = (bq->state.status != new_state->status ||
374 bq->state.fault != new_state->fault ||
375 bq->state.power_good != new_state->power_good);
376 mutex_unlock(&bq->lock);
377
378 return ret;
379}
380
381enum bq24257_loop_status {
382 LOOP_STATUS_NONE,
383 LOOP_STATUS_IN_DPM,
384 LOOP_STATUS_IN_CURRENT_LIMIT,
385 LOOP_STATUS_THERMAL,
386};
387
388enum bq24257_in_ilimit {
389 IILIMIT_100,
390 IILIMIT_150,
391 IILIMIT_500,
392 IILIMIT_900,
393 IILIMIT_1500,
394 IILIMIT_2000,
395 IILIMIT_EXT,
396 IILIMIT_NONE,
397};
398
399enum bq24257_port_type {
400 PORT_TYPE_DCP, /* Dedicated Charging Port */
401 PORT_TYPE_CDP, /* Charging Downstream Port */
402 PORT_TYPE_SDP, /* Standard Downstream Port */
403 PORT_TYPE_NON_STANDARD,
404};
405
406enum bq24257_safety_timer {
407 SAFETY_TIMER_45,
408 SAFETY_TIMER_360,
409 SAFETY_TIMER_540,
410 SAFETY_TIMER_NONE,
411};
412
413static int bq24257_iilimit_autoset(struct bq24257_device *bq)
414{
415 int loop_status;
416 int iilimit;
417 int port_type;
418 int ret;
419 const u8 new_iilimit[] = {
420 [PORT_TYPE_DCP] = IILIMIT_2000,
421 [PORT_TYPE_CDP] = IILIMIT_2000,
422 [PORT_TYPE_SDP] = IILIMIT_500,
423 [PORT_TYPE_NON_STANDARD] = IILIMIT_500
424 };
425
426 ret = bq24257_field_read(bq, F_LOOP_STATUS);
427 if (ret < 0)
428 goto error;
429
430 loop_status = ret;
431
432 ret = bq24257_field_read(bq, F_IILIMIT);
433 if (ret < 0)
434 goto error;
435
436 iilimit = ret;
437
438 /*
439 * All USB ports should be able to handle 500mA. If not, DPM will lower
440 * the charging current to accommodate the power source. No need to set
441 * a lower IILIMIT value.
442 */
443 if (loop_status == LOOP_STATUS_IN_DPM && iilimit == IILIMIT_500)
444 return 0;
445
446 ret = bq24257_field_read(bq, F_USB_DET);
447 if (ret < 0)
448 goto error;
449
450 port_type = ret;
451
452 ret = bq24257_field_write(bq, F_IILIMIT, new_iilimit[port_type]);
453 if (ret < 0)
454 goto error;
455
456 ret = bq24257_field_write(bq, F_TMR, SAFETY_TIMER_360);
457 if (ret < 0)
458 goto error;
459
460 ret = bq24257_field_write(bq, F_CLR_VDP, 1);
461 if (ret < 0)
462 goto error;
463
464 dev_dbg(bq->dev, "port/loop = %d/%d -> iilimit = %d\n",
465 port_type, loop_status, new_iilimit[port_type]);
466
467 return 0;
468
469error:
470 dev_err(bq->dev, "%s: Error communicating with the chip.\n", __func__);
471 return ret;
472}
473
474static void bq24257_iilimit_setup_work(struct work_struct *work)
475{
476 struct bq24257_device *bq = container_of(work, struct bq24257_device,
477 iilimit_setup_work.work);
478
479 bq24257_iilimit_autoset(bq);
480}
481
482static void bq24257_handle_state_change(struct bq24257_device *bq,
483 struct bq24257_state *new_state)
484{
485 int ret;
486 struct bq24257_state old_state;
2219a935
LP		 487
488 mutex_lock(&bq->lock);
489 old_state = bq->state;
490 mutex_unlock(&bq->lock);
491
eb9fbcc6
AD		 492 /*
493 * Handle BQ2425x state changes observing whether the D+/D- based input
494 * current limit autoset functionality is enabled.
495 */
9b1cf1e4
AD		 496 if (!new_state->power_good) {
497 dev_dbg(bq->dev, "Power removed\n");
eb9fbcc6
AD		 498 if (bq->iilimit_autoset_enable) {
499 cancel_delayed_work_sync(&bq->iilimit_setup_work);
500
501 /* activate D+/D- port detection algorithm */
502 ret = bq24257_field_write(bq, F_DPDM_EN, 1);
503 if (ret < 0)
504 goto error;
505
506 /* reset input current limit */
507 ret = bq24257_field_write(bq, F_IILIMIT,
508 bq->init_data.iilimit);
509 if (ret < 0)
510 goto error;
511 }
9b1cf1e4
AD		 512 } else if (!old_state.power_good) {
513 dev_dbg(bq->dev, "Power inserted\n");
514
eb9fbcc6
AD		 515 if (bq->iilimit_autoset_enable)
516 /* configure input current limit */
517 schedule_delayed_work(&bq->iilimit_setup_work,
2219a935 518 msecs_to_jiffies(BQ24257_ILIM_SET_DELAY));
9b1cf1e4
AD		 519 } else if (new_state->fault == FAULT_NO_BAT) {
520 dev_warn(bq->dev, "Battery removed\n");
521 } else if (new_state->fault == FAULT_TIMER) {
522 dev_err(bq->dev, "Safety timer expired! Battery dead?\n");
2219a935
LP		 523 }
524
525 return;
526
527error:
528 dev_err(bq->dev, "%s: Error communicating with the chip.\n", __func__);
529}
530
531static irqreturn_t bq24257_irq_handler_thread(int irq, void *private)
532{
533 int ret;
534 struct bq24257_device *bq = private;
535 struct bq24257_state state;
536
537 ret = bq24257_get_chip_state(bq, &state);
538 if (ret < 0)
539 return IRQ_HANDLED;
540
541 if (!bq24257_state_changed(bq, &state))
542 return IRQ_HANDLED;
543
544 dev_dbg(bq->dev, "irq(state changed): status/fault/pg = %d/%d/%d\n",
545 state.status, state.fault, state.power_good);
546
547 bq24257_handle_state_change(bq, &state);
548
549 mutex_lock(&bq->lock);
550 bq->state = state;
551 mutex_unlock(&bq->lock);
552
553 power_supply_changed(bq->charger);
554
555 return IRQ_HANDLED;
556}
557
558static int bq24257_hw_init(struct bq24257_device *bq)
559{
560 int ret;
561 int i;
562 struct bq24257_state state;
563
564 const struct {
565 int field;
566 u32 value;
567 } init_data[] = {
568 {F_ICHG, bq->init_data.ichg},
569 {F_VBAT, bq->init_data.vbat},
570 {F_ITERM, bq->init_data.iterm}
571 };
572
573 /*
574 * Disable the watchdog timer to prevent the IC from going back to
575 * default settings after 50 seconds of I2C inactivity.
576 */
577 ret = bq24257_field_write(bq, F_WD_EN, 0);
578 if (ret < 0)
579 return ret;
580
581 /* configure the charge currents and voltages */
582 for (i = 0; i < ARRAY_SIZE(init_data); i++) {
583 ret = bq24257_field_write(bq, init_data[i].field,
584 init_data[i].value);
585 if (ret < 0)
586 return ret;
587 }
588
589 ret = bq24257_get_chip_state(bq, &state);
590 if (ret < 0)
591 return ret;
592
593 mutex_lock(&bq->lock);
594 bq->state = state;
595 mutex_unlock(&bq->lock);
596
eb9fbcc6
AD		 597 if (!bq->iilimit_autoset_enable) {
598 dev_dbg(bq->dev, "manually setting iilimit = %u\n",
599 bq->init_data.iilimit);
600
601 /* program fixed input current limit */
602 ret = bq24257_field_write(bq, F_IILIMIT,
603 bq->init_data.iilimit);
604 if (ret < 0)
605 return ret;
606 } else if (!state.power_good)
2219a935
LP		 607 /* activate D+/D- detection algorithm */
608 ret = bq24257_field_write(bq, F_DPDM_EN, 1);
609 else if (state.fault != FAULT_NO_BAT)
610 ret = bq24257_iilimit_autoset(bq);
611
612 return ret;
613}
614
615static enum power_supply_property bq24257_power_supply_props[] = {
616 POWER_SUPPLY_PROP_MANUFACTURER,
bf02dca9 617 POWER_SUPPLY_PROP_MODEL_NAME,
2219a935
LP		 618 POWER_SUPPLY_PROP_STATUS,
619 POWER_SUPPLY_PROP_ONLINE,
620 POWER_SUPPLY_PROP_HEALTH,
621 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
622 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
623 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
624 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
625 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
626};
627
628static char *bq24257_charger_supplied_to[] = {
629 "main-battery",
630};
631
632static const struct power_supply_desc bq24257_power_supply_desc = {
633 .name = "bq24257-charger",
634 .type = POWER_SUPPLY_TYPE_USB,
635 .properties = bq24257_power_supply_props,
636 .num_properties = ARRAY_SIZE(bq24257_power_supply_props),
637 .get_property = bq24257_power_supply_get_property,
638};
639
640static int bq24257_power_supply_init(struct bq24257_device *bq)
641{
642 struct power_supply_config psy_cfg = { .drv_data = bq, };
643
644 psy_cfg.supplied_to = bq24257_charger_supplied_to;
645 psy_cfg.num_supplicants = ARRAY_SIZE(bq24257_charger_supplied_to);
646
dfc60252
AD		 647 bq->charger = devm_power_supply_register(bq->dev,
648 &bq24257_power_supply_desc,
649 &psy_cfg);
650
3b84b8ef 651 return PTR_ERR_OR_ZERO(bq->charger);
2219a935
LP		 652}
653
2219a935
LP		 654static int bq24257_pg_gpio_probe(struct bq24257_device *bq)
655{
e31cd782 656 bq->pg = devm_gpiod_get_index(bq->dev, BQ24257_PG_GPIO, 0, GPIOD_IN);
2219a935
LP		 657 if (IS_ERR(bq->pg)) {
658 dev_err(bq->dev, "could not probe PG pin\n");
659 return PTR_ERR(bq->pg);
660 }
661
e31cd782 662 return 0;
2219a935
LP		 663}
664
665static int bq24257_fw_probe(struct bq24257_device *bq)
666{
667 int ret;
668 u32 property;
669
eb9fbcc6 670 /* Required properties */
2219a935
LP		 671 ret = device_property_read_u32(bq->dev, "ti,charge-current", &property);
672 if (ret < 0)
673 return ret;
674
675 bq->init_data.ichg = bq24257_find_idx(property, bq24257_ichg_map,
676 BQ24257_ICHG_MAP_SIZE);
677
678 ret = device_property_read_u32(bq->dev, "ti,battery-regulation-voltage",
679 &property);
680 if (ret < 0)
681 return ret;
682
683 bq->init_data.vbat = bq24257_find_idx(property, bq24257_vbat_map,
684 BQ24257_VBAT_MAP_SIZE);
685
686 ret = device_property_read_u32(bq->dev, "ti,termination-current",
687 &property);
688 if (ret < 0)
689 return ret;
690
691 bq->init_data.iterm = bq24257_find_idx(property, bq24257_iterm_map,
692 BQ24257_ITERM_MAP_SIZE);
693
eb9fbcc6
AD		 694 /* Optional properties. If not provided use reasonable default. */
695 ret = device_property_read_u32(bq->dev, "ti,current-limit",
696 &property);
697 if (ret < 0) {
698 bq->iilimit_autoset_enable = true;
699
700 /*
701 * Explicitly set a default value which will be needed for
702 * devices that don't support the automatic setting of the input
703 * current limit through the charger type detection mechanism.
704 */
705 bq->init_data.iilimit = IILIMIT_500;
706 } else
707 bq->init_data.iilimit =
708 bq24257_find_idx(property,
709 bq24257_iilimit_map,
710 BQ24257_IILIMIT_MAP_SIZE);
711
2219a935
LP		 712 return 0;
713}
714
715static int bq24257_probe(struct i2c_client *client,
716 const struct i2c_device_id *id)
717{
718 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
719 struct device *dev = &client->dev;
bf02dca9 720 const struct acpi_device_id *acpi_id;
2219a935
LP		 721 struct bq24257_device *bq;
722 int ret;
723 int i;
724
725 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
726 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
727 return -ENODEV;
728 }
729
730 bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
731 if (!bq)
732 return -ENOMEM;
733
734 bq->client = client;
735 bq->dev = dev;
736
bf02dca9
AD		 737 if (ACPI_HANDLE(dev)) {
738 acpi_id = acpi_match_device(dev->driver->acpi_match_table,
739 &client->dev);
740 if (!acpi_id) {
741 dev_err(dev, "Failed to match ACPI device\n");
742 return -ENODEV;
743 }
744 bq->chip = (enum bq2425x_chip)acpi_id->driver_data;
745 } else {
746 bq->chip = (enum bq2425x_chip)id->driver_data;
747 }
748
2219a935
LP		 749 mutex_init(&bq->lock);
750
751 bq->rmap = devm_regmap_init_i2c(client, &bq24257_regmap_config);
752 if (IS_ERR(bq->rmap)) {
753 dev_err(dev, "failed to allocate register map\n");
754 return PTR_ERR(bq->rmap);
755 }
756
757 for (i = 0; i < ARRAY_SIZE(bq24257_reg_fields); i++) {
758 const struct reg_field *reg_fields = bq24257_reg_fields;
759
760 bq->rmap_fields[i] = devm_regmap_field_alloc(dev, bq->rmap,
761 reg_fields[i]);
762 if (IS_ERR(bq->rmap_fields[i])) {
763 dev_err(dev, "cannot allocate regmap field\n");
764 return PTR_ERR(bq->rmap_fields[i]);
765 }
766 }
767
768 i2c_set_clientdata(client, bq);
769
2219a935
LP		 770 if (!dev->platform_data) {
771 ret = bq24257_fw_probe(bq);
772 if (ret < 0) {
773 dev_err(dev, "Cannot read device properties.\n");
774 return ret;
775 }
776 } else {
777 return -ENODEV;
778 }
779
eb9fbcc6
AD		 780 /*
781 * The BQ24250 doesn't support the D+/D- based charger type detection
782 * used for the automatic setting of the input current limit setting so
783 * explicitly disable that feature.
784 */
785 if (bq->chip == BQ24250)
786 bq->iilimit_autoset_enable = false;
787
788 if (bq->iilimit_autoset_enable)
789 INIT_DELAYED_WORK(&bq->iilimit_setup_work,
790 bq24257_iilimit_setup_work);
791
2219a935
LP		 792 /* we can only check Power Good status by probing the PG pin */
793 ret = bq24257_pg_gpio_probe(bq);
794 if (ret < 0)
795 return ret;
796
797 /* reset all registers to defaults */
798 ret = bq24257_field_write(bq, F_RESET, 1);
799 if (ret < 0)
800 return ret;
801
802 /*
803 * Put the RESET bit back to 0, in cache. For some reason the HW always
804 * returns 1 on this bit, so this is the only way to avoid resetting the
805 * chip every time we update another field in this register.
806 */
807 ret = bq24257_field_write(bq, F_RESET, 0);
808 if (ret < 0)
809 return ret;
810
811 ret = bq24257_hw_init(bq);
812 if (ret < 0) {
813 dev_err(dev, "Cannot initialize the chip.\n");
814 return ret;
815 }
816
2219a935
LP		 817 ret = devm_request_threaded_irq(dev, client->irq, NULL,
818 bq24257_irq_handler_thread,
819 IRQF_TRIGGER_FALLING |
820 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
bf02dca9 821 bq2425x_chip_name[bq->chip], bq);
5ff8c89d
AD		 822 if (ret) {
823 dev_err(dev, "Failed to request IRQ #%d\n", client->irq);
2219a935 824 return ret;
5ff8c89d 825 }
2219a935
LP		 826
827 ret = bq24257_power_supply_init(bq);
828 if (ret < 0)
829 dev_err(dev, "Failed to register power supply\n");
830
831 return ret;
832}
833
834static int bq24257_remove(struct i2c_client *client)
835{
836 struct bq24257_device *bq = i2c_get_clientdata(client);
837
eb9fbcc6
AD		 838 if (bq->iilimit_autoset_enable)
839 cancel_delayed_work_sync(&bq->iilimit_setup_work);
2219a935 840
2219a935
LP		 841 bq24257_field_write(bq, F_RESET, 1); /* reset to defaults */
842
843 return 0;
844}
845
846#ifdef CONFIG_PM_SLEEP
847static int bq24257_suspend(struct device *dev)
848{
849 struct bq24257_device *bq = dev_get_drvdata(dev);
850 int ret = 0;
851
eb9fbcc6
AD		 852 if (bq->iilimit_autoset_enable)
853 cancel_delayed_work_sync(&bq->iilimit_setup_work);
2219a935
LP		 854
855 /* reset all registers to default (and activate standalone mode) */
856 ret = bq24257_field_write(bq, F_RESET, 1);
857 if (ret < 0)
858 dev_err(bq->dev, "Cannot reset chip to standalone mode.\n");
859
860 return ret;
861}
862
863static int bq24257_resume(struct device *dev)
864{
865 int ret;
866 struct bq24257_device *bq = dev_get_drvdata(dev);
867
868 ret = regcache_drop_region(bq->rmap, BQ24257_REG_1, BQ24257_REG_7);
869 if (ret < 0)
870 return ret;
871
872 ret = bq24257_field_write(bq, F_RESET, 0);
873 if (ret < 0)
874 return ret;
875
876 ret = bq24257_hw_init(bq);
877 if (ret < 0) {
878 dev_err(bq->dev, "Cannot init chip after resume.\n");
879 return ret;
880 }
881
882 /* signal userspace, maybe state changed while suspended */
883 power_supply_changed(bq->charger);
884
885 return 0;
886}
887#endif
888
889static const struct dev_pm_ops bq24257_pm = {
890 SET_SYSTEM_SLEEP_PM_OPS(bq24257_suspend, bq24257_resume)
891};
892
893static const struct i2c_device_id bq24257_i2c_ids[] = {
bf02dca9
AD		 894 { "bq24250", BQ24250 },
895 { "bq24251", BQ24251 },
896 { "bq24257", BQ24257 },
2219a935
LP		 897 {},
898};
899MODULE_DEVICE_TABLE(i2c, bq24257_i2c_ids);
900
901static const struct of_device_id bq24257_of_match[] = {
bf02dca9
AD		 902 { .compatible = "ti,bq24250", },
903 { .compatible = "ti,bq24251", },
2219a935
LP		 904 { .compatible = "ti,bq24257", },
905 { },
906};
907MODULE_DEVICE_TABLE(of, bq24257_of_match);
908
909static const struct acpi_device_id bq24257_acpi_match[] = {
bf02dca9
AD		 910 { "BQ242500", BQ24250 },
911 { "BQ242510", BQ24251 },
912 { "BQ242570", BQ24257 },
2219a935
LP		 913 {},
914};
915MODULE_DEVICE_TABLE(acpi, bq24257_acpi_match);
916
917static struct i2c_driver bq24257_driver = {
918 .driver = {
919 .name = "bq24257-charger",
920 .of_match_table = of_match_ptr(bq24257_of_match),
921 .acpi_match_table = ACPI_PTR(bq24257_acpi_match),
922 .pm = &bq24257_pm,
923 },
924 .probe = bq24257_probe,
925 .remove = bq24257_remove,
926 .id_table = bq24257_i2c_ids,
927};
928module_i2c_driver(bq24257_driver);
929
930MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>");
931MODULE_DESCRIPTION("bq24257 charger driver");
932MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)