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;
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_VOL_ADC_EN BIT(4)
140 #define SYS_VOL_ADC_EN BIT(6)
141
142 #define PMIC_CHRG_OUT 0x00E4
143 #define USB_CTRL_REG 0x00E5
144 #define PMIC_CHRG_TERM 0x00E6
145 #define BAT_LTS_TS 0x00E9
146 #define PMIC_SYS_STS 0x00f0
147 #define PLUG_IN_STS BIT(6)
148
149 #define CHRG_TERM_DSOC 90
150 #define CHRG_TERM_K 650
151 #define CHRG_FULL_K 400
152 #define CHARGE_FINISH (0x04 << 4)
153
154 /* CALI PARAM */
155 #define FINISH_CALI_CURR 1500
156 #define TERM_CALI_CURR 600
157 #define VIRTUAL_POWER_VOL 4200
158 #define VIRTUAL_POWER_CUR 1000
159 #define VIRTUAL_POWER_SOC 66
160 #define SECONDS(n) ((n) * 1000)
161
162 /* CHRG_CTRL_REG */
163 #define ILIM_450MA (0x00)
164 #define ILIM_2000MA (0x07)
165 #define ILIM_1500MA (0x03)
166 #define VLIM_4500MV (0x50)
167
168 enum charge_current {
169 CHRG_CUR_1000MA,
170 CHRG_CUR_1500MA,
171 CHRG_CUR_2000MA,
172 CHRG_CUR_2500MA,
173 CHRG_CUR_2750MA,
174 CHRG_CUR_3000MA,
175 CHRG_CUR_3500MA,
176 CHRG_CUR_500MA,
177 };
178
179 enum charge_voltage {
180 CHRG_VOL_4100MV,
181 CHRG_VOL_4150MV,
182 CHRG_VOL_4200MV,
183 CHRG_VOL_4250MV,
184 CHRG_VOL_4300MV,
185 CHRG_VOL_4350MV,
186 CHRG_VOL_4400MV,
187 CHRG_VOL_4450MV,
188 };
189
190 /* sample resistor and division */
191 #define SAMPLE_RES_10mR 10
192 #define SAMPLE_RES_20mR 20
193
194 #define CHRG_CT_EN BIT(1)
195 #define MIN_FCC 500
196 #define CAP_INVALID BIT(7)
197 #define DIS_ILIM_EN BIT(3)
198
199 /* USB_CTRL_REG */
200 #define INPUT_CUR_MSK 0x0f
201 #define INPUT_VOL_MSK 0xf0
202 #define CHARGER_CUR_MSK 0x07
203 #define CHARGER_VOL_MSK 0x70
204
205 #define VOL_OUPUT_INSTANT_MODE 0x02
206
207 #define ADC_TO_CURRENT(adc_value, samp_res) \
208 (adc_value * 1720 / 1000 / samp_res)
209 #define CURRENT_TO_ADC(current, samp_res) \
210 (current * 1000 * samp_res / 1720)
211
212 #define ADC_TO_CAPACITY(adc_value, samp_res) \
213 (adc_value / 1000 * 1720 / 3600 / samp_res)
214 #define CAPACITY_TO_ADC(capacity, samp_res) \
215 (capacity * samp_res * 3600 / 1720 * 1000)
216
217 #define ADC_TO_CAPACITY_UAH(adc_value, samp_res) \
218 (adc_value / 3600 * 1720 / samp_res)
219 #define ADC_TO_CAPACITY_MAH(adc_value, samp_res) \
220 (adc_value / 1000 * 1720 / 3600 / samp_res)
221
222 enum tscur_sel {
223 FLOW_OUT_10UA,
224 FLOW_OUT_20UA,
225 FLOW_OUT_30UA,
226 FLOW_OUT_40UA,
227 };
228
229 /* charger type definition */
230 enum charger_type {
231 NO_CHARGER = 0,
232 USB_CHARGER,
233 AC_CHARGER,
234 DC_CHARGER,
235 UNDEF_CHARGER,
236 };
237
238 enum power_supply_type {
239 POWER_SUPPLY_TYPE_UNKNOWN = 0,
240 POWER_SUPPLY_TYPE_USB, /* Standard Downstream Port */
241 POWER_SUPPLY_TYPE_USB_DCP, /* Dedicated Charging Port */
242 POWER_SUPPLY_TYPE_USB_CDP, /* Charging Downstream Port */
243 POWER_SUPPLY_TYPE_USB_FLOATING, /* DCP without shorting D+/D- */
244 };
245
246 struct temp_chrg_table {
247 int temp_down;
248 int temp_up;
249 int chrg_current;
250 int chrg_voltage;
251 int chrg_current_index;
252 int chrg_voltage_index;
253 };
254
255 struct rk817_battery_device {
256 struct udevice *dev;
257 int res_div;
258 bool is_first_power_on;
259 bool is_initialized;
260 bool bat_first_power_on;
261 int current_avg;
262 int current_pwron;
263 int voltage_usb;
264 int voltage_sys;
265 int voltage_avg;
266 int voltage_k;/* VCALIB0 VCALIB1 */
267 int voltage_b;
268 u32 remain_cap;
269 int design_cap;
270 int nac;
271 int fcc;
272 int qmax;
273 int dsoc;
274 int rsoc;
275 int pwron_voltage;
276 int sm_linek;
277 int sm_old_cap;
278 int smooth_soc;
279 u8 halt_cnt;
280 bool is_halt;
281 int dbg_pwr_dsoc;
282 int dbg_pwr_rsoc;
283 int dbg_pwr_vol;
284 int adc_allow_update;
285 int pwroff_min;
286 int chrg_cur_input;
287 u32 *ocv_table;
288 int ocv_size;
289 u32 design_capacity;
290 u32 max_soc_offset;
291 u32 virtual_power;
292 u32 chrg_type;
293 ulong finish_chrg_base;
294 ulong term_sig_base;
295 int contact_res;
296 int ntc_factor;
297 u32 bat_res_up;
298 u32 bat_res_down;
299 u32 variant;
300 int drv_version;
301 struct temp_chrg_table *tc_table;
302 int charge_index;
303 int tc_count;
304 u32 *ntc_table;
305 u32 ntc_size;
306 int ntc_degree_from;
307 int temperature;
308 u32 *ntc_from;
309 int stop_smooth;
310 };
311
interpolate(int value,u32 * table,int size)312 static u32 interpolate(int value, u32 *table, int size)
313 {
314 u8 i;
315 u16 d;
316
317 for (i = 0; i < size; i++) {
318 if (value < table[i])
319 break;
320 }
321
322 if ((i > 0) && (i < size)) {
323 d = (value - table[i - 1]) * (MAX_INTERPOLATE / (size - 1));
324 d /= table[i] - table[i - 1];
325 d = d + (i - 1) * (MAX_INTERPOLATE / (size - 1));
326 } else {
327 d = i * ((MAX_INTERPOLATE + size / 2) / size);
328 }
329
330 if (d > 1000)
331 d = 1000;
332
333 return d;
334 }
335
336 /* (a * b) / c */
ab_div_c(u32 a,u32 b,u32 c)337 static int32_t ab_div_c(u32 a, u32 b, u32 c)
338 {
339 bool sign;
340 u32 ans = MAX_INT;
341 int tmp;
342
343 sign = ((((a ^ b) ^ c) & 0x80000000) != 0);
344 if (c != 0) {
345 if (sign)
346 c = -c;
347 tmp = (a * b + (c >> 1)) / c;
348 if (tmp < MAX_INT)
349 ans = tmp;
350 }
351
352 if (sign)
353 ans = -ans;
354
355 return ans;
356 }
357
rk817_bat_read(struct rk817_battery_device * battery,u8 reg)358 static int rk817_bat_read(struct rk817_battery_device *battery, u8 reg)
359 {
360 return pmic_reg_read(battery->dev->parent, reg);
361 }
362
rk817_bat_write(struct rk817_battery_device * battery,u8 reg,u8 buf)363 static void rk817_bat_write(struct rk817_battery_device *battery,
364 u8 reg, u8 buf)
365 {
366 pmic_reg_write(battery->dev->parent, reg, buf);
367 }
368
rk817_bat_get_vaclib0(struct rk817_battery_device * battery)369 static int rk817_bat_get_vaclib0(struct rk817_battery_device *battery)
370 {
371 int vcalib_value = 0;
372
373 vcalib_value |= rk817_bat_read(battery, VCALIB0_H) << 8;
374 vcalib_value |= rk817_bat_read(battery, VCALIB0_L);
375
376 return vcalib_value;
377 }
378
rk817_bat_get_vaclib1(struct rk817_battery_device * battery)379 static int rk817_bat_get_vaclib1(struct rk817_battery_device *battery)
380 {
381 int vcalib_value = 0;
382
383 vcalib_value |= rk817_bat_read(battery, VCALIB1_H) << 8;
384 vcalib_value |= rk817_bat_read(battery, VCALIB1_L);
385
386 return vcalib_value;
387 }
388
rk817_bat_get_bat_ts(struct rk817_battery_device * battery)389 static int rk817_bat_get_bat_ts(struct rk817_battery_device *battery)
390 {
391 int temp_value = 0;
392
393 temp_value = rk817_bat_read(battery, BAT_TS_H) << 8;
394 temp_value |= rk817_bat_read(battery, BAT_TS_L);
395
396 return temp_value;
397 }
398
rk817_bat_init_voltage_kb(struct rk817_battery_device * battery)399 static void rk817_bat_init_voltage_kb(struct rk817_battery_device *battery)
400 {
401 int vcalib0, vcalib1;
402
403 vcalib0 = rk817_bat_get_vaclib0(battery);
404 vcalib1 = rk817_bat_get_vaclib1(battery);
405
406 if (battery->variant == RK809_ID) {
407 battery->voltage_k = (1050 - 600) * 1000 / DIV(vcalib1 - vcalib0);
408 battery->voltage_b = 1050 - (battery->voltage_k * vcalib1) / 1000;
409 } else {
410 battery->voltage_k = (4025 - 2300) * 1000 / DIV(vcalib1 - vcalib0);
411 battery->voltage_b = 4025 - (battery->voltage_k * vcalib1) / 1000;
412 }
413 }
414
415 /* power on battery voltage */
rk817_bat_get_pwron_voltage(struct rk817_battery_device * battery)416 static int rk817_bat_get_pwron_voltage(struct rk817_battery_device *battery)
417 {
418 int vol, val = 0, vol_temp;
419
420 val = rk817_bat_read(battery, PWRON_VOL_H) << 8;
421 val |= rk817_bat_read(battery, PWRON_VOL_L);
422 vol = battery->voltage_k * val / 1000 + battery->voltage_b;
423 if (battery->variant == RK809_ID) {
424 vol_temp = (vol * battery->bat_res_up / battery->bat_res_down + vol);
425 vol = vol_temp;
426 }
427
428 return vol;
429 }
430
rk817_bat_get_USB_voltage(struct rk817_battery_device * battery)431 static int rk817_bat_get_USB_voltage(struct rk817_battery_device *battery)
432 {
433 int vol, val = 0, vol_temp;
434
435 val = rk817_bat_read(battery, USB_VOL_L) << 0;
436 val |= rk817_bat_read(battery, USB_VOL_H) << 8;
437
438 vol = (battery->voltage_k * val / 1000 + battery->voltage_b) * 60 / 46;
439 if (battery->variant == RK809_ID) {
440 vol_temp = vol * battery->bat_res_up / battery->bat_res_down + vol;
441 vol = vol_temp;
442 }
443
444 return vol;
445 }
446
rk817_bat_get_sys_voltage(struct rk817_battery_device * battery)447 static int rk817_bat_get_sys_voltage(struct rk817_battery_device *battery)
448 {
449 int vol, val = 0, vol_temp;
450
451 val = rk817_bat_read(battery, SYS_VOL_H) << 8;
452 val |= rk817_bat_read(battery, SYS_VOL_L) << 0;
453
454 vol = (battery->voltage_k * val / 1000 + battery->voltage_b) * 60 / 46;
455 if (battery->variant == RK809_ID) {
456 vol_temp = vol * battery->bat_res_up / battery->bat_res_down + vol;
457 vol = vol_temp;
458 }
459
460 return vol;
461 }
462
rk817_bat_get_battery_voltage(struct rk817_battery_device * battery)463 static int rk817_bat_get_battery_voltage(struct rk817_battery_device *battery)
464 {
465 int vol, val = 0, vol_temp;
466
467 val = rk817_bat_read(battery, BAT_VOL_H) << 8;
468 val |= rk817_bat_read(battery, BAT_VOL_L) << 0;
469
470 vol = battery->voltage_k * val / 1000 + battery->voltage_b;
471 if (battery->variant == RK809_ID) {
472 vol_temp = (vol * battery->bat_res_up / battery->bat_res_down + vol);
473 vol = vol_temp;
474 }
475 return vol;
476 }
477
rk817_bat_get_avg_current(struct rk817_battery_device * battery)478 static int rk817_bat_get_avg_current(struct rk817_battery_device *battery)
479 {
480 int cur, val = 0;
481
482 val |= rk817_bat_read(battery, BAT_CUR);
483 val |= rk817_bat_read(battery, BAT_CUR_H) << 8;
484
485 if (val & 0x8000)
486 val -= 0x10000;
487
488 cur = ADC_TO_CURRENT(val, battery->res_div);
489
490 return cur;
491 }
492
rk817_bat_get_pwron_current(struct rk817_battery_device * battery)493 static int rk817_bat_get_pwron_current(struct rk817_battery_device *battery)
494 {
495 int cur, val = 0;
496
497 val |= rk817_bat_read(battery, PWRON_CUR_L);
498 val |= rk817_bat_read(battery, PWRON_CUR_H) << 8;
499
500 if (val & 0x8000)
501 val -= 0x10000;
502 cur = ADC_TO_CURRENT(val, battery->res_div);
503
504 return cur;
505 }
506
rk817_bat_calibration(struct rk817_battery_device * battery)507 static void rk817_bat_calibration(struct rk817_battery_device *battery)
508 {
509 int ioffset_value = 0;
510 int temp;
511 u8 buf = 0;
512
513 if (rk817_bat_read(battery, ADC_CONFIG1) & 0x80) {
514 ioffset_value = rk817_bat_read(battery, IOFFSET_H) << 8;
515 ioffset_value |= rk817_bat_read(battery, IOFFSET_L);
516
517 buf = (ioffset_value >> 8) & 0xff;
518 rk817_bat_write(battery, CAL_OFFSET_H, buf);
519 buf = (ioffset_value >> 0) & 0xff;
520 rk817_bat_write(battery, CAL_OFFSET_L, buf);
521
522 rk817_bat_init_voltage_kb(battery);
523 temp = rk817_bat_read(battery, ADC_CONFIG1);
524 rk817_bat_write(battery, ADC_CONFIG1, temp | 0x80);
525 }
526 }
527
rk817_bat_set_charger_current(struct rk817_battery_device * battery,int charger_current_sel)528 static void rk817_bat_set_charger_current(struct rk817_battery_device *battery,
529 int charger_current_sel)
530 {
531 u8 charger_current;
532
533 charger_current = rk817_bat_read(battery, PMIC_CHRG_OUT);
534 charger_current &= ~CHARGER_CUR_MSK;
535 charger_current |= ((charger_current_sel) | 0x08);
536 rk817_bat_write(battery, PMIC_CHRG_OUT, charger_current);
537 }
538
rk817_bat_set_charger_voltage(struct rk817_battery_device * battery,int charger_voltage_sel)539 static void rk817_bat_set_charger_voltage(struct rk817_battery_device *battery,
540 int charger_voltage_sel)
541 {
542 u8 charger_voltage;
543
544 charger_voltage = rk817_bat_read(battery, PMIC_CHRG_OUT);
545 charger_voltage &= ~CHARGER_VOL_MSK;
546 charger_voltage |= (charger_voltage_sel << 4);
547 rk817_bat_write(battery, PMIC_CHRG_OUT, charger_voltage);
548 }
549
rk817_bat_enable_usb2vsys(struct rk817_battery_device * battery)550 void rk817_bat_enable_usb2vsys(struct rk817_battery_device *battery)
551 {
552 int usb2sys;
553
554 DBG("enable usb2vsys!!!\n");
555 usb2sys = rk817_bat_read(battery, PMIC_CHRG_TERM);
556 usb2sys |= (0x01 << 6);
557 rk817_bat_write(battery, PMIC_CHRG_TERM, usb2sys);
558 }
559
rk817_bat_disable_usb2vsys(struct rk817_battery_device * battery)560 void rk817_bat_disable_usb2vsys(struct rk817_battery_device *battery)
561 {
562 int usb2sys;
563
564 if (battery->voltage_avg < 3800)
565 return;
566 DBG("disable usb2vsys!!!\n");
567 usb2sys = rk817_bat_read(battery, PMIC_CHRG_TERM);
568 usb2sys &= ~(0x01 << 6);
569 rk817_bat_write(battery, PMIC_CHRG_TERM, usb2sys);
570 }
571
rk817_bat_enable_charge(struct rk817_battery_device * battery)572 void rk817_bat_enable_charge(struct rk817_battery_device *battery)
573 {
574 DBG("enable charge by BAT_LTS_TS\n");
575 rk817_bat_write(battery, BAT_LTS_TS, 0xFF);
576 }
577
rk817_bat_disable_charge(struct rk817_battery_device * battery)578 void rk817_bat_disable_charge(struct rk817_battery_device *battery)
579 {
580 DBG("disable charge by BAT_LTS_TS\n");
581 rk817_bat_write(battery, BAT_LTS_TS, 0x00);
582 }
583
rk817_bat_get_nts_res(struct rk817_battery_device * battery)584 static int rk817_bat_get_nts_res(struct rk817_battery_device *battery)
585 {
586 int temp_value, res;
587 int adc_to_vol;
588 int bat_current;
589
590 temp_value = rk817_bat_get_bat_ts(battery);
591 adc_to_vol = temp_value * 1200 / 65536;
592 bat_current = rk817_bat_get_avg_current(battery);
593 res = (adc_to_vol * 1000 - bat_current * battery->contact_res) /
594 battery->ntc_factor;
595
596 DBG("res: %d,adc_to_vol: %d, bat_current: %d, ntc_factor: %d\n",
597 res, adc_to_vol, bat_current, battery->ntc_factor);
598
599 return res;
600 }
601
rk817_bat_init_ts_detect(struct rk817_battery_device * battery)602 static void rk817_bat_init_ts_detect(struct rk817_battery_device *battery)
603 {
604 int value;
605
606 /* the adc of ts1 controlled bit: enable */
607 value = rk817_bat_read(battery, ADC_CONFIG0);
608 rk817_bat_write(battery, ADC_CONFIG0, value | 0x20);
609
610 /* source current to TS pin */
611 value = rk817_bat_read(battery, ADC_CONFIG1);
612 rk817_bat_write(battery, ADC_CONFIG1, value & 0xf7);
613
614 /* ts pin flow out current in active state */
615 value = rk817_bat_read(battery, ADC_CONFIG1);
616 value &= 0xcf;
617 value |= (FLOW_OUT_20UA << 4);
618 rk817_bat_write(battery, ADC_CONFIG1, value);
619 battery->ntc_factor = (FLOW_OUT_20UA + 1) * 10;
620 }
621
rk817_bat_decode_chrg_voltage(u32 chrg_voltage)622 static u8 rk817_bat_decode_chrg_voltage(u32 chrg_voltage)
623 {
624 if (chrg_voltage == 0)
625 return 0xff;
626
627 if (chrg_voltage < 4150)
628 return CHRG_VOL_4100MV;
629 else if (chrg_voltage < 4200)
630 return CHRG_VOL_4100MV;
631 else if (chrg_voltage < 4250)
632 return CHRG_VOL_4200MV;
633 else if (chrg_voltage < 4300)
634 return CHRG_VOL_4250MV;
635 else if (chrg_voltage < 4350)
636 return CHRG_VOL_4300MV;
637 else if (chrg_voltage < 4400)
638 return CHRG_VOL_4350MV;
639 else if (chrg_voltage < 4450)
640 return CHRG_VOL_4400MV;
641 else
642 return CHRG_VOL_4450MV;
643 }
644
rk817_bat_decode_chrg_current(struct rk817_battery_device * battery,u32 chrg_current)645 static u8 rk817_bat_decode_chrg_current(struct rk817_battery_device *battery,
646 u32 chrg_current)
647 {
648 int val;
649
650 if (chrg_current == 0)
651 return 0xff;
652
653 val = chrg_current * battery->res_div / 10;
654 if (val < 1000)
655 return CHRG_CUR_500MA;
656 else if (val < 1500)
657 return CHRG_CUR_1000MA;
658 else if (val < 2000)
659 return CHRG_CUR_1500MA;
660 else if (val < 2500)
661 return CHRG_CUR_2000MA;
662 else if (val < 2750)
663 return CHRG_CUR_2500MA;
664 else if (val < 3000)
665 return CHRG_CUR_2750MA;
666 else if (val < 3500)
667 return CHRG_CUR_3000MA;
668 else
669 return CHRG_CUR_3500MA;
670 }
671
rk817_bat_temperature_chrg(struct rk817_battery_device * battery,int now_temp)672 static void rk817_bat_temperature_chrg(struct rk817_battery_device *battery,
673 int now_temp)
674 {
675 int i, up_temp, down_temp;
676
677 for (i = 0; i < battery->tc_count; i++) {
678 up_temp = battery->tc_table[i].temp_up;
679 down_temp = battery->tc_table[i].temp_down;
680
681 if (now_temp >= down_temp && now_temp <= up_temp) {
682 /* Temp range or charger are not update, return */
683 if (battery->charge_index == i) {
684 DBG("charger voltage: %d, index: %d\n",
685 battery->tc_table[i].chrg_voltage,
686 battery->tc_table[i].chrg_voltage_index);
687 DBG("charger current: %d, index: %d\n",
688 battery->tc_table[i].chrg_current,
689 battery->tc_table[i].chrg_current_index);
690 return;
691 }
692
693 if (battery->tc_table[i].chrg_current != 0 &&
694 battery->tc_table[i].chrg_current_index != 0xff) {
695 if (battery->voltage_avg < 3500)
696 rk817_bat_set_charger_current(battery, CHRG_CUR_500MA);
697 else
698 rk817_bat_set_charger_current(battery,
699 battery->tc_table[i].chrg_current_index);
700 DBG("T change: charger current: %d, index: %d\n",
701 battery->tc_table[i].chrg_current,
702 battery->tc_table[i].chrg_current_index);
703 }
704
705 if (battery->tc_table[i].chrg_voltage != 0 &&
706 battery->tc_table[i].chrg_voltage_index != 0xff) {
707 rk817_bat_disable_usb2vsys(battery);
708 rk817_bat_set_charger_voltage(battery,
709 battery->tc_table[i].chrg_voltage_index);
710 rk817_bat_enable_usb2vsys(battery);
711 DBG("T change: charger voltage: %d, index: %d\n",
712 battery->tc_table[i].chrg_voltage,
713 battery->tc_table[i].chrg_voltage_index);
714 }
715
716 battery->charge_index = i;
717 }
718 }
719
720 if (now_temp < battery->tc_table[0].temp_down ||
721 now_temp > battery->tc_table[battery->tc_count - 1].temp_up) {
722 DBG("now temp: %d, (%d, %d) disable charge\n",
723 now_temp, battery->tc_table[0].temp_down,
724 battery->tc_table[battery->tc_count - 1].temp_up);
725 rk817_bat_disable_charge(battery);
726 } else {
727 rk817_bat_enable_charge(battery);
728 }
729 }
730
rk817_bat_update_temperature(struct rk817_battery_device * battery)731 static void rk817_bat_update_temperature(struct rk817_battery_device *battery)
732 {
733 u32 ntc_size, *ntc_table;
734 int i = 0, res = 0;
735
736 ntc_table = battery->ntc_table;
737 ntc_size = battery->ntc_size;
738
739 if (ntc_size) {
740 res = rk817_bat_get_nts_res(battery);
741 if (res == 0)
742 return;
743
744 DBG("<%d %d %d>\n", ntc_table[0], ntc_table[ntc_size - 1], ntc_size);
745 if (res < ntc_table[ntc_size - 1]) {
746 battery->temperature = 650;
747 DBG("bat ntc upper max degree: r=%d\n", res);
748 } else if (res > ntc_table[0]) {
749 battery->temperature = (battery->ntc_degree_from) * 10;
750 DBG("bat ntc lower min degree: r=%d\n", res);
751 } else {
752 for (i = 0; i < ntc_size; i++) {
753 if (res >= ntc_table[i])
754 break;
755 }
756 if (i <= 0)
757 battery->temperature = (battery->ntc_degree_from) * 10;
758 else
759 battery->temperature = (i + battery->ntc_degree_from) * 10;
760 }
761 DBG("Temperature: %d\n", battery->temperature);
762 rk817_bat_temperature_chrg(battery, battery->temperature / 10);
763 }
764 }
765
766 static int rk817_bat_get_rsoc(struct rk817_battery_device *battery);
767
rk817_bat_init_coulomb_cap(struct rk817_battery_device * battery,u32 capacity)768 static void rk817_bat_init_coulomb_cap(struct rk817_battery_device *battery,
769 u32 capacity)
770 {
771 u8 buf;
772 u32 cap;
773 u32 val;
774
775 cap = CAPACITY_TO_ADC(capacity, battery->res_div);
776 do {
777 buf = (cap >> 24) & 0xff;
778 rk817_bat_write(battery, Q_INIT_H3, buf);
779 buf = (cap >> 16) & 0xff;
780 rk817_bat_write(battery, Q_INIT_H2, buf);
781 buf = (cap >> 8) & 0xff;
782 rk817_bat_write(battery, Q_INIT_L1, buf);
783
784 buf = (cap >> 0) & 0xff;
785 val = rk817_bat_read(battery, Q_INIT_L0);
786 if (val == buf) {
787 rk817_bat_write(battery, Q_INIT_L0, buf + 1);
788 cap += 1;
789 } else {
790 rk817_bat_write(battery, Q_INIT_L0, buf);
791 }
792 val = rk817_bat_read(battery, Q_INIT_H3) << 24;
793 val |= rk817_bat_read(battery, Q_INIT_H2) << 16;
794 val |= rk817_bat_read(battery, Q_INIT_L1) << 8;
795 val |= rk817_bat_read(battery, Q_INIT_L0) << 0;
796 } while (cap != val);
797
798 battery->rsoc = rk817_bat_get_rsoc(battery);
799 battery->remain_cap = capacity * 1000;
800 }
801
rk817_bat_remain_cap_is_valid(struct rk817_battery_device * battery)802 static bool rk817_bat_remain_cap_is_valid(struct rk817_battery_device *battery)
803 {
804 return !(rk817_bat_read(battery, Q_PRES_H3) & CAP_INVALID);
805 }
806
rk817_bat_get_capacity_uah(struct rk817_battery_device * battery)807 static u32 rk817_bat_get_capacity_uah(struct rk817_battery_device *battery)
808 {
809 u32 val = 0, capacity = 0;
810
811 if (rk817_bat_remain_cap_is_valid(battery)) {
812 val = rk817_bat_read(battery, Q_PRES_H3) << 24;
813 val |= rk817_bat_read(battery, Q_PRES_H2) << 16;
814 val |= rk817_bat_read(battery, Q_PRES_L1) << 8;
815 val |= rk817_bat_read(battery, Q_PRES_L0) << 0;
816
817 capacity = ADC_TO_CAPACITY_UAH(val, battery->res_div);
818 }
819
820 return capacity;
821 }
822
rk817_bat_get_capacity_mah(struct rk817_battery_device * battery)823 static int rk817_bat_get_capacity_mah(struct rk817_battery_device *battery)
824 {
825 int val, capacity = 0;
826
827 if (rk817_bat_remain_cap_is_valid(battery)) {
828 val = rk817_bat_read(battery, Q_PRES_H3) << 24;
829 val |= rk817_bat_read(battery, Q_PRES_H2) << 16;
830 val |= rk817_bat_read(battery, Q_PRES_L1) << 8;
831 val |= rk817_bat_read(battery, Q_PRES_L0) << 0;
832 capacity = ADC_TO_CAPACITY(val, battery->res_div);
833 }
834
835 return capacity;
836 }
837
rk817_bat_save_cap(struct rk817_battery_device * battery,int capacity)838 static void rk817_bat_save_cap(struct rk817_battery_device *battery,
839 int capacity)
840 {
841 u8 buf;
842 static u32 old_cap;
843
844 if (capacity >= battery->qmax)
845 capacity = battery->qmax;
846 if (capacity <= 0)
847 capacity = 0;
848 if (old_cap == capacity)
849 return;
850
851 old_cap = capacity;
852 buf = (capacity >> 16) & 0xff;
853 rk817_bat_write(battery, REMAIN_CAP_REG2, buf);
854 buf = (capacity >> 8) & 0xff;
855 rk817_bat_write(battery, REMAIN_CAP_REG1, buf);
856 buf = (capacity >> 0) & 0xff;
857 rk817_bat_write(battery, REMAIN_CAP_REG0, buf);
858 }
859
rk817_bat_get_rsoc(struct rk817_battery_device * battery)860 static int rk817_bat_get_rsoc(struct rk817_battery_device *battery)
861 {
862 int remain_cap;
863
864 remain_cap = rk817_bat_get_capacity_uah(battery);
865
866 return remain_cap * 100 / DIV(battery->fcc);
867 }
868
rk817_bat_vol_to_soc(struct rk817_battery_device * battery,int voltage)869 static int rk817_bat_vol_to_soc(struct rk817_battery_device *battery,
870 int voltage)
871 {
872 u32 *ocv_table, temp;
873 int ocv_size, ocv_soc;
874
875 ocv_table = battery->ocv_table;
876 ocv_size = battery->ocv_size;
877 temp = interpolate(voltage, ocv_table, ocv_size);
878 ocv_soc = ab_div_c(temp, MAX_PERCENTAGE, MAX_INTERPOLATE);
879
880 return ocv_soc;
881 }
882
rk817_bat_vol_to_cap(struct rk817_battery_device * battery,int voltage)883 static int rk817_bat_vol_to_cap(struct rk817_battery_device *battery,
884 int voltage)
885 {
886 u32 *ocv_table, temp;
887 int ocv_size, capacity;
888
889 ocv_table = battery->ocv_table;
890 ocv_size = battery->ocv_size;
891 temp = interpolate(voltage, ocv_table, ocv_size);
892 capacity = ab_div_c(temp, battery->fcc, MAX_INTERPOLATE);
893
894 return capacity;
895 }
896
rk817_bat_save_dsoc(struct rk817_battery_device * battery,int save_soc)897 static void rk817_bat_save_dsoc(struct rk817_battery_device *battery,
898 int save_soc)
899 {
900 static int last_soc = -1;
901
902 if (last_soc != save_soc) {
903 rk817_bat_write(battery, SOC_REG0, save_soc & 0xff);
904 rk817_bat_write(battery, SOC_REG1, (save_soc >> 8) & 0xff);
905 rk817_bat_write(battery, SOC_REG2, (save_soc >> 16) & 0xff);
906
907 last_soc = save_soc;
908 }
909 }
910
rk817_bat_get_prev_dsoc(struct rk817_battery_device * battery)911 static int rk817_bat_get_prev_dsoc(struct rk817_battery_device *battery)
912 {
913 int value;
914
915 value = rk817_bat_read(battery, SOC_REG0);
916 value |= rk817_bat_read(battery, SOC_REG1) << 8;
917 value |= rk817_bat_read(battery, SOC_REG2) << 16;
918
919 return value;
920 }
921
rk817_bat_get_prev_cap(struct rk817_battery_device * battery)922 static int rk817_bat_get_prev_cap(struct rk817_battery_device *battery)
923 {
924 int val = 0;
925
926 val = rk817_bat_read(battery, REMAIN_CAP_REG2) << 16;
927 val |= rk817_bat_read(battery, REMAIN_CAP_REG1) << 8;
928 val |= rk817_bat_read(battery, REMAIN_CAP_REG0) << 0;
929
930 return val;
931 }
932
rk817_bat_gas_gaugle_enable(struct rk817_battery_device * battery)933 static void rk817_bat_gas_gaugle_enable(struct rk817_battery_device *battery)
934 {
935 int value;
936
937 value = rk817_bat_read(battery, ADC_CONFIG0);
938 rk817_bat_write(battery, ADC_CONFIG0, value | 0x80);
939 }
940
is_rk817_bat_first_pwron(struct rk817_battery_device * battery)941 static bool is_rk817_bat_first_pwron(struct rk817_battery_device *battery)
942 {
943 int value;
944
945 value = rk817_bat_read(battery, GG_STS);
946
947 if (value & BAT_CON) {
948 rk817_bat_write(battery, GG_STS, value & (~BAT_CON));
949 return true;
950 }
951
952 return false;
953 }
954
rk817_bat_get_off_count(struct rk817_battery_device * battery)955 static int rk817_bat_get_off_count(struct rk817_battery_device *battery)
956 {
957 int value;
958
959 value = rk817_bat_read(battery, OFF_CNT);
960 rk817_bat_write(battery, OFF_CNT, 0x00);
961
962 return value;
963 }
964
rk817_bat_update_qmax(struct rk817_battery_device * battery,u32 capacity)965 static void rk817_bat_update_qmax(struct rk817_battery_device *battery,
966 u32 capacity)
967 {
968 u8 buf;
969 u32 cap_adc;
970
971 cap_adc = CAPACITY_TO_ADC(capacity, battery->res_div);
972 buf = (cap_adc >> 24) & 0xff;
973 rk817_bat_write(battery, Q_MAX_H3, buf);
974 buf = (cap_adc >> 16) & 0xff;
975 rk817_bat_write(battery, Q_MAX_H2, buf);
976 buf = (cap_adc >> 8) & 0xff;
977 rk817_bat_write(battery, Q_MAX_L1, buf);
978 buf = (cap_adc >> 0) & 0xff;
979 rk817_bat_write(battery, Q_MAX_L0, buf);
980
981 battery->qmax = capacity;
982 }
983
rk817_bat_save_fcc(struct rk817_battery_device * battery,int fcc)984 static void rk817_bat_save_fcc(struct rk817_battery_device *battery, int fcc)
985 {
986 u8 buf;
987
988 buf = (fcc >> 16) & 0xff;
989 rk817_bat_write(battery, NEW_FCC_REG2, buf);
990 buf = (fcc >> 8) & 0xff;
991 rk817_bat_write(battery, NEW_FCC_REG1, buf);
992 buf = (fcc >> 0) & 0xff;
993 rk817_bat_write(battery, NEW_FCC_REG0, buf);
994 }
995
rk817_bat_first_pwron(struct rk817_battery_device * battery)996 static void rk817_bat_first_pwron(struct rk817_battery_device *battery)
997 {
998 battery->rsoc =
999 rk817_bat_vol_to_soc(battery,
1000 battery->pwron_voltage) * 1000;/* uAH */
1001 battery->dsoc = battery->rsoc;
1002 battery->fcc = battery->design_cap;
1003
1004 battery->nac = rk817_bat_vol_to_cap(battery,
1005 battery->pwron_voltage);
1006
1007 rk817_bat_update_qmax(battery, battery->qmax);
1008 rk817_bat_save_fcc(battery, battery->fcc);
1009 DBG("%s, rsoc = %d, dsoc = %d, fcc = %d, nac = %d\n",
1010 __func__, battery->rsoc, battery->dsoc, battery->fcc, battery->nac);
1011 }
1012
rk817_bat_get_fcc(struct rk817_battery_device * battery)1013 static int rk817_bat_get_fcc(struct rk817_battery_device *battery)
1014 {
1015 u32 fcc = 0;
1016
1017 fcc = rk817_bat_read(battery, NEW_FCC_REG2) << 16;
1018 fcc |= rk817_bat_read(battery, NEW_FCC_REG1) << 8;
1019 fcc |= rk817_bat_read(battery, NEW_FCC_REG0) << 0;
1020
1021 if (fcc < MIN_FCC) {
1022 DBG("invalid fcc(%d), use design cap", fcc);
1023 fcc = battery->design_capacity;
1024 rk817_bat_save_fcc(battery, fcc);
1025 } else if (fcc > battery->qmax) {
1026 DBG("invalid fcc(%d), use qmax", fcc);
1027 fcc = battery->qmax;
1028 rk817_bat_save_fcc(battery, fcc);
1029 }
1030
1031 return fcc;
1032 }
1033
rk817_bat_inc_halt_cnt(struct rk817_battery_device * battery)1034 static void rk817_bat_inc_halt_cnt(struct rk817_battery_device *battery)
1035 {
1036 u8 cnt;
1037
1038 cnt = rk817_bat_read(battery, HALT_CNT_REG);
1039 rk817_bat_write(battery, HALT_CNT_REG, ++cnt);
1040 }
1041
is_rk817_bat_last_halt(struct rk817_battery_device * battery)1042 static bool is_rk817_bat_last_halt(struct rk817_battery_device *battery)
1043 {
1044 int pre_cap = rk817_bat_get_prev_cap(battery);
1045 int now_cap = rk817_bat_get_capacity_mah(battery);
1046
1047 battery->nac = rk817_bat_vol_to_cap(battery,
1048 battery->pwron_voltage);
1049
1050 /* over 10%: system halt last time */
1051 if (now_cap > pre_cap) {
1052 if (abs(now_cap - pre_cap) > (battery->fcc / 10)) {
1053 rk817_bat_inc_halt_cnt(battery);
1054 return true;
1055 } else {
1056 return false;
1057 }
1058 } else {
1059 if (abs(battery->nac - pre_cap) > (battery->fcc / 5)) {
1060 rk817_bat_inc_halt_cnt(battery);
1061 return true;
1062 } else {
1063 return false;
1064 }
1065 }
1066 }
1067
rk817_bat_adc_init(struct rk817_battery_device * battery)1068 static void rk817_bat_adc_init(struct rk817_battery_device *battery)
1069 {
1070 int value;
1071
1072 value = rk817_bat_read(battery, ADC_CONFIG0);
1073 value |= USB_VOL_ADC_EN | SYS_VOL_ADC_EN;
1074 rk817_bat_write(battery, ADC_CONFIG0, value);
1075 }
1076
rk817_bat_get_halt_cnt(struct rk817_battery_device * battery)1077 static u8 rk817_bat_get_halt_cnt(struct rk817_battery_device *battery)
1078 {
1079 return rk817_bat_read(battery, HALT_CNT_REG);
1080 }
1081
rk817_bat_is_initialized(struct rk817_battery_device * battery)1082 static int rk817_bat_is_initialized(struct rk817_battery_device *battery)
1083 {
1084 u8 val = rk817_bat_read(battery, FG_INIT);
1085
1086 return (val & 0x80);
1087 }
1088
rk817_bat_set_initialized_flag(struct rk817_battery_device * battery)1089 static void rk817_bat_set_initialized_flag(struct rk817_battery_device *battery)
1090 {
1091 u8 val = rk817_bat_read(battery, FG_INIT);
1092
1093 rk817_bat_write(battery, FG_INIT, val | (0x80));
1094 }
1095
rk817_bat_not_first_pwron(struct rk817_battery_device * battery)1096 static void rk817_bat_not_first_pwron(struct rk817_battery_device *battery)
1097 {
1098 int now_soc, now_cap, pre_soc, pre_cap;
1099
1100 battery->fcc = rk817_bat_get_fcc(battery);
1101 pre_soc = rk817_bat_get_prev_dsoc(battery);
1102 pre_cap = rk817_bat_get_prev_cap(battery);
1103
1104 now_cap = rk817_bat_get_capacity_uah(battery) / 1000;
1105 battery->halt_cnt = rk817_bat_get_halt_cnt(battery);
1106 battery->nac = rk817_bat_vol_to_cap(battery,
1107 battery->pwron_voltage);
1108 battery->is_halt = is_rk817_bat_last_halt(battery);
1109
1110 DBG("now_cap: %d, pre_cap: %d\n", now_cap, pre_cap);
1111 /* determine if there is charging */
1112 if ((now_cap > 0) && (now_cap > pre_cap + 10)) {
1113 if (now_cap >= battery->fcc)
1114 now_cap = battery->fcc;
1115
1116 now_soc = now_cap * 1000 * 100 / battery->fcc;
1117 if (pre_soc < 100 * 1000)
1118 pre_soc += (now_soc - pre_cap * 1000 * 100 / battery->fcc);
1119 pre_cap = now_cap;
1120
1121 if (pre_soc >= 100 * 1000)
1122 pre_soc = 100 * 1000;
1123 if (now_cap >= battery->fcc)
1124 pre_soc = 100 * 1000;
1125 }
1126
1127 rk817_bat_init_coulomb_cap(battery, pre_cap);
1128
1129 battery->remain_cap = rk817_bat_get_capacity_uah(battery);
1130
1131 battery->dsoc = pre_soc;
1132 if (battery->dsoc > 100000)
1133 battery->dsoc = 100000;
1134 battery->nac = pre_cap;
1135 if (battery->nac < 0)
1136 battery->nac = 0;
1137
1138 DBG("dsoc=%d cap=%d v=%d pwron_v =%d min=%d psoc=%d pcap=%d\n",
1139 battery->dsoc, battery->nac, rk817_bat_get_battery_voltage(battery),
1140 rk817_bat_get_pwron_voltage(battery),
1141 battery->pwroff_min, rk817_bat_get_prev_dsoc(battery),
1142 rk817_bat_get_prev_cap(battery));
1143 }
1144
rk817_bat_rsoc_init(struct rk817_battery_device * battery)1145 static void rk817_bat_rsoc_init(struct rk817_battery_device *battery)
1146 {
1147 int version, value;
1148
1149 battery->is_first_power_on = is_rk817_bat_first_pwron(battery);
1150 battery->pwroff_min = rk817_bat_get_off_count(battery);
1151 battery->pwron_voltage = rk817_bat_get_pwron_voltage(battery);
1152
1153 value = rk817_bat_read(battery, DRV_VERSION);
1154 /* drv_version: bit0~bit3 */
1155 version = value & 0x0f;
1156 /* drv_version: [0 15] */
1157 battery->drv_version &= 0x0f;
1158 DBG("reg read version:%d dts read version:%d\n", version, battery->drv_version);
1159 if (battery->drv_version != version) {
1160 battery->is_first_power_on = 1;
1161 value &= 0xf0;
1162 value |= battery->drv_version;
1163 rk817_bat_write(battery, DRV_VERSION, value);
1164 }
1165
1166 DBG("battery = %d\n", rk817_bat_get_battery_voltage(battery));
1167 DBG("%s: is_first_power_on = %d, pwroff_min = %d, pwron_voltage = %d\n",
1168 __func__, battery->is_first_power_on,
1169 battery->pwroff_min, battery->pwron_voltage);
1170
1171 if (battery->is_first_power_on)
1172 rk817_bat_first_pwron(battery);
1173 else
1174 rk817_bat_not_first_pwron(battery);
1175
1176 battery->smooth_soc = battery->dsoc;
1177 battery->sm_old_cap = battery->remain_cap;
1178
1179 rk817_bat_save_dsoc(battery, battery->dsoc);
1180 rk817_bat_save_cap(battery, battery->nac);
1181 }
1182
rk817_bat_calc_linek(struct rk817_battery_device * battery)1183 static int rk817_bat_calc_linek(struct rk817_battery_device *battery)
1184 {
1185 int linek;
1186
1187 linek = MAX_PERCENTAGE * MAX_INTERPOLATE * 1000 /
1188 (MAX_PERCENTAGE * MAX_INTERPOLATE - battery->rsoc + battery->dsoc);
1189
1190 return linek;
1191 }
1192
rk817_bat_update_get_voltage(struct udevice * dev)1193 static int rk817_bat_update_get_voltage(struct udevice *dev)
1194 {
1195 struct rk817_battery_device *battery = dev_get_priv(dev);
1196
1197 if (!battery->virtual_power && battery->voltage_k)
1198 return rk817_bat_get_battery_voltage(battery);
1199 else
1200 return VIRTUAL_POWER_VOL;
1201 }
1202
rk817_bat_update_get_current(struct udevice * dev)1203 static int rk817_bat_update_get_current(struct udevice *dev)
1204 {
1205 struct rk817_battery_device *battery = dev_get_priv(dev);
1206
1207 if (!battery->virtual_power && battery->voltage_k)
1208 return rk817_bat_get_avg_current(battery);
1209 else
1210 return VIRTUAL_POWER_CUR;
1211 }
1212
rk817_bat_dwc_otg_check_dpdm(struct rk817_battery_device * battery)1213 static int rk817_bat_dwc_otg_check_dpdm(struct rk817_battery_device *battery)
1214 {
1215 if (battery->variant == RK809_ID) {
1216 if (rk817_bat_read(battery, PMIC_SYS_STS) & PLUG_IN_STS)
1217 return AC_CHARGER;
1218 else
1219 return NO_CHARGER;
1220 } else {
1221 return rockchip_chg_get_type();
1222 }
1223 }
1224
rk817_bat_update_get_chrg_online(struct udevice * dev)1225 static bool rk817_bat_update_get_chrg_online(struct udevice *dev)
1226 {
1227 struct rk817_battery_device *battery = dev_get_priv(dev);
1228
1229 if (rk817_bat_read(battery, PMIC_SYS_STS) & PLUG_IN_STS)
1230 return AC_CHARGER;
1231 else
1232 return NO_CHARGER;
1233 }
1234
rk817_bat_get_usb_state(struct rk817_battery_device * battery)1235 static int rk817_bat_get_usb_state(struct rk817_battery_device *battery)
1236 {
1237 int charger_type;
1238
1239 switch (rk817_bat_dwc_otg_check_dpdm(battery)) {
1240 case POWER_SUPPLY_TYPE_UNKNOWN:
1241 if ((rk817_bat_read(battery, PMIC_SYS_STS) & PLUG_IN_STS) != 0)
1242 charger_type = DC_CHARGER;
1243 else
1244 charger_type = NO_CHARGER;
1245 break;
1246 case POWER_SUPPLY_TYPE_USB:
1247 charger_type = USB_CHARGER;
1248 break;
1249 case POWER_SUPPLY_TYPE_USB_DCP:
1250 case POWER_SUPPLY_TYPE_USB_CDP:
1251 case POWER_SUPPLY_TYPE_USB_FLOATING:
1252 charger_type = AC_CHARGER;
1253 break;
1254 default:
1255 charger_type = NO_CHARGER;
1256 }
1257
1258 return charger_type;
1259 }
1260
rk817_bat_get_charger_type(struct rk817_battery_device * battery)1261 static int rk817_bat_get_charger_type(struct rk817_battery_device *battery)
1262 {
1263 struct rk8xx_priv *rk8xx = dev_get_priv(battery->dev->parent);
1264 u32 chrg_type;
1265 u8 val;
1266
1267 /* check by ic hardware: this check make check work safer */
1268 if ((rk817_bat_read(battery, PMIC_SYS_STS) & PLUG_IN_STS) == 0)
1269 return NO_CHARGER;
1270
1271 /* virtual or bat not exist */
1272 if (battery->virtual_power)
1273 return DC_CHARGER;
1274
1275 /* check USB secondly */
1276 chrg_type = rk817_bat_get_usb_state(battery);
1277 if (chrg_type != NO_CHARGER && (battery->rsoc + 500) / 1000 >= 100)
1278 chrg_type = CHARGE_FINISH;
1279
1280 if (rk8xx->variant == RK817_ID) {
1281 val = rk817_bat_read(battery, PMIC_CHRG_STS);
1282 if ((val & 0x70) == CHARGE_FINISH)
1283 chrg_type = CHARGE_FINISH;
1284 }
1285
1286 return chrg_type;
1287 }
1288
rk817_bat_set_input_current(struct rk817_battery_device * battery,int input_current)1289 static void rk817_bat_set_input_current(struct rk817_battery_device *battery,
1290 int input_current)
1291 {
1292 u8 usb_ctrl;
1293
1294 usb_ctrl = rk817_bat_read(battery, USB_CTRL_REG);
1295 usb_ctrl &= ~INPUT_CUR_MSK;
1296 usb_ctrl |= ((input_current) | 0x08);
1297 rk817_bat_write(battery, USB_CTRL_REG, usb_ctrl);
1298 }
1299
rk817_bat_set_input_voltage(struct rk817_battery_device * battery,int input_voltage)1300 static void rk817_bat_set_input_voltage(struct rk817_battery_device *battery,
1301 int input_voltage)
1302 {
1303 u8 usb_ctrl;
1304
1305 usb_ctrl = rk817_bat_read(battery, USB_CTRL_REG);
1306 usb_ctrl &= ~INPUT_VOL_MSK;
1307 usb_ctrl |= ((input_voltage) | 0x80);
1308 rk817_bat_write(battery, USB_CTRL_REG, usb_ctrl);
1309 }
1310
rk817_bat_charger_setting(struct rk817_battery_device * battery,int charger)1311 static void rk817_bat_charger_setting(struct rk817_battery_device *battery,
1312 int charger)
1313 {
1314 DBG("charger setting.....\n");
1315 if (charger == NO_CHARGER) {
1316 DBG("NO_CHARGER\n");
1317 rk817_bat_set_input_current(battery, ILIM_450MA);
1318 } else if (charger == USB_CHARGER) {
1319 DBG("USB_CHARGER\n");
1320 rk817_bat_set_input_current(battery, ILIM_450MA);
1321 } else if (charger == DC_CHARGER || charger == AC_CHARGER) {
1322 DBG("DC OR AC CHARGE\n");
1323 rk817_bat_set_input_current(battery, ILIM_1500MA);
1324 } else {
1325 DBG("charger setting error %d\n", charger);
1326 }
1327 }
1328
rk817_bat_smooth_algorithm(struct rk817_battery_device * battery)1329 static void rk817_bat_smooth_algorithm(struct rk817_battery_device *battery)
1330 {
1331 int delta_cap, ydsoc, tmp;
1332
1333 delta_cap = battery->remain_cap - battery->sm_old_cap;
1334 ydsoc = battery->sm_linek * delta_cap / DIV(battery->fcc) / 10;
1335 battery->smooth_soc += ydsoc;
1336 tmp = battery->smooth_soc / 1000;
1337
1338 DBG("remain_cap: %d sm_old_cap: %d, delta_cap: %d, ydsoc: %d, tmp: %d smooth_soc: %d, sm_link: %d\n",
1339 battery->remain_cap, battery->sm_old_cap, delta_cap, ydsoc, tmp,
1340 battery->smooth_soc, battery->sm_linek);
1341
1342 if (ydsoc >= 0) {
1343 if (battery->smooth_soc < 0)
1344 battery->smooth_soc = 0;
1345
1346 if (tmp != battery->dsoc / 1000) {
1347 if (battery->smooth_soc < battery->dsoc)
1348 return;
1349 if (battery->smooth_soc < battery->dsoc + 1000)
1350 battery->dsoc = battery->smooth_soc;
1351 else
1352 battery->dsoc += 1000;
1353 if (battery->dsoc <= 0)
1354 battery->dsoc = 0;
1355 } else {
1356 battery->dsoc = battery->smooth_soc;
1357 }
1358
1359 battery->sm_old_cap = battery->remain_cap;
1360 }
1361 }
1362
rk817_bat_finish_chrg(struct rk817_battery_device * battery)1363 static void rk817_bat_finish_chrg(struct rk817_battery_device *battery)
1364 {
1365 u32 tgt_sec = 0;
1366
1367 if (battery->dsoc / 1000 < 100) {
1368 tgt_sec = battery->fcc * 3600 / 100 / FINISH_CALI_CURR;
1369 if (get_timer(battery->finish_chrg_base) > SECONDS(tgt_sec)) {
1370 battery->finish_chrg_base = get_timer(0);
1371 battery->dsoc += 1000;
1372 }
1373 }
1374 }
1375
rk817_bat_debug_info(struct rk817_battery_device * battery)1376 static void rk817_bat_debug_info(struct rk817_battery_device *battery)
1377 {
1378 DBG("debug info:\n");
1379 DBG("CAL_OFFSET = 0x%x", rk817_bat_read(battery, CAL_OFFSET_H));
1380 DBG("%x\n", rk817_bat_read(battery, CAL_OFFSET_L));
1381 DBG("k = %d, b = %d\n", battery->voltage_k, battery->voltage_b);
1382 DBG("voltage_sys = %d\n", rk817_bat_get_sys_voltage(battery));
1383 DBG("voltage_usb = %d\n", rk817_bat_get_USB_voltage(battery));
1384 DBG("current_avg = %d\n", rk817_bat_get_avg_current(battery));
1385 DBG("fcc = %d\n", battery->fcc);
1386 DBG("qmax = %d\n", battery->qmax);
1387 }
1388
rk817_bat_smooth_charge(struct rk817_battery_device * battery)1389 static void rk817_bat_smooth_charge(struct rk817_battery_device *battery)
1390 {
1391 u8 chg_st = rk817_bat_get_charger_type(battery);
1392
1393 rk817_bat_debug_info(battery);
1394 rk817_bat_calibration(battery);
1395 /* set terminal charge mode */
1396 if (battery->term_sig_base &&
1397 get_timer(battery->term_sig_base) > SECONDS(1))
1398 battery->term_sig_base = 0;
1399
1400 /* not charge mode and not keep in uboot charge: exit */
1401 if ((battery->chrg_type == NO_CHARGER) ||
1402 !rk817_bat_is_initialized(battery)) {
1403 DBG("chrg=%d\n", battery->chrg_type);
1404 rk817_bat_set_initialized_flag(battery);
1405 goto out;
1406 }
1407
1408 /* update rsoc and remain cap */
1409 battery->remain_cap = rk817_bat_get_capacity_uah(battery);
1410 battery->rsoc = rk817_bat_get_rsoc(battery);
1411 if (battery->remain_cap / 1000 > battery->fcc) {
1412 battery->sm_old_cap -=
1413 (battery->remain_cap - battery->fcc * 1000);
1414 rk817_bat_init_coulomb_cap(battery, battery->fcc);
1415 }
1416
1417 /* finish charge step */
1418 if (chg_st == CHARGE_FINISH) {
1419 rk817_bat_finish_chrg(battery);
1420 rk817_bat_init_coulomb_cap(battery, battery->fcc);
1421 } else {
1422 DBG("smooth charge step...\n");
1423 battery->adc_allow_update = true;
1424 battery->finish_chrg_base = get_timer(0);
1425 rk817_bat_smooth_algorithm(battery);
1426 }
1427
1428 /* dsoc limit */
1429 if (battery->dsoc / 1000 > 100)
1430 battery->dsoc = 100 * 1000;
1431 else if (battery->dsoc < 0)
1432 battery->dsoc = 0;
1433
1434 rk817_bat_save_dsoc(battery, battery->dsoc);
1435 rk817_bat_save_cap(battery, battery->remain_cap / 1000);
1436 out:
1437 return;
1438 }
1439
rk817_bat_update_get_soc(struct udevice * dev)1440 static int rk817_bat_update_get_soc(struct udevice *dev)
1441 {
1442 struct rk817_battery_device *battery = dev_get_priv(dev);
1443 static ulong seconds;
1444 int charge_status;
1445
1446 rk817_bat_update_temperature(battery);
1447 battery->rsoc = rk817_bat_get_rsoc(battery);
1448 battery->voltage_avg = rk817_bat_get_battery_voltage(battery);
1449 battery->voltage_sys = rk817_bat_get_sys_voltage(battery);
1450 battery->voltage_usb = rk817_bat_get_USB_voltage(battery);
1451 battery->current_avg = rk817_bat_get_avg_current(battery);
1452
1453 DBG("dsoc: %d, rsoc: %d, voltage: %d, current: %d, remain_cap: %d sm_old_cap: %d, smooth_soc: %d, sm_link: %d\n",
1454 battery->dsoc, battery->rsoc, battery->voltage_avg,
1455 battery->current_avg, battery->remain_cap,
1456 battery->sm_old_cap, battery->smooth_soc,
1457 battery->sm_linek);
1458
1459 /* set charge current */
1460 battery->chrg_type =
1461 rk817_bat_get_charger_type(battery);
1462 charge_status = rk817_bat_get_usb_state(battery);
1463 if (battery->variant == RK817_ID)
1464 rk817_bat_charger_setting(battery, charge_status);
1465
1466 /* fg calc every 5 seconds */
1467 if (!seconds)
1468 seconds = get_timer(0);
1469 if (get_timer(seconds) >= SECONDS(5)) {
1470 seconds = get_timer(0);
1471 rk817_bat_smooth_charge(battery);
1472 }
1473
1474 battery->sm_linek = rk817_bat_calc_linek(battery);
1475 DBG("sm_linek = %d\n", battery->sm_linek);
1476
1477 /* bat exist, fg init success(dts pass) and uboot charge: report data */
1478 if (!battery->virtual_power && battery->voltage_k)
1479 return battery->dsoc / 1000;
1480 else
1481 return VIRTUAL_POWER_SOC;
1482 }
1483
rk817_is_bat_exist(struct rk817_battery_device * battery)1484 static int rk817_is_bat_exist(struct rk817_battery_device *battery)
1485 {
1486 struct rk8xx_priv *rk8xx = dev_get_priv(battery->dev->parent);
1487
1488 if (rk8xx->variant == RK817_ID)
1489 return (rk817_bat_read(battery, PMIC_CHRG_STS) & 0x80) ? 1 : 0;
1490
1491 return 1;
1492 }
1493
rk817_bat_bat_is_exist(struct udevice * dev)1494 static int rk817_bat_bat_is_exist(struct udevice *dev)
1495 {
1496 struct rk817_battery_device *battery = dev_get_priv(dev);
1497
1498 return rk817_is_bat_exist(battery);
1499 }
1500
1501 static struct dm_fuel_gauge_ops fg_ops = {
1502 .bat_is_exist = rk817_bat_bat_is_exist,
1503 .get_soc = rk817_bat_update_get_soc,
1504 .get_voltage = rk817_bat_update_get_voltage,
1505 .get_current = rk817_bat_update_get_current,
1506 .get_chrg_online = rk817_bat_update_get_chrg_online,
1507 };
1508
parse_temperature_chrg_table(struct rk817_battery_device * battery,struct udevice * dev)1509 static void parse_temperature_chrg_table(struct rk817_battery_device *battery,
1510 struct udevice *dev)
1511 {
1512 int size, count;
1513 int i, chrg_current, chrg_voltage;
1514 const __be32 *list;
1515
1516 list = dev_read_prop(dev, "temperature_chrg_table", &size);
1517 size /= sizeof(u32);
1518 if (!size || (size % 3)) {
1519 dev_err(battery->dev,
1520 "invalid temperature_chrg_table: size=%d\n", size);
1521 return;
1522 }
1523
1524 count = size / 4;
1525 battery->tc_count = count;
1526 battery->tc_table = devm_kzalloc(battery->dev,
1527 count * sizeof(*battery->tc_table),
1528 GFP_KERNEL);
1529 if (!battery->tc_table)
1530 return;
1531
1532 for (i = 0; i < count; i++) {
1533 /* temperature */
1534 battery->tc_table[i].temp_down = be32_to_cpu(*list++);
1535 battery->tc_table[i].temp_up = be32_to_cpu(*list++);
1536 chrg_current = be32_to_cpu(*list++);
1537 chrg_voltage = be32_to_cpu(*list++);
1538
1539 /*
1540 * because charge current lowest level is 500mA:
1541 * higher than or equal 1000ma, select charge current;
1542 * lower than 500ma, must select input current.
1543 */
1544 if (chrg_current >= 500) {
1545 battery->tc_table[i].chrg_current = chrg_current;
1546 battery->tc_table[i].chrg_current_index =
1547 rk817_bat_decode_chrg_current(battery, chrg_current);
1548 } else {
1549 battery->tc_table[i].chrg_current = 0;
1550 }
1551
1552 if (chrg_voltage >= 4100) {
1553 battery->tc_table[i].chrg_voltage = chrg_voltage;
1554 battery->tc_table[i].chrg_voltage_index =
1555 rk817_bat_decode_chrg_voltage(chrg_voltage);
1556 } else {
1557 battery->tc_table[i].chrg_voltage = 0;
1558 }
1559
1560 DBG("temp%d: [%d, %d], chrg_current=%d, current_index: %d, chrg_voltage: %d, voltage_index: %d\n",
1561 i, battery->tc_table[i].temp_down,
1562 battery->tc_table[i].temp_up,
1563 battery->tc_table[i].chrg_current,
1564 battery->tc_table[i].chrg_current_index,
1565 battery->tc_table[i].chrg_voltage,
1566 battery->tc_table[i].chrg_voltage_index);
1567 }
1568 }
1569
rk817_fg_ofdata_to_platdata(struct udevice * dev)1570 static int rk817_fg_ofdata_to_platdata(struct udevice *dev)
1571 {
1572 struct rk8xx_priv *rk8xx = dev_get_priv(dev->parent);
1573 struct rk817_battery_device *battery = dev_get_priv(dev);
1574 int len, value, size;
1575 const char *prop;
1576 int i;
1577
1578 if ((rk8xx->variant != RK817_ID) && (rk8xx->variant != RK809_ID)) {
1579 debug("%s: Not support pmic variant: rk%x\n",
1580 __func__, rk8xx->variant);
1581 return -EINVAL;
1582 }
1583
1584 battery->dev = dev;
1585 battery->variant = rk8xx->variant;
1586 /* Parse ocv table */
1587 prop = dev_read_prop(dev, "ocv_table", &len);
1588 if (!prop) {
1589 printf("can't find ocv_table prop\n");
1590 return -EINVAL;
1591 }
1592
1593 battery->ocv_table = calloc(len, 1);
1594 if (!battery->ocv_table) {
1595 printf("can't calloc ocv_table\n");
1596 return -ENOMEM;
1597 }
1598
1599 battery->ocv_size = len / 4;
1600 if (dev_read_u32_array(dev, "ocv_table",
1601 battery->ocv_table, battery->ocv_size)) {
1602 printf("can't read ocv_table\n");
1603 free(battery->ocv_table);
1604 return -EINVAL;
1605 }
1606
1607 /* Parse ntc table */
1608 prop = dev_read_prop(dev, "ntc_table", &len);
1609 if (!prop) {
1610 DBG("can't find %s prop\n", "ntc_table");
1611 } else {
1612 battery->ntc_table = calloc(len, 1);
1613 if (!battery->ocv_table) {
1614 DBG("can't calloc %s\n", "ntc_table");
1615 free(battery->ocv_table);
1616 return -ENOMEM;
1617 }
1618
1619 battery->ntc_size = len / 4;
1620 if (dev_read_u32_array(dev, "ntc_table",
1621 battery->ntc_table, battery->ntc_size)) {
1622 DBG("can't read ntc_table\n");
1623 free(battery->ocv_table);
1624 free(battery->ntc_table);
1625 return -EINVAL;
1626 }
1627
1628 parse_temperature_chrg_table(battery, dev);
1629 /* Parse ntc_degree_from table */
1630 prop = dev_read_prop(dev, "ntc_degree_from", &len);
1631 if (!prop) {
1632 DBG("can't find %s prop\n", "ntc_degree_from");
1633 free(battery->ocv_table);
1634 free(battery->ntc_table);
1635 return -EINVAL;
1636 }
1637
1638 battery->ntc_from = calloc(len, 1);
1639 if (!battery->ntc_from) {
1640 DBG("can't calloc ntc_degree_from\n");
1641 free(battery->ocv_table);
1642 free(battery->ntc_table);
1643 return -ENOMEM;
1644 }
1645
1646 size = len / 4;
1647 if (dev_read_u32_array(dev, "ntc_degree_from",
1648 battery->ntc_from, size)) {
1649 DBG("can't read %s\n", "ntc_degree_from");
1650 free(battery->ocv_table);
1651 free(battery->ntc_table);
1652 free(battery->ntc_from);
1653 return -EINVAL;
1654 }
1655
1656 battery->ntc_degree_from = battery->ntc_from[1];
1657 if (battery->ntc_from[0])
1658 battery->ntc_degree_from = -battery->ntc_degree_from;
1659 }
1660
1661 /* Parse neccessay */
1662 battery->design_cap = dev_read_u32_default(dev, "design_capacity", -1);
1663 if (battery->design_cap < 0) {
1664 printf("can't read design_capacity\n");
1665 return -EINVAL;
1666 }
1667
1668 battery->qmax = dev_read_u32_default(dev, "design_qmax", -1);
1669 if (battery->qmax < 0) {
1670 printf("can't read design_qmax\n");
1671 return -EINVAL;
1672 }
1673
1674 battery->virtual_power = dev_read_u32_default(dev, "virtual_power", 0);
1675 if (!rk817_is_bat_exist(battery))
1676 battery->virtual_power = 1;
1677
1678 if (rk8xx->variant == RK809_ID) {
1679 battery->bat_res_up = dev_read_u32_default(dev, "bat_res_up", -1);
1680 if (battery->bat_res_up < 0) {
1681 printf("can't read bat_res_up\n");
1682 return -EINVAL;
1683 }
1684
1685 battery->bat_res_down = dev_read_u32_default(dev, "bat_res_down", -1);
1686 if (battery->bat_res_down < 0) {
1687 printf("can't read bat_res_down\n");
1688 return -EINVAL;
1689 }
1690 }
1691
1692 battery->drv_version = dev_read_u32_default(dev, "drv_version", -1);
1693 if (battery->drv_version < 0)
1694 battery->drv_version = 0;
1695
1696 value = dev_read_u32_default(dev, "sample_res", -1);
1697 if (value < 0) {
1698 printf("read sample_res error\n");
1699 battery->res_div = SAMPLE_RES_10mR;
1700 } else {
1701 battery->res_div = value;
1702 }
1703
1704 battery->contact_res = dev_read_u32_default(dev, "contact_res", 0);
1705
1706 DBG("OCV Value:");
1707 for (i = 0; i < battery->ocv_size; i++)
1708 DBG("%d ", battery->ocv_table[i]);
1709
1710 DBG("ntc res Value:");
1711 if (battery->ntc_table)
1712 for (i = 0; i < battery->ntc_size; i++)
1713 DBG("%d ", battery->ntc_table[i]);
1714
1715 DBG("ocvsize: %d\n", battery->ocv_size);
1716 DBG("battery->design_cap: %d\n", battery->design_cap);
1717 DBG("battery->qmax: %d\n", battery->qmax);
1718 DBG("battery->bat_res_up: %d\n", battery->bat_res_up);
1719 DBG("battery->bat_res_down: %d\n", battery->bat_res_down);
1720 DBG("battery->contact_res: %d\n", battery->contact_res);
1721
1722 return 0;
1723 }
1724
rk817_fg_init(struct rk817_battery_device * battery)1725 static int rk817_fg_init(struct rk817_battery_device *battery)
1726 {
1727 int value;
1728
1729 value = rk817_bat_read(battery, GG_CON);
1730 rk817_bat_write(battery, GG_CON, value | VOL_OUPUT_INSTANT_MODE);
1731 if (battery->variant == RK817_ID) {
1732 value = rk817_bat_read(battery, BAT_DISCHRG);
1733 rk817_bat_write(battery, BAT_DISCHRG, value & (~DIS_ILIM_EN));
1734 }
1735 rk817_bat_gas_gaugle_enable(battery);
1736 rk817_bat_init_voltage_kb(battery);
1737 rk817_bat_calibration(battery);
1738 rk817_bat_adc_init(battery);
1739 rk817_bat_rsoc_init(battery);
1740 rk817_bat_init_coulomb_cap(battery, battery->nac);
1741 rk817_bat_init_ts_detect(battery);
1742 rk817_bat_set_initialized_flag(battery);
1743
1744 battery->voltage_avg = rk817_bat_get_battery_voltage(battery);
1745 battery->voltage_sys = rk817_bat_get_sys_voltage(battery);
1746 battery->voltage_usb = rk817_bat_get_USB_voltage(battery);
1747 battery->current_avg = rk817_bat_get_avg_current(battery);
1748 battery->current_pwron = rk817_bat_get_pwron_current(battery);
1749 battery->remain_cap = rk817_bat_get_capacity_uah(battery);
1750 battery->rsoc = rk817_bat_get_rsoc(battery);
1751 battery->sm_linek = rk817_bat_calc_linek(battery);
1752 battery->chrg_type = rk817_bat_get_charger_type(battery);
1753 battery->finish_chrg_base = get_timer(0);
1754 battery->term_sig_base = get_timer(0);
1755
1756 battery->dbg_pwr_dsoc = battery->dsoc;
1757 battery->dbg_pwr_rsoc = battery->rsoc;
1758 battery->dbg_pwr_vol = battery->voltage_avg;
1759
1760 if (battery->variant == RK817_ID) {
1761 rk817_bat_set_input_voltage(battery, VLIM_4500MV);
1762 rk817_bat_charger_setting(battery, battery->chrg_type);
1763 }
1764 DBG("voltage_k = %d, voltage_b = %d\n",
1765 battery->voltage_k, battery->voltage_b);
1766 DBG("voltage_sys = %d\n", battery->voltage_sys);
1767 DBG("voltage usb: %d\n", battery->voltage_avg);
1768 DBG("battery: %d\n", battery->voltage_avg);
1769 DBG("current_avg = %d\n", battery->current_avg);
1770 DBG("current_pwron = %d\n", battery->current_pwron);
1771 DBG("remain_cap = %d\n", battery->remain_cap);
1772 DBG("fcc = %d\n", battery->fcc);
1773 DBG("qmax = %d\n", battery->qmax);
1774 DBG("dsoc = %d\n", battery->dsoc);
1775 DBG("rsoc = %d\n", battery->rsoc);
1776 DBG("charge type: %d\n", battery->chrg_type);
1777
1778 return 0;
1779 }
1780
rk817_fg_probe(struct udevice * dev)1781 static int rk817_fg_probe(struct udevice *dev)
1782 {
1783 struct rk8xx_priv *priv = dev_get_priv(dev->parent);
1784 struct rk817_battery_device *battery = dev_get_priv(dev);
1785
1786 if ((priv->variant != RK817_ID) && ((priv->variant != RK809_ID))) {
1787 debug("Not support pmic variant: rk%x\n", priv->variant);
1788 return -EINVAL;
1789 }
1790
1791 return rk817_fg_init(battery);
1792 }
1793
1794 U_BOOT_DRIVER(rk817_fg) = {
1795 .name = "rk817_fg",
1796 .id = UCLASS_FG,
1797 .probe = rk817_fg_probe,
1798 .ops = &fg_ops,
1799 .ofdata_to_platdata = rk817_fg_ofdata_to_platdata,
1800 .priv_auto_alloc_size = sizeof(struct rk817_battery_device),
1801 };
1802