2 * BQ27xxx battery driver
4 * Copyright (C) 2008 Rodolfo Giometti <giometti@linux.it>
5 * Copyright (C) 2008 Eurotech S.p.A. <info@eurotech.it>
6 * Copyright (C) 2010-2011 Lars-Peter Clausen <lars@metafoo.de>
7 * Copyright (C) 2011 Pali Rohár <pali.rohar@gmail.com>
9 * Based on a previous work by Copyright (C) 2008 Texas Instruments, Inc.
11 * This package 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.
15 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20 * http://www.ti.com/product/bq27000
21 * http://www.ti.com/product/bq27200
22 * http://www.ti.com/product/bq27010
23 * http://www.ti.com/product/bq27210
24 * http://www.ti.com/product/bq27500
25 * http://www.ti.com/product/bq27510-g3
26 * http://www.ti.com/product/bq27520-g4
27 * http://www.ti.com/product/bq27530-g1
28 * http://www.ti.com/product/bq27531-g1
29 * http://www.ti.com/product/bq27541-g1
30 * http://www.ti.com/product/bq27542-g1
31 * http://www.ti.com/product/bq27546-g1
32 * http://www.ti.com/product/bq27742-g1
33 * http://www.ti.com/product/bq27545-g1
34 * http://www.ti.com/product/bq27421-g1
35 * http://www.ti.com/product/bq27425-g1
36 * http://www.ti.com/product/bq27411-g1
37 * http://www.ti.com/product/bq27621-g1
40 #include <linux/device.h>
41 #include <linux/module.h>
42 #include <linux/param.h>
43 #include <linux/jiffies.h>
44 #include <linux/workqueue.h>
45 #include <linux/delay.h>
46 #include <linux/platform_device.h>
47 #include <linux/power_supply.h>
48 #include <linux/slab.h>
50 #include <linux/power/bq27xxx_battery.h>
52 #define DRIVER_VERSION "1.2.0"
54 #define BQ27XXX_MANUFACTURER "Texas Instruments"
57 #define BQ27XXX_FLAG_DSC BIT(0)
58 #define BQ27XXX_FLAG_SOCF BIT(1) /* State-of-Charge threshold final */
59 #define BQ27XXX_FLAG_SOC1 BIT(2) /* State-of-Charge threshold 1 */
60 #define BQ27XXX_FLAG_FC BIT(9)
61 #define BQ27XXX_FLAG_OTD BIT(14)
62 #define BQ27XXX_FLAG_OTC BIT(15)
63 #define BQ27XXX_FLAG_UT BIT(14)
64 #define BQ27XXX_FLAG_OT BIT(15)
66 /* BQ27000 has different layout for Flags register */
67 #define BQ27000_FLAG_EDVF BIT(0) /* Final End-of-Discharge-Voltage flag */
68 #define BQ27000_FLAG_EDV1 BIT(1) /* First End-of-Discharge-Voltage flag */
69 #define BQ27000_FLAG_CI BIT(4) /* Capacity Inaccurate flag */
70 #define BQ27000_FLAG_FC BIT(5)
71 #define BQ27000_FLAG_CHGS BIT(7) /* Charge state flag */
73 #define BQ27XXX_RS (20) /* Resistor sense mOhm */
74 #define BQ27XXX_POWER_CONSTANT (29200) /* 29.2 µV^2 * 1000 */
75 #define BQ27XXX_CURRENT_CONSTANT (3570) /* 3.57 µV * 1000 */
77 #define INVALID_REG_ADDR 0xff
80 * bq27xxx_reg_index - Register names
82 * These are indexes into a device's register mapping array.
84 enum bq27xxx_reg_index
{
85 BQ27XXX_REG_CTRL
= 0, /* Control */
86 BQ27XXX_REG_TEMP
, /* Temperature */
87 BQ27XXX_REG_INT_TEMP
, /* Internal Temperature */
88 BQ27XXX_REG_VOLT
, /* Voltage */
89 BQ27XXX_REG_AI
, /* Average Current */
90 BQ27XXX_REG_FLAGS
, /* Flags */
91 BQ27XXX_REG_TTE
, /* Time-to-Empty */
92 BQ27XXX_REG_TTF
, /* Time-to-Full */
93 BQ27XXX_REG_TTES
, /* Time-to-Empty Standby */
94 BQ27XXX_REG_TTECP
, /* Time-to-Empty at Constant Power */
95 BQ27XXX_REG_NAC
, /* Nominal Available Capacity */
96 BQ27XXX_REG_FCC
, /* Full Charge Capacity */
97 BQ27XXX_REG_CYCT
, /* Cycle Count */
98 BQ27XXX_REG_AE
, /* Available Energy */
99 BQ27XXX_REG_SOC
, /* State-of-Charge */
100 BQ27XXX_REG_DCAP
, /* Design Capacity */
101 BQ27XXX_REG_AP
, /* Average Power */
104 /* Register mappings */
105 static u8 bq27000_regs
[] = {
108 INVALID_REG_ADDR
, /* INT TEMP - NA*/
120 0x0b, /* SOC(RSOC) */
121 0x76, /* DCAP(ILMD) */
125 static u8 bq27010_regs
[] = {
128 INVALID_REG_ADDR
, /* INT TEMP - NA*/
139 INVALID_REG_ADDR
, /* AE - NA */
140 0x0b, /* SOC(RSOC) */
141 0x76, /* DCAP(ILMD) */
142 INVALID_REG_ADDR
, /* AP - NA */
145 static u8 bq27500_regs
[] = {
153 INVALID_REG_ADDR
, /* TTF - NA */
155 INVALID_REG_ADDR
, /* TTECP - NA */
159 INVALID_REG_ADDR
, /* AE - NA */
160 0x2c, /* SOC(RSOC) */
161 0x3c, /* DCAP(ILMD) */
162 INVALID_REG_ADDR
, /* AP - NA */
165 static u8 bq27530_regs
[] = {
173 INVALID_REG_ADDR
, /* TTF - NA */
174 INVALID_REG_ADDR
, /* TTES - NA */
175 INVALID_REG_ADDR
, /* TTECP - NA */
179 INVALID_REG_ADDR
, /* AE - NA */
180 0x2c, /* SOC(RSOC) */
181 INVALID_REG_ADDR
, /* DCAP - NA */
185 static u8 bq27541_regs
[] = {
193 INVALID_REG_ADDR
, /* TTF - NA */
194 INVALID_REG_ADDR
, /* TTES - NA */
195 INVALID_REG_ADDR
, /* TTECP - NA */
199 INVALID_REG_ADDR
, /* AE - NA */
200 0x2c, /* SOC(RSOC) */
205 static u8 bq27545_regs
[] = {
213 INVALID_REG_ADDR
, /* TTF - NA */
214 INVALID_REG_ADDR
, /* TTES - NA */
215 INVALID_REG_ADDR
, /* TTECP - NA */
219 INVALID_REG_ADDR
, /* AE - NA */
220 0x2c, /* SOC(RSOC) */
221 INVALID_REG_ADDR
, /* DCAP - NA */
225 static u8 bq27421_regs
[] = {
232 INVALID_REG_ADDR
, /* TTE - NA */
233 INVALID_REG_ADDR
, /* TTF - NA */
234 INVALID_REG_ADDR
, /* TTES - NA */
235 INVALID_REG_ADDR
, /* TTECP - NA */
238 INVALID_REG_ADDR
, /* CYCT - NA */
239 INVALID_REG_ADDR
, /* AE - NA */
245 static u8
*bq27xxx_regs
[] = {
246 [BQ27000
] = bq27000_regs
,
247 [BQ27010
] = bq27010_regs
,
248 [BQ27500
] = bq27500_regs
,
249 [BQ27530
] = bq27530_regs
,
250 [BQ27541
] = bq27541_regs
,
251 [BQ27545
] = bq27545_regs
,
252 [BQ27421
] = bq27421_regs
,
255 static enum power_supply_property bq27000_battery_props
[] = {
256 POWER_SUPPLY_PROP_STATUS
,
257 POWER_SUPPLY_PROP_PRESENT
,
258 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
259 POWER_SUPPLY_PROP_CURRENT_NOW
,
260 POWER_SUPPLY_PROP_CAPACITY
,
261 POWER_SUPPLY_PROP_CAPACITY_LEVEL
,
262 POWER_SUPPLY_PROP_TEMP
,
263 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW
,
264 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG
,
265 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW
,
266 POWER_SUPPLY_PROP_TECHNOLOGY
,
267 POWER_SUPPLY_PROP_CHARGE_FULL
,
268 POWER_SUPPLY_PROP_CHARGE_NOW
,
269 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
,
270 POWER_SUPPLY_PROP_CYCLE_COUNT
,
271 POWER_SUPPLY_PROP_ENERGY_NOW
,
272 POWER_SUPPLY_PROP_POWER_AVG
,
273 POWER_SUPPLY_PROP_HEALTH
,
274 POWER_SUPPLY_PROP_MANUFACTURER
,
277 static enum power_supply_property bq27010_battery_props
[] = {
278 POWER_SUPPLY_PROP_STATUS
,
279 POWER_SUPPLY_PROP_PRESENT
,
280 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
281 POWER_SUPPLY_PROP_CURRENT_NOW
,
282 POWER_SUPPLY_PROP_CAPACITY
,
283 POWER_SUPPLY_PROP_CAPACITY_LEVEL
,
284 POWER_SUPPLY_PROP_TEMP
,
285 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW
,
286 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG
,
287 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW
,
288 POWER_SUPPLY_PROP_TECHNOLOGY
,
289 POWER_SUPPLY_PROP_CHARGE_FULL
,
290 POWER_SUPPLY_PROP_CHARGE_NOW
,
291 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
,
292 POWER_SUPPLY_PROP_CYCLE_COUNT
,
293 POWER_SUPPLY_PROP_HEALTH
,
294 POWER_SUPPLY_PROP_MANUFACTURER
,
297 static enum power_supply_property bq27500_battery_props
[] = {
298 POWER_SUPPLY_PROP_STATUS
,
299 POWER_SUPPLY_PROP_PRESENT
,
300 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
301 POWER_SUPPLY_PROP_CURRENT_NOW
,
302 POWER_SUPPLY_PROP_CAPACITY
,
303 POWER_SUPPLY_PROP_CAPACITY_LEVEL
,
304 POWER_SUPPLY_PROP_TEMP
,
305 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW
,
306 POWER_SUPPLY_PROP_TECHNOLOGY
,
307 POWER_SUPPLY_PROP_CHARGE_FULL
,
308 POWER_SUPPLY_PROP_CHARGE_NOW
,
309 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
,
310 POWER_SUPPLY_PROP_CYCLE_COUNT
,
311 POWER_SUPPLY_PROP_HEALTH
,
312 POWER_SUPPLY_PROP_MANUFACTURER
,
315 static enum power_supply_property bq27530_battery_props
[] = {
316 POWER_SUPPLY_PROP_STATUS
,
317 POWER_SUPPLY_PROP_PRESENT
,
318 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
319 POWER_SUPPLY_PROP_CURRENT_NOW
,
320 POWER_SUPPLY_PROP_CAPACITY
,
321 POWER_SUPPLY_PROP_CAPACITY_LEVEL
,
322 POWER_SUPPLY_PROP_TEMP
,
323 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW
,
324 POWER_SUPPLY_PROP_TECHNOLOGY
,
325 POWER_SUPPLY_PROP_CHARGE_FULL
,
326 POWER_SUPPLY_PROP_CHARGE_NOW
,
327 POWER_SUPPLY_PROP_POWER_AVG
,
328 POWER_SUPPLY_PROP_HEALTH
,
329 POWER_SUPPLY_PROP_CYCLE_COUNT
,
330 POWER_SUPPLY_PROP_MANUFACTURER
,
333 static enum power_supply_property bq27541_battery_props
[] = {
334 POWER_SUPPLY_PROP_STATUS
,
335 POWER_SUPPLY_PROP_PRESENT
,
336 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
337 POWER_SUPPLY_PROP_CURRENT_NOW
,
338 POWER_SUPPLY_PROP_CAPACITY
,
339 POWER_SUPPLY_PROP_CAPACITY_LEVEL
,
340 POWER_SUPPLY_PROP_TEMP
,
341 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW
,
342 POWER_SUPPLY_PROP_TECHNOLOGY
,
343 POWER_SUPPLY_PROP_CHARGE_FULL
,
344 POWER_SUPPLY_PROP_CHARGE_NOW
,
345 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
,
346 POWER_SUPPLY_PROP_CYCLE_COUNT
,
347 POWER_SUPPLY_PROP_POWER_AVG
,
348 POWER_SUPPLY_PROP_HEALTH
,
349 POWER_SUPPLY_PROP_MANUFACTURER
,
352 static enum power_supply_property bq27545_battery_props
[] = {
353 POWER_SUPPLY_PROP_STATUS
,
354 POWER_SUPPLY_PROP_PRESENT
,
355 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
356 POWER_SUPPLY_PROP_CURRENT_NOW
,
357 POWER_SUPPLY_PROP_CAPACITY
,
358 POWER_SUPPLY_PROP_CAPACITY_LEVEL
,
359 POWER_SUPPLY_PROP_TEMP
,
360 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW
,
361 POWER_SUPPLY_PROP_TECHNOLOGY
,
362 POWER_SUPPLY_PROP_CHARGE_FULL
,
363 POWER_SUPPLY_PROP_CHARGE_NOW
,
364 POWER_SUPPLY_PROP_HEALTH
,
365 POWER_SUPPLY_PROP_CYCLE_COUNT
,
366 POWER_SUPPLY_PROP_POWER_AVG
,
367 POWER_SUPPLY_PROP_MANUFACTURER
,
370 static enum power_supply_property bq27421_battery_props
[] = {
371 POWER_SUPPLY_PROP_STATUS
,
372 POWER_SUPPLY_PROP_PRESENT
,
373 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
374 POWER_SUPPLY_PROP_CURRENT_NOW
,
375 POWER_SUPPLY_PROP_CAPACITY
,
376 POWER_SUPPLY_PROP_CAPACITY_LEVEL
,
377 POWER_SUPPLY_PROP_TEMP
,
378 POWER_SUPPLY_PROP_TECHNOLOGY
,
379 POWER_SUPPLY_PROP_CHARGE_FULL
,
380 POWER_SUPPLY_PROP_CHARGE_NOW
,
381 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
,
382 POWER_SUPPLY_PROP_MANUFACTURER
,
385 #define BQ27XXX_PROP(_id, _prop) \
388 .size = ARRAY_SIZE(_prop), \
392 enum power_supply_property
*props
;
394 } bq27xxx_battery_props
[] = {
395 BQ27XXX_PROP(BQ27000
, bq27000_battery_props
),
396 BQ27XXX_PROP(BQ27010
, bq27010_battery_props
),
397 BQ27XXX_PROP(BQ27500
, bq27500_battery_props
),
398 BQ27XXX_PROP(BQ27530
, bq27530_battery_props
),
399 BQ27XXX_PROP(BQ27541
, bq27541_battery_props
),
400 BQ27XXX_PROP(BQ27545
, bq27545_battery_props
),
401 BQ27XXX_PROP(BQ27421
, bq27421_battery_props
),
404 static unsigned int poll_interval
= 360;
405 module_param(poll_interval
, uint
, 0644);
406 MODULE_PARM_DESC(poll_interval
,
407 "battery poll interval in seconds - 0 disables polling");
410 * Common code for BQ27xxx devices
413 static inline int bq27xxx_read(struct bq27xxx_device_info
*di
, int reg_index
,
416 /* Reports EINVAL for invalid/missing registers */
417 if (!di
|| di
->regs
[reg_index
] == INVALID_REG_ADDR
)
420 return di
->bus
.read(di
, di
->regs
[reg_index
], single
);
424 * Return the battery State-of-Charge
425 * Or < 0 if something fails.
427 static int bq27xxx_battery_read_soc(struct bq27xxx_device_info
*di
)
431 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
)
432 soc
= bq27xxx_read(di
, BQ27XXX_REG_SOC
, true);
434 soc
= bq27xxx_read(di
, BQ27XXX_REG_SOC
, false);
437 dev_dbg(di
->dev
, "error reading State-of-Charge\n");
443 * Return a battery charge value in µAh
444 * Or < 0 if something fails.
446 static int bq27xxx_battery_read_charge(struct bq27xxx_device_info
*di
, u8 reg
)
450 charge
= bq27xxx_read(di
, reg
, false);
452 dev_dbg(di
->dev
, "error reading charge register %02x: %d\n",
457 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
)
458 charge
*= BQ27XXX_CURRENT_CONSTANT
/ BQ27XXX_RS
;
466 * Return the battery Nominal available capacity in µAh
467 * Or < 0 if something fails.
469 static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info
*di
)
473 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
) {
474 flags
= bq27xxx_read(di
, BQ27XXX_REG_FLAGS
, true);
475 if (flags
>= 0 && (flags
& BQ27000_FLAG_CI
))
479 return bq27xxx_battery_read_charge(di
, BQ27XXX_REG_NAC
);
483 * Return the battery Full Charge Capacity in µAh
484 * Or < 0 if something fails.
486 static inline int bq27xxx_battery_read_fcc(struct bq27xxx_device_info
*di
)
488 return bq27xxx_battery_read_charge(di
, BQ27XXX_REG_FCC
);
492 * Return the Design Capacity in µAh
493 * Or < 0 if something fails.
495 static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info
*di
)
499 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
)
500 dcap
= bq27xxx_read(di
, BQ27XXX_REG_DCAP
, true);
502 dcap
= bq27xxx_read(di
, BQ27XXX_REG_DCAP
, false);
505 dev_dbg(di
->dev
, "error reading initial last measured discharge\n");
509 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
)
510 dcap
= (dcap
<< 8) * BQ27XXX_CURRENT_CONSTANT
/ BQ27XXX_RS
;
518 * Return the battery Available energy in µWh
519 * Or < 0 if something fails.
521 static int bq27xxx_battery_read_energy(struct bq27xxx_device_info
*di
)
525 ae
= bq27xxx_read(di
, BQ27XXX_REG_AE
, false);
527 dev_dbg(di
->dev
, "error reading available energy\n");
531 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
)
532 ae
*= BQ27XXX_POWER_CONSTANT
/ BQ27XXX_RS
;
540 * Return the battery temperature in tenths of degree Kelvin
541 * Or < 0 if something fails.
543 static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info
*di
)
547 temp
= bq27xxx_read(di
, BQ27XXX_REG_TEMP
, false);
549 dev_err(di
->dev
, "error reading temperature\n");
553 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
)
560 * Return the battery Cycle count total
561 * Or < 0 if something fails.
563 static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info
*di
)
567 cyct
= bq27xxx_read(di
, BQ27XXX_REG_CYCT
, false);
569 dev_err(di
->dev
, "error reading cycle count total\n");
575 * Read a time register.
576 * Return < 0 if something fails.
578 static int bq27xxx_battery_read_time(struct bq27xxx_device_info
*di
, u8 reg
)
582 tval
= bq27xxx_read(di
, reg
, false);
584 dev_dbg(di
->dev
, "error reading time register %02x: %d\n",
596 * Read an average power register.
597 * Return < 0 if something fails.
599 static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info
*di
)
603 tval
= bq27xxx_read(di
, BQ27XXX_REG_AP
, false);
605 dev_err(di
->dev
, "error reading average power register %02x: %d\n",
606 BQ27XXX_REG_AP
, tval
);
610 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
)
611 return (tval
* BQ27XXX_POWER_CONSTANT
) / BQ27XXX_RS
;
617 * Returns true if a battery over temperature condition is detected
619 static bool bq27xxx_battery_overtemp(struct bq27xxx_device_info
*di
, u16 flags
)
621 if (di
->chip
== BQ27500
|| di
->chip
== BQ27541
|| di
->chip
== BQ27545
)
622 return flags
& (BQ27XXX_FLAG_OTC
| BQ27XXX_FLAG_OTD
);
623 if (di
->chip
== BQ27530
|| di
->chip
== BQ27421
)
624 return flags
& BQ27XXX_FLAG_OT
;
630 * Returns true if a battery under temperature condition is detected
632 static bool bq27xxx_battery_undertemp(struct bq27xxx_device_info
*di
, u16 flags
)
634 if (di
->chip
== BQ27530
|| di
->chip
== BQ27421
)
635 return flags
& BQ27XXX_FLAG_UT
;
641 * Returns true if a low state of charge condition is detected
643 static bool bq27xxx_battery_dead(struct bq27xxx_device_info
*di
, u16 flags
)
645 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
)
646 return flags
& (BQ27000_FLAG_EDV1
| BQ27000_FLAG_EDVF
);
648 return flags
& (BQ27XXX_FLAG_SOC1
| BQ27XXX_FLAG_SOCF
);
652 * Read flag register.
653 * Return < 0 if something fails.
655 static int bq27xxx_battery_read_health(struct bq27xxx_device_info
*di
)
659 flags
= bq27xxx_read(di
, BQ27XXX_REG_FLAGS
, false);
661 dev_err(di
->dev
, "error reading flag register:%d\n", flags
);
665 /* Unlikely but important to return first */
666 if (unlikely(bq27xxx_battery_overtemp(di
, flags
)))
667 return POWER_SUPPLY_HEALTH_OVERHEAT
;
668 if (unlikely(bq27xxx_battery_undertemp(di
, flags
)))
669 return POWER_SUPPLY_HEALTH_COLD
;
670 if (unlikely(bq27xxx_battery_dead(di
, flags
)))
671 return POWER_SUPPLY_HEALTH_DEAD
;
673 return POWER_SUPPLY_HEALTH_GOOD
;
676 void bq27xxx_battery_update(struct bq27xxx_device_info
*di
)
678 struct bq27xxx_reg_cache cache
= {0, };
679 bool has_ci_flag
= di
->chip
== BQ27000
|| di
->chip
== BQ27010
;
680 bool has_singe_flag
= di
->chip
== BQ27000
|| di
->chip
== BQ27010
;
682 cache
.flags
= bq27xxx_read(di
, BQ27XXX_REG_FLAGS
, has_singe_flag
);
683 if ((cache
.flags
& 0xff) == 0xff)
684 cache
.flags
= -1; /* read error */
685 if (cache
.flags
>= 0) {
686 cache
.temperature
= bq27xxx_battery_read_temperature(di
);
687 if (has_ci_flag
&& (cache
.flags
& BQ27000_FLAG_CI
)) {
688 dev_info_once(di
->dev
, "battery is not calibrated! ignoring capacity values\n");
689 cache
.capacity
= -ENODATA
;
690 cache
.energy
= -ENODATA
;
691 cache
.time_to_empty
= -ENODATA
;
692 cache
.time_to_empty_avg
= -ENODATA
;
693 cache
.time_to_full
= -ENODATA
;
694 cache
.charge_full
= -ENODATA
;
695 cache
.health
= -ENODATA
;
697 if (di
->regs
[BQ27XXX_REG_TTE
] != INVALID_REG_ADDR
)
698 cache
.time_to_empty
= bq27xxx_battery_read_time(di
, BQ27XXX_REG_TTE
);
699 if (di
->regs
[BQ27XXX_REG_TTECP
] != INVALID_REG_ADDR
)
700 cache
.time_to_empty_avg
= bq27xxx_battery_read_time(di
, BQ27XXX_REG_TTECP
);
701 if (di
->regs
[BQ27XXX_REG_TTF
] != INVALID_REG_ADDR
)
702 cache
.time_to_full
= bq27xxx_battery_read_time(di
, BQ27XXX_REG_TTF
);
703 cache
.charge_full
= bq27xxx_battery_read_fcc(di
);
704 cache
.capacity
= bq27xxx_battery_read_soc(di
);
705 if (di
->regs
[BQ27XXX_REG_AE
] != INVALID_REG_ADDR
)
706 cache
.energy
= bq27xxx_battery_read_energy(di
);
707 cache
.health
= bq27xxx_battery_read_health(di
);
709 if (di
->regs
[BQ27XXX_REG_CYCT
] != INVALID_REG_ADDR
)
710 cache
.cycle_count
= bq27xxx_battery_read_cyct(di
);
711 if (di
->regs
[BQ27XXX_REG_AP
] != INVALID_REG_ADDR
)
712 cache
.power_avg
= bq27xxx_battery_read_pwr_avg(di
);
714 /* We only have to read charge design full once */
715 if (di
->charge_design_full
<= 0)
716 di
->charge_design_full
= bq27xxx_battery_read_dcap(di
);
719 if (di
->cache
.capacity
!= cache
.capacity
)
720 power_supply_changed(di
->bat
);
722 if (memcmp(&di
->cache
, &cache
, sizeof(cache
)) != 0)
725 di
->last_update
= jiffies
;
727 EXPORT_SYMBOL_GPL(bq27xxx_battery_update
);
729 static void bq27xxx_battery_poll(struct work_struct
*work
)
731 struct bq27xxx_device_info
*di
=
732 container_of(work
, struct bq27xxx_device_info
,
735 bq27xxx_battery_update(di
);
737 if (poll_interval
> 0) {
738 /* The timer does not have to be accurate. */
739 set_timer_slack(&di
->work
.timer
, poll_interval
* HZ
/ 4);
740 schedule_delayed_work(&di
->work
, poll_interval
* HZ
);
745 * Return the battery average current in µA
746 * Note that current can be negative signed as well
747 * Or 0 if something fails.
749 static int bq27xxx_battery_current(struct bq27xxx_device_info
*di
,
750 union power_supply_propval
*val
)
755 curr
= bq27xxx_read(di
, BQ27XXX_REG_AI
, false);
757 dev_err(di
->dev
, "error reading current\n");
761 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
) {
762 flags
= bq27xxx_read(di
, BQ27XXX_REG_FLAGS
, false);
763 if (flags
& BQ27000_FLAG_CHGS
) {
764 dev_dbg(di
->dev
, "negative current!\n");
768 val
->intval
= curr
* BQ27XXX_CURRENT_CONSTANT
/ BQ27XXX_RS
;
770 /* Other gauges return signed value */
771 val
->intval
= (int)((s16
)curr
) * 1000;
777 static int bq27xxx_battery_status(struct bq27xxx_device_info
*di
,
778 union power_supply_propval
*val
)
782 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
) {
783 if (di
->cache
.flags
& BQ27000_FLAG_FC
)
784 status
= POWER_SUPPLY_STATUS_FULL
;
785 else if (di
->cache
.flags
& BQ27000_FLAG_CHGS
)
786 status
= POWER_SUPPLY_STATUS_CHARGING
;
787 else if (power_supply_am_i_supplied(di
->bat
))
788 status
= POWER_SUPPLY_STATUS_NOT_CHARGING
;
790 status
= POWER_SUPPLY_STATUS_DISCHARGING
;
792 if (di
->cache
.flags
& BQ27XXX_FLAG_FC
)
793 status
= POWER_SUPPLY_STATUS_FULL
;
794 else if (di
->cache
.flags
& BQ27XXX_FLAG_DSC
)
795 status
= POWER_SUPPLY_STATUS_DISCHARGING
;
797 status
= POWER_SUPPLY_STATUS_CHARGING
;
800 val
->intval
= status
;
805 static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info
*di
,
806 union power_supply_propval
*val
)
810 if (di
->chip
== BQ27000
|| di
->chip
== BQ27010
) {
811 if (di
->cache
.flags
& BQ27000_FLAG_FC
)
812 level
= POWER_SUPPLY_CAPACITY_LEVEL_FULL
;
813 else if (di
->cache
.flags
& BQ27000_FLAG_EDV1
)
814 level
= POWER_SUPPLY_CAPACITY_LEVEL_LOW
;
815 else if (di
->cache
.flags
& BQ27000_FLAG_EDVF
)
816 level
= POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL
;
818 level
= POWER_SUPPLY_CAPACITY_LEVEL_NORMAL
;
820 if (di
->cache
.flags
& BQ27XXX_FLAG_FC
)
821 level
= POWER_SUPPLY_CAPACITY_LEVEL_FULL
;
822 else if (di
->cache
.flags
& BQ27XXX_FLAG_SOC1
)
823 level
= POWER_SUPPLY_CAPACITY_LEVEL_LOW
;
824 else if (di
->cache
.flags
& BQ27XXX_FLAG_SOCF
)
825 level
= POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL
;
827 level
= POWER_SUPPLY_CAPACITY_LEVEL_NORMAL
;
836 * Return the battery Voltage in millivolts
837 * Or < 0 if something fails.
839 static int bq27xxx_battery_voltage(struct bq27xxx_device_info
*di
,
840 union power_supply_propval
*val
)
844 volt
= bq27xxx_read(di
, BQ27XXX_REG_VOLT
, false);
846 dev_err(di
->dev
, "error reading voltage\n");
850 val
->intval
= volt
* 1000;
855 static int bq27xxx_simple_value(int value
,
856 union power_supply_propval
*val
)
866 static int bq27xxx_battery_get_property(struct power_supply
*psy
,
867 enum power_supply_property psp
,
868 union power_supply_propval
*val
)
871 struct bq27xxx_device_info
*di
= power_supply_get_drvdata(psy
);
873 mutex_lock(&di
->lock
);
874 if (time_is_before_jiffies(di
->last_update
+ 5 * HZ
)) {
875 cancel_delayed_work_sync(&di
->work
);
876 bq27xxx_battery_poll(&di
->work
.work
);
878 mutex_unlock(&di
->lock
);
880 if (psp
!= POWER_SUPPLY_PROP_PRESENT
&& di
->cache
.flags
< 0)
884 case POWER_SUPPLY_PROP_STATUS
:
885 ret
= bq27xxx_battery_status(di
, val
);
887 case POWER_SUPPLY_PROP_VOLTAGE_NOW
:
888 ret
= bq27xxx_battery_voltage(di
, val
);
890 case POWER_SUPPLY_PROP_PRESENT
:
891 val
->intval
= di
->cache
.flags
< 0 ? 0 : 1;
893 case POWER_SUPPLY_PROP_CURRENT_NOW
:
894 ret
= bq27xxx_battery_current(di
, val
);
896 case POWER_SUPPLY_PROP_CAPACITY
:
897 ret
= bq27xxx_simple_value(di
->cache
.capacity
, val
);
899 case POWER_SUPPLY_PROP_CAPACITY_LEVEL
:
900 ret
= bq27xxx_battery_capacity_level(di
, val
);
902 case POWER_SUPPLY_PROP_TEMP
:
903 ret
= bq27xxx_simple_value(di
->cache
.temperature
, val
);
905 val
->intval
-= 2731; /* convert decidegree k to c */
907 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW
:
908 ret
= bq27xxx_simple_value(di
->cache
.time_to_empty
, val
);
910 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG
:
911 ret
= bq27xxx_simple_value(di
->cache
.time_to_empty_avg
, val
);
913 case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW
:
914 ret
= bq27xxx_simple_value(di
->cache
.time_to_full
, val
);
916 case POWER_SUPPLY_PROP_TECHNOLOGY
:
917 val
->intval
= POWER_SUPPLY_TECHNOLOGY_LION
;
919 case POWER_SUPPLY_PROP_CHARGE_NOW
:
920 ret
= bq27xxx_simple_value(bq27xxx_battery_read_nac(di
), val
);
922 case POWER_SUPPLY_PROP_CHARGE_FULL
:
923 ret
= bq27xxx_simple_value(di
->cache
.charge_full
, val
);
925 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
:
926 ret
= bq27xxx_simple_value(di
->charge_design_full
, val
);
928 case POWER_SUPPLY_PROP_CYCLE_COUNT
:
929 ret
= bq27xxx_simple_value(di
->cache
.cycle_count
, val
);
931 case POWER_SUPPLY_PROP_ENERGY_NOW
:
932 ret
= bq27xxx_simple_value(di
->cache
.energy
, val
);
934 case POWER_SUPPLY_PROP_POWER_AVG
:
935 ret
= bq27xxx_simple_value(di
->cache
.power_avg
, val
);
937 case POWER_SUPPLY_PROP_HEALTH
:
938 ret
= bq27xxx_simple_value(di
->cache
.health
, val
);
940 case POWER_SUPPLY_PROP_MANUFACTURER
:
941 val
->strval
= BQ27XXX_MANUFACTURER
;
950 static void bq27xxx_external_power_changed(struct power_supply
*psy
)
952 struct bq27xxx_device_info
*di
= power_supply_get_drvdata(psy
);
954 cancel_delayed_work_sync(&di
->work
);
955 schedule_delayed_work(&di
->work
, 0);
958 int bq27xxx_battery_setup(struct bq27xxx_device_info
*di
)
960 struct power_supply_desc
*psy_desc
;
961 struct power_supply_config psy_cfg
= { .drv_data
= di
, };
963 INIT_DELAYED_WORK(&di
->work
, bq27xxx_battery_poll
);
964 mutex_init(&di
->lock
);
965 di
->regs
= bq27xxx_regs
[di
->chip
];
967 psy_desc
= devm_kzalloc(di
->dev
, sizeof(*psy_desc
), GFP_KERNEL
);
971 psy_desc
->name
= di
->name
;
972 psy_desc
->type
= POWER_SUPPLY_TYPE_BATTERY
;
973 psy_desc
->properties
= bq27xxx_battery_props
[di
->chip
].props
;
974 psy_desc
->num_properties
= bq27xxx_battery_props
[di
->chip
].size
;
975 psy_desc
->get_property
= bq27xxx_battery_get_property
;
976 psy_desc
->external_power_changed
= bq27xxx_external_power_changed
;
978 di
->bat
= power_supply_register_no_ws(di
->dev
, psy_desc
, &psy_cfg
);
979 if (IS_ERR(di
->bat
)) {
980 dev_err(di
->dev
, "failed to register battery\n");
981 return PTR_ERR(di
->bat
);
984 dev_info(di
->dev
, "support ver. %s enabled\n", DRIVER_VERSION
);
986 bq27xxx_battery_update(di
);
990 EXPORT_SYMBOL_GPL(bq27xxx_battery_setup
);
992 void bq27xxx_battery_teardown(struct bq27xxx_device_info
*di
)
995 * power_supply_unregister call bq27xxx_battery_get_property which
996 * call bq27xxx_battery_poll.
997 * Make sure that bq27xxx_battery_poll will not call
998 * schedule_delayed_work again after unregister (which cause OOPS).
1002 cancel_delayed_work_sync(&di
->work
);
1004 power_supply_unregister(di
->bat
);
1006 mutex_destroy(&di
->lock
);
1008 EXPORT_SYMBOL_GPL(bq27xxx_battery_teardown
);
1010 static int bq27xxx_battery_platform_read(struct bq27xxx_device_info
*di
, u8 reg
,
1013 struct device
*dev
= di
->dev
;
1014 struct bq27xxx_platform_data
*pdata
= dev
->platform_data
;
1015 unsigned int timeout
= 3;
1020 /* Make sure the value has not changed in between reading the
1021 * lower and the upper part */
1022 upper
= pdata
->read(dev
, reg
+ 1);
1028 lower
= pdata
->read(dev
, reg
);
1032 upper
= pdata
->read(dev
, reg
+ 1);
1033 } while (temp
!= upper
&& --timeout
);
1038 return (upper
<< 8) | lower
;
1041 return pdata
->read(dev
, reg
);
1044 static int bq27xxx_battery_platform_probe(struct platform_device
*pdev
)
1046 struct bq27xxx_device_info
*di
;
1047 struct bq27xxx_platform_data
*pdata
= pdev
->dev
.platform_data
;
1050 dev_err(&pdev
->dev
, "no platform_data supplied\n");
1055 dev_err(&pdev
->dev
, "no hdq read callback supplied\n");
1060 dev_err(&pdev
->dev
, "no device supplied\n");
1064 di
= devm_kzalloc(&pdev
->dev
, sizeof(*di
), GFP_KERNEL
);
1068 platform_set_drvdata(pdev
, di
);
1070 di
->dev
= &pdev
->dev
;
1071 di
->chip
= pdata
->chip
;
1072 di
->name
= pdata
->name
?: dev_name(&pdev
->dev
);
1073 di
->bus
.read
= bq27xxx_battery_platform_read
;
1075 return bq27xxx_battery_setup(di
);
1078 static int bq27xxx_battery_platform_remove(struct platform_device
*pdev
)
1080 struct bq27xxx_device_info
*di
= platform_get_drvdata(pdev
);
1082 bq27xxx_battery_teardown(di
);
1087 static const struct platform_device_id bq27xxx_battery_platform_id_table
[] = {
1088 { "bq27000-battery", },
1091 MODULE_DEVICE_TABLE(platform
, bq27xxx_battery_platform_id_table
);
1093 static struct platform_driver bq27xxx_battery_platform_driver
= {
1094 .probe
= bq27xxx_battery_platform_probe
,
1095 .remove
= bq27xxx_battery_platform_remove
,
1097 .name
= "bq27000-battery",
1099 .id_table
= bq27xxx_battery_platform_id_table
,
1101 module_platform_driver(bq27xxx_battery_platform_driver
);
1103 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
1104 MODULE_DESCRIPTION("BQ27xxx battery monitor driver");
1105 MODULE_LICENSE("GPL");