?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[drm/drm-misc.git] / drivers / power / supply / bq25890_charger.c
blob2f5ceaf00b94cd9e5eab40909bcff247035feb13
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * TI BQ25890 charger driver
4 *
5 * Copyright (C) 2015 Intel Corporation
6 */
7
8 #include <linux/module.h>
9 #include <linux/i2c.h>
10 #include <linux/power_supply.h>
11 #include <linux/power/bq25890_charger.h>
12 #include <linux/regmap.h>
13 #include <linux/regulator/driver.h>
14 #include <linux/types.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/interrupt.h>
17 #include <linux/delay.h>
18 #include <linux/usb/phy.h>
19
20 #include <linux/acpi.h>
21 #include <linux/of.h>
22
23 #define BQ25890_MANUFACTURER "Texas Instruments"
24 #define BQ25890_IRQ_PIN "bq25890_irq"
25
26 #define BQ25890_ID 3
27 #define BQ25895_ID 7
28 #define BQ25896_ID 0
29
30 #define PUMP_EXPRESS_START_DELAY (5 * HZ)
31 #define PUMP_EXPRESS_MAX_TRIES 6
32 #define PUMP_EXPRESS_VBUS_MARGIN_uV 1000000
33
34 enum bq25890_chip_version {
35 BQ25890,
36 BQ25892,
37 BQ25895,
38 BQ25896,
39 };
40
41 static const char *const bq25890_chip_name[] = {
42 "BQ25890",
43 "BQ25892",
44 "BQ25895",
45 "BQ25896",
46 };
47
48 enum bq25890_fields {
49 F_EN_HIZ, F_EN_ILIM, F_IINLIM, /* Reg00 */
50 F_BHOT, F_BCOLD, F_VINDPM_OFS, /* Reg01 */
51 F_CONV_START, F_CONV_RATE, F_BOOSTF, F_ICO_EN,
52 F_HVDCP_EN, F_MAXC_EN, F_FORCE_DPM, F_AUTO_DPDM_EN, /* Reg02 */
53 F_BAT_LOAD_EN, F_WD_RST, F_OTG_CFG, F_CHG_CFG, F_SYSVMIN,
54 F_MIN_VBAT_SEL, /* Reg03 */
55 F_PUMPX_EN, F_ICHG, /* Reg04 */
56 F_IPRECHG, F_ITERM, /* Reg05 */
57 F_VREG, F_BATLOWV, F_VRECHG, /* Reg06 */
58 F_TERM_EN, F_STAT_DIS, F_WD, F_TMR_EN, F_CHG_TMR,
59 F_JEITA_ISET, /* Reg07 */
60 F_BATCMP, F_VCLAMP, F_TREG, /* Reg08 */
61 F_FORCE_ICO, F_TMR2X_EN, F_BATFET_DIS, F_JEITA_VSET,
62 F_BATFET_DLY, F_BATFET_RST_EN, F_PUMPX_UP, F_PUMPX_DN, /* Reg09 */
63 F_BOOSTV, F_PFM_OTG_DIS, F_BOOSTI, /* Reg0A */
64 F_VBUS_STAT, F_CHG_STAT, F_PG_STAT, F_SDP_STAT, F_0B_RSVD,
65 F_VSYS_STAT, /* Reg0B */
66 F_WD_FAULT, F_BOOST_FAULT, F_CHG_FAULT, F_BAT_FAULT,
67 F_NTC_FAULT, /* Reg0C */
68 F_FORCE_VINDPM, F_VINDPM, /* Reg0D */
69 F_THERM_STAT, F_BATV, /* Reg0E */
70 F_SYSV, /* Reg0F */
71 F_TSPCT, /* Reg10 */
72 F_VBUS_GD, F_VBUSV, /* Reg11 */
73 F_ICHGR, /* Reg12 */
74 F_VDPM_STAT, F_IDPM_STAT, F_IDPM_LIM, /* Reg13 */
75 F_REG_RST, F_ICO_OPTIMIZED, F_PN, F_TS_PROFILE, F_DEV_REV, /* Reg14 */
76
77 F_MAX_FIELDS
78 };
79
80 /* initial field values, converted to register values */
81 struct bq25890_init_data {
82 u8 ichg; /* charge current */
83 u8 vreg; /* regulation voltage */
84 u8 iterm; /* termination current */
85 u8 iprechg; /* precharge current */
86 u8 sysvmin; /* minimum system voltage limit */
87 u8 boostv; /* boost regulation voltage */
88 u8 boosti; /* boost current limit */
89 u8 boostf; /* boost frequency */
90 u8 ilim_en; /* enable ILIM pin */
91 u8 treg; /* thermal regulation threshold */
92 u8 rbatcomp; /* IBAT sense resistor value */
93 u8 vclamp; /* IBAT compensation voltage limit */
94 };
95
96 struct bq25890_state {
97 u8 online;
98 u8 hiz;
99 u8 chrg_status;
100 u8 chrg_fault;
101 u8 vsys_status;
102 u8 boost_fault;
103 u8 bat_fault;
104 u8 ntc_fault;
105 };
106
107 struct bq25890_device {
108 struct i2c_client *client;
109 struct device *dev;
110 struct power_supply *charger;
111 struct power_supply *secondary_chrg;
112 struct power_supply_desc desc;
113 char name[28]; /* "bq25890-charger-%d" */
114 int id;
115
116 struct usb_phy *usb_phy;
117 struct notifier_block usb_nb;
118 struct work_struct usb_work;
119 struct delayed_work pump_express_work;
120 unsigned long usb_event;
121
122 struct regmap *rmap;
123 struct regmap_field *rmap_fields[F_MAX_FIELDS];
124
125 bool skip_reset;
126 bool read_back_init_data;
127 bool force_hiz;
128 u32 pump_express_vbus_max;
129 u32 iinlim_percentage;
130 enum bq25890_chip_version chip_version;
131 struct bq25890_init_data init_data;
132 struct bq25890_state state;
133
134 struct mutex lock; /* protect state data */
135 };
136
137 static DEFINE_IDR(bq25890_id);
138 static DEFINE_MUTEX(bq25890_id_mutex);
139
140 static const struct regmap_range bq25890_readonly_reg_ranges[] = {
141 regmap_reg_range(0x0b, 0x0c),
142 regmap_reg_range(0x0e, 0x13),
143 };
144
145 static const struct regmap_access_table bq25890_writeable_regs = {
146 .no_ranges = bq25890_readonly_reg_ranges,
147 .n_no_ranges = ARRAY_SIZE(bq25890_readonly_reg_ranges),
148 };
149
150 static const struct regmap_range bq25890_volatile_reg_ranges[] = {
151 regmap_reg_range(0x00, 0x00),
152 regmap_reg_range(0x02, 0x02),
153 regmap_reg_range(0x09, 0x09),
154 regmap_reg_range(0x0b, 0x14),
155 };
156
157 static const struct regmap_access_table bq25890_volatile_regs = {
158 .yes_ranges = bq25890_volatile_reg_ranges,
159 .n_yes_ranges = ARRAY_SIZE(bq25890_volatile_reg_ranges),
160 };
161
162 static const struct regmap_config bq25890_regmap_config = {
163 .reg_bits = 8,
164 .val_bits = 8,
165
166 .max_register = 0x14,
167 .cache_type = REGCACHE_RBTREE,
168
169 .wr_table = &bq25890_writeable_regs,
170 .volatile_table = &bq25890_volatile_regs,
171 };
172
173 static const struct reg_field bq25890_reg_fields[] = {
174 /* REG00 */
175 [F_EN_HIZ] = REG_FIELD(0x00, 7, 7),
176 [F_EN_ILIM] = REG_FIELD(0x00, 6, 6),
177 [F_IINLIM] = REG_FIELD(0x00, 0, 5),
178 /* REG01 */
179 [F_BHOT] = REG_FIELD(0x01, 6, 7),
180 [F_BCOLD] = REG_FIELD(0x01, 5, 5),
181 [F_VINDPM_OFS] = REG_FIELD(0x01, 0, 4),
182 /* REG02 */
183 [F_CONV_START] = REG_FIELD(0x02, 7, 7),
184 [F_CONV_RATE] = REG_FIELD(0x02, 6, 6),
185 [F_BOOSTF] = REG_FIELD(0x02, 5, 5),
186 [F_ICO_EN] = REG_FIELD(0x02, 4, 4),
187 [F_HVDCP_EN] = REG_FIELD(0x02, 3, 3), // reserved on BQ25896
188 [F_MAXC_EN] = REG_FIELD(0x02, 2, 2), // reserved on BQ25896
189 [F_FORCE_DPM] = REG_FIELD(0x02, 1, 1),
190 [F_AUTO_DPDM_EN] = REG_FIELD(0x02, 0, 0),
191 /* REG03 */
192 [F_BAT_LOAD_EN] = REG_FIELD(0x03, 7, 7),
193 [F_WD_RST] = REG_FIELD(0x03, 6, 6),
194 [F_OTG_CFG] = REG_FIELD(0x03, 5, 5),
195 [F_CHG_CFG] = REG_FIELD(0x03, 4, 4),
196 [F_SYSVMIN] = REG_FIELD(0x03, 1, 3),
197 [F_MIN_VBAT_SEL] = REG_FIELD(0x03, 0, 0), // BQ25896 only
198 /* REG04 */
199 [F_PUMPX_EN] = REG_FIELD(0x04, 7, 7),
200 [F_ICHG] = REG_FIELD(0x04, 0, 6),
201 /* REG05 */
202 [F_IPRECHG] = REG_FIELD(0x05, 4, 7),
203 [F_ITERM] = REG_FIELD(0x05, 0, 3),
204 /* REG06 */
205 [F_VREG] = REG_FIELD(0x06, 2, 7),
206 [F_BATLOWV] = REG_FIELD(0x06, 1, 1),
207 [F_VRECHG] = REG_FIELD(0x06, 0, 0),
208 /* REG07 */
209 [F_TERM_EN] = REG_FIELD(0x07, 7, 7),
210 [F_STAT_DIS] = REG_FIELD(0x07, 6, 6),
211 [F_WD] = REG_FIELD(0x07, 4, 5),
212 [F_TMR_EN] = REG_FIELD(0x07, 3, 3),
213 [F_CHG_TMR] = REG_FIELD(0x07, 1, 2),
214 [F_JEITA_ISET] = REG_FIELD(0x07, 0, 0), // reserved on BQ25895
215 /* REG08 */
216 [F_BATCMP] = REG_FIELD(0x08, 5, 7),
217 [F_VCLAMP] = REG_FIELD(0x08, 2, 4),
218 [F_TREG] = REG_FIELD(0x08, 0, 1),
219 /* REG09 */
220 [F_FORCE_ICO] = REG_FIELD(0x09, 7, 7),
221 [F_TMR2X_EN] = REG_FIELD(0x09, 6, 6),
222 [F_BATFET_DIS] = REG_FIELD(0x09, 5, 5),
223 [F_JEITA_VSET] = REG_FIELD(0x09, 4, 4), // reserved on BQ25895
224 [F_BATFET_DLY] = REG_FIELD(0x09, 3, 3),
225 [F_BATFET_RST_EN] = REG_FIELD(0x09, 2, 2),
226 [F_PUMPX_UP] = REG_FIELD(0x09, 1, 1),
227 [F_PUMPX_DN] = REG_FIELD(0x09, 0, 0),
228 /* REG0A */
229 [F_BOOSTV] = REG_FIELD(0x0A, 4, 7),
230 [F_BOOSTI] = REG_FIELD(0x0A, 0, 2), // reserved on BQ25895
231 [F_PFM_OTG_DIS] = REG_FIELD(0x0A, 3, 3), // BQ25896 only
232 /* REG0B */
233 [F_VBUS_STAT] = REG_FIELD(0x0B, 5, 7),
234 [F_CHG_STAT] = REG_FIELD(0x0B, 3, 4),
235 [F_PG_STAT] = REG_FIELD(0x0B, 2, 2),
236 [F_SDP_STAT] = REG_FIELD(0x0B, 1, 1), // reserved on BQ25896
237 [F_VSYS_STAT] = REG_FIELD(0x0B, 0, 0),
238 /* REG0C */
239 [F_WD_FAULT] = REG_FIELD(0x0C, 7, 7),
240 [F_BOOST_FAULT] = REG_FIELD(0x0C, 6, 6),
241 [F_CHG_FAULT] = REG_FIELD(0x0C, 4, 5),
242 [F_BAT_FAULT] = REG_FIELD(0x0C, 3, 3),
243 [F_NTC_FAULT] = REG_FIELD(0x0C, 0, 2),
244 /* REG0D */
245 [F_FORCE_VINDPM] = REG_FIELD(0x0D, 7, 7),
246 [F_VINDPM] = REG_FIELD(0x0D, 0, 6),
247 /* REG0E */
248 [F_THERM_STAT] = REG_FIELD(0x0E, 7, 7),
249 [F_BATV] = REG_FIELD(0x0E, 0, 6),
250 /* REG0F */
251 [F_SYSV] = REG_FIELD(0x0F, 0, 6),
252 /* REG10 */
253 [F_TSPCT] = REG_FIELD(0x10, 0, 6),
254 /* REG11 */
255 [F_VBUS_GD] = REG_FIELD(0x11, 7, 7),
256 [F_VBUSV] = REG_FIELD(0x11, 0, 6),
257 /* REG12 */
258 [F_ICHGR] = REG_FIELD(0x12, 0, 6),
259 /* REG13 */
260 [F_VDPM_STAT] = REG_FIELD(0x13, 7, 7),
261 [F_IDPM_STAT] = REG_FIELD(0x13, 6, 6),
262 [F_IDPM_LIM] = REG_FIELD(0x13, 0, 5),
263 /* REG14 */
264 [F_REG_RST] = REG_FIELD(0x14, 7, 7),
265 [F_ICO_OPTIMIZED] = REG_FIELD(0x14, 6, 6),
266 [F_PN] = REG_FIELD(0x14, 3, 5),
267 [F_TS_PROFILE] = REG_FIELD(0x14, 2, 2),
268 [F_DEV_REV] = REG_FIELD(0x14, 0, 1)
269 };
270
271 /*
272 * Most of the val -> idx conversions can be computed, given the minimum,
273 * maximum and the step between values. For the rest of conversions, we use
274 * lookup tables.
275 */
276 enum bq25890_table_ids {
277 /* range tables */
278 TBL_ICHG,
279 TBL_ITERM,
280 TBL_IINLIM,
281 TBL_VREG,
282 TBL_BOOSTV,
283 TBL_SYSVMIN,
284 TBL_VBUSV,
285 TBL_VBATCOMP,
286 TBL_RBATCOMP,
287
288 /* lookup tables */
289 TBL_TREG,
290 TBL_BOOSTI,
291 TBL_TSPCT,
292 };
293
294 /* Thermal Regulation Threshold lookup table, in degrees Celsius */
295 static const u32 bq25890_treg_tbl[] = { 60, 80, 100, 120 };
296
297 #define BQ25890_TREG_TBL_SIZE ARRAY_SIZE(bq25890_treg_tbl)
298
299 /* Boost mode current limit lookup table, in uA */
300 static const u32 bq25890_boosti_tbl[] = {
301 500000, 700000, 1100000, 1300000, 1600000, 1800000, 2100000, 2400000
302 };
303
304 #define BQ25890_BOOSTI_TBL_SIZE ARRAY_SIZE(bq25890_boosti_tbl)
305
306 /* NTC 10K temperature lookup table in tenths of a degree */
307 static const u32 bq25890_tspct_tbl[] = {
308 850, 840, 830, 820, 810, 800, 790, 780,
309 770, 760, 750, 740, 730, 720, 710, 700,
310 690, 685, 680, 675, 670, 660, 650, 645,
311 640, 630, 620, 615, 610, 600, 590, 585,
312 580, 570, 565, 560, 550, 540, 535, 530,
313 520, 515, 510, 500, 495, 490, 480, 475,
314 470, 460, 455, 450, 440, 435, 430, 425,
315 420, 410, 405, 400, 390, 385, 380, 370,
316 365, 360, 355, 350, 340, 335, 330, 320,
317 310, 305, 300, 290, 285, 280, 275, 270,
318 260, 250, 245, 240, 230, 225, 220, 210,
319 205, 200, 190, 180, 175, 170, 160, 150,
320 145, 140, 130, 120, 115, 110, 100, 90,
321 80, 70, 60, 50, 40, 30, 20, 10,
322 0, -10, -20, -30, -40, -60, -70, -80,
323 -90, -10, -120, -140, -150, -170, -190, -210,
324 };
325
326 #define BQ25890_TSPCT_TBL_SIZE ARRAY_SIZE(bq25890_tspct_tbl)
327
328 struct bq25890_range {
329 u32 min;
330 u32 max;
331 u32 step;
332 };
333
334 struct bq25890_lookup {
335 const u32 *tbl;
336 u32 size;
337 };
338
339 static const union {
340 struct bq25890_range rt;
341 struct bq25890_lookup lt;
342 } bq25890_tables[] = {
343 /* range tables */
344 /* TODO: BQ25896 has max ICHG 3008 mA */
345 [TBL_ICHG] = { .rt = {0, 5056000, 64000} }, /* uA */
346 [TBL_ITERM] = { .rt = {64000, 1024000, 64000} }, /* uA */
347 [TBL_IINLIM] = { .rt = {100000, 3250000, 50000} }, /* uA */
348 [TBL_VREG] = { .rt = {3840000, 4608000, 16000} }, /* uV */
349 [TBL_BOOSTV] = { .rt = {4550000, 5510000, 64000} }, /* uV */
350 [TBL_SYSVMIN] = { .rt = {3000000, 3700000, 100000} }, /* uV */
351 [TBL_VBUSV] = { .rt = {2600000, 15300000, 100000} }, /* uV */
352 [TBL_VBATCOMP] = { .rt = {0, 224000, 32000} }, /* uV */
353 [TBL_RBATCOMP] = { .rt = {0, 140000, 20000} }, /* uOhm */
354
355 /* lookup tables */
356 [TBL_TREG] = { .lt = {bq25890_treg_tbl, BQ25890_TREG_TBL_SIZE} },
357 [TBL_BOOSTI] = { .lt = {bq25890_boosti_tbl, BQ25890_BOOSTI_TBL_SIZE} },
358 [TBL_TSPCT] = { .lt = {bq25890_tspct_tbl, BQ25890_TSPCT_TBL_SIZE} }
359 };
360
361 static int bq25890_field_read(struct bq25890_device *bq,
362 enum bq25890_fields field_id)
363 {
364 int ret;
365 int val;
366
367 ret = regmap_field_read(bq->rmap_fields[field_id], &val);
368 if (ret < 0)
369 return ret;
370
371 return val;
372 }
373
374 static int bq25890_field_write(struct bq25890_device *bq,
375 enum bq25890_fields field_id, u8 val)
376 {
377 return regmap_field_write(bq->rmap_fields[field_id], val);
378 }
379
380 static u8 bq25890_find_idx(u32 value, enum bq25890_table_ids id)
381 {
382 u8 idx;
383
384 if (id >= TBL_TREG) {
385 const u32 *tbl = bq25890_tables[id].lt.tbl;
386 u32 tbl_size = bq25890_tables[id].lt.size;
387
388 for (idx = 1; idx < tbl_size && tbl[idx] <= value; idx++)
389 ;
390 } else {
391 const struct bq25890_range *rtbl = &bq25890_tables[id].rt;
392 u8 rtbl_size;
393
394 rtbl_size = (rtbl->max - rtbl->min) / rtbl->step + 1;
395
396 for (idx = 1;
397 idx < rtbl_size && (idx * rtbl->step + rtbl->min <= value);
398 idx++)
399 ;
400 }
401
402 return idx - 1;
403 }
404
405 static u32 bq25890_find_val(u8 idx, enum bq25890_table_ids id)
406 {
407 const struct bq25890_range *rtbl;
408
409 /* lookup table? */
410 if (id >= TBL_TREG)
411 return bq25890_tables[id].lt.tbl[idx];
412
413 /* range table */
414 rtbl = &bq25890_tables[id].rt;
415
416 return (rtbl->min + idx * rtbl->step);
417 }
418
419 enum bq25890_status {
420 STATUS_NOT_CHARGING,
421 STATUS_PRE_CHARGING,
422 STATUS_FAST_CHARGING,
423 STATUS_TERMINATION_DONE,
424 };
425
426 enum bq25890_chrg_fault {
427 CHRG_FAULT_NORMAL,
428 CHRG_FAULT_INPUT,
429 CHRG_FAULT_THERMAL_SHUTDOWN,
430 CHRG_FAULT_TIMER_EXPIRED,
431 };
432
433 enum bq25890_ntc_fault {
434 NTC_FAULT_NORMAL = 0,
435 NTC_FAULT_WARM = 2,
436 NTC_FAULT_COOL = 3,
437 NTC_FAULT_COLD = 5,
438 NTC_FAULT_HOT = 6,
439 };
440
441 static bool bq25890_is_adc_property(enum power_supply_property psp)
442 {
443 switch (psp) {
444 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
445 case POWER_SUPPLY_PROP_CURRENT_NOW:
446 case POWER_SUPPLY_PROP_TEMP:
447 return true;
448
449 default:
450 return false;
451 }
452 }
453
454 static irqreturn_t __bq25890_handle_irq(struct bq25890_device *bq);
455
456 static int bq25890_get_vbus_voltage(struct bq25890_device *bq)
457 {
458 int ret;
459
460 ret = bq25890_field_read(bq, F_VBUSV);
461 if (ret < 0)
462 return ret;
463
464 return bq25890_find_val(ret, TBL_VBUSV);
465 }
466
467 static void bq25890_update_state(struct bq25890_device *bq,
468 enum power_supply_property psp,
469 struct bq25890_state *state)
470 {
471 bool do_adc_conv;
472 int ret;
473
474 mutex_lock(&bq->lock);
475 /* update state in case we lost an interrupt */
476 __bq25890_handle_irq(bq);
477 *state = bq->state;
478 do_adc_conv = (!state->online || state->hiz) && bq25890_is_adc_property(psp);
479 if (do_adc_conv)
480 bq25890_field_write(bq, F_CONV_START, 1);
481 mutex_unlock(&bq->lock);
482
483 if (do_adc_conv)
484 regmap_field_read_poll_timeout(bq->rmap_fields[F_CONV_START],
485 ret, !ret, 25000, 1000000);
486 }
487
488 static int bq25890_power_supply_get_property(struct power_supply *psy,
489 enum power_supply_property psp,
490 union power_supply_propval *val)
491 {
492 struct bq25890_device *bq = power_supply_get_drvdata(psy);
493 struct bq25890_state state;
494 int ret;
495
496 bq25890_update_state(bq, psp, &state);
497
498 switch (psp) {
499 case POWER_SUPPLY_PROP_STATUS:
500 if (!state.online || state.hiz)
501 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
502 else if (state.chrg_status == STATUS_NOT_CHARGING)
503 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
504 else if (state.chrg_status == STATUS_PRE_CHARGING ||
505 state.chrg_status == STATUS_FAST_CHARGING)
506 val->intval = POWER_SUPPLY_STATUS_CHARGING;
507 else if (state.chrg_status == STATUS_TERMINATION_DONE)
508 val->intval = POWER_SUPPLY_STATUS_FULL;
509 else
510 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
511
512 break;
513
514 case POWER_SUPPLY_PROP_CHARGE_TYPE:
515 if (!state.online || state.hiz ||
516 state.chrg_status == STATUS_NOT_CHARGING ||
517 state.chrg_status == STATUS_TERMINATION_DONE)
518 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
519 else if (state.chrg_status == STATUS_PRE_CHARGING)
520 val->intval = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
521 else if (state.chrg_status == STATUS_FAST_CHARGING)
522 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
523 else /* unreachable */
524 val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
525 break;
526
527 case POWER_SUPPLY_PROP_MANUFACTURER:
528 val->strval = BQ25890_MANUFACTURER;
529 break;
530
531 case POWER_SUPPLY_PROP_MODEL_NAME:
532 val->strval = bq25890_chip_name[bq->chip_version];
533 break;
534
535 case POWER_SUPPLY_PROP_ONLINE:
536 val->intval = state.online && !state.hiz;
537 break;
538
539 case POWER_SUPPLY_PROP_HEALTH:
540 if (!state.chrg_fault && !state.bat_fault && !state.boost_fault)
541 val->intval = POWER_SUPPLY_HEALTH_GOOD;
542 else if (state.bat_fault)
543 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
544 else if (state.chrg_fault == CHRG_FAULT_TIMER_EXPIRED)
545 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
546 else if (state.chrg_fault == CHRG_FAULT_THERMAL_SHUTDOWN)
547 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
548 else
549 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
550 break;
551
552 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
553 val->intval = bq25890_find_val(bq->init_data.iprechg, TBL_ITERM);
554 break;
555
556 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
557 val->intval = bq25890_find_val(bq->init_data.iterm, TBL_ITERM);
558 break;
559
560 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
561 ret = bq25890_field_read(bq, F_IINLIM);
562 if (ret < 0)
563 return ret;
564
565 val->intval = bq25890_find_val(ret, TBL_IINLIM);
566 break;
567
568 case POWER_SUPPLY_PROP_CURRENT_NOW: /* I_BAT now */
569 /*
570 * This is ADC-sampled immediate charge current supplied
571 * from charger to battery. The property name is confusing,
572 * for clarification refer to:
573 * Documentation/ABI/testing/sysfs-class-power
574 * /sys/class/power_supply/<supply_name>/current_now
575 */
576 ret = bq25890_field_read(bq, F_ICHGR); /* read measured value */
577 if (ret < 0)
578 return ret;
579
580 /* converted_val = ADC_val * 50mA (table 10.3.19) */
581 val->intval = ret * -50000;
582 break;
583
584 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: /* I_BAT user limit */
585 /*
586 * This is user-configured constant charge current supplied
587 * from charger to battery in first phase of charging, when
588 * battery voltage is below constant charge voltage.
589 *
590 * This value reflects the current hardware setting.
591 *
592 * The POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX is the
593 * maximum value of this property.
594 */
595 ret = bq25890_field_read(bq, F_ICHG);
596 if (ret < 0)
597 return ret;
598 val->intval = bq25890_find_val(ret, TBL_ICHG);
599
600 /* When temperature is too low, charge current is decreased */
601 if (bq->state.ntc_fault == NTC_FAULT_COOL) {
602 ret = bq25890_field_read(bq, F_JEITA_ISET);
603 if (ret < 0)
604 return ret;
605
606 if (ret)
607 val->intval /= 5;
608 else
609 val->intval /= 2;
610 }
611 break;
612
613 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: /* I_BAT max */
614 /*
615 * This is maximum allowed constant charge current supplied
616 * from charger to battery in first phase of charging, when
617 * battery voltage is below constant charge voltage.
618 *
619 * This value is constant for each battery and set from DT.
620 */
621 val->intval = bq25890_find_val(bq->init_data.ichg, TBL_ICHG);
622 break;
623
624 case POWER_SUPPLY_PROP_VOLTAGE_NOW: /* V_BAT now */
625 /*
626 * This is ADC-sampled immediate charge voltage supplied
627 * from charger to battery. The property name is confusing,
628 * for clarification refer to:
629 * Documentation/ABI/testing/sysfs-class-power
630 * /sys/class/power_supply/<supply_name>/voltage_now
631 */
632 ret = bq25890_field_read(bq, F_BATV); /* read measured value */
633 if (ret < 0)
634 return ret;
635
636 /* converted_val = 2.304V + ADC_val * 20mV (table 10.3.15) */
637 val->intval = 2304000 + ret * 20000;
638 break;
639
640 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: /* V_BAT user limit */
641 /*
642 * This is user-configured constant charge voltage supplied
643 * from charger to battery in second phase of charging, when
644 * battery voltage reached constant charge voltage.
645 *
646 * This value reflects the current hardware setting.
647 *
648 * The POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX is the
649 * maximum value of this property.
650 */
651 ret = bq25890_field_read(bq, F_VREG);
652 if (ret < 0)
653 return ret;
654
655 val->intval = bq25890_find_val(ret, TBL_VREG);
656 break;
657
658 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: /* V_BAT max */
659 /*
660 * This is maximum allowed constant charge voltage supplied
661 * from charger to battery in second phase of charging, when
662 * battery voltage reached constant charge voltage.
663 *
664 * This value is constant for each battery and set from DT.
665 */
666 val->intval = bq25890_find_val(bq->init_data.vreg, TBL_VREG);
667 break;
668
669 case POWER_SUPPLY_PROP_TEMP:
670 ret = bq25890_field_read(bq, F_TSPCT);
671 if (ret < 0)
672 return ret;
673
674 /* convert TS percentage into rough temperature */
675 val->intval = bq25890_find_val(ret, TBL_TSPCT);
676 break;
677
678 default:
679 return -EINVAL;
680 }
681
682 return 0;
683 }
684
685 static int bq25890_power_supply_set_property(struct power_supply *psy,
686 enum power_supply_property psp,
687 const union power_supply_propval *val)
688 {
689 struct bq25890_device *bq = power_supply_get_drvdata(psy);
690 struct bq25890_state state;
691 int maxval, ret;
692 u8 lval;
693
694 switch (psp) {
695 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
696 maxval = bq25890_find_val(bq->init_data.ichg, TBL_ICHG);
697 lval = bq25890_find_idx(min(val->intval, maxval), TBL_ICHG);
698 return bq25890_field_write(bq, F_ICHG, lval);
699 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
700 maxval = bq25890_find_val(bq->init_data.vreg, TBL_VREG);
701 lval = bq25890_find_idx(min(val->intval, maxval), TBL_VREG);
702 return bq25890_field_write(bq, F_VREG, lval);
703 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
704 lval = bq25890_find_idx(val->intval, TBL_IINLIM);
705 return bq25890_field_write(bq, F_IINLIM, lval);
706 case POWER_SUPPLY_PROP_ONLINE:
707 ret = bq25890_field_write(bq, F_EN_HIZ, !val->intval);
708 if (!ret)
709 bq->force_hiz = !val->intval;
710 bq25890_update_state(bq, psp, &state);
711 return ret;
712 default:
713 return -EINVAL;
714 }
715 }
716
717 static int bq25890_power_supply_property_is_writeable(struct power_supply *psy,
718 enum power_supply_property psp)
719 {
720 switch (psp) {
721 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
722 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
723 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
724 case POWER_SUPPLY_PROP_ONLINE:
725 return true;
726 default:
727 return false;
728 }
729 }
730
731 /*
732 * If there are multiple chargers the maximum current the external power-supply
733 * can deliver needs to be divided over the chargers. This is done according
734 * to the bq->iinlim_percentage setting.
735 */
736 static int bq25890_charger_get_scaled_iinlim_regval(struct bq25890_device *bq,
737 int iinlim_ua)
738 {
739 iinlim_ua = iinlim_ua * bq->iinlim_percentage / 100;
740 return bq25890_find_idx(iinlim_ua, TBL_IINLIM);
741 }
742
743 /* On the BQ25892 try to get charger-type info from our supplier */
744 static void bq25890_charger_external_power_changed(struct power_supply *psy)
745 {
746 struct bq25890_device *bq = power_supply_get_drvdata(psy);
747 union power_supply_propval val;
748 int input_current_limit, ret;
749
750 if (bq->chip_version != BQ25892)
751 return;
752
753 ret = power_supply_get_property_from_supplier(psy,
754 POWER_SUPPLY_PROP_USB_TYPE,
755 &val);
756 if (ret)
757 return;
758
759 switch (val.intval) {
760 case POWER_SUPPLY_USB_TYPE_DCP:
761 input_current_limit = bq25890_charger_get_scaled_iinlim_regval(bq, 2000000);
762 if (bq->pump_express_vbus_max) {
763 queue_delayed_work(system_power_efficient_wq,
764 &bq->pump_express_work,
765 PUMP_EXPRESS_START_DELAY);
766 }
767 break;
768 case POWER_SUPPLY_USB_TYPE_CDP:
769 case POWER_SUPPLY_USB_TYPE_ACA:
770 input_current_limit = bq25890_charger_get_scaled_iinlim_regval(bq, 1500000);
771 break;
772 case POWER_SUPPLY_USB_TYPE_SDP:
773 default:
774 input_current_limit = bq25890_charger_get_scaled_iinlim_regval(bq, 500000);
775 }
776
777 bq25890_field_write(bq, F_IINLIM, input_current_limit);
778 power_supply_changed(psy);
779 }
780
781 static int bq25890_get_chip_state(struct bq25890_device *bq,
782 struct bq25890_state *state)
783 {
784 int i, ret;
785
786 struct {
787 enum bq25890_fields id;
788 u8 *data;
789 } state_fields[] = {
790 {F_CHG_STAT, &state->chrg_status},
791 {F_PG_STAT, &state->online},
792 {F_EN_HIZ, &state->hiz},
793 {F_VSYS_STAT, &state->vsys_status},
794 {F_BOOST_FAULT, &state->boost_fault},
795 {F_BAT_FAULT, &state->bat_fault},
796 {F_CHG_FAULT, &state->chrg_fault},
797 {F_NTC_FAULT, &state->ntc_fault}
798 };
799
800 for (i = 0; i < ARRAY_SIZE(state_fields); i++) {
801 ret = bq25890_field_read(bq, state_fields[i].id);
802 if (ret < 0)
803 return ret;
804
805 *state_fields[i].data = ret;
806 }
807
808 dev_dbg(bq->dev, "S:CHG/PG/HIZ/VSYS=%d/%d/%d/%d, F:CHG/BOOST/BAT/NTC=%d/%d/%d/%d\n",
809 state->chrg_status, state->online,
810 state->hiz, state->vsys_status,
811 state->chrg_fault, state->boost_fault,
812 state->bat_fault, state->ntc_fault);
813
814 return 0;
815 }
816
817 static irqreturn_t __bq25890_handle_irq(struct bq25890_device *bq)
818 {
819 bool adc_conv_rate, new_adc_conv_rate;
820 struct bq25890_state new_state;
821 int ret;
822
823 ret = bq25890_get_chip_state(bq, &new_state);
824 if (ret < 0)
825 return IRQ_NONE;
826
827 if (!memcmp(&bq->state, &new_state, sizeof(new_state)))
828 return IRQ_NONE;
829
830 /*
831 * Restore HiZ bit in case it was set by user. The chip does not retain
832 * this bit on cable replug, hence the bit must be reset manually here.
833 */
834 if (new_state.online && !bq->state.online && bq->force_hiz) {
835 ret = bq25890_field_write(bq, F_EN_HIZ, bq->force_hiz);
836 if (ret < 0)
837 goto error;
838 new_state.hiz = 1;
839 }
840
841 /* Should period ADC sampling be enabled? */
842 adc_conv_rate = bq->state.online && !bq->state.hiz;
843 new_adc_conv_rate = new_state.online && !new_state.hiz;
844
845 if (new_adc_conv_rate != adc_conv_rate) {
846 ret = bq25890_field_write(bq, F_CONV_RATE, new_adc_conv_rate);
847 if (ret < 0)
848 goto error;
849 }
850
851 bq->state = new_state;
852 power_supply_changed(bq->charger);
853
854 return IRQ_HANDLED;
855 error:
856 dev_err(bq->dev, "Error communicating with the chip: %pe\n",
857 ERR_PTR(ret));
858 return IRQ_HANDLED;
859 }
860
861 static irqreturn_t bq25890_irq_handler_thread(int irq, void *private)
862 {
863 struct bq25890_device *bq = private;
864 irqreturn_t ret;
865
866 mutex_lock(&bq->lock);
867 ret = __bq25890_handle_irq(bq);
868 mutex_unlock(&bq->lock);
869
870 return ret;
871 }
872
873 static int bq25890_chip_reset(struct bq25890_device *bq)
874 {
875 int ret;
876 int rst_check_counter = 10;
877
878 ret = bq25890_field_write(bq, F_REG_RST, 1);
879 if (ret < 0)
880 return ret;
881
882 do {
883 ret = bq25890_field_read(bq, F_REG_RST);
884 if (ret < 0)
885 return ret;
886
887 usleep_range(5, 10);
888 } while (ret == 1 && --rst_check_counter);
889
890 if (!rst_check_counter)
891 return -ETIMEDOUT;
892
893 return 0;
894 }
895
896 static int bq25890_rw_init_data(struct bq25890_device *bq)
897 {
898 bool write = !bq->read_back_init_data;
899 int ret;
900 int i;
901
902 const struct {
903 enum bq25890_fields id;
904 u8 *value;
905 } init_data[] = {
906 {F_ICHG, &bq->init_data.ichg},
907 {F_VREG, &bq->init_data.vreg},
908 {F_ITERM, &bq->init_data.iterm},
909 {F_IPRECHG, &bq->init_data.iprechg},
910 {F_SYSVMIN, &bq->init_data.sysvmin},
911 {F_BOOSTV, &bq->init_data.boostv},
912 {F_BOOSTI, &bq->init_data.boosti},
913 {F_BOOSTF, &bq->init_data.boostf},
914 {F_EN_ILIM, &bq->init_data.ilim_en},
915 {F_TREG, &bq->init_data.treg},
916 {F_BATCMP, &bq->init_data.rbatcomp},
917 {F_VCLAMP, &bq->init_data.vclamp},
918 };
919
920 for (i = 0; i < ARRAY_SIZE(init_data); i++) {
921 if (write) {
922 ret = bq25890_field_write(bq, init_data[i].id,
923 *init_data[i].value);
924 } else {
925 ret = bq25890_field_read(bq, init_data[i].id);
926 if (ret >= 0)
927 *init_data[i].value = ret;
928 }
929 if (ret < 0) {
930 dev_dbg(bq->dev, "Accessing init data failed %d\n", ret);
931 return ret;
932 }
933 }
934
935 return 0;
936 }
937
938 static int bq25890_hw_init(struct bq25890_device *bq)
939 {
940 int ret;
941
942 if (!bq->skip_reset) {
943 ret = bq25890_chip_reset(bq);
944 if (ret < 0) {
945 dev_dbg(bq->dev, "Reset failed %d\n", ret);
946 return ret;
947 }
948 } else {
949 /*
950 * Ensure charging is enabled, on some boards where the fw
951 * takes care of initalizition F_CHG_CFG is set to 0 before
952 * handing control over to the OS.
953 */
954 ret = bq25890_field_write(bq, F_CHG_CFG, 1);
955 if (ret < 0) {
956 dev_dbg(bq->dev, "Enabling charging failed %d\n", ret);
957 return ret;
958 }
959 }
960
961 /* disable watchdog */
962 ret = bq25890_field_write(bq, F_WD, 0);
963 if (ret < 0) {
964 dev_dbg(bq->dev, "Disabling watchdog failed %d\n", ret);
965 return ret;
966 }
967
968 /* initialize currents/voltages and other parameters */
969 ret = bq25890_rw_init_data(bq);
970 if (ret)
971 return ret;
972
973 ret = bq25890_get_chip_state(bq, &bq->state);
974 if (ret < 0) {
975 dev_dbg(bq->dev, "Get state failed %d\n", ret);
976 return ret;
977 }
978
979 /* Configure ADC for continuous conversions when charging */
980 ret = bq25890_field_write(bq, F_CONV_RATE, bq->state.online && !bq->state.hiz);
981 if (ret < 0) {
982 dev_dbg(bq->dev, "Config ADC failed %d\n", ret);
983 return ret;
984 }
985
986 return 0;
987 }
988
989 static const enum power_supply_property bq25890_power_supply_props[] = {
990 POWER_SUPPLY_PROP_MANUFACTURER,
991 POWER_SUPPLY_PROP_MODEL_NAME,
992 POWER_SUPPLY_PROP_STATUS,
993 POWER_SUPPLY_PROP_CHARGE_TYPE,
994 POWER_SUPPLY_PROP_ONLINE,
995 POWER_SUPPLY_PROP_HEALTH,
996 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
997 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
998 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
999 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
1000 POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
1001 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
1002 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1003 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1004 POWER_SUPPLY_PROP_CURRENT_NOW,
1005 POWER_SUPPLY_PROP_TEMP,
1006 };
1007
1008 static char *bq25890_charger_supplied_to[] = {
1009 "main-battery",
1010 };
1011
1012 static const struct power_supply_desc bq25890_power_supply_desc = {
1013 .type = POWER_SUPPLY_TYPE_USB,
1014 .properties = bq25890_power_supply_props,
1015 .num_properties = ARRAY_SIZE(bq25890_power_supply_props),
1016 .get_property = bq25890_power_supply_get_property,
1017 .set_property = bq25890_power_supply_set_property,
1018 .property_is_writeable = bq25890_power_supply_property_is_writeable,
1019 .external_power_changed = bq25890_charger_external_power_changed,
1020 };
1021
1022 static int bq25890_power_supply_init(struct bq25890_device *bq)
1023 {
1024 struct power_supply_config psy_cfg = { .drv_data = bq, };
1025
1026 /* Get ID for the device */
1027 mutex_lock(&bq25890_id_mutex);
1028 bq->id = idr_alloc(&bq25890_id, bq, 0, 0, GFP_KERNEL);
1029 mutex_unlock(&bq25890_id_mutex);
1030 if (bq->id < 0)
1031 return bq->id;
1032
1033 snprintf(bq->name, sizeof(bq->name), "bq25890-charger-%d", bq->id);
1034 bq->desc = bq25890_power_supply_desc;
1035 bq->desc.name = bq->name;
1036
1037 psy_cfg.supplied_to = bq25890_charger_supplied_to;
1038 psy_cfg.num_supplicants = ARRAY_SIZE(bq25890_charger_supplied_to);
1039
1040 bq->charger = devm_power_supply_register(bq->dev, &bq->desc, &psy_cfg);
1041
1042 return PTR_ERR_OR_ZERO(bq->charger);
1043 }
1044
1045 static int bq25890_set_otg_cfg(struct bq25890_device *bq, u8 val)
1046 {
1047 int ret;
1048
1049 ret = bq25890_field_write(bq, F_OTG_CFG, val);
1050 if (ret < 0)
1051 dev_err(bq->dev, "Error switching to boost/charger mode: %d\n", ret);
1052
1053 return ret;
1054 }
1055
1056 static void bq25890_pump_express_work(struct work_struct *data)
1057 {
1058 struct bq25890_device *bq =
1059 container_of(data, struct bq25890_device, pump_express_work.work);
1060 union power_supply_propval value;
1061 int voltage, i, ret;
1062
1063 dev_dbg(bq->dev, "Start to request input voltage increasing\n");
1064
1065 /* If there is a second charger put in Hi-Z mode */
1066 if (bq->secondary_chrg) {
1067 value.intval = 0;
1068 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &value);
1069 }
1070
1071 /* Enable current pulse voltage control protocol */
1072 ret = bq25890_field_write(bq, F_PUMPX_EN, 1);
1073 if (ret < 0)
1074 goto error_print;
1075
1076 for (i = 0; i < PUMP_EXPRESS_MAX_TRIES; i++) {
1077 voltage = bq25890_get_vbus_voltage(bq);
1078 if (voltage < 0)
1079 goto error_print;
1080 dev_dbg(bq->dev, "input voltage = %d uV\n", voltage);
1081
1082 if ((voltage + PUMP_EXPRESS_VBUS_MARGIN_uV) >
1083 bq->pump_express_vbus_max)
1084 break;
1085
1086 ret = bq25890_field_write(bq, F_PUMPX_UP, 1);
1087 if (ret < 0)
1088 goto error_print;
1089
1090 /* Note a single PUMPX up pulse-sequence takes 2.1s */
1091 ret = regmap_field_read_poll_timeout(bq->rmap_fields[F_PUMPX_UP],
1092 ret, !ret, 100000, 3000000);
1093 if (ret < 0)
1094 goto error_print;
1095
1096 /* Make sure ADC has sampled Vbus before checking again */
1097 msleep(1000);
1098 }
1099
1100 bq25890_field_write(bq, F_PUMPX_EN, 0);
1101
1102 if (bq->secondary_chrg) {
1103 value.intval = 1;
1104 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &value);
1105 }
1106
1107 dev_info(bq->dev, "Hi-voltage charging requested, input voltage is %d mV\n",
1108 voltage);
1109
1110 power_supply_changed(bq->charger);
1111
1112 return;
1113 error_print:
1114 bq25890_field_write(bq, F_PUMPX_EN, 0);
1115 dev_err(bq->dev, "Failed to request hi-voltage charging\n");
1116 }
1117
1118 static void bq25890_usb_work(struct work_struct *data)
1119 {
1120 int ret;
1121 struct bq25890_device *bq =
1122 container_of(data, struct bq25890_device, usb_work);
1123
1124 switch (bq->usb_event) {
1125 case USB_EVENT_ID:
1126 /* Enable boost mode */
1127 bq25890_set_otg_cfg(bq, 1);
1128 break;
1129
1130 case USB_EVENT_NONE:
1131 /* Disable boost mode */
1132 ret = bq25890_set_otg_cfg(bq, 0);
1133 if (ret == 0)
1134 power_supply_changed(bq->charger);
1135 break;
1136 }
1137 }
1138
1139 static int bq25890_usb_notifier(struct notifier_block *nb, unsigned long val,
1140 void *priv)
1141 {
1142 struct bq25890_device *bq =
1143 container_of(nb, struct bq25890_device, usb_nb);
1144
1145 bq->usb_event = val;
1146 queue_work(system_power_efficient_wq, &bq->usb_work);
1147
1148 return NOTIFY_OK;
1149 }
1150
1151 #ifdef CONFIG_REGULATOR
1152 static int bq25890_vbus_enable(struct regulator_dev *rdev)
1153 {
1154 struct bq25890_device *bq = rdev_get_drvdata(rdev);
1155 union power_supply_propval val = {
1156 .intval = 0,
1157 };
1158
1159 /*
1160 * When enabling 5V boost / Vbus output, we need to put the secondary
1161 * charger in Hi-Z mode to avoid it trying to charge the secondary
1162 * battery from the 5V boost output.
1163 */
1164 if (bq->secondary_chrg)
1165 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &val);
1166
1167 return bq25890_set_otg_cfg(bq, 1);
1168 }
1169
1170 static int bq25890_vbus_disable(struct regulator_dev *rdev)
1171 {
1172 struct bq25890_device *bq = rdev_get_drvdata(rdev);
1173 union power_supply_propval val = {
1174 .intval = 1,
1175 };
1176 int ret;
1177
1178 ret = bq25890_set_otg_cfg(bq, 0);
1179 if (ret)
1180 return ret;
1181
1182 if (bq->secondary_chrg)
1183 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &val);
1184
1185 return 0;
1186 }
1187
1188 static int bq25890_vbus_is_enabled(struct regulator_dev *rdev)
1189 {
1190 struct bq25890_device *bq = rdev_get_drvdata(rdev);
1191
1192 return bq25890_field_read(bq, F_OTG_CFG);
1193 }
1194
1195 static int bq25890_vbus_get_voltage(struct regulator_dev *rdev)
1196 {
1197 struct bq25890_device *bq = rdev_get_drvdata(rdev);
1198
1199 return bq25890_get_vbus_voltage(bq);
1200 }
1201
1202 static int bq25890_vsys_get_voltage(struct regulator_dev *rdev)
1203 {
1204 struct bq25890_device *bq = rdev_get_drvdata(rdev);
1205 int ret;
1206
1207 /* Should be some output voltage ? */
1208 ret = bq25890_field_read(bq, F_SYSV); /* read measured value */
1209 if (ret < 0)
1210 return ret;
1211
1212 /* converted_val = 2.304V + ADC_val * 20mV (table 10.3.15) */
1213 return 2304000 + ret * 20000;
1214 }
1215
1216 static const struct regulator_ops bq25890_vbus_ops = {
1217 .enable = bq25890_vbus_enable,
1218 .disable = bq25890_vbus_disable,
1219 .is_enabled = bq25890_vbus_is_enabled,
1220 .get_voltage = bq25890_vbus_get_voltage,
1221 };
1222
1223 static const struct regulator_desc bq25890_vbus_desc = {
1224 .name = "usb_otg_vbus",
1225 .of_match = "usb-otg-vbus",
1226 .type = REGULATOR_VOLTAGE,
1227 .owner = THIS_MODULE,
1228 .ops = &bq25890_vbus_ops,
1229 };
1230
1231 static const struct regulator_ops bq25890_vsys_ops = {
1232 .get_voltage = bq25890_vsys_get_voltage,
1233 };
1234
1235 static const struct regulator_desc bq25890_vsys_desc = {
1236 .name = "vsys",
1237 .of_match = "vsys",
1238 .type = REGULATOR_VOLTAGE,
1239 .owner = THIS_MODULE,
1240 .ops = &bq25890_vsys_ops,
1241 };
1242
1243 static int bq25890_register_regulator(struct bq25890_device *bq)
1244 {
1245 struct bq25890_platform_data *pdata = dev_get_platdata(bq->dev);
1246 struct regulator_config cfg = {
1247 .dev = bq->dev,
1248 .driver_data = bq,
1249 };
1250 struct regulator_dev *reg;
1251
1252 if (pdata)
1253 cfg.init_data = pdata->regulator_init_data;
1254
1255 reg = devm_regulator_register(bq->dev, &bq25890_vbus_desc, &cfg);
1256 if (IS_ERR(reg)) {
1257 return dev_err_probe(bq->dev, PTR_ERR(reg),
1258 "registering vbus regulator");
1259 }
1260
1261 /* pdata->regulator_init_data is for vbus only */
1262 cfg.init_data = NULL;
1263 reg = devm_regulator_register(bq->dev, &bq25890_vsys_desc, &cfg);
1264 if (IS_ERR(reg)) {
1265 return dev_err_probe(bq->dev, PTR_ERR(reg),
1266 "registering vsys regulator");
1267 }
1268
1269 return 0;
1270 }
1271 #else
1272 static inline int
1273 bq25890_register_regulator(struct bq25890_device *bq)
1274 {
1275 return 0;
1276 }
1277 #endif
1278
1279 static int bq25890_get_chip_version(struct bq25890_device *bq)
1280 {
1281 int id, rev;
1282
1283 id = bq25890_field_read(bq, F_PN);
1284 if (id < 0) {
1285 dev_err(bq->dev, "Cannot read chip ID: %d\n", id);
1286 return id;
1287 }
1288
1289 rev = bq25890_field_read(bq, F_DEV_REV);
1290 if (rev < 0) {
1291 dev_err(bq->dev, "Cannot read chip revision: %d\n", rev);
1292 return rev;
1293 }
1294
1295 switch (id) {
1296 case BQ25890_ID:
1297 bq->chip_version = BQ25890;
1298 break;
1299
1300 /* BQ25892 and BQ25896 share same ID 0 */
1301 case BQ25896_ID:
1302 switch (rev) {
1303 case 2:
1304 bq->chip_version = BQ25896;
1305 break;
1306 case 1:
1307 bq->chip_version = BQ25892;
1308 break;
1309 default:
1310 dev_err(bq->dev,
1311 "Unknown device revision %d, assume BQ25892\n",
1312 rev);
1313 bq->chip_version = BQ25892;
1314 }
1315 break;
1316
1317 case BQ25895_ID:
1318 bq->chip_version = BQ25895;
1319 break;
1320
1321 default:
1322 dev_err(bq->dev, "Unknown chip ID %d\n", id);
1323 return -ENODEV;
1324 }
1325
1326 return 0;
1327 }
1328
1329 static int bq25890_irq_probe(struct bq25890_device *bq)
1330 {
1331 struct gpio_desc *irq;
1332
1333 irq = devm_gpiod_get(bq->dev, BQ25890_IRQ_PIN, GPIOD_IN);
1334 if (IS_ERR(irq))
1335 return dev_err_probe(bq->dev, PTR_ERR(irq),
1336 "Could not probe irq pin.\n");
1337
1338 return gpiod_to_irq(irq);
1339 }
1340
1341 static int bq25890_fw_read_u32_props(struct bq25890_device *bq)
1342 {
1343 int ret;
1344 u32 property;
1345 int i;
1346 struct bq25890_init_data *init = &bq->init_data;
1347 struct {
1348 char *name;
1349 bool optional;
1350 enum bq25890_table_ids tbl_id;
1351 u8 *conv_data; /* holds converted value from given property */
1352 } props[] = {
1353 /* required properties */
1354 {"ti,charge-current", false, TBL_ICHG, &init->ichg},
1355 {"ti,battery-regulation-voltage", false, TBL_VREG, &init->vreg},
1356 {"ti,termination-current", false, TBL_ITERM, &init->iterm},
1357 {"ti,precharge-current", false, TBL_ITERM, &init->iprechg},
1358 {"ti,minimum-sys-voltage", false, TBL_SYSVMIN, &init->sysvmin},
1359 {"ti,boost-voltage", false, TBL_BOOSTV, &init->boostv},
1360 {"ti,boost-max-current", false, TBL_BOOSTI, &init->boosti},
1361
1362 /* optional properties */
1363 {"ti,thermal-regulation-threshold", true, TBL_TREG, &init->treg},
1364 {"ti,ibatcomp-micro-ohms", true, TBL_RBATCOMP, &init->rbatcomp},
1365 {"ti,ibatcomp-clamp-microvolt", true, TBL_VBATCOMP, &init->vclamp},
1366 };
1367
1368 /* initialize data for optional properties */
1369 init->treg = 3; /* 120 degrees Celsius */
1370 init->rbatcomp = init->vclamp = 0; /* IBAT compensation disabled */
1371
1372 for (i = 0; i < ARRAY_SIZE(props); i++) {
1373 ret = device_property_read_u32(bq->dev, props[i].name,
1374 &property);
1375 if (ret < 0) {
1376 if (props[i].optional)
1377 continue;
1378
1379 dev_err(bq->dev, "Unable to read property %d %s\n", ret,
1380 props[i].name);
1381
1382 return ret;
1383 }
1384
1385 *props[i].conv_data = bq25890_find_idx(property,
1386 props[i].tbl_id);
1387 }
1388
1389 return 0;
1390 }
1391
1392 static int bq25890_fw_probe(struct bq25890_device *bq)
1393 {
1394 int ret;
1395 struct bq25890_init_data *init = &bq->init_data;
1396 const char *str;
1397 u32 val;
1398
1399 ret = device_property_read_string(bq->dev, "linux,secondary-charger-name", &str);
1400 if (ret == 0) {
1401 bq->secondary_chrg = power_supply_get_by_name(str);
1402 if (!bq->secondary_chrg)
1403 return -EPROBE_DEFER;
1404 }
1405
1406 /* Optional, left at 0 if property is not present */
1407 device_property_read_u32(bq->dev, "linux,pump-express-vbus-max",
1408 &bq->pump_express_vbus_max);
1409
1410 ret = device_property_read_u32(bq->dev, "linux,iinlim-percentage", &val);
1411 if (ret == 0) {
1412 if (val > 100) {
1413 dev_err(bq->dev, "Error linux,iinlim-percentage %u > 100\n", val);
1414 return -EINVAL;
1415 }
1416 bq->iinlim_percentage = val;
1417 } else {
1418 bq->iinlim_percentage = 100;
1419 }
1420
1421 bq->skip_reset = device_property_read_bool(bq->dev, "linux,skip-reset");
1422 bq->read_back_init_data = device_property_read_bool(bq->dev,
1423 "linux,read-back-settings");
1424 if (bq->read_back_init_data)
1425 return 0;
1426
1427 ret = bq25890_fw_read_u32_props(bq);
1428 if (ret < 0)
1429 return ret;
1430
1431 init->ilim_en = device_property_read_bool(bq->dev, "ti,use-ilim-pin");
1432 init->boostf = device_property_read_bool(bq->dev, "ti,boost-low-freq");
1433
1434 return 0;
1435 }
1436
1437 static void bq25890_non_devm_cleanup(void *data)
1438 {
1439 struct bq25890_device *bq = data;
1440
1441 cancel_delayed_work_sync(&bq->pump_express_work);
1442
1443 if (bq->id >= 0) {
1444 mutex_lock(&bq25890_id_mutex);
1445 idr_remove(&bq25890_id, bq->id);
1446 mutex_unlock(&bq25890_id_mutex);
1447 }
1448 }
1449
1450 static int bq25890_probe(struct i2c_client *client)
1451 {
1452 struct device *dev = &client->dev;
1453 struct bq25890_device *bq;
1454 int ret;
1455
1456 bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
1457 if (!bq)
1458 return -ENOMEM;
1459
1460 bq->client = client;
1461 bq->dev = dev;
1462 bq->id = -1;
1463
1464 mutex_init(&bq->lock);
1465 INIT_DELAYED_WORK(&bq->pump_express_work, bq25890_pump_express_work);
1466
1467 bq->rmap = devm_regmap_init_i2c(client, &bq25890_regmap_config);
1468 if (IS_ERR(bq->rmap))
1469 return dev_err_probe(dev, PTR_ERR(bq->rmap),
1470 "failed to allocate register map\n");
1471
1472 ret = devm_regmap_field_bulk_alloc(dev, bq->rmap, bq->rmap_fields,
1473 bq25890_reg_fields, F_MAX_FIELDS);
1474 if (ret)
1475 return ret;
1476
1477 i2c_set_clientdata(client, bq);
1478
1479 ret = bq25890_get_chip_version(bq);
1480 if (ret) {
1481 dev_err(dev, "Cannot read chip ID or unknown chip: %d\n", ret);
1482 return ret;
1483 }
1484
1485 ret = bq25890_fw_probe(bq);
1486 if (ret < 0)
1487 return dev_err_probe(dev, ret, "reading device properties\n");
1488
1489 ret = bq25890_hw_init(bq);
1490 if (ret < 0) {
1491 dev_err(dev, "Cannot initialize the chip: %d\n", ret);
1492 return ret;
1493 }
1494
1495 if (client->irq <= 0)
1496 client->irq = bq25890_irq_probe(bq);
1497
1498 if (client->irq < 0) {
1499 dev_err(dev, "No irq resource found.\n");
1500 return client->irq;
1501 }
1502
1503 /* OTG reporting */
1504 bq->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
1505
1506 /*
1507 * This must be before bq25890_power_supply_init(), so that it runs
1508 * after devm unregisters the power_supply.
1509 */
1510 ret = devm_add_action_or_reset(dev, bq25890_non_devm_cleanup, bq);
1511 if (ret)
1512 return ret;
1513
1514 ret = bq25890_register_regulator(bq);
1515 if (ret)
1516 return ret;
1517
1518 ret = bq25890_power_supply_init(bq);
1519 if (ret < 0)
1520 return dev_err_probe(dev, ret, "registering power supply\n");
1521
1522 ret = devm_request_threaded_irq(dev, client->irq, NULL,
1523 bq25890_irq_handler_thread,
1524 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1525 BQ25890_IRQ_PIN, bq);
1526 if (ret)
1527 return ret;
1528
1529 if (!IS_ERR_OR_NULL(bq->usb_phy)) {
1530 INIT_WORK(&bq->usb_work, bq25890_usb_work);
1531 bq->usb_nb.notifier_call = bq25890_usb_notifier;
1532 usb_register_notifier(bq->usb_phy, &bq->usb_nb);
1533 }
1534
1535 return 0;
1536 }
1537
1538 static void bq25890_remove(struct i2c_client *client)
1539 {
1540 struct bq25890_device *bq = i2c_get_clientdata(client);
1541
1542 if (!IS_ERR_OR_NULL(bq->usb_phy)) {
1543 usb_unregister_notifier(bq->usb_phy, &bq->usb_nb);
1544 cancel_work_sync(&bq->usb_work);
1545 }
1546
1547 if (!bq->skip_reset) {
1548 /* reset all registers to default values */
1549 bq25890_chip_reset(bq);
1550 }
1551 }
1552
1553 static void bq25890_shutdown(struct i2c_client *client)
1554 {
1555 struct bq25890_device *bq = i2c_get_clientdata(client);
1556
1557 /*
1558 * TODO this if + return should probably be removed, but that would
1559 * introduce a function change for boards using the usb-phy framework.
1560 * This needs to be tested on such a board before making this change.
1561 */
1562 if (!IS_ERR_OR_NULL(bq->usb_phy))
1563 return;
1564
1565 /*
1566 * Turn off the 5v Boost regulator which outputs Vbus to the device's
1567 * Micro-USB or Type-C USB port. Leaving this on drains power and
1568 * this avoids the PMIC on some device-models seeing this as Vbus
1569 * getting inserted after shutdown, causing the device to immediately
1570 * power-up again.
1571 */
1572 bq25890_set_otg_cfg(bq, 0);
1573 }
1574
1575 #ifdef CONFIG_PM_SLEEP
1576 static int bq25890_suspend(struct device *dev)
1577 {
1578 struct bq25890_device *bq = dev_get_drvdata(dev);
1579
1580 /*
1581 * If charger is removed, while in suspend, make sure ADC is diabled
1582 * since it consumes slightly more power.
1583 */
1584 return bq25890_field_write(bq, F_CONV_RATE, 0);
1585 }
1586
1587 static int bq25890_resume(struct device *dev)
1588 {
1589 int ret;
1590 struct bq25890_device *bq = dev_get_drvdata(dev);
1591
1592 mutex_lock(&bq->lock);
1593
1594 ret = bq25890_get_chip_state(bq, &bq->state);
1595 if (ret < 0)
1596 goto unlock;
1597
1598 /* Re-enable ADC only if charger is plugged in. */
1599 if (bq->state.online) {
1600 ret = bq25890_field_write(bq, F_CONV_RATE, 1);
1601 if (ret < 0)
1602 goto unlock;
1603 }
1604
1605 /* signal userspace, maybe state changed while suspended */
1606 power_supply_changed(bq->charger);
1607
1608 unlock:
1609 mutex_unlock(&bq->lock);
1610
1611 return ret;
1612 }
1613 #endif
1614
1615 static const struct dev_pm_ops bq25890_pm = {
1616 SET_SYSTEM_SLEEP_PM_OPS(bq25890_suspend, bq25890_resume)
1617 };
1618
1619 static const struct i2c_device_id bq25890_i2c_ids[] = {
1620 { "bq25890" },
1621 { "bq25892" },
1622 { "bq25895" },
1623 { "bq25896" },
1624 {}
1625 };
1626 MODULE_DEVICE_TABLE(i2c, bq25890_i2c_ids);
1627
1628 static const struct of_device_id bq25890_of_match[] __maybe_unused = {
1629 { .compatible = "ti,bq25890", },
1630 { .compatible = "ti,bq25892", },
1631 { .compatible = "ti,bq25895", },
1632 { .compatible = "ti,bq25896", },
1633 { },
1634 };
1635 MODULE_DEVICE_TABLE(of, bq25890_of_match);
1636
1637 #ifdef CONFIG_ACPI
1638 static const struct acpi_device_id bq25890_acpi_match[] = {
1639 {"BQ258900", 0},
1640 {},
1641 };
1642 MODULE_DEVICE_TABLE(acpi, bq25890_acpi_match);
1643 #endif
1644
1645 static struct i2c_driver bq25890_driver = {
1646 .driver = {
1647 .name = "bq25890-charger",
1648 .of_match_table = of_match_ptr(bq25890_of_match),
1649 .acpi_match_table = ACPI_PTR(bq25890_acpi_match),
1650 .pm = &bq25890_pm,
1651 },
1652 .probe = bq25890_probe,
1653 .remove = bq25890_remove,
1654 .shutdown = bq25890_shutdown,
1655 .id_table = bq25890_i2c_ids,
1656 };
1657 module_i2c_driver(bq25890_driver);
1658
1659 MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>");
1660 MODULE_DESCRIPTION("bq25890 charger driver");
1661 MODULE_LICENSE("GPL");
Kernel DRM miscellaneous fixes and cross-tree changes