1 /*
2 * (C) Copyright 2018 Rockchip Electronics Co., Ltd
3 *
4 * SPDX-License-Identifier: GPL-2.0+
5 */
6 #include <dm.h>
7 #include <errno.h>
8 #include <common.h>
9 #include <malloc.h>
10 #include <fdtdec.h>
11 #include <asm/gpio.h>
12 #include <common.h>
13 #include <power/pmic.h>
14 #include <dm/uclass-internal.h>
15 #include <power/charge_display.h>
16 #include <power/charge_animation.h>
17 #include <power/fuel_gauge.h>
18 #include <power/rk8xx_pmic.h>
19 #include <linux/usb/phy-rockchip-usb2.h>
20
21 DECLARE_GLOBAL_DATA_PTR;
22
23 static int dbg_enable = 0;
24 #define DBG(args...) \
25 do { \
26 if (dbg_enable) { \
27 printf(args); \
28 } \
29 } while (0)
30
31 #define DIV(value) ((value) ? (value) : 1)
32 #define ENABLE 0x01
33 #define DISABLE 0x00
34 #define MAX_INTERPOLATE 1000
35 #define MAX_PERCENTAGE 100
36 #define MAX_INT 0x7FFF
37
38 #define ADC_CONFIG0 0x0050
39 #define CUR_ADC_CFG0 0x0051
40 #define CUR_ADC_CFG1 0x0052
41 #define VOL_ADC_CFG0 0x0053
42 #define VOL_ADC_CFG1 0x0054
43 #define ADC_CONFIG1 0x0055
44 #define GG_CON 0x0056
45 #define GG_STS 0x0057
46 #define RELAX_THRE_H 0x0058
47 #define RELAX_THRE_L 0x0059
48 #define RELAX_VOL1_H 0x005a
49 #define RELAX_VOL1_L 0x005b
50 #define RELAX_VOL2_H 0x005c
51 #define RELAX_VOL2_L 0x005d
52 #define RELAX_CUR1_H 0x005e
53 #define RELAX_CUR1_L 0x005f
54 #define RELAX_CUR2_H 0x0060
55 #define RELAX_CUR2_L 0x0061
56 #define OCV_THRE_VOL 0x0062
57 #define OCV_VOL_H 0x0063
58 #define OCV_VOL_L 0x0064
59 #define OCV_VOL0_H 0x0065
60 #define OCV_VOL0_L 0x0066
61 #define OCV_CUR_H 0x0067
62 #define OCV_CUR_L 0x0068
63 #define OCV_CUR0_H 0x0069
64 #define OCV_CUR0_L 0x006a
65 #define PWRON_VOL_H 0x006b
66 #define PWRON_VOL_L 0x006c
67 #define PWRON_CUR_H 0x006d
68 #define PWRON_CUR_L 0x006e
69 #define OFF_CNT 0x006f
70 #define Q_INIT_H3 0x0070
71 #define Q_INIT_H2 0x0071
72 #define Q_INIT_L1 0x0072
73 #define Q_INIT_L0 0x0073
74 #define Q_PRES_H3 0x0074
75 #define Q_PRES_H2 0x0075
76 #define Q_PRES_L1 0x0076
77 #define Q_PRES_L0 0x0077
78 #define BAT_VOL_H 0x0078
79 #define BAT_VOL_L 0x0079
80 #define BAT_CUR_H 0x007a
81 #define BAT_CUR 0x007b
82 #define BAT_TS_H 0x007c
83 #define BAT_TS_L 0x007d
84 #define USB_VOL_H 0x007e
85 #define USB_VOL_L 0x007f
86 #define SYS_VOL_H 0x0080
87 #define SYS_VOL_L 0x0081
88 #define Q_MAX_H3 0x0082
89 #define Q_MAX_H2 0x0083
90 #define Q_MAX_L1 0x0084
91 #define Q_MAX_L0 0x0085
92 #define Q_TERM_H3 0x0086
93 #define Q_TERM_H2 0x0087
94 #define Q_TERM_L1 0x0088
95 #define Q_TERM_L0 0x0089
96 #define Q_OCV_H3 0x008a
97 #define Q_OCV_H2 0x008b
98 #define Q_OCV_L1 0x008c
99 #define Q_OCV_L0 0x008d
100 #define OCV_CNT 0x008e
101 #define SLEEP_CON_SAMP_CUR_H 0x008f
102 #define SLEEP_CON_SAMP_CUR 0x0090
103 #define CAL_OFFSET_H 0x0091
104 #define CAL_OFFSET_L 0x0092
105 #define VCALIB0_H 0x0093
106 #define VCALIB0_L 0x0094
107 #define VCALIB1_H 0x0095
108 #define VCALIB1_L 0x0096
109 #define IOFFSET_H 0x0097
110 #define IOFFSET_L 0x0098
111 #define BAT_R0 0x0099
112 #define SOC_REG0 0x009a
113 #define SOC_REG1 0x009b
114 #define SOC_REG2 0x009c
115 #define REMAIN_CAP_REG0 0x9d
116 #define REMAIN_CAP_REG1 0x9e
117 #define REMAIN_CAP_REG2 0x9f
118 #define NEW_FCC_REG0 0x00a0
119 #define NEW_FCC_REG1 0x00a1
120 #define NEW_FCC_REG2 0x00a2
121 #define DRV_VERSION 0x00a3
122 #define DATA7 0x00a4
123 #define FG_INIT 0x00a5
124 #define HALT_CNT_REG 0x00a6
125 #define DATA10 0x00a7
126 #define DATA11 0x00a8
127 #define VOL_ADC_B3 0x00a9
128 #define VOL_ADC_B2 0x00aa
129 #define VOL_ADC_B1 0x00ab
130 #define VOL_ADC_B_7_0 0x00ac
131 #define CUR_ADC_K3 0x00ad
132 #define CUR_ADC_K2 0x00ae
133 #define CUR_ADC_K1 0x00af
134 #define CUR_ADC_K0 0x00b0
135 #define PMIC_CHRG_STS 0x00eb
136 #define BAT_DISCHRG 0x00ec
137 #define BAT_CON BIT(4)
138
139 #define USB_CTRL_REG 0x00E5
140 #define PMIC_SYS_STS 0x00f0
141 #define PLUG_IN_STS BIT(6)
142
143 #define CHRG_TERM_DSOC 90
144 #define CHRG_TERM_K 650
145 #define CHRG_FULL_K 400
146 #define CHARGE_FINISH (0x04 << 4)
147
148 /* CALI PARAM */
149 #define FINISH_CALI_CURR 1500
150 #define TERM_CALI_CURR 600
151 #define VIRTUAL_POWER_VOL 4200
152 #define VIRTUAL_POWER_CUR 1000
153 #define VIRTUAL_POWER_SOC 66
154 #define SECONDS(n) ((n) * 1000)
155
156 /* CHRG_CTRL_REG */
157 #define ILIM_450MA (0x00)
158 #define ILIM_2000MA (0x07)
159 #define ILIM_1500MA (0x03)
160 #define VLIM_4500MV (0x50)
161
162 /* sample resistor and division */
163 #define SAMPLE_RES_10mR 10
164 #define SAMPLE_RES_20mR 20
165 #define SAMPLE_RES_DIV1 1
166 #define SAMPLE_RES_DIV2 2
167
168 #define CHRG_CT_EN BIT(1)
169 #define MIN_FCC 500
170 #define CAP_INVALID BIT(7)
171 #define DIS_ILIM_EN BIT(3)
172
173 /* USB_CTRL_REG */
174 #define INPUT_CUR_MSK 0x0f
175 #define INPUT_VOL_MSK 0xf0
176 #define VOL_OUPUT_INSTANT_MODE 0x02
177
178 #define ADC_TO_CURRENT(adc_value, samp_res) \
179 (adc_value * 172 / 1000 / samp_res)
180 #define CURRENT_TO_ADC(current, samp_res) \
181 (current * 1000 * samp_res / 172)
182
183 #define ADC_TO_CAPACITY(adc_value, samp_res) \
184 (adc_value / 1000 * 172 / 3600 / samp_res)
185 #define CAPACITY_TO_ADC(capacity, samp_res) \
186 (capacity * samp_res * 3600 / 172 * 1000)
187
188 #define ADC_TO_CAPACITY_UAH(adc_value, samp_res) \
189 (adc_value / 3600 * 172 / samp_res)
190 #define ADC_TO_CAPACITY_MAH(adc_value, samp_res) \
191 (adc_value / 1000 * 172 / 3600 / samp_res)
192
193 /* charger type definition */
194 enum charger_type {
195 NO_CHARGER = 0,
196 USB_CHARGER,
197 AC_CHARGER,
198 DC_CHARGER,
199 UNDEF_CHARGER,
200 };
201
202 enum power_supply_type {
203 POWER_SUPPLY_TYPE_UNKNOWN = 0,
204 POWER_SUPPLY_TYPE_USB, /* Standard Downstream Port */
205 POWER_SUPPLY_TYPE_USB_DCP, /* Dedicated Charging Port */
206 POWER_SUPPLY_TYPE_USB_CDP, /* Charging Downstream Port */
207 POWER_SUPPLY_TYPE_USB_FLOATING, /* DCP without shorting D+/D- */
208 };
209
210 struct rk817_battery_device {
211 struct udevice *dev;
212 int res_div;
213 bool is_first_power_on;
214 bool is_initialized;
215 bool bat_first_power_on;
216 int current_avg;
217 int current_pwron;
218 int voltage_usb;
219 int voltage_sys;
220 int voltage_avg;
221 int voltage_k;/* VCALIB0 VCALIB1 */
222 int voltage_b;
223 u32 remain_cap;
224 int design_cap;
225 int nac;
226 int fcc;
227 int qmax;
228 int dsoc;
229 int rsoc;
230 int pwron_voltage;
231 int sm_linek;
232 int sm_old_cap;
233 int calc_dsoc;
234 int calc_rsoc;
235 int sm_chrg_dsoc;
236 u8 halt_cnt;
237 bool is_halt;
238 int dbg_pwr_dsoc;
239 int dbg_pwr_rsoc;
240 int dbg_pwr_vol;
241 int dbg_meet_soc;
242 int dbg_calc_dsoc;
243 int dbg_calc_rsoc;
244 int adc_allow_update;
245 int pwroff_min;
246 int chrg_cur_input;
247 u32 *ocv_table;
248 int ocv_size;
249 u32 design_capacity;
250 u32 max_soc_offset;
251 u32 virtual_power;
252 u32 chrg_type;
253 ulong finish_chrg_base;
254 ulong term_sig_base;
255 int sm_meet_soc;
256 u32 bat_res_up;
257 u32 bat_res_down;
258 u32 variant;
259 int drv_version;
260 };
261
interpolate(int value,u32 * table,int size)262 static u32 interpolate(int value, u32 *table, int size)
263 {
264 u8 i;
265 u16 d;
266
267 for (i = 0; i < size; i++) {
268 if (value < table[i])
269 break;
270 }
271
272 if ((i > 0) && (i < size)) {
273 d = (value - table[i - 1]) * (MAX_INTERPOLATE / (size - 1));
274 d /= table[i] - table[i - 1];
275 d = d + (i - 1) * (MAX_INTERPOLATE / (size - 1));
276 } else {
277 d = i * ((MAX_INTERPOLATE + size / 2) / size);
278 }
279
280 if (d > 1000)
281 d = 1000;
282
283 return d;
284 }
285
286 /* (a * b) / c */
ab_div_c(u32 a,u32 b,u32 c)287 static int32_t ab_div_c(u32 a, u32 b, u32 c)
288 {
289 bool sign;
290 u32 ans = MAX_INT;
291 int tmp;
292
293 sign = ((((a ^ b) ^ c) & 0x80000000) != 0);
294 if (c != 0) {
295 if (sign)
296 c = -c;
297 tmp = (a * b + (c >> 1)) / c;
298 if (tmp < MAX_INT)
299 ans = tmp;
300 }
301
302 if (sign)
303 ans = -ans;
304
305 return ans;
306 }
307
rk817_bat_read(struct rk817_battery_device * battery,u8 reg)308 static int rk817_bat_read(struct rk817_battery_device *battery, u8 reg)
309 {
310 return pmic_reg_read(battery->dev->parent, reg);
311 }
312
rk817_bat_write(struct rk817_battery_device * battery,u8 reg,u8 buf)313 static void rk817_bat_write(struct rk817_battery_device *battery,
314 u8 reg, u8 buf)
315 {
316 pmic_reg_write(battery->dev->parent, reg, buf);
317 }
318
rk817_bat_get_vaclib0(struct rk817_battery_device * battery)319 static int rk817_bat_get_vaclib0(struct rk817_battery_device *battery)
320 {
321 int vcalib_value = 0;
322
323 vcalib_value |= rk817_bat_read(battery, VCALIB0_H) << 8;
324 vcalib_value |= rk817_bat_read(battery, VCALIB0_L);
325
326 return vcalib_value;
327 }
328
rk817_bat_get_vaclib1(struct rk817_battery_device * battery)329 static int rk817_bat_get_vaclib1(struct rk817_battery_device *battery)
330 {
331 int vcalib_value = 0;
332
333 vcalib_value |= rk817_bat_read(battery, VCALIB1_H) << 8;
334 vcalib_value |= rk817_bat_read(battery, VCALIB1_L);
335
336 return vcalib_value;
337 }
338
rk817_bat_init_voltage_kb(struct rk817_battery_device * battery)339 static void rk817_bat_init_voltage_kb(struct rk817_battery_device *battery)
340 {
341 int vcalib0, vcalib1;
342
343 vcalib0 = rk817_bat_get_vaclib0(battery);
344 vcalib1 = rk817_bat_get_vaclib1(battery);
345
346 if (battery->variant == RK809_ID) {
347 battery->voltage_k = (1050 - 600) * 1000 / DIV(vcalib1 - vcalib0);
348 battery->voltage_b = 1050 - (battery->voltage_k * vcalib1) / 1000;
349 } else {
350 battery->voltage_k = (4025 - 2300) * 1000 / DIV(vcalib1 - vcalib0);
351 battery->voltage_b = 4025 - (battery->voltage_k * vcalib1) / 1000;
352 }
353 }
354
355 /* power on battery voltage */
rk817_bat_get_pwron_voltage(struct rk817_battery_device * battery)356 static int rk817_bat_get_pwron_voltage(struct rk817_battery_device *battery)
357 {
358 int vol, val = 0, vol_temp;
359
360 val = rk817_bat_read(battery, PWRON_VOL_H) << 8;
361 val |= rk817_bat_read(battery, PWRON_VOL_L);
362 vol = battery->voltage_k * val / 1000 + battery->voltage_b;
363 if (battery->variant == RK809_ID) {
364 vol_temp = (vol * battery->bat_res_up / battery->bat_res_down + vol);
365 vol = vol_temp;
366 }
367
368 return vol;
369 }
370
rk817_bat_get_USB_voltage(struct rk817_battery_device * battery)371 static int rk817_bat_get_USB_voltage(struct rk817_battery_device *battery)
372 {
373 int vol, val = 0, vol_temp;
374
375 val = rk817_bat_read(battery, USB_VOL_L) << 0;
376 val |= rk817_bat_read(battery, USB_VOL_H) << 8;
377
378 vol = (battery->voltage_k * val / 1000 + battery->voltage_b) * 60 / 46;
379 if (battery->variant == RK809_ID) {
380 vol_temp = vol * battery->bat_res_up / battery->bat_res_down + vol;
381 vol = vol_temp;
382 }
383
384 return vol;
385 }
386
rk817_bat_get_sys_voltage(struct rk817_battery_device * battery)387 static int rk817_bat_get_sys_voltage(struct rk817_battery_device *battery)
388 {
389 int vol, val = 0, vol_temp;
390
391 val = rk817_bat_read(battery, SYS_VOL_H) << 8;
392 val |= rk817_bat_read(battery, SYS_VOL_L) << 0;
393
394 vol = (battery->voltage_k * val / 1000 + battery->voltage_b) * 60 / 46;
395 if (battery->variant == RK809_ID) {
396 vol_temp = vol * battery->bat_res_up / battery->bat_res_down + vol;
397 vol = vol_temp;
398 }
399
400 return vol;
401 }
402
rk817_bat_get_battery_voltage(struct rk817_battery_device * battery)403 static int rk817_bat_get_battery_voltage(struct rk817_battery_device *battery)
404 {
405 int vol, val = 0, vol_temp;
406
407 val = rk817_bat_read(battery, BAT_VOL_H) << 8;
408 val |= rk817_bat_read(battery, BAT_VOL_L) << 0;
409
410 vol = battery->voltage_k * val / 1000 + battery->voltage_b;
411 if (battery->variant == RK809_ID) {
412 vol_temp = (vol * battery->bat_res_up / battery->bat_res_down + vol);
413 vol = vol_temp;
414 }
415 return vol;
416 }
417
rk817_bat_get_avg_current(struct rk817_battery_device * battery)418 static int rk817_bat_get_avg_current(struct rk817_battery_device *battery)
419 {
420 int cur, val = 0;
421
422 val |= rk817_bat_read(battery, BAT_CUR);
423 val |= rk817_bat_read(battery, BAT_CUR_H) << 8;
424
425 if (val & 0x8000)
426 val -= 0x10000;
427
428 cur = ADC_TO_CURRENT(val, battery->res_div);
429
430 return cur;
431 }
432
rk817_bat_get_pwron_current(struct rk817_battery_device * battery)433 static int rk817_bat_get_pwron_current(struct rk817_battery_device *battery)
434 {
435 int cur, val = 0;
436
437 val |= rk817_bat_read(battery, PWRON_CUR_L);
438 val |= rk817_bat_read(battery, PWRON_CUR_H) << 8;
439
440 if (val & 0x8000)
441 val -= 0x10000;
442 cur = ADC_TO_CURRENT(val, battery->res_div);
443
444 return cur;
445 }
446
rk817_bat_calibration(struct rk817_battery_device * battery)447 static void rk817_bat_calibration(struct rk817_battery_device *battery)
448 {
449 int ioffset_value = 0;
450 u8 buf = 0;
451
452 if (rk817_bat_read(battery, ADC_CONFIG1) & 0x80) {
453 ioffset_value = rk817_bat_read(battery, IOFFSET_H) << 8;
454 ioffset_value |= rk817_bat_read(battery, IOFFSET_L);
455
456 buf = (ioffset_value >> 8) & 0xff;
457 rk817_bat_write(battery, CAL_OFFSET_H, buf);
458 buf = (ioffset_value >> 0) & 0xff;
459 rk817_bat_write(battery, CAL_OFFSET_L, buf);
460
461 rk817_bat_init_voltage_kb(battery);
462 rk817_bat_write(battery, ADC_CONFIG1, 0x80);
463 }
464 }
465
466 static int rk817_bat_get_rsoc(struct rk817_battery_device *battery);
467
rk817_bat_init_coulomb_cap(struct rk817_battery_device * battery,u32 capacity)468 static void rk817_bat_init_coulomb_cap(struct rk817_battery_device *battery,
469 u32 capacity)
470 {
471 u8 buf;
472 u32 cap;
473 u32 val;
474
475 cap = CAPACITY_TO_ADC(capacity, battery->res_div);
476
477 do {
478 buf = (cap >> 24) & 0xff;
479 rk817_bat_write(battery, Q_INIT_H3, buf);
480 buf = (cap >> 16) & 0xff;
481 rk817_bat_write(battery, Q_INIT_H2, buf);
482 buf = (cap >> 8) & 0xff;
483 rk817_bat_write(battery, Q_INIT_L1, buf);
484 buf = (cap >> 0) & 0xff;
485 rk817_bat_write(battery, Q_INIT_L0, buf);
486
487 val = rk817_bat_read(battery, Q_INIT_H3) << 24;
488 val |= rk817_bat_read(battery, Q_INIT_H2) << 16;
489 val |= rk817_bat_read(battery, Q_INIT_L1) << 8;
490 val |= rk817_bat_read(battery, Q_INIT_L0) << 0;
491 } while (cap != val);
492
493 battery->rsoc = rk817_bat_get_rsoc(battery);
494 battery->remain_cap = capacity * 1000;
495 }
496
rk817_bat_remain_cap_is_valid(struct rk817_battery_device * battery)497 static bool rk817_bat_remain_cap_is_valid(struct rk817_battery_device *battery)
498 {
499 return !(rk817_bat_read(battery, Q_PRES_H3) & CAP_INVALID);
500 }
501
rk817_bat_get_capacity_uah(struct rk817_battery_device * battery)502 static u32 rk817_bat_get_capacity_uah(struct rk817_battery_device *battery)
503 {
504 u32 val = 0, capacity = 0;
505
506 if (rk817_bat_remain_cap_is_valid(battery)) {
507 val = rk817_bat_read(battery, Q_PRES_H3) << 24;
508 val |= rk817_bat_read(battery, Q_PRES_H2) << 16;
509 val |= rk817_bat_read(battery, Q_PRES_L1) << 8;
510 val |= rk817_bat_read(battery, Q_PRES_L0) << 0;
511
512 capacity = ADC_TO_CAPACITY_UAH(val, battery->res_div);
513 }
514
515 return capacity;
516 }
517
rk817_bat_get_capacity_mah(struct rk817_battery_device * battery)518 static u32 rk817_bat_get_capacity_mah(struct rk817_battery_device *battery)
519 {
520 u32 val, capacity = 0;
521
522 if (rk817_bat_remain_cap_is_valid(battery)) {
523 val = rk817_bat_read(battery, Q_PRES_H3) << 24;
524 val |= rk817_bat_read(battery, Q_PRES_H2) << 16;
525 val |= rk817_bat_read(battery, Q_PRES_L1) << 8;
526 val |= rk817_bat_read(battery, Q_PRES_L0) << 0;
527 capacity = ADC_TO_CAPACITY(val, battery->res_div);
528 }
529
530 return capacity;
531 }
532
rk817_bat_save_cap(struct rk817_battery_device * battery,int capacity)533 static void rk817_bat_save_cap(struct rk817_battery_device *battery,
534 int capacity)
535 {
536 u8 buf;
537 static u32 old_cap;
538
539 if (capacity >= battery->qmax)
540 capacity = battery->qmax;
541 if (capacity <= 0)
542 capacity = 0;
543 if (old_cap == capacity)
544 return;
545
546 old_cap = capacity;
547 buf = (capacity >> 16) & 0xff;
548 rk817_bat_write(battery, REMAIN_CAP_REG2, buf);
549 buf = (capacity >> 8) & 0xff;
550 rk817_bat_write(battery, REMAIN_CAP_REG1, buf);
551 buf = (capacity >> 0) & 0xff;
552 rk817_bat_write(battery, REMAIN_CAP_REG0, buf);
553 }
554
rk817_bat_get_rsoc(struct rk817_battery_device * battery)555 static int rk817_bat_get_rsoc(struct rk817_battery_device *battery)
556 {
557 int remain_cap;
558
559 remain_cap = rk817_bat_get_capacity_uah(battery);
560
561 return remain_cap * 100 / DIV(battery->fcc);
562 }
563
rk817_bat_vol_to_soc(struct rk817_battery_device * battery,int voltage)564 static int rk817_bat_vol_to_soc(struct rk817_battery_device *battery,
565 int voltage)
566 {
567 u32 *ocv_table, temp;
568 int ocv_size, ocv_soc;
569
570 ocv_table = battery->ocv_table;
571 ocv_size = battery->ocv_size;
572 temp = interpolate(voltage, ocv_table, ocv_size);
573 ocv_soc = ab_div_c(temp, MAX_PERCENTAGE, MAX_INTERPOLATE);
574
575 return ocv_soc;
576 }
577
rk817_bat_vol_to_cap(struct rk817_battery_device * battery,int voltage)578 static int rk817_bat_vol_to_cap(struct rk817_battery_device *battery,
579 int voltage)
580 {
581 u32 *ocv_table, temp;
582 int ocv_size, capacity;
583
584 ocv_table = battery->ocv_table;
585 ocv_size = battery->ocv_size;
586 temp = interpolate(voltage, ocv_table, ocv_size);
587 capacity = ab_div_c(temp, battery->fcc, MAX_INTERPOLATE);
588
589 return capacity;
590 }
591
rk817_bat_save_dsoc(struct rk817_battery_device * battery,int save_soc)592 static void rk817_bat_save_dsoc(struct rk817_battery_device *battery,
593 int save_soc)
594 {
595 static int last_soc = -1;
596
597 if (last_soc != save_soc) {
598 rk817_bat_write(battery, SOC_REG0, save_soc & 0xff);
599 rk817_bat_write(battery, SOC_REG1, (save_soc >> 8) & 0xff);
600 rk817_bat_write(battery, SOC_REG2, (save_soc >> 16) & 0xff);
601
602 last_soc = save_soc;
603 }
604 }
605
rk817_bat_get_prev_dsoc(struct rk817_battery_device * battery)606 static int rk817_bat_get_prev_dsoc(struct rk817_battery_device *battery)
607 {
608 int value;
609
610 value = rk817_bat_read(battery, SOC_REG0);
611 value |= rk817_bat_read(battery, SOC_REG1) << 8;
612 value |= rk817_bat_read(battery, SOC_REG2) << 16;
613
614 return value;
615 }
616
rk817_bat_get_prev_cap(struct rk817_battery_device * battery)617 static int rk817_bat_get_prev_cap(struct rk817_battery_device *battery)
618 {
619 int val = 0;
620
621 val = rk817_bat_read(battery, REMAIN_CAP_REG2) << 16;
622 val |= rk817_bat_read(battery, REMAIN_CAP_REG1) << 8;
623 val |= rk817_bat_read(battery, REMAIN_CAP_REG0) << 0;
624
625 return val;
626 }
627
rk817_bat_gas_gaugle_enable(struct rk817_battery_device * battery)628 static void rk817_bat_gas_gaugle_enable(struct rk817_battery_device *battery)
629 {
630 int value;
631
632 value = rk817_bat_read(battery, ADC_CONFIG0);
633 rk817_bat_write(battery, ADC_CONFIG0, value | 0x80);
634 }
635
is_rk817_bat_first_pwron(struct rk817_battery_device * battery)636 static bool is_rk817_bat_first_pwron(struct rk817_battery_device *battery)
637 {
638 int value;
639
640 value = rk817_bat_read(battery, GG_STS);
641
642 if (value & BAT_CON) {
643 rk817_bat_write(battery, GG_STS, value & (~BAT_CON));
644 return true;
645 }
646
647 return false;
648 }
649
rk817_bat_get_off_count(struct rk817_battery_device * battery)650 static int rk817_bat_get_off_count(struct rk817_battery_device *battery)
651 {
652 int value;
653
654 value = rk817_bat_read(battery, OFF_CNT);
655 rk817_bat_write(battery, OFF_CNT, 0x00);
656
657 return value;
658 }
659
rk817_bat_update_qmax(struct rk817_battery_device * battery,u32 capacity)660 static void rk817_bat_update_qmax(struct rk817_battery_device *battery,
661 u32 capacity)
662 {
663 u8 buf;
664 u32 cap_adc;
665
666 cap_adc = CAPACITY_TO_ADC(capacity, battery->res_div);
667 buf = (cap_adc >> 24) & 0xff;
668 rk817_bat_write(battery, Q_MAX_H3, buf);
669 buf = (cap_adc >> 16) & 0xff;
670 rk817_bat_write(battery, Q_MAX_H2, buf);
671 buf = (cap_adc >> 8) & 0xff;
672 rk817_bat_write(battery, Q_MAX_L1, buf);
673 buf = (cap_adc >> 0) & 0xff;
674 rk817_bat_write(battery, Q_MAX_L0, buf);
675
676 battery->qmax = capacity;
677 }
678
rk817_bat_save_fcc(struct rk817_battery_device * battery,int fcc)679 static void rk817_bat_save_fcc(struct rk817_battery_device *battery, int fcc)
680 {
681 u8 buf;
682
683 buf = (fcc >> 16) & 0xff;
684 rk817_bat_write(battery, NEW_FCC_REG2, buf);
685 buf = (fcc >> 8) & 0xff;
686 rk817_bat_write(battery, NEW_FCC_REG1, buf);
687 buf = (fcc >> 0) & 0xff;
688 rk817_bat_write(battery, NEW_FCC_REG0, buf);
689 }
690
rk817_bat_first_pwron(struct rk817_battery_device * battery)691 static void rk817_bat_first_pwron(struct rk817_battery_device *battery)
692 {
693 battery->rsoc =
694 rk817_bat_vol_to_soc(battery,
695 battery->pwron_voltage) * 1000;/* uAH */
696 battery->dsoc = battery->rsoc;
697 battery->fcc = battery->design_cap;
698
699 battery->nac = rk817_bat_vol_to_cap(battery,
700 battery->pwron_voltage);
701
702 rk817_bat_update_qmax(battery, battery->qmax);
703 rk817_bat_save_fcc(battery, battery->fcc);
704 DBG("%s, rsoc = %d, dsoc = %d, fcc = %d, nac = %d\n",
705 __func__, battery->rsoc, battery->dsoc, battery->fcc, battery->nac);
706 }
707
rk817_bat_get_fcc(struct rk817_battery_device * battery)708 static int rk817_bat_get_fcc(struct rk817_battery_device *battery)
709 {
710 u32 fcc = 0;
711
712 fcc = rk817_bat_read(battery, NEW_FCC_REG2) << 16;
713 fcc |= rk817_bat_read(battery, NEW_FCC_REG1) << 8;
714 fcc |= rk817_bat_read(battery, NEW_FCC_REG0) << 0;
715
716 if (fcc < MIN_FCC) {
717 DBG("invalid fcc(%d), use design cap", fcc);
718 fcc = battery->design_capacity;
719 rk817_bat_save_fcc(battery, fcc);
720 } else if (fcc > battery->qmax) {
721 DBG("invalid fcc(%d), use qmax", fcc);
722 fcc = battery->qmax;
723 rk817_bat_save_fcc(battery, fcc);
724 }
725
726 return fcc;
727 }
728
rk817_bat_inc_halt_cnt(struct rk817_battery_device * battery)729 static void rk817_bat_inc_halt_cnt(struct rk817_battery_device *battery)
730 {
731 u8 cnt;
732
733 cnt = rk817_bat_read(battery, HALT_CNT_REG);
734 rk817_bat_write(battery, HALT_CNT_REG, ++cnt);
735 }
736
is_rk817_bat_last_halt(struct rk817_battery_device * battery)737 static bool is_rk817_bat_last_halt(struct rk817_battery_device *battery)
738 {
739 int pre_cap = rk817_bat_get_prev_cap(battery);
740 int now_cap = rk817_bat_get_capacity_mah(battery);
741
742 battery->nac = rk817_bat_vol_to_cap(battery,
743 battery->pwron_voltage);
744
745 /* over 10%: system halt last time */
746 if (now_cap > pre_cap) {
747 if (abs(now_cap - pre_cap) > (battery->fcc / 10)) {
748 rk817_bat_inc_halt_cnt(battery);
749 return true;
750 } else {
751 return false;
752 }
753 } else {
754 if (abs(battery->nac - pre_cap) > (battery->fcc / 5)) {
755 rk817_bat_inc_halt_cnt(battery);
756 return true;
757 } else {
758 return false;
759 }
760 }
761 }
762
rk817_bat_get_halt_cnt(struct rk817_battery_device * battery)763 static u8 rk817_bat_get_halt_cnt(struct rk817_battery_device *battery)
764 {
765 return rk817_bat_read(battery, HALT_CNT_REG);
766 }
767
rk817_bat_is_initialized(struct rk817_battery_device * battery)768 static int rk817_bat_is_initialized(struct rk817_battery_device *battery)
769 {
770 u8 val = rk817_bat_read(battery, FG_INIT);
771
772 return (val & 0x80);
773 }
774
rk817_bat_set_initialized_flag(struct rk817_battery_device * battery)775 static void rk817_bat_set_initialized_flag(struct rk817_battery_device *battery)
776 {
777 u8 val = rk817_bat_read(battery, FG_INIT);
778
779 rk817_bat_write(battery, FG_INIT, val | (0x80));
780 }
781
rk817_bat_not_first_pwron(struct rk817_battery_device * battery)782 static void rk817_bat_not_first_pwron(struct rk817_battery_device *battery)
783 {
784 int now_soc, now_cap, pre_soc, pre_cap;
785
786 battery->fcc = rk817_bat_get_fcc(battery);
787 pre_soc = rk817_bat_get_prev_dsoc(battery);
788 pre_cap = rk817_bat_get_prev_cap(battery);
789
790 now_cap = rk817_bat_get_capacity_mah(battery);
791 battery->halt_cnt = rk817_bat_get_halt_cnt(battery);
792 battery->nac = rk817_bat_vol_to_cap(battery,
793 battery->pwron_voltage);
794 battery->remain_cap = pre_cap * 1000;
795 battery->is_halt = is_rk817_bat_last_halt(battery);
796
797 DBG("now_cap: %d, pre_cap: %d\n", now_cap, pre_cap);
798
799 if (now_cap > pre_cap) {
800 if (now_cap >= battery->fcc)
801 now_cap = battery->fcc;
802
803 now_soc = now_cap * 1000 * 100 / battery->fcc;
804 if (pre_soc < 100 * 1000)
805 pre_soc += (now_soc - pre_cap * 1000 * 100 / battery->fcc);
806 pre_cap = now_cap;
807
808 if (pre_soc >= 100 * 1000)
809 pre_soc = 100 * 1000;
810 if (now_cap >= battery->fcc)
811 pre_soc = 100 * 1000;
812 }
813
814 rk817_bat_init_coulomb_cap(battery, pre_cap);
815 rk817_bat_init_coulomb_cap(battery, pre_cap + 1);
816 rk817_bat_get_capacity_mah(battery);
817
818 battery->dsoc = pre_soc;
819 if (battery->dsoc > 100000)
820 battery->dsoc = 100000;
821 battery->nac = pre_cap;
822 if (battery->nac < 0)
823 battery->nac = 0;
824
825 DBG("dsoc=%d cap=%d v=%d pwron_v =%d min=%d psoc=%d pcap=%d\n",
826 battery->dsoc, battery->nac, rk817_bat_get_battery_voltage(battery),
827 rk817_bat_get_pwron_voltage(battery),
828 battery->pwroff_min, rk817_bat_get_prev_dsoc(battery),
829 rk817_bat_get_prev_cap(battery));
830 }
831
rk817_bat_rsoc_init(struct rk817_battery_device * battery)832 static void rk817_bat_rsoc_init(struct rk817_battery_device *battery)
833 {
834 int version, value;
835
836 battery->is_first_power_on = is_rk817_bat_first_pwron(battery);
837 battery->pwroff_min = rk817_bat_get_off_count(battery);
838 battery->pwron_voltage = rk817_bat_get_pwron_voltage(battery);
839
840 value = rk817_bat_read(battery, DRV_VERSION);
841 /* drv_version: bit0~bit3 */
842 version = value & 0x0f;
843 /* drv_version: [0 15] */
844 battery->drv_version &= 0x0f;
845 DBG("reg read version:%d dts read version:%d\n", version, battery->drv_version);
846 if (battery->drv_version != version) {
847 battery->is_first_power_on = 1;
848 value &= 0xf0;
849 value |= battery->drv_version;
850 rk817_bat_write(battery, DRV_VERSION, value);
851 }
852
853 DBG("battery = %d\n", rk817_bat_get_battery_voltage(battery));
854 DBG("%s: is_first_power_on = %d, pwroff_min = %d, pwron_voltage = %d\n",
855 __func__, battery->is_first_power_on,
856 battery->pwroff_min, battery->pwron_voltage);
857
858 if (battery->is_first_power_on)
859 rk817_bat_first_pwron(battery);
860 else
861 rk817_bat_not_first_pwron(battery);
862
863 rk817_bat_save_dsoc(battery, battery->dsoc);
864 rk817_bat_save_cap(battery, battery->nac);
865 }
866
rk817_bat_calc_linek(struct rk817_battery_device * battery)867 static int rk817_bat_calc_linek(struct rk817_battery_device *battery)
868 {
869 int linek, diff, delta;
870
871 battery->calc_dsoc = battery->dsoc;
872 battery->calc_rsoc = battery->rsoc;
873 battery->sm_old_cap = battery->remain_cap;
874
875 delta = abs(battery->dsoc - battery->rsoc);
876 diff = delta * 3;
877 battery->sm_meet_soc = (battery->dsoc >= battery->rsoc) ?
878 (battery->dsoc + diff) : (battery->rsoc + diff);
879
880 if (battery->dsoc < battery->rsoc)
881 linek = 1000 * (delta + diff) / DIV(diff);
882 else if (battery->dsoc > battery->rsoc)
883 linek = 1000 * diff / DIV(delta + diff);
884 else
885 linek = 1000;
886
887 battery->sm_chrg_dsoc = battery->dsoc;
888
889 DBG("<%s>. meet=%d, diff=%d, link=%d, calc: dsoc=%d, rsoc=%d\n",
890 __func__, battery->sm_meet_soc, diff, linek,
891 battery->calc_dsoc, battery->calc_rsoc);
892
893 return linek;
894 }
895
rk817_bat_get_est_voltage(struct rk817_battery_device * battery)896 static int rk817_bat_get_est_voltage(struct rk817_battery_device *battery)
897 {
898 return rk817_bat_get_battery_voltage(battery);
899 }
900
rk817_bat_update_get_voltage(struct udevice * dev)901 static int rk817_bat_update_get_voltage(struct udevice *dev)
902 {
903 struct rk817_battery_device *battery = dev_get_priv(dev);
904
905 if (!battery->virtual_power && battery->voltage_k)
906 return rk817_bat_get_est_voltage(battery);
907 else
908 return VIRTUAL_POWER_VOL;
909 }
910
rk817_bat_update_get_current(struct udevice * dev)911 static int rk817_bat_update_get_current(struct udevice *dev)
912 {
913 struct rk817_battery_device *battery = dev_get_priv(dev);
914
915 if (!battery->virtual_power && battery->voltage_k)
916 return rk817_bat_get_avg_current(battery);
917 else
918 return VIRTUAL_POWER_CUR;
919 }
920
rk817_bat_dwc_otg_check_dpdm(struct rk817_battery_device * battery)921 static int rk817_bat_dwc_otg_check_dpdm(struct rk817_battery_device *battery)
922 {
923 if (battery->variant == RK809_ID) {
924 if (rk817_bat_read(battery, PMIC_SYS_STS) & PLUG_IN_STS)
925 return AC_CHARGER;
926 else
927 return NO_CHARGER;
928 } else {
929 return rockchip_chg_get_type();
930 }
931 }
932
rk817_bat_update_get_chrg_online(struct udevice * dev)933 static bool rk817_bat_update_get_chrg_online(struct udevice *dev)
934 {
935 struct rk817_battery_device *battery = dev_get_priv(dev);
936
937 return rk817_bat_dwc_otg_check_dpdm(battery);
938 }
939
rk817_bat_get_usb_state(struct rk817_battery_device * battery)940 static int rk817_bat_get_usb_state(struct rk817_battery_device *battery)
941 {
942 int charger_type;
943
944 switch (rk817_bat_dwc_otg_check_dpdm(battery)) {
945 case POWER_SUPPLY_TYPE_UNKNOWN:
946 if ((rk817_bat_read(battery, PMIC_SYS_STS) & PLUG_IN_STS) != 0)
947 charger_type = DC_CHARGER;
948 else
949 charger_type = NO_CHARGER;
950 break;
951 case POWER_SUPPLY_TYPE_USB:
952 charger_type = USB_CHARGER;
953 break;
954 case POWER_SUPPLY_TYPE_USB_DCP:
955 case POWER_SUPPLY_TYPE_USB_CDP:
956 case POWER_SUPPLY_TYPE_USB_FLOATING:
957 charger_type = AC_CHARGER;
958 break;
959 default:
960 charger_type = NO_CHARGER;
961 }
962
963 return charger_type;
964 }
965
rk817_bat_get_charger_type(struct rk817_battery_device * battery)966 static int rk817_bat_get_charger_type(struct rk817_battery_device *battery)
967 {
968 struct rk8xx_priv *rk8xx = dev_get_priv(battery->dev->parent);
969 u32 chrg_type;
970 u8 val;
971
972 /* check by ic hardware: this check make check work safer */
973 if ((rk817_bat_read(battery, PMIC_SYS_STS) & PLUG_IN_STS) == 0)
974 return NO_CHARGER;
975
976 /* virtual or bat not exist */
977 if (battery->virtual_power)
978 return DC_CHARGER;
979
980 /* check USB secondly */
981 chrg_type = rk817_bat_get_usb_state(battery);
982 if (chrg_type != NO_CHARGER && (battery->rsoc + 500) / 1000 >= 100)
983 chrg_type = CHARGE_FINISH;
984
985 if (rk8xx->variant == RK817_ID) {
986 val = rk817_bat_read(battery, PMIC_CHRG_STS);
987 if ((val & 0x70) == CHARGE_FINISH)
988 chrg_type = CHARGE_FINISH;
989 }
990
991 return chrg_type;
992 }
993
rk817_bat_set_input_current(struct rk817_battery_device * battery,int input_current)994 static void rk817_bat_set_input_current(struct rk817_battery_device *battery,
995 int input_current)
996 {
997 u8 usb_ctrl;
998
999 usb_ctrl = rk817_bat_read(battery, USB_CTRL_REG);
1000 usb_ctrl &= ~INPUT_CUR_MSK;
1001 usb_ctrl |= ((input_current) | 0x08);
1002 rk817_bat_write(battery, USB_CTRL_REG, usb_ctrl);
1003 }
1004
rk817_bat_set_input_voltage(struct rk817_battery_device * battery,int input_voltage)1005 static void rk817_bat_set_input_voltage(struct rk817_battery_device *battery,
1006 int input_voltage)
1007 {
1008 u8 usb_ctrl;
1009
1010 usb_ctrl = rk817_bat_read(battery, USB_CTRL_REG);
1011 usb_ctrl &= ~INPUT_VOL_MSK;
1012 usb_ctrl |= ((input_voltage) | 0x80);
1013 rk817_bat_write(battery, USB_CTRL_REG, usb_ctrl);
1014 }
1015
rk817_bat_charger_setting(struct rk817_battery_device * battery,int charger)1016 static void rk817_bat_charger_setting(struct rk817_battery_device *battery,
1017 int charger)
1018 {
1019 static u8 old_charger = UNDEF_CHARGER;
1020
1021 rk817_bat_set_input_voltage(battery, VLIM_4500MV);
1022 /* charger changed */
1023 if (old_charger != charger) {
1024 if (charger == NO_CHARGER) {
1025 DBG("NO_CHARGER\n");
1026 rk817_bat_set_input_current(battery, ILIM_450MA);
1027 } else if (charger == USB_CHARGER) {
1028 DBG("USB_CHARGER\n");
1029 rk817_bat_set_input_current(battery, ILIM_450MA);
1030 } else if (charger == DC_CHARGER || charger == AC_CHARGER) {
1031 DBG("DC OR AC CHARGE\n");
1032 rk817_bat_set_input_current(battery, ILIM_1500MA);
1033 } else {
1034 DBG("charger setting error %d\n", charger);
1035 }
1036
1037 old_charger = charger;
1038 }
1039 }
1040
rk817_bat_linek_algorithm(struct rk817_battery_device * battery)1041 static void rk817_bat_linek_algorithm(struct rk817_battery_device *battery)
1042 {
1043 int delta_cap, ydsoc, tmp;
1044 u8 chg_st = rk817_bat_get_charger_type(battery);
1045
1046 /* slow down */
1047 if (battery->dsoc / 1000 == 99)
1048 battery->sm_linek = CHRG_FULL_K;
1049 else if (battery->dsoc / 1000 >= CHRG_TERM_DSOC &&
1050 battery->current_avg > TERM_CALI_CURR)
1051 battery->sm_linek = CHRG_TERM_K;
1052
1053 delta_cap = battery->remain_cap - battery->sm_old_cap;
1054 ydsoc = battery->sm_linek * (delta_cap / DIV(battery->fcc)) / 10;
1055 battery->sm_chrg_dsoc += ydsoc;
1056
1057 tmp = battery->sm_chrg_dsoc / 1000;
1058
1059 if (ydsoc > 0) {
1060 if (battery->sm_chrg_dsoc < 0)
1061 battery->sm_chrg_dsoc = 0;
1062
1063 tmp = battery->sm_chrg_dsoc / 1000;
1064
1065 if (tmp != battery->dsoc / 1000) {
1066 if (battery->sm_chrg_dsoc < battery->dsoc)
1067 return;
1068
1069 battery->dsoc = battery->sm_chrg_dsoc;
1070 if (battery->dsoc <= 0)
1071 battery->dsoc = 0;
1072 }
1073
1074 battery->sm_old_cap = battery->remain_cap;
1075 if (battery->dsoc / 1000 == battery->rsoc / 1000 &&
1076 battery->sm_linek != CHRG_FULL_K &&
1077 battery->sm_linek != CHRG_TERM_K)
1078 battery->sm_linek = 1000;
1079 }
1080
1081 if ((battery->sm_linek == 1000 || battery->dsoc >= 100 * 1000) &&
1082 (chg_st != CHARGE_FINISH)) {
1083 if (battery->sm_linek == 1000)
1084 battery->dsoc = battery->rsoc;
1085 battery->sm_chrg_dsoc = battery->dsoc;
1086 }
1087 }
1088
rk817_bat_finish_chrg(struct rk817_battery_device * battery)1089 static void rk817_bat_finish_chrg(struct rk817_battery_device *battery)
1090 {
1091 u32 tgt_sec = 0;
1092
1093 if (battery->dsoc / 1000 < 100) {
1094 tgt_sec = battery->fcc * 3600 / 100 / FINISH_CALI_CURR;
1095 if (get_timer(battery->finish_chrg_base) > SECONDS(tgt_sec)) {
1096 battery->finish_chrg_base = get_timer(0);
1097 battery->dsoc += 1000;
1098 }
1099 }
1100 }
1101
rk817_bat_debug_info(struct rk817_battery_device * battery)1102 static void rk817_bat_debug_info(struct rk817_battery_device *battery)
1103 {
1104 DBG("debug info:\n");
1105 DBG("CAL_OFFSET = 0x%x", rk817_bat_read(battery, CAL_OFFSET_H));
1106 DBG("%x\n", rk817_bat_read(battery, CAL_OFFSET_L));
1107 DBG("current_avg = %d\n", rk817_bat_get_avg_current(battery));
1108 DBG("k = %d, b = %d\n", battery->voltage_k, battery->voltage_b);
1109 DBG("battery: %d\n", rk817_bat_get_battery_voltage(battery));
1110 DBG("voltage_sys = %d\n", rk817_bat_get_sys_voltage(battery));
1111 DBG("voltage_usb = %d\n", rk817_bat_get_USB_voltage(battery));
1112 DBG("current_avg = %d\n", rk817_bat_get_avg_current(battery));
1113 DBG("dsoc = %d\n", battery->dsoc);
1114 DBG("rsoc = %d\n", rk817_bat_get_rsoc(battery));
1115 DBG("remain_cap = %d\n", rk817_bat_get_capacity_uah(battery));
1116 DBG("fcc = %d\n", battery->fcc);
1117 DBG("qmax = %d\n", battery->qmax);
1118 }
1119
rk817_bat_smooth_charge(struct rk817_battery_device * battery)1120 static void rk817_bat_smooth_charge(struct rk817_battery_device *battery)
1121 {
1122 u8 chg_st = rk817_bat_get_charger_type(battery);
1123
1124 rk817_bat_debug_info(battery);
1125 rk817_bat_calibration(battery);
1126 /* set terminal charge mode */
1127 if (battery->term_sig_base &&
1128 get_timer(battery->term_sig_base) > SECONDS(1))
1129 battery->term_sig_base = 0;
1130
1131 /* not charge mode and not keep in uboot charge: exit */
1132 if ((battery->chrg_type == NO_CHARGER) ||
1133 !rk817_bat_is_initialized(battery)) {
1134 DBG("chrg=%d\n", battery->chrg_type);
1135 rk817_bat_set_initialized_flag(battery);
1136 goto out;
1137 }
1138
1139 /* update rsoc and remain cap */
1140 battery->remain_cap = rk817_bat_get_capacity_uah(battery);
1141 battery->rsoc = rk817_bat_get_rsoc(battery);
1142 if (battery->remain_cap / 1000 > battery->fcc) {
1143 battery->sm_old_cap -=
1144 (battery->remain_cap - battery->fcc * 1000);
1145 rk817_bat_init_coulomb_cap(battery, battery->fcc + 100);
1146 rk817_bat_init_coulomb_cap(battery, battery->fcc);
1147 }
1148
1149 /* finish charge step */
1150 if (chg_st == CHARGE_FINISH) {
1151 rk817_bat_finish_chrg(battery);
1152 rk817_bat_init_coulomb_cap(battery, battery->fcc + 100);
1153 rk817_bat_init_coulomb_cap(battery, battery->fcc);
1154 } else {
1155 DBG("smooth charge step...\n");
1156 battery->adc_allow_update = true;
1157 battery->finish_chrg_base = get_timer(0);
1158 rk817_bat_linek_algorithm(battery);
1159 }
1160
1161 /* dsoc limit */
1162 if (battery->dsoc / 1000 > 100)
1163 battery->dsoc = 100 * 1000;
1164 else if (battery->dsoc < 0)
1165 battery->dsoc = 0;
1166
1167 rk817_bat_save_dsoc(battery, battery->dsoc);
1168 rk817_bat_save_cap(battery, battery->remain_cap / 1000);
1169 out:
1170 return;
1171 }
1172
rk817_bat_update_get_soc(struct udevice * dev)1173 static int rk817_bat_update_get_soc(struct udevice *dev)
1174 {
1175 struct rk817_battery_device *battery = dev_get_priv(dev);
1176 static ulong seconds;
1177
1178 rk817_bat_debug_info(battery);
1179 /* set charge current */
1180 battery->chrg_type =
1181 rk817_bat_get_charger_type(battery);
1182 rk817_bat_charger_setting(battery, battery->chrg_type);
1183
1184 /* fg calc every 5 seconds */
1185 if (!seconds)
1186 seconds = get_timer(0);
1187 if (get_timer(seconds) >= SECONDS(5)) {
1188 seconds = get_timer(0);
1189 rk817_bat_smooth_charge(battery);
1190 }
1191
1192 /* bat exist, fg init success(dts pass) and uboot charge: report data */
1193 if (!battery->virtual_power && battery->voltage_k)
1194 return battery->dsoc / 1000;
1195 else
1196 return VIRTUAL_POWER_SOC;
1197 }
1198
rk817_is_bat_exist(struct rk817_battery_device * battery)1199 static int rk817_is_bat_exist(struct rk817_battery_device *battery)
1200 {
1201 struct rk8xx_priv *rk8xx = dev_get_priv(battery->dev->parent);
1202
1203 if (rk8xx->variant == RK817_ID)
1204 return (rk817_bat_read(battery, PMIC_CHRG_STS) & 0x80) ? 1 : 0;
1205
1206 return 1;
1207 }
1208
rk817_bat_bat_is_exist(struct udevice * dev)1209 static int rk817_bat_bat_is_exist(struct udevice *dev)
1210 {
1211 struct rk817_battery_device *battery = dev_get_priv(dev);
1212
1213 return rk817_is_bat_exist(battery);
1214 }
1215
1216
1217 static struct dm_fuel_gauge_ops fg_ops = {
1218 .bat_is_exist = rk817_bat_bat_is_exist,
1219 .get_soc = rk817_bat_update_get_soc,
1220 .get_voltage = rk817_bat_update_get_voltage,
1221 .get_current = rk817_bat_update_get_current,
1222 .get_chrg_online = rk817_bat_update_get_chrg_online,
1223 };
1224
rk817_fg_ofdata_to_platdata(struct udevice * dev)1225 static int rk817_fg_ofdata_to_platdata(struct udevice *dev)
1226 {
1227 struct rk8xx_priv *rk8xx = dev_get_priv(dev->parent);
1228 struct rk817_battery_device *battery = dev_get_priv(dev);
1229 const char *prop;
1230 int len, value;
1231 int i;
1232
1233 if ((rk8xx->variant != RK817_ID) && (rk8xx->variant != RK809_ID)) {
1234 debug("%s: Not support pmic variant: rk%x\n",
1235 __func__, rk8xx->variant);
1236 return -EINVAL;
1237 }
1238
1239 battery->dev = dev;
1240 battery->variant = rk8xx->variant;
1241 /* Parse ocv table */
1242 prop = dev_read_prop(dev, "ocv_table", &len);
1243 if (!prop) {
1244 printf("can't find ocv_table prop\n");
1245 return -EINVAL;
1246 }
1247
1248 battery->ocv_table = calloc(len, 1);
1249 if (!battery->ocv_table) {
1250 printf("can't calloc ocv_table\n");
1251 return -ENOMEM;
1252 }
1253
1254 battery->ocv_size = len / 4;
1255 if (dev_read_u32_array(dev, "ocv_table",
1256 battery->ocv_table, battery->ocv_size)) {
1257 printf("can't read ocv_table\n");
1258 free(battery->ocv_table);
1259 return -EINVAL;
1260 }
1261
1262 /* Parse neccessay */
1263 battery->design_cap = dev_read_u32_default(dev, "design_capacity", -1);
1264 if (battery->design_cap < 0) {
1265 printf("can't read design_capacity\n");
1266 return -EINVAL;
1267 }
1268
1269 battery->qmax = dev_read_u32_default(dev, "design_qmax", -1);
1270 if (battery->qmax < 0) {
1271 printf("can't read design_qmax\n");
1272 return -EINVAL;
1273 }
1274
1275 battery->virtual_power = dev_read_u32_default(dev, "virtual_power", 0);
1276 if (!rk817_is_bat_exist(battery))
1277 battery->virtual_power = 1;
1278
1279 if (rk8xx->variant == RK809_ID) {
1280 battery->bat_res_up = dev_read_u32_default(dev, "bat_res_up", -1);
1281 if (battery->bat_res_up < 0) {
1282 printf("can't read bat_res_up\n");
1283 return -EINVAL;
1284 }
1285
1286 battery->bat_res_down = dev_read_u32_default(dev, "bat_res_down", -1);
1287 if (battery->bat_res_down < 0) {
1288 printf("can't read bat_res_down\n");
1289 return -EINVAL;
1290 }
1291 }
1292
1293 battery->drv_version = dev_read_u32_default(dev, "drv_version", -1);
1294 if (battery->drv_version < 0)
1295 battery->drv_version = 0;
1296
1297 value = dev_read_u32_default(dev, "sample_res", -1);
1298 if (battery->res_div < 0)
1299 printf("read sample_res error\n");
1300
1301 battery->res_div = (value == SAMPLE_RES_20mR) ?
1302 SAMPLE_RES_DIV2 : SAMPLE_RES_DIV1;
1303
1304 DBG("OCV Value:");
1305 for (i = 0; i < battery->ocv_size; i++)
1306 DBG("%d ", battery->ocv_table[i]);
1307 DBG("ocvsize: %d\n", battery->ocv_size);
1308 DBG("battery->design_cap: %d\n", battery->design_cap);
1309 DBG("battery->qmax: %d\n", battery->qmax);
1310 DBG("battery->bat_res_up: %d\n", battery->bat_res_up);
1311 DBG("battery->bat_res_down: %d\n", battery->bat_res_down);
1312
1313 return 0;
1314 }
1315
rk817_fg_init(struct rk817_battery_device * battery)1316 static int rk817_fg_init(struct rk817_battery_device *battery)
1317 {
1318 int value;
1319
1320 value = rk817_bat_read(battery, GG_CON);
1321 rk817_bat_write(battery, GG_CON, value | VOL_OUPUT_INSTANT_MODE);
1322 if (battery->variant == RK817_ID) {
1323 value = rk817_bat_read(battery, BAT_DISCHRG);
1324 rk817_bat_write(battery, BAT_DISCHRG, value & (~DIS_ILIM_EN));
1325 }
1326 rk817_bat_gas_gaugle_enable(battery);
1327 rk817_bat_init_voltage_kb(battery);
1328 rk817_bat_calibration(battery);
1329 rk817_bat_rsoc_init(battery);
1330 rk817_bat_init_coulomb_cap(battery, battery->nac);
1331 rk817_bat_set_initialized_flag(battery);
1332
1333 battery->voltage_avg = rk817_bat_get_battery_voltage(battery);
1334 battery->voltage_sys = rk817_bat_get_sys_voltage(battery);
1335 battery->voltage_usb = rk817_bat_get_USB_voltage(battery);
1336 battery->current_avg = rk817_bat_get_avg_current(battery);
1337 battery->current_pwron = rk817_bat_get_pwron_current(battery);
1338 battery->remain_cap = rk817_bat_get_capacity_uah(battery);
1339 battery->rsoc = rk817_bat_get_rsoc(battery);
1340 battery->sm_linek = rk817_bat_calc_linek(battery);
1341 battery->chrg_type = rk817_bat_get_charger_type(battery);
1342 battery->finish_chrg_base = get_timer(0);
1343 battery->term_sig_base = get_timer(0);
1344
1345 battery->dbg_pwr_dsoc = battery->dsoc;
1346 battery->dbg_pwr_rsoc = battery->rsoc;
1347 battery->dbg_pwr_vol = battery->voltage_avg;
1348
1349 if (battery->variant == RK817_ID)
1350 rk817_bat_charger_setting(battery, battery->chrg_type);
1351
1352 DBG("voltage_k = %d, voltage_b = %d\n",
1353 battery->voltage_k, battery->voltage_b);
1354 DBG("voltage_sys = %d\n", battery->voltage_sys);
1355 DBG("voltage usb: %d\n", battery->voltage_avg);
1356 DBG("battery: %d\n", battery->voltage_avg);
1357 DBG("current_avg = %d\n", battery->current_avg);
1358 DBG("current_pwron = %d\n", battery->current_pwron);
1359 DBG("remain_cap = %d\n", battery->remain_cap);
1360 DBG("fcc = %d\n", battery->fcc);
1361 DBG("qmax = %d\n", battery->qmax);
1362 DBG("dsoc = %d\n", battery->dsoc);
1363 DBG("rsoc = %d\n", battery->rsoc);
1364 DBG("charge type: %d\n", battery->chrg_type);
1365
1366 return 0;
1367 }
1368
rk817_fg_probe(struct udevice * dev)1369 static int rk817_fg_probe(struct udevice *dev)
1370 {
1371 struct rk8xx_priv *priv = dev_get_priv(dev->parent);
1372 struct rk817_battery_device *battery = dev_get_priv(dev);
1373
1374 if ((priv->variant != RK817_ID) && ((priv->variant != RK809_ID))) {
1375 debug("Not support pmic variant: rk%x\n", priv->variant);
1376 return -EINVAL;
1377 }
1378
1379 return rk817_fg_init(battery);
1380 }
1381
1382 U_BOOT_DRIVER(rk817_fg) = {
1383 .name = "rk817_fg",
1384 .id = UCLASS_FG,
1385 .probe = rk817_fg_probe,
1386 .ops = &fg_ops,
1387 .ofdata_to_platdata = rk817_fg_ofdata_to_platdata,
1388 .priv_auto_alloc_size = sizeof(struct rk817_battery_device),
1389 };
1390