1 | /* |
2 | * Battery power supply driver for X-Powers AXP20X and AXP22X PMICs |
3 | * |
4 | * Copyright 2016 Free Electrons NextThing Co. |
5 | * Quentin Schulz <quentin.schulz@free-electrons.com> |
6 | * |
7 | * This driver is based on a previous upstreaming attempt by: |
8 | * Bruno Prémont <bonbons@linux-vserver.org> |
9 | * |
10 | * This file is subject to the terms and conditions of the GNU General |
11 | * Public License. See the file "COPYING" in the main directory of this |
12 | * archive for more details. |
13 | * |
14 | * This program is distributed in the hope that it will be useful, |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
17 | * GNU General Public License for more details. |
18 | */ |
19 | |
20 | #include <linux/err.h> |
21 | #include <linux/interrupt.h> |
22 | #include <linux/irq.h> |
23 | #include <linux/module.h> |
24 | #include <linux/of.h> |
25 | #include <linux/platform_device.h> |
26 | #include <linux/power_supply.h> |
27 | #include <linux/regmap.h> |
28 | #include <linux/slab.h> |
29 | #include <linux/time.h> |
30 | #include <linux/iio/iio.h> |
31 | #include <linux/iio/consumer.h> |
32 | #include <linux/mfd/axp20x.h> |
33 | |
34 | #define AXP20X_PWR_STATUS_BAT_CHARGING BIT(2) |
35 | |
36 | #define AXP20X_PWR_OP_BATT_PRESENT BIT(5) |
37 | #define AXP20X_PWR_OP_BATT_ACTIVATED BIT(3) |
38 | |
39 | #define AXP209_FG_PERCENT GENMASK(6, 0) |
40 | #define AXP22X_FG_VALID BIT(7) |
41 | |
42 | #define AXP20X_CHRG_CTRL1_ENABLE BIT(7) |
43 | #define AXP20X_CHRG_CTRL1_TGT_VOLT GENMASK(6, 5) |
44 | #define AXP20X_CHRG_CTRL1_TGT_4_1V (0 << 5) |
45 | #define AXP20X_CHRG_CTRL1_TGT_4_15V (1 << 5) |
46 | #define AXP20X_CHRG_CTRL1_TGT_4_2V (2 << 5) |
47 | #define AXP20X_CHRG_CTRL1_TGT_4_36V (3 << 5) |
48 | |
49 | #define AXP22X_CHRG_CTRL1_TGT_4_22V (1 << 5) |
50 | #define AXP22X_CHRG_CTRL1_TGT_4_24V (3 << 5) |
51 | |
52 | #define AXP813_CHRG_CTRL1_TGT_4_35V (3 << 5) |
53 | |
54 | #define AXP20X_CHRG_CTRL1_TGT_CURR GENMASK(3, 0) |
55 | |
56 | #define AXP20X_V_OFF_MASK GENMASK(2, 0) |
57 | |
58 | struct axp20x_batt_ps; |
59 | |
60 | struct axp_data { |
61 | int ccc_scale; |
62 | int ccc_offset; |
63 | bool has_fg_valid; |
64 | int (*get_max_voltage)(struct axp20x_batt_ps *batt, int *val); |
65 | int (*set_max_voltage)(struct axp20x_batt_ps *batt, int val); |
66 | }; |
67 | |
68 | struct axp20x_batt_ps { |
69 | struct regmap *regmap; |
70 | struct power_supply *batt; |
71 | struct device *dev; |
72 | struct iio_channel *batt_chrg_i; |
73 | struct iio_channel *batt_dischrg_i; |
74 | struct iio_channel *batt_v; |
75 | /* Maximum constant charge current */ |
76 | unsigned int max_ccc; |
77 | const struct axp_data *data; |
78 | }; |
79 | |
80 | static int axp20x_battery_get_max_voltage(struct axp20x_batt_ps *axp20x_batt, |
81 | int *val) |
82 | { |
83 | int ret, reg; |
84 | |
85 | ret = regmap_read(map: axp20x_batt->regmap, AXP20X_CHRG_CTRL1, val: ®); |
86 | if (ret) |
87 | return ret; |
88 | |
89 | switch (reg & AXP20X_CHRG_CTRL1_TGT_VOLT) { |
90 | case AXP20X_CHRG_CTRL1_TGT_4_1V: |
91 | *val = 4100000; |
92 | break; |
93 | case AXP20X_CHRG_CTRL1_TGT_4_15V: |
94 | *val = 4150000; |
95 | break; |
96 | case AXP20X_CHRG_CTRL1_TGT_4_2V: |
97 | *val = 4200000; |
98 | break; |
99 | case AXP20X_CHRG_CTRL1_TGT_4_36V: |
100 | *val = 4360000; |
101 | break; |
102 | default: |
103 | return -EINVAL; |
104 | } |
105 | |
106 | return 0; |
107 | } |
108 | |
109 | static int axp22x_battery_get_max_voltage(struct axp20x_batt_ps *axp20x_batt, |
110 | int *val) |
111 | { |
112 | int ret, reg; |
113 | |
114 | ret = regmap_read(map: axp20x_batt->regmap, AXP20X_CHRG_CTRL1, val: ®); |
115 | if (ret) |
116 | return ret; |
117 | |
118 | switch (reg & AXP20X_CHRG_CTRL1_TGT_VOLT) { |
119 | case AXP20X_CHRG_CTRL1_TGT_4_1V: |
120 | *val = 4100000; |
121 | break; |
122 | case AXP20X_CHRG_CTRL1_TGT_4_2V: |
123 | *val = 4200000; |
124 | break; |
125 | case AXP22X_CHRG_CTRL1_TGT_4_22V: |
126 | *val = 4220000; |
127 | break; |
128 | case AXP22X_CHRG_CTRL1_TGT_4_24V: |
129 | *val = 4240000; |
130 | break; |
131 | default: |
132 | return -EINVAL; |
133 | } |
134 | |
135 | return 0; |
136 | } |
137 | |
138 | static int axp813_battery_get_max_voltage(struct axp20x_batt_ps *axp20x_batt, |
139 | int *val) |
140 | { |
141 | int ret, reg; |
142 | |
143 | ret = regmap_read(map: axp20x_batt->regmap, AXP20X_CHRG_CTRL1, val: ®); |
144 | if (ret) |
145 | return ret; |
146 | |
147 | switch (reg & AXP20X_CHRG_CTRL1_TGT_VOLT) { |
148 | case AXP20X_CHRG_CTRL1_TGT_4_1V: |
149 | *val = 4100000; |
150 | break; |
151 | case AXP20X_CHRG_CTRL1_TGT_4_15V: |
152 | *val = 4150000; |
153 | break; |
154 | case AXP20X_CHRG_CTRL1_TGT_4_2V: |
155 | *val = 4200000; |
156 | break; |
157 | case AXP813_CHRG_CTRL1_TGT_4_35V: |
158 | *val = 4350000; |
159 | break; |
160 | default: |
161 | return -EINVAL; |
162 | } |
163 | |
164 | return 0; |
165 | } |
166 | |
167 | static int axp20x_get_constant_charge_current(struct axp20x_batt_ps *axp, |
168 | int *val) |
169 | { |
170 | int ret; |
171 | |
172 | ret = regmap_read(map: axp->regmap, AXP20X_CHRG_CTRL1, val); |
173 | if (ret) |
174 | return ret; |
175 | |
176 | *val &= AXP20X_CHRG_CTRL1_TGT_CURR; |
177 | |
178 | *val = *val * axp->data->ccc_scale + axp->data->ccc_offset; |
179 | |
180 | return 0; |
181 | } |
182 | |
183 | static int axp20x_battery_get_prop(struct power_supply *psy, |
184 | enum power_supply_property psp, |
185 | union power_supply_propval *val) |
186 | { |
187 | struct axp20x_batt_ps *axp20x_batt = power_supply_get_drvdata(psy); |
188 | int ret = 0, reg, val1; |
189 | |
190 | switch (psp) { |
191 | case POWER_SUPPLY_PROP_PRESENT: |
192 | case POWER_SUPPLY_PROP_ONLINE: |
193 | ret = regmap_read(map: axp20x_batt->regmap, AXP20X_PWR_OP_MODE, |
194 | val: ®); |
195 | if (ret) |
196 | return ret; |
197 | |
198 | val->intval = !!(reg & AXP20X_PWR_OP_BATT_PRESENT); |
199 | break; |
200 | |
201 | case POWER_SUPPLY_PROP_STATUS: |
202 | ret = regmap_read(map: axp20x_batt->regmap, AXP20X_PWR_INPUT_STATUS, |
203 | val: ®); |
204 | if (ret) |
205 | return ret; |
206 | |
207 | if (reg & AXP20X_PWR_STATUS_BAT_CHARGING) { |
208 | val->intval = POWER_SUPPLY_STATUS_CHARGING; |
209 | return 0; |
210 | } |
211 | |
212 | ret = iio_read_channel_processed(chan: axp20x_batt->batt_dischrg_i, |
213 | val: &val1); |
214 | if (ret) |
215 | return ret; |
216 | |
217 | if (val1) { |
218 | val->intval = POWER_SUPPLY_STATUS_DISCHARGING; |
219 | return 0; |
220 | } |
221 | |
222 | ret = regmap_read(map: axp20x_batt->regmap, AXP20X_FG_RES, val: &val1); |
223 | if (ret) |
224 | return ret; |
225 | |
226 | /* |
227 | * Fuel Gauge data takes 7 bits but the stored value seems to be |
228 | * directly the raw percentage without any scaling to 7 bits. |
229 | */ |
230 | if ((val1 & AXP209_FG_PERCENT) == 100) |
231 | val->intval = POWER_SUPPLY_STATUS_FULL; |
232 | else |
233 | val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; |
234 | break; |
235 | |
236 | case POWER_SUPPLY_PROP_HEALTH: |
237 | ret = regmap_read(map: axp20x_batt->regmap, AXP20X_PWR_OP_MODE, |
238 | val: &val1); |
239 | if (ret) |
240 | return ret; |
241 | |
242 | if (val1 & AXP20X_PWR_OP_BATT_ACTIVATED) { |
243 | val->intval = POWER_SUPPLY_HEALTH_DEAD; |
244 | return 0; |
245 | } |
246 | |
247 | val->intval = POWER_SUPPLY_HEALTH_GOOD; |
248 | break; |
249 | |
250 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: |
251 | ret = axp20x_get_constant_charge_current(axp: axp20x_batt, |
252 | val: &val->intval); |
253 | if (ret) |
254 | return ret; |
255 | break; |
256 | |
257 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: |
258 | val->intval = axp20x_batt->max_ccc; |
259 | break; |
260 | |
261 | case POWER_SUPPLY_PROP_CURRENT_NOW: |
262 | ret = regmap_read(map: axp20x_batt->regmap, AXP20X_PWR_INPUT_STATUS, |
263 | val: ®); |
264 | if (ret) |
265 | return ret; |
266 | |
267 | if (reg & AXP20X_PWR_STATUS_BAT_CHARGING) { |
268 | ret = iio_read_channel_processed(chan: axp20x_batt->batt_chrg_i, val: &val->intval); |
269 | } else { |
270 | ret = iio_read_channel_processed(chan: axp20x_batt->batt_dischrg_i, val: &val1); |
271 | val->intval = -val1; |
272 | } |
273 | if (ret) |
274 | return ret; |
275 | |
276 | /* IIO framework gives mA but Power Supply framework gives uA */ |
277 | val->intval *= 1000; |
278 | break; |
279 | |
280 | case POWER_SUPPLY_PROP_CAPACITY: |
281 | /* When no battery is present, return capacity is 100% */ |
282 | ret = regmap_read(map: axp20x_batt->regmap, AXP20X_PWR_OP_MODE, |
283 | val: ®); |
284 | if (ret) |
285 | return ret; |
286 | |
287 | if (!(reg & AXP20X_PWR_OP_BATT_PRESENT)) { |
288 | val->intval = 100; |
289 | return 0; |
290 | } |
291 | |
292 | ret = regmap_read(map: axp20x_batt->regmap, AXP20X_FG_RES, val: ®); |
293 | if (ret) |
294 | return ret; |
295 | |
296 | if (axp20x_batt->data->has_fg_valid && !(reg & AXP22X_FG_VALID)) |
297 | return -EINVAL; |
298 | |
299 | /* |
300 | * Fuel Gauge data takes 7 bits but the stored value seems to be |
301 | * directly the raw percentage without any scaling to 7 bits. |
302 | */ |
303 | val->intval = reg & AXP209_FG_PERCENT; |
304 | break; |
305 | |
306 | case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: |
307 | return axp20x_batt->data->get_max_voltage(axp20x_batt, |
308 | &val->intval); |
309 | |
310 | case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: |
311 | ret = regmap_read(map: axp20x_batt->regmap, AXP20X_V_OFF, val: ®); |
312 | if (ret) |
313 | return ret; |
314 | |
315 | val->intval = 2600000 + 100000 * (reg & AXP20X_V_OFF_MASK); |
316 | break; |
317 | |
318 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
319 | ret = iio_read_channel_processed(chan: axp20x_batt->batt_v, |
320 | val: &val->intval); |
321 | if (ret) |
322 | return ret; |
323 | |
324 | /* IIO framework gives mV but Power Supply framework gives uV */ |
325 | val->intval *= 1000; |
326 | break; |
327 | |
328 | default: |
329 | return -EINVAL; |
330 | } |
331 | |
332 | return 0; |
333 | } |
334 | |
335 | static int axp22x_battery_set_max_voltage(struct axp20x_batt_ps *axp20x_batt, |
336 | int val) |
337 | { |
338 | switch (val) { |
339 | case 4100000: |
340 | val = AXP20X_CHRG_CTRL1_TGT_4_1V; |
341 | break; |
342 | |
343 | case 4200000: |
344 | val = AXP20X_CHRG_CTRL1_TGT_4_2V; |
345 | break; |
346 | |
347 | default: |
348 | /* |
349 | * AXP20x max voltage can be set to 4.36V and AXP22X max voltage |
350 | * can be set to 4.22V and 4.24V, but these voltages are too |
351 | * high for Lithium based batteries (AXP PMICs are supposed to |
352 | * be used with these kinds of battery). |
353 | */ |
354 | return -EINVAL; |
355 | } |
356 | |
357 | return regmap_update_bits(map: axp20x_batt->regmap, AXP20X_CHRG_CTRL1, |
358 | AXP20X_CHRG_CTRL1_TGT_VOLT, val); |
359 | } |
360 | |
361 | static int axp20x_battery_set_max_voltage(struct axp20x_batt_ps *axp20x_batt, |
362 | int val) |
363 | { |
364 | switch (val) { |
365 | case 4100000: |
366 | val = AXP20X_CHRG_CTRL1_TGT_4_1V; |
367 | break; |
368 | |
369 | case 4150000: |
370 | val = AXP20X_CHRG_CTRL1_TGT_4_15V; |
371 | break; |
372 | |
373 | case 4200000: |
374 | val = AXP20X_CHRG_CTRL1_TGT_4_2V; |
375 | break; |
376 | |
377 | default: |
378 | /* |
379 | * AXP20x max voltage can be set to 4.36V and AXP22X max voltage |
380 | * can be set to 4.22V and 4.24V, but these voltages are too |
381 | * high for Lithium based batteries (AXP PMICs are supposed to |
382 | * be used with these kinds of battery). |
383 | */ |
384 | return -EINVAL; |
385 | } |
386 | |
387 | return regmap_update_bits(map: axp20x_batt->regmap, AXP20X_CHRG_CTRL1, |
388 | AXP20X_CHRG_CTRL1_TGT_VOLT, val); |
389 | } |
390 | |
391 | static int axp20x_set_constant_charge_current(struct axp20x_batt_ps *axp_batt, |
392 | int charge_current) |
393 | { |
394 | if (charge_current > axp_batt->max_ccc) |
395 | return -EINVAL; |
396 | |
397 | charge_current = (charge_current - axp_batt->data->ccc_offset) / |
398 | axp_batt->data->ccc_scale; |
399 | |
400 | if (charge_current > AXP20X_CHRG_CTRL1_TGT_CURR || charge_current < 0) |
401 | return -EINVAL; |
402 | |
403 | return regmap_update_bits(map: axp_batt->regmap, AXP20X_CHRG_CTRL1, |
404 | AXP20X_CHRG_CTRL1_TGT_CURR, val: charge_current); |
405 | } |
406 | |
407 | static int axp20x_set_max_constant_charge_current(struct axp20x_batt_ps *axp, |
408 | int charge_current) |
409 | { |
410 | bool lower_max = false; |
411 | |
412 | charge_current = (charge_current - axp->data->ccc_offset) / |
413 | axp->data->ccc_scale; |
414 | |
415 | if (charge_current > AXP20X_CHRG_CTRL1_TGT_CURR || charge_current < 0) |
416 | return -EINVAL; |
417 | |
418 | charge_current = charge_current * axp->data->ccc_scale + |
419 | axp->data->ccc_offset; |
420 | |
421 | if (charge_current > axp->max_ccc) |
422 | dev_warn(axp->dev, |
423 | "Setting max constant charge current higher than previously defined. Note that increasing the constant charge current may damage your battery.\n" ); |
424 | else |
425 | lower_max = true; |
426 | |
427 | axp->max_ccc = charge_current; |
428 | |
429 | if (lower_max) { |
430 | int current_cc; |
431 | |
432 | axp20x_get_constant_charge_current(axp, val: ¤t_cc); |
433 | if (current_cc > charge_current) |
434 | axp20x_set_constant_charge_current(axp_batt: axp, charge_current); |
435 | } |
436 | |
437 | return 0; |
438 | } |
439 | static int axp20x_set_voltage_min_design(struct axp20x_batt_ps *axp_batt, |
440 | int min_voltage) |
441 | { |
442 | int val1 = (min_voltage - 2600000) / 100000; |
443 | |
444 | if (val1 < 0 || val1 > AXP20X_V_OFF_MASK) |
445 | return -EINVAL; |
446 | |
447 | return regmap_update_bits(map: axp_batt->regmap, AXP20X_V_OFF, |
448 | AXP20X_V_OFF_MASK, val: val1); |
449 | } |
450 | |
451 | static int axp20x_battery_set_prop(struct power_supply *psy, |
452 | enum power_supply_property psp, |
453 | const union power_supply_propval *val) |
454 | { |
455 | struct axp20x_batt_ps *axp20x_batt = power_supply_get_drvdata(psy); |
456 | |
457 | switch (psp) { |
458 | case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: |
459 | return axp20x_set_voltage_min_design(axp_batt: axp20x_batt, min_voltage: val->intval); |
460 | |
461 | case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: |
462 | return axp20x_batt->data->set_max_voltage(axp20x_batt, val->intval); |
463 | |
464 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: |
465 | return axp20x_set_constant_charge_current(axp_batt: axp20x_batt, |
466 | charge_current: val->intval); |
467 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: |
468 | return axp20x_set_max_constant_charge_current(axp: axp20x_batt, |
469 | charge_current: val->intval); |
470 | case POWER_SUPPLY_PROP_STATUS: |
471 | switch (val->intval) { |
472 | case POWER_SUPPLY_STATUS_CHARGING: |
473 | return regmap_update_bits(map: axp20x_batt->regmap, AXP20X_CHRG_CTRL1, |
474 | AXP20X_CHRG_CTRL1_ENABLE, AXP20X_CHRG_CTRL1_ENABLE); |
475 | |
476 | case POWER_SUPPLY_STATUS_DISCHARGING: |
477 | case POWER_SUPPLY_STATUS_NOT_CHARGING: |
478 | return regmap_update_bits(map: axp20x_batt->regmap, AXP20X_CHRG_CTRL1, |
479 | AXP20X_CHRG_CTRL1_ENABLE, val: 0); |
480 | } |
481 | fallthrough; |
482 | default: |
483 | return -EINVAL; |
484 | } |
485 | } |
486 | |
487 | static enum power_supply_property axp20x_battery_props[] = { |
488 | POWER_SUPPLY_PROP_PRESENT, |
489 | POWER_SUPPLY_PROP_ONLINE, |
490 | POWER_SUPPLY_PROP_STATUS, |
491 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
492 | POWER_SUPPLY_PROP_CURRENT_NOW, |
493 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, |
494 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, |
495 | POWER_SUPPLY_PROP_HEALTH, |
496 | POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, |
497 | POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, |
498 | POWER_SUPPLY_PROP_CAPACITY, |
499 | }; |
500 | |
501 | static int axp20x_battery_prop_writeable(struct power_supply *psy, |
502 | enum power_supply_property psp) |
503 | { |
504 | return psp == POWER_SUPPLY_PROP_STATUS || |
505 | psp == POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN || |
506 | psp == POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN || |
507 | psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT || |
508 | psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX; |
509 | } |
510 | |
511 | static const struct power_supply_desc axp20x_batt_ps_desc = { |
512 | .name = "axp20x-battery" , |
513 | .type = POWER_SUPPLY_TYPE_BATTERY, |
514 | .properties = axp20x_battery_props, |
515 | .num_properties = ARRAY_SIZE(axp20x_battery_props), |
516 | .property_is_writeable = axp20x_battery_prop_writeable, |
517 | .get_property = axp20x_battery_get_prop, |
518 | .set_property = axp20x_battery_set_prop, |
519 | }; |
520 | |
521 | static const struct axp_data axp209_data = { |
522 | .ccc_scale = 100000, |
523 | .ccc_offset = 300000, |
524 | .get_max_voltage = axp20x_battery_get_max_voltage, |
525 | .set_max_voltage = axp20x_battery_set_max_voltage, |
526 | }; |
527 | |
528 | static const struct axp_data axp221_data = { |
529 | .ccc_scale = 150000, |
530 | .ccc_offset = 300000, |
531 | .has_fg_valid = true, |
532 | .get_max_voltage = axp22x_battery_get_max_voltage, |
533 | .set_max_voltage = axp22x_battery_set_max_voltage, |
534 | }; |
535 | |
536 | static const struct axp_data axp813_data = { |
537 | .ccc_scale = 200000, |
538 | .ccc_offset = 200000, |
539 | .has_fg_valid = true, |
540 | .get_max_voltage = axp813_battery_get_max_voltage, |
541 | .set_max_voltage = axp20x_battery_set_max_voltage, |
542 | }; |
543 | |
544 | static const struct of_device_id axp20x_battery_ps_id[] = { |
545 | { |
546 | .compatible = "x-powers,axp209-battery-power-supply" , |
547 | .data = (void *)&axp209_data, |
548 | }, { |
549 | .compatible = "x-powers,axp221-battery-power-supply" , |
550 | .data = (void *)&axp221_data, |
551 | }, { |
552 | .compatible = "x-powers,axp813-battery-power-supply" , |
553 | .data = (void *)&axp813_data, |
554 | }, { /* sentinel */ }, |
555 | }; |
556 | MODULE_DEVICE_TABLE(of, axp20x_battery_ps_id); |
557 | |
558 | static int axp20x_power_probe(struct platform_device *pdev) |
559 | { |
560 | struct axp20x_batt_ps *axp20x_batt; |
561 | struct power_supply_config psy_cfg = {}; |
562 | struct power_supply_battery_info *info; |
563 | struct device *dev = &pdev->dev; |
564 | |
565 | if (!of_device_is_available(device: pdev->dev.of_node)) |
566 | return -ENODEV; |
567 | |
568 | axp20x_batt = devm_kzalloc(dev: &pdev->dev, size: sizeof(*axp20x_batt), |
569 | GFP_KERNEL); |
570 | if (!axp20x_batt) |
571 | return -ENOMEM; |
572 | |
573 | axp20x_batt->dev = &pdev->dev; |
574 | |
575 | axp20x_batt->batt_v = devm_iio_channel_get(dev: &pdev->dev, consumer_channel: "batt_v" ); |
576 | if (IS_ERR(ptr: axp20x_batt->batt_v)) { |
577 | if (PTR_ERR(ptr: axp20x_batt->batt_v) == -ENODEV) |
578 | return -EPROBE_DEFER; |
579 | return PTR_ERR(ptr: axp20x_batt->batt_v); |
580 | } |
581 | |
582 | axp20x_batt->batt_chrg_i = devm_iio_channel_get(dev: &pdev->dev, |
583 | consumer_channel: "batt_chrg_i" ); |
584 | if (IS_ERR(ptr: axp20x_batt->batt_chrg_i)) { |
585 | if (PTR_ERR(ptr: axp20x_batt->batt_chrg_i) == -ENODEV) |
586 | return -EPROBE_DEFER; |
587 | return PTR_ERR(ptr: axp20x_batt->batt_chrg_i); |
588 | } |
589 | |
590 | axp20x_batt->batt_dischrg_i = devm_iio_channel_get(dev: &pdev->dev, |
591 | consumer_channel: "batt_dischrg_i" ); |
592 | if (IS_ERR(ptr: axp20x_batt->batt_dischrg_i)) { |
593 | if (PTR_ERR(ptr: axp20x_batt->batt_dischrg_i) == -ENODEV) |
594 | return -EPROBE_DEFER; |
595 | return PTR_ERR(ptr: axp20x_batt->batt_dischrg_i); |
596 | } |
597 | |
598 | axp20x_batt->regmap = dev_get_regmap(dev: pdev->dev.parent, NULL); |
599 | platform_set_drvdata(pdev, data: axp20x_batt); |
600 | |
601 | psy_cfg.drv_data = axp20x_batt; |
602 | psy_cfg.of_node = pdev->dev.of_node; |
603 | |
604 | axp20x_batt->data = (struct axp_data *)of_device_get_match_data(dev); |
605 | |
606 | axp20x_batt->batt = devm_power_supply_register(parent: &pdev->dev, |
607 | desc: &axp20x_batt_ps_desc, |
608 | cfg: &psy_cfg); |
609 | if (IS_ERR(ptr: axp20x_batt->batt)) { |
610 | dev_err(&pdev->dev, "failed to register power supply: %ld\n" , |
611 | PTR_ERR(axp20x_batt->batt)); |
612 | return PTR_ERR(ptr: axp20x_batt->batt); |
613 | } |
614 | |
615 | if (!power_supply_get_battery_info(psy: axp20x_batt->batt, info_out: &info)) { |
616 | int vmin = info->voltage_min_design_uv; |
617 | int ccc = info->constant_charge_current_max_ua; |
618 | |
619 | if (vmin > 0 && axp20x_set_voltage_min_design(axp_batt: axp20x_batt, |
620 | min_voltage: vmin)) |
621 | dev_err(&pdev->dev, |
622 | "couldn't set voltage_min_design\n" ); |
623 | |
624 | /* Set max to unverified value to be able to set CCC */ |
625 | axp20x_batt->max_ccc = ccc; |
626 | |
627 | if (ccc <= 0 || axp20x_set_constant_charge_current(axp_batt: axp20x_batt, |
628 | charge_current: ccc)) { |
629 | dev_err(&pdev->dev, |
630 | "couldn't set constant charge current from DT: fallback to minimum value\n" ); |
631 | ccc = 300000; |
632 | axp20x_batt->max_ccc = ccc; |
633 | axp20x_set_constant_charge_current(axp_batt: axp20x_batt, charge_current: ccc); |
634 | } |
635 | } |
636 | |
637 | /* |
638 | * Update max CCC to a valid value if battery info is present or set it |
639 | * to current register value by default. |
640 | */ |
641 | axp20x_get_constant_charge_current(axp: axp20x_batt, |
642 | val: &axp20x_batt->max_ccc); |
643 | |
644 | return 0; |
645 | } |
646 | |
647 | static struct platform_driver axp20x_batt_driver = { |
648 | .probe = axp20x_power_probe, |
649 | .driver = { |
650 | .name = "axp20x-battery-power-supply" , |
651 | .of_match_table = axp20x_battery_ps_id, |
652 | }, |
653 | }; |
654 | |
655 | module_platform_driver(axp20x_batt_driver); |
656 | |
657 | MODULE_DESCRIPTION("Battery power supply driver for AXP20X and AXP22X PMICs" ); |
658 | MODULE_AUTHOR("Quentin Schulz <quentin.schulz@free-electrons.com>" ); |
659 | MODULE_LICENSE("GPL" ); |
660 | |