1 /*
2 * ADP5061 I2C Programmable Linear Battery Charger
3 *
4 * Copyright 2018 Analog Devices Inc.
5 *
6 * Licensed under the GPL-2.
7 */
8
9 #include <linux/init.h>
10 #include <linux/module.h>
11 #include <linux/slab.h>
12 #include <linux/i2c.h>
13 #include <linux/delay.h>
14 #include <linux/pm.h>
15 #include <linux/mod_devicetable.h>
16 #include <linux/power_supply.h>
17 #include <linux/platform_device.h>
18 #include <linux/of.h>
19 #include <linux/regmap.h>
20
21 /* ADP5061 registers definition */
22 #define ADP5061_ID 0x00
23 #define ADP5061_REV 0x01
24 #define ADP5061_VINX_SET 0x02
25 #define ADP5061_TERM_SET 0x03
26 #define ADP5061_CHG_CURR 0x04
27 #define ADP5061_VOLTAGE_TH 0x05
28 #define ADP5061_TIMER_SET 0x06
29 #define ADP5061_FUNC_SET_1 0x07
30 #define ADP5061_FUNC_SET_2 0x08
31 #define ADP5061_INT_EN 0x09
32 #define ADP5061_INT_ACT 0x0A
33 #define ADP5061_CHG_STATUS_1 0x0B
34 #define ADP5061_CHG_STATUS_2 0x0C
35 #define ADP5061_FAULT 0x0D
36 #define ADP5061_BATTERY_SHORT 0x10
37 #define ADP5061_IEND 0x11
38
39 /* ADP5061_VINX_SET */
40 #define ADP5061_VINX_SET_ILIM_MSK GENMASK(3, 0)
41 #define ADP5061_VINX_SET_ILIM_MODE(x) (((x) & 0x0F) << 0)
42
43 /* ADP5061_TERM_SET */
44 #define ADP5061_TERM_SET_VTRM_MSK GENMASK(7, 2)
45 #define ADP5061_TERM_SET_VTRM_MODE(x) (((x) & 0x3F) << 2)
46 #define ADP5061_TERM_SET_CHG_VLIM_MSK GENMASK(1, 0)
47 #define ADP5061_TERM_SET_CHG_VLIM_MODE(x) (((x) & 0x03) << 0)
48
49 /* ADP5061_CHG_CURR */
50 #define ADP5061_CHG_CURR_ICHG_MSK GENMASK(6, 2)
51 #define ADP5061_CHG_CURR_ICHG_MODE(x) (((x) & 0x1F) << 2)
52 #define ADP5061_CHG_CURR_ITRK_DEAD_MSK GENMASK(1, 0)
53 #define ADP5061_CHG_CURR_ITRK_DEAD_MODE(x) (((x) & 0x03) << 0)
54
55 /* ADP5061_VOLTAGE_TH */
56 #define ADP5061_VOLTAGE_TH_DIS_RCH_MSK BIT(7)
57 #define ADP5061_VOLTAGE_TH_DIS_RCH_MODE(x) (((x) & 0x01) << 7)
58 #define ADP5061_VOLTAGE_TH_VRCH_MSK GENMASK(6, 5)
59 #define ADP5061_VOLTAGE_TH_VRCH_MODE(x) (((x) & 0x03) << 5)
60 #define ADP5061_VOLTAGE_TH_VTRK_DEAD_MSK GENMASK(4, 3)
61 #define ADP5061_VOLTAGE_TH_VTRK_DEAD_MODE(x) (((x) & 0x03) << 3)
62 #define ADP5061_VOLTAGE_TH_VWEAK_MSK GENMASK(2, 0)
63 #define ADP5061_VOLTAGE_TH_VWEAK_MODE(x) (((x) & 0x07) << 0)
64
65 /* ADP5061_CHG_STATUS_1 */
66 #define ADP5061_CHG_STATUS_1_VIN_OV(x) (((x) >> 7) & 0x1)
67 #define ADP5061_CHG_STATUS_1_VIN_OK(x) (((x) >> 6) & 0x1)
68 #define ADP5061_CHG_STATUS_1_VIN_ILIM(x) (((x) >> 5) & 0x1)
69 #define ADP5061_CHG_STATUS_1_THERM_LIM(x) (((x) >> 4) & 0x1)
70 #define ADP5061_CHG_STATUS_1_CHDONE(x) (((x) >> 3) & 0x1)
71 #define ADP5061_CHG_STATUS_1_CHG_STATUS(x) (((x) >> 0) & 0x7)
72
73 /* ADP5061_CHG_STATUS_2 */
74 #define ADP5061_CHG_STATUS_2_THR_STATUS(x) (((x) >> 5) & 0x7)
75 #define ADP5061_CHG_STATUS_2_RCH_LIM_INFO(x) (((x) >> 3) & 0x1)
76 #define ADP5061_CHG_STATUS_2_BAT_STATUS(x) (((x) >> 0) & 0x7)
77
78 /* ADP5061_IEND */
79 #define ADP5061_IEND_IEND_MSK GENMASK(7, 5)
80 #define ADP5061_IEND_IEND_MODE(x) (((x) & 0x07) << 5)
81
82 #define ADP5061_NO_BATTERY 0x01
83 #define ADP5061_ICHG_MAX 1300 // mA
84
85 enum adp5061_chg_status {
86 ADP5061_CHG_OFF,
87 ADP5061_CHG_TRICKLE,
88 ADP5061_CHG_FAST_CC,
89 ADP5061_CHG_FAST_CV,
90 ADP5061_CHG_COMPLETE,
91 ADP5061_CHG_LDO_MODE,
92 ADP5061_CHG_TIMER_EXP,
93 ADP5061_CHG_BAT_DET,
94 };
95
96 static const int adp5061_chg_type[4] = {
97 [ADP5061_CHG_OFF] = POWER_SUPPLY_CHARGE_TYPE_NONE,
98 [ADP5061_CHG_TRICKLE] = POWER_SUPPLY_CHARGE_TYPE_TRICKLE,
99 [ADP5061_CHG_FAST_CC] = POWER_SUPPLY_CHARGE_TYPE_FAST,
100 [ADP5061_CHG_FAST_CV] = POWER_SUPPLY_CHARGE_TYPE_FAST,
101 };
102
103 static const int adp5061_vweak_th[8] = {
104 2700, 2800, 2900, 3000, 3100, 3200, 3300, 3400,
105 };
106
107 static const int adp5061_prechg_current[4] = {
108 5, 10, 20, 80,
109 };
110
111 static const int adp5061_vmin[4] = {
112 2000, 2500, 2600, 2900,
113 };
114
115 static const int adp5061_const_chg_vmax[4] = {
116 3200, 3400, 3700, 3800,
117 };
118
119 static const int adp5061_const_ichg[24] = {
120 50, 100, 150, 200, 250, 300, 350, 400, 450, 500, 550, 600, 650,
121 700, 750, 800, 850, 900, 950, 1000, 1050, 1100, 1200, 1300,
122 };
123
124 static const int adp5061_vmax[36] = {
125 3800, 3820, 3840, 3860, 3880, 3900, 3920, 3940, 3960, 3980,
126 4000, 4020, 4040, 4060, 4080, 4100, 4120, 4140, 4160, 4180,
127 4200, 4220, 4240, 4260, 4280, 4300, 4320, 4340, 4360, 4380,
128 4400, 4420, 4440, 4460, 4480, 4500,
129 };
130
131 static const int adp5061_in_current_lim[16] = {
132 100, 150, 200, 250, 300, 400, 500, 600, 700,
133 800, 900, 1000, 1200, 1500, 1800, 2100,
134 };
135
136 static const int adp5061_iend[8] = {
137 12500, 32500, 52500, 72500, 92500, 117500, 142500, 170000,
138 };
139
140 struct adp5061_state {
141 struct i2c_client *client;
142 struct regmap *regmap;
143 struct power_supply *psy;
144 };
145
adp5061_get_array_index(const int * array,u8 size,int val)146 static int adp5061_get_array_index(const int *array, u8 size, int val)
147 {
148 int i;
149
150 for (i = 1; i < size; i++) {
151 if (val < array[i])
152 break;
153 }
154
155 return i-1;
156 }
157
adp5061_get_status(struct adp5061_state * st,u8 * status1,u8 * status2)158 static int adp5061_get_status(struct adp5061_state *st,
159 u8 *status1, u8 *status2)
160 {
161 u8 buf[2];
162 int ret;
163
164 /* CHG_STATUS1 and CHG_STATUS2 are adjacent regs */
165 ret = regmap_bulk_read(st->regmap, ADP5061_CHG_STATUS_1,
166 &buf[0], 2);
167 if (ret < 0)
168 return ret;
169
170 *status1 = buf[0];
171 *status2 = buf[1];
172
173 return ret;
174 }
175
adp5061_get_input_current_limit(struct adp5061_state * st,union power_supply_propval * val)176 static int adp5061_get_input_current_limit(struct adp5061_state *st,
177 union power_supply_propval *val)
178 {
179 unsigned int regval;
180 int mode, ret;
181
182 ret = regmap_read(st->regmap, ADP5061_VINX_SET, ®val);
183 if (ret < 0)
184 return ret;
185
186 mode = ADP5061_VINX_SET_ILIM_MODE(regval);
187 val->intval = adp5061_in_current_lim[mode] * 1000;
188
189 return ret;
190 }
191
adp5061_set_input_current_limit(struct adp5061_state * st,int val)192 static int adp5061_set_input_current_limit(struct adp5061_state *st, int val)
193 {
194 int index;
195
196 /* Convert from uA to mA */
197 val /= 1000;
198 index = adp5061_get_array_index(adp5061_in_current_lim,
199 ARRAY_SIZE(adp5061_in_current_lim),
200 val);
201 if (index < 0)
202 return index;
203
204 return regmap_update_bits(st->regmap, ADP5061_VINX_SET,
205 ADP5061_VINX_SET_ILIM_MSK,
206 ADP5061_VINX_SET_ILIM_MODE(index));
207 }
208
adp5061_set_min_voltage(struct adp5061_state * st,int val)209 static int adp5061_set_min_voltage(struct adp5061_state *st, int val)
210 {
211 int index;
212
213 /* Convert from uV to mV */
214 val /= 1000;
215 index = adp5061_get_array_index(adp5061_vmin,
216 ARRAY_SIZE(adp5061_vmin),
217 val);
218 if (index < 0)
219 return index;
220
221 return regmap_update_bits(st->regmap, ADP5061_VOLTAGE_TH,
222 ADP5061_VOLTAGE_TH_VTRK_DEAD_MSK,
223 ADP5061_VOLTAGE_TH_VTRK_DEAD_MODE(index));
224 }
225
adp5061_get_min_voltage(struct adp5061_state * st,union power_supply_propval * val)226 static int adp5061_get_min_voltage(struct adp5061_state *st,
227 union power_supply_propval *val)
228 {
229 unsigned int regval;
230 int ret;
231
232 ret = regmap_read(st->regmap, ADP5061_VOLTAGE_TH, ®val);
233 if (ret < 0)
234 return ret;
235
236 regval = ((regval & ADP5061_VOLTAGE_TH_VTRK_DEAD_MSK) >> 3);
237 val->intval = adp5061_vmin[regval] * 1000;
238
239 return ret;
240 }
241
adp5061_get_chg_volt_lim(struct adp5061_state * st,union power_supply_propval * val)242 static int adp5061_get_chg_volt_lim(struct adp5061_state *st,
243 union power_supply_propval *val)
244 {
245 unsigned int regval;
246 int mode, ret;
247
248 ret = regmap_read(st->regmap, ADP5061_TERM_SET, ®val);
249 if (ret < 0)
250 return ret;
251
252 mode = ADP5061_TERM_SET_CHG_VLIM_MODE(regval);
253 val->intval = adp5061_const_chg_vmax[mode] * 1000;
254
255 return ret;
256 }
257
adp5061_get_max_voltage(struct adp5061_state * st,union power_supply_propval * val)258 static int adp5061_get_max_voltage(struct adp5061_state *st,
259 union power_supply_propval *val)
260 {
261 unsigned int regval;
262 int ret;
263
264 ret = regmap_read(st->regmap, ADP5061_TERM_SET, ®val);
265 if (ret < 0)
266 return ret;
267
268 regval = ((regval & ADP5061_TERM_SET_VTRM_MSK) >> 2) - 0x0F;
269 if (regval >= ARRAY_SIZE(adp5061_vmax))
270 regval = ARRAY_SIZE(adp5061_vmax) - 1;
271
272 val->intval = adp5061_vmax[regval] * 1000;
273
274 return ret;
275 }
276
adp5061_set_max_voltage(struct adp5061_state * st,int val)277 static int adp5061_set_max_voltage(struct adp5061_state *st, int val)
278 {
279 int vmax_index;
280
281 /* Convert from uV to mV */
282 val /= 1000;
283 if (val > 4500)
284 val = 4500;
285
286 vmax_index = adp5061_get_array_index(adp5061_vmax,
287 ARRAY_SIZE(adp5061_vmax), val);
288 if (vmax_index < 0)
289 return vmax_index;
290
291 vmax_index += 0x0F;
292
293 return regmap_update_bits(st->regmap, ADP5061_TERM_SET,
294 ADP5061_TERM_SET_VTRM_MSK,
295 ADP5061_TERM_SET_VTRM_MODE(vmax_index));
296 }
297
adp5061_set_const_chg_vmax(struct adp5061_state * st,int val)298 static int adp5061_set_const_chg_vmax(struct adp5061_state *st, int val)
299 {
300 int index;
301
302 /* Convert from uV to mV */
303 val /= 1000;
304 index = adp5061_get_array_index(adp5061_const_chg_vmax,
305 ARRAY_SIZE(adp5061_const_chg_vmax),
306 val);
307 if (index < 0)
308 return index;
309
310 return regmap_update_bits(st->regmap, ADP5061_TERM_SET,
311 ADP5061_TERM_SET_CHG_VLIM_MSK,
312 ADP5061_TERM_SET_CHG_VLIM_MODE(index));
313 }
314
adp5061_set_const_chg_current(struct adp5061_state * st,int val)315 static int adp5061_set_const_chg_current(struct adp5061_state *st, int val)
316 {
317
318 int index;
319
320 /* Convert from uA to mA */
321 val /= 1000;
322 if (val > ADP5061_ICHG_MAX)
323 val = ADP5061_ICHG_MAX;
324
325 index = adp5061_get_array_index(adp5061_const_ichg,
326 ARRAY_SIZE(adp5061_const_ichg),
327 val);
328 if (index < 0)
329 return index;
330
331 return regmap_update_bits(st->regmap, ADP5061_CHG_CURR,
332 ADP5061_CHG_CURR_ICHG_MSK,
333 ADP5061_CHG_CURR_ICHG_MODE(index));
334 }
335
adp5061_get_const_chg_current(struct adp5061_state * st,union power_supply_propval * val)336 static int adp5061_get_const_chg_current(struct adp5061_state *st,
337 union power_supply_propval *val)
338 {
339 unsigned int regval;
340 int ret;
341
342 ret = regmap_read(st->regmap, ADP5061_CHG_CURR, ®val);
343 if (ret < 0)
344 return ret;
345
346 regval = ((regval & ADP5061_CHG_CURR_ICHG_MSK) >> 2);
347 if (regval >= ARRAY_SIZE(adp5061_const_ichg))
348 regval = ARRAY_SIZE(adp5061_const_ichg) - 1;
349
350 val->intval = adp5061_const_ichg[regval] * 1000;
351
352 return ret;
353 }
354
adp5061_get_prechg_current(struct adp5061_state * st,union power_supply_propval * val)355 static int adp5061_get_prechg_current(struct adp5061_state *st,
356 union power_supply_propval *val)
357 {
358 unsigned int regval;
359 int ret;
360
361 ret = regmap_read(st->regmap, ADP5061_CHG_CURR, ®val);
362 if (ret < 0)
363 return ret;
364
365 regval &= ADP5061_CHG_CURR_ITRK_DEAD_MSK;
366 val->intval = adp5061_prechg_current[regval] * 1000;
367
368 return ret;
369 }
370
adp5061_set_prechg_current(struct adp5061_state * st,int val)371 static int adp5061_set_prechg_current(struct adp5061_state *st, int val)
372 {
373 int index;
374
375 /* Convert from uA to mA */
376 val /= 1000;
377 index = adp5061_get_array_index(adp5061_prechg_current,
378 ARRAY_SIZE(adp5061_prechg_current),
379 val);
380 if (index < 0)
381 return index;
382
383 return regmap_update_bits(st->regmap, ADP5061_CHG_CURR,
384 ADP5061_CHG_CURR_ITRK_DEAD_MSK,
385 ADP5061_CHG_CURR_ITRK_DEAD_MODE(index));
386 }
387
adp5061_get_vweak_th(struct adp5061_state * st,union power_supply_propval * val)388 static int adp5061_get_vweak_th(struct adp5061_state *st,
389 union power_supply_propval *val)
390 {
391 unsigned int regval;
392 int ret;
393
394 ret = regmap_read(st->regmap, ADP5061_VOLTAGE_TH, ®val);
395 if (ret < 0)
396 return ret;
397
398 regval &= ADP5061_VOLTAGE_TH_VWEAK_MSK;
399 val->intval = adp5061_vweak_th[regval] * 1000;
400
401 return ret;
402 }
403
adp5061_set_vweak_th(struct adp5061_state * st,int val)404 static int adp5061_set_vweak_th(struct adp5061_state *st, int val)
405 {
406 int index;
407
408 /* Convert from uV to mV */
409 val /= 1000;
410 index = adp5061_get_array_index(adp5061_vweak_th,
411 ARRAY_SIZE(adp5061_vweak_th),
412 val);
413 if (index < 0)
414 return index;
415
416 return regmap_update_bits(st->regmap, ADP5061_VOLTAGE_TH,
417 ADP5061_VOLTAGE_TH_VWEAK_MSK,
418 ADP5061_VOLTAGE_TH_VWEAK_MODE(index));
419 }
420
adp5061_get_chg_type(struct adp5061_state * st,union power_supply_propval * val)421 static int adp5061_get_chg_type(struct adp5061_state *st,
422 union power_supply_propval *val)
423 {
424 u8 status1, status2;
425 int chg_type, ret;
426
427 ret = adp5061_get_status(st, &status1, &status2);
428 if (ret < 0)
429 return ret;
430
431 chg_type = adp5061_chg_type[ADP5061_CHG_STATUS_1_CHG_STATUS(status1)];
432 if (chg_type > ADP5061_CHG_FAST_CV)
433 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
434 else
435 val->intval = chg_type;
436
437 return ret;
438 }
439
adp5061_get_charger_status(struct adp5061_state * st,union power_supply_propval * val)440 static int adp5061_get_charger_status(struct adp5061_state *st,
441 union power_supply_propval *val)
442 {
443 u8 status1, status2;
444 int ret;
445
446 ret = adp5061_get_status(st, &status1, &status2);
447 if (ret < 0)
448 return ret;
449
450 switch (ADP5061_CHG_STATUS_1_CHG_STATUS(status1)) {
451 case ADP5061_CHG_OFF:
452 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
453 break;
454 case ADP5061_CHG_TRICKLE:
455 case ADP5061_CHG_FAST_CC:
456 case ADP5061_CHG_FAST_CV:
457 val->intval = POWER_SUPPLY_STATUS_CHARGING;
458 break;
459 case ADP5061_CHG_COMPLETE:
460 val->intval = POWER_SUPPLY_STATUS_FULL;
461 break;
462 case ADP5061_CHG_TIMER_EXP:
463 /* The battery must be discharging if there is a charge fault */
464 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
465 break;
466 default:
467 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
468 }
469
470 return ret;
471 }
472
adp5061_get_battery_status(struct adp5061_state * st,union power_supply_propval * val)473 static int adp5061_get_battery_status(struct adp5061_state *st,
474 union power_supply_propval *val)
475 {
476 u8 status1, status2;
477 int ret;
478
479 ret = adp5061_get_status(st, &status1, &status2);
480 if (ret < 0)
481 return ret;
482
483 switch (ADP5061_CHG_STATUS_2_BAT_STATUS(status2)) {
484 case 0x0: /* Battery monitor off */
485 case 0x1: /* No battery */
486 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
487 break;
488 case 0x2: /* VBAT < VTRK */
489 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
490 break;
491 case 0x3: /* VTRK < VBAT_SNS < VWEAK */
492 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
493 break;
494 case 0x4: /* VBAT_SNS > VWEAK */
495 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
496 break;
497 }
498
499 return ret;
500 }
501
adp5061_get_termination_current(struct adp5061_state * st,union power_supply_propval * val)502 static int adp5061_get_termination_current(struct adp5061_state *st,
503 union power_supply_propval *val)
504 {
505 unsigned int regval;
506 int ret;
507
508 ret = regmap_read(st->regmap, ADP5061_IEND, ®val);
509 if (ret < 0)
510 return ret;
511
512 regval = (regval & ADP5061_IEND_IEND_MSK) >> 5;
513 val->intval = adp5061_iend[regval];
514
515 return ret;
516 }
517
adp5061_set_termination_current(struct adp5061_state * st,int val)518 static int adp5061_set_termination_current(struct adp5061_state *st, int val)
519 {
520 int index;
521
522 index = adp5061_get_array_index(adp5061_iend,
523 ARRAY_SIZE(adp5061_iend),
524 val);
525 if (index < 0)
526 return index;
527
528 return regmap_update_bits(st->regmap, ADP5061_IEND,
529 ADP5061_IEND_IEND_MSK,
530 ADP5061_IEND_IEND_MODE(index));
531 }
532
adp5061_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)533 static int adp5061_get_property(struct power_supply *psy,
534 enum power_supply_property psp,
535 union power_supply_propval *val)
536 {
537 struct adp5061_state *st = power_supply_get_drvdata(psy);
538 u8 status1, status2;
539 int mode, ret;
540
541 switch (psp) {
542 case POWER_SUPPLY_PROP_PRESENT:
543 ret = adp5061_get_status(st, &status1, &status2);
544 if (ret < 0)
545 return ret;
546
547 mode = ADP5061_CHG_STATUS_2_BAT_STATUS(status2);
548 if (mode == ADP5061_NO_BATTERY)
549 val->intval = 0;
550 else
551 val->intval = 1;
552 break;
553 case POWER_SUPPLY_PROP_CHARGE_TYPE:
554 return adp5061_get_chg_type(st, val);
555 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
556 /* This property is used to indicate the input current
557 * limit into VINx (ILIM)
558 */
559 return adp5061_get_input_current_limit(st, val);
560 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
561 /* This property is used to indicate the termination
562 * voltage (VTRM)
563 */
564 return adp5061_get_max_voltage(st, val);
565 case POWER_SUPPLY_PROP_VOLTAGE_MIN:
566 /*
567 * This property is used to indicate the trickle to fast
568 * charge threshold (VTRK_DEAD)
569 */
570 return adp5061_get_min_voltage(st, val);
571 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
572 /* This property is used to indicate the charging
573 * voltage limit (CHG_VLIM)
574 */
575 return adp5061_get_chg_volt_lim(st, val);
576 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
577 /*
578 * This property is used to indicate the value of the constant
579 * current charge (ICHG)
580 */
581 return adp5061_get_const_chg_current(st, val);
582 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
583 /*
584 * This property is used to indicate the value of the trickle
585 * and weak charge currents (ITRK_DEAD)
586 */
587 return adp5061_get_prechg_current(st, val);
588 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
589 /*
590 * This property is used to set the VWEAK threshold
591 * bellow this value, weak charge mode is entered
592 * above this value, fast chargerge mode is entered
593 */
594 return adp5061_get_vweak_th(st, val);
595 case POWER_SUPPLY_PROP_STATUS:
596 /*
597 * Indicate the charger status in relation to power
598 * supply status property
599 */
600 return adp5061_get_charger_status(st, val);
601 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
602 /*
603 * Indicate the battery status in relation to power
604 * supply capacity level property
605 */
606 return adp5061_get_battery_status(st, val);
607 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
608 /* Indicate the values of the termination current */
609 return adp5061_get_termination_current(st, val);
610 default:
611 return -EINVAL;
612 }
613
614 return 0;
615 }
616
adp5061_set_property(struct power_supply * psy,enum power_supply_property psp,const union power_supply_propval * val)617 static int adp5061_set_property(struct power_supply *psy,
618 enum power_supply_property psp,
619 const union power_supply_propval *val)
620 {
621 struct adp5061_state *st = power_supply_get_drvdata(psy);
622
623 switch (psp) {
624 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
625 return adp5061_set_input_current_limit(st, val->intval);
626 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
627 return adp5061_set_max_voltage(st, val->intval);
628 case POWER_SUPPLY_PROP_VOLTAGE_MIN:
629 return adp5061_set_min_voltage(st, val->intval);
630 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
631 return adp5061_set_const_chg_vmax(st, val->intval);
632 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
633 return adp5061_set_const_chg_current(st, val->intval);
634 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
635 return adp5061_set_prechg_current(st, val->intval);
636 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
637 return adp5061_set_vweak_th(st, val->intval);
638 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
639 return adp5061_set_termination_current(st, val->intval);
640 default:
641 return -EINVAL;
642 }
643
644 return 0;
645 }
646
adp5061_prop_writeable(struct power_supply * psy,enum power_supply_property psp)647 static int adp5061_prop_writeable(struct power_supply *psy,
648 enum power_supply_property psp)
649 {
650 switch (psp) {
651 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
652 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
653 case POWER_SUPPLY_PROP_VOLTAGE_MIN:
654 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
655 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
656 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
657 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
658 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
659 return 1;
660 default:
661 return 0;
662 }
663 }
664
665 static enum power_supply_property adp5061_props[] = {
666 POWER_SUPPLY_PROP_PRESENT,
667 POWER_SUPPLY_PROP_CHARGE_TYPE,
668 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
669 POWER_SUPPLY_PROP_VOLTAGE_MAX,
670 POWER_SUPPLY_PROP_VOLTAGE_MIN,
671 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
672 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
673 POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
674 POWER_SUPPLY_PROP_VOLTAGE_AVG,
675 POWER_SUPPLY_PROP_STATUS,
676 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
677 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
678 };
679
680 static const struct regmap_config adp5061_regmap_config = {
681 .reg_bits = 8,
682 .val_bits = 8,
683 };
684
685 static const struct power_supply_desc adp5061_desc = {
686 .name = "adp5061",
687 .type = POWER_SUPPLY_TYPE_USB,
688 .get_property = adp5061_get_property,
689 .set_property = adp5061_set_property,
690 .property_is_writeable = adp5061_prop_writeable,
691 .properties = adp5061_props,
692 .num_properties = ARRAY_SIZE(adp5061_props),
693 };
694
adp5061_probe(struct i2c_client * client,const struct i2c_device_id * id)695 static int adp5061_probe(struct i2c_client *client,
696 const struct i2c_device_id *id)
697 {
698 struct power_supply_config psy_cfg = {};
699 struct adp5061_state *st;
700
701 st = devm_kzalloc(&client->dev, sizeof(*st), GFP_KERNEL);
702 if (!st)
703 return -ENOMEM;
704
705 st->client = client;
706 st->regmap = devm_regmap_init_i2c(client,
707 &adp5061_regmap_config);
708 if (IS_ERR(st->regmap)) {
709 dev_err(&client->dev, "Failed to initialize register map\n");
710 return -EINVAL;
711 }
712
713 i2c_set_clientdata(client, st);
714 psy_cfg.drv_data = st;
715
716 st->psy = devm_power_supply_register(&client->dev,
717 &adp5061_desc,
718 &psy_cfg);
719
720 if (IS_ERR(st->psy)) {
721 dev_err(&client->dev, "Failed to register power supply\n");
722 return PTR_ERR(st->psy);
723 }
724
725 return 0;
726 }
727
728 static const struct i2c_device_id adp5061_id[] = {
729 { "adp5061", 0},
730 { }
731 };
732 MODULE_DEVICE_TABLE(i2c, adp5061_id);
733
734 static struct i2c_driver adp5061_driver = {
735 .driver = {
736 .name = KBUILD_MODNAME,
737 },
738 .probe = adp5061_probe,
739 .id_table = adp5061_id,
740 };
741 module_i2c_driver(adp5061_driver);
742
743 MODULE_DESCRIPTION("Analog Devices adp5061 battery charger driver");
744 MODULE_AUTHOR("Stefan Popa <stefan.popa@analog.com>");
745 MODULE_LICENSE("GPL v2");
746
