1 /*
2 * Battery driver for CPCAP PMIC
3 *
4 * Copyright (C) 2017 Tony Lindgren <tony@atomide.com>
5 *
6 * Some parts of the code based on earlier Motorola mapphone Linux kernel
7 * drivers:
8 *
9 * Copyright (C) 2009-2010 Motorola, Inc.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14
15 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
16 * kind, whether express or implied; without even the implied warranty
17 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 */
20
21 #include <linux/delay.h>
22 #include <linux/err.h>
23 #include <linux/interrupt.h>
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/of_device.h>
27 #include <linux/platform_device.h>
28 #include <linux/power_supply.h>
29 #include <linux/reboot.h>
30 #include <linux/regmap.h>
31 #include <linux/nvmem-consumer.h>
32 #include <linux/moduleparam.h>
33
34 #include <linux/iio/consumer.h>
35 #include <linux/iio/types.h>
36 #include <linux/mfd/motorola-cpcap.h>
37
38 /*
39 * Register bit defines for CPCAP_REG_BPEOL. Some of these seem to
40 * map to MC13783UG.pdf "Table 5-19. Register 13, Power Control 0"
41 * to enable BATTDETEN, LOBAT and EOL features. We currently use
42 * LOBAT interrupts instead of EOL.
43 */
44 #define CPCAP_REG_BPEOL_BIT_EOL9 BIT(9) /* Set for EOL irq */
45 #define CPCAP_REG_BPEOL_BIT_EOL8 BIT(8) /* Set for EOL irq */
46 #define CPCAP_REG_BPEOL_BIT_UNKNOWN7 BIT(7)
47 #define CPCAP_REG_BPEOL_BIT_UNKNOWN6 BIT(6)
48 #define CPCAP_REG_BPEOL_BIT_UNKNOWN5 BIT(5)
49 #define CPCAP_REG_BPEOL_BIT_EOL_MULTI BIT(4) /* Set for multiple EOL irqs */
50 #define CPCAP_REG_BPEOL_BIT_UNKNOWN3 BIT(3)
51 #define CPCAP_REG_BPEOL_BIT_UNKNOWN2 BIT(2)
52 #define CPCAP_REG_BPEOL_BIT_BATTDETEN BIT(1) /* Enable battery detect */
53 #define CPCAP_REG_BPEOL_BIT_EOLSEL BIT(0) /* BPDET = 0, EOL = 1 */
54
55 /*
56 * Register bit defines for CPCAP_REG_CCC1. These seem similar to the twl6030
57 * coulomb counter registers rather than the mc13892 registers. Both twl6030
58 * and mc13892 set bits 2 and 1 to reset and clear registers. But mc13892
59 * sets bit 0 to start the coulomb counter while twl6030 sets bit 0 to stop
60 * the coulomb counter like cpcap does. So for now, we use the twl6030 style
61 * naming for the registers.
62 */
63 #define CPCAP_REG_CCC1_ACTIVE_MODE1 BIT(4) /* Update rate */
64 #define CPCAP_REG_CCC1_ACTIVE_MODE0 BIT(3) /* Update rate */
65 #define CPCAP_REG_CCC1_AUTOCLEAR BIT(2) /* Resets sample registers */
66 #define CPCAP_REG_CCC1_CAL_EN BIT(1) /* Clears after write in 1s */
67 #define CPCAP_REG_CCC1_PAUSE BIT(0) /* Stop counters, allow write */
68 #define CPCAP_REG_CCC1_RESET_MASK (CPCAP_REG_CCC1_AUTOCLEAR | \
69 CPCAP_REG_CCC1_CAL_EN)
70
71 #define CPCAP_REG_CCCC2_RATE1 BIT(5)
72 #define CPCAP_REG_CCCC2_RATE0 BIT(4)
73 #define CPCAP_REG_CCCC2_ENABLE BIT(3)
74
75 #define CPCAP_BATTERY_CC_SAMPLE_PERIOD_MS 250
76
77 #define CPCAP_BATTERY_EB41_HW4X_ID 0x9E
78 #define CPCAP_BATTERY_BW8X_ID 0x98
79
80 enum {
81 CPCAP_BATTERY_IIO_BATTDET,
82 CPCAP_BATTERY_IIO_VOLTAGE,
83 CPCAP_BATTERY_IIO_CHRG_CURRENT,
84 CPCAP_BATTERY_IIO_BATT_CURRENT,
85 CPCAP_BATTERY_IIO_NR,
86 };
87
88 enum cpcap_battery_irq_action {
89 CPCAP_BATTERY_IRQ_ACTION_NONE,
90 CPCAP_BATTERY_IRQ_ACTION_CC_CAL_DONE,
91 CPCAP_BATTERY_IRQ_ACTION_BATTERY_LOW,
92 CPCAP_BATTERY_IRQ_ACTION_POWEROFF,
93 };
94
95 struct cpcap_interrupt_desc {
96 const char *name;
97 struct list_head node;
98 int irq;
99 enum cpcap_battery_irq_action action;
100 };
101
102 struct cpcap_battery_config {
103 int cd_factor;
104 struct power_supply_info info;
105 struct power_supply_battery_info bat;
106 };
107
108 struct cpcap_coulomb_counter_data {
109 s32 sample; /* 24 or 32 bits */
110 s32 accumulator;
111 s16 offset; /* 9 bits */
112 s16 integrator; /* 13 or 16 bits */
113 };
114
115 enum cpcap_battery_state {
116 CPCAP_BATTERY_STATE_PREVIOUS,
117 CPCAP_BATTERY_STATE_LATEST,
118 CPCAP_BATTERY_STATE_EMPTY,
119 CPCAP_BATTERY_STATE_FULL,
120 CPCAP_BATTERY_STATE_NR,
121 };
122
123 struct cpcap_battery_state_data {
124 int voltage;
125 int current_ua;
126 int counter_uah;
127 int temperature;
128 ktime_t time;
129 struct cpcap_coulomb_counter_data cc;
130 };
131
132 struct cpcap_battery_ddata {
133 struct device *dev;
134 struct regmap *reg;
135 struct list_head irq_list;
136 struct iio_channel *channels[CPCAP_BATTERY_IIO_NR];
137 struct power_supply *psy;
138 struct cpcap_battery_config config;
139 struct cpcap_battery_state_data state[CPCAP_BATTERY_STATE_NR];
140 u32 cc_lsb; /* μAms per LSB */
141 atomic_t active;
142 int charge_full;
143 int status;
144 u16 vendor;
145 bool check_nvmem;
146 unsigned int is_full:1;
147 };
148
149 #define CPCAP_NO_BATTERY -400
150
151 static bool ignore_temperature_probe;
152 module_param(ignore_temperature_probe, bool, 0660);
153
154 static struct cpcap_battery_state_data *
cpcap_battery_get_state(struct cpcap_battery_ddata * ddata,enum cpcap_battery_state state)155 cpcap_battery_get_state(struct cpcap_battery_ddata *ddata,
156 enum cpcap_battery_state state)
157 {
158 if (state >= CPCAP_BATTERY_STATE_NR)
159 return NULL;
160
161 return &ddata->state[state];
162 }
163
164 static struct cpcap_battery_state_data *
cpcap_battery_latest(struct cpcap_battery_ddata * ddata)165 cpcap_battery_latest(struct cpcap_battery_ddata *ddata)
166 {
167 return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_LATEST);
168 }
169
170 static struct cpcap_battery_state_data *
cpcap_battery_previous(struct cpcap_battery_ddata * ddata)171 cpcap_battery_previous(struct cpcap_battery_ddata *ddata)
172 {
173 return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_PREVIOUS);
174 }
175
176 static struct cpcap_battery_state_data *
cpcap_battery_get_empty(struct cpcap_battery_ddata * ddata)177 cpcap_battery_get_empty(struct cpcap_battery_ddata *ddata)
178 {
179 return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_EMPTY);
180 }
181
182 static struct cpcap_battery_state_data *
cpcap_battery_get_full(struct cpcap_battery_ddata * ddata)183 cpcap_battery_get_full(struct cpcap_battery_ddata *ddata)
184 {
185 return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_FULL);
186 }
187
cpcap_charger_battery_temperature(struct cpcap_battery_ddata * ddata,int * value)188 static int cpcap_charger_battery_temperature(struct cpcap_battery_ddata *ddata,
189 int *value)
190 {
191 struct iio_channel *channel;
192 int error;
193
194 channel = ddata->channels[CPCAP_BATTERY_IIO_BATTDET];
195 error = iio_read_channel_processed(channel, value);
196 if (error < 0) {
197 if (!ignore_temperature_probe)
198 dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
199 *value = CPCAP_NO_BATTERY;
200
201 return error;
202 }
203
204 *value /= 100;
205
206 return 0;
207 }
208
cpcap_battery_get_voltage(struct cpcap_battery_ddata * ddata)209 static int cpcap_battery_get_voltage(struct cpcap_battery_ddata *ddata)
210 {
211 struct iio_channel *channel;
212 int error, value = 0;
213
214 channel = ddata->channels[CPCAP_BATTERY_IIO_VOLTAGE];
215 error = iio_read_channel_processed(channel, &value);
216 if (error < 0) {
217 dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
218
219 return 0;
220 }
221
222 return value * 1000;
223 }
224
cpcap_battery_get_current(struct cpcap_battery_ddata * ddata)225 static int cpcap_battery_get_current(struct cpcap_battery_ddata *ddata)
226 {
227 struct iio_channel *channel;
228 int error, value = 0;
229
230 channel = ddata->channels[CPCAP_BATTERY_IIO_BATT_CURRENT];
231 error = iio_read_channel_processed(channel, &value);
232 if (error < 0) {
233 dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
234
235 return 0;
236 }
237
238 return value * 1000;
239 }
240
241 /**
242 * cpcap_battery_cc_raw_div - calculate and divide coulomb counter μAms values
243 * @ddata: device driver data
244 * @sample: coulomb counter sample value
245 * @accumulator: coulomb counter integrator value
246 * @offset: coulomb counter offset value
247 * @divider: conversion divider
248 *
249 * Note that cc_lsb and cc_dur values are from Motorola Linux kernel
250 * function data_get_avg_curr_ua() and seem to be based on measured test
251 * results. It also has the following comment:
252 *
253 * Adjustment factors are applied here as a temp solution per the test
254 * results. Need to work out a formal solution for this adjustment.
255 *
256 * A coulomb counter for similar hardware seems to be documented in
257 * "TWL6030 Gas Gauging Basics (Rev. A)" swca095a.pdf in chapter
258 * "10 Calculating Accumulated Current". We however follow what the
259 * Motorola mapphone Linux kernel is doing as there may be either a
260 * TI or ST coulomb counter in the PMIC.
261 */
cpcap_battery_cc_raw_div(struct cpcap_battery_ddata * ddata,s32 sample,s32 accumulator,s16 offset,u32 divider)262 static int cpcap_battery_cc_raw_div(struct cpcap_battery_ddata *ddata,
263 s32 sample, s32 accumulator,
264 s16 offset, u32 divider)
265 {
266 s64 acc;
267
268 if (!divider)
269 return 0;
270
271 acc = accumulator;
272 acc -= (s64)sample * offset;
273 acc *= ddata->cc_lsb;
274 acc *= -1;
275 acc = div_s64(acc, divider);
276
277 return acc;
278 }
279
280 /* 3600000μAms = 1μAh */
cpcap_battery_cc_to_uah(struct cpcap_battery_ddata * ddata,s32 sample,s32 accumulator,s16 offset)281 static int cpcap_battery_cc_to_uah(struct cpcap_battery_ddata *ddata,
282 s32 sample, s32 accumulator,
283 s16 offset)
284 {
285 return cpcap_battery_cc_raw_div(ddata, sample,
286 accumulator, offset,
287 3600000);
288 }
289
cpcap_battery_cc_to_ua(struct cpcap_battery_ddata * ddata,s32 sample,s32 accumulator,s16 offset)290 static int cpcap_battery_cc_to_ua(struct cpcap_battery_ddata *ddata,
291 s32 sample, s32 accumulator,
292 s16 offset)
293 {
294 return cpcap_battery_cc_raw_div(ddata, sample,
295 accumulator, offset,
296 sample *
297 CPCAP_BATTERY_CC_SAMPLE_PERIOD_MS);
298 }
299
300 /**
301 * cpcap_battery_read_accumulated - reads cpcap coulomb counter
302 * @ddata: device driver data
303 * @ccd: coulomb counter values
304 *
305 * Based on Motorola mapphone kernel function data_read_regs().
306 * Looking at the registers, the coulomb counter seems similar to
307 * the coulomb counter in TWL6030. See "TWL6030 Gas Gauging Basics
308 * (Rev. A) swca095a.pdf for "10 Calculating Accumulated Current".
309 *
310 * Note that swca095a.pdf instructs to stop the coulomb counter
311 * before reading to avoid values changing. Motorola mapphone
312 * Linux kernel does not do it, so let's assume they've verified
313 * the data produced is correct.
314 */
315 static int
cpcap_battery_read_accumulated(struct cpcap_battery_ddata * ddata,struct cpcap_coulomb_counter_data * ccd)316 cpcap_battery_read_accumulated(struct cpcap_battery_ddata *ddata,
317 struct cpcap_coulomb_counter_data *ccd)
318 {
319 u16 buf[7]; /* CPCAP_REG_CCS1 to CCI */
320 int error;
321
322 ccd->sample = 0;
323 ccd->accumulator = 0;
324 ccd->offset = 0;
325 ccd->integrator = 0;
326
327 /* Read coulomb counter register range */
328 error = regmap_bulk_read(ddata->reg, CPCAP_REG_CCS1,
329 buf, ARRAY_SIZE(buf));
330 if (error)
331 return 0;
332
333 /* Sample value CPCAP_REG_CCS1 & 2 */
334 ccd->sample = (buf[1] & 0x0fff) << 16;
335 ccd->sample |= buf[0];
336 if (ddata->vendor == CPCAP_VENDOR_TI)
337 ccd->sample = sign_extend32(24, ccd->sample);
338
339 /* Accumulator value CPCAP_REG_CCA1 & 2 */
340 ccd->accumulator = ((s16)buf[3]) << 16;
341 ccd->accumulator |= buf[2];
342
343 /*
344 * Coulomb counter calibration offset is CPCAP_REG_CCM,
345 * REG_CCO seems unused
346 */
347 ccd->offset = buf[4];
348 ccd->offset = sign_extend32(ccd->offset, 9);
349
350 /* Integrator register CPCAP_REG_CCI */
351 if (ddata->vendor == CPCAP_VENDOR_TI)
352 ccd->integrator = sign_extend32(buf[6], 13);
353 else
354 ccd->integrator = (s16)buf[6];
355
356 return cpcap_battery_cc_to_uah(ddata,
357 ccd->sample,
358 ccd->accumulator,
359 ccd->offset);
360 }
361
362
363 /*
364 * Based on the values from Motorola mapphone Linux kernel for the
365 * stock Droid 4 battery eb41. In the Motorola mapphone Linux
366 * kernel tree the value for pm_cd_factor is passed to the kernel
367 * via device tree. If it turns out to be something device specific
368 * we can consider that too later. These values are also fine for
369 * Bionic's hw4x.
370 *
371 * And looking at the battery full and shutdown values for the stock
372 * kernel on droid 4, full is 4351000 and software initiates shutdown
373 * at 3078000. The device will die around 2743000.
374 */
375 static const struct cpcap_battery_config cpcap_battery_eb41_data = {
376 .cd_factor = 0x3cc,
377 .info.technology = POWER_SUPPLY_TECHNOLOGY_LION,
378 .info.voltage_max_design = 4351000,
379 .info.voltage_min_design = 3100000,
380 .info.charge_full_design = 1740000,
381 .bat.constant_charge_voltage_max_uv = 4200000,
382 };
383
384 /* Values for the extended Droid Bionic battery bw8x. */
385 static const struct cpcap_battery_config cpcap_battery_bw8x_data = {
386 .cd_factor = 0x3cc,
387 .info.technology = POWER_SUPPLY_TECHNOLOGY_LION,
388 .info.voltage_max_design = 4200000,
389 .info.voltage_min_design = 3200000,
390 .info.charge_full_design = 2760000,
391 .bat.constant_charge_voltage_max_uv = 4200000,
392 };
393
394 /*
395 * Safe values for any lipo battery likely to fit into a mapphone
396 * battery bay.
397 */
398 static const struct cpcap_battery_config cpcap_battery_unkown_data = {
399 .cd_factor = 0x3cc,
400 .info.technology = POWER_SUPPLY_TECHNOLOGY_LION,
401 .info.voltage_max_design = 4200000,
402 .info.voltage_min_design = 3200000,
403 .info.charge_full_design = 3000000,
404 .bat.constant_charge_voltage_max_uv = 4200000,
405 };
406
cpcap_battery_match_nvmem(struct device * dev,const void * data)407 static int cpcap_battery_match_nvmem(struct device *dev, const void *data)
408 {
409 if (strcmp(dev_name(dev), "89-500029ba0f73") == 0)
410 return 1;
411 else
412 return 0;
413 }
414
cpcap_battery_detect_battery_type(struct cpcap_battery_ddata * ddata)415 static void cpcap_battery_detect_battery_type(struct cpcap_battery_ddata *ddata)
416 {
417 struct nvmem_device *nvmem;
418 u8 battery_id = 0;
419
420 ddata->check_nvmem = false;
421
422 nvmem = nvmem_device_find(NULL, &cpcap_battery_match_nvmem);
423 if (IS_ERR_OR_NULL(nvmem)) {
424 ddata->check_nvmem = true;
425 dev_info_once(ddata->dev, "Can not find battery nvmem device. Assuming generic lipo battery\n");
426 } else if (nvmem_device_read(nvmem, 2, 1, &battery_id) < 0) {
427 battery_id = 0;
428 ddata->check_nvmem = true;
429 dev_warn(ddata->dev, "Can not read battery nvmem device. Assuming generic lipo battery\n");
430 }
431
432 switch (battery_id) {
433 case CPCAP_BATTERY_EB41_HW4X_ID:
434 ddata->config = cpcap_battery_eb41_data;
435 break;
436 case CPCAP_BATTERY_BW8X_ID:
437 ddata->config = cpcap_battery_bw8x_data;
438 break;
439 default:
440 ddata->config = cpcap_battery_unkown_data;
441 }
442 }
443
444 /**
445 * cpcap_battery_cc_get_avg_current - read cpcap coulumb counter
446 * @ddata: cpcap battery driver device data
447 */
cpcap_battery_cc_get_avg_current(struct cpcap_battery_ddata * ddata)448 static int cpcap_battery_cc_get_avg_current(struct cpcap_battery_ddata *ddata)
449 {
450 int value, acc, error;
451 s32 sample;
452 s16 offset;
453
454 /* Coulomb counter integrator */
455 error = regmap_read(ddata->reg, CPCAP_REG_CCI, &value);
456 if (error)
457 return error;
458
459 if (ddata->vendor == CPCAP_VENDOR_TI) {
460 acc = sign_extend32(value, 13);
461 sample = 1;
462 } else {
463 acc = (s16)value;
464 sample = 4;
465 }
466
467 /* Coulomb counter calibration offset */
468 error = regmap_read(ddata->reg, CPCAP_REG_CCM, &value);
469 if (error)
470 return error;
471
472 offset = sign_extend32(value, 9);
473
474 return cpcap_battery_cc_to_ua(ddata, sample, acc, offset);
475 }
476
cpcap_battery_get_charger_status(struct cpcap_battery_ddata * ddata,int * val)477 static int cpcap_battery_get_charger_status(struct cpcap_battery_ddata *ddata,
478 int *val)
479 {
480 union power_supply_propval prop;
481 struct power_supply *charger;
482 int error;
483
484 charger = power_supply_get_by_name("usb");
485 if (!charger)
486 return -ENODEV;
487
488 error = power_supply_get_property(charger, POWER_SUPPLY_PROP_STATUS,
489 &prop);
490 if (error)
491 *val = POWER_SUPPLY_STATUS_UNKNOWN;
492 else
493 *val = prop.intval;
494
495 power_supply_put(charger);
496
497 return error;
498 }
499
cpcap_battery_full(struct cpcap_battery_ddata * ddata)500 static bool cpcap_battery_full(struct cpcap_battery_ddata *ddata)
501 {
502 struct cpcap_battery_state_data *state = cpcap_battery_latest(ddata);
503 unsigned int vfull;
504 int error, val;
505
506 error = cpcap_battery_get_charger_status(ddata, &val);
507 if (!error) {
508 switch (val) {
509 case POWER_SUPPLY_STATUS_DISCHARGING:
510 dev_dbg(ddata->dev, "charger disconnected\n");
511 ddata->is_full = 0;
512 break;
513 case POWER_SUPPLY_STATUS_FULL:
514 dev_dbg(ddata->dev, "charger full status\n");
515 ddata->is_full = 1;
516 break;
517 default:
518 break;
519 }
520 }
521
522 /*
523 * The full battery voltage here can be inaccurate, it's used just to
524 * filter out any trickle charging events. We clear the is_full status
525 * on charger disconnect above anyways.
526 */
527 vfull = ddata->config.bat.constant_charge_voltage_max_uv - 120000;
528
529 if (ddata->is_full && state->voltage < vfull)
530 ddata->is_full = 0;
531
532 return ddata->is_full;
533 }
534
cpcap_battery_low(struct cpcap_battery_ddata * ddata)535 static bool cpcap_battery_low(struct cpcap_battery_ddata *ddata)
536 {
537 struct cpcap_battery_state_data *state = cpcap_battery_latest(ddata);
538 static bool is_low;
539
540 if (state->current_ua > 0 && (state->voltage <= 3350000 || is_low))
541 is_low = true;
542 else
543 is_low = false;
544
545 return is_low;
546 }
547
cpcap_battery_update_status(struct cpcap_battery_ddata * ddata)548 static int cpcap_battery_update_status(struct cpcap_battery_ddata *ddata)
549 {
550 struct cpcap_battery_state_data state, *latest, *previous,
551 *empty, *full;
552 ktime_t now;
553 int error;
554
555 memset(&state, 0, sizeof(state));
556 now = ktime_get();
557
558 latest = cpcap_battery_latest(ddata);
559 if (latest) {
560 s64 delta_ms = ktime_to_ms(ktime_sub(now, latest->time));
561
562 if (delta_ms < CPCAP_BATTERY_CC_SAMPLE_PERIOD_MS)
563 return delta_ms;
564 }
565
566 state.time = now;
567 state.voltage = cpcap_battery_get_voltage(ddata);
568 state.current_ua = cpcap_battery_get_current(ddata);
569 state.counter_uah = cpcap_battery_read_accumulated(ddata, &state.cc);
570
571 error = cpcap_charger_battery_temperature(ddata,
572 &state.temperature);
573 if (error)
574 return error;
575
576 previous = cpcap_battery_previous(ddata);
577 memcpy(previous, latest, sizeof(*previous));
578 memcpy(latest, &state, sizeof(*latest));
579
580 if (cpcap_battery_full(ddata)) {
581 full = cpcap_battery_get_full(ddata);
582 memcpy(full, latest, sizeof(*full));
583
584 empty = cpcap_battery_get_empty(ddata);
585 if (empty->voltage && empty->voltage != -1) {
586 empty->voltage = -1;
587 ddata->charge_full =
588 empty->counter_uah - full->counter_uah;
589 } else if (ddata->charge_full) {
590 empty->voltage = -1;
591 empty->counter_uah =
592 full->counter_uah + ddata->charge_full;
593 }
594 } else if (cpcap_battery_low(ddata)) {
595 empty = cpcap_battery_get_empty(ddata);
596 memcpy(empty, latest, sizeof(*empty));
597
598 full = cpcap_battery_get_full(ddata);
599 if (full->voltage) {
600 full->voltage = 0;
601 ddata->charge_full =
602 empty->counter_uah - full->counter_uah;
603 }
604 }
605
606 return 0;
607 }
608
609 /*
610 * Update battery status when cpcap-charger calls power_supply_changed().
611 * This allows us to detect battery full condition before the charger
612 * disconnects.
613 */
cpcap_battery_external_power_changed(struct power_supply * psy)614 static void cpcap_battery_external_power_changed(struct power_supply *psy)
615 {
616 union power_supply_propval prop;
617
618 power_supply_get_property(psy, POWER_SUPPLY_PROP_STATUS, &prop);
619 }
620
621 static enum power_supply_property cpcap_battery_props[] = {
622 POWER_SUPPLY_PROP_STATUS,
623 POWER_SUPPLY_PROP_PRESENT,
624 POWER_SUPPLY_PROP_TECHNOLOGY,
625 POWER_SUPPLY_PROP_VOLTAGE_NOW,
626 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
627 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
628 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
629 POWER_SUPPLY_PROP_CURRENT_AVG,
630 POWER_SUPPLY_PROP_CURRENT_NOW,
631 POWER_SUPPLY_PROP_CHARGE_FULL,
632 POWER_SUPPLY_PROP_CHARGE_NOW,
633 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
634 POWER_SUPPLY_PROP_CHARGE_COUNTER,
635 POWER_SUPPLY_PROP_POWER_NOW,
636 POWER_SUPPLY_PROP_POWER_AVG,
637 POWER_SUPPLY_PROP_CAPACITY,
638 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
639 POWER_SUPPLY_PROP_SCOPE,
640 POWER_SUPPLY_PROP_TEMP,
641 };
642
cpcap_battery_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)643 static int cpcap_battery_get_property(struct power_supply *psy,
644 enum power_supply_property psp,
645 union power_supply_propval *val)
646 {
647 struct cpcap_battery_ddata *ddata = power_supply_get_drvdata(psy);
648 struct cpcap_battery_state_data *latest, *previous, *empty;
649 u32 sample;
650 s32 accumulator;
651 int cached;
652 s64 tmp;
653
654 cached = cpcap_battery_update_status(ddata);
655 if (cached < 0)
656 return cached;
657
658 latest = cpcap_battery_latest(ddata);
659 previous = cpcap_battery_previous(ddata);
660
661 if (ddata->check_nvmem)
662 cpcap_battery_detect_battery_type(ddata);
663
664 switch (psp) {
665 case POWER_SUPPLY_PROP_PRESENT:
666 if (latest->temperature > CPCAP_NO_BATTERY || ignore_temperature_probe)
667 val->intval = 1;
668 else
669 val->intval = 0;
670 break;
671 case POWER_SUPPLY_PROP_STATUS:
672 if (cpcap_battery_full(ddata)) {
673 val->intval = POWER_SUPPLY_STATUS_FULL;
674 break;
675 }
676 if (cpcap_battery_cc_get_avg_current(ddata) < 0)
677 val->intval = POWER_SUPPLY_STATUS_CHARGING;
678 else
679 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
680 break;
681 case POWER_SUPPLY_PROP_TECHNOLOGY:
682 val->intval = ddata->config.info.technology;
683 break;
684 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
685 val->intval = cpcap_battery_get_voltage(ddata);
686 break;
687 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
688 val->intval = ddata->config.info.voltage_max_design;
689 break;
690 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
691 val->intval = ddata->config.info.voltage_min_design;
692 break;
693 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
694 val->intval = ddata->config.bat.constant_charge_voltage_max_uv;
695 break;
696 case POWER_SUPPLY_PROP_CURRENT_AVG:
697 sample = latest->cc.sample - previous->cc.sample;
698 if (!sample) {
699 val->intval = cpcap_battery_cc_get_avg_current(ddata);
700 break;
701 }
702 accumulator = latest->cc.accumulator - previous->cc.accumulator;
703 val->intval = cpcap_battery_cc_to_ua(ddata, sample,
704 accumulator,
705 latest->cc.offset);
706 break;
707 case POWER_SUPPLY_PROP_CURRENT_NOW:
708 val->intval = latest->current_ua;
709 break;
710 case POWER_SUPPLY_PROP_CHARGE_COUNTER:
711 val->intval = latest->counter_uah;
712 break;
713 case POWER_SUPPLY_PROP_POWER_NOW:
714 tmp = (latest->voltage / 10000) * latest->current_ua;
715 val->intval = div64_s64(tmp, 100);
716 break;
717 case POWER_SUPPLY_PROP_POWER_AVG:
718 sample = latest->cc.sample - previous->cc.sample;
719 if (!sample) {
720 tmp = cpcap_battery_cc_get_avg_current(ddata);
721 tmp *= (latest->voltage / 10000);
722 val->intval = div64_s64(tmp, 100);
723 break;
724 }
725 accumulator = latest->cc.accumulator - previous->cc.accumulator;
726 tmp = cpcap_battery_cc_to_ua(ddata, sample, accumulator,
727 latest->cc.offset);
728 tmp *= ((latest->voltage + previous->voltage) / 20000);
729 val->intval = div64_s64(tmp, 100);
730 break;
731 case POWER_SUPPLY_PROP_CAPACITY:
732 empty = cpcap_battery_get_empty(ddata);
733 if (!empty->voltage || !ddata->charge_full)
734 return -ENODATA;
735 /* (ddata->charge_full / 200) is needed for rounding */
736 val->intval = empty->counter_uah - latest->counter_uah +
737 ddata->charge_full / 200;
738 val->intval = clamp(val->intval, 0, ddata->charge_full);
739 val->intval = val->intval * 100 / ddata->charge_full;
740 break;
741 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
742 if (cpcap_battery_full(ddata))
743 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
744 else if (latest->voltage >= 3750000)
745 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
746 else if (latest->voltage >= 3300000)
747 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
748 else if (latest->voltage > 3100000)
749 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
750 else if (latest->voltage <= 3100000)
751 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
752 else
753 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
754 break;
755 case POWER_SUPPLY_PROP_CHARGE_NOW:
756 empty = cpcap_battery_get_empty(ddata);
757 if (!empty->voltage)
758 return -ENODATA;
759 val->intval = empty->counter_uah - latest->counter_uah;
760 if (val->intval < 0) {
761 /* Assume invalid config if CHARGE_NOW is -20% */
762 if (ddata->charge_full && abs(val->intval) > ddata->charge_full/5) {
763 empty->voltage = 0;
764 ddata->charge_full = 0;
765 return -ENODATA;
766 }
767 val->intval = 0;
768 } else if (ddata->charge_full && ddata->charge_full < val->intval) {
769 /* Assume invalid config if CHARGE_NOW exceeds CHARGE_FULL by 20% */
770 if (val->intval > (6*ddata->charge_full)/5) {
771 empty->voltage = 0;
772 ddata->charge_full = 0;
773 return -ENODATA;
774 }
775 val->intval = ddata->charge_full;
776 }
777 break;
778 case POWER_SUPPLY_PROP_CHARGE_FULL:
779 if (!ddata->charge_full)
780 return -ENODATA;
781 val->intval = ddata->charge_full;
782 break;
783 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
784 val->intval = ddata->config.info.charge_full_design;
785 break;
786 case POWER_SUPPLY_PROP_SCOPE:
787 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
788 break;
789 case POWER_SUPPLY_PROP_TEMP:
790 if (ignore_temperature_probe)
791 return -ENODATA;
792 val->intval = latest->temperature;
793 break;
794 default:
795 return -EINVAL;
796 }
797
798 return 0;
799 }
800
cpcap_battery_update_charger(struct cpcap_battery_ddata * ddata,int const_charge_voltage)801 static int cpcap_battery_update_charger(struct cpcap_battery_ddata *ddata,
802 int const_charge_voltage)
803 {
804 union power_supply_propval prop;
805 union power_supply_propval val;
806 struct power_supply *charger;
807 int error;
808
809 charger = power_supply_get_by_name("usb");
810 if (!charger)
811 return -ENODEV;
812
813 error = power_supply_get_property(charger,
814 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
815 &prop);
816 if (error)
817 goto out_put;
818
819 /* Allow charger const voltage lower than battery const voltage */
820 if (const_charge_voltage > prop.intval)
821 goto out_put;
822
823 val.intval = const_charge_voltage;
824
825 error = power_supply_set_property(charger,
826 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
827 &val);
828 out_put:
829 power_supply_put(charger);
830
831 return error;
832 }
833
cpcap_battery_set_property(struct power_supply * psy,enum power_supply_property psp,const union power_supply_propval * val)834 static int cpcap_battery_set_property(struct power_supply *psy,
835 enum power_supply_property psp,
836 const union power_supply_propval *val)
837 {
838 struct cpcap_battery_ddata *ddata = power_supply_get_drvdata(psy);
839
840 switch (psp) {
841 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
842 if (val->intval < ddata->config.info.voltage_min_design)
843 return -EINVAL;
844 if (val->intval > ddata->config.info.voltage_max_design)
845 return -EINVAL;
846
847 ddata->config.bat.constant_charge_voltage_max_uv = val->intval;
848
849 return cpcap_battery_update_charger(ddata, val->intval);
850 case POWER_SUPPLY_PROP_CHARGE_FULL:
851 if (val->intval < 0)
852 return -EINVAL;
853 if (val->intval > (6*ddata->config.info.charge_full_design)/5)
854 return -EINVAL;
855
856 ddata->charge_full = val->intval;
857
858 return 0;
859 default:
860 return -EINVAL;
861 }
862
863 return 0;
864 }
865
cpcap_battery_property_is_writeable(struct power_supply * psy,enum power_supply_property psp)866 static int cpcap_battery_property_is_writeable(struct power_supply *psy,
867 enum power_supply_property psp)
868 {
869 switch (psp) {
870 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
871 case POWER_SUPPLY_PROP_CHARGE_FULL:
872 return 1;
873 default:
874 return 0;
875 }
876 }
877
cpcap_battery_irq_thread(int irq,void * data)878 static irqreturn_t cpcap_battery_irq_thread(int irq, void *data)
879 {
880 struct cpcap_battery_ddata *ddata = data;
881 struct cpcap_battery_state_data *latest;
882 struct cpcap_interrupt_desc *d;
883
884 if (!atomic_read(&ddata->active))
885 return IRQ_NONE;
886
887 list_for_each_entry(d, &ddata->irq_list, node) {
888 if (irq == d->irq)
889 break;
890 }
891
892 if (list_entry_is_head(d, &ddata->irq_list, node))
893 return IRQ_NONE;
894
895 latest = cpcap_battery_latest(ddata);
896
897 switch (d->action) {
898 case CPCAP_BATTERY_IRQ_ACTION_CC_CAL_DONE:
899 dev_info(ddata->dev, "Coulomb counter calibration done\n");
900 break;
901 case CPCAP_BATTERY_IRQ_ACTION_BATTERY_LOW:
902 if (latest->current_ua >= 0)
903 dev_warn(ddata->dev, "Battery low at %imV!\n",
904 latest->voltage / 1000);
905 break;
906 case CPCAP_BATTERY_IRQ_ACTION_POWEROFF:
907 if (latest->current_ua >= 0 && latest->voltage <= 3200000) {
908 dev_emerg(ddata->dev,
909 "Battery empty at %imV, powering off\n",
910 latest->voltage / 1000);
911 orderly_poweroff(true);
912 }
913 break;
914 default:
915 break;
916 }
917
918 power_supply_changed(ddata->psy);
919
920 return IRQ_HANDLED;
921 }
922
cpcap_battery_init_irq(struct platform_device * pdev,struct cpcap_battery_ddata * ddata,const char * name)923 static int cpcap_battery_init_irq(struct platform_device *pdev,
924 struct cpcap_battery_ddata *ddata,
925 const char *name)
926 {
927 struct cpcap_interrupt_desc *d;
928 int irq, error;
929
930 irq = platform_get_irq_byname(pdev, name);
931 if (irq < 0)
932 return irq;
933
934 error = devm_request_threaded_irq(ddata->dev, irq, NULL,
935 cpcap_battery_irq_thread,
936 IRQF_SHARED | IRQF_ONESHOT,
937 name, ddata);
938 if (error) {
939 dev_err(ddata->dev, "could not get irq %s: %i\n",
940 name, error);
941
942 return error;
943 }
944
945 d = devm_kzalloc(ddata->dev, sizeof(*d), GFP_KERNEL);
946 if (!d)
947 return -ENOMEM;
948
949 d->name = name;
950 d->irq = irq;
951
952 if (!strncmp(name, "cccal", 5))
953 d->action = CPCAP_BATTERY_IRQ_ACTION_CC_CAL_DONE;
954 else if (!strncmp(name, "lowbph", 6))
955 d->action = CPCAP_BATTERY_IRQ_ACTION_BATTERY_LOW;
956 else if (!strncmp(name, "lowbpl", 6))
957 d->action = CPCAP_BATTERY_IRQ_ACTION_POWEROFF;
958
959 list_add(&d->node, &ddata->irq_list);
960
961 return 0;
962 }
963
cpcap_battery_init_interrupts(struct platform_device * pdev,struct cpcap_battery_ddata * ddata)964 static int cpcap_battery_init_interrupts(struct platform_device *pdev,
965 struct cpcap_battery_ddata *ddata)
966 {
967 static const char * const cpcap_battery_irqs[] = {
968 "eol", "lowbph", "lowbpl",
969 "chrgcurr1", "battdetb"
970 };
971 int i, error;
972
973 for (i = 0; i < ARRAY_SIZE(cpcap_battery_irqs); i++) {
974 error = cpcap_battery_init_irq(pdev, ddata,
975 cpcap_battery_irqs[i]);
976 if (error)
977 return error;
978 }
979
980 /* Enable calibration interrupt if already available in dts */
981 cpcap_battery_init_irq(pdev, ddata, "cccal");
982
983 /* Enable low battery interrupts for 3.3V high and 3.1V low */
984 error = regmap_update_bits(ddata->reg, CPCAP_REG_BPEOL,
985 0xffff,
986 CPCAP_REG_BPEOL_BIT_BATTDETEN);
987 if (error)
988 return error;
989
990 return 0;
991 }
992
cpcap_battery_init_iio(struct cpcap_battery_ddata * ddata)993 static int cpcap_battery_init_iio(struct cpcap_battery_ddata *ddata)
994 {
995 const char * const names[CPCAP_BATTERY_IIO_NR] = {
996 "battdetb", "battp", "chg_isense", "batti",
997 };
998 int error, i;
999
1000 for (i = 0; i < CPCAP_BATTERY_IIO_NR; i++) {
1001 ddata->channels[i] = devm_iio_channel_get(ddata->dev,
1002 names[i]);
1003 if (IS_ERR(ddata->channels[i])) {
1004 error = PTR_ERR(ddata->channels[i]);
1005 goto out_err;
1006 }
1007
1008 if (!ddata->channels[i]->indio_dev) {
1009 error = -ENXIO;
1010 goto out_err;
1011 }
1012 }
1013
1014 return 0;
1015
1016 out_err:
1017 return dev_err_probe(ddata->dev, error,
1018 "could not initialize VBUS or ID IIO\n");
1019 }
1020
1021 /* Calibrate coulomb counter */
cpcap_battery_calibrate(struct cpcap_battery_ddata * ddata)1022 static int cpcap_battery_calibrate(struct cpcap_battery_ddata *ddata)
1023 {
1024 int error, ccc1, value;
1025 unsigned long timeout;
1026
1027 error = regmap_read(ddata->reg, CPCAP_REG_CCC1, &ccc1);
1028 if (error)
1029 return error;
1030
1031 timeout = jiffies + msecs_to_jiffies(6000);
1032
1033 /* Start calibration */
1034 error = regmap_update_bits(ddata->reg, CPCAP_REG_CCC1,
1035 0xffff,
1036 CPCAP_REG_CCC1_CAL_EN);
1037 if (error)
1038 goto restore;
1039
1040 while (time_before(jiffies, timeout)) {
1041 error = regmap_read(ddata->reg, CPCAP_REG_CCC1, &value);
1042 if (error)
1043 goto restore;
1044
1045 if (!(value & CPCAP_REG_CCC1_CAL_EN))
1046 break;
1047
1048 error = regmap_read(ddata->reg, CPCAP_REG_CCM, &value);
1049 if (error)
1050 goto restore;
1051
1052 msleep(300);
1053 }
1054
1055 /* Read calibration offset from CCM */
1056 error = regmap_read(ddata->reg, CPCAP_REG_CCM, &value);
1057 if (error)
1058 goto restore;
1059
1060 dev_info(ddata->dev, "calibration done: 0x%04x\n", value);
1061
1062 restore:
1063 if (error)
1064 dev_err(ddata->dev, "%s: error %i\n", __func__, error);
1065
1066 error = regmap_update_bits(ddata->reg, CPCAP_REG_CCC1,
1067 0xffff, ccc1);
1068 if (error)
1069 dev_err(ddata->dev, "%s: restore error %i\n",
1070 __func__, error);
1071
1072 return error;
1073 }
1074
1075 #ifdef CONFIG_OF
1076 static const struct of_device_id cpcap_battery_id_table[] = {
1077 {
1078 .compatible = "motorola,cpcap-battery",
1079 },
1080 {},
1081 };
1082 MODULE_DEVICE_TABLE(of, cpcap_battery_id_table);
1083 #endif
1084
1085 static const struct power_supply_desc cpcap_charger_battery_desc = {
1086 .name = "battery",
1087 .type = POWER_SUPPLY_TYPE_BATTERY,
1088 .properties = cpcap_battery_props,
1089 .num_properties = ARRAY_SIZE(cpcap_battery_props),
1090 .get_property = cpcap_battery_get_property,
1091 .set_property = cpcap_battery_set_property,
1092 .property_is_writeable = cpcap_battery_property_is_writeable,
1093 .external_power_changed = cpcap_battery_external_power_changed,
1094 };
1095
cpcap_battery_probe(struct platform_device * pdev)1096 static int cpcap_battery_probe(struct platform_device *pdev)
1097 {
1098 struct cpcap_battery_ddata *ddata;
1099 struct power_supply_config psy_cfg = {};
1100 int error;
1101
1102 ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
1103 if (!ddata)
1104 return -ENOMEM;
1105
1106 cpcap_battery_detect_battery_type(ddata);
1107
1108 INIT_LIST_HEAD(&ddata->irq_list);
1109 ddata->dev = &pdev->dev;
1110
1111 ddata->reg = dev_get_regmap(ddata->dev->parent, NULL);
1112 if (!ddata->reg)
1113 return -ENODEV;
1114
1115 error = cpcap_get_vendor(ddata->dev, ddata->reg, &ddata->vendor);
1116 if (error)
1117 return error;
1118
1119 switch (ddata->vendor) {
1120 case CPCAP_VENDOR_ST:
1121 ddata->cc_lsb = 95374; /* μAms per LSB */
1122 break;
1123 case CPCAP_VENDOR_TI:
1124 ddata->cc_lsb = 91501; /* μAms per LSB */
1125 break;
1126 default:
1127 return -EINVAL;
1128 }
1129 ddata->cc_lsb = (ddata->cc_lsb * ddata->config.cd_factor) / 1000;
1130
1131 platform_set_drvdata(pdev, ddata);
1132
1133 error = cpcap_battery_init_interrupts(pdev, ddata);
1134 if (error)
1135 return error;
1136
1137 error = cpcap_battery_init_iio(ddata);
1138 if (error)
1139 return error;
1140
1141 psy_cfg.of_node = pdev->dev.of_node;
1142 psy_cfg.drv_data = ddata;
1143
1144 ddata->psy = devm_power_supply_register(ddata->dev,
1145 &cpcap_charger_battery_desc,
1146 &psy_cfg);
1147 error = PTR_ERR_OR_ZERO(ddata->psy);
1148 if (error) {
1149 dev_err(ddata->dev, "failed to register power supply\n");
1150 return error;
1151 }
1152
1153 atomic_set(&ddata->active, 1);
1154
1155 error = cpcap_battery_calibrate(ddata);
1156 if (error)
1157 return error;
1158
1159 return 0;
1160 }
1161
cpcap_battery_remove(struct platform_device * pdev)1162 static int cpcap_battery_remove(struct platform_device *pdev)
1163 {
1164 struct cpcap_battery_ddata *ddata = platform_get_drvdata(pdev);
1165 int error;
1166
1167 atomic_set(&ddata->active, 0);
1168 error = regmap_update_bits(ddata->reg, CPCAP_REG_BPEOL,
1169 0xffff, 0);
1170 if (error)
1171 dev_err(&pdev->dev, "could not disable: %i\n", error);
1172
1173 return 0;
1174 }
1175
1176 static struct platform_driver cpcap_battery_driver = {
1177 .driver = {
1178 .name = "cpcap_battery",
1179 .of_match_table = of_match_ptr(cpcap_battery_id_table),
1180 },
1181 .probe = cpcap_battery_probe,
1182 .remove = cpcap_battery_remove,
1183 };
1184 module_platform_driver(cpcap_battery_driver);
1185
1186 MODULE_LICENSE("GPL v2");
1187 MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
1188 MODULE_DESCRIPTION("CPCAP PMIC Battery Driver");
1189