Debian Codegraph @

drivers/power/supply/bq25980_charger.c

raw
1 // SPDX-License-Identifier: GPL-2.0
2 // BQ25980 Battery Charger Driver
3 // Copyright (C) 2020 Texas Instruments Incorporated - http://www.ti.com/
4
5 #include <linux/err.h>
6 #include <linux/i2c.h>
7 #include <linux/init.h>
8 #include <linux/interrupt.h>
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/power_supply.h>
12 #include <linux/regmap.h>
13 #include <linux/types.h>
14 #include <linux/delay.h>
15 #include <linux/device.h>
16 #include <linux/moduleparam.h>
17 #include <linux/slab.h>
18
19 #include "bq25980_charger.h"
20
21 struct bq25980_state {
22 bool dischg;
23 bool ovp;
24 bool ocp;
25 bool wdt;
26 bool tflt;
27 bool online;
28 bool ce;
29 bool hiz;
30 bool bypass;
31
32 u32 vbat_adc;
33 u32 vsys_adc;
34 u32 ibat_adc;
35 };
36
37 enum bq25980_id {
38 BQ25980,
39 BQ25975,
40 BQ25960,
41 };
42
43 struct bq25980_chip_info {
44
45 int model_id;
46
47 const struct regmap_config *regmap_config;
48
49 int busocp_def;
50 int busocp_sc_max;
51 int busocp_byp_max;
52 int busocp_sc_min;
53 int busocp_byp_min;
54
55 int busovp_sc_def;
56 int busovp_byp_def;
57 int busovp_sc_step;
58
59 int busovp_sc_offset;
60 int busovp_byp_step;
61 int busovp_byp_offset;
62 int busovp_sc_min;
63 int busovp_sc_max;
64 int busovp_byp_min;
65 int busovp_byp_max;
66
67 int batovp_def;
68 int batovp_max;
69 int batovp_min;
70 int batovp_step;
71 int batovp_offset;
72
73 int batocp_def;
74 int batocp_max;
75 };
76
77 struct bq25980_init_data {
78 u32 ichg;
79 u32 bypass_ilim;
80 u32 sc_ilim;
81 u32 vreg;
82 u32 iterm;
83 u32 iprechg;
84 u32 bypass_vlim;
85 u32 sc_vlim;
86 u32 ichg_max;
87 u32 vreg_max;
88 };
89
90 struct bq25980_device {
91 struct i2c_client *client;
92 struct device *dev;
93 struct power_supply *charger;
94 struct power_supply *battery;
95 struct mutex lock;
96 struct regmap *regmap;
97
98 char model_name[I2C_NAME_SIZE];
99
100 struct bq25980_init_data init_data;
101 const struct bq25980_chip_info *chip_info;
102 struct bq25980_state state;
103 int watchdog_timer;
104 };
105
106 static const struct reg_default bq25980_reg_defs[] = {
107 {BQ25980_BATOVP, 0x5A},
108 {BQ25980_BATOVP_ALM, 0x46},
109 {BQ25980_BATOCP, 0x51},
110 {BQ25980_BATOCP_ALM, 0x50},
111 {BQ25980_BATUCP_ALM, 0x28},
112 {BQ25980_CHRGR_CTRL_1, 0x0},
113 {BQ25980_BUSOVP, 0x26},
114 {BQ25980_BUSOVP_ALM, 0x22},
115 {BQ25980_BUSOCP, 0xD},
116 {BQ25980_BUSOCP_ALM, 0xC},
117 {BQ25980_TEMP_CONTROL, 0x30},
118 {BQ25980_TDIE_ALM, 0xC8},
119 {BQ25980_TSBUS_FLT, 0x15},
120 {BQ25980_TSBAT_FLG, 0x15},
121 {BQ25980_VAC_CONTROL, 0x0},
122 {BQ25980_CHRGR_CTRL_2, 0x0},
123 {BQ25980_CHRGR_CTRL_3, 0x20},
124 {BQ25980_CHRGR_CTRL_4, 0x1D},
125 {BQ25980_CHRGR_CTRL_5, 0x18},
126 {BQ25980_STAT1, 0x0},
127 {BQ25980_STAT2, 0x0},
128 {BQ25980_STAT3, 0x0},
129 {BQ25980_STAT4, 0x0},
130 {BQ25980_STAT5, 0x0},
131 {BQ25980_FLAG1, 0x0},
132 {BQ25980_FLAG2, 0x0},
133 {BQ25980_FLAG3, 0x0},
134 {BQ25980_FLAG4, 0x0},
135 {BQ25980_FLAG5, 0x0},
136 {BQ25980_MASK1, 0x0},
137 {BQ25980_MASK2, 0x0},
138 {BQ25980_MASK3, 0x0},
139 {BQ25980_MASK4, 0x0},
140 {BQ25980_MASK5, 0x0},
141 {BQ25980_DEVICE_INFO, 0x8},
142 {BQ25980_ADC_CONTROL1, 0x0},
143 {BQ25980_ADC_CONTROL2, 0x0},
144 {BQ25980_IBUS_ADC_LSB, 0x0},
145 {BQ25980_IBUS_ADC_MSB, 0x0},
146 {BQ25980_VBUS_ADC_LSB, 0x0},
147 {BQ25980_VBUS_ADC_MSB, 0x0},
148 {BQ25980_VAC1_ADC_LSB, 0x0},
149 {BQ25980_VAC2_ADC_LSB, 0x0},
150 {BQ25980_VOUT_ADC_LSB, 0x0},
151 {BQ25980_VBAT_ADC_LSB, 0x0},
152 {BQ25980_IBAT_ADC_MSB, 0x0},
153 {BQ25980_IBAT_ADC_LSB, 0x0},
154 {BQ25980_TSBUS_ADC_LSB, 0x0},
155 {BQ25980_TSBAT_ADC_LSB, 0x0},
156 {BQ25980_TDIE_ADC_LSB, 0x0},
157 {BQ25980_DEGLITCH_TIME, 0x0},
158 {BQ25980_CHRGR_CTRL_6, 0x0},
159 };
160
161 static const struct reg_default bq25975_reg_defs[] = {
162 {BQ25980_BATOVP, 0x5A},
163 {BQ25980_BATOVP_ALM, 0x46},
164 {BQ25980_BATOCP, 0x51},
165 {BQ25980_BATOCP_ALM, 0x50},
166 {BQ25980_BATUCP_ALM, 0x28},
167 {BQ25980_CHRGR_CTRL_1, 0x0},
168 {BQ25980_BUSOVP, 0x26},
169 {BQ25980_BUSOVP_ALM, 0x22},
170 {BQ25980_BUSOCP, 0xD},
171 {BQ25980_BUSOCP_ALM, 0xC},
172 {BQ25980_TEMP_CONTROL, 0x30},
173 {BQ25980_TDIE_ALM, 0xC8},
174 {BQ25980_TSBUS_FLT, 0x15},
175 {BQ25980_TSBAT_FLG, 0x15},
176 {BQ25980_VAC_CONTROL, 0x0},
177 {BQ25980_CHRGR_CTRL_2, 0x0},
178 {BQ25980_CHRGR_CTRL_3, 0x20},
179 {BQ25980_CHRGR_CTRL_4, 0x1D},
180 {BQ25980_CHRGR_CTRL_5, 0x18},
181 {BQ25980_STAT1, 0x0},
182 {BQ25980_STAT2, 0x0},
183 {BQ25980_STAT3, 0x0},
184 {BQ25980_STAT4, 0x0},
185 {BQ25980_STAT5, 0x0},
186 {BQ25980_FLAG1, 0x0},
187 {BQ25980_FLAG2, 0x0},
188 {BQ25980_FLAG3, 0x0},
189 {BQ25980_FLAG4, 0x0},
190 {BQ25980_FLAG5, 0x0},
191 {BQ25980_MASK1, 0x0},
192 {BQ25980_MASK2, 0x0},
193 {BQ25980_MASK3, 0x0},
194 {BQ25980_MASK4, 0x0},
195 {BQ25980_MASK5, 0x0},
196 {BQ25980_DEVICE_INFO, 0x8},
197 {BQ25980_ADC_CONTROL1, 0x0},
198 {BQ25980_ADC_CONTROL2, 0x0},
199 {BQ25980_IBUS_ADC_LSB, 0x0},
200 {BQ25980_IBUS_ADC_MSB, 0x0},
201 {BQ25980_VBUS_ADC_LSB, 0x0},
202 {BQ25980_VBUS_ADC_MSB, 0x0},
203 {BQ25980_VAC1_ADC_LSB, 0x0},
204 {BQ25980_VAC2_ADC_LSB, 0x0},
205 {BQ25980_VOUT_ADC_LSB, 0x0},
206 {BQ25980_VBAT_ADC_LSB, 0x0},
207 {BQ25980_IBAT_ADC_MSB, 0x0},
208 {BQ25980_IBAT_ADC_LSB, 0x0},
209 {BQ25980_TSBUS_ADC_LSB, 0x0},
210 {BQ25980_TSBAT_ADC_LSB, 0x0},
211 {BQ25980_TDIE_ADC_LSB, 0x0},
212 {BQ25980_DEGLITCH_TIME, 0x0},
213 {BQ25980_CHRGR_CTRL_6, 0x0},
214 };
215
216 static const struct reg_default bq25960_reg_defs[] = {
217 {BQ25980_BATOVP, 0x5A},
218 {BQ25980_BATOVP_ALM, 0x46},
219 {BQ25980_BATOCP, 0x51},
220 {BQ25980_BATOCP_ALM, 0x50},
221 {BQ25980_BATUCP_ALM, 0x28},
222 {BQ25980_CHRGR_CTRL_1, 0x0},
223 {BQ25980_BUSOVP, 0x26},
224 {BQ25980_BUSOVP_ALM, 0x22},
225 {BQ25980_BUSOCP, 0xD},
226 {BQ25980_BUSOCP_ALM, 0xC},
227 {BQ25980_TEMP_CONTROL, 0x30},
228 {BQ25980_TDIE_ALM, 0xC8},
229 {BQ25980_TSBUS_FLT, 0x15},
230 {BQ25980_TSBAT_FLG, 0x15},
231 {BQ25980_VAC_CONTROL, 0x0},
232 {BQ25980_CHRGR_CTRL_2, 0x0},
233 {BQ25980_CHRGR_CTRL_3, 0x20},
234 {BQ25980_CHRGR_CTRL_4, 0x1D},
235 {BQ25980_CHRGR_CTRL_5, 0x18},
236 {BQ25980_STAT1, 0x0},
237 {BQ25980_STAT2, 0x0},
238 {BQ25980_STAT3, 0x0},
239 {BQ25980_STAT4, 0x0},
240 {BQ25980_STAT5, 0x0},
241 {BQ25980_FLAG1, 0x0},
242 {BQ25980_FLAG2, 0x0},
243 {BQ25980_FLAG3, 0x0},
244 {BQ25980_FLAG4, 0x0},
245 {BQ25980_FLAG5, 0x0},
246 {BQ25980_MASK1, 0x0},
247 {BQ25980_MASK2, 0x0},
248 {BQ25980_MASK3, 0x0},
249 {BQ25980_MASK4, 0x0},
250 {BQ25980_MASK5, 0x0},
251 {BQ25980_DEVICE_INFO, 0x8},
252 {BQ25980_ADC_CONTROL1, 0x0},
253 {BQ25980_ADC_CONTROL2, 0x0},
254 {BQ25980_IBUS_ADC_LSB, 0x0},
255 {BQ25980_IBUS_ADC_MSB, 0x0},
256 {BQ25980_VBUS_ADC_LSB, 0x0},
257 {BQ25980_VBUS_ADC_MSB, 0x0},
258 {BQ25980_VAC1_ADC_LSB, 0x0},
259 {BQ25980_VAC2_ADC_LSB, 0x0},
260 {BQ25980_VOUT_ADC_LSB, 0x0},
261 {BQ25980_VBAT_ADC_LSB, 0x0},
262 {BQ25980_IBAT_ADC_MSB, 0x0},
263 {BQ25980_IBAT_ADC_LSB, 0x0},
264 {BQ25980_TSBUS_ADC_LSB, 0x0},
265 {BQ25980_TSBAT_ADC_LSB, 0x0},
266 {BQ25980_TDIE_ADC_LSB, 0x0},
267 {BQ25980_DEGLITCH_TIME, 0x0},
268 {BQ25980_CHRGR_CTRL_6, 0x0},
269 };
270
271 static int bq25980_watchdog_time[BQ25980_NUM_WD_VAL] = {5000, 10000, 50000,
272 300000};
273
274 static int bq25980_get_input_curr_lim(struct bq25980_device *bq)
275 {
276 unsigned int busocp_reg_code;
277 int ret;
278
279 ret = regmap_read(bq->regmap, BQ25980_BUSOCP, &busocp_reg_code);
280 if (ret)
281 return ret;
282
283 return (busocp_reg_code * BQ25980_BUSOCP_STEP_uA) + BQ25980_BUSOCP_OFFSET_uA;
284 }
285
286 static int bq25980_set_hiz(struct bq25980_device *bq, int setting)
287 {
288 return regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
289 BQ25980_EN_HIZ, setting);
290 }
291
292 static int bq25980_set_input_curr_lim(struct bq25980_device *bq, int busocp)
293 {
294 unsigned int busocp_reg_code;
295 int ret;
296
297 if (!busocp)
298 return bq25980_set_hiz(bq, BQ25980_ENABLE_HIZ);
299
300 bq25980_set_hiz(bq, BQ25980_DISABLE_HIZ);
301
302 if (busocp < BQ25980_BUSOCP_MIN_uA)
303 busocp = BQ25980_BUSOCP_MIN_uA;
304
305 if (bq->state.bypass)
306 busocp = min(busocp, bq->chip_info->busocp_sc_max);
307 else
308 busocp = min(busocp, bq->chip_info->busocp_byp_max);
309
310 busocp_reg_code = (busocp - BQ25980_BUSOCP_OFFSET_uA)
311 / BQ25980_BUSOCP_STEP_uA;
312
313 ret = regmap_write(bq->regmap, BQ25980_BUSOCP, busocp_reg_code);
314 if (ret)
315 return ret;
316
317 return regmap_write(bq->regmap, BQ25980_BUSOCP_ALM, busocp_reg_code);
318 }
319
320 static int bq25980_get_input_volt_lim(struct bq25980_device *bq)
321 {
322 unsigned int busovp_reg_code;
323 unsigned int busovp_offset;
324 unsigned int busovp_step;
325 int ret;
326
327 if (bq->state.bypass) {
328 busovp_step = bq->chip_info->busovp_byp_step;
329 busovp_offset = bq->chip_info->busovp_byp_offset;
330 } else {
331 busovp_step = bq->chip_info->busovp_sc_step;
332 busovp_offset = bq->chip_info->busovp_sc_offset;
333 }
334
335 ret = regmap_read(bq->regmap, BQ25980_BUSOVP, &busovp_reg_code);
336 if (ret)
337 return ret;
338
339 return (busovp_reg_code * busovp_step) + busovp_offset;
340 }
341
342 static int bq25980_set_input_volt_lim(struct bq25980_device *bq, int busovp)
343 {
344 unsigned int busovp_reg_code;
345 unsigned int busovp_step;
346 unsigned int busovp_offset;
347 int ret;
348
349 if (bq->state.bypass) {
350 busovp_step = bq->chip_info->busovp_byp_step;
351 busovp_offset = bq->chip_info->busovp_byp_offset;
352 if (busovp > bq->chip_info->busovp_byp_max)
353 busovp = bq->chip_info->busovp_byp_max;
354 else if (busovp < bq->chip_info->busovp_byp_min)
355 busovp = bq->chip_info->busovp_byp_min;
356 } else {
357 busovp_step = bq->chip_info->busovp_sc_step;
358 busovp_offset = bq->chip_info->busovp_sc_offset;
359 if (busovp > bq->chip_info->busovp_sc_max)
360 busovp = bq->chip_info->busovp_sc_max;
361 else if (busovp < bq->chip_info->busovp_sc_min)
362 busovp = bq->chip_info->busovp_sc_min;
363 }
364
365 busovp_reg_code = (busovp - busovp_offset) / busovp_step;
366
367 ret = regmap_write(bq->regmap, BQ25980_BUSOVP, busovp_reg_code);
368 if (ret)
369 return ret;
370
371 return regmap_write(bq->regmap, BQ25980_BUSOVP_ALM, busovp_reg_code);
372 }
373
374 static int bq25980_get_const_charge_curr(struct bq25980_device *bq)
375 {
376 unsigned int batocp_reg_code;
377 int ret;
378
379 ret = regmap_read(bq->regmap, BQ25980_BATOCP, &batocp_reg_code);
380 if (ret)
381 return ret;
382
383 return (batocp_reg_code & BQ25980_BATOCP_MASK) *
384 BQ25980_BATOCP_STEP_uA;
385 }
386
387 static int bq25980_set_const_charge_curr(struct bq25980_device *bq, int batocp)
388 {
389 unsigned int batocp_reg_code;
390 int ret;
391
392 batocp = max(batocp, BQ25980_BATOCP_MIN_uA);
393 batocp = min(batocp, bq->chip_info->batocp_max);
394
395 batocp_reg_code = batocp / BQ25980_BATOCP_STEP_uA;
396
397 ret = regmap_update_bits(bq->regmap, BQ25980_BATOCP,
398 BQ25980_BATOCP_MASK, batocp_reg_code);
399 if (ret)
400 return ret;
401
402 return regmap_update_bits(bq->regmap, BQ25980_BATOCP_ALM,
403 BQ25980_BATOCP_MASK, batocp_reg_code);
404 }
405
406 static int bq25980_get_const_charge_volt(struct bq25980_device *bq)
407 {
408 unsigned int batovp_reg_code;
409 int ret;
410
411 ret = regmap_read(bq->regmap, BQ25980_BATOVP, &batovp_reg_code);
412 if (ret)
413 return ret;
414
415 return ((batovp_reg_code * bq->chip_info->batovp_step) +
416 bq->chip_info->batovp_offset);
417 }
418
419 static int bq25980_set_const_charge_volt(struct bq25980_device *bq, int batovp)
420 {
421 unsigned int batovp_reg_code;
422 int ret;
423
424 if (batovp < bq->chip_info->batovp_min)
425 batovp = bq->chip_info->batovp_min;
426
427 if (batovp > bq->chip_info->batovp_max)
428 batovp = bq->chip_info->batovp_max;
429
430 batovp_reg_code = (batovp - bq->chip_info->batovp_offset) /
431 bq->chip_info->batovp_step;
432
433 ret = regmap_write(bq->regmap, BQ25980_BATOVP, batovp_reg_code);
434 if (ret)
435 return ret;
436
437 return regmap_write(bq->regmap, BQ25980_BATOVP_ALM, batovp_reg_code);
438 }
439
440 static int bq25980_set_bypass(struct bq25980_device *bq, bool en_bypass)
441 {
442 int ret;
443
444 if (en_bypass)
445 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
446 BQ25980_EN_BYPASS, BQ25980_EN_BYPASS);
447 else
448 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
449 BQ25980_EN_BYPASS, en_bypass);
450 if (ret)
451 return ret;
452
453 bq->state.bypass = en_bypass;
454
455 return bq->state.bypass;
456 }
457
458 static int bq25980_set_chg_en(struct bq25980_device *bq, bool en_chg)
459 {
460 int ret;
461
462 if (en_chg)
463 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
464 BQ25980_CHG_EN, BQ25980_CHG_EN);
465 else
466 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
467 BQ25980_CHG_EN, en_chg);
468 if (ret)
469 return ret;
470
471 bq->state.ce = en_chg;
472
473 return 0;
474 }
475
476 static int bq25980_get_adc_ibus(struct bq25980_device *bq)
477 {
478 int ibus_adc_lsb, ibus_adc_msb;
479 u16 ibus_adc;
480 int ret;
481
482 ret = regmap_read(bq->regmap, BQ25980_IBUS_ADC_MSB, &ibus_adc_msb);
483 if (ret)
484 return ret;
485
486 ret = regmap_read(bq->regmap, BQ25980_IBUS_ADC_LSB, &ibus_adc_lsb);
487 if (ret)
488 return ret;
489
490 ibus_adc = (ibus_adc_msb << 8) | ibus_adc_lsb;
491
492 if (ibus_adc_msb & BQ25980_ADC_POLARITY_BIT)
493 return ((ibus_adc ^ 0xffff) + 1) * BQ25980_ADC_CURR_STEP_uA;
494
495 return ibus_adc * BQ25980_ADC_CURR_STEP_uA;
496 }
497
498 static int bq25980_get_adc_vbus(struct bq25980_device *bq)
499 {
500 int vbus_adc_lsb, vbus_adc_msb;
501 u16 vbus_adc;
502 int ret;
503
504 ret = regmap_read(bq->regmap, BQ25980_VBUS_ADC_MSB, &vbus_adc_msb);
505 if (ret)
506 return ret;
507
508 ret = regmap_read(bq->regmap, BQ25980_VBUS_ADC_LSB, &vbus_adc_lsb);
509 if (ret)
510 return ret;
511
512 vbus_adc = (vbus_adc_msb << 8) | vbus_adc_lsb;
513
514 return vbus_adc * BQ25980_ADC_VOLT_STEP_uV;
515 }
516
517 static int bq25980_get_ibat_adc(struct bq25980_device *bq)
518 {
519 int ret;
520 int ibat_adc_lsb, ibat_adc_msb;
521 int ibat_adc;
522
523 ret = regmap_read(bq->regmap, BQ25980_IBAT_ADC_MSB, &ibat_adc_msb);
524 if (ret)
525 return ret;
526
527 ret = regmap_read(bq->regmap, BQ25980_IBAT_ADC_LSB, &ibat_adc_lsb);
528 if (ret)
529 return ret;
530
531 ibat_adc = (ibat_adc_msb << 8) | ibat_adc_lsb;
532
533 if (ibat_adc_msb & BQ25980_ADC_POLARITY_BIT)
534 return ((ibat_adc ^ 0xffff) + 1) * BQ25980_ADC_CURR_STEP_uA;
535
536 return ibat_adc * BQ25980_ADC_CURR_STEP_uA;
537 }
538
539 static int bq25980_get_adc_vbat(struct bq25980_device *bq)
540 {
541 int vsys_adc_lsb, vsys_adc_msb;
542 u16 vsys_adc;
543 int ret;
544
545 ret = regmap_read(bq->regmap, BQ25980_VBAT_ADC_MSB, &vsys_adc_msb);
546 if (ret)
547 return ret;
548
549 ret = regmap_read(bq->regmap, BQ25980_VBAT_ADC_LSB, &vsys_adc_lsb);
550 if (ret)
551 return ret;
552
553 vsys_adc = (vsys_adc_msb << 8) | vsys_adc_lsb;
554
555 return vsys_adc * BQ25980_ADC_VOLT_STEP_uV;
556 }
557
558 static int bq25980_get_state(struct bq25980_device *bq,
559 struct bq25980_state *state)
560 {
561 unsigned int chg_ctrl_2;
562 unsigned int stat1;
563 unsigned int stat2;
564 unsigned int stat3;
565 unsigned int stat4;
566 unsigned int ibat_adc_msb;
567 int ret;
568
569 ret = regmap_read(bq->regmap, BQ25980_STAT1, &stat1);
570 if (ret)
571 return ret;
572
573 ret = regmap_read(bq->regmap, BQ25980_STAT2, &stat2);
574 if (ret)
575 return ret;
576
577 ret = regmap_read(bq->regmap, BQ25980_STAT3, &stat3);
578 if (ret)
579 return ret;
580
581 ret = regmap_read(bq->regmap, BQ25980_STAT4, &stat4);
582 if (ret)
583 return ret;
584
585 ret = regmap_read(bq->regmap, BQ25980_CHRGR_CTRL_2, &chg_ctrl_2);
586 if (ret)
587 return ret;
588
589 ret = regmap_read(bq->regmap, BQ25980_IBAT_ADC_MSB, &ibat_adc_msb);
590 if (ret)
591 return ret;
592
593 state->dischg = ibat_adc_msb & BQ25980_ADC_POLARITY_BIT;
594 state->ovp = (stat1 & BQ25980_STAT1_OVP_MASK) |
595 (stat3 & BQ25980_STAT3_OVP_MASK);
596 state->ocp = (stat1 & BQ25980_STAT1_OCP_MASK) |
597 (stat2 & BQ25980_STAT2_OCP_MASK);
598 state->tflt = stat4 & BQ25980_STAT4_TFLT_MASK;
599 state->wdt = stat4 & BQ25980_WD_STAT;
600 state->online = stat3 & BQ25980_PRESENT_MASK;
601 state->ce = chg_ctrl_2 & BQ25980_CHG_EN;
602 state->hiz = chg_ctrl_2 & BQ25980_EN_HIZ;
603 state->bypass = chg_ctrl_2 & BQ25980_EN_BYPASS;
604
605 return 0;
606 }
607
608 static int bq25980_get_battery_property(struct power_supply *psy,
609 enum power_supply_property psp,
610 union power_supply_propval *val)
611 {
612 struct bq25980_device *bq = power_supply_get_drvdata(psy);
613 int ret = 0;
614
615 switch (psp) {
616 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
617 val->intval = bq->init_data.ichg_max;
618 break;
619
620 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
621 val->intval = bq->init_data.vreg_max;
622 break;
623
624 case POWER_SUPPLY_PROP_CURRENT_NOW:
625 ret = bq25980_get_ibat_adc(bq);
626 val->intval = ret;
627 break;
628
629 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
630 ret = bq25980_get_adc_vbat(bq);
631 if (ret < 0)
632 return ret;
633
634 val->intval = ret;
635 break;
636
637 default:
638 return -EINVAL;
639 }
640
641 return ret;
642 }
643
644 static int bq25980_set_charger_property(struct power_supply *psy,
645 enum power_supply_property prop,
646 const union power_supply_propval *val)
647 {
648 struct bq25980_device *bq = power_supply_get_drvdata(psy);
649 int ret = -EINVAL;
650
651 switch (prop) {
652 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
653 ret = bq25980_set_input_curr_lim(bq, val->intval);
654 if (ret)
655 return ret;
656 break;
657
658 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
659 ret = bq25980_set_input_volt_lim(bq, val->intval);
660 if (ret)
661 return ret;
662 break;
663
664 case POWER_SUPPLY_PROP_CHARGE_TYPE:
665 ret = bq25980_set_bypass(bq, val->intval);
666 if (ret)
667 return ret;
668 break;
669
670 case POWER_SUPPLY_PROP_STATUS:
671 ret = bq25980_set_chg_en(bq, val->intval);
672 if (ret)
673 return ret;
674 break;
675
676 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
677 ret = bq25980_set_const_charge_curr(bq, val->intval);
678 if (ret)
679 return ret;
680 break;
681
682 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
683 ret = bq25980_set_const_charge_volt(bq, val->intval);
684 if (ret)
685 return ret;
686 break;
687
688 default:
689 return -EINVAL;
690 }
691
692 return ret;
693 }
694
695 static int bq25980_get_charger_property(struct power_supply *psy,
696 enum power_supply_property psp,
697 union power_supply_propval *val)
698 {
699 struct bq25980_device *bq = power_supply_get_drvdata(psy);
700 struct bq25980_state state;
701 int ret = 0;
702
703 mutex_lock(&bq->lock);
704 ret = bq25980_get_state(bq, &state);
705 mutex_unlock(&bq->lock);
706 if (ret)
707 return ret;
708
709 switch (psp) {
710 case POWER_SUPPLY_PROP_MANUFACTURER:
711 val->strval = BQ25980_MANUFACTURER;
712 break;
713 case POWER_SUPPLY_PROP_MODEL_NAME:
714 val->strval = bq->model_name;
715 break;
716 case POWER_SUPPLY_PROP_ONLINE:
717 val->intval = state.online;
718 break;
719
720 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
721 ret = bq25980_get_input_volt_lim(bq);
722 if (ret < 0)
723 return ret;
724 val->intval = ret;
725 break;
726
727 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
728 ret = bq25980_get_input_curr_lim(bq);
729 if (ret < 0)
730 return ret;
731
732 val->intval = ret;
733 break;
734
735 case POWER_SUPPLY_PROP_HEALTH:
736 val->intval = POWER_SUPPLY_HEALTH_GOOD;
737
738 if (state.tflt)
739 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
740 else if (state.ovp)
741 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
742 else if (state.ocp)
743 val->intval = POWER_SUPPLY_HEALTH_OVERCURRENT;
744 else if (state.wdt)
745 val->intval =
746 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE;
747 break;
748
749 case POWER_SUPPLY_PROP_STATUS:
750 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
751
752 if ((state.ce) && (!state.hiz))
753 val->intval = POWER_SUPPLY_STATUS_CHARGING;
754 else if (state.dischg)
755 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
756 else if (!state.ce)
757 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
758 break;
759
760 case POWER_SUPPLY_PROP_CHARGE_TYPE:
761 val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
762
763 if (!state.ce)
764 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
765 else if (state.bypass)
766 val->intval = POWER_SUPPLY_CHARGE_TYPE_BYPASS;
767 else if (!state.bypass)
768 val->intval = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
769 break;
770
771 case POWER_SUPPLY_PROP_CURRENT_NOW:
772 ret = bq25980_get_adc_ibus(bq);
773 if (ret < 0)
774 return ret;
775
776 val->intval = ret;
777 break;
778
779 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
780 ret = bq25980_get_adc_vbus(bq);
781 if (ret < 0)
782 return ret;
783
784 val->intval = ret;
785 break;
786
787 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
788 ret = bq25980_get_const_charge_curr(bq);
789 if (ret < 0)
790 return ret;
791
792 val->intval = ret;
793 break;
794
795 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
796 ret = bq25980_get_const_charge_volt(bq);
797 if (ret < 0)
798 return ret;
799
800 val->intval = ret;
801 break;
802
803 default:
804 return -EINVAL;
805 }
806
807 return ret;
808 }
809
810 static bool bq25980_state_changed(struct bq25980_device *bq,
811 struct bq25980_state *new_state)
812 {
813 struct bq25980_state old_state;
814
815 mutex_lock(&bq->lock);
816 old_state = bq->state;
817 mutex_unlock(&bq->lock);
818
819 return (old_state.dischg != new_state->dischg ||
820 old_state.ovp != new_state->ovp ||
821 old_state.ocp != new_state->ocp ||
822 old_state.online != new_state->online ||
823 old_state.wdt != new_state->wdt ||
824 old_state.tflt != new_state->tflt ||
825 old_state.ce != new_state->ce ||
826 old_state.hiz != new_state->hiz ||
827 old_state.bypass != new_state->bypass);
828 }
829
830 static irqreturn_t bq25980_irq_handler_thread(int irq, void *private)
831 {
832 struct bq25980_device *bq = private;
833 struct bq25980_state state;
834 int ret;
835
836 ret = bq25980_get_state(bq, &state);
837 if (ret < 0)
838 goto irq_out;
839
840 if (!bq25980_state_changed(bq, &state))
841 goto irq_out;
842
843 mutex_lock(&bq->lock);
844 bq->state = state;
845 mutex_unlock(&bq->lock);
846
847 power_supply_changed(bq->charger);
848
849 irq_out:
850 return IRQ_HANDLED;
851 }
852
853 static enum power_supply_property bq25980_power_supply_props[] = {
854 POWER_SUPPLY_PROP_MANUFACTURER,
855 POWER_SUPPLY_PROP_MODEL_NAME,
856 POWER_SUPPLY_PROP_STATUS,
857 POWER_SUPPLY_PROP_ONLINE,
858 POWER_SUPPLY_PROP_HEALTH,
859 POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT,
860 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
861 POWER_SUPPLY_PROP_CHARGE_TYPE,
862 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
863 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
864 POWER_SUPPLY_PROP_CURRENT_NOW,
865 POWER_SUPPLY_PROP_VOLTAGE_NOW,
866 };
867
868 static enum power_supply_property bq25980_battery_props[] = {
869 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
870 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
871 POWER_SUPPLY_PROP_CURRENT_NOW,
872 POWER_SUPPLY_PROP_VOLTAGE_NOW,
873 };
874
875 static char *bq25980_charger_supplied_to[] = {
876 "main-battery",
877 };
878
879 static int bq25980_property_is_writeable(struct power_supply *psy,
880 enum power_supply_property prop)
881 {
882 switch (prop) {
883 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
884 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
885 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
886 case POWER_SUPPLY_PROP_CHARGE_TYPE:
887 case POWER_SUPPLY_PROP_STATUS:
888 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
889 return true;
890 default:
891 return false;
892 }
893 }
894
895 static const struct power_supply_desc bq25980_power_supply_desc = {
896 .name = "bq25980-charger",
897 .type = POWER_SUPPLY_TYPE_MAINS,
898 .properties = bq25980_power_supply_props,
899 .num_properties = ARRAY_SIZE(bq25980_power_supply_props),
900 .get_property = bq25980_get_charger_property,
901 .set_property = bq25980_set_charger_property,
902 .property_is_writeable = bq25980_property_is_writeable,
903 };
904
905 static struct power_supply_desc bq25980_battery_desc = {
906 .name = "bq25980-battery",
907 .type = POWER_SUPPLY_TYPE_BATTERY,
908 .get_property = bq25980_get_battery_property,
909 .properties = bq25980_battery_props,
910 .num_properties = ARRAY_SIZE(bq25980_battery_props),
911 .property_is_writeable = bq25980_property_is_writeable,
912 };
913
914
915 static bool bq25980_is_volatile_reg(struct device *dev, unsigned int reg)
916 {
917 switch (reg) {
918 case BQ25980_CHRGR_CTRL_2:
919 case BQ25980_STAT1...BQ25980_FLAG5:
920 case BQ25980_ADC_CONTROL1...BQ25980_TDIE_ADC_LSB:
921 return true;
922 default:
923 return false;
924 }
925 }
926
927 static const struct regmap_config bq25980_regmap_config = {
928 .reg_bits = 8,
929 .val_bits = 8,
930
931 .max_register = BQ25980_CHRGR_CTRL_6,
932 .reg_defaults = bq25980_reg_defs,
933 .num_reg_defaults = ARRAY_SIZE(bq25980_reg_defs),
934 .cache_type = REGCACHE_MAPLE,
935 .volatile_reg = bq25980_is_volatile_reg,
936 };
937
938 static const struct regmap_config bq25975_regmap_config = {
939 .reg_bits = 8,
940 .val_bits = 8,
941
942 .max_register = BQ25980_CHRGR_CTRL_6,
943 .reg_defaults = bq25975_reg_defs,
944 .num_reg_defaults = ARRAY_SIZE(bq25975_reg_defs),
945 .cache_type = REGCACHE_MAPLE,
946 .volatile_reg = bq25980_is_volatile_reg,
947 };
948
949 static const struct regmap_config bq25960_regmap_config = {
950 .reg_bits = 8,
951 .val_bits = 8,
952
953 .max_register = BQ25980_CHRGR_CTRL_6,
954 .reg_defaults = bq25960_reg_defs,
955 .num_reg_defaults = ARRAY_SIZE(bq25960_reg_defs),
956 .cache_type = REGCACHE_MAPLE,
957 .volatile_reg = bq25980_is_volatile_reg,
958 };
959
960 static const struct bq25980_chip_info bq25980_chip_info_tbl[] = {
961 [BQ25980] = {
962 .model_id = BQ25980,
963 .regmap_config = &bq25980_regmap_config,
964
965 .busocp_def = BQ25980_BUSOCP_DFLT_uA,
966 .busocp_sc_min = BQ25960_BUSOCP_SC_MAX_uA,
967 .busocp_sc_max = BQ25980_BUSOCP_SC_MAX_uA,
968 .busocp_byp_max = BQ25980_BUSOCP_BYP_MAX_uA,
969 .busocp_byp_min = BQ25980_BUSOCP_MIN_uA,
970
971 .busovp_sc_def = BQ25980_BUSOVP_DFLT_uV,
972 .busovp_byp_def = BQ25980_BUSOVP_BYPASS_DFLT_uV,
973 .busovp_sc_step = BQ25980_BUSOVP_SC_STEP_uV,
974 .busovp_sc_offset = BQ25980_BUSOVP_SC_OFFSET_uV,
975 .busovp_byp_step = BQ25980_BUSOVP_BYP_STEP_uV,
976 .busovp_byp_offset = BQ25980_BUSOVP_BYP_OFFSET_uV,
977 .busovp_sc_min = BQ25980_BUSOVP_SC_MIN_uV,
978 .busovp_sc_max = BQ25980_BUSOVP_SC_MAX_uV,
979 .busovp_byp_min = BQ25980_BUSOVP_BYP_MIN_uV,
980 .busovp_byp_max = BQ25980_BUSOVP_BYP_MAX_uV,
981
982 .batovp_def = BQ25980_BATOVP_DFLT_uV,
983 .batovp_max = BQ25980_BATOVP_MAX_uV,
984 .batovp_min = BQ25980_BATOVP_MIN_uV,
985 .batovp_step = BQ25980_BATOVP_STEP_uV,
986 .batovp_offset = BQ25980_BATOVP_OFFSET_uV,
987
988 .batocp_def = BQ25980_BATOCP_DFLT_uA,
989 .batocp_max = BQ25980_BATOCP_MAX_uA,
990 },
991
992 [BQ25975] = {
993 .model_id = BQ25975,
994 .regmap_config = &bq25975_regmap_config,
995
996 .busocp_def = BQ25975_BUSOCP_DFLT_uA,
997 .busocp_sc_min = BQ25975_BUSOCP_SC_MAX_uA,
998 .busocp_sc_max = BQ25975_BUSOCP_SC_MAX_uA,
999 .busocp_byp_min = BQ25980_BUSOCP_MIN_uA,
1000 .busocp_byp_max = BQ25975_BUSOCP_BYP_MAX_uA,
1001
1002 .busovp_sc_def = BQ25975_BUSOVP_DFLT_uV,
1003 .busovp_byp_def = BQ25975_BUSOVP_BYPASS_DFLT_uV,
1004 .busovp_sc_step = BQ25975_BUSOVP_SC_STEP_uV,
1005 .busovp_sc_offset = BQ25975_BUSOVP_SC_OFFSET_uV,
1006 .busovp_byp_step = BQ25975_BUSOVP_BYP_STEP_uV,
1007 .busovp_byp_offset = BQ25975_BUSOVP_BYP_OFFSET_uV,
1008 .busovp_sc_min = BQ25975_BUSOVP_SC_MIN_uV,
1009 .busovp_sc_max = BQ25975_BUSOVP_SC_MAX_uV,
1010 .busovp_byp_min = BQ25975_BUSOVP_BYP_MIN_uV,
1011 .busovp_byp_max = BQ25975_BUSOVP_BYP_MAX_uV,
1012
1013 .batovp_def = BQ25975_BATOVP_DFLT_uV,
1014 .batovp_max = BQ25975_BATOVP_MAX_uV,
1015 .batovp_min = BQ25975_BATOVP_MIN_uV,
1016 .batovp_step = BQ25975_BATOVP_STEP_uV,
1017 .batovp_offset = BQ25975_BATOVP_OFFSET_uV,
1018
1019 .batocp_def = BQ25980_BATOCP_DFLT_uA,
1020 .batocp_max = BQ25980_BATOCP_MAX_uA,
1021 },
1022
1023 [BQ25960] = {
1024 .model_id = BQ25960,
1025 .regmap_config = &bq25960_regmap_config,
1026
1027 .busocp_def = BQ25960_BUSOCP_DFLT_uA,
1028 .busocp_sc_min = BQ25960_BUSOCP_SC_MAX_uA,
1029 .busocp_sc_max = BQ25960_BUSOCP_SC_MAX_uA,
1030 .busocp_byp_min = BQ25960_BUSOCP_SC_MAX_uA,
1031 .busocp_byp_max = BQ25960_BUSOCP_BYP_MAX_uA,
1032
1033 .busovp_sc_def = BQ25975_BUSOVP_DFLT_uV,
1034 .busovp_byp_def = BQ25975_BUSOVP_BYPASS_DFLT_uV,
1035 .busovp_sc_step = BQ25960_BUSOVP_SC_STEP_uV,
1036 .busovp_sc_offset = BQ25960_BUSOVP_SC_OFFSET_uV,
1037 .busovp_byp_step = BQ25960_BUSOVP_BYP_STEP_uV,
1038 .busovp_byp_offset = BQ25960_BUSOVP_BYP_OFFSET_uV,
1039 .busovp_sc_min = BQ25960_BUSOVP_SC_MIN_uV,
1040 .busovp_sc_max = BQ25960_BUSOVP_SC_MAX_uV,
1041 .busovp_byp_min = BQ25960_BUSOVP_BYP_MIN_uV,
1042 .busovp_byp_max = BQ25960_BUSOVP_BYP_MAX_uV,
1043
1044 .batovp_def = BQ25960_BATOVP_DFLT_uV,
1045 .batovp_max = BQ25960_BATOVP_MAX_uV,
1046 .batovp_min = BQ25960_BATOVP_MIN_uV,
1047 .batovp_step = BQ25960_BATOVP_STEP_uV,
1048 .batovp_offset = BQ25960_BATOVP_OFFSET_uV,
1049
1050 .batocp_def = BQ25960_BATOCP_DFLT_uA,
1051 .batocp_max = BQ25960_BATOCP_MAX_uA,
1052 },
1053 };
1054
1055 static int bq25980_power_supply_init(struct bq25980_device *bq,
1056 struct device *dev)
1057 {
1058 struct power_supply_config psy_cfg = { .drv_data = bq,
1059 .fwnode = dev_fwnode(dev), };
1060
1061 psy_cfg.supplied_to = bq25980_charger_supplied_to;
1062 psy_cfg.num_supplicants = ARRAY_SIZE(bq25980_charger_supplied_to);
1063
1064 bq->charger = devm_power_supply_register(bq->dev,
1065 &bq25980_power_supply_desc,
1066 &psy_cfg);
1067 if (IS_ERR(bq->charger))
1068 return -EINVAL;
1069
1070 bq->battery = devm_power_supply_register(bq->dev,
1071 &bq25980_battery_desc,
1072 &psy_cfg);
1073 if (IS_ERR(bq->battery))
1074 return -EINVAL;
1075
1076 return 0;
1077 }
1078
1079 static int bq25980_hw_init(struct bq25980_device *bq)
1080 {
1081 struct power_supply_battery_info *bat_info;
1082 int wd_reg_val = BQ25980_WATCHDOG_DIS;
1083 int wd_max_val = BQ25980_NUM_WD_VAL - 1;
1084 int ret = 0;
1085 int curr_val;
1086 int volt_val;
1087 int i;
1088
1089 if (bq->watchdog_timer) {
1090 if (bq->watchdog_timer >= bq25980_watchdog_time[wd_max_val])
1091 wd_reg_val = wd_max_val;
1092 else {
1093 for (i = 0; i < wd_max_val; i++) {
1094 if (bq->watchdog_timer > bq25980_watchdog_time[i] &&
1095 bq->watchdog_timer < bq25980_watchdog_time[i + 1]) {
1096 wd_reg_val = i;
1097 break;
1098 }
1099 }
1100 }
1101 }
1102
1103 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_3,
1104 BQ25980_WATCHDOG_MASK, wd_reg_val);
1105 if (ret)
1106 return ret;
1107
1108 ret = power_supply_get_battery_info(bq->charger, &bat_info);
1109 if (ret) {
1110 dev_warn(bq->dev, "battery info missing\n");
1111 return -EINVAL;
1112 }
1113
1114 bq->init_data.ichg_max = bat_info->constant_charge_current_max_ua;
1115 bq->init_data.vreg_max = bat_info->constant_charge_voltage_max_uv;
1116
1117 if (bq->state.bypass) {
1118 ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
1119 BQ25980_EN_BYPASS, BQ25980_EN_BYPASS);
1120 if (ret)
1121 return ret;
1122
1123 curr_val = bq->init_data.bypass_ilim;
1124 volt_val = bq->init_data.bypass_vlim;
1125 } else {
1126 curr_val = bq->init_data.sc_ilim;
1127 volt_val = bq->init_data.sc_vlim;
1128 }
1129
1130 ret = bq25980_set_input_curr_lim(bq, curr_val);
1131 if (ret)
1132 return ret;
1133
1134 ret = bq25980_set_input_volt_lim(bq, volt_val);
1135 if (ret)
1136 return ret;
1137
1138 return regmap_update_bits(bq->regmap, BQ25980_ADC_CONTROL1,
1139 BQ25980_ADC_EN, BQ25980_ADC_EN);
1140 }
1141
1142 static int bq25980_parse_dt(struct bq25980_device *bq)
1143 {
1144 int ret;
1145
1146 ret = device_property_read_u32(bq->dev, "ti,watchdog-timeout-ms",
1147 &bq->watchdog_timer);
1148 if (ret)
1149 bq->watchdog_timer = BQ25980_WATCHDOG_MIN;
1150
1151 if (bq->watchdog_timer > BQ25980_WATCHDOG_MAX ||
1152 bq->watchdog_timer < BQ25980_WATCHDOG_MIN)
1153 return -EINVAL;
1154
1155 ret = device_property_read_u32(bq->dev,
1156 "ti,sc-ovp-limit-microvolt",
1157 &bq->init_data.sc_vlim);
1158 if (ret)
1159 bq->init_data.sc_vlim = bq->chip_info->busovp_sc_def;
1160
1161 if (bq->init_data.sc_vlim > bq->chip_info->busovp_sc_max ||
1162 bq->init_data.sc_vlim < bq->chip_info->busovp_sc_min) {
1163 dev_err(bq->dev, "SC ovp limit is out of range\n");
1164 return -EINVAL;
1165 }
1166
1167 ret = device_property_read_u32(bq->dev,
1168 "ti,sc-ocp-limit-microamp",
1169 &bq->init_data.sc_ilim);
1170 if (ret)
1171 bq->init_data.sc_ilim = bq->chip_info->busocp_def;
1172
1173 if (bq->init_data.sc_ilim > bq->chip_info->busocp_sc_max ||
1174 bq->init_data.sc_ilim < bq->chip_info->busocp_sc_min) {
1175 dev_err(bq->dev, "SC ocp limit is out of range\n");
1176 return -EINVAL;
1177 }
1178
1179 ret = device_property_read_u32(bq->dev,
1180 "ti,bypass-ovp-limit-microvolt",
1181 &bq->init_data.bypass_vlim);
1182 if (ret)
1183 bq->init_data.bypass_vlim = bq->chip_info->busovp_byp_def;
1184
1185 if (bq->init_data.bypass_vlim > bq->chip_info->busovp_byp_max ||
1186 bq->init_data.bypass_vlim < bq->chip_info->busovp_byp_min) {
1187 dev_err(bq->dev, "Bypass ovp limit is out of range\n");
1188 return -EINVAL;
1189 }
1190
1191 ret = device_property_read_u32(bq->dev,
1192 "ti,bypass-ocp-limit-microamp",
1193 &bq->init_data.bypass_ilim);
1194 if (ret)
1195 bq->init_data.bypass_ilim = bq->chip_info->busocp_def;
1196
1197 if (bq->init_data.bypass_ilim > bq->chip_info->busocp_byp_max ||
1198 bq->init_data.bypass_ilim < bq->chip_info->busocp_byp_min) {
1199 dev_err(bq->dev, "Bypass ocp limit is out of range\n");
1200 return -EINVAL;
1201 }
1202
1203
1204 bq->state.bypass = device_property_read_bool(bq->dev,
1205 "ti,bypass-enable");
1206 return 0;
1207 }
1208
1209 static int bq25980_probe(struct i2c_client *client)
1210 {
1211 const struct i2c_device_id *id = i2c_client_get_device_id(client);
1212 struct device *dev = &client->dev;
1213 struct bq25980_device *bq;
1214 int ret;
1215
1216 bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
1217 if (!bq)
1218 return -ENOMEM;
1219
1220 bq->client = client;
1221 bq->dev = dev;
1222
1223 mutex_init(&bq->lock);
1224
1225 strscpy(bq->model_name, id->name, sizeof(bq->model_name));
1226 bq->chip_info = &bq25980_chip_info_tbl[id->driver_data];
1227
1228 bq->regmap = devm_regmap_init_i2c(client,
1229 bq->chip_info->regmap_config);
1230 if (IS_ERR(bq->regmap)) {
1231 dev_err(dev, "Failed to allocate register map\n");
1232 return PTR_ERR(bq->regmap);
1233 }
1234
1235 i2c_set_clientdata(client, bq);
1236
1237 ret = bq25980_parse_dt(bq);
1238 if (ret) {
1239 dev_err(dev, "Failed to read device tree properties%d\n", ret);
1240 return ret;
1241 }
1242
1243 ret = bq25980_power_supply_init(bq, dev);
1244 if (ret) {
1245 dev_err(dev, "Failed to register power supply\n");
1246 return ret;
1247 }
1248
1249 if (client->irq) {
1250 ret = devm_request_threaded_irq(dev, client->irq, NULL,
1251 bq25980_irq_handler_thread,
1252 IRQF_TRIGGER_FALLING |
1253 IRQF_ONESHOT,
1254 dev_name(&client->dev), bq);
1255 if (ret)
1256 return ret;
1257 }
1258
1259 ret = bq25980_hw_init(bq);
1260 if (ret) {
1261 dev_err(dev, "Cannot initialize the chip.\n");
1262 return ret;
1263 }
1264
1265 return 0;
1266 }
1267
1268 static const struct i2c_device_id bq25980_i2c_ids[] = {
1269 { "bq25980", BQ25980 },
1270 { "bq25975", BQ25975 },
1271 { "bq25960", BQ25960 },
1272 {},
1273 };
1274 MODULE_DEVICE_TABLE(i2c, bq25980_i2c_ids);
1275
1276 static const struct of_device_id bq25980_of_match[] = {
1277 { .compatible = "ti,bq25980", .data = (void *)BQ25980 },
1278 { .compatible = "ti,bq25975", .data = (void *)BQ25975 },
1279 { .compatible = "ti,bq25960", .data = (void *)BQ25960 },
1280 { },
1281 };
1282 MODULE_DEVICE_TABLE(of, bq25980_of_match);
1283
1284 static struct i2c_driver bq25980_driver = {
1285 .driver = {
1286 .name = "bq25980-charger",
1287 .of_match_table = bq25980_of_match,
1288 },
1289 .probe = bq25980_probe,
1290 .id_table = bq25980_i2c_ids,
1291 };
1292 module_i2c_driver(bq25980_driver);
1293
1294 MODULE_AUTHOR("Dan Murphy <[email protected]>");
1295 MODULE_AUTHOR("Ricardo Rivera-Matos <[email protected]>");
1296 MODULE_DESCRIPTION("bq25980 charger driver");
1297 MODULE_LICENSE("GPL v2");