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