Commit | Line | Data |
---|---|---|
f059b46e HG |
1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* | |
3 | * Battery monitor driver for the uPI uG3105 battery monitor | |
4 | * | |
5 | * Note the uG3105 is not a full-featured autonomous fuel-gauge. Instead it is | |
6 | * expected to be use in combination with some always on microcontroller reading | |
7 | * its coulomb-counter before it can wrap (must be read every 400 seconds!). | |
8 | * | |
9 | * Since Linux does not monitor coulomb-counter changes while the device | |
10 | * is off or suspended, the coulomb counter is not used atm. | |
11 | * | |
12 | * Possible improvements: | |
13 | * 1. Activate commented out total_coulomb_count code | |
14 | * 2. Reset total_coulomb_count val to 0 when the battery is as good as empty | |
15 | * and remember that we did this (and clear the flag for this on susp/resume) | |
16 | * 3. When the battery is full check if the flag that we set total_coulomb_count | |
17 | * to when the battery was empty is set. If so we now know the capacity, | |
18 | * not the design, but actual capacity, of the battery | |
19 | * 4. Add some mechanism (needs userspace help, or maybe use efivar?) to remember | |
20 | * the actual capacity of the battery over reboots | |
21 | * 5. When we know the actual capacity at probe time, add energy_now and | |
22 | * energy_full attributes. Guess boot + resume energy_now value based on ocv | |
23 | * and then use total_coulomb_count to report energy_now over time, resetting | |
24 | * things to adjust for drift when empty/full. This should give more accurate | |
25 | * readings, esp. in the 30-70% range and allow userspace to estimate time | |
26 | * remaining till empty/full | |
27 | * 6. Maybe unregister + reregister the psy device when we learn the actual | |
28 | * capacity during run-time ? | |
29 | * | |
30 | * The above will also require some sort of mwh_per_unit calculation. Testing | |
31 | * has shown that an estimated 7404mWh increase of the battery's energy results | |
32 | * in a total_coulomb_count increase of 3277 units with a 5 milli-ohm sense R. | |
33 | * | |
34 | * Copyright (C) 2021 Hans de Goede <hdegoede@redhat.com> | |
35 | */ | |
36 | ||
37 | #include <linux/devm-helpers.h> | |
38 | #include <linux/module.h> | |
39 | #include <linux/mutex.h> | |
40 | #include <linux/slab.h> | |
41 | #include <linux/i2c.h> | |
42 | #include <linux/mod_devicetable.h> | |
43 | #include <linux/power_supply.h> | |
44 | #include <linux/workqueue.h> | |
45 | ||
46 | #define UG3105_MOV_AVG_WINDOW 8 | |
47 | #define UG3105_INIT_POLL_TIME (5 * HZ) | |
48 | #define UG3105_POLL_TIME (30 * HZ) | |
49 | #define UG3105_SETTLE_TIME (1 * HZ) | |
50 | ||
51 | #define UG3105_INIT_POLL_COUNT 30 | |
52 | ||
53 | #define UG3105_REG_MODE 0x00 | |
54 | #define UG3105_REG_CTRL1 0x01 | |
55 | #define UG3105_REG_COULOMB_CNT 0x02 | |
56 | #define UG3105_REG_BAT_VOLT 0x08 | |
57 | #define UG3105_REG_BAT_CURR 0x0c | |
58 | ||
59 | #define UG3105_MODE_STANDBY 0x00 | |
60 | #define UG3105_MODE_RUN 0x10 | |
61 | ||
62 | #define UG3105_CTRL1_RESET_COULOMB_CNT 0x03 | |
63 | ||
64 | #define UG3105_CURR_HYST_UA 65000 | |
65 | ||
66 | #define UG3105_LOW_BAT_UV 3700000 | |
67 | #define UG3105_FULL_BAT_HYST_UV 38000 | |
68 | ||
69 | struct ug3105_chip { | |
70 | struct i2c_client *client; | |
71 | struct power_supply *psy; | |
72 | struct power_supply_battery_info *info; | |
73 | struct delayed_work work; | |
74 | struct mutex lock; | |
75 | int ocv[UG3105_MOV_AVG_WINDOW]; /* micro-volt */ | |
76 | int intern_res[UG3105_MOV_AVG_WINDOW]; /* milli-ohm */ | |
77 | int poll_count; | |
78 | int ocv_avg_index; | |
79 | int ocv_avg; /* micro-volt */ | |
80 | int intern_res_poll_count; | |
81 | int intern_res_avg_index; | |
82 | int intern_res_avg; /* milli-ohm */ | |
83 | int volt; /* micro-volt */ | |
84 | int curr; /* micro-ampere */ | |
85 | int total_coulomb_count; | |
86 | int uv_per_unit; | |
87 | int ua_per_unit; | |
88 | int status; | |
89 | int capacity; | |
90 | bool supplied; | |
91 | }; | |
92 | ||
93 | static int ug3105_read_word(struct i2c_client *client, u8 reg) | |
94 | { | |
95 | int val; | |
96 | ||
97 | val = i2c_smbus_read_word_data(client, reg); | |
98 | if (val < 0) | |
99 | dev_err(&client->dev, "Error reading reg 0x%02x\n", reg); | |
100 | ||
101 | return val; | |
102 | } | |
103 | ||
104 | static int ug3105_get_status(struct ug3105_chip *chip) | |
105 | { | |
106 | int full = chip->info->constant_charge_voltage_max_uv - UG3105_FULL_BAT_HYST_UV; | |
107 | ||
108 | if (chip->curr > UG3105_CURR_HYST_UA) | |
109 | return POWER_SUPPLY_STATUS_CHARGING; | |
110 | ||
111 | if (chip->curr < -UG3105_CURR_HYST_UA) | |
112 | return POWER_SUPPLY_STATUS_DISCHARGING; | |
113 | ||
114 | if (chip->supplied && chip->ocv_avg > full) | |
115 | return POWER_SUPPLY_STATUS_FULL; | |
116 | ||
117 | return POWER_SUPPLY_STATUS_NOT_CHARGING; | |
118 | } | |
119 | ||
120 | static int ug3105_get_capacity(struct ug3105_chip *chip) | |
121 | { | |
122 | /* | |
123 | * OCV voltages in uV for 0-110% in 5% increments, the 100-110% is | |
124 | * for LiPo HV (High-Voltage) bateries which can go up to 4.35V | |
125 | * instead of the usual 4.2V. | |
126 | */ | |
127 | static const int ocv_capacity_tbl[23] = { | |
128 | 3350000, | |
129 | 3610000, | |
130 | 3690000, | |
131 | 3710000, | |
132 | 3730000, | |
133 | 3750000, | |
134 | 3770000, | |
135 | 3786667, | |
136 | 3803333, | |
137 | 3820000, | |
138 | 3836667, | |
139 | 3853333, | |
140 | 3870000, | |
141 | 3907500, | |
142 | 3945000, | |
143 | 3982500, | |
144 | 4020000, | |
145 | 4075000, | |
146 | 4110000, | |
147 | 4150000, | |
148 | 4200000, | |
149 | 4250000, | |
150 | 4300000, | |
151 | }; | |
152 | int i, ocv_diff, ocv_step; | |
153 | ||
154 | if (chip->ocv_avg < ocv_capacity_tbl[0]) | |
155 | return 0; | |
156 | ||
157 | if (chip->status == POWER_SUPPLY_STATUS_FULL) | |
158 | return 100; | |
159 | ||
160 | for (i = 1; i < ARRAY_SIZE(ocv_capacity_tbl); i++) { | |
161 | if (chip->ocv_avg > ocv_capacity_tbl[i]) | |
162 | continue; | |
163 | ||
164 | ocv_diff = ocv_capacity_tbl[i] - chip->ocv_avg; | |
165 | ocv_step = ocv_capacity_tbl[i] - ocv_capacity_tbl[i - 1]; | |
166 | /* scale 0-110% down to 0-100% for LiPo HV */ | |
167 | if (chip->info->constant_charge_voltage_max_uv >= 4300000) | |
168 | return (i * 500 - ocv_diff * 500 / ocv_step) / 110; | |
169 | else | |
170 | return i * 5 - ocv_diff * 5 / ocv_step; | |
171 | } | |
172 | ||
173 | return 100; | |
174 | } | |
175 | ||
176 | static void ug3105_work(struct work_struct *work) | |
177 | { | |
178 | struct ug3105_chip *chip = container_of(work, struct ug3105_chip, | |
179 | work.work); | |
180 | int i, val, curr_diff, volt_diff, res, win_size; | |
181 | bool prev_supplied = chip->supplied; | |
182 | int prev_status = chip->status; | |
183 | int prev_volt = chip->volt; | |
184 | int prev_curr = chip->curr; | |
185 | struct power_supply *psy; | |
186 | ||
187 | mutex_lock(&chip->lock); | |
188 | ||
189 | psy = chip->psy; | |
190 | if (!psy) | |
191 | goto out; | |
192 | ||
193 | val = ug3105_read_word(chip->client, UG3105_REG_BAT_VOLT); | |
194 | if (val < 0) | |
195 | goto out; | |
196 | chip->volt = val * chip->uv_per_unit; | |
197 | ||
198 | val = ug3105_read_word(chip->client, UG3105_REG_BAT_CURR); | |
199 | if (val < 0) | |
200 | goto out; | |
201 | chip->curr = (s16)val * chip->ua_per_unit; | |
202 | ||
203 | chip->ocv[chip->ocv_avg_index] = | |
204 | chip->volt - chip->curr * chip->intern_res_avg / 1000; | |
205 | chip->ocv_avg_index = (chip->ocv_avg_index + 1) % UG3105_MOV_AVG_WINDOW; | |
206 | chip->poll_count++; | |
207 | ||
208 | /* | |
209 | * See possible improvements comment above. | |
210 | * | |
211 | * Read + reset coulomb counter every 10 polls (every 300 seconds) | |
212 | * if ((chip->poll_count % 10) == 0) { | |
213 | * val = ug3105_read_word(chip->client, UG3105_REG_COULOMB_CNT); | |
214 | * if (val < 0) | |
215 | * goto out; | |
216 | * | |
217 | * i2c_smbus_write_byte_data(chip->client, UG3105_REG_CTRL1, | |
218 | * UG3105_CTRL1_RESET_COULOMB_CNT); | |
219 | * | |
220 | * chip->total_coulomb_count += (s16)val; | |
221 | * dev_dbg(&chip->client->dev, "coulomb count %d total %d\n", | |
222 | * (s16)val, chip->total_coulomb_count); | |
223 | * } | |
224 | */ | |
225 | ||
226 | chip->ocv_avg = 0; | |
227 | win_size = min(chip->poll_count, UG3105_MOV_AVG_WINDOW); | |
228 | for (i = 0; i < win_size; i++) | |
229 | chip->ocv_avg += chip->ocv[i]; | |
230 | chip->ocv_avg /= win_size; | |
231 | ||
232 | chip->supplied = power_supply_am_i_supplied(psy); | |
233 | chip->status = ug3105_get_status(chip); | |
234 | chip->capacity = ug3105_get_capacity(chip); | |
235 | ||
236 | /* | |
237 | * Skip internal resistance calc on charger [un]plug and | |
238 | * when the battery is almost empty (voltage low). | |
239 | */ | |
240 | if (chip->supplied != prev_supplied || | |
241 | chip->volt < UG3105_LOW_BAT_UV || | |
242 | chip->poll_count < 2) | |
243 | goto out; | |
244 | ||
245 | /* | |
246 | * Assuming that the OCV voltage does not change significantly | |
247 | * between 2 polls, then we can calculate the internal resistance | |
248 | * on a significant current change by attributing all voltage | |
249 | * change between the 2 readings to the internal resistance. | |
250 | */ | |
251 | curr_diff = abs(chip->curr - prev_curr); | |
252 | if (curr_diff < UG3105_CURR_HYST_UA) | |
253 | goto out; | |
254 | ||
255 | volt_diff = abs(chip->volt - prev_volt); | |
256 | res = volt_diff * 1000 / curr_diff; | |
257 | ||
258 | if ((res < (chip->intern_res_avg * 2 / 3)) || | |
259 | (res > (chip->intern_res_avg * 4 / 3))) { | |
260 | dev_dbg(&chip->client->dev, "Ignoring outlier internal resistance %d mOhm\n", res); | |
261 | goto out; | |
262 | } | |
263 | ||
264 | dev_dbg(&chip->client->dev, "Internal resistance %d mOhm\n", res); | |
265 | ||
266 | chip->intern_res[chip->intern_res_avg_index] = res; | |
267 | chip->intern_res_avg_index = (chip->intern_res_avg_index + 1) % UG3105_MOV_AVG_WINDOW; | |
268 | chip->intern_res_poll_count++; | |
269 | ||
270 | chip->intern_res_avg = 0; | |
271 | win_size = min(chip->intern_res_poll_count, UG3105_MOV_AVG_WINDOW); | |
272 | for (i = 0; i < win_size; i++) | |
273 | chip->intern_res_avg += chip->intern_res[i]; | |
274 | chip->intern_res_avg /= win_size; | |
275 | ||
276 | out: | |
277 | mutex_unlock(&chip->lock); | |
278 | ||
279 | queue_delayed_work(system_wq, &chip->work, | |
280 | (chip->poll_count <= UG3105_INIT_POLL_COUNT) ? | |
281 | UG3105_INIT_POLL_TIME : UG3105_POLL_TIME); | |
282 | ||
283 | if (chip->status != prev_status && psy) | |
284 | power_supply_changed(psy); | |
285 | } | |
286 | ||
287 | static enum power_supply_property ug3105_battery_props[] = { | |
288 | POWER_SUPPLY_PROP_STATUS, | |
289 | POWER_SUPPLY_PROP_PRESENT, | |
290 | POWER_SUPPLY_PROP_TECHNOLOGY, | |
291 | POWER_SUPPLY_PROP_SCOPE, | |
292 | POWER_SUPPLY_PROP_VOLTAGE_NOW, | |
293 | POWER_SUPPLY_PROP_VOLTAGE_OCV, | |
294 | POWER_SUPPLY_PROP_CURRENT_NOW, | |
295 | POWER_SUPPLY_PROP_CAPACITY, | |
296 | }; | |
297 | ||
298 | static int ug3105_get_property(struct power_supply *psy, | |
299 | enum power_supply_property psp, | |
300 | union power_supply_propval *val) | |
301 | { | |
302 | struct ug3105_chip *chip = power_supply_get_drvdata(psy); | |
303 | int ret = 0; | |
304 | ||
305 | mutex_lock(&chip->lock); | |
306 | ||
307 | if (!chip->psy) { | |
308 | ret = -EAGAIN; | |
309 | goto out; | |
310 | } | |
311 | ||
312 | switch (psp) { | |
313 | case POWER_SUPPLY_PROP_STATUS: | |
314 | val->intval = chip->status; | |
315 | break; | |
316 | case POWER_SUPPLY_PROP_PRESENT: | |
317 | val->intval = 1; | |
318 | break; | |
319 | case POWER_SUPPLY_PROP_TECHNOLOGY: | |
320 | val->intval = chip->info->technology; | |
321 | break; | |
322 | case POWER_SUPPLY_PROP_SCOPE: | |
323 | val->intval = POWER_SUPPLY_SCOPE_SYSTEM; | |
324 | break; | |
325 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: | |
326 | ret = ug3105_read_word(chip->client, UG3105_REG_BAT_VOLT); | |
327 | if (ret < 0) | |
328 | break; | |
329 | val->intval = ret * chip->uv_per_unit; | |
330 | ret = 0; | |
331 | break; | |
332 | case POWER_SUPPLY_PROP_VOLTAGE_OCV: | |
333 | val->intval = chip->ocv_avg; | |
334 | break; | |
335 | case POWER_SUPPLY_PROP_CURRENT_NOW: | |
336 | ret = ug3105_read_word(chip->client, UG3105_REG_BAT_CURR); | |
337 | if (ret < 0) | |
338 | break; | |
339 | val->intval = (s16)ret * chip->ua_per_unit; | |
340 | ret = 0; | |
341 | break; | |
342 | case POWER_SUPPLY_PROP_CAPACITY: | |
343 | val->intval = chip->capacity; | |
344 | break; | |
345 | default: | |
346 | ret = -EINVAL; | |
347 | } | |
348 | ||
349 | out: | |
350 | mutex_unlock(&chip->lock); | |
351 | return ret; | |
352 | } | |
353 | ||
354 | static void ug3105_external_power_changed(struct power_supply *psy) | |
355 | { | |
356 | struct ug3105_chip *chip = power_supply_get_drvdata(psy); | |
357 | ||
358 | dev_dbg(&chip->client->dev, "external power changed\n"); | |
359 | mod_delayed_work(system_wq, &chip->work, UG3105_SETTLE_TIME); | |
360 | } | |
361 | ||
362 | static const struct power_supply_desc ug3105_psy_desc = { | |
363 | .name = "ug3105_battery", | |
364 | .type = POWER_SUPPLY_TYPE_BATTERY, | |
365 | .get_property = ug3105_get_property, | |
366 | .external_power_changed = ug3105_external_power_changed, | |
367 | .properties = ug3105_battery_props, | |
368 | .num_properties = ARRAY_SIZE(ug3105_battery_props), | |
369 | }; | |
370 | ||
371 | static void ug3105_init(struct ug3105_chip *chip) | |
372 | { | |
373 | chip->poll_count = 0; | |
374 | chip->ocv_avg_index = 0; | |
375 | chip->total_coulomb_count = 0; | |
376 | i2c_smbus_write_byte_data(chip->client, UG3105_REG_MODE, | |
377 | UG3105_MODE_RUN); | |
378 | i2c_smbus_write_byte_data(chip->client, UG3105_REG_CTRL1, | |
379 | UG3105_CTRL1_RESET_COULOMB_CNT); | |
380 | queue_delayed_work(system_wq, &chip->work, 0); | |
381 | flush_delayed_work(&chip->work); | |
382 | } | |
383 | ||
384 | static int ug3105_probe(struct i2c_client *client) | |
385 | { | |
386 | struct power_supply_config psy_cfg = {}; | |
387 | struct device *dev = &client->dev; | |
388 | u32 curr_sense_res_uohm = 10000; | |
389 | struct power_supply *psy; | |
390 | struct ug3105_chip *chip; | |
391 | int ret; | |
392 | ||
393 | chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL); | |
394 | if (!chip) | |
395 | return -ENOMEM; | |
396 | ||
397 | chip->client = client; | |
398 | mutex_init(&chip->lock); | |
399 | ret = devm_delayed_work_autocancel(dev, &chip->work, ug3105_work); | |
400 | if (ret) | |
401 | return ret; | |
402 | ||
403 | psy_cfg.drv_data = chip; | |
404 | psy = devm_power_supply_register(dev, &ug3105_psy_desc, &psy_cfg); | |
405 | if (IS_ERR(psy)) | |
406 | return PTR_ERR(psy); | |
407 | ||
408 | ret = power_supply_get_battery_info(psy, &chip->info); | |
409 | if (ret) | |
410 | return ret; | |
411 | ||
412 | if (chip->info->factory_internal_resistance_uohm == -EINVAL || | |
413 | chip->info->constant_charge_voltage_max_uv == -EINVAL) { | |
414 | dev_err(dev, "error required properties are missing\n"); | |
415 | return -ENODEV; | |
416 | } | |
417 | ||
418 | device_property_read_u32(dev, "upisemi,rsns-microohm", &curr_sense_res_uohm); | |
419 | ||
420 | /* | |
421 | * DAC maximum is 4.5V divided by 65536 steps + an unknown factor of 10 | |
422 | * coming from somewhere for some reason (verified with a volt-meter). | |
423 | */ | |
424 | chip->uv_per_unit = 45000000/65536; | |
425 | /* Datasheet says 8.1 uV per unit for the current ADC */ | |
426 | chip->ua_per_unit = 8100000 / curr_sense_res_uohm; | |
427 | ||
428 | /* Use provided internal resistance as start point (in milli-ohm) */ | |
429 | chip->intern_res_avg = chip->info->factory_internal_resistance_uohm / 1000; | |
430 | /* Also add it to the internal resistance moving average window */ | |
431 | chip->intern_res[0] = chip->intern_res_avg; | |
432 | chip->intern_res_avg_index = 1; | |
433 | chip->intern_res_poll_count = 1; | |
434 | ||
435 | mutex_lock(&chip->lock); | |
436 | chip->psy = psy; | |
437 | mutex_unlock(&chip->lock); | |
438 | ||
439 | ug3105_init(chip); | |
440 | ||
441 | i2c_set_clientdata(client, chip); | |
442 | return 0; | |
443 | } | |
444 | ||
445 | static int __maybe_unused ug3105_suspend(struct device *dev) | |
446 | { | |
447 | struct ug3105_chip *chip = dev_get_drvdata(dev); | |
448 | ||
449 | cancel_delayed_work_sync(&chip->work); | |
450 | i2c_smbus_write_byte_data(chip->client, UG3105_REG_MODE, | |
451 | UG3105_MODE_STANDBY); | |
452 | ||
453 | return 0; | |
454 | } | |
455 | ||
456 | static int __maybe_unused ug3105_resume(struct device *dev) | |
457 | { | |
458 | struct ug3105_chip *chip = dev_get_drvdata(dev); | |
459 | ||
460 | ug3105_init(chip); | |
461 | ||
462 | return 0; | |
463 | } | |
464 | ||
465 | static SIMPLE_DEV_PM_OPS(ug3105_pm_ops, ug3105_suspend, | |
466 | ug3105_resume); | |
467 | ||
468 | static const struct i2c_device_id ug3105_id[] = { | |
469 | { "ug3105" }, | |
470 | { } | |
471 | }; | |
472 | MODULE_DEVICE_TABLE(i2c, ug3105_id); | |
473 | ||
474 | static struct i2c_driver ug3105_i2c_driver = { | |
475 | .driver = { | |
476 | .name = "ug3105", | |
477 | .pm = &ug3105_pm_ops, | |
478 | }, | |
fe20b1dc | 479 | .probe = ug3105_probe, |
f059b46e HG |
480 | .id_table = ug3105_id, |
481 | }; | |
482 | module_i2c_driver(ug3105_i2c_driver); | |
483 | ||
484 | MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com"); | |
485 | MODULE_DESCRIPTION("uPI uG3105 battery monitor driver"); | |
486 | MODULE_LICENSE("GPL"); |