Commit | Line | Data |
---|---|---|
75853406 SH |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | // | |
3 | // Copyright (C) 2021 Samuel Holland <samuel@sholland.org> | |
4 | ||
5 | #include <linux/i2c.h> | |
6 | #include <linux/module.h> | |
7 | #include <linux/power_supply.h> | |
8 | #include <linux/regmap.h> | |
9 | ||
10 | #define IP5XXX_SYS_CTL0 0x01 | |
11 | #define IP5XXX_SYS_CTL0_WLED_DET_EN BIT(4) | |
12 | #define IP5XXX_SYS_CTL0_WLED_EN BIT(3) | |
13 | #define IP5XXX_SYS_CTL0_BOOST_EN BIT(2) | |
14 | #define IP5XXX_SYS_CTL0_CHARGER_EN BIT(1) | |
15 | #define IP5XXX_SYS_CTL1 0x02 | |
16 | #define IP5XXX_SYS_CTL1_LIGHT_SHDN_EN BIT(1) | |
17 | #define IP5XXX_SYS_CTL1_LOAD_PWRUP_EN BIT(0) | |
18 | #define IP5XXX_SYS_CTL2 0x0c | |
19 | #define IP5XXX_SYS_CTL2_LIGHT_SHDN_TH GENMASK(7, 3) | |
20 | #define IP5XXX_SYS_CTL3 0x03 | |
21 | #define IP5XXX_SYS_CTL3_LONG_PRESS_TIME_SEL GENMASK(7, 6) | |
22 | #define IP5XXX_SYS_CTL3_BTN_SHDN_EN BIT(5) | |
23 | #define IP5XXX_SYS_CTL4 0x04 | |
24 | #define IP5XXX_SYS_CTL4_SHDN_TIME_SEL GENMASK(7, 6) | |
25 | #define IP5XXX_SYS_CTL4_VIN_PULLOUT_BOOST_EN BIT(5) | |
26 | #define IP5XXX_SYS_CTL5 0x07 | |
27 | #define IP5XXX_SYS_CTL5_NTC_DIS BIT(6) | |
28 | #define IP5XXX_SYS_CTL5_WLED_MODE_SEL BIT(1) | |
29 | #define IP5XXX_SYS_CTL5_BTN_SHDN_SEL BIT(0) | |
30 | #define IP5XXX_CHG_CTL1 0x22 | |
31 | #define IP5XXX_CHG_CTL1_BOOST_UVP_SEL GENMASK(3, 2) | |
32 | #define IP5XXX_CHG_CTL2 0x24 | |
33 | #define IP5XXX_CHG_CTL2_BAT_TYPE_SEL GENMASK(6, 5) | |
34 | #define IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_2V (0x0 << 5) | |
35 | #define IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_3V (0x1 << 5) | |
36 | #define IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_35V (0x2 << 5) | |
37 | #define IP5XXX_CHG_CTL2_CONST_VOLT_SEL GENMASK(2, 1) | |
38 | #define IP5XXX_CHG_CTL4 0x26 | |
39 | #define IP5XXX_CHG_CTL4_BAT_TYPE_SEL_EN BIT(6) | |
40 | #define IP5XXX_CHG_CTL4A 0x25 | |
41 | #define IP5XXX_CHG_CTL4A_CONST_CUR_SEL GENMASK(4, 0) | |
42 | #define IP5XXX_MFP_CTL0 0x51 | |
43 | #define IP5XXX_MFP_CTL1 0x52 | |
44 | #define IP5XXX_GPIO_CTL2 0x53 | |
45 | #define IP5XXX_GPIO_CTL2A 0x54 | |
46 | #define IP5XXX_GPIO_CTL3 0x55 | |
47 | #define IP5XXX_READ0 0x71 | |
48 | #define IP5XXX_READ0_CHG_STAT GENMASK(7, 5) | |
49 | #define IP5XXX_READ0_CHG_STAT_IDLE (0x0 << 5) | |
50 | #define IP5XXX_READ0_CHG_STAT_TRICKLE (0x1 << 5) | |
51 | #define IP5XXX_READ0_CHG_STAT_CONST_VOLT (0x2 << 5) | |
52 | #define IP5XXX_READ0_CHG_STAT_CONST_CUR (0x3 << 5) | |
53 | #define IP5XXX_READ0_CHG_STAT_CONST_VOLT_STOP (0x4 << 5) | |
54 | #define IP5XXX_READ0_CHG_STAT_FULL (0x5 << 5) | |
55 | #define IP5XXX_READ0_CHG_STAT_TIMEOUT (0x6 << 5) | |
56 | #define IP5XXX_READ0_CHG_OP BIT(4) | |
57 | #define IP5XXX_READ0_CHG_END BIT(3) | |
58 | #define IP5XXX_READ0_CONST_VOLT_TIMEOUT BIT(2) | |
59 | #define IP5XXX_READ0_CHG_TIMEOUT BIT(1) | |
60 | #define IP5XXX_READ0_TRICKLE_TIMEOUT BIT(0) | |
61 | #define IP5XXX_READ0_TIMEOUT GENMASK(2, 0) | |
62 | #define IP5XXX_READ1 0x72 | |
63 | #define IP5XXX_READ1_WLED_PRESENT BIT(7) | |
64 | #define IP5XXX_READ1_LIGHT_LOAD BIT(6) | |
65 | #define IP5XXX_READ1_VIN_OVERVOLT BIT(5) | |
66 | #define IP5XXX_READ2 0x77 | |
67 | #define IP5XXX_READ2_BTN_PRESS BIT(3) | |
68 | #define IP5XXX_READ2_BTN_LONG_PRESS BIT(1) | |
69 | #define IP5XXX_READ2_BTN_SHORT_PRESS BIT(0) | |
70 | #define IP5XXX_BATVADC_DAT0 0xa2 | |
71 | #define IP5XXX_BATVADC_DAT1 0xa3 | |
72 | #define IP5XXX_BATIADC_DAT0 0xa4 | |
73 | #define IP5XXX_BATIADC_DAT1 0xa5 | |
74 | #define IP5XXX_BATOCV_DAT0 0xa8 | |
75 | #define IP5XXX_BATOCV_DAT1 0xa9 | |
76 | ||
77 | struct ip5xxx { | |
78 | struct regmap *regmap; | |
79 | bool initialized; | |
80 | }; | |
81 | ||
82 | /* | |
83 | * The IP5xxx charger only responds on I2C when it is "awake". The charger is | |
84 | * generally only awake when VIN is powered or when its boost converter is | |
85 | * enabled. Going into shutdown resets all register values. To handle this: | |
86 | * 1) When any bus error occurs, assume the charger has gone into shutdown. | |
87 | * 2) Attempt the initialization sequence on each subsequent register access | |
88 | * until it succeeds. | |
89 | */ | |
90 | static int ip5xxx_read(struct ip5xxx *ip5xxx, unsigned int reg, | |
91 | unsigned int *val) | |
92 | { | |
93 | int ret; | |
94 | ||
95 | ret = regmap_read(ip5xxx->regmap, reg, val); | |
96 | if (ret) | |
97 | ip5xxx->initialized = false; | |
98 | ||
99 | return ret; | |
100 | } | |
101 | ||
102 | static int ip5xxx_update_bits(struct ip5xxx *ip5xxx, unsigned int reg, | |
103 | unsigned int mask, unsigned int val) | |
104 | { | |
105 | int ret; | |
106 | ||
107 | ret = regmap_update_bits(ip5xxx->regmap, reg, mask, val); | |
108 | if (ret) | |
109 | ip5xxx->initialized = false; | |
110 | ||
111 | return ret; | |
112 | } | |
113 | ||
114 | static int ip5xxx_initialize(struct power_supply *psy) | |
115 | { | |
116 | struct ip5xxx *ip5xxx = power_supply_get_drvdata(psy); | |
117 | int ret; | |
118 | ||
119 | if (ip5xxx->initialized) | |
120 | return 0; | |
121 | ||
122 | /* | |
123 | * Disable shutdown under light load. | |
124 | * Enable power on when under load. | |
125 | */ | |
126 | ret = ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL1, | |
127 | IP5XXX_SYS_CTL1_LIGHT_SHDN_EN | | |
128 | IP5XXX_SYS_CTL1_LOAD_PWRUP_EN, | |
129 | IP5XXX_SYS_CTL1_LOAD_PWRUP_EN); | |
130 | if (ret) | |
131 | return ret; | |
132 | ||
133 | /* | |
134 | * Enable shutdown after a long button press (as configured below). | |
135 | */ | |
136 | ret = ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL3, | |
137 | IP5XXX_SYS_CTL3_BTN_SHDN_EN, | |
138 | IP5XXX_SYS_CTL3_BTN_SHDN_EN); | |
139 | if (ret) | |
140 | return ret; | |
141 | ||
142 | /* | |
143 | * Power on automatically when VIN is removed. | |
144 | */ | |
145 | ret = ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL4, | |
146 | IP5XXX_SYS_CTL4_VIN_PULLOUT_BOOST_EN, | |
147 | IP5XXX_SYS_CTL4_VIN_PULLOUT_BOOST_EN); | |
148 | if (ret) | |
149 | return ret; | |
150 | ||
151 | /* | |
152 | * Enable the NTC. | |
153 | * Configure the button for two presses => LED, long press => shutdown. | |
154 | */ | |
155 | ret = ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL5, | |
156 | IP5XXX_SYS_CTL5_NTC_DIS | | |
157 | IP5XXX_SYS_CTL5_WLED_MODE_SEL | | |
158 | IP5XXX_SYS_CTL5_BTN_SHDN_SEL, | |
159 | IP5XXX_SYS_CTL5_WLED_MODE_SEL | | |
160 | IP5XXX_SYS_CTL5_BTN_SHDN_SEL); | |
161 | if (ret) | |
162 | return ret; | |
163 | ||
164 | ip5xxx->initialized = true; | |
165 | dev_dbg(psy->dev.parent, "Initialized after power on\n"); | |
166 | ||
167 | return 0; | |
168 | } | |
169 | ||
170 | static const enum power_supply_property ip5xxx_battery_properties[] = { | |
171 | POWER_SUPPLY_PROP_STATUS, | |
172 | POWER_SUPPLY_PROP_CHARGE_TYPE, | |
173 | POWER_SUPPLY_PROP_HEALTH, | |
174 | POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, | |
175 | POWER_SUPPLY_PROP_VOLTAGE_NOW, | |
176 | POWER_SUPPLY_PROP_VOLTAGE_OCV, | |
177 | POWER_SUPPLY_PROP_CURRENT_NOW, | |
178 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, | |
179 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, | |
180 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, | |
181 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, | |
182 | }; | |
183 | ||
184 | static int ip5xxx_battery_get_status(struct ip5xxx *ip5xxx, int *val) | |
185 | { | |
186 | unsigned int rval; | |
187 | int ret; | |
188 | ||
189 | ret = ip5xxx_read(ip5xxx, IP5XXX_READ0, &rval); | |
190 | if (ret) | |
191 | return ret; | |
192 | ||
193 | switch (rval & IP5XXX_READ0_CHG_STAT) { | |
194 | case IP5XXX_READ0_CHG_STAT_IDLE: | |
195 | *val = POWER_SUPPLY_STATUS_DISCHARGING; | |
196 | break; | |
197 | case IP5XXX_READ0_CHG_STAT_TRICKLE: | |
198 | case IP5XXX_READ0_CHG_STAT_CONST_CUR: | |
199 | case IP5XXX_READ0_CHG_STAT_CONST_VOLT: | |
200 | *val = POWER_SUPPLY_STATUS_CHARGING; | |
201 | break; | |
202 | case IP5XXX_READ0_CHG_STAT_CONST_VOLT_STOP: | |
203 | case IP5XXX_READ0_CHG_STAT_FULL: | |
204 | *val = POWER_SUPPLY_STATUS_FULL; | |
205 | break; | |
206 | case IP5XXX_READ0_CHG_STAT_TIMEOUT: | |
207 | *val = POWER_SUPPLY_STATUS_NOT_CHARGING; | |
208 | break; | |
209 | default: | |
210 | return -EINVAL; | |
211 | } | |
212 | ||
213 | return 0; | |
214 | } | |
215 | ||
216 | static int ip5xxx_battery_get_charge_type(struct ip5xxx *ip5xxx, int *val) | |
217 | { | |
218 | unsigned int rval; | |
219 | int ret; | |
220 | ||
221 | ret = ip5xxx_read(ip5xxx, IP5XXX_READ0, &rval); | |
222 | if (ret) | |
223 | return ret; | |
224 | ||
225 | switch (rval & IP5XXX_READ0_CHG_STAT) { | |
226 | case IP5XXX_READ0_CHG_STAT_IDLE: | |
227 | case IP5XXX_READ0_CHG_STAT_CONST_VOLT_STOP: | |
228 | case IP5XXX_READ0_CHG_STAT_FULL: | |
229 | case IP5XXX_READ0_CHG_STAT_TIMEOUT: | |
230 | *val = POWER_SUPPLY_CHARGE_TYPE_NONE; | |
231 | break; | |
232 | case IP5XXX_READ0_CHG_STAT_TRICKLE: | |
233 | *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; | |
234 | break; | |
235 | case IP5XXX_READ0_CHG_STAT_CONST_CUR: | |
236 | case IP5XXX_READ0_CHG_STAT_CONST_VOLT: | |
237 | *val = POWER_SUPPLY_CHARGE_TYPE_STANDARD; | |
238 | break; | |
239 | default: | |
240 | return -EINVAL; | |
241 | } | |
242 | ||
243 | return 0; | |
244 | } | |
245 | ||
246 | static int ip5xxx_battery_get_health(struct ip5xxx *ip5xxx, int *val) | |
247 | { | |
248 | unsigned int rval; | |
249 | int ret; | |
250 | ||
251 | ret = ip5xxx_read(ip5xxx, IP5XXX_READ0, &rval); | |
252 | if (ret) | |
253 | return ret; | |
254 | ||
255 | if (rval & IP5XXX_READ0_TIMEOUT) | |
256 | *val = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE; | |
257 | else | |
258 | *val = POWER_SUPPLY_HEALTH_GOOD; | |
259 | ||
260 | return 0; | |
261 | } | |
262 | ||
263 | static int ip5xxx_battery_get_voltage_max(struct ip5xxx *ip5xxx, int *val) | |
264 | { | |
265 | unsigned int rval; | |
266 | int ret; | |
267 | ||
268 | ret = ip5xxx_read(ip5xxx, IP5XXX_CHG_CTL2, &rval); | |
269 | if (ret) | |
270 | return ret; | |
271 | ||
272 | /* | |
273 | * It is not clear what this will return if | |
274 | * IP5XXX_CHG_CTL4_BAT_TYPE_SEL_EN is not set... | |
275 | */ | |
276 | switch (rval & IP5XXX_CHG_CTL2_BAT_TYPE_SEL) { | |
277 | case IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_2V: | |
278 | *val = 4200000; | |
279 | break; | |
280 | case IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_3V: | |
281 | *val = 4300000; | |
282 | break; | |
283 | case IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_35V: | |
284 | *val = 4350000; | |
285 | break; | |
286 | default: | |
287 | return -EINVAL; | |
288 | } | |
289 | ||
290 | return 0; | |
291 | } | |
292 | ||
293 | static int ip5xxx_battery_read_adc(struct ip5xxx *ip5xxx, | |
294 | u8 lo_reg, u8 hi_reg, int *val) | |
295 | { | |
296 | unsigned int hi, lo; | |
297 | int ret; | |
298 | ||
299 | ret = ip5xxx_read(ip5xxx, lo_reg, &lo); | |
300 | if (ret) | |
301 | return ret; | |
302 | ||
303 | ret = ip5xxx_read(ip5xxx, hi_reg, &hi); | |
304 | if (ret) | |
305 | return ret; | |
306 | ||
307 | *val = sign_extend32(hi << 8 | lo, 13); | |
308 | ||
309 | return 0; | |
310 | } | |
311 | ||
312 | static int ip5xxx_battery_get_property(struct power_supply *psy, | |
313 | enum power_supply_property psp, | |
314 | union power_supply_propval *val) | |
315 | { | |
316 | struct ip5xxx *ip5xxx = power_supply_get_drvdata(psy); | |
317 | int raw, ret, vmax; | |
318 | unsigned int rval; | |
319 | ||
320 | ret = ip5xxx_initialize(psy); | |
321 | if (ret) | |
322 | return ret; | |
323 | ||
324 | switch (psp) { | |
325 | case POWER_SUPPLY_PROP_STATUS: | |
326 | return ip5xxx_battery_get_status(ip5xxx, &val->intval); | |
327 | ||
328 | case POWER_SUPPLY_PROP_CHARGE_TYPE: | |
329 | return ip5xxx_battery_get_charge_type(ip5xxx, &val->intval); | |
330 | ||
331 | case POWER_SUPPLY_PROP_HEALTH: | |
332 | return ip5xxx_battery_get_health(ip5xxx, &val->intval); | |
333 | ||
334 | case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: | |
335 | return ip5xxx_battery_get_voltage_max(ip5xxx, &val->intval); | |
336 | ||
337 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: | |
338 | ret = ip5xxx_battery_read_adc(ip5xxx, IP5XXX_BATVADC_DAT0, | |
339 | IP5XXX_BATVADC_DAT1, &raw); | |
340 | ||
341 | val->intval = 2600000 + DIV_ROUND_CLOSEST(raw * 26855, 100); | |
342 | return 0; | |
343 | ||
344 | case POWER_SUPPLY_PROP_VOLTAGE_OCV: | |
345 | ret = ip5xxx_battery_read_adc(ip5xxx, IP5XXX_BATOCV_DAT0, | |
346 | IP5XXX_BATOCV_DAT1, &raw); | |
347 | ||
348 | val->intval = 2600000 + DIV_ROUND_CLOSEST(raw * 26855, 100); | |
349 | return 0; | |
350 | ||
351 | case POWER_SUPPLY_PROP_CURRENT_NOW: | |
352 | ret = ip5xxx_battery_read_adc(ip5xxx, IP5XXX_BATIADC_DAT0, | |
353 | IP5XXX_BATIADC_DAT1, &raw); | |
354 | ||
f9be5cb6 | 355 | val->intval = DIV_ROUND_CLOSEST(raw * 149197, 200); |
75853406 SH |
356 | return 0; |
357 | ||
358 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: | |
359 | ret = ip5xxx_read(ip5xxx, IP5XXX_CHG_CTL4A, &rval); | |
360 | if (ret) | |
361 | return ret; | |
362 | ||
363 | rval &= IP5XXX_CHG_CTL4A_CONST_CUR_SEL; | |
364 | val->intval = 100000 * rval; | |
365 | return 0; | |
366 | ||
367 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: | |
368 | val->intval = 100000 * 0x1f; | |
369 | return 0; | |
370 | ||
371 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: | |
372 | ret = ip5xxx_battery_get_voltage_max(ip5xxx, &vmax); | |
373 | if (ret) | |
374 | return ret; | |
375 | ||
376 | ret = ip5xxx_read(ip5xxx, IP5XXX_CHG_CTL2, &rval); | |
377 | if (ret) | |
378 | return ret; | |
379 | ||
380 | rval &= IP5XXX_CHG_CTL2_CONST_VOLT_SEL; | |
381 | val->intval = vmax + 14000 * (rval >> 1); | |
382 | return 0; | |
383 | ||
384 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: | |
385 | ret = ip5xxx_battery_get_voltage_max(ip5xxx, &vmax); | |
386 | if (ret) | |
387 | return ret; | |
388 | ||
389 | val->intval = vmax + 14000 * 3; | |
390 | return 0; | |
391 | ||
392 | default: | |
393 | return -EINVAL; | |
394 | } | |
395 | } | |
396 | ||
397 | static int ip5xxx_battery_set_voltage_max(struct ip5xxx *ip5xxx, int val) | |
398 | { | |
399 | unsigned int rval; | |
400 | int ret; | |
401 | ||
402 | switch (val) { | |
403 | case 4200000: | |
404 | rval = IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_2V; | |
405 | break; | |
406 | case 4300000: | |
407 | rval = IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_3V; | |
408 | break; | |
409 | case 4350000: | |
410 | rval = IP5XXX_CHG_CTL2_BAT_TYPE_SEL_4_35V; | |
411 | break; | |
412 | default: | |
413 | return -EINVAL; | |
414 | } | |
415 | ||
416 | ret = ip5xxx_update_bits(ip5xxx, IP5XXX_CHG_CTL2, | |
417 | IP5XXX_CHG_CTL2_BAT_TYPE_SEL, rval); | |
418 | if (ret) | |
419 | return ret; | |
420 | ||
421 | ret = ip5xxx_update_bits(ip5xxx, IP5XXX_CHG_CTL4, | |
422 | IP5XXX_CHG_CTL4_BAT_TYPE_SEL_EN, | |
423 | IP5XXX_CHG_CTL4_BAT_TYPE_SEL_EN); | |
424 | if (ret) | |
425 | return ret; | |
426 | ||
427 | return 0; | |
428 | } | |
429 | ||
430 | static int ip5xxx_battery_set_property(struct power_supply *psy, | |
431 | enum power_supply_property psp, | |
432 | const union power_supply_propval *val) | |
433 | { | |
434 | struct ip5xxx *ip5xxx = power_supply_get_drvdata(psy); | |
435 | unsigned int rval; | |
436 | int ret, vmax; | |
437 | ||
438 | ret = ip5xxx_initialize(psy); | |
439 | if (ret) | |
440 | return ret; | |
441 | ||
442 | switch (psp) { | |
443 | case POWER_SUPPLY_PROP_STATUS: | |
444 | switch (val->intval) { | |
445 | case POWER_SUPPLY_STATUS_CHARGING: | |
446 | rval = IP5XXX_SYS_CTL0_CHARGER_EN; | |
447 | break; | |
448 | case POWER_SUPPLY_STATUS_DISCHARGING: | |
449 | case POWER_SUPPLY_STATUS_NOT_CHARGING: | |
450 | rval = 0; | |
451 | break; | |
452 | default: | |
453 | return -EINVAL; | |
454 | } | |
455 | return ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL0, | |
456 | IP5XXX_SYS_CTL0_CHARGER_EN, rval); | |
457 | ||
458 | case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: | |
459 | return ip5xxx_battery_set_voltage_max(ip5xxx, val->intval); | |
460 | ||
461 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: | |
462 | rval = val->intval / 100000; | |
463 | return ip5xxx_update_bits(ip5xxx, IP5XXX_CHG_CTL4A, | |
464 | IP5XXX_CHG_CTL4A_CONST_CUR_SEL, rval); | |
465 | ||
466 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: | |
467 | ret = ip5xxx_battery_get_voltage_max(ip5xxx, &vmax); | |
468 | if (ret) | |
469 | return ret; | |
470 | ||
471 | rval = ((val->intval - vmax) / 14000) << 1; | |
472 | return ip5xxx_update_bits(ip5xxx, IP5XXX_CHG_CTL2, | |
473 | IP5XXX_CHG_CTL2_CONST_VOLT_SEL, rval); | |
474 | ||
475 | default: | |
476 | return -EINVAL; | |
477 | } | |
478 | } | |
479 | ||
480 | static int ip5xxx_battery_property_is_writeable(struct power_supply *psy, | |
481 | enum power_supply_property psp) | |
482 | { | |
483 | return psp == POWER_SUPPLY_PROP_STATUS || | |
484 | psp == POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN || | |
485 | psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT || | |
486 | psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE; | |
487 | } | |
488 | ||
489 | static const struct power_supply_desc ip5xxx_battery_desc = { | |
490 | .name = "ip5xxx-battery", | |
491 | .type = POWER_SUPPLY_TYPE_BATTERY, | |
492 | .properties = ip5xxx_battery_properties, | |
493 | .num_properties = ARRAY_SIZE(ip5xxx_battery_properties), | |
494 | .get_property = ip5xxx_battery_get_property, | |
495 | .set_property = ip5xxx_battery_set_property, | |
496 | .property_is_writeable = ip5xxx_battery_property_is_writeable, | |
497 | }; | |
498 | ||
499 | static const enum power_supply_property ip5xxx_boost_properties[] = { | |
500 | POWER_SUPPLY_PROP_ONLINE, | |
501 | POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, | |
502 | }; | |
503 | ||
504 | static int ip5xxx_boost_get_property(struct power_supply *psy, | |
505 | enum power_supply_property psp, | |
506 | union power_supply_propval *val) | |
507 | { | |
508 | struct ip5xxx *ip5xxx = power_supply_get_drvdata(psy); | |
509 | unsigned int rval; | |
510 | int ret; | |
511 | ||
512 | ret = ip5xxx_initialize(psy); | |
513 | if (ret) | |
514 | return ret; | |
515 | ||
516 | switch (psp) { | |
517 | case POWER_SUPPLY_PROP_ONLINE: | |
518 | ret = ip5xxx_read(ip5xxx, IP5XXX_SYS_CTL0, &rval); | |
519 | if (ret) | |
520 | return ret; | |
521 | ||
522 | val->intval = !!(rval & IP5XXX_SYS_CTL0_BOOST_EN); | |
523 | return 0; | |
524 | ||
525 | case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: | |
526 | ret = ip5xxx_read(ip5xxx, IP5XXX_CHG_CTL1, &rval); | |
527 | if (ret) | |
528 | return ret; | |
529 | ||
530 | rval &= IP5XXX_CHG_CTL1_BOOST_UVP_SEL; | |
531 | val->intval = 4530000 + 100000 * (rval >> 2); | |
532 | return 0; | |
533 | ||
534 | default: | |
535 | return -EINVAL; | |
536 | } | |
537 | } | |
538 | ||
539 | static int ip5xxx_boost_set_property(struct power_supply *psy, | |
540 | enum power_supply_property psp, | |
541 | const union power_supply_propval *val) | |
542 | { | |
543 | struct ip5xxx *ip5xxx = power_supply_get_drvdata(psy); | |
544 | unsigned int rval; | |
545 | int ret; | |
546 | ||
547 | ret = ip5xxx_initialize(psy); | |
548 | if (ret) | |
549 | return ret; | |
550 | ||
551 | switch (psp) { | |
552 | case POWER_SUPPLY_PROP_ONLINE: | |
553 | rval = val->intval ? IP5XXX_SYS_CTL0_BOOST_EN : 0; | |
554 | return ip5xxx_update_bits(ip5xxx, IP5XXX_SYS_CTL0, | |
555 | IP5XXX_SYS_CTL0_BOOST_EN, rval); | |
556 | ||
557 | case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: | |
558 | rval = ((val->intval - 4530000) / 100000) << 2; | |
559 | return ip5xxx_update_bits(ip5xxx, IP5XXX_CHG_CTL1, | |
560 | IP5XXX_CHG_CTL1_BOOST_UVP_SEL, rval); | |
561 | ||
562 | default: | |
563 | return -EINVAL; | |
564 | } | |
565 | } | |
566 | ||
567 | static int ip5xxx_boost_property_is_writeable(struct power_supply *psy, | |
568 | enum power_supply_property psp) | |
569 | { | |
570 | return true; | |
571 | } | |
572 | ||
573 | static const struct power_supply_desc ip5xxx_boost_desc = { | |
574 | .name = "ip5xxx-boost", | |
575 | .type = POWER_SUPPLY_TYPE_USB, | |
576 | .properties = ip5xxx_boost_properties, | |
577 | .num_properties = ARRAY_SIZE(ip5xxx_boost_properties), | |
578 | .get_property = ip5xxx_boost_get_property, | |
579 | .set_property = ip5xxx_boost_set_property, | |
580 | .property_is_writeable = ip5xxx_boost_property_is_writeable, | |
581 | }; | |
582 | ||
583 | static const struct regmap_config ip5xxx_regmap_config = { | |
584 | .reg_bits = 8, | |
585 | .val_bits = 8, | |
586 | .max_register = IP5XXX_BATOCV_DAT1, | |
587 | }; | |
588 | ||
589 | static int ip5xxx_power_probe(struct i2c_client *client) | |
590 | { | |
591 | struct power_supply_config psy_cfg = {}; | |
592 | struct device *dev = &client->dev; | |
593 | struct power_supply *psy; | |
594 | struct ip5xxx *ip5xxx; | |
595 | ||
596 | ip5xxx = devm_kzalloc(dev, sizeof(*ip5xxx), GFP_KERNEL); | |
597 | if (!ip5xxx) | |
598 | return -ENOMEM; | |
599 | ||
600 | ip5xxx->regmap = devm_regmap_init_i2c(client, &ip5xxx_regmap_config); | |
601 | if (IS_ERR(ip5xxx->regmap)) | |
602 | return PTR_ERR(ip5xxx->regmap); | |
603 | ||
604 | psy_cfg.of_node = dev->of_node; | |
605 | psy_cfg.drv_data = ip5xxx; | |
606 | ||
607 | psy = devm_power_supply_register(dev, &ip5xxx_battery_desc, &psy_cfg); | |
608 | if (IS_ERR(psy)) | |
609 | return PTR_ERR(psy); | |
610 | ||
611 | psy = devm_power_supply_register(dev, &ip5xxx_boost_desc, &psy_cfg); | |
612 | if (IS_ERR(psy)) | |
613 | return PTR_ERR(psy); | |
614 | ||
615 | return 0; | |
616 | } | |
617 | ||
618 | static const struct of_device_id ip5xxx_power_of_match[] = { | |
619 | { .compatible = "injoinic,ip5108" }, | |
620 | { .compatible = "injoinic,ip5109" }, | |
621 | { .compatible = "injoinic,ip5207" }, | |
622 | { .compatible = "injoinic,ip5209" }, | |
623 | { } | |
624 | }; | |
625 | MODULE_DEVICE_TABLE(of, ip5xxx_power_of_match); | |
626 | ||
627 | static struct i2c_driver ip5xxx_power_driver = { | |
fe20b1dc | 628 | .probe = ip5xxx_power_probe, |
75853406 SH |
629 | .driver = { |
630 | .name = "ip5xxx-power", | |
631 | .of_match_table = ip5xxx_power_of_match, | |
632 | } | |
633 | }; | |
634 | module_i2c_driver(ip5xxx_power_driver); | |
635 | ||
636 | MODULE_AUTHOR("Samuel Holland <samuel@sholland.org>"); | |
637 | MODULE_DESCRIPTION("Injoinic IP5xxx power bank IC driver"); | |
638 | MODULE_LICENSE("GPL"); |