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