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>
8 * Copyright (C) 2017 Liam Breck <kernel@networkimprov.net>
10 * Based on a previous work by Copyright (C) 2008 Texas Instruments, Inc.
12 * This package is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
16 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21 * http://www.ti.com/product/bq27000
22 * http://www.ti.com/product/bq27200
23 * http://www.ti.com/product/bq27010
24 * http://www.ti.com/product/bq27210
25 * http://www.ti.com/product/bq27500
26 * http://www.ti.com/product/bq27510-g1
27 * http://www.ti.com/product/bq27510-g2
28 * http://www.ti.com/product/bq27510-g3
29 * http://www.ti.com/product/bq27520-g4
30 * http://www.ti.com/product/bq27520-g1
31 * http://www.ti.com/product/bq27520-g2
32 * http://www.ti.com/product/bq27520-g3
33 * http://www.ti.com/product/bq27520-g4
34 * http://www.ti.com/product/bq27530-g1
35 * http://www.ti.com/product/bq27531-g1
36 * http://www.ti.com/product/bq27541-g1
37 * http://www.ti.com/product/bq27542-g1
38 * http://www.ti.com/product/bq27546-g1
39 * http://www.ti.com/product/bq27742-g1
40 * http://www.ti.com/product/bq27545-g1
41 * http://www.ti.com/product/bq27421-g1
42 * http://www.ti.com/product/bq27425-g1
43 * http://www.ti.com/product/bq27411-g1
44 * http://www.ti.com/product/bq27621-g1
47 #include <linux/device.h>
48 #include <linux/module.h>
49 #include <linux/mutex.h>
50 #include <linux/param.h>
51 #include <linux/jiffies.h>
52 #include <linux/workqueue.h>
53 #include <linux/delay.h>
54 #include <linux/platform_device.h>
55 #include <linux/power_supply.h>
56 #include <linux/slab.h>
59 #include <linux/power/bq27xxx_battery.h>
61 #define BQ27XXX_MANUFACTURER "Texas Instruments"
64 #define BQ27XXX_FLAG_DSC BIT(0)
65 #define BQ27XXX_FLAG_SOCF BIT(1) /* State-of-Charge threshold final */
66 #define BQ27XXX_FLAG_SOC1 BIT(2) /* State-of-Charge threshold 1 */
67 #define BQ27XXX_FLAG_CFGUP BIT(4)
68 #define BQ27XXX_FLAG_FC BIT(9)
69 #define BQ27XXX_FLAG_OTD BIT(14)
70 #define BQ27XXX_FLAG_OTC BIT(15)
71 #define BQ27XXX_FLAG_UT BIT(14)
72 #define BQ27XXX_FLAG_OT BIT(15)
74 /* BQ27000 has different layout for Flags register */
75 #define BQ27000_FLAG_EDVF BIT(0) /* Final End-of-Discharge-Voltage flag */
76 #define BQ27000_FLAG_EDV1 BIT(1) /* First End-of-Discharge-Voltage flag */
77 #define BQ27000_FLAG_CI BIT(4) /* Capacity Inaccurate flag */
78 #define BQ27000_FLAG_FC BIT(5)
79 #define BQ27000_FLAG_CHGS BIT(7) /* Charge state flag */
81 /* control register params */
82 #define BQ27XXX_SEALED 0x20
83 #define BQ27XXX_SET_CFGUPDATE 0x13
84 #define BQ27XXX_SOFT_RESET 0x42
85 #define BQ27XXX_RESET 0x41
87 #define BQ27XXX_RS (20) /* Resistor sense mOhm */
88 #define BQ27XXX_POWER_CONSTANT (29200) /* 29.2 µV^2 * 1000 */
89 #define BQ27XXX_CURRENT_CONSTANT (3570) /* 3.57 µV * 1000 */
91 #define INVALID_REG_ADDR 0xff
94 * bq27xxx_reg_index - Register names
96 * These are indexes into a device's register mapping array.
99 enum bq27xxx_reg_index {
100 BQ27XXX_REG_CTRL = 0, /* Control */
101 BQ27XXX_REG_TEMP, /* Temperature */
102 BQ27XXX_REG_INT_TEMP, /* Internal Temperature */
103 BQ27XXX_REG_VOLT, /* Voltage */
104 BQ27XXX_REG_AI, /* Average Current */
105 BQ27XXX_REG_FLAGS, /* Flags */
106 BQ27XXX_REG_TTE, /* Time-to-Empty */
107 BQ27XXX_REG_TTF, /* Time-to-Full */
108 BQ27XXX_REG_TTES, /* Time-to-Empty Standby */
109 BQ27XXX_REG_TTECP, /* Time-to-Empty at Constant Power */
110 BQ27XXX_REG_NAC, /* Nominal Available Capacity */
111 BQ27XXX_REG_FCC, /* Full Charge Capacity */
112 BQ27XXX_REG_CYCT, /* Cycle Count */
113 BQ27XXX_REG_AE, /* Available Energy */
114 BQ27XXX_REG_SOC, /* State-of-Charge */
115 BQ27XXX_REG_DCAP, /* Design Capacity */
116 BQ27XXX_REG_AP, /* Average Power */
117 BQ27XXX_DM_CTRL, /* Block Data Control */
118 BQ27XXX_DM_CLASS, /* Data Class */
119 BQ27XXX_DM_BLOCK, /* Data Block */
120 BQ27XXX_DM_DATA, /* Block Data */
121 BQ27XXX_DM_CKSUM, /* Block Data Checksum */
122 BQ27XXX_REG_MAX, /* sentinel */
125 #define BQ27XXX_DM_REG_ROWS \
126 [BQ27XXX_DM_CTRL] = 0x61, \
127 [BQ27XXX_DM_CLASS] = 0x3e, \
128 [BQ27XXX_DM_BLOCK] = 0x3f, \
129 [BQ27XXX_DM_DATA] = 0x40, \
130 [BQ27XXX_DM_CKSUM] = 0x60
132 /* Register mappings */
134 bq27000_regs[BQ27XXX_REG_MAX] = {
135 [BQ27XXX_REG_CTRL] = 0x00,
136 [BQ27XXX_REG_TEMP] = 0x06,
137 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
138 [BQ27XXX_REG_VOLT] = 0x08,
139 [BQ27XXX_REG_AI] = 0x14,
140 [BQ27XXX_REG_FLAGS] = 0x0a,
141 [BQ27XXX_REG_TTE] = 0x16,
142 [BQ27XXX_REG_TTF] = 0x18,
143 [BQ27XXX_REG_TTES] = 0x1c,
144 [BQ27XXX_REG_TTECP] = 0x26,
145 [BQ27XXX_REG_NAC] = 0x0c,
146 [BQ27XXX_REG_FCC] = 0x12,
147 [BQ27XXX_REG_CYCT] = 0x2a,
148 [BQ27XXX_REG_AE] = 0x22,
149 [BQ27XXX_REG_SOC] = 0x0b,
150 [BQ27XXX_REG_DCAP] = 0x76,
151 [BQ27XXX_REG_AP] = 0x24,
152 [BQ27XXX_DM_CTRL] = INVALID_REG_ADDR,
153 [BQ27XXX_DM_CLASS] = INVALID_REG_ADDR,
154 [BQ27XXX_DM_BLOCK] = INVALID_REG_ADDR,
155 [BQ27XXX_DM_DATA] = INVALID_REG_ADDR,
156 [BQ27XXX_DM_CKSUM] = INVALID_REG_ADDR,
158 bq27010_regs[BQ27XXX_REG_MAX] = {
159 [BQ27XXX_REG_CTRL] = 0x00,
160 [BQ27XXX_REG_TEMP] = 0x06,
161 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
162 [BQ27XXX_REG_VOLT] = 0x08,
163 [BQ27XXX_REG_AI] = 0x14,
164 [BQ27XXX_REG_FLAGS] = 0x0a,
165 [BQ27XXX_REG_TTE] = 0x16,
166 [BQ27XXX_REG_TTF] = 0x18,
167 [BQ27XXX_REG_TTES] = 0x1c,
168 [BQ27XXX_REG_TTECP] = 0x26,
169 [BQ27XXX_REG_NAC] = 0x0c,
170 [BQ27XXX_REG_FCC] = 0x12,
171 [BQ27XXX_REG_CYCT] = 0x2a,
172 [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
173 [BQ27XXX_REG_SOC] = 0x0b,
174 [BQ27XXX_REG_DCAP] = 0x76,
175 [BQ27XXX_REG_AP] = INVALID_REG_ADDR,
176 [BQ27XXX_DM_CTRL] = INVALID_REG_ADDR,
177 [BQ27XXX_DM_CLASS] = INVALID_REG_ADDR,
178 [BQ27XXX_DM_BLOCK] = INVALID_REG_ADDR,
179 [BQ27XXX_DM_DATA] = INVALID_REG_ADDR,
180 [BQ27XXX_DM_CKSUM] = INVALID_REG_ADDR,
182 bq2750x_regs[BQ27XXX_REG_MAX] = {
183 [BQ27XXX_REG_CTRL] = 0x00,
184 [BQ27XXX_REG_TEMP] = 0x06,
185 [BQ27XXX_REG_INT_TEMP] = 0x28,
186 [BQ27XXX_REG_VOLT] = 0x08,
187 [BQ27XXX_REG_AI] = 0x14,
188 [BQ27XXX_REG_FLAGS] = 0x0a,
189 [BQ27XXX_REG_TTE] = 0x16,
190 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
191 [BQ27XXX_REG_TTES] = 0x1a,
192 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
193 [BQ27XXX_REG_NAC] = 0x0c,
194 [BQ27XXX_REG_FCC] = 0x12,
195 [BQ27XXX_REG_CYCT] = 0x2a,
196 [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
197 [BQ27XXX_REG_SOC] = 0x2c,
198 [BQ27XXX_REG_DCAP] = 0x3c,
199 [BQ27XXX_REG_AP] = INVALID_REG_ADDR,
202 bq2751x_regs[BQ27XXX_REG_MAX] = {
203 [BQ27XXX_REG_CTRL] = 0x00,
204 [BQ27XXX_REG_TEMP] = 0x06,
205 [BQ27XXX_REG_INT_TEMP] = 0x28,
206 [BQ27XXX_REG_VOLT] = 0x08,
207 [BQ27XXX_REG_AI] = 0x14,
208 [BQ27XXX_REG_FLAGS] = 0x0a,
209 [BQ27XXX_REG_TTE] = 0x16,
210 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
211 [BQ27XXX_REG_TTES] = 0x1a,
212 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
213 [BQ27XXX_REG_NAC] = 0x0c,
214 [BQ27XXX_REG_FCC] = 0x12,
215 [BQ27XXX_REG_CYCT] = 0x1e,
216 [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
217 [BQ27XXX_REG_SOC] = 0x20,
218 [BQ27XXX_REG_DCAP] = 0x2e,
219 [BQ27XXX_REG_AP] = INVALID_REG_ADDR,
222 #define bq2752x_regs bq2751x_regs
223 bq27500_regs[BQ27XXX_REG_MAX] = {
224 [BQ27XXX_REG_CTRL] = 0x00,
225 [BQ27XXX_REG_TEMP] = 0x06,
226 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
227 [BQ27XXX_REG_VOLT] = 0x08,
228 [BQ27XXX_REG_AI] = 0x14,
229 [BQ27XXX_REG_FLAGS] = 0x0a,
230 [BQ27XXX_REG_TTE] = 0x16,
231 [BQ27XXX_REG_TTF] = 0x18,
232 [BQ27XXX_REG_TTES] = 0x1c,
233 [BQ27XXX_REG_TTECP] = 0x26,
234 [BQ27XXX_REG_NAC] = 0x0c,
235 [BQ27XXX_REG_FCC] = 0x12,
236 [BQ27XXX_REG_CYCT] = 0x2a,
237 [BQ27XXX_REG_AE] = 0x22,
238 [BQ27XXX_REG_SOC] = 0x2c,
239 [BQ27XXX_REG_DCAP] = 0x3c,
240 [BQ27XXX_REG_AP] = 0x24,
243 bq27510g1_regs[BQ27XXX_REG_MAX] = {
244 [BQ27XXX_REG_CTRL] = 0x00,
245 [BQ27XXX_REG_TEMP] = 0x06,
246 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
247 [BQ27XXX_REG_VOLT] = 0x08,
248 [BQ27XXX_REG_AI] = 0x14,
249 [BQ27XXX_REG_FLAGS] = 0x0a,
250 [BQ27XXX_REG_TTE] = 0x16,
251 [BQ27XXX_REG_TTF] = 0x18,
252 [BQ27XXX_REG_TTES] = 0x1c,
253 [BQ27XXX_REG_TTECP] = 0x26,
254 [BQ27XXX_REG_NAC] = 0x0c,
255 [BQ27XXX_REG_FCC] = 0x12,
256 [BQ27XXX_REG_CYCT] = 0x2a,
257 [BQ27XXX_REG_AE] = 0x22,
258 [BQ27XXX_REG_SOC] = 0x2c,
259 [BQ27XXX_REG_DCAP] = 0x3c,
260 [BQ27XXX_REG_AP] = 0x24,
263 bq27510g2_regs[BQ27XXX_REG_MAX] = {
264 [BQ27XXX_REG_CTRL] = 0x00,
265 [BQ27XXX_REG_TEMP] = 0x06,
266 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
267 [BQ27XXX_REG_VOLT] = 0x08,
268 [BQ27XXX_REG_AI] = 0x14,
269 [BQ27XXX_REG_FLAGS] = 0x0a,
270 [BQ27XXX_REG_TTE] = 0x16,
271 [BQ27XXX_REG_TTF] = 0x18,
272 [BQ27XXX_REG_TTES] = 0x1c,
273 [BQ27XXX_REG_TTECP] = 0x26,
274 [BQ27XXX_REG_NAC] = 0x0c,
275 [BQ27XXX_REG_FCC] = 0x12,
276 [BQ27XXX_REG_CYCT] = 0x2a,
277 [BQ27XXX_REG_AE] = 0x22,
278 [BQ27XXX_REG_SOC] = 0x2c,
279 [BQ27XXX_REG_DCAP] = 0x3c,
280 [BQ27XXX_REG_AP] = 0x24,
283 bq27510g3_regs[BQ27XXX_REG_MAX] = {
284 [BQ27XXX_REG_CTRL] = 0x00,
285 [BQ27XXX_REG_TEMP] = 0x06,
286 [BQ27XXX_REG_INT_TEMP] = 0x28,
287 [BQ27XXX_REG_VOLT] = 0x08,
288 [BQ27XXX_REG_AI] = 0x14,
289 [BQ27XXX_REG_FLAGS] = 0x0a,
290 [BQ27XXX_REG_TTE] = 0x16,
291 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
292 [BQ27XXX_REG_TTES] = 0x1a,
293 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
294 [BQ27XXX_REG_NAC] = 0x0c,
295 [BQ27XXX_REG_FCC] = 0x12,
296 [BQ27XXX_REG_CYCT] = 0x1e,
297 [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
298 [BQ27XXX_REG_SOC] = 0x20,
299 [BQ27XXX_REG_DCAP] = 0x2e,
300 [BQ27XXX_REG_AP] = INVALID_REG_ADDR,
303 bq27520g1_regs[BQ27XXX_REG_MAX] = {
304 [BQ27XXX_REG_CTRL] = 0x00,
305 [BQ27XXX_REG_TEMP] = 0x06,
306 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR,
307 [BQ27XXX_REG_VOLT] = 0x08,
308 [BQ27XXX_REG_AI] = 0x14,
309 [BQ27XXX_REG_FLAGS] = 0x0a,
310 [BQ27XXX_REG_TTE] = 0x16,
311 [BQ27XXX_REG_TTF] = 0x18,
312 [BQ27XXX_REG_TTES] = 0x1c,
313 [BQ27XXX_REG_TTECP] = 0x26,
314 [BQ27XXX_REG_NAC] = 0x0c,
315 [BQ27XXX_REG_FCC] = 0x12,
316 [BQ27XXX_REG_CYCT] = INVALID_REG_ADDR,
317 [BQ27XXX_REG_AE] = 0x22,
318 [BQ27XXX_REG_SOC] = 0x2c,
319 [BQ27XXX_REG_DCAP] = 0x3c,
320 [BQ27XXX_REG_AP] = 0x24,
323 bq27520g2_regs[BQ27XXX_REG_MAX] = {
324 [BQ27XXX_REG_CTRL] = 0x00,
325 [BQ27XXX_REG_TEMP] = 0x06,
326 [BQ27XXX_REG_INT_TEMP] = 0x36,
327 [BQ27XXX_REG_VOLT] = 0x08,
328 [BQ27XXX_REG_AI] = 0x14,
329 [BQ27XXX_REG_FLAGS] = 0x0a,
330 [BQ27XXX_REG_TTE] = 0x16,
331 [BQ27XXX_REG_TTF] = 0x18,
332 [BQ27XXX_REG_TTES] = 0x1c,
333 [BQ27XXX_REG_TTECP] = 0x26,
334 [BQ27XXX_REG_NAC] = 0x0c,
335 [BQ27XXX_REG_FCC] = 0x12,
336 [BQ27XXX_REG_CYCT] = 0x2a,
337 [BQ27XXX_REG_AE] = 0x22,
338 [BQ27XXX_REG_SOC] = 0x2c,
339 [BQ27XXX_REG_DCAP] = 0x3c,
340 [BQ27XXX_REG_AP] = 0x24,
343 bq27520g3_regs[BQ27XXX_REG_MAX] = {
344 [BQ27XXX_REG_CTRL] = 0x00,
345 [BQ27XXX_REG_TEMP] = 0x06,
346 [BQ27XXX_REG_INT_TEMP] = 0x36,
347 [BQ27XXX_REG_VOLT] = 0x08,
348 [BQ27XXX_REG_AI] = 0x14,
349 [BQ27XXX_REG_FLAGS] = 0x0a,
350 [BQ27XXX_REG_TTE] = 0x16,
351 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
352 [BQ27XXX_REG_TTES] = 0x1c,
353 [BQ27XXX_REG_TTECP] = 0x26,
354 [BQ27XXX_REG_NAC] = 0x0c,
355 [BQ27XXX_REG_FCC] = 0x12,
356 [BQ27XXX_REG_CYCT] = 0x2a,
357 [BQ27XXX_REG_AE] = 0x22,
358 [BQ27XXX_REG_SOC] = 0x2c,
359 [BQ27XXX_REG_DCAP] = 0x3c,
360 [BQ27XXX_REG_AP] = 0x24,
363 bq27520g4_regs[BQ27XXX_REG_MAX] = {
364 [BQ27XXX_REG_CTRL] = 0x00,
365 [BQ27XXX_REG_TEMP] = 0x06,
366 [BQ27XXX_REG_INT_TEMP] = 0x28,
367 [BQ27XXX_REG_VOLT] = 0x08,
368 [BQ27XXX_REG_AI] = 0x14,
369 [BQ27XXX_REG_FLAGS] = 0x0a,
370 [BQ27XXX_REG_TTE] = 0x16,
371 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
372 [BQ27XXX_REG_TTES] = 0x1c,
373 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
374 [BQ27XXX_REG_NAC] = 0x0c,
375 [BQ27XXX_REG_FCC] = 0x12,
376 [BQ27XXX_REG_CYCT] = 0x1e,
377 [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
378 [BQ27XXX_REG_SOC] = 0x20,
379 [BQ27XXX_REG_DCAP] = INVALID_REG_ADDR,
380 [BQ27XXX_REG_AP] = INVALID_REG_ADDR,
383 bq27530_regs[BQ27XXX_REG_MAX] = {
384 [BQ27XXX_REG_CTRL] = 0x00,
385 [BQ27XXX_REG_TEMP] = 0x06,
386 [BQ27XXX_REG_INT_TEMP] = 0x32,
387 [BQ27XXX_REG_VOLT] = 0x08,
388 [BQ27XXX_REG_AI] = 0x14,
389 [BQ27XXX_REG_FLAGS] = 0x0a,
390 [BQ27XXX_REG_TTE] = 0x16,
391 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
392 [BQ27XXX_REG_TTES] = INVALID_REG_ADDR,
393 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
394 [BQ27XXX_REG_NAC] = 0x0c,
395 [BQ27XXX_REG_FCC] = 0x12,
396 [BQ27XXX_REG_CYCT] = 0x2a,
397 [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
398 [BQ27XXX_REG_SOC] = 0x2c,
399 [BQ27XXX_REG_DCAP] = INVALID_REG_ADDR,
400 [BQ27XXX_REG_AP] = 0x24,
403 #define bq27531_regs bq27530_regs
404 bq27541_regs[BQ27XXX_REG_MAX] = {
405 [BQ27XXX_REG_CTRL] = 0x00,
406 [BQ27XXX_REG_TEMP] = 0x06,
407 [BQ27XXX_REG_INT_TEMP] = 0x28,
408 [BQ27XXX_REG_VOLT] = 0x08,
409 [BQ27XXX_REG_AI] = 0x14,
410 [BQ27XXX_REG_FLAGS] = 0x0a,
411 [BQ27XXX_REG_TTE] = 0x16,
412 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
413 [BQ27XXX_REG_TTES] = INVALID_REG_ADDR,
414 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
415 [BQ27XXX_REG_NAC] = 0x0c,
416 [BQ27XXX_REG_FCC] = 0x12,
417 [BQ27XXX_REG_CYCT] = 0x2a,
418 [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
419 [BQ27XXX_REG_SOC] = 0x2c,
420 [BQ27XXX_REG_DCAP] = 0x3c,
421 [BQ27XXX_REG_AP] = 0x24,
424 #define bq27542_regs bq27541_regs
425 #define bq27546_regs bq27541_regs
426 #define bq27742_regs bq27541_regs
427 bq27545_regs[BQ27XXX_REG_MAX] = {
428 [BQ27XXX_REG_CTRL] = 0x00,
429 [BQ27XXX_REG_TEMP] = 0x06,
430 [BQ27XXX_REG_INT_TEMP] = 0x28,
431 [BQ27XXX_REG_VOLT] = 0x08,
432 [BQ27XXX_REG_AI] = 0x14,
433 [BQ27XXX_REG_FLAGS] = 0x0a,
434 [BQ27XXX_REG_TTE] = 0x16,
435 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
436 [BQ27XXX_REG_TTES] = INVALID_REG_ADDR,
437 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
438 [BQ27XXX_REG_NAC] = 0x0c,
439 [BQ27XXX_REG_FCC] = 0x12,
440 [BQ27XXX_REG_CYCT] = 0x2a,
441 [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
442 [BQ27XXX_REG_SOC] = 0x2c,
443 [BQ27XXX_REG_DCAP] = INVALID_REG_ADDR,
444 [BQ27XXX_REG_AP] = 0x24,
447 bq27421_regs[BQ27XXX_REG_MAX] = {
448 [BQ27XXX_REG_CTRL] = 0x00,
449 [BQ27XXX_REG_TEMP] = 0x02,
450 [BQ27XXX_REG_INT_TEMP] = 0x1e,
451 [BQ27XXX_REG_VOLT] = 0x04,
452 [BQ27XXX_REG_AI] = 0x10,
453 [BQ27XXX_REG_FLAGS] = 0x06,
454 [BQ27XXX_REG_TTE] = INVALID_REG_ADDR,
455 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR,
456 [BQ27XXX_REG_TTES] = INVALID_REG_ADDR,
457 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR,
458 [BQ27XXX_REG_NAC] = 0x08,
459 [BQ27XXX_REG_FCC] = 0x0e,
460 [BQ27XXX_REG_CYCT] = INVALID_REG_ADDR,
461 [BQ27XXX_REG_AE] = INVALID_REG_ADDR,
462 [BQ27XXX_REG_SOC] = 0x1c,
463 [BQ27XXX_REG_DCAP] = 0x3c,
464 [BQ27XXX_REG_AP] = 0x18,
467 #define bq27425_regs bq27421_regs
468 #define bq27441_regs bq27421_regs
469 #define bq27621_regs bq27421_regs
471 static enum power_supply_property bq27000_props[] = {
472 POWER_SUPPLY_PROP_STATUS,
473 POWER_SUPPLY_PROP_PRESENT,
474 POWER_SUPPLY_PROP_VOLTAGE_NOW,
475 POWER_SUPPLY_PROP_CURRENT_NOW,
476 POWER_SUPPLY_PROP_CAPACITY,
477 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
478 POWER_SUPPLY_PROP_TEMP,
479 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
480 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
481 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
482 POWER_SUPPLY_PROP_TECHNOLOGY,
483 POWER_SUPPLY_PROP_CHARGE_FULL,
484 POWER_SUPPLY_PROP_CHARGE_NOW,
485 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
486 POWER_SUPPLY_PROP_CYCLE_COUNT,
487 POWER_SUPPLY_PROP_ENERGY_NOW,
488 POWER_SUPPLY_PROP_POWER_AVG,
489 POWER_SUPPLY_PROP_HEALTH,
490 POWER_SUPPLY_PROP_MANUFACTURER,
493 static enum power_supply_property bq27010_props[] = {
494 POWER_SUPPLY_PROP_STATUS,
495 POWER_SUPPLY_PROP_PRESENT,
496 POWER_SUPPLY_PROP_VOLTAGE_NOW,
497 POWER_SUPPLY_PROP_CURRENT_NOW,
498 POWER_SUPPLY_PROP_CAPACITY,
499 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
500 POWER_SUPPLY_PROP_TEMP,
501 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
502 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
503 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
504 POWER_SUPPLY_PROP_TECHNOLOGY,
505 POWER_SUPPLY_PROP_CHARGE_FULL,
506 POWER_SUPPLY_PROP_CHARGE_NOW,
507 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
508 POWER_SUPPLY_PROP_CYCLE_COUNT,
509 POWER_SUPPLY_PROP_HEALTH,
510 POWER_SUPPLY_PROP_MANUFACTURER,
513 static enum power_supply_property bq2750x_props[] = {
514 POWER_SUPPLY_PROP_STATUS,
515 POWER_SUPPLY_PROP_PRESENT,
516 POWER_SUPPLY_PROP_VOLTAGE_NOW,
517 POWER_SUPPLY_PROP_CURRENT_NOW,
518 POWER_SUPPLY_PROP_CAPACITY,
519 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
520 POWER_SUPPLY_PROP_TEMP,
521 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
522 POWER_SUPPLY_PROP_TECHNOLOGY,
523 POWER_SUPPLY_PROP_CHARGE_FULL,
524 POWER_SUPPLY_PROP_CHARGE_NOW,
525 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
526 POWER_SUPPLY_PROP_CYCLE_COUNT,
527 POWER_SUPPLY_PROP_HEALTH,
528 POWER_SUPPLY_PROP_MANUFACTURER,
531 static enum power_supply_property bq2751x_props[] = {
532 POWER_SUPPLY_PROP_STATUS,
533 POWER_SUPPLY_PROP_PRESENT,
534 POWER_SUPPLY_PROP_VOLTAGE_NOW,
535 POWER_SUPPLY_PROP_CURRENT_NOW,
536 POWER_SUPPLY_PROP_CAPACITY,
537 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
538 POWER_SUPPLY_PROP_TEMP,
539 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
540 POWER_SUPPLY_PROP_TECHNOLOGY,
541 POWER_SUPPLY_PROP_CHARGE_FULL,
542 POWER_SUPPLY_PROP_CHARGE_NOW,
543 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
544 POWER_SUPPLY_PROP_CYCLE_COUNT,
545 POWER_SUPPLY_PROP_HEALTH,
546 POWER_SUPPLY_PROP_MANUFACTURER,
548 #define bq2752x_props bq2751x_props
550 static enum power_supply_property bq27500_props[] = {
551 POWER_SUPPLY_PROP_STATUS,
552 POWER_SUPPLY_PROP_PRESENT,
553 POWER_SUPPLY_PROP_VOLTAGE_NOW,
554 POWER_SUPPLY_PROP_CURRENT_NOW,
555 POWER_SUPPLY_PROP_CAPACITY,
556 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
557 POWER_SUPPLY_PROP_TEMP,
558 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
559 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
560 POWER_SUPPLY_PROP_TECHNOLOGY,
561 POWER_SUPPLY_PROP_CHARGE_FULL,
562 POWER_SUPPLY_PROP_CHARGE_NOW,
563 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
564 POWER_SUPPLY_PROP_CYCLE_COUNT,
565 POWER_SUPPLY_PROP_ENERGY_NOW,
566 POWER_SUPPLY_PROP_POWER_AVG,
567 POWER_SUPPLY_PROP_HEALTH,
568 POWER_SUPPLY_PROP_MANUFACTURER,
571 static enum power_supply_property bq27510g1_props[] = {
572 POWER_SUPPLY_PROP_STATUS,
573 POWER_SUPPLY_PROP_PRESENT,
574 POWER_SUPPLY_PROP_VOLTAGE_NOW,
575 POWER_SUPPLY_PROP_CURRENT_NOW,
576 POWER_SUPPLY_PROP_CAPACITY,
577 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
578 POWER_SUPPLY_PROP_TEMP,
579 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
580 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
581 POWER_SUPPLY_PROP_TECHNOLOGY,
582 POWER_SUPPLY_PROP_CHARGE_FULL,
583 POWER_SUPPLY_PROP_CHARGE_NOW,
584 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
585 POWER_SUPPLY_PROP_CYCLE_COUNT,
586 POWER_SUPPLY_PROP_ENERGY_NOW,
587 POWER_SUPPLY_PROP_POWER_AVG,
588 POWER_SUPPLY_PROP_HEALTH,
589 POWER_SUPPLY_PROP_MANUFACTURER,
592 static enum power_supply_property bq27510g2_props[] = {
593 POWER_SUPPLY_PROP_STATUS,
594 POWER_SUPPLY_PROP_PRESENT,
595 POWER_SUPPLY_PROP_VOLTAGE_NOW,
596 POWER_SUPPLY_PROP_CURRENT_NOW,
597 POWER_SUPPLY_PROP_CAPACITY,
598 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
599 POWER_SUPPLY_PROP_TEMP,
600 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
601 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
602 POWER_SUPPLY_PROP_TECHNOLOGY,
603 POWER_SUPPLY_PROP_CHARGE_FULL,
604 POWER_SUPPLY_PROP_CHARGE_NOW,
605 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
606 POWER_SUPPLY_PROP_CYCLE_COUNT,
607 POWER_SUPPLY_PROP_ENERGY_NOW,
608 POWER_SUPPLY_PROP_POWER_AVG,
609 POWER_SUPPLY_PROP_HEALTH,
610 POWER_SUPPLY_PROP_MANUFACTURER,
613 static enum power_supply_property bq27510g3_props[] = {
614 POWER_SUPPLY_PROP_STATUS,
615 POWER_SUPPLY_PROP_PRESENT,
616 POWER_SUPPLY_PROP_VOLTAGE_NOW,
617 POWER_SUPPLY_PROP_CURRENT_NOW,
618 POWER_SUPPLY_PROP_CAPACITY,
619 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
620 POWER_SUPPLY_PROP_TEMP,
621 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
622 POWER_SUPPLY_PROP_TECHNOLOGY,
623 POWER_SUPPLY_PROP_CHARGE_FULL,
624 POWER_SUPPLY_PROP_CHARGE_NOW,
625 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
626 POWER_SUPPLY_PROP_CYCLE_COUNT,
627 POWER_SUPPLY_PROP_HEALTH,
628 POWER_SUPPLY_PROP_MANUFACTURER,
631 static enum power_supply_property bq27520g1_props[] = {
632 POWER_SUPPLY_PROP_STATUS,
633 POWER_SUPPLY_PROP_PRESENT,
634 POWER_SUPPLY_PROP_VOLTAGE_NOW,
635 POWER_SUPPLY_PROP_CURRENT_NOW,
636 POWER_SUPPLY_PROP_CAPACITY,
637 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
638 POWER_SUPPLY_PROP_TEMP,
639 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
640 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
641 POWER_SUPPLY_PROP_TECHNOLOGY,
642 POWER_SUPPLY_PROP_CHARGE_FULL,
643 POWER_SUPPLY_PROP_CHARGE_NOW,
644 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
645 POWER_SUPPLY_PROP_ENERGY_NOW,
646 POWER_SUPPLY_PROP_POWER_AVG,
647 POWER_SUPPLY_PROP_HEALTH,
648 POWER_SUPPLY_PROP_MANUFACTURER,
651 static enum power_supply_property bq27520g2_props[] = {
652 POWER_SUPPLY_PROP_STATUS,
653 POWER_SUPPLY_PROP_PRESENT,
654 POWER_SUPPLY_PROP_VOLTAGE_NOW,
655 POWER_SUPPLY_PROP_CURRENT_NOW,
656 POWER_SUPPLY_PROP_CAPACITY,
657 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
658 POWER_SUPPLY_PROP_TEMP,
659 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
660 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
661 POWER_SUPPLY_PROP_TECHNOLOGY,
662 POWER_SUPPLY_PROP_CHARGE_FULL,
663 POWER_SUPPLY_PROP_CHARGE_NOW,
664 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
665 POWER_SUPPLY_PROP_CYCLE_COUNT,
666 POWER_SUPPLY_PROP_ENERGY_NOW,
667 POWER_SUPPLY_PROP_POWER_AVG,
668 POWER_SUPPLY_PROP_HEALTH,
669 POWER_SUPPLY_PROP_MANUFACTURER,
672 static enum power_supply_property bq27520g3_props[] = {
673 POWER_SUPPLY_PROP_STATUS,
674 POWER_SUPPLY_PROP_PRESENT,
675 POWER_SUPPLY_PROP_VOLTAGE_NOW,
676 POWER_SUPPLY_PROP_CURRENT_NOW,
677 POWER_SUPPLY_PROP_CAPACITY,
678 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
679 POWER_SUPPLY_PROP_TEMP,
680 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
681 POWER_SUPPLY_PROP_TECHNOLOGY,
682 POWER_SUPPLY_PROP_CHARGE_FULL,
683 POWER_SUPPLY_PROP_CHARGE_NOW,
684 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
685 POWER_SUPPLY_PROP_CYCLE_COUNT,
686 POWER_SUPPLY_PROP_ENERGY_NOW,
687 POWER_SUPPLY_PROP_POWER_AVG,
688 POWER_SUPPLY_PROP_HEALTH,
689 POWER_SUPPLY_PROP_MANUFACTURER,
692 static enum power_supply_property bq27520g4_props[] = {
693 POWER_SUPPLY_PROP_STATUS,
694 POWER_SUPPLY_PROP_PRESENT,
695 POWER_SUPPLY_PROP_VOLTAGE_NOW,
696 POWER_SUPPLY_PROP_CURRENT_NOW,
697 POWER_SUPPLY_PROP_CAPACITY,
698 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
699 POWER_SUPPLY_PROP_TEMP,
700 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
701 POWER_SUPPLY_PROP_TECHNOLOGY,
702 POWER_SUPPLY_PROP_CHARGE_FULL,
703 POWER_SUPPLY_PROP_CHARGE_NOW,
704 POWER_SUPPLY_PROP_CYCLE_COUNT,
705 POWER_SUPPLY_PROP_HEALTH,
706 POWER_SUPPLY_PROP_MANUFACTURER,
709 static enum power_supply_property bq27530_props[] = {
710 POWER_SUPPLY_PROP_STATUS,
711 POWER_SUPPLY_PROP_PRESENT,
712 POWER_SUPPLY_PROP_VOLTAGE_NOW,
713 POWER_SUPPLY_PROP_CURRENT_NOW,
714 POWER_SUPPLY_PROP_CAPACITY,
715 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
716 POWER_SUPPLY_PROP_TEMP,
717 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
718 POWER_SUPPLY_PROP_TECHNOLOGY,
719 POWER_SUPPLY_PROP_CHARGE_FULL,
720 POWER_SUPPLY_PROP_CHARGE_NOW,
721 POWER_SUPPLY_PROP_POWER_AVG,
722 POWER_SUPPLY_PROP_HEALTH,
723 POWER_SUPPLY_PROP_CYCLE_COUNT,
724 POWER_SUPPLY_PROP_MANUFACTURER,
726 #define bq27531_props bq27530_props
728 static enum power_supply_property bq27541_props[] = {
729 POWER_SUPPLY_PROP_STATUS,
730 POWER_SUPPLY_PROP_PRESENT,
731 POWER_SUPPLY_PROP_VOLTAGE_NOW,
732 POWER_SUPPLY_PROP_CURRENT_NOW,
733 POWER_SUPPLY_PROP_CAPACITY,
734 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
735 POWER_SUPPLY_PROP_TEMP,
736 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
737 POWER_SUPPLY_PROP_TECHNOLOGY,
738 POWER_SUPPLY_PROP_CHARGE_FULL,
739 POWER_SUPPLY_PROP_CHARGE_NOW,
740 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
741 POWER_SUPPLY_PROP_CYCLE_COUNT,
742 POWER_SUPPLY_PROP_POWER_AVG,
743 POWER_SUPPLY_PROP_HEALTH,
744 POWER_SUPPLY_PROP_MANUFACTURER,
746 #define bq27542_props bq27541_props
747 #define bq27546_props bq27541_props
748 #define bq27742_props bq27541_props
750 static enum power_supply_property bq27545_props[] = {
751 POWER_SUPPLY_PROP_STATUS,
752 POWER_SUPPLY_PROP_PRESENT,
753 POWER_SUPPLY_PROP_VOLTAGE_NOW,
754 POWER_SUPPLY_PROP_CURRENT_NOW,
755 POWER_SUPPLY_PROP_CAPACITY,
756 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
757 POWER_SUPPLY_PROP_TEMP,
758 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
759 POWER_SUPPLY_PROP_TECHNOLOGY,
760 POWER_SUPPLY_PROP_CHARGE_FULL,
761 POWER_SUPPLY_PROP_CHARGE_NOW,
762 POWER_SUPPLY_PROP_HEALTH,
763 POWER_SUPPLY_PROP_CYCLE_COUNT,
764 POWER_SUPPLY_PROP_POWER_AVG,
765 POWER_SUPPLY_PROP_MANUFACTURER,
768 static enum power_supply_property bq27421_props[] = {
769 POWER_SUPPLY_PROP_STATUS,
770 POWER_SUPPLY_PROP_PRESENT,
771 POWER_SUPPLY_PROP_VOLTAGE_NOW,
772 POWER_SUPPLY_PROP_CURRENT_NOW,
773 POWER_SUPPLY_PROP_CAPACITY,
774 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
775 POWER_SUPPLY_PROP_TEMP,
776 POWER_SUPPLY_PROP_TECHNOLOGY,
777 POWER_SUPPLY_PROP_CHARGE_FULL,
778 POWER_SUPPLY_PROP_CHARGE_NOW,
779 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
780 POWER_SUPPLY_PROP_MANUFACTURER,
782 #define bq27425_props bq27421_props
783 #define bq27441_props bq27421_props
784 #define bq27621_props bq27421_props
786 struct bq27xxx_dm_reg {
793 enum bq27xxx_dm_reg_id {
794 BQ27XXX_DM_DESIGN_CAPACITY = 0,
795 BQ27XXX_DM_DESIGN_ENERGY,
796 BQ27XXX_DM_TERMINATE_VOLTAGE,
799 #define bq27000_dm_regs 0
800 #define bq27010_dm_regs 0
801 #define bq2750x_dm_regs 0
802 #define bq2751x_dm_regs 0
803 #define bq2752x_dm_regs 0
805 #if 0 /* not yet tested */
806 static struct bq27xxx_dm_reg bq27500_dm_regs[] = {
807 [BQ27XXX_DM_DESIGN_CAPACITY] = { 48, 10, 2, 0, 65535 },
808 [BQ27XXX_DM_DESIGN_ENERGY] = { }, /* missing on chip */
809 [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 48, 2, 1000, 32767 },
812 #define bq27500_dm_regs 0
815 /* todo create data memory definitions from datasheets and test on chips */
816 #define bq27510g1_dm_regs 0
817 #define bq27510g2_dm_regs 0
818 #define bq27510g3_dm_regs 0
819 #define bq27520g1_dm_regs 0
820 #define bq27520g2_dm_regs 0
821 #define bq27520g3_dm_regs 0
822 #define bq27520g4_dm_regs 0
823 #define bq27530_dm_regs 0
824 #define bq27531_dm_regs 0
825 #define bq27541_dm_regs 0
826 #define bq27542_dm_regs 0
827 #define bq27546_dm_regs 0
828 #define bq27742_dm_regs 0
830 #if 0 /* not yet tested */
831 static struct bq27xxx_dm_reg bq27545_dm_regs[] = {
832 [BQ27XXX_DM_DESIGN_CAPACITY] = { 48, 23, 2, 0, 32767 },
833 [BQ27XXX_DM_DESIGN_ENERGY] = { 48, 25, 2, 0, 32767 },
834 [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 67, 2, 2800, 3700 },
837 #define bq27545_dm_regs 0
840 #if 0 /* not yet tested */
841 static struct bq27xxx_dm_reg bq27421_dm_regs[] = {
842 [BQ27XXX_DM_DESIGN_CAPACITY] = { 82, 10, 2, 0, 8000 },
843 [BQ27XXX_DM_DESIGN_ENERGY] = { 82, 12, 2, 0, 32767 },
844 [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 16, 2, 2500, 3700 },
847 #define bq27421_dm_regs 0
850 static struct bq27xxx_dm_reg bq27425_dm_regs[] = {
851 [BQ27XXX_DM_DESIGN_CAPACITY] = { 82, 12, 2, 0, 32767 },
852 [BQ27XXX_DM_DESIGN_ENERGY] = { 82, 14, 2, 0, 32767 },
853 [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 18, 2, 2800, 3700 },
856 #if 0 /* not yet tested */
857 #define bq27441_dm_regs bq27421_dm_regs
859 #define bq27441_dm_regs 0
862 #if 0 /* not yet tested */
863 static struct bq27xxx_dm_reg bq27621_dm_regs[] = {
864 [BQ27XXX_DM_DESIGN_CAPACITY] = { 82, 3, 2, 0, 8000 },
865 [BQ27XXX_DM_DESIGN_ENERGY] = { 82, 5, 2, 0, 32767 },
866 [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 9, 2, 2500, 3700 },
869 #define bq27621_dm_regs 0
872 #define BQ27XXX_O_ZERO 0x00000001
873 #define BQ27XXX_O_OTDC 0x00000002
874 #define BQ27XXX_O_UTOT 0x00000004
875 #define BQ27XXX_O_CFGUP 0x00000008
876 #define BQ27XXX_O_RAM 0x00000010
878 #define BQ27XXX_DATA(ref, key, opt) { \
881 .regs = ref##_regs, \
882 .dm_regs = ref##_dm_regs, \
883 .props = ref##_props, \
884 .props_size = ARRAY_SIZE(ref##_props) }
890 struct bq27xxx_dm_reg *dm_regs;
891 enum power_supply_property *props;
893 } bq27xxx_chip_data[] = {
894 [BQ27000] = BQ27XXX_DATA(bq27000, 0 , BQ27XXX_O_ZERO),
895 [BQ27010] = BQ27XXX_DATA(bq27010, 0 , BQ27XXX_O_ZERO),
896 [BQ2750X] = BQ27XXX_DATA(bq2750x, 0 , BQ27XXX_O_OTDC),
897 [BQ2751X] = BQ27XXX_DATA(bq2751x, 0 , BQ27XXX_O_OTDC),
898 [BQ2752X] = BQ27XXX_DATA(bq2752x, 0 , BQ27XXX_O_OTDC),
899 [BQ27500] = BQ27XXX_DATA(bq27500, 0x04143672, BQ27XXX_O_OTDC),
900 [BQ27510G1] = BQ27XXX_DATA(bq27510g1, 0 , BQ27XXX_O_OTDC),
901 [BQ27510G2] = BQ27XXX_DATA(bq27510g2, 0 , BQ27XXX_O_OTDC),
902 [BQ27510G3] = BQ27XXX_DATA(bq27510g3, 0 , BQ27XXX_O_OTDC),
903 [BQ27520G1] = BQ27XXX_DATA(bq27520g1, 0 , BQ27XXX_O_OTDC),
904 [BQ27520G2] = BQ27XXX_DATA(bq27520g2, 0 , BQ27XXX_O_OTDC),
905 [BQ27520G3] = BQ27XXX_DATA(bq27520g3, 0 , BQ27XXX_O_OTDC),
906 [BQ27520G4] = BQ27XXX_DATA(bq27520g4, 0 , BQ27XXX_O_OTDC),
907 [BQ27530] = BQ27XXX_DATA(bq27530, 0 , BQ27XXX_O_UTOT),
908 [BQ27531] = BQ27XXX_DATA(bq27531, 0 , BQ27XXX_O_UTOT),
909 [BQ27541] = BQ27XXX_DATA(bq27541, 0 , BQ27XXX_O_OTDC),
910 [BQ27542] = BQ27XXX_DATA(bq27542, 0 , BQ27XXX_O_OTDC),
911 [BQ27546] = BQ27XXX_DATA(bq27546, 0 , BQ27XXX_O_OTDC),
912 [BQ27742] = BQ27XXX_DATA(bq27742, 0 , BQ27XXX_O_OTDC),
913 [BQ27545] = BQ27XXX_DATA(bq27545, 0x04143672, BQ27XXX_O_OTDC),
914 [BQ27421] = BQ27XXX_DATA(bq27421, 0x80008000, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP | BQ27XXX_O_RAM),
915 [BQ27425] = BQ27XXX_DATA(bq27425, 0x04143672, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP),
916 [BQ27441] = BQ27XXX_DATA(bq27441, 0x80008000, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP | BQ27XXX_O_RAM),
917 [BQ27621] = BQ27XXX_DATA(bq27621, 0x80008000, BQ27XXX_O_UTOT | BQ27XXX_O_CFGUP | BQ27XXX_O_RAM),
920 static DEFINE_MUTEX(bq27xxx_list_lock);
921 static LIST_HEAD(bq27xxx_battery_devices);
923 #define BQ27XXX_MSLEEP(i) usleep_range((i)*1000, (i)*1000+500)
925 #define BQ27XXX_DM_SZ 32
928 * struct bq27xxx_dm_buf - chip data memory buffer
929 * @class: data memory subclass_id
930 * @block: data memory block number
931 * @data: data from/for the block
932 * @has_data: true if data has been filled by read
933 * @dirty: true if data has changed since last read/write
935 * Encapsulates info required to manage chip data memory blocks.
937 struct bq27xxx_dm_buf {
940 u8 data[BQ27XXX_DM_SZ];
941 bool has_data, dirty;
944 #define BQ27XXX_DM_BUF(di, i) { \
945 .class = (di)->dm_regs[i].subclass_id, \
946 .block = (di)->dm_regs[i].offset / BQ27XXX_DM_SZ, \
949 static inline u16 *bq27xxx_dm_reg_ptr(struct bq27xxx_dm_buf *buf,
950 struct bq27xxx_dm_reg *reg)
952 if (buf->class == reg->subclass_id &&
953 buf->block == reg->offset / BQ27XXX_DM_SZ)
954 return (u16 *) (buf->data + reg->offset % BQ27XXX_DM_SZ);
959 static const char * const bq27xxx_dm_reg_name[] = {
960 [BQ27XXX_DM_DESIGN_CAPACITY] = "design-capacity",
961 [BQ27XXX_DM_DESIGN_ENERGY] = "design-energy",
962 [BQ27XXX_DM_TERMINATE_VOLTAGE] = "terminate-voltage",
966 static bool bq27xxx_dt_to_nvm = true;
967 module_param_named(dt_monitored_battery_updates_nvm, bq27xxx_dt_to_nvm, bool, 0444);
968 MODULE_PARM_DESC(dt_monitored_battery_updates_nvm,
969 "Devicetree monitored-battery config updates data memory on NVM/flash chips.\n"
970 "Users must set this =0 when installing a different type of battery!\n"
972 #ifndef CONFIG_BATTERY_BQ27XXX_DT_UPDATES_NVM
973 "\nSetting this affects future kernel updates, not the current configuration."
977 static int poll_interval_param_set(const char *val, const struct kernel_param *kp)
979 struct bq27xxx_device_info *di;
980 unsigned int prev_val = *(unsigned int *) kp->arg;
983 ret = param_set_uint(val, kp);
984 if (ret < 0 || prev_val == *(unsigned int *) kp->arg)
987 mutex_lock(&bq27xxx_list_lock);
988 list_for_each_entry(di, &bq27xxx_battery_devices, list) {
989 cancel_delayed_work_sync(&di->work);
990 schedule_delayed_work(&di->work, 0);
992 mutex_unlock(&bq27xxx_list_lock);
997 static const struct kernel_param_ops param_ops_poll_interval = {
998 .get = param_get_uint,
999 .set = poll_interval_param_set,
1002 static unsigned int poll_interval = 360;
1003 module_param_cb(poll_interval, ¶m_ops_poll_interval, &poll_interval, 0644);
1004 MODULE_PARM_DESC(poll_interval,
1005 "battery poll interval in seconds - 0 disables polling");
1008 * Common code for BQ27xxx devices
1011 static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index,
1016 if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
1019 ret = di->bus.read(di, di->regs[reg_index], single);
1021 dev_dbg(di->dev, "failed to read register 0x%02x (index %d)\n",
1022 di->regs[reg_index], reg_index);
1027 static inline int bq27xxx_write(struct bq27xxx_device_info *di, int reg_index,
1028 u16 value, bool single)
1032 if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
1038 ret = di->bus.write(di, di->regs[reg_index], value, single);
1040 dev_dbg(di->dev, "failed to write register 0x%02x (index %d)\n",
1041 di->regs[reg_index], reg_index);
1046 static inline int bq27xxx_read_block(struct bq27xxx_device_info *di, int reg_index,
1051 if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
1054 if (!di->bus.read_bulk)
1057 ret = di->bus.read_bulk(di, di->regs[reg_index], data, len);
1059 dev_dbg(di->dev, "failed to read_bulk register 0x%02x (index %d)\n",
1060 di->regs[reg_index], reg_index);
1065 static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_index,
1070 if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
1073 if (!di->bus.write_bulk)
1076 ret = di->bus.write_bulk(di, di->regs[reg_index], data, len);
1078 dev_dbg(di->dev, "failed to write_bulk register 0x%02x (index %d)\n",
1079 di->regs[reg_index], reg_index);
1084 static int bq27xxx_battery_seal(struct bq27xxx_device_info *di)
1088 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_SEALED, false);
1090 dev_err(di->dev, "bus error on seal: %d\n", ret);
1097 static int bq27xxx_battery_unseal(struct bq27xxx_device_info *di)
1101 if (di->unseal_key == 0) {
1102 dev_err(di->dev, "unseal failed due to missing key\n");
1106 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)(di->unseal_key >> 16), false);
1110 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)di->unseal_key, false);
1117 dev_err(di->dev, "bus error on unseal: %d\n", ret);
1121 static u8 bq27xxx_battery_checksum_dm_block(struct bq27xxx_dm_buf *buf)
1126 for (i = 0; i < BQ27XXX_DM_SZ; i++)
1127 sum += buf->data[i];
1133 static int bq27xxx_battery_read_dm_block(struct bq27xxx_device_info *di,
1134 struct bq27xxx_dm_buf *buf)
1138 buf->has_data = false;
1140 ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
1144 ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
1150 ret = bq27xxx_read_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
1154 ret = bq27xxx_read(di, BQ27XXX_DM_CKSUM, true);
1158 if ((u8)ret != bq27xxx_battery_checksum_dm_block(buf)) {
1163 buf->has_data = true;
1169 dev_err(di->dev, "bus error reading chip memory: %d\n", ret);
1173 static void bq27xxx_battery_update_dm_block(struct bq27xxx_device_info *di,
1174 struct bq27xxx_dm_buf *buf,
1175 enum bq27xxx_dm_reg_id reg_id,
1178 struct bq27xxx_dm_reg *reg = &di->dm_regs[reg_id];
1179 const char *str = bq27xxx_dm_reg_name[reg_id];
1180 u16 *prev = bq27xxx_dm_reg_ptr(buf, reg);
1183 dev_warn(di->dev, "buffer does not match %s dm spec\n", str);
1187 if (reg->bytes != 2) {
1188 dev_warn(di->dev, "%s dm spec has unsupported byte size\n", str);
1195 if (be16_to_cpup(prev) == val) {
1196 dev_info(di->dev, "%s has %u\n", str, val);
1200 #ifdef CONFIG_BATTERY_BQ27XXX_DT_UPDATES_NVM
1201 if (!(di->opts & BQ27XXX_O_RAM) && !bq27xxx_dt_to_nvm) {
1203 if (!(di->opts & BQ27XXX_O_RAM)) {
1205 /* devicetree and NVM differ; defer to NVM */
1206 dev_warn(di->dev, "%s has %u; update to %u disallowed "
1207 #ifdef CONFIG_BATTERY_BQ27XXX_DT_UPDATES_NVM
1208 "by dt_monitored_battery_updates_nvm=0"
1210 "for flash/NVM data memory"
1212 "\n", str, be16_to_cpup(prev), val);
1216 dev_info(di->dev, "update %s to %u\n", str, val);
1218 *prev = cpu_to_be16(val);
1222 static int bq27xxx_battery_cfgupdate_priv(struct bq27xxx_device_info *di, bool active)
1224 const int limit = 100;
1225 u16 cmd = active ? BQ27XXX_SET_CFGUPDATE : BQ27XXX_SOFT_RESET;
1226 int ret, try = limit;
1228 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, cmd, false);
1234 ret = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
1237 } while (!!(ret & BQ27XXX_FLAG_CFGUP) != active && --try);
1239 if (!try && di->chip != BQ27425) { // 425 has a bug
1240 dev_err(di->dev, "timed out waiting for cfgupdate flag %d\n", active);
1244 if (limit - try > 3)
1245 dev_warn(di->dev, "cfgupdate %d, retries %d\n", active, limit - try);
1250 static inline int bq27xxx_battery_set_cfgupdate(struct bq27xxx_device_info *di)
1252 int ret = bq27xxx_battery_cfgupdate_priv(di, true);
1253 if (ret < 0 && ret != -EINVAL)
1254 dev_err(di->dev, "bus error on set_cfgupdate: %d\n", ret);
1259 static inline int bq27xxx_battery_soft_reset(struct bq27xxx_device_info *di)
1261 int ret = bq27xxx_battery_cfgupdate_priv(di, false);
1262 if (ret < 0 && ret != -EINVAL)
1263 dev_err(di->dev, "bus error on soft_reset: %d\n", ret);
1268 static int bq27xxx_battery_write_dm_block(struct bq27xxx_device_info *di,
1269 struct bq27xxx_dm_buf *buf)
1271 bool cfgup = di->opts & BQ27XXX_O_CFGUP;
1278 ret = bq27xxx_battery_set_cfgupdate(di);
1283 ret = bq27xxx_write(di, BQ27XXX_DM_CTRL, 0, true);
1287 ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
1291 ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
1297 ret = bq27xxx_write_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
1301 ret = bq27xxx_write(di, BQ27XXX_DM_CKSUM,
1302 bq27xxx_battery_checksum_dm_block(buf), true);
1306 /* DO NOT read BQ27XXX_DM_CKSUM here to verify it! That may cause NVM
1307 * corruption on the '425 chip (and perhaps others), which can damage
1313 ret = bq27xxx_battery_soft_reset(di);
1317 BQ27XXX_MSLEEP(100); /* flash DM updates in <100ms */
1326 bq27xxx_battery_soft_reset(di);
1328 dev_err(di->dev, "bus error writing chip memory: %d\n", ret);
1332 static void bq27xxx_battery_set_config(struct bq27xxx_device_info *di,
1333 struct power_supply_battery_info *info)
1335 struct bq27xxx_dm_buf bd = BQ27XXX_DM_BUF(di, BQ27XXX_DM_DESIGN_CAPACITY);
1336 struct bq27xxx_dm_buf bt = BQ27XXX_DM_BUF(di, BQ27XXX_DM_TERMINATE_VOLTAGE);
1339 if (bq27xxx_battery_unseal(di) < 0)
1342 if (info->charge_full_design_uah != -EINVAL &&
1343 info->energy_full_design_uwh != -EINVAL) {
1344 bq27xxx_battery_read_dm_block(di, &bd);
1345 /* assume design energy & capacity are in same block */
1346 bq27xxx_battery_update_dm_block(di, &bd,
1347 BQ27XXX_DM_DESIGN_CAPACITY,
1348 info->charge_full_design_uah / 1000);
1349 bq27xxx_battery_update_dm_block(di, &bd,
1350 BQ27XXX_DM_DESIGN_ENERGY,
1351 info->energy_full_design_uwh / 1000);
1354 if (info->voltage_min_design_uv != -EINVAL) {
1355 bool same = bd.class == bt.class && bd.block == bt.block;
1357 bq27xxx_battery_read_dm_block(di, &bt);
1358 bq27xxx_battery_update_dm_block(di, same ? &bd : &bt,
1359 BQ27XXX_DM_TERMINATE_VOLTAGE,
1360 info->voltage_min_design_uv / 1000);
1363 updated = bd.dirty || bt.dirty;
1365 bq27xxx_battery_write_dm_block(di, &bd);
1366 bq27xxx_battery_write_dm_block(di, &bt);
1368 bq27xxx_battery_seal(di);
1370 if (updated && !(di->opts & BQ27XXX_O_CFGUP)) {
1371 bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_RESET, false);
1372 BQ27XXX_MSLEEP(300); /* reset time is not documented */
1374 /* assume bq27xxx_battery_update() is called hereafter */
1377 static void bq27xxx_battery_settings(struct bq27xxx_device_info *di)
1379 struct power_supply_battery_info info = {};
1380 unsigned int min, max;
1382 if (power_supply_get_battery_info(di->bat, &info) < 0)
1386 dev_warn(di->dev, "data memory update not supported for chip\n");
1390 if (info.energy_full_design_uwh != info.charge_full_design_uah) {
1391 if (info.energy_full_design_uwh == -EINVAL)
1392 dev_warn(di->dev, "missing battery:energy-full-design-microwatt-hours\n");
1393 else if (info.charge_full_design_uah == -EINVAL)
1394 dev_warn(di->dev, "missing battery:charge-full-design-microamp-hours\n");
1397 /* assume min == 0 */
1398 max = di->dm_regs[BQ27XXX_DM_DESIGN_ENERGY].max;
1399 if (info.energy_full_design_uwh > max * 1000) {
1400 dev_err(di->dev, "invalid battery:energy-full-design-microwatt-hours %d\n",
1401 info.energy_full_design_uwh);
1402 info.energy_full_design_uwh = -EINVAL;
1405 /* assume min == 0 */
1406 max = di->dm_regs[BQ27XXX_DM_DESIGN_CAPACITY].max;
1407 if (info.charge_full_design_uah > max * 1000) {
1408 dev_err(di->dev, "invalid battery:charge-full-design-microamp-hours %d\n",
1409 info.charge_full_design_uah);
1410 info.charge_full_design_uah = -EINVAL;
1413 min = di->dm_regs[BQ27XXX_DM_TERMINATE_VOLTAGE].min;
1414 max = di->dm_regs[BQ27XXX_DM_TERMINATE_VOLTAGE].max;
1415 if ((info.voltage_min_design_uv < min * 1000 ||
1416 info.voltage_min_design_uv > max * 1000) &&
1417 info.voltage_min_design_uv != -EINVAL) {
1418 dev_err(di->dev, "invalid battery:voltage-min-design-microvolt %d\n",
1419 info.voltage_min_design_uv);
1420 info.voltage_min_design_uv = -EINVAL;
1423 if ((info.energy_full_design_uwh != -EINVAL &&
1424 info.charge_full_design_uah != -EINVAL) ||
1425 info.voltage_min_design_uv != -EINVAL)
1426 bq27xxx_battery_set_config(di, &info);
1430 * Return the battery State-of-Charge
1431 * Or < 0 if something fails.
1433 static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)
1437 if (di->opts & BQ27XXX_O_ZERO)
1438 soc = bq27xxx_read(di, BQ27XXX_REG_SOC, true);
1440 soc = bq27xxx_read(di, BQ27XXX_REG_SOC, false);
1443 dev_dbg(di->dev, "error reading State-of-Charge\n");
1449 * Return a battery charge value in µAh
1450 * Or < 0 if something fails.
1452 static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
1456 charge = bq27xxx_read(di, reg, false);
1458 dev_dbg(di->dev, "error reading charge register %02x: %d\n",
1463 if (di->opts & BQ27XXX_O_ZERO)
1464 charge *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
1472 * Return the battery Nominal available capacity in µAh
1473 * Or < 0 if something fails.
1475 static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
1479 if (di->opts & BQ27XXX_O_ZERO) {
1480 flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true);
1481 if (flags >= 0 && (flags & BQ27000_FLAG_CI))
1485 return bq27xxx_battery_read_charge(di, BQ27XXX_REG_NAC);
1489 * Return the battery Full Charge Capacity in µAh
1490 * Or < 0 if something fails.
1492 static inline int bq27xxx_battery_read_fcc(struct bq27xxx_device_info *di)
1494 return bq27xxx_battery_read_charge(di, BQ27XXX_REG_FCC);
1498 * Return the Design Capacity in µAh
1499 * Or < 0 if something fails.
1501 static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di)
1505 if (di->opts & BQ27XXX_O_ZERO)
1506 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, true);
1508 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false);
1511 dev_dbg(di->dev, "error reading initial last measured discharge\n");
1515 if (di->opts & BQ27XXX_O_ZERO)
1516 dcap = (dcap << 8) * BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
1524 * Return the battery Available energy in µWh
1525 * Or < 0 if something fails.
1527 static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di)
1531 ae = bq27xxx_read(di, BQ27XXX_REG_AE, false);
1533 dev_dbg(di->dev, "error reading available energy\n");
1537 if (di->opts & BQ27XXX_O_ZERO)
1538 ae *= BQ27XXX_POWER_CONSTANT / BQ27XXX_RS;
1546 * Return the battery temperature in tenths of degree Kelvin
1547 * Or < 0 if something fails.
1549 static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di)
1553 temp = bq27xxx_read(di, BQ27XXX_REG_TEMP, false);
1555 dev_err(di->dev, "error reading temperature\n");
1559 if (di->opts & BQ27XXX_O_ZERO)
1560 temp = 5 * temp / 2;
1566 * Return the battery Cycle count total
1567 * Or < 0 if something fails.
1569 static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di)
1573 cyct = bq27xxx_read(di, BQ27XXX_REG_CYCT, false);
1575 dev_err(di->dev, "error reading cycle count total\n");
1581 * Read a time register.
1582 * Return < 0 if something fails.
1584 static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
1588 tval = bq27xxx_read(di, reg, false);
1590 dev_dbg(di->dev, "error reading time register %02x: %d\n",
1602 * Read an average power register.
1603 * Return < 0 if something fails.
1605 static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di)
1609 tval = bq27xxx_read(di, BQ27XXX_REG_AP, false);
1611 dev_err(di->dev, "error reading average power register %02x: %d\n",
1612 BQ27XXX_REG_AP, tval);
1616 if (di->opts & BQ27XXX_O_ZERO)
1617 return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
1623 * Returns true if a battery over temperature condition is detected
1625 static bool bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
1627 if (di->opts & BQ27XXX_O_OTDC)
1628 return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD);
1629 if (di->opts & BQ27XXX_O_UTOT)
1630 return flags & BQ27XXX_FLAG_OT;
1636 * Returns true if a battery under temperature condition is detected
1638 static bool bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags)
1640 if (di->opts & BQ27XXX_O_UTOT)
1641 return flags & BQ27XXX_FLAG_UT;
1647 * Returns true if a low state of charge condition is detected
1649 static bool bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags)
1651 if (di->opts & BQ27XXX_O_ZERO)
1652 return flags & (BQ27000_FLAG_EDV1 | BQ27000_FLAG_EDVF);
1654 return flags & (BQ27XXX_FLAG_SOC1 | BQ27XXX_FLAG_SOCF);
1658 * Read flag register.
1659 * Return < 0 if something fails.
1661 static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
1664 bool has_singe_flag = di->opts & BQ27XXX_O_ZERO;
1666 flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag);
1668 dev_err(di->dev, "error reading flag register:%d\n", flags);
1672 /* Unlikely but important to return first */
1673 if (unlikely(bq27xxx_battery_overtemp(di, flags)))
1674 return POWER_SUPPLY_HEALTH_OVERHEAT;
1675 if (unlikely(bq27xxx_battery_undertemp(di, flags)))
1676 return POWER_SUPPLY_HEALTH_COLD;
1677 if (unlikely(bq27xxx_battery_dead(di, flags)))
1678 return POWER_SUPPLY_HEALTH_DEAD;
1680 return POWER_SUPPLY_HEALTH_GOOD;
1683 void bq27xxx_battery_update(struct bq27xxx_device_info *di)
1685 struct bq27xxx_reg_cache cache = {0, };
1686 bool has_ci_flag = di->opts & BQ27XXX_O_ZERO;
1687 bool has_singe_flag = di->opts & BQ27XXX_O_ZERO;
1689 cache.flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag);
1690 if ((cache.flags & 0xff) == 0xff)
1691 cache.flags = -1; /* read error */
1692 if (cache.flags >= 0) {
1693 cache.temperature = bq27xxx_battery_read_temperature(di);
1694 if (has_ci_flag && (cache.flags & BQ27000_FLAG_CI)) {
1695 dev_info_once(di->dev, "battery is not calibrated! ignoring capacity values\n");
1696 cache.capacity = -ENODATA;
1697 cache.energy = -ENODATA;
1698 cache.time_to_empty = -ENODATA;
1699 cache.time_to_empty_avg = -ENODATA;
1700 cache.time_to_full = -ENODATA;
1701 cache.charge_full = -ENODATA;
1702 cache.health = -ENODATA;
1704 if (di->regs[BQ27XXX_REG_TTE] != INVALID_REG_ADDR)
1705 cache.time_to_empty = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTE);
1706 if (di->regs[BQ27XXX_REG_TTECP] != INVALID_REG_ADDR)
1707 cache.time_to_empty_avg = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTECP);
1708 if (di->regs[BQ27XXX_REG_TTF] != INVALID_REG_ADDR)
1709 cache.time_to_full = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTF);
1710 cache.charge_full = bq27xxx_battery_read_fcc(di);
1711 cache.capacity = bq27xxx_battery_read_soc(di);
1712 if (di->regs[BQ27XXX_REG_AE] != INVALID_REG_ADDR)
1713 cache.energy = bq27xxx_battery_read_energy(di);
1714 cache.health = bq27xxx_battery_read_health(di);
1716 if (di->regs[BQ27XXX_REG_CYCT] != INVALID_REG_ADDR)
1717 cache.cycle_count = bq27xxx_battery_read_cyct(di);
1718 if (di->regs[BQ27XXX_REG_AP] != INVALID_REG_ADDR)
1719 cache.power_avg = bq27xxx_battery_read_pwr_avg(di);
1721 /* We only have to read charge design full once */
1722 if (di->charge_design_full <= 0)
1723 di->charge_design_full = bq27xxx_battery_read_dcap(di);
1726 if (di->cache.capacity != cache.capacity)
1727 power_supply_changed(di->bat);
1729 if (memcmp(&di->cache, &cache, sizeof(cache)) != 0)
1732 di->last_update = jiffies;
1734 EXPORT_SYMBOL_GPL(bq27xxx_battery_update);
1736 static void bq27xxx_battery_poll(struct work_struct *work)
1738 struct bq27xxx_device_info *di =
1739 container_of(work, struct bq27xxx_device_info,
1742 bq27xxx_battery_update(di);
1744 if (poll_interval > 0)
1745 schedule_delayed_work(&di->work, poll_interval * HZ);
1749 * Return the battery average current in µA
1750 * Note that current can be negative signed as well
1751 * Or 0 if something fails.
1753 static int bq27xxx_battery_current(struct bq27xxx_device_info *di,
1754 union power_supply_propval *val)
1759 curr = bq27xxx_read(di, BQ27XXX_REG_AI, false);
1761 dev_err(di->dev, "error reading current\n");
1765 if (di->opts & BQ27XXX_O_ZERO) {
1766 flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true);
1767 if (flags & BQ27000_FLAG_CHGS) {
1768 dev_dbg(di->dev, "negative current!\n");
1772 val->intval = curr * BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
1774 /* Other gauges return signed value */
1775 val->intval = (int)((s16)curr) * 1000;
1781 static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
1782 union power_supply_propval *val)
1786 if (di->opts & BQ27XXX_O_ZERO) {
1787 if (di->cache.flags & BQ27000_FLAG_FC)
1788 status = POWER_SUPPLY_STATUS_FULL;
1789 else if (di->cache.flags & BQ27000_FLAG_CHGS)
1790 status = POWER_SUPPLY_STATUS_CHARGING;
1791 else if (power_supply_am_i_supplied(di->bat))
1792 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1794 status = POWER_SUPPLY_STATUS_DISCHARGING;
1796 if (di->cache.flags & BQ27XXX_FLAG_FC)
1797 status = POWER_SUPPLY_STATUS_FULL;
1798 else if (di->cache.flags & BQ27XXX_FLAG_DSC)
1799 status = POWER_SUPPLY_STATUS_DISCHARGING;
1801 status = POWER_SUPPLY_STATUS_CHARGING;
1804 val->intval = status;
1809 static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di,
1810 union power_supply_propval *val)
1814 if (di->opts & BQ27XXX_O_ZERO) {
1815 if (di->cache.flags & BQ27000_FLAG_FC)
1816 level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1817 else if (di->cache.flags & BQ27000_FLAG_EDV1)
1818 level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1819 else if (di->cache.flags & BQ27000_FLAG_EDVF)
1820 level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1822 level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1824 if (di->cache.flags & BQ27XXX_FLAG_FC)
1825 level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1826 else if (di->cache.flags & BQ27XXX_FLAG_SOC1)
1827 level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1828 else if (di->cache.flags & BQ27XXX_FLAG_SOCF)
1829 level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1831 level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1834 val->intval = level;
1840 * Return the battery Voltage in millivolts
1841 * Or < 0 if something fails.
1843 static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di,
1844 union power_supply_propval *val)
1848 volt = bq27xxx_read(di, BQ27XXX_REG_VOLT, false);
1850 dev_err(di->dev, "error reading voltage\n");
1854 val->intval = volt * 1000;
1859 static int bq27xxx_simple_value(int value,
1860 union power_supply_propval *val)
1865 val->intval = value;
1870 static int bq27xxx_battery_get_property(struct power_supply *psy,
1871 enum power_supply_property psp,
1872 union power_supply_propval *val)
1875 struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);
1877 mutex_lock(&di->lock);
1878 if (time_is_before_jiffies(di->last_update + 5 * HZ)) {
1879 cancel_delayed_work_sync(&di->work);
1880 bq27xxx_battery_poll(&di->work.work);
1882 mutex_unlock(&di->lock);
1884 if (psp != POWER_SUPPLY_PROP_PRESENT && di->cache.flags < 0)
1888 case POWER_SUPPLY_PROP_STATUS:
1889 ret = bq27xxx_battery_status(di, val);
1891 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1892 ret = bq27xxx_battery_voltage(di, val);
1894 case POWER_SUPPLY_PROP_PRESENT:
1895 val->intval = di->cache.flags < 0 ? 0 : 1;
1897 case POWER_SUPPLY_PROP_CURRENT_NOW:
1898 ret = bq27xxx_battery_current(di, val);
1900 case POWER_SUPPLY_PROP_CAPACITY:
1901 ret = bq27xxx_simple_value(di->cache.capacity, val);
1903 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
1904 ret = bq27xxx_battery_capacity_level(di, val);
1906 case POWER_SUPPLY_PROP_TEMP:
1907 ret = bq27xxx_simple_value(di->cache.temperature, val);
1909 val->intval -= 2731; /* convert decidegree k to c */
1911 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
1912 ret = bq27xxx_simple_value(di->cache.time_to_empty, val);
1914 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
1915 ret = bq27xxx_simple_value(di->cache.time_to_empty_avg, val);
1917 case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
1918 ret = bq27xxx_simple_value(di->cache.time_to_full, val);
1920 case POWER_SUPPLY_PROP_TECHNOLOGY:
1921 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
1923 case POWER_SUPPLY_PROP_CHARGE_NOW:
1924 ret = bq27xxx_simple_value(bq27xxx_battery_read_nac(di), val);
1926 case POWER_SUPPLY_PROP_CHARGE_FULL:
1927 ret = bq27xxx_simple_value(di->cache.charge_full, val);
1929 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
1930 ret = bq27xxx_simple_value(di->charge_design_full, val);
1933 * TODO: Implement these to make registers set from
1934 * power_supply_battery_info visible in sysfs.
1936 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
1937 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
1939 case POWER_SUPPLY_PROP_CYCLE_COUNT:
1940 ret = bq27xxx_simple_value(di->cache.cycle_count, val);
1942 case POWER_SUPPLY_PROP_ENERGY_NOW:
1943 ret = bq27xxx_simple_value(di->cache.energy, val);
1945 case POWER_SUPPLY_PROP_POWER_AVG:
1946 ret = bq27xxx_simple_value(di->cache.power_avg, val);
1948 case POWER_SUPPLY_PROP_HEALTH:
1949 ret = bq27xxx_simple_value(di->cache.health, val);
1951 case POWER_SUPPLY_PROP_MANUFACTURER:
1952 val->strval = BQ27XXX_MANUFACTURER;
1961 static void bq27xxx_external_power_changed(struct power_supply *psy)
1963 struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);
1965 cancel_delayed_work_sync(&di->work);
1966 schedule_delayed_work(&di->work, 0);
1969 int bq27xxx_battery_setup(struct bq27xxx_device_info *di)
1971 struct power_supply_desc *psy_desc;
1972 struct power_supply_config psy_cfg = {
1973 .of_node = di->dev->of_node,
1977 INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
1978 mutex_init(&di->lock);
1980 di->regs = bq27xxx_chip_data[di->chip].regs;
1981 di->unseal_key = bq27xxx_chip_data[di->chip].unseal_key;
1982 di->dm_regs = bq27xxx_chip_data[di->chip].dm_regs;
1983 di->opts = bq27xxx_chip_data[di->chip].opts;
1985 psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL);
1989 psy_desc->name = di->name;
1990 psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
1991 psy_desc->properties = bq27xxx_chip_data[di->chip].props;
1992 psy_desc->num_properties = bq27xxx_chip_data[di->chip].props_size;
1993 psy_desc->get_property = bq27xxx_battery_get_property;
1994 psy_desc->external_power_changed = bq27xxx_external_power_changed;
1996 di->bat = power_supply_register_no_ws(di->dev, psy_desc, &psy_cfg);
1997 if (IS_ERR(di->bat)) {
1998 dev_err(di->dev, "failed to register battery\n");
1999 return PTR_ERR(di->bat);
2002 bq27xxx_battery_settings(di);
2003 bq27xxx_battery_update(di);
2005 mutex_lock(&bq27xxx_list_lock);
2006 list_add(&di->list, &bq27xxx_battery_devices);
2007 mutex_unlock(&bq27xxx_list_lock);
2011 EXPORT_SYMBOL_GPL(bq27xxx_battery_setup);
2013 void bq27xxx_battery_teardown(struct bq27xxx_device_info *di)
2016 * power_supply_unregister call bq27xxx_battery_get_property which
2017 * call bq27xxx_battery_poll.
2018 * Make sure that bq27xxx_battery_poll will not call
2019 * schedule_delayed_work again after unregister (which cause OOPS).
2023 cancel_delayed_work_sync(&di->work);
2025 power_supply_unregister(di->bat);
2027 mutex_lock(&bq27xxx_list_lock);
2028 list_del(&di->list);
2029 mutex_unlock(&bq27xxx_list_lock);
2031 mutex_destroy(&di->lock);
2033 EXPORT_SYMBOL_GPL(bq27xxx_battery_teardown);
2035 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
2036 MODULE_DESCRIPTION("BQ27xxx battery monitor driver");
2037 MODULE_LICENSE("GPL");