1 /*
2 * rk817 battery driver
3 *
4 * Copyright (C) 2018 Rockchip Corporation
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 */
17
18 #define pr_fmt(fmt) "rk817-bat: " fmt
19
20 #include <linux/delay.h>
21 #include <linux/extcon.h>
22 #include <linux/fb.h>
23 #include <linux/gpio.h>
24 #include <linux/iio/consumer.h>
25 #include <linux/iio/iio.h>
26 #include <linux/irq.h>
27 #include <linux/jiffies.h>
28 #include <linux/mfd/rk808.h>
29 #include <linux/module.h>
30 #include <linux/of_device.h>
31 #include <linux/of_gpio.h>
32 #include <linux/platform_device.h>
33 #include <linux/power_supply.h>
34 #include <linux/power/rk_usbbc.h>
35 #include <linux/regmap.h>
36 #include <linux/rk_keys.h>
37 #include <linux/rtc.h>
38 #include <linux/timer.h>
39 #include <linux/wakelock.h>
40 #include <linux/workqueue.h>
41
42 static int dbg_enable;
43
44 module_param_named(dbg_level, dbg_enable, int, 0644);
45
46 #define DBG(args...) \
47 do { \
48 if (dbg_enable) { \
49 pr_info(args); \
50 } \
51 } while (0)
52
53 #define BAT_INFO(fmt, args...) pr_info(fmt, ##args)
54
55 #define DRIVER_VERSION "1.00"
56 #define SFT_SET_KB 1
57
58 #define DIV(x) ((x) ? (x) : 1)
59 #define ENABLE 0x01
60 #define DISABLE 0x00
61 #define MAX_INTERPOLATE 1000
62 #define MAX_PERCENTAGE 100
63 #define MAX_INT 0x7FFF
64
65 /* RK818_GGCON */
66 #define OCV_SAMP_MIN_MSK 0x0c
67 #define OCV_SAMP_8MIN (0x00 << 2)
68
69 #define ADC_CAL_8MIN 0x00
70 #define RELAX_VOL12_UPD_MSK (RELAX_VOL1_UPD | RELAX_VOL2_UPD)
71 #define MINUTE(x) \
72 ((x) * 60)
73
74 #define ADC_TO_CURRENT(adc_value, samp_res) \
75 (adc_value * 172 / 1000 / samp_res)
76 #define CURRENT_TO_ADC(current, samp_res) \
77 (current * 1000 * samp_res / 172)
78
79 #define ADC_TO_CAPACITY(adc_value, samp_res) \
80 (adc_value / 1000 * 172 / 3600 / samp_res)
81 #define CAPACITY_TO_ADC(capacity, samp_res) \
82 (capacity * samp_res * 3600 / 172 * 1000)
83
84 #define ADC_TO_CAPACITY_UAH(adc_value, samp_res) \
85 (adc_value / 3600 * 172 / samp_res)
86 #define ADC_TO_CAPACITY_MAH(adc_value, samp_res) \
87 (adc_value / 1000 * 172 / 3600 / samp_res)
88
89 /* THREAML_REG */
90 #define TEMP_85C (0x00 << 2)
91 #define TEMP_95C (0x01 << 2)
92 #define TEMP_105C (0x02 << 2)
93 #define TEMP_115C (0x03 << 2)
94
95 #define ZERO_LOAD_LVL1 1400
96 #define ZERO_LOAD_LVL2 600
97
98 /* zero algorithm */
99 #define PWROFF_THRESD 3400
100 #define MIN_ZERO_DSOC_ACCURACY 10 /*0.01%*/
101 #define MIN_ZERO_OVERCNT 100
102 #define MIN_ACCURACY 1
103 #define DEF_PWRPATH_RES 50
104 #define WAIT_DSOC_DROP_SEC 15
105 #define WAIT_SHTD_DROP_SEC 30
106 #define MIN_ZERO_GAP_XSOC1 10
107 #define MIN_ZERO_GAP_XSOC2 5
108 #define MIN_ZERO_GAP_XSOC3 3
109 #define MIN_ZERO_GAP_CALIB 5
110
111 #define ADC_CALIB_THRESHOLD 4
112 #define ADC_CALIB_LMT_MIN 3
113 #define ADC_CALIB_CNT 5
114
115 /* default param */
116 #define DEFAULT_BAT_RES 135
117 #define DEFAULT_SLP_ENTER_CUR 300
118 #define DEFAULT_SLP_EXIT_CUR 300
119 #define DEFAULT_SLP_FILTER_CUR 100
120 #define DEFAULT_PWROFF_VOL_THRESD 3400
121 #define DEFAULT_MONITOR_SEC 5
122 #define DEFAULT_ALGR_VOL_THRESD1 3850
123 #define DEFAULT_ALGR_VOL_THRESD2 3950
124 #define DEFAULT_CHRG_VOL_SEL CHRG_VOL4200MV
125 #define DEFAULT_CHRG_CUR_SEL CHRG_CUR1400MA
126 #define DEFAULT_CHRG_CUR_INPUT INPUT_CUR2000MA
127 #define DEFAULT_POFFSET 42
128 #define DEFAULT_MAX_SOC_OFFSET 60
129 #define DEFAULT_FB_TEMP TEMP_115C
130 #define DEFAULT_ENERGY_MODE 0
131 #define DEFAULT_ZERO_RESERVE_DSOC 10
132 #define DEFAULT_SAMPLE_RES 20
133
134 /* sample resistor and division */
135 #define SAMPLE_RES_10MR 10
136 #define SAMPLE_RES_20MR 20
137 #define SAMPLE_RES_DIV1 1
138 #define SAMPLE_RES_DIV2 2
139
140 /* sleep */
141 #define SLP_CURR_MAX 40
142 #define SLP_CURR_MIN 6
143 #define LOW_PWR_SLP_CURR_MAX 20
144 #define LOW_PWR_SLP_CURR_MIN 1
145 #define DISCHRG_TIME_STEP1 MINUTE(10)
146 #define DISCHRG_TIME_STEP2 MINUTE(60)
147 #define SLP_DSOC_VOL_THRESD 3600
148 #define REBOOT_PERIOD_SEC 180
149 #define REBOOT_MAX_CNT 80
150
151 #define TIMER_MS_COUNTS 1000
152 /* fcc */
153 #define MIN_FCC 500
154 #define CAP_INVALID 0x80
155
156 /* virtual params */
157 #define VIRTUAL_CURRENT 1000
158 #define VIRTUAL_VOLTAGE 3888
159 #define VIRTUAL_SOC 66
160 #define VIRTUAL_PRESET 1
161 #define VIRTUAL_TEMPERATURE 188
162 #define VIRTUAL_STATUS POWER_SUPPLY_STATUS_CHARGING
163
164 #define FINISH_CHRG_CUR1 1000
165 #define FINISH_CHRG_CUR2 1500
166 #define FINISH_MAX_SOC_DELAY 20
167 #define TERM_CHRG_DSOC 88
168 #define TERM_CHRG_CURR 600
169 #define TERM_CHRG_K 650
170 #define SIMULATE_CHRG_INTV 8
171 #define SIMULATE_CHRG_CURR 400
172 #define SIMULATE_CHRG_K 1500
173 #define FULL_CHRG_K 400
174
175 enum work_mode {
176 MODE_ZERO = 0,
177 MODE_FINISH,
178 MODE_SMOOTH_CHRG,
179 MODE_SMOOTH_DISCHRG,
180 MODE_SMOOTH,
181 };
182
183 enum charge_status {
184 CHRG_OFF,
185 DEAD_CHRG,
186 TRICKLE_CHRG,
187 CC_OR_CV_CHRG,
188 CHARGE_FINISH,
189 USB_OVER_VOL,
190 BAT_TMP_ERR,
191 BAT_TIM_ERR,
192 };
193
194 enum bat_mode {
195 MODE_BATTARY = 0,
196 MODE_VIRTUAL,
197 };
198
199 enum rk817_sample_time {
200 S_8_MIN,
201 S_16_MIN,
202 S_32_MIN,
203 S_48_MIN,
204 };
205
206 enum rk817_output_mode {
207 AVERAGE_MODE,
208 INSTANT_MODE,
209 };
210
211 enum rk817_battery_fields {
212 ADC_SLP_RATE, BAT_CUR_ADC_EN, BAT_VOL_ADC_EN,
213 USB_VOL_ADC_EN, TS_ADC_EN, SYS_VOL_ADC_EN, GG_EN, /*ADC_CONFIG0*/
214 CUR_ADC_DITH_SEL, CUR_ADC_DIH_EN, CUR_ADC_CHOP_EN,
215 CUR_ADC_CHOP_SEL, CUR_ADC_CHOP_VREF_EN, /*CUR_ADC_CFG0*/
216 CUR_ADC_VCOM_SEL, CUR_ADC_VCOM_BUF_INC, CUR_ADC_VREF_BUF_INC,
217 CUR_ADC_BIAS_DEC, CUR_ADC_IBIAS_SEL,/*CUR_ADC_CFG1*/
218 VOL_ADC_EXT_VREF_EN, VOL_ADC_DITH_SEL, VOL_ADC_DITH_EN,
219 VOL_ADC_CHOP_EN, VOL_ADC_CHOP_SEL, VOL_ADC_CHOP_VREF_EN,
220 VOL_ADC_VCOM_SEL, VOL_ADC_VCOM_BUF_INC, VOL_ADC_VREF_BUF_INC,
221 VOL_ADC_IBIAS_SEL, /*VOL_ADC_CFG1*/
222 RLX_CUR_FILTER, TS_FUN, VOL_ADC_TSCUR_SEL,
223 VOL_CALIB_UPD, CUR_CALIB_UPD, /*ADC_CONFIG1*/
224 CUR_OUT_MOD, VOL_OUT_MOD, FRAME_SMP_INTERV,
225 ADC_OFF_CAL_INTERV, RLX_SPT, /*GG_CON*/
226 OCV_UPD, RELAX_STS, RELAX_VOL2_UPD, RELAX_VOL1_UPD, BAT_CON,
227 QMAX_UPD_SOFT, TERM_UPD, OCV_STS, /*GG_STS*/
228 RELAX_THRE_H, RELAX_THRE_L, /*RELAX_THRE*/
229 RELAX_VOL1_H, RELAX_VOL1_L,
230 RELAX_VOL2_H, RELAX_VOL2_L,
231 RELAX_CUR1_H, RELAX_CUR1_L,
232 RELAX_CUR2_H, RELAX_CUR2_L,
233 OCV_THRE_VOL,
234 OCV_VOL_H, OCV_VOL_L,
235 OCV_VOL0_H, OCV_VOL0_L,
236 OCV_CUR_H, OCV_CUR_L,
237 OCV_CUR0_H, OCV_CUR0_L,
238 PWRON_VOL_H, PWRON_VOL_L,
239 PWRON_CUR_H, PWRON_CUR_L,
240 OFF_CNT,
241 Q_INIT_H3, Q_INIT_H2, Q_INIT_L1, Q_INIT_L0,
242 Q_PRESS_H3, Q_PRESS_H2, Q_PRESS_L1, Q_PRESS_L0,
243 BAT_VOL_H, BAT_VOL_L,
244 BAT_CUR_H, BAT_CUR_L,
245 BAT_TS_H, BAT_TS_L,
246 USB_VOL_H, USB_VOL_L,
247 SYS_VOL_H, SYS_VOL_L,
248 Q_MAX_H3, Q_MAX_H2, Q_MAX_L1, Q_MAX_L0,
249 Q_TERM_H3, Q_TERM_H2, Q_TERM_L1, Q_TERM_L0,
250 Q_OCV_H3, Q_OCV_H2, Q_OCV_L1, Q_OCV_L0,
251 OCV_CNT,
252 SLEEP_CON_SAMP_CUR_H, SLEEP_CON_SAMP_CUR_L,
253 CAL_OFFSET_H, CAL_OFFSET_L,
254 VCALIB0_H, VCALIB0_L,
255 VCALIB1_H, VCALIB1_L,
256 IOFFSET_H, IOFFSET_L,
257 BAT_R0, SOC_REG0, SOC_REG1, SOC_REG2,
258 REMAIN_CAP_REG2, REMAIN_CAP_REG1, REMAIN_CAP_REG0,
259 NEW_FCC_REG2, NEW_FCC_REG1, NEW_FCC_REG0,
260 RESET_MODE,
261 FG_INIT, HALT_CNT_REG, CALC_REST_REGL, CALC_REST_REGH,
262 VOL_ADC_B3, VOL_ADC_B2, VOL_ADC_B1, VOL_ADC_B0,
263 VOL_ADC_K3, VOL_ADC_K2, VOL_ADC_K1, VOL_ADC_K0,
264 BAT_EXS, CHG_STS, BAT_OVP_STS, CHRG_IN_CLAMP,
265 CHIP_NAME_H, CHIP_NAME_L,
266 PLUG_IN_STS,
267 F_MAX_FIELDS
268 };
269
270 static const struct reg_field rk817_battery_reg_fields[] = {
271 [ADC_SLP_RATE] = REG_FIELD(0x50, 0, 0),
272 [BAT_CUR_ADC_EN] = REG_FIELD(0x50, 2, 2),
273 [BAT_VOL_ADC_EN] = REG_FIELD(0x50, 3, 3),
274 [USB_VOL_ADC_EN] = REG_FIELD(0x50, 4, 4),
275 [TS_ADC_EN] = REG_FIELD(0x50, 5, 5),
276 [SYS_VOL_ADC_EN] = REG_FIELD(0x50, 6, 6),
277 [GG_EN] = REG_FIELD(0x50, 7, 7),/*ADC_CONFIG0*/
278
279 [CUR_ADC_DITH_SEL] = REG_FIELD(0x51, 1, 3),
280 [CUR_ADC_DIH_EN] = REG_FIELD(0x51, 4, 4),
281 [CUR_ADC_CHOP_EN] = REG_FIELD(0x51, 5, 5),
282 [CUR_ADC_CHOP_SEL] = REG_FIELD(0x51, 6, 6),
283 [CUR_ADC_CHOP_VREF_EN] = REG_FIELD(0x51, 7, 7), /*CUR_ADC_COFG0*/
284
285 [CUR_ADC_VCOM_SEL] = REG_FIELD(0x52, 0, 1),
286 [CUR_ADC_VCOM_BUF_INC] = REG_FIELD(0x52, 2, 2),
287 [CUR_ADC_VREF_BUF_INC] = REG_FIELD(0x52, 3, 3),
288 [CUR_ADC_BIAS_DEC] = REG_FIELD(0x52, 4, 4),
289 [CUR_ADC_IBIAS_SEL] = REG_FIELD(0x52, 5, 6), /*CUR_ADC_COFG1*/
290
291 [VOL_ADC_EXT_VREF_EN] = REG_FIELD(0x53, 0, 0),
292 [VOL_ADC_DITH_SEL] = REG_FIELD(0x53, 1, 3),
293 [VOL_ADC_DITH_EN] = REG_FIELD(0x53, 4, 4),
294 [VOL_ADC_CHOP_EN] = REG_FIELD(0x53, 5, 5),
295 [VOL_ADC_CHOP_SEL] = REG_FIELD(0x53, 6, 6),
296 [VOL_ADC_CHOP_VREF_EN] = REG_FIELD(0x53, 7, 7),/*VOL_ADC_COFG0*/
297
298 [VOL_ADC_VCOM_SEL] = REG_FIELD(0x54, 0, 1),
299 [VOL_ADC_VCOM_BUF_INC] = REG_FIELD(0x54, 2, 2),
300 [VOL_ADC_VREF_BUF_INC] = REG_FIELD(0x54, 3, 3),
301 [VOL_ADC_IBIAS_SEL] = REG_FIELD(0x54, 5, 6), /*VOL_ADC_COFG1*/
302
303 [RLX_CUR_FILTER] = REG_FIELD(0x55, 0, 1),
304 [TS_FUN] = REG_FIELD(0x55, 3, 3),
305 [VOL_ADC_TSCUR_SEL] = REG_FIELD(0x55, 4, 5),
306 [VOL_CALIB_UPD] = REG_FIELD(0x55, 6, 6),
307 [CUR_CALIB_UPD] = REG_FIELD(0x55, 7, 7), /*ADC_CONFIG1*/
308
309 [CUR_OUT_MOD] = REG_FIELD(0x56, 0, 0),
310 [VOL_OUT_MOD] = REG_FIELD(0x56, 1, 1),
311 [FRAME_SMP_INTERV] = REG_FIELD(0x56, 2, 3),
312 [ADC_OFF_CAL_INTERV] = REG_FIELD(0x56, 4, 5),
313 [RLX_SPT] = REG_FIELD(0x56, 6, 7), /*GG_CON*/
314
315 [OCV_UPD] = REG_FIELD(0x57, 0, 0),
316 [RELAX_STS] = REG_FIELD(0x57, 1, 1),
317 [RELAX_VOL2_UPD] = REG_FIELD(0x57, 2, 2),
318 [RELAX_VOL1_UPD] = REG_FIELD(0x57, 3, 3),
319 [BAT_CON] = REG_FIELD(0x57, 4, 4),
320 [QMAX_UPD_SOFT] = REG_FIELD(0x57, 5, 5),
321 [TERM_UPD] = REG_FIELD(0x57, 6, 6),
322 [OCV_STS] = REG_FIELD(0x57, 7, 7), /*GG_STS*/
323
324 [RELAX_THRE_H] = REG_FIELD(0x58, 0, 7),
325 [RELAX_THRE_L] = REG_FIELD(0x59, 0, 7),
326
327 [RELAX_VOL1_H] = REG_FIELD(0x5A, 0, 7),
328 [RELAX_VOL1_L] = REG_FIELD(0x5B, 0, 7),
329 [RELAX_VOL2_H] = REG_FIELD(0x5C, 0, 7),
330 [RELAX_VOL2_L] = REG_FIELD(0x5D, 0, 7),
331
332 [RELAX_CUR1_H] = REG_FIELD(0x5E, 0, 7),
333 [RELAX_CUR1_L] = REG_FIELD(0x5F, 0, 7),
334 [RELAX_CUR2_H] = REG_FIELD(0x60, 0, 7),
335 [RELAX_CUR2_L] = REG_FIELD(0x61, 0, 7),
336
337 [OCV_THRE_VOL] = REG_FIELD(0x62, 0, 7),
338
339 [OCV_VOL_H] = REG_FIELD(0x63, 0, 7),
340 [OCV_VOL_L] = REG_FIELD(0x64, 0, 7),
341 [OCV_VOL0_H] = REG_FIELD(0x65, 0, 7),
342 [OCV_VOL0_L] = REG_FIELD(0x66, 0, 7),
343 [OCV_CUR_H] = REG_FIELD(0x67, 0, 7),
344 [OCV_CUR_L] = REG_FIELD(0x68, 0, 7),
345 [OCV_CUR0_H] = REG_FIELD(0x69, 0, 7),
346 [OCV_CUR0_L] = REG_FIELD(0x6A, 0, 7),
347 [PWRON_VOL_H] = REG_FIELD(0x6B, 0, 7),
348 [PWRON_VOL_L] = REG_FIELD(0x6C, 0, 7),
349 [PWRON_CUR_H] = REG_FIELD(0x6D, 0, 7),
350 [PWRON_CUR_L] = REG_FIELD(0x6E, 0, 7),
351 [OFF_CNT] = REG_FIELD(0x6F, 0, 7),
352 [Q_INIT_H3] = REG_FIELD(0x70, 0, 7),
353 [Q_INIT_H2] = REG_FIELD(0x71, 0, 7),
354 [Q_INIT_L1] = REG_FIELD(0x72, 0, 7),
355 [Q_INIT_L0] = REG_FIELD(0x73, 0, 7),
356
357 [Q_PRESS_H3] = REG_FIELD(0x74, 0, 7),
358 [Q_PRESS_H2] = REG_FIELD(0x75, 0, 7),
359 [Q_PRESS_L1] = REG_FIELD(0x76, 0, 7),
360 [Q_PRESS_L0] = REG_FIELD(0x77, 0, 7),
361
362 [BAT_VOL_H] = REG_FIELD(0x78, 0, 7),
363 [BAT_VOL_L] = REG_FIELD(0x79, 0, 7),
364
365 [BAT_CUR_H] = REG_FIELD(0x7A, 0, 7),
366 [BAT_CUR_L] = REG_FIELD(0x7B, 0, 7),
367
368 [BAT_TS_H] = REG_FIELD(0x7C, 0, 7),
369 [BAT_TS_L] = REG_FIELD(0x7D, 0, 7),
370 [USB_VOL_H] = REG_FIELD(0x7E, 0, 7),
371 [USB_VOL_L] = REG_FIELD(0x7F, 0, 7),
372
373 [SYS_VOL_H] = REG_FIELD(0x80, 0, 7),
374 [SYS_VOL_L] = REG_FIELD(0x81, 0, 7),
375 [Q_MAX_H3] = REG_FIELD(0x82, 0, 7),
376 [Q_MAX_H2] = REG_FIELD(0x83, 0, 7),
377 [Q_MAX_L1] = REG_FIELD(0x84, 0, 7),
378 [Q_MAX_L0] = REG_FIELD(0x85, 0, 7),
379
380 [Q_TERM_H3] = REG_FIELD(0x86, 0, 7),
381 [Q_TERM_H2] = REG_FIELD(0x87, 0, 7),
382 [Q_TERM_L1] = REG_FIELD(0x88, 0, 7),
383 [Q_TERM_L0] = REG_FIELD(0x89, 0, 7),
384 [Q_OCV_H3] = REG_FIELD(0x8A, 0, 7),
385 [Q_OCV_H2] = REG_FIELD(0x8B, 0, 7),
386
387 [Q_OCV_L1] = REG_FIELD(0x8C, 0, 7),
388 [Q_OCV_L0] = REG_FIELD(0x8D, 0, 7),
389 [OCV_CNT] = REG_FIELD(0x8E, 0, 7),
390 [SLEEP_CON_SAMP_CUR_H] = REG_FIELD(0x8F, 0, 7),
391 [SLEEP_CON_SAMP_CUR_L] = REG_FIELD(0x90, 0, 7),
392 [CAL_OFFSET_H] = REG_FIELD(0x91, 0, 7),
393 [CAL_OFFSET_L] = REG_FIELD(0x92, 0, 7),
394 [VCALIB0_H] = REG_FIELD(0x93, 0, 7),
395 [VCALIB0_L] = REG_FIELD(0x94, 0, 7),
396 [VCALIB1_H] = REG_FIELD(0x95, 0, 7),
397 [VCALIB1_L] = REG_FIELD(0x96, 0, 7),
398 [IOFFSET_H] = REG_FIELD(0x97, 0, 7),
399 [IOFFSET_L] = REG_FIELD(0x98, 0, 7),
400
401 [BAT_R0] = REG_FIELD(0x99, 0, 7),
402 [SOC_REG0] = REG_FIELD(0x9A, 0, 7),
403 [SOC_REG1] = REG_FIELD(0x9B, 0, 7),
404 [SOC_REG2] = REG_FIELD(0x9C, 0, 7),
405
406 [REMAIN_CAP_REG0] = REG_FIELD(0x9D, 0, 7),
407 [REMAIN_CAP_REG1] = REG_FIELD(0x9E, 0, 7),
408 [REMAIN_CAP_REG2] = REG_FIELD(0x9F, 0, 7),
409 [NEW_FCC_REG0] = REG_FIELD(0xA0, 0, 7),
410 [NEW_FCC_REG1] = REG_FIELD(0xA1, 0, 7),
411 [NEW_FCC_REG2] = REG_FIELD(0xA2, 0, 7),
412 [RESET_MODE] = REG_FIELD(0xA3, 0, 3),
413 [FG_INIT] = REG_FIELD(0xA5, 7, 7),
414
415 [HALT_CNT_REG] = REG_FIELD(0xA6, 0, 7),
416 [CALC_REST_REGL] = REG_FIELD(0xA7, 0, 7),
417 [CALC_REST_REGH] = REG_FIELD(0xA8, 0, 7),
418
419 [VOL_ADC_B3] = REG_FIELD(0xA9, 0, 7),
420 [VOL_ADC_B2] = REG_FIELD(0xAA, 0, 7),
421 [VOL_ADC_B1] = REG_FIELD(0xAB, 0, 7),
422 [VOL_ADC_B0] = REG_FIELD(0xAC, 0, 7),
423
424 [VOL_ADC_K3] = REG_FIELD(0xAD, 0, 7),
425 [VOL_ADC_K2] = REG_FIELD(0xAE, 0, 7),
426 [VOL_ADC_K1] = REG_FIELD(0xAF, 0, 7),
427 [VOL_ADC_K0] = REG_FIELD(0xB0, 0, 7),
428 [BAT_EXS] = REG_FIELD(0xEB, 7, 7),
429 [CHG_STS] = REG_FIELD(0xEB, 4, 6),
430 [BAT_OVP_STS] = REG_FIELD(0xEB, 3, 3),
431 [CHRG_IN_CLAMP] = REG_FIELD(0xEB, 2, 2),
432 [CHIP_NAME_H] = REG_FIELD(0xED, 0, 7),
433 [CHIP_NAME_L] = REG_FIELD(0xEE, 0, 7),
434 [PLUG_IN_STS] = REG_FIELD(0xF0, 6, 6),
435 };
436
437 struct battery_platform_data {
438 u32 *ocv_table;
439 u32 *zero_table;
440
441 u32 table_t[4][21];
442 int temp_t[4];
443 u32 temp_t_num;
444
445 u32 *ntc_table;
446 u32 ocv_size;
447 u32 ntc_size;
448 int ntc_degree_from;
449 u32 ntc_factor;
450 u32 max_input_current;
451 u32 max_chrg_current;
452 u32 max_chrg_voltage;
453 u32 lp_input_current;
454 u32 lp_soc_min;
455 u32 lp_soc_max;
456 u32 pwroff_vol;
457 u32 monitor_sec;
458 u32 zero_algorithm_vol;
459 u32 zero_reserve_dsoc;
460 u32 bat_res;
461 u32 design_capacity;
462 u32 design_qmax;
463 u32 sleep_enter_current;
464 u32 sleep_exit_current;
465 u32 sleep_filter_current;
466
467 u32 power_dc2otg;
468 u32 max_soc_offset;
469 u32 bat_mode;
470 u32 fb_temp;
471 u32 energy_mode;
472 u32 cccv_hour;
473 u32 dc_det_adc;
474 int dc_det_pin;
475 u8 dc_det_level;
476 u32 sample_res;
477 u32 bat_res_up;
478 u32 bat_res_down;
479 u32 design_max_voltage;
480 bool extcon;
481 u32 low_pwr_sleep;
482 };
483
484 struct rk817_battery_device {
485 struct platform_device *pdev;
486 struct device *dev;
487 struct i2c_client *client;
488 struct rk808 *rk817;
489 struct power_supply *bat;
490 struct power_supply *chg_psy;
491 struct power_supply *usb_psy;
492 struct power_supply *ac_psy;
493 struct regmap *regmap;
494 struct regmap_field *rmap_fields[F_MAX_FIELDS];
495 struct battery_platform_data *pdata;
496 struct workqueue_struct *bat_monitor_wq;
497 struct delayed_work bat_delay_work;
498 struct delayed_work calib_delay_work;
499 struct work_struct resume_work;
500 struct wake_lock wake_lock;
501 struct timer_list caltimer;
502
503 int res_div;
504 int bat_res;
505 bool is_first_power_on;
506 int chrg_status;
507 int res_fac;
508 int over_20mR;
509 bool is_initialized;
510 bool bat_first_power_on;
511 u8 ac_in;
512 u8 usb_in;
513 u8 otg_in;
514 u8 dc_in;
515 u8 prop_status;
516 int cvtlmt_irq;
517 int current_avg;
518 int current_relax;
519 int voltage_usb;
520 int voltage_sys;
521 int voltage_avg;
522 int voltage_ocv;
523 int voltage_relax;
524 int voltage_k;/* VCALIB0 VCALIB1 */
525 int voltage_b;
526 u32 remain_cap;
527 int design_cap;
528 int nac;
529 int fcc;
530 int lock_fcc;
531 int qmax;
532 int dsoc;
533 int rsoc;
534 int poffset;
535 int fake_offline;
536 int age_ocv_soc;
537 bool age_allow_update;
538 int age_level;
539 int age_ocv_cap;
540 int pwron_voltage;
541 int age_voltage;
542 int age_adjust_cap;
543 unsigned long age_keep_sec;
544 int zero_timeout_cnt;
545 int zero_remain_cap;
546 int zero_dsoc;
547 int zero_linek;
548 u64 zero_drop_sec;
549 u64 shtd_drop_sec;
550
551 int powerpatch_res;
552 int zero_voltage_avg;
553 int zero_current_avg;
554 int zero_vsys;
555 int zero_dead_voltage;
556 int zero_dead_soc;
557 int zero_dead_cap;
558 int zero_batvol_to_ocv;
559 int zero_batocv_to_soc;
560 int zero_batocv_to_cap;
561 int zero_xsoc;
562 unsigned long finish_base;
563 time64_t rtc_base;
564 int sm_remain_cap;
565 int sm_linek;
566 int sm_chrg_dsoc;
567 int sm_dischrg_dsoc;
568 int smooth_soc;
569 int algo_rest_val;
570 int algo_rest_mode;
571 int sleep_sum_cap;
572 int sleep_remain_cap;
573 unsigned long sleep_dischrg_sec;
574 unsigned long sleep_sum_sec;
575 bool sleep_chrg_online;
576 u8 sleep_chrg_status;
577 bool adc_allow_update;
578 int fb_blank;
579 bool s2r; /*suspend to resume*/
580 u32 work_mode;
581 int temperature;
582 int chrg_cur_lp_input;
583 int chrg_vol_sel;
584 int chrg_cur_input;
585 int chrg_cur_sel;
586 u32 monitor_ms;
587 u32 pwroff_min;
588 u32 adc_calib_cnt;
589 unsigned long chrg_finish_base;
590 unsigned long boot_base;
591 unsigned long flat_match_sec;
592 unsigned long plug_in_base;
593 unsigned long plug_out_base;
594 u8 halt_cnt;
595 bool is_halt;
596 bool is_max_soc_offset;
597 bool is_sw_reset;
598 bool is_ocv_calib;
599 bool is_first_on;
600 bool is_force_calib;
601 int last_dsoc;
602 u8 cvtlmt_int_event;
603 u8 slp_dcdc_en_reg;
604 int ocv_pre_dsoc;
605 int ocv_new_dsoc;
606 int max_pre_dsoc;
607 int max_new_dsoc;
608 int force_pre_dsoc;
609 int force_new_dsoc;
610
611 int dbg_cap_low0;
612 int dbg_pwr_dsoc;
613 int dbg_pwr_rsoc;
614 int dbg_pwr_vol;
615 int dbg_chrg_min[10];
616 int dbg_meet_soc;
617 int dbg_calc_dsoc;
618 int dbg_calc_rsoc;
619 int is_charging;
620 unsigned long charge_count;
621 u8 plugin_trigger;
622 u8 plugout_trigger;
623 int plugin_irq;
624 int plugout_irq;
625 int chip_id;
626 int is_register_chg_psy;
627 bool change; /* Battery status change, report information */
628 };
629
630 static void rk817_bat_resume_work(struct work_struct *work);
631
get_boot_sec(void)632 static u64 get_boot_sec(void)
633 {
634 struct timespec64 ts;
635
636 ktime_get_boottime_ts64(&ts);
637
638 return ts.tv_sec;
639 }
640
base2sec(unsigned long x)641 static unsigned long base2sec(unsigned long x)
642 {
643 if (x)
644 return (get_boot_sec() > x) ? (get_boot_sec() - x) : 0;
645 else
646 return 0;
647 }
648
interpolate(int value,u32 * table,int size)649 static u32 interpolate(int value, u32 *table, int size)
650 {
651 u8 i;
652 u16 d;
653
654 for (i = 0; i < size; i++) {
655 if (value < table[i])
656 break;
657 }
658
659 if ((i > 0) && (i < size)) {
660 d = (value - table[i - 1]) * (MAX_INTERPOLATE / (size - 1));
661 d /= table[i] - table[i - 1];
662 d = d + (i - 1) * (MAX_INTERPOLATE / (size - 1));
663 } else {
664 d = i * ((MAX_INTERPOLATE + size / 2) / size);
665 }
666
667 if (d > 1000)
668 d = 1000;
669
670 return d;
671 }
672
673 /* (a * b) / c */
ab_div_c(u32 a,u32 b,u32 c)674 static int32_t ab_div_c(u32 a, u32 b, u32 c)
675 {
676 bool sign;
677 u32 ans = MAX_INT;
678 int tmp;
679
680 sign = ((((a ^ b) ^ c) & 0x80000000) != 0);
681 if (c != 0) {
682 if (sign)
683 c = -c;
684 tmp = (a * b + (c >> 1)) / c;
685 if (tmp < MAX_INT)
686 ans = tmp;
687 }
688
689 if (sign)
690 ans = -ans;
691
692 return ans;
693 }
694
rk817_bat_field_read(struct rk817_battery_device * battery,enum rk817_battery_fields field_id)695 static int rk817_bat_field_read(struct rk817_battery_device *battery,
696 enum rk817_battery_fields field_id)
697 {
698 int val;
699 int ret;
700
701 ret = regmap_field_read(battery->rmap_fields[field_id], &val);
702 if (ret < 0)
703 return ret;
704
705 return val;
706 }
707
rk817_bat_field_write(struct rk817_battery_device * battery,enum rk817_battery_fields field_id,unsigned int val)708 static int rk817_bat_field_write(struct rk817_battery_device *battery,
709 enum rk817_battery_fields field_id,
710 unsigned int val)
711 {
712 return regmap_field_write(battery->rmap_fields[field_id], val);
713 }
714
715 /*cal_offset: current offset value*/
rk817_bat_get_coffset(struct rk817_battery_device * battery)716 static int rk817_bat_get_coffset(struct rk817_battery_device *battery)
717 {
718 int coffset_value = 0;
719
720 coffset_value |= rk817_bat_field_read(battery, CAL_OFFSET_H) << 8;
721 coffset_value |= rk817_bat_field_read(battery, CAL_OFFSET_L);
722
723 return coffset_value;
724 }
725
rk817_bat_set_coffset(struct rk817_battery_device * battery,int val)726 static void rk817_bat_set_coffset(struct rk817_battery_device *battery, int val)
727 {
728 u8 buf = 0;
729
730 buf = (val >> 8) & 0xff;
731 rk817_bat_field_write(battery, CAL_OFFSET_H, buf);
732 buf = (val >> 0) & 0xff;
733 rk817_bat_field_write(battery, CAL_OFFSET_L, buf);
734 }
735
736 /* current offset value calculated */
rk817_bat_get_ioffset(struct rk817_battery_device * battery)737 static int rk817_bat_get_ioffset(struct rk817_battery_device *battery)
738 {
739 int ioffset_value = 0;
740
741 ioffset_value |= rk817_bat_field_read(battery, IOFFSET_H) << 8;
742 ioffset_value |= rk817_bat_field_read(battery, IOFFSET_L);
743
744 return ioffset_value;
745 }
746
rk817_bat_current_calibration(struct rk817_battery_device * battery)747 static void rk817_bat_current_calibration(struct rk817_battery_device *battery)
748 {
749 int pwron_value, ioffset, cal_offset;
750
751 pwron_value = rk817_bat_field_read(battery, PWRON_CUR_H) << 8;
752 pwron_value |= rk817_bat_field_read(battery, PWRON_CUR_L);
753
754 ioffset = rk817_bat_get_ioffset(battery);
755
756 DBG("Caloffset: 0x%x\n", rk817_bat_get_coffset(battery));
757 DBG("IOFFSET: 0x%x\n", ioffset);
758 if (0)
759 cal_offset = pwron_value + ioffset;
760 else
761 cal_offset = ioffset;
762
763 rk817_bat_set_coffset(battery, cal_offset);
764 DBG("Caloffset: 0x%x\n", rk817_bat_get_coffset(battery));
765
766 }
767
rk817_bat_get_vaclib0(struct rk817_battery_device * battery)768 static int rk817_bat_get_vaclib0(struct rk817_battery_device *battery)
769 {
770 int vcalib_value = 0;
771
772 vcalib_value |= rk817_bat_field_read(battery, VCALIB0_H) << 8;
773 vcalib_value |= rk817_bat_field_read(battery, VCALIB0_L);
774
775 return vcalib_value;
776 }
777
rk817_bat_get_vaclib1(struct rk817_battery_device * battery)778 static int rk817_bat_get_vaclib1(struct rk817_battery_device *battery)
779 {
780 int vcalib_value = 0;
781
782 vcalib_value |= rk817_bat_field_read(battery, VCALIB1_H) << 8;
783 vcalib_value |= rk817_bat_field_read(battery, VCALIB1_L);
784
785 return vcalib_value;
786 }
787
rk817_bat_init_voltage_kb(struct rk817_battery_device * battery)788 static void rk817_bat_init_voltage_kb(struct rk817_battery_device *battery)
789 {
790 int vcalib0, vcalib1;
791
792 vcalib0 = rk817_bat_get_vaclib0(battery);
793 vcalib1 = rk817_bat_get_vaclib1(battery);
794 if (battery->chip_id == RK809_ID) {
795 battery->voltage_k = (1050 - 600) * 1000 / DIV(vcalib1 - vcalib0);
796 battery->voltage_b = 1050 - (battery->voltage_k * vcalib1) / 1000;
797 } else {
798 battery->voltage_k = (4025 - 2300) * 1000 / DIV(vcalib1 - vcalib0);
799 battery->voltage_b = 4025 - (battery->voltage_k * vcalib1) / 1000;
800 }
801 }
802
rk817_bat_restart_relax(struct rk817_battery_device * battery)803 static void rk817_bat_restart_relax(struct rk817_battery_device *battery)
804 {
805 rk817_bat_field_write(battery, RELAX_VOL1_UPD, 0x00);
806 rk817_bat_field_write(battery, RELAX_VOL2_UPD, 0x00);
807 }
808
is_rk817_bat_relax_mode(struct rk817_battery_device * battery)809 static bool is_rk817_bat_relax_mode(struct rk817_battery_device *battery)
810 {
811 u8 relax_sts, relax_vol1_upd, relax_vol2_upd;
812
813 relax_sts = rk817_bat_field_read(battery, RELAX_STS);
814 relax_vol1_upd = rk817_bat_field_read(battery, RELAX_VOL1_UPD);
815 relax_vol2_upd = rk817_bat_field_read(battery, RELAX_VOL2_UPD);
816
817 DBG("RELAX_STS: %d\n", relax_sts);
818 DBG("RELAX_VOL1_UPD: %d\n", relax_vol1_upd);
819 DBG("RELAX_VOL2_UPD: %d\n", relax_vol2_upd);
820 if (relax_sts && relax_vol1_upd && relax_vol2_upd)
821 return true;
822 else
823 return false;
824 }
825
rk817_bat_get_relax_vol1(struct rk817_battery_device * battery)826 static u16 rk817_bat_get_relax_vol1(struct rk817_battery_device *battery)
827 {
828 u16 vol, val = 0;
829
830 val = rk817_bat_field_read(battery, RELAX_VOL1_H) << 8;
831 val |= rk817_bat_field_read(battery, RELAX_VOL1_L);
832 vol = battery->voltage_k * val / 1000 + battery->voltage_b;
833
834 return vol;
835 }
836
rk817_bat_get_relax_vol2(struct rk817_battery_device * battery)837 static u16 rk817_bat_get_relax_vol2(struct rk817_battery_device *battery)
838 {
839 u16 vol, val = 0;
840
841 val = rk817_bat_field_read(battery, RELAX_VOL2_H) << 8;
842 val |= rk817_bat_field_read(battery, RELAX_VOL2_L);
843 vol = battery->voltage_k * val / 1000 + battery->voltage_b;
844
845 return vol;
846 }
847
rk817_bat_get_relax_voltage(struct rk817_battery_device * battery)848 static u16 rk817_bat_get_relax_voltage(struct rk817_battery_device *battery)
849 {
850 u16 relax_vol1, relax_vol2;
851
852 if (!is_rk817_bat_relax_mode(battery))
853 return 0;
854
855 relax_vol1 = rk817_bat_get_relax_vol1(battery);
856 relax_vol2 = rk817_bat_get_relax_vol2(battery);
857
858 return relax_vol1 > relax_vol2 ? relax_vol1 : relax_vol2;
859 }
860
rk817_bat_set_relax_sample(struct rk817_battery_device * battery)861 static void rk817_bat_set_relax_sample(struct rk817_battery_device *battery)
862 {
863 u8 buf;
864 int enter_thres, filter_thres;
865 struct battery_platform_data *pdata = battery->pdata;
866
867 filter_thres = pdata->sleep_filter_current * 1000 / 1506;
868
869 enter_thres = CURRENT_TO_ADC(pdata->sleep_enter_current,
870 battery->res_div);
871 filter_thres = CURRENT_TO_ADC(pdata->sleep_filter_current,
872 battery->res_div);
873
874 /* set relax enter and exit threshold */
875 buf = (enter_thres >> 8) & 0xff;
876 rk817_bat_field_write(battery, RELAX_THRE_H, buf);
877 buf = enter_thres & 0xff;
878 rk817_bat_field_write(battery, RELAX_THRE_L, buf);
879 /* set sample current threshold */
880 buf = (filter_thres >> 8) & 0xff;
881 rk817_bat_field_write(battery, SLEEP_CON_SAMP_CUR_H, buf);
882 buf = filter_thres & 0xff;
883 rk817_bat_field_write(battery, SLEEP_CON_SAMP_CUR_L, buf);
884
885 /* reset relax update state */
886 rk817_bat_restart_relax(battery);
887 DBG("<%s>. sleep_enter_current = %d, sleep_exit_current = %d\n",
888 __func__, pdata->sleep_enter_current, pdata->sleep_exit_current);
889 }
890
891 /* runtime OCV voltage, |RLX_VOL2 - RLX_VOL1| < OCV_THRE,
892 * the OCV reg update every 120s
893 */
rk817_bat_ocv_thre(struct rk817_battery_device * battery,int value)894 static void rk817_bat_ocv_thre(struct rk817_battery_device *battery, int value)
895 {
896 rk817_bat_field_write(battery, OCV_THRE_VOL, value);
897 }
898
rk817_bat_get_ocv_voltage(struct rk817_battery_device * battery)899 static int rk817_bat_get_ocv_voltage(struct rk817_battery_device *battery)
900 {
901 int vol, val = 0, vol_temp;
902
903 val = rk817_bat_field_read(battery, OCV_VOL_H) << 8;
904 val |= rk817_bat_field_read(battery, OCV_VOL_L);
905 vol = battery->voltage_k * val / 1000 + battery->voltage_b;
906
907 if (battery->chip_id == RK809_ID) {
908 vol_temp = vol * battery->pdata->bat_res_up /
909 battery->pdata->bat_res_down + vol;
910 vol = vol_temp;
911 }
912
913 return vol;
914 }
915
rk817_bat_get_ocv0_voltage0(struct rk817_battery_device * battery)916 static int rk817_bat_get_ocv0_voltage0(struct rk817_battery_device *battery)
917 {
918 int vol, val = 0, vol_temp;
919
920 val = rk817_bat_field_read(battery, OCV_VOL0_H) << 8;
921 val |= rk817_bat_field_read(battery, OCV_VOL0_L);
922 vol = battery->voltage_k * val / 1000 + battery->voltage_b;
923 if (battery->chip_id == RK809_ID) {
924 vol_temp = vol * battery->pdata->bat_res_up /
925 battery->pdata->bat_res_down + vol;
926 vol = vol_temp;
927 }
928
929 return vol;
930 }
931
932 /* power on battery voltage */
rk817_bat_get_pwron_voltage(struct rk817_battery_device * battery)933 static int rk817_bat_get_pwron_voltage(struct rk817_battery_device *battery)
934 {
935 int vol, val = 0, vol_temp;
936
937 val = rk817_bat_field_read(battery, PWRON_VOL_H) << 8;
938 val |= rk817_bat_field_read(battery, PWRON_VOL_L);
939 vol = battery->voltage_k * val / 1000 + battery->voltage_b;
940 if (battery->chip_id == RK809_ID) {
941 vol_temp = vol * battery->pdata->bat_res_up /
942 battery->pdata->bat_res_down + vol;
943 vol = vol_temp;
944 }
945
946 return vol;
947 }
948
rk817_bat_get_battery_voltage(struct rk817_battery_device * battery)949 static int rk817_bat_get_battery_voltage(struct rk817_battery_device *battery)
950 {
951 int vol, val = 0, vol_temp;
952 int vcalib0, vcalib1;
953
954 vcalib0 = rk817_bat_get_vaclib0(battery);
955 vcalib1 = rk817_bat_get_vaclib1(battery);
956
957
958 val = rk817_bat_field_read(battery, BAT_VOL_H) << 8;
959 val |= rk817_bat_field_read(battery, BAT_VOL_L) << 0;
960
961 vol = battery->voltage_k * val / 1000 + battery->voltage_b;
962
963 if (battery->chip_id == RK809_ID) {
964 vol_temp = vol * battery->pdata->bat_res_up /
965 battery->pdata->bat_res_down + vol;
966 vol = vol_temp;
967 }
968
969 return vol;
970 }
971
rk817_bat_get_USB_voltage(struct rk817_battery_device * battery)972 static int rk817_bat_get_USB_voltage(struct rk817_battery_device *battery)
973 {
974 int vol, val = 0, vol_temp;
975
976 rk817_bat_field_write(battery, USB_VOL_ADC_EN, 0x01);
977
978 val = rk817_bat_field_read(battery, USB_VOL_H) << 8;
979 val |= rk817_bat_field_read(battery, USB_VOL_L) << 0;
980
981 vol = (battery->voltage_k * val / 1000 + battery->voltage_b) * 60 / 46;
982
983 if (battery->chip_id == RK809_ID) {
984 vol_temp = vol * battery->pdata->bat_res_up /
985 battery->pdata->bat_res_down + vol;
986 vol = vol_temp;
987 }
988
989 return vol;
990 }
991
rk817_bat_get_sys_voltage(struct rk817_battery_device * battery)992 static int rk817_bat_get_sys_voltage(struct rk817_battery_device *battery)
993 {
994 int vol, val = 0, vol_temp;
995
996 val = rk817_bat_field_read(battery, SYS_VOL_H) << 8;
997 val |= rk817_bat_field_read(battery, SYS_VOL_L) << 0;
998
999 vol = (battery->voltage_k * val / 1000 + battery->voltage_b) * 60 / 46;
1000
1001 if (battery->chip_id == RK809_ID) {
1002 vol_temp = vol * battery->pdata->bat_res_up /
1003 battery->pdata->bat_res_down + vol;
1004 vol = vol_temp;
1005 }
1006
1007 return vol;
1008 }
1009
rk817_bat_get_avg_current(struct rk817_battery_device * battery)1010 static int rk817_bat_get_avg_current(struct rk817_battery_device *battery)
1011 {
1012 int cur, val = 0;
1013
1014 val = rk817_bat_field_read(battery, BAT_CUR_H) << 8;
1015 val |= rk817_bat_field_read(battery, BAT_CUR_L);
1016
1017 if (val & 0x8000)
1018 val -= 0x10000;
1019
1020 cur = ADC_TO_CURRENT(val, battery->res_div);
1021
1022 return cur;
1023 }
1024
rk817_bat_get_relax_cur1(struct rk817_battery_device * battery)1025 static int rk817_bat_get_relax_cur1(struct rk817_battery_device *battery)
1026 {
1027 int cur, val = 0;
1028
1029 val = rk817_bat_field_read(battery, RELAX_CUR1_H) << 8;
1030 val |= rk817_bat_field_read(battery, RELAX_CUR1_L);
1031
1032 if (val & 0x8000)
1033 val -= 0x10000;
1034
1035 cur = ADC_TO_CURRENT(val, battery->res_div);
1036
1037 return cur;
1038 }
1039
rk817_bat_get_relax_cur2(struct rk817_battery_device * battery)1040 static int rk817_bat_get_relax_cur2(struct rk817_battery_device *battery)
1041 {
1042 int cur, val = 0;
1043
1044 val |= rk817_bat_field_read(battery, RELAX_CUR2_H) << 8;
1045 val = rk817_bat_field_read(battery, RELAX_CUR2_L);
1046
1047 if (val & 0x8000)
1048 val -= 0x10000;
1049
1050 cur = ADC_TO_CURRENT(val, battery->res_div);
1051
1052 return cur;
1053 }
1054
rk817_bat_get_relax_current(struct rk817_battery_device * battery)1055 static int rk817_bat_get_relax_current(struct rk817_battery_device *battery)
1056 {
1057 int relax_cur1, relax_cur2;
1058
1059 if (!is_rk817_bat_relax_mode(battery))
1060 return 0;
1061
1062 relax_cur1 = rk817_bat_get_relax_cur1(battery);
1063 relax_cur2 = rk817_bat_get_relax_cur2(battery);
1064
1065 return (relax_cur1 < relax_cur2) ? relax_cur1 : relax_cur2;
1066 }
1067
rk817_bat_get_ocv_current(struct rk817_battery_device * battery)1068 static int rk817_bat_get_ocv_current(struct rk817_battery_device *battery)
1069 {
1070 int cur, val = 0;
1071
1072 val = rk817_bat_field_read(battery, OCV_CUR_H) << 8;
1073 val |= rk817_bat_field_read(battery, OCV_CUR_L);
1074
1075 if (val & 0x8000)
1076 val -= 0x10000;
1077
1078 cur = ADC_TO_CURRENT(val, battery->res_div);
1079
1080 return cur;
1081 }
1082
rk817_bat_get_ocv_current0(struct rk817_battery_device * battery)1083 static int rk817_bat_get_ocv_current0(struct rk817_battery_device *battery)
1084 {
1085 int cur, val = 0;
1086
1087 val = rk817_bat_field_read(battery, OCV_CUR0_H) << 8;
1088 val |= rk817_bat_field_read(battery, OCV_CUR0_L);
1089
1090 if (val & 0x8000)
1091 val -= 0x10000;
1092
1093 cur = ADC_TO_CURRENT(val, battery->res_div);
1094
1095 return cur;
1096 }
1097
rk817_bat_get_pwron_current(struct rk817_battery_device * battery)1098 static int rk817_bat_get_pwron_current(struct rk817_battery_device *battery)
1099 {
1100 int cur, val = 0;
1101
1102 val = rk817_bat_field_read(battery, PWRON_CUR_H) << 8;
1103 val |= rk817_bat_field_read(battery, PWRON_CUR_L);
1104
1105 if (val & 0x8000)
1106 val -= 0x10000;
1107 cur = ADC_TO_CURRENT(val, battery->res_div);
1108
1109 return cur;
1110 }
1111
rk817_bat_remain_cap_is_valid(struct rk817_battery_device * battery)1112 static bool rk817_bat_remain_cap_is_valid(struct rk817_battery_device *battery)
1113 {
1114 return !(rk817_bat_field_read(battery, Q_PRESS_H3) & CAP_INVALID);
1115 }
1116
rk817_bat_get_capacity_uah(struct rk817_battery_device * battery)1117 static u32 rk817_bat_get_capacity_uah(struct rk817_battery_device *battery)
1118 {
1119 u32 val = 0, capacity = 0;
1120
1121 if (rk817_bat_remain_cap_is_valid(battery)) {
1122 val = rk817_bat_field_read(battery, Q_PRESS_H3) << 24;
1123 val |= rk817_bat_field_read(battery, Q_PRESS_H2) << 16;
1124 val |= rk817_bat_field_read(battery, Q_PRESS_L1) << 8;
1125 val |= rk817_bat_field_read(battery, Q_PRESS_L0) << 0;
1126
1127 capacity = ADC_TO_CAPACITY_UAH(val, battery->res_div);
1128 }
1129
1130 DBG("xxxxxxxxxxxxx capacity = %d\n", capacity);
1131 return capacity;
1132 }
1133
rk817_bat_get_capacity_mah(struct rk817_battery_device * battery)1134 static u32 rk817_bat_get_capacity_mah(struct rk817_battery_device *battery)
1135 {
1136 u32 val, capacity = 0;
1137
1138 if (rk817_bat_remain_cap_is_valid(battery)) {
1139 val = rk817_bat_field_read(battery, Q_PRESS_H3) << 24;
1140 val |= rk817_bat_field_read(battery, Q_PRESS_H2) << 16;
1141 val |= rk817_bat_field_read(battery, Q_PRESS_L1) << 8;
1142 val |= rk817_bat_field_read(battery, Q_PRESS_L0) << 0;
1143
1144 capacity = ADC_TO_CAPACITY(val, battery->res_div);
1145 }
1146 DBG("Q_PRESS_H3 = 0x%x\n", rk817_bat_field_read(battery, Q_PRESS_H3));
1147 DBG("Q_PRESS_H2 = 0x%x\n", rk817_bat_field_read(battery, Q_PRESS_H2));
1148 DBG("Q_PRESS_H1 = 0x%x\n", rk817_bat_field_read(battery, Q_PRESS_L1));
1149 DBG("Q_PRESS_H0 = 0x%x\n", rk817_bat_field_read(battery, Q_PRESS_L0));
1150
1151 DBG("xxxxxxxxxxxxx capacity = %d\n", capacity);
1152 return capacity;
1153 }
1154
fuel_gauge_q_init_info(struct rk817_battery_device * battery)1155 static void fuel_gauge_q_init_info(struct rk817_battery_device *battery)
1156 {
1157 DBG("Q_INIT_H3 = 0x%x\n", rk817_bat_field_read(battery, Q_INIT_H3));
1158 DBG("Q_INIT_H2 = 0x%x\n", rk817_bat_field_read(battery, Q_INIT_H2));
1159 DBG("Q_INIT_L1 = 0x%x\n", rk817_bat_field_read(battery, Q_INIT_L1));
1160 DBG("Q_INIT_L0 = 0x%x\n", rk817_bat_field_read(battery, Q_INIT_L0));
1161 }
1162
rk817_bat_init_coulomb_cap(struct rk817_battery_device * battery,u32 capacity)1163 static void rk817_bat_init_coulomb_cap(struct rk817_battery_device *battery,
1164 u32 capacity)
1165 {
1166 u8 buf;
1167 u32 cap;
1168
1169 fuel_gauge_q_init_info(battery);
1170 cap = CAPACITY_TO_ADC(capacity, battery->res_div);
1171 DBG("new cap: 0x%x\n", cap);
1172 buf = (cap >> 24) & 0xff;
1173 rk817_bat_field_write(battery, Q_INIT_H3, buf);
1174 buf = (cap >> 16) & 0xff;
1175 rk817_bat_field_write(battery, Q_INIT_H2, buf);
1176 buf = (cap >> 8) & 0xff;
1177 rk817_bat_field_write(battery, Q_INIT_L1, buf);
1178 buf = (cap >> 0) & 0xff;
1179 rk817_bat_field_write(battery, Q_INIT_L0, buf);
1180
1181 battery->rsoc = capacity * 1000 * 100 / battery->fcc;
1182 battery->remain_cap = capacity * 1000;
1183 DBG("new remaincap: %d\n", battery->remain_cap);
1184 fuel_gauge_q_init_info(battery);
1185 }
1186
rk817_bat_save_cap(struct rk817_battery_device * battery,int capacity)1187 static void rk817_bat_save_cap(struct rk817_battery_device *battery,
1188 int capacity)
1189 {
1190 u8 buf;
1191 static u32 old_cap;
1192
1193 if (capacity >= battery->qmax)
1194 capacity = battery->qmax;
1195 if (capacity <= 0)
1196 capacity = 0;
1197 if (old_cap == capacity)
1198 return;
1199
1200 old_cap = capacity;
1201 buf = (capacity >> 16) & 0xff;
1202 rk817_bat_field_write(battery, REMAIN_CAP_REG2, buf);
1203 buf = (capacity >> 8) & 0xff;
1204 rk817_bat_field_write(battery, REMAIN_CAP_REG1, buf);
1205 buf = (capacity >> 0) & 0xff;
1206 rk817_bat_field_write(battery, REMAIN_CAP_REG0, buf);
1207 }
1208
rk817_bat_update_qmax(struct rk817_battery_device * battery,u32 capacity)1209 static void rk817_bat_update_qmax(struct rk817_battery_device *battery,
1210 u32 capacity)
1211 {
1212 u8 buf;
1213 u32 cap_adc;
1214
1215 cap_adc = CAPACITY_TO_ADC(capacity, battery->res_div);
1216 buf = (cap_adc >> 24) & 0xff;
1217 rk817_bat_field_write(battery, Q_MAX_H3, buf);
1218 buf = (cap_adc >> 16) & 0xff;
1219 rk817_bat_field_write(battery, Q_MAX_H2, buf);
1220 buf = (cap_adc >> 8) & 0xff;
1221 rk817_bat_field_write(battery, Q_MAX_L1, buf);
1222 buf = (cap_adc >> 0) & 0xff;
1223 rk817_bat_field_write(battery, Q_MAX_L0, buf);
1224 battery->qmax = capacity;
1225 }
1226
rk817_bat_get_qmax(struct rk817_battery_device * battery)1227 static int rk817_bat_get_qmax(struct rk817_battery_device *battery)
1228 {
1229 u32 capacity;
1230 int val = 0;
1231
1232 val = rk817_bat_field_read(battery, Q_MAX_H3) << 24;
1233 val |= rk817_bat_field_read(battery, Q_MAX_H2) << 16;
1234 val |= rk817_bat_field_read(battery, Q_MAX_L1) << 8;
1235 val |= rk817_bat_field_read(battery, Q_MAX_L0) << 0;
1236 capacity = ADC_TO_CAPACITY(val, battery->res_div);
1237 battery->qmax = capacity;
1238 return capacity;
1239 }
1240
rk817_bat_save_fcc(struct rk817_battery_device * battery,int fcc)1241 static void rk817_bat_save_fcc(struct rk817_battery_device *battery, int fcc)
1242 {
1243 u8 buf;
1244
1245 buf = (fcc >> 16) & 0xff;
1246 rk817_bat_field_write(battery, NEW_FCC_REG2, buf);
1247 buf = (fcc >> 8) & 0xff;
1248 rk817_bat_field_write(battery, NEW_FCC_REG1, buf);
1249 buf = (fcc >> 0) & 0xff;
1250 rk817_bat_field_write(battery, NEW_FCC_REG0, buf);
1251 }
1252
rk817_bat_get_fcc(struct rk817_battery_device * battery)1253 static int rk817_bat_get_fcc(struct rk817_battery_device *battery)
1254 {
1255 u32 fcc = 0;
1256
1257 fcc |= rk817_bat_field_read(battery, NEW_FCC_REG2) << 16;
1258 fcc |= rk817_bat_field_read(battery, NEW_FCC_REG1) << 8;
1259 fcc |= rk817_bat_field_read(battery, NEW_FCC_REG0) << 0;
1260
1261 if (fcc < MIN_FCC) {
1262 DBG("invalid fcc(%d), use design cap", fcc);
1263 fcc = battery->pdata->design_capacity;
1264 rk817_bat_save_fcc(battery, fcc);
1265 } else if (fcc > battery->pdata->design_qmax) {
1266 DBG("invalid fcc(%d), use qmax", fcc);
1267 fcc = battery->pdata->design_qmax;
1268 rk817_bat_save_fcc(battery, fcc);
1269 }
1270
1271 return fcc;
1272 }
1273
rk817_bat_get_rsoc(struct rk817_battery_device * battery)1274 static int rk817_bat_get_rsoc(struct rk817_battery_device *battery)
1275 {
1276 int remain_cap;
1277
1278 remain_cap = rk817_bat_get_capacity_uah(battery);
1279
1280 return remain_cap * 100 / DIV(battery->fcc);
1281 }
1282
rk817_bat_get_off_count(struct rk817_battery_device * battery)1283 static int rk817_bat_get_off_count(struct rk817_battery_device *battery)
1284 {
1285 return rk817_bat_field_read(battery, OFF_CNT);
1286 }
1287
rk817_bat_get_ocv_count(struct rk817_battery_device * battery)1288 static int rk817_bat_get_ocv_count(struct rk817_battery_device *battery)
1289 {
1290 return rk817_bat_field_read(battery, OCV_CNT);
1291 }
1292
rk817_bat_vol_to_soc(struct rk817_battery_device * battery,int voltage)1293 static int rk817_bat_vol_to_soc(struct rk817_battery_device *battery,
1294 int voltage)
1295 {
1296 u32 *ocv_table, temp;
1297 int ocv_size, ocv_soc;
1298
1299 ocv_table = battery->pdata->ocv_table;
1300 ocv_size = battery->pdata->ocv_size;
1301 temp = interpolate(voltage, ocv_table, ocv_size);
1302 ocv_soc = ab_div_c(temp, MAX_PERCENTAGE, MAX_INTERPOLATE);
1303
1304 return ocv_soc;
1305 }
1306
rk817_bat_vol_to_cap(struct rk817_battery_device * battery,int voltage)1307 static int rk817_bat_vol_to_cap(struct rk817_battery_device *battery,
1308 int voltage)
1309 {
1310 u32 *ocv_table, temp;
1311 int ocv_size, capacity;
1312
1313 ocv_table = battery->pdata->ocv_table;
1314 ocv_size = battery->pdata->ocv_size;
1315 temp = interpolate(voltage, ocv_table, ocv_size);
1316 capacity = ab_div_c(temp, battery->fcc, MAX_INTERPOLATE);
1317
1318 return capacity;
1319 }
1320
rk817_bat_save_dsoc(struct rk817_battery_device * battery,int save_soc)1321 static void rk817_bat_save_dsoc(struct rk817_battery_device *battery,
1322 int save_soc)
1323 {
1324 static int last_soc = -1;
1325
1326 if (last_soc != save_soc) {
1327 rk817_bat_field_write(battery, SOC_REG0,
1328 save_soc & 0xff);
1329 rk817_bat_field_write(battery, SOC_REG1,
1330 (save_soc >> 8) & 0xff);
1331 rk817_bat_field_write(battery, SOC_REG2,
1332 (save_soc >> 16) & 0xff);
1333
1334 last_soc = save_soc;
1335 }
1336 }
1337
rk817_bat_get_prev_dsoc(struct rk817_battery_device * battery)1338 static int rk817_bat_get_prev_dsoc(struct rk817_battery_device *battery)
1339 {
1340 int soc_save;
1341
1342 soc_save = rk817_bat_field_read(battery, SOC_REG0);
1343 soc_save |= (rk817_bat_field_read(battery, SOC_REG1) << 8);
1344 soc_save |= (rk817_bat_field_read(battery, SOC_REG2) << 16);
1345
1346 return soc_save;
1347 }
1348
is_rk817_bat_first_pwron(struct rk817_battery_device * battery)1349 static bool is_rk817_bat_first_pwron(struct rk817_battery_device *battery)
1350 {
1351 if (rk817_bat_field_read(battery, BAT_CON)) {
1352 rk817_bat_field_write(battery, BAT_CON, 0x00);
1353 return true;
1354 }
1355
1356 return false;
1357 }
1358
rk817_bat_get_charge_status(struct rk817_battery_device * battery)1359 static int rk817_bat_get_charge_status(struct rk817_battery_device *battery)
1360 {
1361 int status;
1362
1363 if (battery->chip_id == RK809_ID) {
1364 if ((battery->voltage_avg > battery->pdata->design_max_voltage) &&
1365 (battery->current_avg > 0) &&
1366 ((battery->current_avg < 500) ||
1367 (battery->rsoc / 1000 == 100)))
1368 return CHARGE_FINISH;
1369
1370 if (battery->plugin_trigger)
1371 return CC_OR_CV_CHRG;
1372 else
1373 return CHRG_OFF;
1374 }
1375 status = rk817_bat_field_read(battery, CHG_STS);
1376
1377 if (status == CC_OR_CV_CHRG) {
1378 if (battery->rsoc == 100 * 1000) {
1379 DBG("charge to finish\n");
1380 status = CHARGE_FINISH;
1381 }
1382 }
1383
1384 switch (status) {
1385 case CHRG_OFF:
1386 DBG("charge off...\n");
1387 break;
1388 case DEAD_CHRG:
1389 DBG("dead charge...\n");
1390 break;
1391 case TRICKLE_CHRG:
1392 DBG("trickle charge...\n");
1393 break;
1394 case CC_OR_CV_CHRG:
1395 DBG("CC or CV charge...\n");
1396 break;
1397 case CHARGE_FINISH:
1398 DBG("charge finish...\n");
1399 break;
1400 case USB_OVER_VOL:
1401 DBG("USB over voltage...\n");
1402 break;
1403 case BAT_TMP_ERR:
1404 DBG("battery temperature error...\n");
1405 break;
1406 case BAT_TIM_ERR:
1407 DBG("battery timer error..\n");
1408 break;
1409 default:
1410 break;
1411 }
1412
1413 return status;
1414 }
1415
1416 /*
1417 * cccv and finish switch all the time will cause dsoc freeze,
1418 * if so, do finish chrg, 100ma is less than min finish_ma.
1419 */
rk817_bat_fake_finish_mode(struct rk817_battery_device * battery)1420 static bool rk817_bat_fake_finish_mode(struct rk817_battery_device *battery)
1421 {
1422 if ((battery->rsoc == 100) &&
1423 (rk817_bat_get_charge_status(battery) == CC_OR_CV_CHRG) &&
1424 (abs(battery->current_avg) <= 100))
1425 return true;
1426 else
1427 return false;
1428 }
1429
get_charge_status(struct rk817_battery_device * battery)1430 static int get_charge_status(struct rk817_battery_device *battery)
1431 {
1432 return rk817_bat_get_charge_status(battery);
1433 }
1434
is_rk817_bat_ocv_valid(struct rk817_battery_device * battery)1435 static bool is_rk817_bat_ocv_valid(struct rk817_battery_device *battery)
1436 {
1437 return (!battery->is_initialized && battery->pwroff_min >= 30);
1438 }
1439
rk817_bat_gas_gaugle_enable(struct rk817_battery_device * battery)1440 static void rk817_bat_gas_gaugle_enable(struct rk817_battery_device *battery)
1441 {
1442 rk817_bat_field_write(battery, GG_EN, ENABLE);
1443 }
1444
rk817_bat_gg_con_init(struct rk817_battery_device * battery)1445 static void rk817_bat_gg_con_init(struct rk817_battery_device *battery)
1446 {
1447 rk817_bat_field_write(battery, RLX_SPT, S_8_MIN);
1448 rk817_bat_field_write(battery, ADC_OFF_CAL_INTERV, S_8_MIN);
1449 rk817_bat_field_write(battery, VOL_OUT_MOD, AVERAGE_MODE);
1450 rk817_bat_field_write(battery, CUR_OUT_MOD, AVERAGE_MODE);
1451 }
1452
rk817_bat_adc_init(struct rk817_battery_device * battery)1453 static void rk817_bat_adc_init(struct rk817_battery_device *battery)
1454 {
1455 rk817_bat_field_write(battery, SYS_VOL_ADC_EN, ENABLE);
1456 rk817_bat_field_write(battery, TS_ADC_EN, ENABLE);
1457 rk817_bat_field_write(battery, USB_VOL_ADC_EN, ENABLE);
1458 rk817_bat_field_write(battery, BAT_VOL_ADC_EN, ENABLE);
1459 rk817_bat_field_write(battery, BAT_CUR_ADC_EN, ENABLE);
1460 }
1461
rk817_bat_init_info(struct rk817_battery_device * battery)1462 static void rk817_bat_init_info(struct rk817_battery_device *battery)
1463 {
1464 battery->design_cap = battery->pdata->design_capacity;
1465 battery->qmax = battery->pdata->design_qmax;
1466 battery->bat_res = battery->pdata->bat_res;
1467 battery->monitor_ms = battery->pdata->monitor_sec * TIMER_MS_COUNTS;
1468 battery->res_div = (battery->pdata->sample_res == SAMPLE_RES_20MR) ?
1469 SAMPLE_RES_DIV2 : SAMPLE_RES_DIV1;
1470 DBG("battery->qmax :%d\n", battery->qmax);
1471 }
1472
rk817_bat_get_prev_cap(struct rk817_battery_device * battery)1473 static int rk817_bat_get_prev_cap(struct rk817_battery_device *battery)
1474 {
1475 int val = 0;
1476
1477 val = rk817_bat_field_read(battery, REMAIN_CAP_REG2) << 16;
1478 val |= rk817_bat_field_read(battery, REMAIN_CAP_REG1) << 8;
1479 val |= rk817_bat_field_read(battery, REMAIN_CAP_REG0) << 0;
1480
1481 return val;
1482 }
1483
rk817_bat_get_halt_cnt(struct rk817_battery_device * battery)1484 static u8 rk817_bat_get_halt_cnt(struct rk817_battery_device *battery)
1485 {
1486 return rk817_bat_field_read(battery, HALT_CNT_REG);
1487 }
1488
rk817_bat_inc_halt_cnt(struct rk817_battery_device * battery)1489 static void rk817_bat_inc_halt_cnt(struct rk817_battery_device *battery)
1490 {
1491 u8 cnt;
1492
1493 cnt = rk817_bat_field_read(battery, HALT_CNT_REG);
1494 rk817_bat_field_write(battery, HALT_CNT_REG, ++cnt);
1495 }
1496
is_rk817_bat_last_halt(struct rk817_battery_device * battery)1497 static bool is_rk817_bat_last_halt(struct rk817_battery_device *battery)
1498 {
1499 int pre_cap = rk817_bat_get_prev_cap(battery);
1500 int now_cap = rk817_bat_get_capacity_mah(battery);
1501
1502 /* over 10%: system halt last time */
1503 if (abs(now_cap - pre_cap) > (battery->fcc / 10)) {
1504 rk817_bat_inc_halt_cnt(battery);
1505 return true;
1506 } else {
1507 return false;
1508 }
1509 }
1510
is_rk817_bat_initialized(struct rk817_battery_device * battery)1511 static u8 is_rk817_bat_initialized(struct rk817_battery_device *battery)
1512 {
1513 u8 val = rk817_bat_field_read(battery, FG_INIT);
1514
1515 if (val) {
1516 rk817_bat_field_write(battery, FG_INIT, 0x00);
1517 return true;
1518 } else {
1519 return false;
1520 }
1521 }
1522
rk817_bat_calc_sm_linek(struct rk817_battery_device * battery)1523 static void rk817_bat_calc_sm_linek(struct rk817_battery_device *battery)
1524 {
1525 int linek;
1526 int diff, delta;
1527 int current_avg = rk817_bat_get_avg_current(battery);
1528
1529 delta = abs(battery->dsoc - battery->rsoc);
1530 diff = delta * 3;/* speed:3/4 */
1531
1532 if (current_avg > 0) {
1533 if (battery->dsoc < battery->rsoc)
1534 linek = 1000 * (delta + diff) / DIV(diff);
1535 else if (battery->dsoc > battery->rsoc)
1536 linek = 1000 * diff / DIV(delta + diff);
1537 else
1538 linek = 1000;
1539 } else {
1540 if (battery->dsoc < battery->rsoc)
1541 linek = -1000 * diff / DIV(delta + diff);
1542 else if (battery->dsoc > battery->rsoc)
1543 linek = -1000 * (delta + diff) / DIV(diff);
1544 else
1545 linek = -1000;
1546 }
1547
1548 battery->dbg_meet_soc = (battery->dsoc >= battery->rsoc) ?
1549 (battery->dsoc - diff) : (battery->rsoc - diff);
1550
1551 battery->sm_linek = linek;
1552 battery->sm_remain_cap = battery->remain_cap;
1553 battery->dbg_calc_dsoc = battery->dsoc;
1554 battery->dbg_calc_rsoc = battery->rsoc;
1555 }
1556
rk817_bat_smooth_algo_prepare(struct rk817_battery_device * battery)1557 static void rk817_bat_smooth_algo_prepare(struct rk817_battery_device *battery)
1558 {
1559 battery->smooth_soc = battery->dsoc;
1560
1561 DBG("<%s>. dsoc=%d, dsoc:smooth_soc=%d\n",
1562 __func__, battery->dsoc, battery->smooth_soc);
1563 rk817_bat_calc_sm_linek(battery);
1564 }
1565
rk817_bat_finish_algo_prepare(struct rk817_battery_device * battery)1566 static void rk817_bat_finish_algo_prepare(struct rk817_battery_device *battery)
1567 {
1568 battery->finish_base = get_boot_sec();
1569
1570 if (!battery->finish_base)
1571 battery->finish_base = 1;
1572 }
1573
rk817_bat_init_dsoc_algorithm(struct rk817_battery_device * battery)1574 static void rk817_bat_init_dsoc_algorithm(struct rk817_battery_device *battery)
1575 {
1576 if (battery->dsoc >= 100 * 1000)
1577 battery->dsoc = 100 * 1000;
1578 else if (battery->dsoc <= 0)
1579 battery->dsoc = 0;
1580 /* init current mode */
1581 battery->voltage_avg = rk817_bat_get_battery_voltage(battery);
1582 battery->current_avg = rk817_bat_get_avg_current(battery);
1583
1584 if (get_charge_status(battery) == CHARGE_FINISH) {
1585 rk817_bat_finish_algo_prepare(battery);
1586 battery->work_mode = MODE_FINISH;
1587 } else {
1588 rk817_bat_smooth_algo_prepare(battery);
1589 battery->work_mode = MODE_SMOOTH;
1590 }
1591 DBG("%s, sm_remain_cap = %d, smooth_soc = %d\n",
1592 __func__, battery->sm_remain_cap, battery->smooth_soc);
1593 }
1594
rk817_bat_first_pwron(struct rk817_battery_device * battery)1595 static void rk817_bat_first_pwron(struct rk817_battery_device *battery)
1596 {
1597 battery->rsoc =
1598 rk817_bat_vol_to_soc(battery,
1599 battery->pwron_voltage) * 1000;/* uAH */
1600 battery->dsoc = battery->rsoc;
1601 battery->fcc = battery->pdata->design_capacity;
1602 battery->nac = rk817_bat_vol_to_cap(battery, battery->pwron_voltage);
1603
1604 rk817_bat_update_qmax(battery, battery->qmax);
1605 rk817_bat_save_fcc(battery, battery->fcc);
1606 DBG("%s, rsoc = %d, dsoc = %d, fcc = %d, nac = %d\n",
1607 __func__, battery->rsoc, battery->dsoc, battery->fcc, battery->nac);
1608 }
1609
rk817_bat_not_first_pwron(struct rk817_battery_device * battery)1610 static void rk817_bat_not_first_pwron(struct rk817_battery_device *battery)
1611 {
1612 int now_cap, pre_soc, pre_cap, ocv_cap, ocv_soc, ocv_vol;
1613
1614 battery->fcc = rk817_bat_get_fcc(battery);
1615 pre_soc = rk817_bat_get_prev_dsoc(battery);
1616 pre_cap = rk817_bat_get_prev_cap(battery);
1617 now_cap = rk817_bat_get_capacity_mah(battery);
1618 battery->remain_cap = pre_cap * 1000;
1619 battery->is_halt = is_rk817_bat_last_halt(battery);
1620 battery->halt_cnt = rk817_bat_get_halt_cnt(battery);
1621 battery->is_initialized = is_rk817_bat_initialized(battery);
1622 battery->is_ocv_calib = is_rk817_bat_ocv_valid(battery);
1623
1624 if (battery->is_halt) {
1625 BAT_INFO("system halt last time... cap: pre=%d, now=%d\n",
1626 pre_cap, now_cap);
1627 if (now_cap < 0)
1628 now_cap = 0;
1629 rk817_bat_init_coulomb_cap(battery, now_cap);
1630 pre_cap = now_cap;
1631 pre_soc = battery->rsoc;
1632 goto finish;
1633 } else if (battery->is_initialized) {
1634 /* uboot initialized */
1635 BAT_INFO("initialized yet..\n");
1636 goto finish;
1637 } else if (battery->is_ocv_calib) {
1638 /* not initialized and poweroff_cnt above 30 min */
1639 ocv_vol = rk817_bat_get_ocv_voltage(battery);
1640 ocv_soc = rk817_bat_vol_to_soc(battery, ocv_vol);
1641 ocv_cap = rk817_bat_vol_to_cap(battery, ocv_vol);
1642 pre_cap = ocv_cap;
1643 battery->ocv_pre_dsoc = pre_soc;
1644 battery->ocv_new_dsoc = ocv_soc;
1645 if (abs(ocv_soc - pre_soc) >= battery->pdata->max_soc_offset) {
1646 battery->ocv_pre_dsoc = pre_soc;
1647 battery->ocv_new_dsoc = ocv_soc;
1648 battery->is_max_soc_offset = true;
1649 BAT_INFO("trigger max soc offset, dsoc: %d -> %d\n",
1650 pre_soc, ocv_soc);
1651 pre_soc = ocv_soc;
1652 }
1653 BAT_INFO("OCV calib: cap=%d, rsoc=%d\n", ocv_cap, ocv_soc);
1654 } else if (battery->pwroff_min > 0) {
1655 ocv_vol = rk817_bat_get_ocv_voltage(battery);
1656 ocv_soc = rk817_bat_vol_to_soc(battery, ocv_vol);
1657 ocv_cap = rk817_bat_vol_to_cap(battery, ocv_vol);
1658 battery->force_pre_dsoc = pre_soc;
1659 battery->force_new_dsoc = ocv_soc;
1660 if (abs(ocv_soc - pre_soc) >= 80) {
1661 battery->is_force_calib = true;
1662 BAT_INFO("dsoc force calib: %d -> %d\n",
1663 pre_soc, ocv_soc);
1664 pre_soc = ocv_soc;
1665 pre_cap = ocv_cap;
1666 }
1667 }
1668 finish:
1669 battery->dsoc = pre_soc;
1670 battery->nac = pre_cap;
1671 if (battery->nac < 0)
1672 battery->nac = 0;
1673
1674 DBG("dsoc=%d cap=%d v=%d ov=%d rv=%d min=%d psoc=%d pcap=%d\n",
1675 battery->dsoc, battery->nac, rk817_bat_get_battery_voltage(battery),
1676 rk817_bat_get_ocv_voltage(battery),
1677 rk817_bat_get_relax_voltage(battery),
1678 battery->pwroff_min, rk817_bat_get_prev_dsoc(battery),
1679 rk817_bat_get_prev_cap(battery));
1680 }
1681
rk817_bat_rsoc_init(struct rk817_battery_device * battery)1682 static void rk817_bat_rsoc_init(struct rk817_battery_device *battery)
1683 {
1684 battery->is_first_power_on = is_rk817_bat_first_pwron(battery);
1685 battery->pwroff_min = rk817_bat_get_off_count(battery);
1686 battery->pwron_voltage = rk817_bat_get_pwron_voltage(battery);
1687
1688 DBG("%s, is_first_power_on = %d, pwroff_min = %d, pwron_voltage = %d\n",
1689 __func__, battery->is_first_power_on,
1690 battery->pwroff_min, battery->pwron_voltage);
1691
1692 if (battery->is_first_power_on)
1693 rk817_bat_first_pwron(battery);
1694 else
1695 rk817_bat_not_first_pwron(battery);
1696
1697 rk817_bat_save_dsoc(battery, battery->dsoc);
1698 }
1699
rk817_bat_caltimer_isr(struct timer_list * t)1700 static void rk817_bat_caltimer_isr(struct timer_list *t)
1701 {
1702 struct rk817_battery_device *battery =
1703 from_timer(battery, t, caltimer);
1704
1705 mod_timer(&battery->caltimer, jiffies + MINUTE(8) * HZ);
1706 queue_delayed_work(battery->bat_monitor_wq,
1707 &battery->calib_delay_work,
1708 msecs_to_jiffies(10));
1709 }
1710
rk817_bat_internal_calib(struct work_struct * work)1711 static void rk817_bat_internal_calib(struct work_struct *work)
1712 {
1713 struct rk817_battery_device *battery = container_of(work,
1714 struct rk817_battery_device, calib_delay_work.work);
1715
1716 return;
1717
1718 rk817_bat_current_calibration(battery);
1719 /* calib voltage kb */
1720 rk817_bat_init_voltage_kb(battery);
1721
1722 DBG("caltimer:coffset=0x%x\n", rk817_bat_get_coffset(battery));
1723 }
1724
rk817_bat_init_caltimer(struct rk817_battery_device * battery)1725 static void rk817_bat_init_caltimer(struct rk817_battery_device *battery)
1726 {
1727 timer_setup(&battery->caltimer,
1728 rk817_bat_caltimer_isr,
1729 0);
1730 battery->caltimer.expires = jiffies + MINUTE(8) * HZ;
1731 add_timer(&battery->caltimer);
1732 INIT_DELAYED_WORK(&battery->calib_delay_work, rk817_bat_internal_calib);
1733 }
1734
rk817_bat_init_fg(struct rk817_battery_device * battery)1735 static void rk817_bat_init_fg(struct rk817_battery_device *battery)
1736 {
1737 rk817_bat_adc_init(battery);
1738 rk817_bat_gas_gaugle_enable(battery);
1739 rk817_bat_gg_con_init(battery);
1740 rk817_bat_init_voltage_kb(battery);
1741 rk817_bat_set_relax_sample(battery);
1742 rk817_bat_ocv_thre(battery, 0xff);
1743 rk817_bat_init_caltimer(battery);
1744 rk817_bat_rsoc_init(battery);
1745 rk817_bat_init_coulomb_cap(battery, battery->nac);
1746 DBG("rsoc%d, fcc = %d\n", battery->rsoc, battery->fcc);
1747 rk817_bat_init_dsoc_algorithm(battery);
1748 battery->qmax = rk817_bat_get_qmax(battery);
1749 battery->voltage_avg = rk817_bat_get_battery_voltage(battery);
1750 battery->voltage_sys = rk817_bat_get_sys_voltage(battery);
1751
1752 battery->voltage_ocv = rk817_bat_get_ocv_voltage(battery);
1753 battery->voltage_relax = rk817_bat_get_relax_voltage(battery);
1754 battery->current_avg = rk817_bat_get_avg_current(battery);
1755 battery->dbg_pwr_dsoc = battery->dsoc;
1756 battery->dbg_pwr_rsoc = battery->rsoc;
1757 battery->dbg_pwr_vol = battery->voltage_avg;
1758 battery->temperature = VIRTUAL_TEMPERATURE;
1759
1760 DBG("probe init: battery->dsoc = %d, rsoc = %d\n"
1761 "remain_cap = %d\n, battery_vol = %d\n, system_vol = %d, qmax = %d\n",
1762 battery->dsoc, battery->rsoc, battery->remain_cap,
1763 battery->voltage_avg, battery->voltage_sys, battery->qmax);
1764 DBG("OCV_THRE_VOL: 0x%x", rk817_bat_field_read(battery, OCV_THRE_VOL));
1765 }
1766
rk817_bat_parse_dt(struct rk817_battery_device * battery)1767 static int rk817_bat_parse_dt(struct rk817_battery_device *battery)
1768 {
1769 u32 out_value;
1770 int length, ret;
1771 size_t size;
1772 struct battery_platform_data *pdata;
1773 struct device *dev = battery->dev;
1774 struct device_node *np = battery->dev->of_node;
1775
1776 pdata = devm_kzalloc(battery->dev, sizeof(*pdata), GFP_KERNEL);
1777 if (!pdata)
1778 return -ENOMEM;
1779
1780 battery->pdata = pdata;
1781 /* init default param */
1782 pdata->bat_res = DEFAULT_BAT_RES;
1783 pdata->monitor_sec = DEFAULT_MONITOR_SEC;
1784 pdata->pwroff_vol = DEFAULT_PWROFF_VOL_THRESD;
1785 pdata->sleep_exit_current = DEFAULT_SLP_EXIT_CUR;
1786 pdata->sleep_enter_current = DEFAULT_SLP_ENTER_CUR;
1787
1788 pdata->sleep_filter_current = DEFAULT_SLP_FILTER_CUR;
1789 pdata->bat_mode = MODE_BATTARY;
1790 pdata->max_soc_offset = DEFAULT_MAX_SOC_OFFSET;
1791 pdata->fb_temp = DEFAULT_FB_TEMP;
1792 pdata->energy_mode = DEFAULT_ENERGY_MODE;
1793 pdata->zero_reserve_dsoc = DEFAULT_ZERO_RESERVE_DSOC * 1000;
1794
1795 pdata->sample_res = DEFAULT_SAMPLE_RES;
1796
1797 /* parse necessary param */
1798 if (!of_find_property(np, "ocv_table", &length)) {
1799 dev_err(dev, "ocv_table not found!\n");
1800 return -EINVAL;
1801 }
1802
1803 pdata->ocv_size = length / sizeof(u32);
1804 if (pdata->ocv_size <= 0) {
1805 dev_err(dev, "invalid ocv table\n");
1806 return -EINVAL;
1807 }
1808
1809 size = sizeof(*pdata->ocv_table) * pdata->ocv_size;
1810 pdata->ocv_table = devm_kzalloc(battery->dev, size, GFP_KERNEL);
1811 if (!pdata->ocv_table)
1812 return -ENOMEM;
1813
1814 ret = of_property_read_u32_array(np, "ocv_table", pdata->ocv_table,
1815 pdata->ocv_size);
1816 if (ret < 0)
1817 return ret;
1818
1819 ret = of_property_read_u32(np, "design_capacity", &out_value);
1820 if (ret < 0) {
1821 dev_err(dev, "design_capacity not found!\n");
1822 return ret;
1823 }
1824 pdata->design_capacity = out_value;
1825
1826 ret = of_property_read_u32(np, "design_qmax", &out_value);
1827 if (ret < 0) {
1828 dev_err(dev, "design_qmax not found!\n");
1829 return ret;
1830 }
1831 pdata->design_qmax = out_value;
1832
1833 /* parse unnecessary param */
1834 ret = of_property_read_u32(np, "sample_res", &pdata->sample_res);
1835 if (ret < 0)
1836 dev_err(dev, "sample_res missing!\n");
1837
1838 ret = of_property_read_u32(np, "fb_temperature", &pdata->fb_temp);
1839 if (ret < 0)
1840 dev_err(dev, "fb_temperature missing!\n");
1841
1842 ret = of_property_read_u32(np, "energy_mode", &pdata->energy_mode);
1843 if (ret < 0)
1844 dev_err(dev, "energy_mode missing!\n");
1845
1846 ret = of_property_read_u32(np, "max_soc_offset",
1847 &pdata->max_soc_offset);
1848 if (ret < 0)
1849 dev_err(dev, "max_soc_offset missing!\n");
1850
1851 ret = of_property_read_u32(np, "monitor_sec", &pdata->monitor_sec);
1852 if (ret < 0)
1853 dev_err(dev, "monitor_sec missing!\n");
1854
1855 ret = of_property_read_u32(np, "zero_algorithm_vol",
1856 &pdata->zero_algorithm_vol);
1857 if (ret < 0)
1858 dev_err(dev, "zero_algorithm_vol missing!\n");
1859
1860 ret = of_property_read_u32(np, "zero_reserve_dsoc",
1861 &pdata->zero_reserve_dsoc);
1862 if (ret < 0)
1863 dev_err(dev, "zero_reserve_dsoc missing!\n");
1864 pdata->zero_reserve_dsoc *= 1000;
1865
1866 ret = of_property_read_u32(np, "virtual_power", &pdata->bat_mode);
1867 if (ret < 0)
1868 dev_err(dev, "virtual_power missing!\n");
1869
1870 ret = of_property_read_u32(np, "bat_res", &pdata->bat_res);
1871 if (ret < 0)
1872 dev_err(dev, "bat_res missing!\n");
1873
1874 ret = of_property_read_u32(np, "sleep_enter_current",
1875 &pdata->sleep_enter_current);
1876 if (ret < 0)
1877 dev_err(dev, "sleep_enter_current missing!\n");
1878
1879 ret = of_property_read_u32(np, "sleep_exit_current",
1880 &pdata->sleep_exit_current);
1881 if (ret < 0)
1882 dev_err(dev, "sleep_exit_current missing!\n");
1883
1884 ret = of_property_read_u32(np, "sleep_filter_current",
1885 &pdata->sleep_filter_current);
1886 if (ret < 0)
1887 dev_err(dev, "sleep_filter_current missing!\n");
1888
1889 ret = of_property_read_u32(np, "power_off_thresd", &pdata->pwroff_vol);
1890 if (ret < 0)
1891 dev_err(dev, "power_off_thresd missing!\n");
1892
1893 ret = of_property_read_u32(np, "low_power_sleep", &pdata->low_pwr_sleep);
1894 if (ret < 0)
1895 dev_info(dev, "low_power_sleep missing!\n");
1896
1897 if (battery->chip_id == RK809_ID) {
1898 ret = of_property_read_u32(np, "bat_res_up",
1899 &pdata->bat_res_up);
1900 if (ret < 0)
1901 dev_err(dev, "battery res_up missing\n");
1902
1903 ret = of_property_read_u32(np, "bat_res_down",
1904 &pdata->bat_res_down);
1905 if (ret < 0)
1906 dev_err(dev, "battery res_down missing!\n");
1907
1908 ret = of_property_read_u32(np, "design_max_voltage",
1909 &pdata->design_max_voltage);
1910 if (ret < 0)
1911 dev_err(dev, "battery design_max_voltage missing!\n");
1912
1913 ret = of_property_read_u32(np, "register_chg_psy",
1914 &battery->is_register_chg_psy);
1915 if (ret < 0 || !battery->is_register_chg_psy)
1916 dev_err(dev, "not have to register chg psy!\n");
1917 }
1918
1919 DBG("the battery dts info dump:\n"
1920 "bat_res:%d\n"
1921 "res_sample:%d\n"
1922 "design_capacity:%d\n"
1923 "design_qmax :%d\n"
1924 "sleep_enter_current:%d\n"
1925 "sleep_exit_current:%d\n"
1926 "sleep_filter_current:%d\n"
1927 "zero_algorithm_vol:%d\n"
1928 "zero_reserve_dsoc:%d\n"
1929 "monitor_sec:%d\n"
1930 "max_soc_offset:%d\n"
1931 "virtual_power:%d\n"
1932 "pwroff_vol:%d\n",
1933 pdata->bat_res,
1934 pdata->sample_res,
1935 pdata->design_capacity,
1936 pdata->design_qmax,
1937 pdata->sleep_enter_current,
1938 pdata->sleep_exit_current,
1939 pdata->sleep_filter_current,
1940 pdata->zero_algorithm_vol,
1941 pdata->zero_reserve_dsoc,
1942 pdata->monitor_sec,
1943 pdata->max_soc_offset,
1944 pdata->bat_mode,
1945 pdata->pwroff_vol);
1946
1947 return 0;
1948 }
1949
1950 static enum power_supply_property rk817_bat_props[] = {
1951 POWER_SUPPLY_PROP_STATUS,
1952 POWER_SUPPLY_PROP_CURRENT_NOW,
1953 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1954 POWER_SUPPLY_PROP_HEALTH,
1955 POWER_SUPPLY_PROP_CAPACITY,
1956 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
1957 POWER_SUPPLY_PROP_TEMP,
1958 POWER_SUPPLY_PROP_CHARGE_COUNTER,
1959 POWER_SUPPLY_PROP_CHARGE_FULL,
1960 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
1961 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
1962 };
1963
rk817_bat_get_usb_psy(struct device * dev,void * data)1964 static int rk817_bat_get_usb_psy(struct device *dev, void *data)
1965 {
1966 struct rk817_battery_device *battery = data;
1967 struct power_supply *psy = dev_get_drvdata(dev);
1968
1969 if (psy->desc->type == POWER_SUPPLY_TYPE_USB) {
1970 battery->usb_psy = psy;
1971 return 1;
1972 }
1973
1974 return 0;
1975 }
1976
rk817_bat_get_ac_psy(struct device * dev,void * data)1977 static int rk817_bat_get_ac_psy(struct device *dev, void *data)
1978 {
1979 struct rk817_battery_device *battery = data;
1980 struct power_supply *psy = dev_get_drvdata(dev);
1981
1982 if (psy->desc->type == POWER_SUPPLY_TYPE_MAINS) {
1983 battery->ac_psy = psy;
1984 return 1;
1985 }
1986
1987 return 0;
1988 }
1989
rk817_bat_get_chrg_psy(struct rk817_battery_device * battery)1990 static void rk817_bat_get_chrg_psy(struct rk817_battery_device *battery)
1991 {
1992 if (!battery->usb_psy)
1993 class_for_each_device(power_supply_class, NULL, (void *)battery,
1994 rk817_bat_get_usb_psy);
1995 if (!battery->ac_psy)
1996 class_for_each_device(power_supply_class, NULL, (void *)battery,
1997 rk817_bat_get_ac_psy);
1998 }
1999
rk817_bat_get_charge_state(struct rk817_battery_device * battery)2000 static int rk817_bat_get_charge_state(struct rk817_battery_device *battery)
2001 {
2002 union power_supply_propval val;
2003 int ret;
2004 struct power_supply *psy;
2005
2006 if (!battery->usb_psy || !battery->ac_psy)
2007 rk817_bat_get_chrg_psy(battery);
2008
2009 psy = battery->usb_psy;
2010 if (psy) {
2011 ret = psy->desc->get_property(psy, POWER_SUPPLY_PROP_ONLINE,
2012 &val);
2013 if (!ret)
2014 battery->usb_in = val.intval;
2015 }
2016
2017 psy = battery->ac_psy;
2018 if (psy) {
2019 ret = psy->desc->get_property(psy, POWER_SUPPLY_PROP_ONLINE,
2020 &val);
2021 if (!ret)
2022 battery->ac_in = val.intval;
2023 }
2024
2025 DBG("%s: ac_online=%d, usb_online=%d\n",
2026 __func__, battery->ac_in, battery->usb_in);
2027
2028 return (battery->usb_in || battery->ac_in);
2029 }
2030
rk817_get_capacity_leve(struct rk817_battery_device * battery)2031 static int rk817_get_capacity_leve(struct rk817_battery_device *battery)
2032 {
2033 int dsoc;
2034
2035 if (battery->pdata->bat_mode == MODE_VIRTUAL)
2036 return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
2037
2038 dsoc = (battery->dsoc + 500) / 1000;
2039 if (dsoc < 1)
2040 return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
2041 else if (dsoc <= 20)
2042 return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
2043 else if (dsoc <= 70)
2044 return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
2045 else if (dsoc <= 90)
2046 return POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
2047 else
2048 return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
2049 }
2050
rk817_battery_time_to_full(struct rk817_battery_device * battery)2051 static int rk817_battery_time_to_full(struct rk817_battery_device *battery)
2052 {
2053 int time_sec;
2054 int cap_temp;
2055
2056 if (battery->pdata->bat_mode == MODE_VIRTUAL) {
2057 time_sec = 3600;
2058 } else if (battery->voltage_avg > 0) {
2059 cap_temp = battery->design_cap - (battery->remain_cap / 1000);
2060 if (cap_temp < 0)
2061 cap_temp = 0;
2062 time_sec = (3600 * cap_temp) / battery->voltage_avg;
2063 } else {
2064 time_sec = 3600 * 24; /* One day */
2065 }
2066
2067 return time_sec;
2068 }
2069
rk817_battery_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)2070 static int rk817_battery_get_property(struct power_supply *psy,
2071 enum power_supply_property psp,
2072 union power_supply_propval *val)
2073 {
2074 struct rk817_battery_device *battery = power_supply_get_drvdata(psy);
2075
2076 switch (psp) {
2077 case POWER_SUPPLY_PROP_CURRENT_NOW:
2078 val->intval = battery->current_avg * 1000;/*uA*/
2079 if (battery->pdata->bat_mode == MODE_VIRTUAL)
2080 val->intval = VIRTUAL_CURRENT * 1000;
2081 break;
2082 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2083 val->intval = battery->voltage_avg * 1000;/*uV*/
2084 if (battery->pdata->bat_mode == MODE_VIRTUAL)
2085 val->intval = VIRTUAL_VOLTAGE * 1000;
2086 break;
2087 case POWER_SUPPLY_PROP_CAPACITY:
2088 val->intval = (battery->dsoc + 500) / 1000;
2089 if (battery->pdata->bat_mode == MODE_VIRTUAL)
2090 val->intval = VIRTUAL_SOC;
2091 break;
2092 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
2093 val->intval = rk817_get_capacity_leve(battery);
2094 break;
2095 case POWER_SUPPLY_PROP_HEALTH:
2096 val->intval = POWER_SUPPLY_HEALTH_GOOD;
2097 break;
2098 case POWER_SUPPLY_PROP_TEMP:
2099 val->intval = battery->temperature;
2100 if (battery->pdata->bat_mode == MODE_VIRTUAL)
2101 val->intval = VIRTUAL_TEMPERATURE;
2102 break;
2103 case POWER_SUPPLY_PROP_STATUS:
2104 if (battery->pdata->bat_mode == MODE_VIRTUAL)
2105 val->intval = VIRTUAL_STATUS;
2106 else if (battery->dsoc == 100 * 1000)
2107 val->intval = POWER_SUPPLY_STATUS_FULL;
2108 else {
2109 if ((battery->chip_id != RK809_ID) &&
2110 rk817_bat_get_charge_state(battery))
2111 val->intval = POWER_SUPPLY_STATUS_CHARGING;
2112 else if (battery->chip_id == RK809_ID &&
2113 battery->plugin_trigger)
2114 val->intval = POWER_SUPPLY_STATUS_CHARGING;
2115 else
2116 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2117 }
2118 break;
2119 case POWER_SUPPLY_PROP_CHARGE_COUNTER:
2120 val->intval = battery->charge_count;
2121 break;
2122 case POWER_SUPPLY_PROP_CHARGE_FULL:
2123 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
2124 val->intval = battery->pdata->design_capacity * 1000;/* uAh */
2125 break;
2126 case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
2127 val->intval = rk817_battery_time_to_full(battery);
2128 break;
2129 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
2130 val->intval = 4500 * 1000;
2131 break;
2132 case POWER_SUPPLY_PROP_CURRENT_MAX:
2133 val->intval = 5000 * 1000;
2134 break;
2135 default:
2136 return -EINVAL;
2137 }
2138
2139 return 0;
2140 }
2141
2142 static const struct power_supply_desc rk817_bat_desc = {
2143 .name = "battery",
2144 .type = POWER_SUPPLY_TYPE_BATTERY,
2145 .properties = rk817_bat_props,
2146 .num_properties = ARRAY_SIZE(rk817_bat_props),
2147 .get_property = rk817_battery_get_property,
2148 };
2149
rk817_bat_init_power_supply(struct rk817_battery_device * battery)2150 static int rk817_bat_init_power_supply(struct rk817_battery_device *battery)
2151 {
2152 struct power_supply_config psy_cfg = { .drv_data = battery, };
2153
2154 battery->bat = devm_power_supply_register(battery->dev,
2155 &rk817_bat_desc,
2156 &psy_cfg);
2157 if (IS_ERR(battery->bat)) {
2158 dev_err(battery->dev, "register bat power supply fail\n");
2159 return PTR_ERR(battery->bat);
2160 }
2161
2162 return 0;
2163 }
2164
2165 static enum power_supply_property rk809_chg_props[] = {
2166 POWER_SUPPLY_PROP_ONLINE,
2167 POWER_SUPPLY_PROP_STATUS,
2168 };
2169
rk809_chg_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)2170 static int rk809_chg_get_property(struct power_supply *psy,
2171 enum power_supply_property psp,
2172 union power_supply_propval *val)
2173 {
2174 struct rk817_battery_device *battery = power_supply_get_drvdata(psy);
2175 int online = 0;
2176 int ret = 0;
2177
2178 if (battery->plugin_trigger)
2179 online = 1;
2180 switch (psp) {
2181 case POWER_SUPPLY_PROP_ONLINE:
2182 val->intval = online;
2183 dev_dbg(battery->dev, "report online: %d\n", val->intval);
2184 break;
2185 case POWER_SUPPLY_PROP_STATUS:
2186 if (online)
2187 val->intval = POWER_SUPPLY_STATUS_CHARGING;
2188 else
2189 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
2190 dev_dbg(battery->dev, "report prop: %d\n", val->intval);
2191 break;
2192 default:
2193 ret = -EINVAL;
2194 break;
2195 }
2196
2197 return ret;
2198 }
2199
2200 static const struct power_supply_desc rk809_chg_desc = {
2201 .name = "charger",
2202 .type = POWER_SUPPLY_TYPE_USB,
2203 .properties = rk809_chg_props,
2204 .num_properties = ARRAY_SIZE(rk809_chg_props),
2205 .get_property = rk809_chg_get_property,
2206 };
2207
rk809_chg_init_power_supply(struct rk817_battery_device * battery)2208 static int rk809_chg_init_power_supply(struct rk817_battery_device *battery)
2209 {
2210 struct power_supply_config psy_cfg = { .drv_data = battery, };
2211
2212 battery->chg_psy =
2213 devm_power_supply_register(battery->dev, &rk809_chg_desc,
2214 &psy_cfg);
2215 if (IS_ERR(battery->chg_psy)) {
2216 dev_err(battery->dev, "register chg psy power supply fail\n");
2217 return PTR_ERR(battery->chg_psy);
2218 }
2219
2220 return 0;
2221 }
2222
rk817_bat_power_supply_changed(struct rk817_battery_device * battery)2223 static void rk817_bat_power_supply_changed(struct rk817_battery_device *battery)
2224 {
2225 static int old_soc = -1;
2226
2227 if (battery->dsoc > 100 * 1000)
2228 battery->dsoc = 100 * 1000;
2229 else if (battery->dsoc < 0)
2230 battery->dsoc = 0;
2231
2232 if (battery->dsoc == old_soc && !battery->change)
2233 return;
2234
2235 battery->change = false;
2236 old_soc = battery->dsoc;
2237 battery->last_dsoc = battery->dsoc;
2238 power_supply_changed(battery->bat);
2239 DBG("changed: dsoc=%d, rsoc=%d, v=%d, ov=%d c=%d, cap=%d, f=%d\n",
2240 battery->dsoc, battery->rsoc, battery->voltage_avg,
2241 battery->voltage_ocv, battery->current_avg,
2242 battery->remain_cap, battery->fcc);
2243
2244 DBG("dl=%d, rl=%d, v=%d, halt=%d, halt_n=%d, max=%d\n"
2245 "init=%d, sw=%d, calib=%d, below0=%d, force=%d\n",
2246 battery->dbg_pwr_dsoc, battery->dbg_pwr_rsoc,
2247 battery->dbg_pwr_vol,
2248 battery->is_halt, battery->halt_cnt,
2249 battery->is_max_soc_offset,
2250 battery->is_initialized, battery->is_sw_reset,
2251 battery->is_ocv_calib,
2252 battery->dbg_cap_low0, battery->is_force_calib);
2253 }
2254
rk817_battery_debug_info(struct rk817_battery_device * battery)2255 static void rk817_battery_debug_info(struct rk817_battery_device *battery)
2256 {
2257 rk817_bat_get_battery_voltage(battery);
2258 rk817_bat_get_sys_voltage(battery);
2259 rk817_bat_get_USB_voltage(battery);
2260 rk817_bat_get_pwron_voltage(battery);
2261 rk817_bat_get_ocv_voltage(battery);
2262 rk817_bat_get_ocv0_voltage0(battery);
2263
2264 rk817_bat_current_calibration(battery);
2265 rk817_bat_get_avg_current(battery);
2266 rk817_bat_get_relax_cur1(battery);
2267 rk817_bat_get_relax_cur2(battery);
2268 rk817_bat_get_relax_current(battery);
2269 rk817_bat_get_ocv_current(battery);
2270 rk817_bat_get_ocv_current0(battery);
2271 rk817_bat_get_pwron_current(battery);
2272 rk817_bat_get_ocv_count(battery);
2273 rk817_bat_save_dsoc(battery, battery->dsoc);
2274 DBG("capactiy = %d\n", rk817_bat_get_capacity_mah(battery));
2275 }
2276
2277 static void
rk817_bat_update_charging_status(struct rk817_battery_device * battery)2278 rk817_bat_update_charging_status(struct rk817_battery_device *battery)
2279 {
2280 int is_charging;
2281
2282 is_charging = rk817_bat_get_charge_state(battery);
2283 if (is_charging == battery->is_charging)
2284 return;
2285
2286 battery->change = true;
2287 battery->is_charging = is_charging;
2288 if (is_charging)
2289 battery->charge_count++;
2290 }
2291
rk817_bat_update_info(struct rk817_battery_device * battery)2292 static void rk817_bat_update_info(struct rk817_battery_device *battery)
2293 {
2294 battery->voltage_avg = rk817_bat_get_battery_voltage(battery);
2295 battery->voltage_sys = rk817_bat_get_sys_voltage(battery);
2296 battery->current_avg = rk817_bat_get_avg_current(battery);
2297 battery->voltage_relax = rk817_bat_get_relax_voltage(battery);
2298 battery->rsoc = rk817_bat_get_rsoc(battery);
2299 battery->remain_cap = rk817_bat_get_capacity_uah(battery);
2300 battery->voltage_usb = rk817_bat_get_USB_voltage(battery);
2301 battery->chrg_status = get_charge_status(battery);
2302 rk817_bat_update_charging_status(battery);
2303 DBG("valtage usb: %d\n", battery->voltage_usb);
2304 DBG("UPDATE: voltage_avg = %d\n"
2305 "voltage_sys = %d\n"
2306 "curren_avg = %d\n"
2307 "rsoc = %d\n"
2308 "chrg_status = %d\n"
2309 "PWRON_CUR = %d\n"
2310 "remain_cap = %d\n",
2311 battery->voltage_avg,
2312 battery->voltage_sys,
2313 battery->current_avg,
2314 battery->rsoc,
2315 battery->chrg_status,
2316 rk817_bat_get_pwron_current(battery),
2317 battery->remain_cap);
2318
2319 /* smooth charge */
2320 if (battery->remain_cap / 1000 > battery->fcc) {
2321 /*battery->sm_remain_cap -=*/
2322 /*(battery->remain_cap - battery->fcc * 1000);*/
2323 battery->sm_remain_cap = battery->fcc * 1000;
2324 DBG("<%s>. cap: remain=%d, sm_remain=%d\n",
2325 __func__, battery->remain_cap, battery->sm_remain_cap);
2326 DBG("fcc: %d\n", battery->fcc);
2327 rk817_bat_init_coulomb_cap(battery, battery->fcc + 100);
2328 rk817_bat_init_coulomb_cap(battery, battery->fcc);
2329 rk817_bat_get_capacity_mah(battery);
2330 }
2331
2332 if (battery->chrg_status != CHARGE_FINISH)
2333 battery->finish_base = get_boot_sec();
2334 }
2335
rk817_bat_save_data(struct rk817_battery_device * battery)2336 static void rk817_bat_save_data(struct rk817_battery_device *battery)
2337 {
2338 rk817_bat_save_dsoc(battery, battery->dsoc);
2339 rk817_bat_save_cap(battery, battery->remain_cap / 1000);
2340 }
2341
2342 /* high load: current < 0 with charger in.
2343 * System will not shutdown while dsoc=0% with charging state(ac_in),
2344 * which will cause over discharge, so oppose status before report states.
2345 */
rk817_bat_lowpwr_check(struct rk817_battery_device * battery)2346 static void rk817_bat_lowpwr_check(struct rk817_battery_device *battery)
2347 {
2348 static u64 time;
2349 int pwr_off_thresd = battery->pdata->pwroff_vol;
2350
2351 if (battery->current_avg < 0 && battery->voltage_avg < pwr_off_thresd) {
2352 if (!time)
2353 time = get_boot_sec();
2354
2355 if ((base2sec(time) > MINUTE(1)) ||
2356 (battery->voltage_avg <= pwr_off_thresd - 50)) {
2357 battery->fake_offline = 1;
2358 if (battery->voltage_avg <= pwr_off_thresd - 50)
2359 battery->dsoc -= 1000;
2360 DBG("low power, soc=%d, current=%d\n",
2361 battery->dsoc, battery->current_avg);
2362 }
2363 } else {
2364 time = 0;
2365 battery->fake_offline = 0;
2366 }
2367
2368 DBG("<%s>. t=%lu, dsoc=%d, current=%d, fake_offline=%d\n",
2369 __func__, base2sec(time), battery->dsoc,
2370 battery->current_avg, battery->fake_offline);
2371 }
2372
rk817_bat_calc_smooth_dischrg(struct rk817_battery_device * battery)2373 static void rk817_bat_calc_smooth_dischrg(struct rk817_battery_device *battery)
2374 {
2375 int tmp_soc = 0;
2376
2377 /* check new dsoc */
2378 if (battery->smooth_soc < 0)
2379 battery->smooth_soc = 0;
2380
2381 tmp_soc = battery->smooth_soc / 1000;
2382
2383 if (tmp_soc != battery->dsoc / 1000) {
2384 if (battery->smooth_soc > battery->dsoc)
2385 return;
2386
2387 if (battery->smooth_soc + 1000 > battery->dsoc)
2388 battery->dsoc = battery->smooth_soc;
2389 else
2390 battery->dsoc -= 1000;
2391
2392 if (battery->dsoc <= 0)
2393 battery->dsoc = 0;
2394 }
2395 }
2396
rk817_bat_smooth_algorithm(struct rk817_battery_device * battery)2397 static void rk817_bat_smooth_algorithm(struct rk817_battery_device *battery)
2398 {
2399 int ydsoc = 0, delta_cap = 0, old_cap = 0, tmp_soc;
2400 /*int linek;*/
2401 int diff, delta;
2402 /*int current_avg = rk817_bat_get_avg_current(battery);*/
2403
2404 delta = abs(battery->dsoc - battery->rsoc);
2405 diff = delta * 3;/* speed:3/4 */
2406
2407 /* charge and discharge switch */
2408 if ((battery->sm_linek * battery->current_avg <= 0)) {
2409 DBG("<%s>. linek mode, retinit sm linek..\n", __func__);
2410 rk817_bat_calc_sm_linek(battery);
2411 }
2412
2413 /*battery->sm_linek = linek;*/
2414
2415 battery->remain_cap = rk817_bat_get_capacity_uah(battery);
2416
2417 old_cap = battery->sm_remain_cap;
2418 DBG("smooth: smooth_soc = %d, dsoc = %d, battery->sm_linek = %d\n",
2419 battery->smooth_soc, battery->dsoc, battery->sm_linek);
2420
2421 /* discharge status: sm_remain_cap > remain_cap, delta_cap > 0 */
2422 /* from charge to discharge:
2423 * remain_cap may be above sm_remain_cap, delta_cap <= 0
2424 */
2425 delta_cap = battery->remain_cap - battery->sm_remain_cap;
2426 DBG("smooth: sm_remain_cap = %d, remain_cap = %d\n",
2427 battery->sm_remain_cap, battery->remain_cap);
2428 DBG("smooth: delta_cap = %d, dsoc = %d\n",
2429 delta_cap, battery->dsoc);
2430
2431 if (delta_cap == 0) {
2432 DBG("<%s>. delta_cap = 0\n", __func__);
2433 return;
2434 }
2435
2436 /* discharge: sm_linek < 0, if delate_cap <0, ydsoc > 0 */
2437 ydsoc = battery->sm_linek * abs(delta_cap / 10) / DIV(battery->fcc);
2438
2439 DBG("smooth: ydsoc = %d, fcc = %d\n", ydsoc, battery->fcc);
2440 if (ydsoc == 0) {
2441 DBG("<%s>. ydsoc = 0\n", __func__);
2442 return;
2443 }
2444 battery->sm_remain_cap = battery->remain_cap;
2445
2446 DBG("<%s>. k=%d, ydsoc=%d; cap:old=%d, new:%d; delta_cap=%d\n",
2447 __func__, battery->sm_linek, ydsoc, old_cap,
2448 battery->sm_remain_cap, delta_cap);
2449
2450 /* discharge mode */
2451 /* discharge mode, but ydsoc > 0,
2452 * from charge status to dischrage
2453 */
2454 battery->smooth_soc += ydsoc;
2455 if (ydsoc < 0) {
2456 rk817_bat_calc_smooth_dischrg(battery);
2457 } else {
2458 if (battery->smooth_soc < 0)
2459 battery->smooth_soc = 0;
2460
2461 tmp_soc = battery->smooth_soc / 1000;
2462
2463 if (tmp_soc != battery->dsoc / 1000) {
2464 if (battery->smooth_soc < battery->dsoc)
2465 return;
2466
2467 battery->dsoc = battery->smooth_soc;
2468 if (battery->dsoc <= 0)
2469 battery->dsoc = 0;
2470 }
2471 }
2472
2473 if (battery->s2r) {
2474 battery->s2r = false;
2475 rk817_bat_calc_sm_linek(battery);
2476 }
2477
2478 DBG("smooth: smooth_soc = %d, dsoc = %d\n",
2479 battery->smooth_soc, battery->dsoc);
2480 DBG("smooth: delta_cap = %d, dsoc = %d\n",
2481 delta_cap, battery->dsoc);
2482 }
2483
rk817_bat_calc_zero_linek(struct rk817_battery_device * battery)2484 static void rk817_bat_calc_zero_linek(struct rk817_battery_device *battery)
2485 {
2486 int dead_voltage, ocv_voltage;
2487 int voltage_avg, current_avg, vsys;
2488 int ocv_cap, dead_cap, xsoc;
2489 int ocv_soc, dead_soc;
2490 int pwroff_vol;
2491 int min_gap_xsoc;
2492 int powerpatch_res;
2493
2494 if ((abs(battery->current_avg) < 400) && (battery->dsoc / 1000 > 5))
2495 pwroff_vol = battery->pdata->pwroff_vol + 50;
2496 else
2497 pwroff_vol = battery->pdata->pwroff_vol;
2498
2499 /* calc estimate ocv voltage */
2500 voltage_avg = rk817_bat_get_battery_voltage(battery);
2501 current_avg = rk817_bat_get_avg_current(battery);
2502 vsys = voltage_avg + (current_avg * DEF_PWRPATH_RES) / 1000;
2503
2504 powerpatch_res = (voltage_avg - vsys) * 1000 / current_avg;
2505
2506 battery->zero_voltage_avg = voltage_avg;
2507 battery->zero_current_avg = current_avg;
2508 battery->zero_vsys = vsys;
2509
2510 DBG("Zero: voltage_avg = %d, Vsys = %d\n", voltage_avg, vsys);
2511 DBG("Zero: powerpatch_res = %d\n", powerpatch_res);
2512 DBG("ZERO0: shtd_vol: poweroff_vol(usr) = %d\n"
2513 "pwroff_vol = %d\n"
2514 "zero_reserve_dsoc = %d\n",
2515 battery->pdata->pwroff_vol,
2516 pwroff_vol,
2517 battery->pdata->zero_reserve_dsoc);
2518
2519 /* get the dead ocv voltage, pwroff_vol is vsys */
2520 dead_voltage = pwroff_vol - current_avg *
2521 (battery->bat_res + DEF_PWRPATH_RES) / 1000;
2522
2523 ocv_voltage = voltage_avg - (current_avg * battery->bat_res) / 1000;
2524 DBG("ZERO0: dead_voltage(shtd) = %d, ocv_voltage(now) = %d\n",
2525 dead_voltage, ocv_voltage);
2526
2527 /* calc estimate soc and cap */
2528 dead_soc = rk817_bat_vol_to_soc(battery, dead_voltage);
2529 dead_cap = rk817_bat_vol_to_cap(battery, dead_voltage);
2530 DBG("ZERO0: dead_soc = %d, dead_cap = %d\n",
2531 dead_soc, dead_cap);
2532
2533 ocv_soc = rk817_bat_vol_to_soc(battery, ocv_voltage);
2534 ocv_cap = rk817_bat_vol_to_cap(battery, ocv_voltage);
2535 DBG("ZERO0: ocv_soc = %d, ocv_cap = %d\n",
2536 ocv_soc, ocv_cap);
2537
2538 /* xsoc: available rsoc */
2539 xsoc = ocv_soc - dead_soc;
2540
2541 battery->zero_dead_voltage = dead_voltage;
2542 battery->zero_dead_soc = dead_soc;
2543 battery->zero_dead_cap = dead_cap;
2544
2545 battery->zero_batvol_to_ocv = ocv_voltage;
2546 battery->zero_batocv_to_soc = ocv_soc;
2547 battery->zero_batocv_to_cap = ocv_cap;
2548
2549 battery->zero_xsoc = xsoc;
2550
2551 DBG("Zero: xsoc = %d\n", xsoc);
2552 /* min_gap_xsoc: reserve xsoc */
2553 if (abs(current_avg) > ZERO_LOAD_LVL1)
2554 min_gap_xsoc = MIN_ZERO_GAP_XSOC3;
2555 else if (abs(current_avg) > ZERO_LOAD_LVL2)
2556 min_gap_xsoc = MIN_ZERO_GAP_XSOC2;
2557 else
2558 min_gap_xsoc = MIN_ZERO_GAP_XSOC1;
2559
2560 if ((xsoc <= 30) &&
2561 (battery->dsoc >= battery->pdata->zero_reserve_dsoc))
2562 min_gap_xsoc = min_gap_xsoc + MIN_ZERO_GAP_CALIB;
2563
2564 battery->zero_remain_cap = battery->remain_cap;
2565 battery->zero_timeout_cnt = 0;
2566 if ((battery->dsoc / 1000 <= 1) && (xsoc > 0)) {
2567 battery->zero_linek = 400;
2568 battery->zero_drop_sec = 0;
2569 } else if (xsoc >= 0) {
2570 battery->zero_drop_sec = 0;
2571 battery->zero_linek =
2572 (battery->zero_dsoc + xsoc / 2) / DIV(xsoc);
2573 /* battery energy mode to use up voltage */
2574 if ((battery->pdata->energy_mode) &&
2575 (xsoc - battery->dsoc / 1000 >= MIN_ZERO_GAP_XSOC3) &&
2576 (battery->dsoc / 1000 <= 10) && (battery->zero_linek < 300)) {
2577 battery->zero_linek = 300;
2578 DBG("ZERO-new: zero_linek adjust step0...\n");
2579 /* reserve enough power yet, slow down any way */
2580 } else if ((xsoc - battery->dsoc / 1000 >= min_gap_xsoc) ||
2581 ((xsoc - battery->dsoc / 1000 >= MIN_ZERO_GAP_XSOC2) &&
2582 (battery->dsoc / 1000 <= 10) && (xsoc > 15))) {
2583 if (xsoc <= 20 &&
2584 battery->dsoc / 1000 >= battery->pdata->zero_reserve_dsoc)
2585 battery->zero_linek = 1200;
2586 else if (xsoc - battery->dsoc / 1000 >= 2 * min_gap_xsoc)
2587 battery->zero_linek = 400;
2588 else if (xsoc - battery->dsoc / 1000 >= 3 + min_gap_xsoc)
2589 battery->zero_linek = 600;
2590 else
2591 battery->zero_linek = 800;
2592 DBG("ZERO-new: zero_linek adjust step1...\n");
2593 /* control zero mode beginning enter */
2594 } else if ((battery->zero_linek > 1800) &&
2595 (battery->dsoc / 1000 > 70)) {
2596 battery->zero_linek = 1800;
2597 DBG("ZERO-new: zero_linek adjust step2...\n");
2598 /* dsoc close to xsoc: it must reserve power */
2599 } else if ((battery->zero_linek > 1000) &&
2600 (battery->zero_linek < 1200)) {
2601 battery->zero_linek = 1200;
2602 DBG("ZERO-new: zero_linek adjust step3...\n");
2603 /* dsoc[5~15], dsoc < xsoc */
2604 } else if ((battery->dsoc / 1000 <= 15 && battery->dsoc > 5) &&
2605 (battery->zero_linek <= 1200)) {
2606 /* slow down */
2607 if ((xsoc - battery->dsoc / 1000) >= min_gap_xsoc)
2608 battery->zero_linek = 800;
2609 /* reserve power */
2610 else
2611 battery->zero_linek = 1200;
2612 DBG("ZERO-new: zero_linek adjust step4...\n");
2613 /* dsoc[5, 100], dsoc < xsoc */
2614 } else if ((battery->zero_linek < 1000) &&
2615 (battery->dsoc / 1000 >= 5)) {
2616 if ((xsoc - battery->dsoc / 1000) < min_gap_xsoc) {
2617 /* reserve power */
2618 battery->zero_linek = 1200;
2619 } else {
2620 if (abs(battery->current_avg) > 500)/* heavy */
2621 battery->zero_linek = 900;
2622 else
2623 battery->zero_linek = 1000;
2624 }
2625 DBG("ZERO-new: zero_linek adjust step5...\n");
2626 /* dsoc[0~5], dsoc < xsoc */
2627 } else if ((battery->zero_linek < 1000) &&
2628 (battery->dsoc / 1000 <= 5)) {
2629 if ((xsoc - battery->dsoc / 1000) <= 3)
2630 battery->zero_linek = 1200;
2631 else
2632 battery->zero_linek = 800;
2633 DBG("ZERO-new: zero_linek adjust step6...\n");
2634 }
2635 } else {
2636 /* xsoc < 0 */
2637 battery->zero_linek = 1000;
2638 if (!battery->zero_drop_sec)
2639 battery->zero_drop_sec = get_boot_sec();
2640 if (base2sec(battery->zero_drop_sec) >= WAIT_DSOC_DROP_SEC) {
2641 DBG("ZERO0: t=%lu\n", base2sec(battery->zero_drop_sec));
2642 battery->zero_drop_sec = 0;
2643 battery->dsoc -= 1000;
2644 if (battery->dsoc < 0)
2645 battery->dsoc = 0;
2646 battery->zero_dsoc = battery->dsoc;
2647 }
2648 }
2649
2650 if (voltage_avg < pwroff_vol - 70) {
2651 if (!battery->shtd_drop_sec)
2652 battery->shtd_drop_sec = get_boot_sec();
2653 if (base2sec(battery->shtd_drop_sec) > WAIT_SHTD_DROP_SEC) {
2654 DBG("voltage extreme low...soc:%d->0\n", battery->dsoc);
2655 battery->shtd_drop_sec = 0;
2656 battery->dsoc = 0;
2657 }
2658 } else {
2659 battery->shtd_drop_sec = 0;
2660 }
2661
2662 DBG("Zero: zero_linek = %d\n", battery->zero_linek);
2663 }
2664
rk817_bat_zero_algo_prepare(struct rk817_battery_device * battery)2665 static void rk817_bat_zero_algo_prepare(struct rk817_battery_device *battery)
2666 {
2667 int tmp_dsoc;
2668
2669 tmp_dsoc = battery->zero_dsoc / 1000;
2670
2671 if (tmp_dsoc != battery->smooth_soc / 1000)
2672 battery->zero_dsoc = battery->smooth_soc;
2673
2674 DBG("zero_smooth: zero_dsoc = %d\n", battery->zero_dsoc);
2675
2676 rk817_bat_calc_zero_linek(battery);
2677 }
2678
rk817_bat_calc_zero_algorithm(struct rk817_battery_device * battery)2679 static void rk817_bat_calc_zero_algorithm(struct rk817_battery_device *battery)
2680 {
2681 int tmp_soc;
2682
2683 tmp_soc = battery->zero_dsoc / 1000;
2684
2685 if (tmp_soc == battery->dsoc / 1000)
2686 return;
2687
2688 if (battery->zero_dsoc > battery->dsoc)
2689 return;
2690
2691 if (battery->zero_dsoc < battery->dsoc - 1000)
2692 battery->dsoc -= 1000;
2693 else
2694 battery->dsoc = battery->zero_dsoc;
2695 }
2696
rk817_bat_zero_algorithm(struct rk817_battery_device * battery)2697 static void rk817_bat_zero_algorithm(struct rk817_battery_device *battery)
2698 {
2699 int delta_cap = 0, delta_soc = 0;
2700
2701 battery->zero_timeout_cnt++;
2702 delta_cap = battery->zero_remain_cap - battery->remain_cap;
2703 delta_soc = battery->zero_linek * delta_cap / DIV(battery->fcc) / 10;
2704
2705 DBG("zero algorithm start\n");
2706 DBG("DEAD: dead_voltage: %d\n"
2707 "dead_soc: %d\n"
2708 "dead_cap: %d\n"
2709 "powoff_vol: %d\n",
2710 battery->zero_dead_voltage,
2711 battery->zero_dead_soc,
2712 battery->zero_dead_cap,
2713 battery->pdata->pwroff_vol);
2714 DBG("DEAD: bat_voltage: %d\n"
2715 "bat_current: %d\n"
2716 "batvol_to_ocv: %d\n"
2717 "batocv_to_soc: %d\n"
2718 "batocv_to_cap: %d\n",
2719 battery->zero_voltage_avg,
2720 battery->zero_current_avg,
2721 battery->zero_batvol_to_ocv,
2722 battery->zero_batocv_to_soc,
2723 battery->zero_batocv_to_cap);
2724 DBG("DEAD: Xsoc: %d, zero_reserve_dsoc: %d\n",
2725 battery->zero_xsoc, battery->pdata->zero_reserve_dsoc);
2726 DBG("CAP: zero_remain_cap = %d, remain_cap = %d\n",
2727 battery->zero_remain_cap, battery->remain_cap);
2728 DBG("Zero: zero_delta_cap = %d, zero_link = %d, delta_soc = %d\n",
2729 delta_cap, battery->zero_linek, delta_soc);
2730 DBG("zero algorithm end\n");
2731
2732 if ((delta_soc >= MIN_ZERO_DSOC_ACCURACY) ||
2733 (battery->zero_timeout_cnt > MIN_ZERO_OVERCNT) ||
2734 (battery->zero_linek == 0)) {
2735 DBG("ZERO1:--------- enter calc -----------\n");
2736 battery->zero_timeout_cnt = 0;
2737 battery->zero_dsoc -= delta_soc;
2738 rk817_bat_calc_zero_algorithm(battery);
2739 DBG("Zero: dsoc: %d\n", battery->dsoc);
2740 rk817_bat_calc_zero_linek(battery);
2741 }
2742
2743 if ((battery->rsoc / 1000 < 1) &&
2744 (battery->zero_batocv_to_cap > battery->fcc / 100)) {
2745 DBG("ZERO2:---------check step1 -----------\n");
2746 rk817_bat_init_coulomb_cap(battery,
2747 battery->zero_batocv_to_cap);
2748 rk817_bat_calc_zero_linek(battery);
2749 }
2750 }
2751
rk817_bat_finish_algorithm(struct rk817_battery_device * battery)2752 static void rk817_bat_finish_algorithm(struct rk817_battery_device *battery)
2753 {
2754 unsigned long finish_sec, soc_sec;
2755 int plus_soc, finish_current, rest = 0;
2756
2757 /* rsoc */
2758 if ((battery->remain_cap != battery->fcc) &&
2759 (get_charge_status(battery) == CHARGE_FINISH)) {
2760 battery->age_adjust_cap +=
2761 (battery->fcc * 1000 - battery->remain_cap);
2762 rk817_bat_init_coulomb_cap(battery, battery->fcc);
2763 rk817_bat_get_capacity_mah(battery);
2764 }
2765
2766 /* dsoc */
2767 if (battery->dsoc < 100 * 1000) {
2768 if (!battery->finish_base)
2769 battery->finish_base = get_boot_sec();
2770
2771 finish_current = (battery->rsoc - battery->dsoc) > FINISH_MAX_SOC_DELAY ?
2772 FINISH_CHRG_CUR2 : FINISH_CHRG_CUR1;
2773 finish_sec = base2sec(battery->finish_base);
2774
2775 soc_sec = battery->fcc * 3600 / 100 / DIV(finish_current);
2776 plus_soc = finish_sec / DIV(soc_sec);
2777 if (finish_sec > soc_sec) {
2778 rest = finish_sec % soc_sec;
2779 battery->dsoc += plus_soc * 1000;
2780 battery->finish_base = get_boot_sec();
2781 if (battery->finish_base > rest)
2782 battery->finish_base = get_boot_sec() - rest;
2783 }
2784 DBG("CHARGE_FINISH:dsoc<100,dsoc=%d\n"
2785 "soc_time=%lu, sec_finish=%lu, plus_soc=%d, rest=%d\n",
2786 battery->dsoc, soc_sec, finish_sec, plus_soc, rest);
2787 DBG("battery->age_adjust_cap = %d\n", battery->age_adjust_cap);
2788 }
2789 }
2790
rk817_bat_display_smooth(struct rk817_battery_device * battery)2791 static void rk817_bat_display_smooth(struct rk817_battery_device *battery)
2792 {
2793 /* discharge: reinit "zero & smooth" algorithm to avoid handling dsoc */
2794 if (battery->s2r && !battery->sleep_chrg_online) {
2795 DBG("s2r: discharge, reset algorithm...\n");
2796 battery->s2r = false;
2797 rk817_bat_zero_algo_prepare(battery);
2798 rk817_bat_smooth_algo_prepare(battery);
2799 return;
2800 }
2801
2802 if (battery->work_mode == MODE_FINISH) {
2803 DBG("step1: charge finish...\n");
2804 rk817_bat_finish_algorithm(battery);
2805
2806 if ((get_charge_status(battery) != CHARGE_FINISH) &&
2807 !rk817_bat_fake_finish_mode(battery)) {
2808 if ((battery->current_avg < 0) &&
2809 (battery->voltage_avg < battery->pdata->zero_algorithm_vol)) {
2810 DBG("step1: change to zero mode...\n");
2811 rk817_bat_zero_algo_prepare(battery);
2812 battery->work_mode = MODE_ZERO;
2813 } else {
2814 DBG("step1: change to smooth mode...\n");
2815 rk817_bat_smooth_algo_prepare(battery);
2816 battery->work_mode = MODE_SMOOTH;
2817 }
2818 }
2819 } else if (battery->work_mode == MODE_ZERO) {
2820 DBG("step2: zero algorithm...\n");
2821 rk817_bat_zero_algorithm(battery);
2822 if ((battery->voltage_avg >=
2823 battery->pdata->zero_algorithm_vol + 50) ||
2824 (battery->current_avg >= 0)) {
2825 DBG("step2: change to smooth mode...\n");
2826 rk817_bat_smooth_algo_prepare(battery);
2827 battery->work_mode = MODE_SMOOTH;
2828 } else if ((get_charge_status(battery) == CHARGE_FINISH) ||
2829 rk817_bat_fake_finish_mode(battery)) {
2830 DBG("step2: change to finish mode...\n");
2831 rk817_bat_finish_algo_prepare(battery);
2832 battery->work_mode = MODE_FINISH;
2833 }
2834 } else {
2835 DBG("step3: smooth algorithm...\n");
2836 rk817_bat_smooth_algorithm(battery);
2837 if ((battery->current_avg < 0) &&
2838 (battery->voltage_avg <
2839 battery->pdata->zero_algorithm_vol)) {
2840 DBG("step3: change to zero mode...\n");
2841 rk817_bat_zero_algo_prepare(battery);
2842 battery->work_mode = MODE_ZERO;
2843 } else if ((get_charge_status(battery) == CHARGE_FINISH) ||
2844 rk817_bat_fake_finish_mode(battery)) {
2845 DBG("step3: change to finish mode...\n");
2846 rk817_bat_finish_algo_prepare(battery);
2847 battery->work_mode = MODE_FINISH;
2848 }
2849 }
2850 }
2851
rk817_bat_output_info(struct rk817_battery_device * battery)2852 static void rk817_bat_output_info(struct rk817_battery_device *battery)
2853 {
2854 DBG("info start:\n");
2855 DBG("info: voltage_k = %d\n", battery->voltage_k);
2856 DBG("info: voltage_b = %d\n", battery->voltage_b);
2857 DBG("info: voltage = %d\n", battery->voltage_avg);
2858 DBG("info: voltage_sys = %d\n", battery->voltage_sys);
2859 DBG("info: current = %d\n", battery->current_avg);
2860
2861 DBG("info: FCC = %d\n", battery->fcc);
2862 DBG("info: remain_cap = %d\n", battery->remain_cap);
2863 DBG("info: sm_remain_cap = %d\n", battery->sm_remain_cap);
2864 DBG("info: sm_link = %d\n", battery->sm_linek);
2865 DBG("info: smooth_soc = %d\n", battery->smooth_soc);
2866
2867 DBG("info: zero_remain_cap = %d\n", battery->zero_remain_cap);
2868 DBG("info: zero_link = %d\n", battery->zero_linek);
2869 DBG("info: zero_dsoc = %d\n", battery->zero_dsoc);
2870
2871 DBG("info: remain_cap = %d\n", battery->remain_cap);
2872 DBG("info: dsoc = %d, dsoc/1000 = %d\n",
2873 battery->dsoc, battery->dsoc / 1000);
2874 DBG("info: rsoc = %d\n", battery->rsoc);
2875 DBG("info END.\n");
2876 }
2877
rk817_battery_work(struct work_struct * work)2878 static void rk817_battery_work(struct work_struct *work)
2879 {
2880 struct rk817_battery_device *battery =
2881 container_of(work,
2882 struct rk817_battery_device,
2883 bat_delay_work.work);
2884
2885 rk817_bat_update_info(battery);
2886 rk817_bat_lowpwr_check(battery);
2887 rk817_bat_display_smooth(battery);
2888 rk817_bat_power_supply_changed(battery);
2889 rk817_bat_save_data(battery);
2890 rk817_bat_output_info(battery);
2891
2892 if (rk817_bat_field_read(battery, CUR_CALIB_UPD)) {
2893 rk817_bat_current_calibration(battery);
2894 rk817_bat_init_voltage_kb(battery);
2895 rk817_bat_field_write(battery, CUR_CALIB_UPD, 0x01);
2896 }
2897
2898 queue_delayed_work(battery->bat_monitor_wq, &battery->bat_delay_work,
2899 msecs_to_jiffies(battery->monitor_ms));
2900 }
2901
rk809_plug_in_isr(int irq,void * cg)2902 static irqreturn_t rk809_plug_in_isr(int irq, void *cg)
2903 {
2904 struct rk817_battery_device *battery;
2905
2906 battery = (struct rk817_battery_device *)cg;
2907 battery->plugin_trigger = 1;
2908 battery->plugout_trigger = 0;
2909 power_supply_changed(battery->bat);
2910 if (battery->is_register_chg_psy)
2911 power_supply_changed(battery->chg_psy);
2912
2913 return IRQ_HANDLED;
2914 }
2915
rk809_plug_out_isr(int irq,void * cg)2916 static irqreturn_t rk809_plug_out_isr(int irq, void *cg)
2917 {
2918 struct rk817_battery_device *battery;
2919
2920 battery = (struct rk817_battery_device *)cg;
2921 battery->plugin_trigger = 0;
2922 battery->plugout_trigger = 1;
2923 power_supply_changed(battery->bat);
2924 if (battery->is_register_chg_psy)
2925 power_supply_changed(battery->chg_psy);
2926
2927 return IRQ_HANDLED;
2928 }
2929
rk809_charge_init_irqs(struct rk817_battery_device * battery)2930 static int rk809_charge_init_irqs(struct rk817_battery_device *battery)
2931 {
2932 struct rk808 *rk817 = battery->rk817;
2933 struct platform_device *pdev = battery->pdev;
2934 int ret, plug_in_irq, plug_out_irq;
2935
2936 battery->plugin_trigger = 0;
2937 battery->plugout_trigger = 0;
2938
2939 plug_in_irq = regmap_irq_get_virq(rk817->irq_data, RK817_IRQ_PLUG_IN);
2940 if (plug_in_irq < 0) {
2941 dev_err(battery->dev, "plug_in_irq request failed!\n");
2942 return plug_in_irq;
2943 }
2944
2945 plug_out_irq = regmap_irq_get_virq(rk817->irq_data, RK817_IRQ_PLUG_OUT);
2946 if (plug_out_irq < 0) {
2947 dev_err(battery->dev, "plug_out_irq request failed!\n");
2948 return plug_out_irq;
2949 }
2950
2951 ret = devm_request_threaded_irq(battery->dev, plug_in_irq, NULL,
2952 rk809_plug_in_isr,
2953 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
2954 "rk817_plug_in", battery);
2955 if (ret) {
2956 dev_err(&pdev->dev, "plug_in_irq request failed!\n");
2957 return ret;
2958 }
2959
2960 ret = devm_request_threaded_irq(battery->dev, plug_out_irq, NULL,
2961 rk809_plug_out_isr,
2962 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
2963 "rk817_plug_out", battery);
2964 if (ret) {
2965 dev_err(&pdev->dev, "plug_out_irq request failed!\n");
2966 return ret;
2967 }
2968
2969 if (rk817_bat_field_read(battery, PLUG_IN_STS)) {
2970 battery->plugin_trigger = 1;
2971 battery->plugout_trigger = 0;
2972 }
2973
2974 return 0;
2975 }
2976
2977 #ifdef CONFIG_OF
2978 static const struct of_device_id rk817_bat_of_match[] = {
2979 { .compatible = "rk817,battery", },
2980 { },
2981 };
2982 MODULE_DEVICE_TABLE(of, rk817_bat_of_match);
2983 #else
2984 static const struct of_device_id rk817_bat_of_match[] = {
2985 { },
2986 };
2987 #endif
2988
rk817_battery_probe(struct platform_device * pdev)2989 static int rk817_battery_probe(struct platform_device *pdev)
2990 {
2991 const struct of_device_id *of_id =
2992 of_match_device(rk817_bat_of_match, &pdev->dev);
2993 struct rk817_battery_device *battery;
2994 struct rk808 *rk817 = dev_get_drvdata(pdev->dev.parent);
2995 struct i2c_client *client = rk817->i2c;
2996 int i, ret;
2997
2998 if (!of_id) {
2999 dev_err(&pdev->dev, "Failed to find matching dt id\n");
3000 return -ENODEV;
3001 }
3002
3003 battery = devm_kzalloc(&client->dev, sizeof(*battery), GFP_KERNEL);
3004 if (!battery)
3005 return -EINVAL;
3006
3007 battery->rk817 = rk817;
3008 battery->client = client;
3009 battery->dev = &pdev->dev;
3010 platform_set_drvdata(pdev, battery);
3011 battery->chip_id = rk817->variant;
3012
3013 battery->regmap = rk817->regmap;
3014 if (IS_ERR(battery->regmap)) {
3015 dev_err(battery->dev, "Failed to initialize regmap\n");
3016 return -EINVAL;
3017 }
3018
3019 for (i = 0; i < ARRAY_SIZE(rk817_battery_reg_fields); i++) {
3020 const struct reg_field *reg_fields = rk817_battery_reg_fields;
3021
3022 battery->rmap_fields[i] =
3023 devm_regmap_field_alloc(battery->dev,
3024 battery->regmap,
3025 reg_fields[i]);
3026 if (IS_ERR(battery->rmap_fields[i])) {
3027 dev_err(battery->dev, "cannot allocate regmap field\n");
3028 return PTR_ERR(battery->rmap_fields[i]);
3029 }
3030 }
3031
3032 ret = rk817_bat_parse_dt(battery);
3033 if (ret < 0) {
3034 dev_err(battery->dev, "battery parse dt failed!\n");
3035 return ret;
3036 }
3037
3038 rk817_bat_init_info(battery);
3039 rk817_bat_init_fg(battery);
3040
3041 rk817_battery_debug_info(battery);
3042 rk817_bat_update_info(battery);
3043
3044 rk817_bat_output_info(battery);
3045 battery->bat_monitor_wq = alloc_ordered_workqueue("%s",
3046 WQ_MEM_RECLAIM | WQ_FREEZABLE, "rk817-bat-monitor-wq");
3047 INIT_DELAYED_WORK(&battery->bat_delay_work, rk817_battery_work);
3048 queue_delayed_work(battery->bat_monitor_wq, &battery->bat_delay_work,
3049 msecs_to_jiffies(TIMER_MS_COUNTS * 5));
3050 INIT_WORK(&battery->resume_work, rk817_bat_resume_work);
3051
3052 ret = rk817_bat_init_power_supply(battery);
3053 if (ret) {
3054 dev_err(battery->dev, "rk817 power supply register failed!\n");
3055 return ret;
3056 }
3057 if (battery->is_register_chg_psy) {
3058 ret = rk809_chg_init_power_supply(battery);
3059 if (ret) {
3060 dev_err(battery->dev, "rk809 chg psy init failed!\n");
3061 return ret;
3062 }
3063 }
3064
3065 if (battery->chip_id == RK809_ID)
3066 rk809_charge_init_irqs(battery);
3067
3068 wake_lock_init(&battery->wake_lock, WAKE_LOCK_SUSPEND,
3069 "rk817_bat_lock");
3070
3071 DBG("name: 0x%x", rk817_bat_field_read(battery, CHIP_NAME_H));
3072 DBG("%x\n", rk817_bat_field_read(battery, CHIP_NAME_L));
3073 DBG("driver version %s\n", DRIVER_VERSION);
3074
3075 return 0;
3076 }
3077
rk817_battery_shutdown(struct platform_device * dev)3078 static void rk817_battery_shutdown(struct platform_device *dev)
3079 {
3080 }
3081
rk817_get_rtc_sec(void)3082 static time64_t rk817_get_rtc_sec(void)
3083 {
3084 int err;
3085 struct rtc_time tm;
3086 struct rtc_device *rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
3087
3088 err = rtc_read_time(rtc, &tm);
3089 if (err) {
3090 dev_err(rtc->dev.parent, "read hardware clk failed\n");
3091 return 0;
3092 }
3093
3094 err = rtc_valid_tm(&tm);
3095 if (err) {
3096 dev_err(rtc->dev.parent, "invalid date time\n");
3097 return 0;
3098 }
3099
3100 return rtc_tm_to_time64(&tm);
3101 }
3102
3103 #ifdef CONFIG_PM_SLEEP
rk817_bat_pm_suspend(struct device * dev)3104 static int rk817_bat_pm_suspend(struct device *dev)
3105 {
3106 struct platform_device *pdev = to_platform_device(dev);
3107 struct rk817_battery_device *battery = dev_get_drvdata(&pdev->dev);
3108
3109 cancel_delayed_work_sync(&battery->bat_delay_work);
3110
3111 battery->s2r = false;
3112 battery->sleep_chrg_status = get_charge_status(battery);
3113 battery->current_avg = rk817_bat_get_avg_current(battery);
3114 if (battery->current_avg > 0 ||
3115 (battery->sleep_chrg_status == CC_OR_CV_CHRG) ||
3116 (battery->sleep_chrg_status == CHARGE_FINISH))
3117 battery->sleep_chrg_online = 1;
3118 else
3119 battery->sleep_chrg_online = 0;
3120
3121 battery->remain_cap = rk817_bat_get_capacity_uah(battery);
3122 battery->rsoc = rk817_bat_get_rsoc(battery);
3123
3124 battery->rtc_base = rk817_get_rtc_sec();
3125 rk817_bat_save_data(battery);
3126
3127 if (battery->sleep_chrg_status != CHARGE_FINISH)
3128 battery->finish_base = get_boot_sec();
3129
3130 if ((battery->work_mode == MODE_ZERO) &&
3131 (battery->current_avg >= 0)) {
3132 DBG("suspend: MODE_ZERO exit...\n");
3133 /* it need't do prepare for mode finish and smooth, it will
3134 * be done in display_smooth
3135 */
3136 if (battery->sleep_chrg_status == CHARGE_FINISH) {
3137 battery->work_mode = MODE_FINISH;
3138 battery->finish_base = get_boot_sec();
3139 } else {
3140 battery->work_mode = MODE_SMOOTH;
3141 rk817_bat_smooth_algo_prepare(battery);
3142 }
3143 }
3144
3145 DBG("suspend get_boot_sec: %lld\n", get_boot_sec());
3146
3147 DBG("suspend: dl=%d rl=%d c=%d v=%d cap=%d at=%ld ch=%d\n",
3148 battery->dsoc, battery->rsoc, battery->current_avg,
3149 rk817_bat_get_battery_voltage(battery),
3150 rk817_bat_get_capacity_uah(battery),
3151 battery->sleep_dischrg_sec, battery->sleep_chrg_online);
3152 DBG("battery->sleep_chrg_status=%d\n", battery->sleep_chrg_status);
3153
3154 return 0;
3155 }
3156
rk817_bat_rtc_sleep_sec(struct rk817_battery_device * battery)3157 static int rk817_bat_rtc_sleep_sec(struct rk817_battery_device *battery)
3158 {
3159 int interval_sec;
3160
3161 interval_sec = rk817_get_rtc_sec() - battery->rtc_base;
3162
3163 return (interval_sec > 0) ? interval_sec : 0;
3164 }
3165
rk817_bat_relife_age_flag(struct rk817_battery_device * battery)3166 static void rk817_bat_relife_age_flag(struct rk817_battery_device *battery)
3167 {
3168 u8 ocv_soc, ocv_cap, soc_level;
3169
3170 if (battery->voltage_relax <= 0)
3171 return;
3172
3173 ocv_soc = rk817_bat_vol_to_soc(battery, battery->voltage_relax);
3174 ocv_cap = rk817_bat_vol_to_cap(battery, battery->voltage_relax);
3175 DBG("<%s>. ocv_soc=%d, min=%lu, vol=%d\n", __func__,
3176 ocv_soc, battery->sleep_dischrg_sec / 60, battery->voltage_relax);
3177
3178 /* sleep enough time and ocv_soc enough low */
3179 if (!battery->age_allow_update && ocv_soc <= 10) {
3180 battery->age_voltage = battery->voltage_relax;
3181 battery->age_ocv_cap = ocv_cap;
3182 battery->age_ocv_soc = ocv_soc;
3183 battery->age_adjust_cap = 0;
3184
3185 if (ocv_soc <= 1)
3186 battery->age_level = 100;
3187 else if (ocv_soc < 5)
3188 battery->age_level = 90;
3189 else
3190 battery->age_level = 80;
3191
3192 /*soc_level = rk818_bat_get_age_level(battery);*/
3193 soc_level = 0;
3194 if (soc_level > battery->age_level) {
3195 battery->age_allow_update = false;
3196 } else {
3197 battery->age_allow_update = true;
3198 battery->age_keep_sec = get_boot_sec();
3199 }
3200
3201 BAT_INFO("resume: age_vol:%d, age_ocv_cap:%d, age_ocv_soc:%d, "
3202 "soc_level:%d, age_allow_update:%d, "
3203 "age_level:%d\n",
3204 battery->age_voltage, battery->age_ocv_cap,
3205 ocv_soc, soc_level,
3206 battery->age_allow_update, battery->age_level);
3207 }
3208 }
3209
rk817_bat_init_capacity(struct rk817_battery_device * battery,u32 cap)3210 static void rk817_bat_init_capacity(struct rk817_battery_device *battery,
3211 u32 cap)
3212 {
3213 int delta_cap;
3214
3215 delta_cap = cap - battery->remain_cap;
3216 if (!delta_cap)
3217 return;
3218
3219 battery->age_adjust_cap += delta_cap;
3220 rk817_bat_init_coulomb_cap(battery, cap);
3221 rk817_bat_smooth_algo_prepare(battery);
3222 rk817_bat_zero_algo_prepare(battery);
3223 }
3224
rk817_bat_relax_vol_calib(struct rk817_battery_device * battery)3225 static void rk817_bat_relax_vol_calib(struct rk817_battery_device *battery)
3226 {
3227 int soc, cap, vol;
3228
3229 vol = battery->voltage_relax;
3230 soc = rk817_bat_vol_to_soc(battery, vol);
3231 cap = rk817_bat_vol_to_cap(battery, vol);
3232 rk817_bat_init_capacity(battery, cap);
3233 BAT_INFO("sleep ocv calib: rsoc=%d, cap=%d\n", soc, cap);
3234 }
3235
rk817_bat_sleep_dischrg(struct rk817_battery_device * battery)3236 static int rk817_bat_sleep_dischrg(struct rk817_battery_device *battery)
3237 {
3238 bool ocv_soc_updated = false;
3239 int tgt_dsoc, gap_soc, sleep_soc = 0;
3240 int pwroff_vol = battery->pdata->pwroff_vol;
3241 unsigned long sleep_sec = battery->sleep_dischrg_sec;
3242 int sleep_cur;
3243
3244 DBG("<%s>. enter: dsoc=%d, rsoc=%d, rv=%d, v=%d, sleep_min=%lu\n",
3245 __func__, battery->dsoc, battery->rsoc, battery->voltage_relax,
3246 battery->voltage_avg, sleep_sec / 60);
3247
3248 if (battery->voltage_relax >= battery->voltage_avg) {
3249 rk817_bat_relax_vol_calib(battery);
3250 rk817_bat_restart_relax(battery);
3251 rk817_bat_relife_age_flag(battery);
3252 ocv_soc_updated = true;
3253 }
3254
3255 /* handle dsoc */
3256 if (battery->dsoc <= battery->rsoc) {
3257 if (battery->pdata->low_pwr_sleep)
3258 sleep_cur = LOW_PWR_SLP_CURR_MIN;
3259 else
3260 sleep_cur = SLP_CURR_MIN;
3261 battery->sleep_sum_cap = (sleep_cur * sleep_sec / 3600);
3262 sleep_soc = battery->sleep_sum_cap * 100 / DIV(battery->fcc);
3263 tgt_dsoc = battery->dsoc - sleep_soc * 1000;
3264 if (sleep_soc > 0) {
3265 BAT_INFO("calib0: rl=%d, dl=%d, intval=%d\n",
3266 battery->rsoc, battery->dsoc, sleep_soc);
3267 if (battery->dsoc / 1000 < 5) {
3268 battery->dsoc -= 1000;
3269 } else if ((tgt_dsoc / 1000 < 5) &&
3270 (battery->dsoc / 1000 >= 5)) {
3271 if (battery->dsoc / 1000 == 5)
3272 battery->dsoc -= 1000;
3273 else
3274 battery->dsoc = 5 * 1000;
3275 } else if (tgt_dsoc / 1000 > 5) {
3276 battery->dsoc = tgt_dsoc;
3277 }
3278 }
3279
3280 DBG("%s: dsoc<=rsoc, sum_cap=%d==>sleep_soc=%d, tgt_dsoc=%d\n",
3281 __func__, battery->sleep_sum_cap, sleep_soc, tgt_dsoc);
3282 } else {
3283 /* di->dsoc > di->rsoc */
3284 if (battery->pdata->low_pwr_sleep)
3285 sleep_cur = LOW_PWR_SLP_CURR_MAX;
3286 else
3287 sleep_cur = SLP_CURR_MAX;
3288 battery->sleep_sum_cap = (sleep_cur * sleep_sec / 3600);
3289 sleep_soc = battery->sleep_sum_cap / DIV(battery->fcc / 100);
3290 gap_soc = battery->dsoc - battery->rsoc;
3291
3292 DBG("calib1: rsoc=%d, dsoc=%d, intval=%d\n",
3293 battery->rsoc, battery->dsoc, sleep_soc);
3294 if (gap_soc / 1000 > sleep_soc) {
3295 if ((gap_soc - 5000) > (sleep_soc * 2 * 1000))
3296 battery->dsoc -= (sleep_soc * 2 * 1000);
3297 else
3298 battery->dsoc -= sleep_soc * 1000;
3299 } else {
3300 battery->dsoc = battery->rsoc;
3301 }
3302
3303 DBG("%s: dsoc>rsoc, sum_cap=%d=>sleep_soc=%d, gap_soc=%d\n",
3304 __func__, battery->sleep_sum_cap, sleep_soc, gap_soc);
3305 }
3306
3307 if (battery->voltage_avg <= pwroff_vol - 70) {
3308 battery->dsoc = 0;
3309 DBG("low power sleeping, shutdown... %d\n", battery->dsoc);
3310 }
3311
3312 if (ocv_soc_updated && sleep_soc &&
3313 (battery->rsoc - battery->dsoc) < 5000 &&
3314 battery->dsoc < 40 * 1000) {
3315 battery->dsoc -= 1000;
3316 DBG("low power sleeping, reserved... %d\n", battery->dsoc);
3317 }
3318
3319 if (battery->dsoc <= 0) {
3320 battery->dsoc = 0;
3321 DBG("sleep dsoc is %d...\n", battery->dsoc);
3322 }
3323
3324 DBG("<%s>. out: dsoc=%d, rsoc=%d, sum_cap=%d\n",
3325 __func__, battery->dsoc, battery->rsoc, battery->sleep_sum_cap);
3326
3327 return sleep_soc;
3328 }
3329
rk817_bat_resume_work(struct work_struct * work)3330 static void rk817_bat_resume_work(struct work_struct *work)
3331 {
3332 struct rk817_battery_device *battery = container_of(work, struct rk817_battery_device, resume_work);
3333 int interval_sec = 0, time_step = 0, pwroff_vol;
3334
3335 battery->s2r = true;
3336 battery->current_avg = rk817_bat_get_avg_current(battery);
3337 battery->voltage_relax = rk817_bat_get_relax_voltage(battery);
3338 battery->voltage_avg = rk817_bat_get_battery_voltage(battery);
3339 battery->remain_cap = rk817_bat_get_capacity_uah(battery);
3340 battery->rsoc = rk817_bat_get_rsoc(battery);
3341 interval_sec = rk817_bat_rtc_sleep_sec(battery);
3342 battery->sleep_sum_sec += interval_sec;
3343 pwroff_vol = battery->pdata->pwroff_vol;
3344
3345 if (!battery->sleep_chrg_online) {
3346 /* only add up discharge sleep seconds */
3347 battery->sleep_dischrg_sec += interval_sec;
3348 if (battery->voltage_avg <= pwroff_vol + 50)
3349 time_step = DISCHRG_TIME_STEP1;
3350 else
3351 time_step = DISCHRG_TIME_STEP2;
3352 }
3353
3354 DBG("resume: dl=%d rl=%d c=%d v=%d rv=%d "
3355 "cap=%d dt=%d at=%ld ch=%d, sec = %d\n",
3356 battery->dsoc, battery->rsoc, battery->current_avg,
3357 battery->voltage_avg, battery->voltage_relax,
3358 rk817_bat_get_capacity_uah(battery), interval_sec,
3359 battery->sleep_dischrg_sec, battery->sleep_chrg_online,
3360 interval_sec);
3361
3362 /* sleep: enough time and discharge */
3363 if ((!battery->sleep_chrg_online) &&
3364 (battery->sleep_dischrg_sec > time_step)) {
3365 if (rk817_bat_sleep_dischrg(battery))
3366 battery->sleep_dischrg_sec = 0;
3367 }
3368
3369 rk817_bat_save_data(battery);
3370
3371 /* charge/lowpower lock: for battery work to update dsoc and rsoc */
3372 if ((battery->sleep_chrg_online) ||
3373 (!battery->sleep_chrg_online &&
3374 battery->voltage_avg < battery->pdata->pwroff_vol))
3375 wake_lock_timeout(&battery->wake_lock, msecs_to_jiffies(2000));
3376
3377 queue_delayed_work(battery->bat_monitor_wq, &battery->bat_delay_work,
3378 msecs_to_jiffies(1000));
3379 }
3380
rk817_bat_pm_resume(struct device * dev)3381 static int rk817_bat_pm_resume(struct device *dev)
3382 {
3383 struct rk817_battery_device *battery = dev_get_drvdata(dev);
3384
3385 queue_work(battery->bat_monitor_wq, &battery->resume_work);
3386
3387 return 0;
3388 }
3389 #endif
3390
3391 static SIMPLE_DEV_PM_OPS(rk817_bat_pm_ops,
3392 rk817_bat_pm_suspend,
3393 rk817_bat_pm_resume);
3394
3395 static struct platform_driver rk817_battery_driver = {
3396 .probe = rk817_battery_probe,
3397 .shutdown = rk817_battery_shutdown,
3398 .driver = {
3399 .name = "rk817-battery",
3400 .pm = &rk817_bat_pm_ops,
3401 .of_match_table = of_match_ptr(rk817_bat_of_match),
3402 },
3403 };
3404
rk817_battery_init(void)3405 static int __init rk817_battery_init(void)
3406 {
3407 return platform_driver_register(&rk817_battery_driver);
3408 }
3409 fs_initcall_sync(rk817_battery_init);
3410
rk817_battery_exit(void)3411 static void __exit rk817_battery_exit(void)
3412 {
3413 platform_driver_unregister(&rk817_battery_driver);
3414 }
3415 module_exit(rk817_battery_exit);
3416
3417 MODULE_DESCRIPTION("RK817 Battery driver");
3418 MODULE_LICENSE("GPL");
3419