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