1 /* 2 * (C) Copyright 2017 Rockchip Electronics Co., Ltd 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 /* #include <adc.h> */ 8 #include <dm.h> 9 #include <errno.h> 10 #include <common.h> 11 #include <malloc.h> 12 #include <fdtdec.h> 13 #include <asm/gpio.h> 14 #include <common.h> 15 #include <power/pmic.h> 16 #include <dm/uclass-internal.h> 17 #include <power/charge_display.h> 18 #include <power/charge_animation.h> 19 #include <power/fuel_gauge.h> 20 #include <power/rk8xx_pmic.h> 21 #include <linux/usb/phy-rockchip-inno-usb2.h> 22 #include "fg_regs.h" 23 24 DECLARE_GLOBAL_DATA_PTR; 25 26 static int dbg_enable = 0; 27 #define DBG(args...) \ 28 do { \ 29 if (dbg_enable) { \ 30 printf(args); \ 31 } \ 32 } while (0) 33 34 #define BAT_INFO(fmt, args...) printf("rk816-bat: "fmt, ##args) 35 36 #define DRIVER_VERSION "2.0" 37 38 /* THERMAL_REG */ 39 #define TEMP_115C (0x03 << 2) 40 #define FB_TEMP_MSK 0x0c 41 42 /* CHRG_CTRL_REG2*/ 43 #define FINISH_100MA (0x00 << 6) 44 #define FINISH_150MA (0x01 << 6) 45 #define FINISH_200MA (0x02 << 6) 46 #define FINISH_250MA (0x03 << 6) 47 #define FINISH_CUR_MSK 0xc7 48 49 /* CHRG_CTRL_REG3*/ 50 #define CHRG_TERM_DIG_SIGNAL (1 << 5) 51 #define CHRG_TIMER_CCCV_EN (1 << 2) 52 53 /* CHRG_CTRL_REG */ 54 #define ILIM_450MA (0x00) 55 #define ILIM_2000MA (0x07) 56 #define CHRG_CT_EN (1 << 7) 57 58 /* USB_CTRL_REG */ 59 #define INPUT_CUR_MSK 0x0f 60 61 /* VB_MON_REG */ 62 #define PLUG_IN_STS (1 << 6) 63 64 /* GGSTS */ 65 #define BAT_CON (1 << 4) 66 #define VOL_INSTANT (1 << 0) 67 #define VOL_AVG (0 << 0) 68 #define VOL_AVG_MASK (1 << 0) 69 70 /* TS_CTRL_REG */ 71 #define GG_EN (1 << 7) 72 73 /* CHRG_USB_CTRL*/ 74 #define CHRG_EN (1 << 7) 75 76 /* BAT_CTRL_REG */ 77 #define USB_SYS_EN (1 << 6) 78 79 /*SUP_STS_REG*/ 80 #define BAT_EXS (1 << 7) 81 #define USB_EXIST (1 << 1) 82 #define USB_EFF (1 << 0) 83 #define CHARGE_OFF (0x00 << 4) 84 #define DEAD_CHARGE (0x01 << 4) 85 #define TRICKLE_CHARGE (0x02 << 4) 86 #define CC_OR_CV (0x03 << 4) 87 #define CHARGE_FINISH (0x04 << 4) 88 #define USB_OVER_VOL (0x05 << 4) 89 #define BAT_TMP_ERR (0x06 << 4) 90 #define TIMER_ERR (0x07 << 4) 91 #define USB_VLIMIT_EN (1 << 3) 92 #define USB_CLIMIT_EN (1 << 2) 93 #define BAT_STATUS_MSK 0x70 94 95 /* GGCON */ 96 #define ADC_CUR_MODE (1 << 1) 97 98 /* CALI PARAM */ 99 #define FINISH_CALI_CURR 1500 100 #define TERM_CALI_CURR 600 101 #define VIRTUAL_POWER_VOL 4200 102 #define VIRTUAL_POWER_CUR 1000 103 #define VIRTUAL_POWER_SOC 66 104 #define SECONDS(n) ((n) * 1000) 105 106 /* CALC PARAM */ 107 #define MAX_PERCENTAGE 100 108 #define MAX_INTERPOLATE 1000 109 #define MAX_INT 0x7fff 110 #define MIN_FCC 500 111 112 /* DC ADC */ 113 #define FG_INIT (1 << 3) 114 #define FG_RESET_LATE (1 << 1) 115 #define FG_RESET_NOW (1 << 0) 116 #define CHRG_TERM_DSOC 90 117 #define CHRG_TERM_K 650 118 #define CHRG_FULL_K 400 119 #define ADC_CALIB_THRESHOLD 4 120 #define DC_ADC_TRIGGER 150 121 #define DIV(x) ((x) ? (x) : 1) 122 123 /***********************************************************/ 124 struct battery_priv { 125 struct udevice *dev; 126 int chrg_type; 127 int poffset; 128 int bat_res; 129 int current_avg; 130 int voltage_avg; 131 int voltage_ocv; 132 int voltage_k; 133 int voltage_b; 134 int dsoc; 135 int rsoc; 136 int fcc; 137 u32 qmax; 138 int remain_cap; 139 u32 design_cap; 140 int nac; 141 u32 *ocv_table; 142 u32 ocv_size; 143 int virtual_power; 144 int pwroff_min; 145 int sm_old_cap; 146 int sm_linek; 147 int sm_chrg_dsoc; 148 int adc_allow_update; 149 int chrg_vol_sel; 150 int chrg_cur_input; 151 int chrg_cur_sel; 152 int dts_vol_sel; 153 int dts_cur_input; 154 int dts_cur_sel; 155 int max_soc_offset; 156 struct gpio_desc dc_det; 157 int dc_type; 158 int dc_det_adc; 159 ulong vol_mode_base; 160 ulong finish_chrg_base; 161 u8 calc_dsoc; 162 u8 calc_rsoc; 163 int sm_meet_soc; 164 u8 halt_cnt; 165 bool is_halt; 166 bool is_ocv_calib; 167 bool is_max_soc_offset; 168 bool is_first_power_on; 169 bool is_sw_reset; 170 int pwr_dsoc; 171 int pwr_rsoc; 172 int pwr_vol; 173 }; 174 175 enum charger_type { 176 NO_CHARGER = 0, 177 USB_CHARGER, 178 AC_CHARGER, 179 DC_CHARGER, 180 UNDEF_CHARGER, 181 }; 182 183 enum dc_type { 184 DC_TYPE_OF_NONE = 0, 185 DC_TYPE_OF_GPIO, 186 DC_TYPE_OF_ADC, 187 }; 188 189 static const char *charger_type_to_name[] = { 190 "NONE", 191 "USB", 192 "AC", 193 "DC", 194 "UNKN", 195 }; 196 197 static const u32 CHRG_VOL_SEL[] = { 198 4050, 4100, 4150, 4200, 4250, 4300, 4350 199 }; 200 201 static const u32 CHRG_CUR_SEL[] = { 202 1000, 1200, 1400, 1600, 1800, 2000, 2250, 2400 203 }; 204 205 static const u32 CHRG_CUR_INPUT[] = { 206 450, 800, 850, 1000, 1250, 1500, 1750, 2000 207 }; 208 209 static int rk816_bat_read(struct battery_priv *di, u8 reg) 210 { 211 return pmic_reg_read(di->dev->parent, reg); 212 } 213 214 static void rk816_bat_write(struct battery_priv *di, u8 reg, u8 buf) 215 { 216 pmic_reg_write(di->dev->parent, reg, buf); 217 } 218 219 static int rk816_bat_dwc_otg_check_dpdm(void) 220 { 221 #ifdef CONFIG_PHY_ROCKCHIP_INNO_USB2 222 return rockchip_chg_get_type(); 223 #else 224 BAT_INFO("rockchip_chg_get_type() is not implement\n"); 225 return NO_CHARGER; 226 #endif 227 } 228 229 static int rk816_bat_get_rsoc(struct battery_priv *di) 230 { 231 return (di->remain_cap + di->fcc / 200) * 100 / DIV(di->fcc); 232 } 233 234 static int rk816_bat_get_dsoc(struct battery_priv *di) 235 { 236 return rk816_bat_read(di, SOC_REG); 237 } 238 239 static void rk816_bat_enable_input_current(struct battery_priv *di) 240 { 241 u8 val; 242 243 val = rk816_bat_read(di, BAT_CTRL_REG); 244 val |= USB_SYS_EN; 245 rk816_bat_write(di, BAT_CTRL_REG, val); 246 } 247 248 static void rk816_bat_enable_gauge(struct battery_priv *di) 249 { 250 u8 val; 251 252 val = rk816_bat_read(di, TS_CTRL_REG); 253 val |= GG_EN; 254 rk816_bat_write(di, TS_CTRL_REG, val); 255 } 256 257 static void rk816_bat_set_vol_instant_mode(struct battery_priv *di) 258 { 259 u8 val; 260 261 val = rk816_bat_read(di, GGSTS_REG); 262 val |= VOL_INSTANT; 263 rk816_bat_write(di, GGSTS_REG, val); 264 } 265 266 static void rk816_bat_set_vol_avg_mode(struct battery_priv *di) 267 { 268 u8 val; 269 270 val = rk816_bat_read(di, GGSTS_REG); 271 val &= ~VOL_AVG_MASK; 272 val |= VOL_AVG; 273 rk816_bat_write(di, GGSTS_REG, val); 274 } 275 276 static int rk816_bat_get_vcalib0(struct battery_priv *di) 277 { 278 int val = 0; 279 280 val |= rk816_bat_read(di, VCALIB0_REGL) << 0; 281 val |= rk816_bat_read(di, VCALIB0_REGH) << 8; 282 283 return val; 284 } 285 286 static int rk816_bat_get_vcalib1(struct battery_priv *di) 287 { 288 int val = 0; 289 290 val |= rk816_bat_read(di, VCALIB1_REGL) << 0; 291 val |= rk816_bat_read(di, VCALIB1_REGH) << 8; 292 293 return val; 294 } 295 296 static void rk816_bat_set_coffset(struct battery_priv *di, int val) 297 { 298 u8 buf; 299 300 buf = (val >> 0) & 0xff; 301 rk816_bat_write(di, CAL_OFFSET_REGL, buf); 302 buf = (val >> 8) & 0xff; 303 rk816_bat_write(di, CAL_OFFSET_REGH, buf); 304 } 305 306 static int rk816_bat_get_ioffset(struct battery_priv *di) 307 { 308 int val = 0; 309 310 val |= rk816_bat_read(di, IOFFSET_REGL) << 0; 311 val |= rk816_bat_read(di, IOFFSET_REGH) << 8; 312 313 return val; 314 } 315 316 static void rk816_bat_save_dsoc(struct battery_priv *di, u8 save_soc) 317 { 318 static int old_soc = -1; 319 320 if (old_soc != save_soc) { 321 old_soc = save_soc; 322 rk816_bat_write(di, SOC_REG, save_soc); 323 } 324 } 325 326 static void rk816_bat_save_cap(struct battery_priv *di, int cap) 327 { 328 u8 buf; 329 static int old_cap; 330 331 if (old_cap == cap) 332 return; 333 334 if (cap >= di->qmax) 335 cap = di->qmax; 336 337 old_cap = cap; 338 buf = (cap >> 24) & 0xff; 339 rk816_bat_write(di, REMAIN_CAP_REG3, buf); 340 buf = (cap >> 16) & 0xff; 341 rk816_bat_write(di, REMAIN_CAP_REG2, buf); 342 buf = (cap >> 8) & 0xff; 343 rk816_bat_write(di, REMAIN_CAP_REG1, buf); 344 buf = (cap >> 0) & 0xff; 345 rk816_bat_write(di, REMAIN_CAP_REG0, buf); 346 } 347 348 static void rk816_bat_init_voltage_kb(struct battery_priv *di) 349 { 350 int vcalib0, vcalib1; 351 352 vcalib0 = rk816_bat_get_vcalib0(di); 353 vcalib1 = rk816_bat_get_vcalib1(di); 354 di->voltage_k = (4200 - 3000) * 1000 / DIV(vcalib1 - vcalib0); 355 di->voltage_b = 4200 - (di->voltage_k * vcalib1) / 1000; 356 DBG("%s. vk=%d, vb=%d\n", __func__, di->voltage_k, di->voltage_b); 357 } 358 359 static int rk816_bat_get_ocv_voltage(struct battery_priv *di) 360 { 361 int vol, val = 0; 362 363 val |= rk816_bat_read(di, BAT_OCV_REGL) << 0; 364 val |= rk816_bat_read(di, BAT_OCV_REGH) << 8; 365 vol = di->voltage_k * val / 1000 + di->voltage_b; 366 vol = vol * 1100 / 1000; 367 368 return vol; 369 } 370 371 static int rk816_bat_get_avg_current(struct battery_priv *di) 372 { 373 int val = 0; 374 375 val |= rk816_bat_read(di, BAT_CUR_AVG_REGL) << 0; 376 val |= rk816_bat_read(di, BAT_CUR_AVG_REGH) << 8; 377 378 if (val & 0x800) 379 val -= 4096; 380 val = val * 1506 / 1000; 381 382 return val; 383 } 384 385 static int rk816_bat_get_avg_voltage(struct battery_priv *di) 386 { 387 int vol, val = 0; 388 389 val |= rk816_bat_read(di, BAT_VOL_REGL) << 0; 390 val |= rk816_bat_read(di, BAT_VOL_REGH) << 8; 391 vol = di->voltage_k * val / 1000 + di->voltage_b; 392 vol = vol * 1100 / 1000; 393 394 return vol; 395 } 396 397 static int rk816_bat_get_est_voltage(struct battery_priv *di) 398 { 399 int est_vol, vol, curr; 400 401 vol = rk816_bat_get_avg_voltage(di); 402 curr = rk816_bat_get_avg_current(di); 403 est_vol = vol - (di->bat_res * curr / 1000); 404 405 return (est_vol > 2800) ? est_vol : vol; 406 } 407 408 static u8 rk816_bat_finish_ma(int fcc) 409 { 410 u8 ma; 411 412 if (fcc > 5000) 413 ma = FINISH_250MA; 414 else if (fcc >= 4000) 415 ma = FINISH_200MA; 416 else if (fcc >= 3000) 417 ma = FINISH_150MA; 418 else 419 ma = FINISH_100MA; 420 421 return ma; 422 } 423 424 static void rk816_bat_select_chrg_cv(struct battery_priv *di) 425 { 426 int index, chrg_vol_sel, chrg_cur_sel, chrg_cur_input; 427 428 chrg_vol_sel = di->dts_vol_sel; 429 chrg_cur_sel = di->dts_cur_sel; 430 chrg_cur_input = di->dts_cur_input; 431 432 for (index = 0; index < ARRAY_SIZE(CHRG_VOL_SEL); index++) { 433 if (chrg_vol_sel < CHRG_VOL_SEL[index]) 434 break; 435 di->chrg_vol_sel = (index << 4); 436 } 437 438 for (index = 0; index < ARRAY_SIZE(CHRG_CUR_INPUT); index++) { 439 if (chrg_cur_input < CHRG_CUR_INPUT[index]) 440 break; 441 di->chrg_cur_input = (index << 0); 442 } 443 444 for (index = 0; index < ARRAY_SIZE(CHRG_CUR_SEL); index++) { 445 if (chrg_cur_sel < CHRG_CUR_SEL[index]) 446 break; 447 di->chrg_cur_sel = (index << 0); 448 } 449 450 DBG("<%s>. vol=0x%x, input=0x%x, sel=0x%x\n", 451 __func__, di->chrg_vol_sel, di->chrg_cur_input, di->chrg_cur_sel); 452 } 453 454 static void rk816_bat_init_chrg_config(struct battery_priv *di) 455 { 456 u8 chrg_ctrl1, usb_ctrl, chrg_ctrl2, chrg_ctrl3; 457 u8 sup_sts, ggcon, thermal, finish_ma; 458 459 rk816_bat_select_chrg_cv(di); 460 finish_ma = rk816_bat_finish_ma(di->fcc); 461 462 ggcon = rk816_bat_read(di, GGCON_REG); 463 sup_sts = rk816_bat_read(di, SUP_STS_REG); 464 usb_ctrl = rk816_bat_read(di, USB_CTRL_REG); 465 thermal = rk816_bat_read(di, THERMAL_REG); 466 chrg_ctrl2 = rk816_bat_read(di, CHRG_CTRL_REG2); 467 chrg_ctrl3 = rk816_bat_read(di, CHRG_CTRL_REG3); 468 469 /* set charge current and voltage */ 470 usb_ctrl &= ~INPUT_CUR_MSK; 471 usb_ctrl |= di->chrg_cur_input; 472 chrg_ctrl1 = (CHRG_EN | di->chrg_vol_sel | di->chrg_cur_sel); 473 474 /* digital signal and finish current*/ 475 chrg_ctrl3 |= CHRG_TERM_DIG_SIGNAL; 476 chrg_ctrl2 &= ~FINISH_CUR_MSK; 477 chrg_ctrl2 |= finish_ma; 478 479 /* cccv mode */ 480 chrg_ctrl3 &= ~CHRG_TIMER_CCCV_EN; 481 482 /* enable voltage limit and enable input current limit */ 483 sup_sts |= USB_VLIMIT_EN; 484 sup_sts |= USB_CLIMIT_EN; 485 486 /* set feedback temperature */ 487 usb_ctrl |= CHRG_CT_EN; 488 thermal &= ~FB_TEMP_MSK; 489 thermal |= TEMP_115C; 490 491 /* adc current mode */ 492 ggcon |= ADC_CUR_MODE; 493 494 rk816_bat_write(di, GGCON_REG, ggcon); 495 rk816_bat_write(di, SUP_STS_REG, sup_sts); 496 rk816_bat_write(di, USB_CTRL_REG, usb_ctrl); 497 rk816_bat_write(di, THERMAL_REG, thermal); 498 rk816_bat_write(di, CHRG_CTRL_REG1, chrg_ctrl1); 499 rk816_bat_write(di, CHRG_CTRL_REG2, chrg_ctrl2); 500 rk816_bat_write(di, CHRG_CTRL_REG3, chrg_ctrl3); 501 } 502 503 static u32 interpolate(int value, u32 *table, int size) 504 { 505 uint8_t i; 506 uint16_t d; 507 508 for (i = 0; i < size; i++) { 509 if (value < table[i]) 510 break; 511 } 512 513 if ((i > 0) && (i < size)) { 514 d = (value - table[i - 1]) * (MAX_INTERPOLATE / (size - 1)); 515 d /= table[i] - table[i - 1]; 516 d = d + (i - 1) * (MAX_INTERPOLATE / (size - 1)); 517 } else { 518 d = i * ((MAX_INTERPOLATE + size / 2) / size); 519 } 520 521 if (d > 1000) 522 d = 1000; 523 524 return d; 525 } 526 527 /* returns (a * b) / c */ 528 static int32_t ab_div_c(u32 a, u32 b, u32 c) 529 { 530 bool sign; 531 u32 ans = MAX_INT; 532 int32_t tmp; 533 534 sign = ((((a ^ b) ^ c) & 0x80000000) != 0); 535 536 if (c != 0) { 537 if (sign) 538 c = -c; 539 tmp = ((int32_t)a * b + (c >> 1)) / c; 540 if (tmp < MAX_INT) 541 ans = tmp; 542 } 543 544 if (sign) 545 ans = -ans; 546 547 return ans; 548 } 549 550 static int rk816_bat_vol_to_cap(struct battery_priv *di, int voltage) 551 { 552 u32 *ocv_table, tmp; 553 int ocv_size, ocv_cap; 554 555 ocv_table = di->ocv_table; 556 ocv_size = di->ocv_size; 557 tmp = interpolate(voltage, ocv_table, ocv_size); 558 ocv_cap = ab_div_c(tmp, di->fcc, MAX_INTERPOLATE); 559 560 return ocv_cap; 561 } 562 563 static int rk816_bat_vol_to_soc(struct battery_priv *di, int voltage) 564 { 565 u32 *ocv_table, tmp; 566 int ocv_size, ocv_soc; 567 568 ocv_table = di->ocv_table; 569 ocv_size = di->ocv_size; 570 tmp = interpolate(voltage, ocv_table, ocv_size); 571 ocv_soc = ab_div_c(tmp, MAX_PERCENTAGE, MAX_INTERPOLATE); 572 573 return ocv_soc; 574 } 575 576 static int rk816_bat_get_prev_cap(struct battery_priv *di) 577 { 578 int val = 0; 579 580 val |= rk816_bat_read(di, REMAIN_CAP_REG3) << 24; 581 val |= rk816_bat_read(di, REMAIN_CAP_REG2) << 16; 582 val |= rk816_bat_read(di, REMAIN_CAP_REG1) << 8; 583 val |= rk816_bat_read(di, REMAIN_CAP_REG0) << 0; 584 585 return val; 586 } 587 588 static void rk816_bat_save_fcc(struct battery_priv *di, u32 cap) 589 { 590 u8 buf; 591 592 buf = (cap >> 24) & 0xff; 593 rk816_bat_write(di, NEW_FCC_REG3, buf); 594 buf = (cap >> 16) & 0xff; 595 rk816_bat_write(di, NEW_FCC_REG2, buf); 596 buf = (cap >> 8) & 0xff; 597 rk816_bat_write(di, NEW_FCC_REG1, buf); 598 buf = (cap >> 0) & 0xff; 599 rk816_bat_write(di, NEW_FCC_REG0, buf); 600 } 601 602 static int rk816_bat_get_fcc(struct battery_priv *di) 603 { 604 int val = 0; 605 606 val |= rk816_bat_read(di, NEW_FCC_REG3) << 24; 607 val |= rk816_bat_read(di, NEW_FCC_REG2) << 16; 608 val |= rk816_bat_read(di, NEW_FCC_REG1) << 8; 609 val |= rk816_bat_read(di, NEW_FCC_REG0) << 0; 610 611 if (val < MIN_FCC) 612 val = di->design_cap; 613 else if (val > di->qmax) 614 val = di->qmax; 615 616 return val; 617 } 618 619 static u8 rk816_bat_get_pwroff_min(struct battery_priv *di) 620 { 621 u8 cur, last; 622 623 cur = rk816_bat_read(di, NON_ACT_TIMER_CNT_REG); 624 last = rk816_bat_read(di, NON_ACT_TIMER_CNT_SAVE_REG); 625 rk816_bat_write(di, NON_ACT_TIMER_CNT_SAVE_REG, cur); 626 627 return (cur != last) ? cur : 0; 628 } 629 630 static int rk816_bat_get_coulomb_cap(struct battery_priv *di) 631 { 632 int val = 0; 633 634 val |= rk816_bat_read(di, GASCNT_REG3) << 24; 635 val |= rk816_bat_read(di, GASCNT_REG2) << 16; 636 val |= rk816_bat_read(di, GASCNT_REG1) << 8; 637 val |= rk816_bat_read(di, GASCNT_REG0) << 0; 638 val /= 2390; 639 640 return val; 641 } 642 643 static void rk816_bat_init_capacity(struct battery_priv *di, u32 capacity) 644 { 645 u8 buf; 646 u32 cap; 647 int delta; 648 649 delta = capacity - di->remain_cap; 650 if (!delta) 651 return; 652 653 cap = capacity * 2390; 654 buf = (cap >> 24) & 0xff; 655 rk816_bat_write(di, GASCNT_CAL_REG3, buf); 656 buf = (cap >> 16) & 0xff; 657 rk816_bat_write(di, GASCNT_CAL_REG2, buf); 658 buf = (cap >> 8) & 0xff; 659 rk816_bat_write(di, GASCNT_CAL_REG1, buf); 660 buf = (cap >> 0) & 0xff; 661 rk816_bat_write(di, GASCNT_CAL_REG0, buf); 662 udelay(75); 663 di->remain_cap = rk816_bat_get_coulomb_cap(di); 664 di->rsoc = rk816_bat_get_rsoc(di); 665 } 666 667 static bool is_rk816_bat_ocv_valid(struct battery_priv *di) 668 { 669 return di->pwroff_min >= 30 ? true : false; 670 } 671 672 static int rk816_bat_get_usb_state(struct battery_priv *di) 673 { 674 int charger_type; 675 676 switch (rk816_bat_dwc_otg_check_dpdm()) { 677 case 0: 678 if ((rk816_bat_read(di, VB_MON_REG) & PLUG_IN_STS) != 0) 679 charger_type = DC_CHARGER; 680 else 681 charger_type = NO_CHARGER; 682 break; 683 case 1: 684 case 3: 685 charger_type = USB_CHARGER; 686 break; 687 case 2: 688 charger_type = AC_CHARGER; 689 break; 690 default: 691 charger_type = NO_CHARGER; 692 } 693 694 return charger_type; 695 } 696 697 static void rk816_bat_clr_initialized_state(struct battery_priv *di) 698 { 699 u8 val; 700 701 val = rk816_bat_read(di, MISC_MARK_REG); 702 val &= ~FG_INIT; 703 rk816_bat_write(di, MISC_MARK_REG, val); 704 } 705 706 static bool rk816_bat_is_initialized(struct battery_priv *di) 707 { 708 return (rk816_bat_read(di, MISC_MARK_REG) & FG_INIT) ? true : false; 709 } 710 711 static void rk816_bat_set_initialized_state(struct battery_priv *di) 712 { 713 u8 val; 714 715 val = rk816_bat_read(di, MISC_MARK_REG); 716 if (rk816_bat_get_usb_state(di) != NO_CHARGER) { 717 val |= FG_INIT; 718 rk816_bat_write(di, MISC_MARK_REG, val); 719 BAT_INFO("fuel gauge initialized... estv=%d, ch=%d\n", 720 rk816_bat_get_est_voltage(di), 721 rk816_bat_get_usb_state(di)); 722 } 723 } 724 725 static void rk816_bat_first_pwron(struct battery_priv *di) 726 { 727 int ocv_vol; 728 729 rk816_bat_save_fcc(di, di->design_cap); 730 ocv_vol = rk816_bat_get_ocv_voltage(di); 731 di->fcc = rk816_bat_get_fcc(di); 732 di->nac = rk816_bat_vol_to_cap(di, ocv_vol); 733 di->rsoc = rk816_bat_vol_to_soc(di, ocv_vol); 734 di->dsoc = di->rsoc; 735 rk816_bat_init_capacity(di, di->nac); 736 rk816_bat_set_initialized_state(di); 737 738 BAT_INFO("first power on: soc=%d\n", di->dsoc); 739 } 740 741 static u8 rk816_bat_get_halt_cnt(struct battery_priv *di) 742 { 743 return rk816_bat_read(di, HALT_CNT_REG); 744 } 745 746 static void rk816_bat_inc_halt_cnt(struct battery_priv *di) 747 { 748 u8 cnt; 749 750 cnt = rk816_bat_read(di, HALT_CNT_REG); 751 rk816_bat_write(di, HALT_CNT_REG, ++cnt); 752 } 753 754 static bool is_rk816_bat_last_halt(struct battery_priv *di) 755 { 756 int pre_cap = rk816_bat_get_prev_cap(di); 757 int now_cap = rk816_bat_get_coulomb_cap(di); 758 759 /* over 5%: system halt last time */ 760 if (abs(now_cap - pre_cap) > (di->fcc / 20)) { 761 rk816_bat_inc_halt_cnt(di); 762 return true; 763 } else { 764 return false; 765 } 766 } 767 768 static void rk816_bat_not_first_pwron(struct battery_priv *di) 769 { 770 int pre_soc, pre_cap, ocv_cap, ocv_soc, ocv_vol, now_cap; 771 772 di->fcc = rk816_bat_get_fcc(di); 773 pre_soc = rk816_bat_get_dsoc(di); 774 pre_cap = rk816_bat_get_prev_cap(di); 775 now_cap = rk816_bat_get_coulomb_cap(di); 776 di->pwr_dsoc = pre_soc; 777 di->pwr_rsoc = (now_cap + di->fcc / 200) * 100 / DIV(di->fcc); 778 di->is_halt = is_rk816_bat_last_halt(di); 779 di->halt_cnt = rk816_bat_get_halt_cnt(di); 780 di->is_ocv_calib = is_rk816_bat_ocv_valid(di); 781 782 if (di->is_halt) { 783 BAT_INFO("system halt last time... cap: pre=%d, now=%d\n", 784 pre_cap, now_cap); 785 if (now_cap < 0) 786 now_cap = 0; 787 rk816_bat_init_capacity(di, now_cap); 788 pre_cap = di->remain_cap; 789 pre_soc = di->rsoc; 790 goto finish; 791 } else if (di->is_ocv_calib) { 792 ocv_vol = rk816_bat_get_ocv_voltage(di); 793 ocv_soc = rk816_bat_vol_to_soc(di, ocv_vol); 794 ocv_cap = rk816_bat_vol_to_cap(di, ocv_vol); 795 pre_cap = ocv_cap; 796 BAT_INFO("do ocv calib.. rsoc=%d\n", ocv_soc); 797 798 if (abs(ocv_soc - pre_soc) >= di->max_soc_offset) { 799 BAT_INFO("trigger max soc offset, soc: %d -> %d\n", 800 pre_soc, ocv_soc); 801 pre_soc = ocv_soc; 802 di->is_max_soc_offset = true; 803 } 804 BAT_INFO("OCV calib: cap=%d, rsoc=%d\n", ocv_cap, ocv_soc); 805 } 806 finish: 807 di->dsoc = pre_soc; 808 di->nac = pre_cap; 809 rk816_bat_init_capacity(di, di->nac); 810 rk816_bat_set_initialized_state(di); 811 BAT_INFO("dl=%d rl=%d cap=%d m=%d v=%d ov=%d c=%d pl=%d ch=%d Ver=%s\n", 812 di->dsoc, di->rsoc, di->remain_cap, di->pwroff_min, 813 rk816_bat_get_avg_voltage(di), rk816_bat_get_ocv_voltage(di), 814 rk816_bat_get_avg_current(di), rk816_bat_get_dsoc(di), 815 rk816_bat_get_usb_state(di), DRIVER_VERSION 816 ); 817 } 818 819 static bool is_rk816_bat_first_poweron(struct battery_priv *di) 820 { 821 u8 buf; 822 823 buf = rk816_bat_read(di, GGSTS_REG); 824 if (buf & BAT_CON) { 825 buf &= ~BAT_CON; 826 rk816_bat_write(di, GGSTS_REG, buf); 827 return true; 828 } 829 830 return false; 831 } 832 833 static bool rk816_bat_ocv_sw_reset(struct battery_priv *di) 834 { 835 u8 buf; 836 837 buf = rk816_bat_read(di, MISC_MARK_REG); 838 if (((buf & FG_RESET_LATE) && di->pwroff_min >= 30) || 839 (buf & FG_RESET_NOW)) { 840 buf &= ~FG_RESET_LATE; 841 buf &= ~FG_RESET_NOW; 842 rk816_bat_write(di, MISC_MARK_REG, buf); 843 BAT_INFO("manual reset fuel gauge\n"); 844 return true; 845 } else { 846 return false; 847 } 848 } 849 850 static int rk816_bat_calc_linek(struct battery_priv *di) 851 { 852 int linek, diff, delta; 853 854 di->calc_dsoc = di->dsoc; 855 di->calc_rsoc = di->rsoc; 856 di->sm_old_cap = di->remain_cap; 857 858 delta = abs(di->dsoc - di->rsoc); 859 diff = delta * 3; 860 di->sm_meet_soc = (di->dsoc >= di->rsoc) ? 861 (di->dsoc + diff) : (di->rsoc + diff); 862 863 if (di->dsoc < di->rsoc) 864 linek = 1000 * (delta + diff) / DIV(diff); 865 else if (di->dsoc > di->rsoc) 866 linek = 1000 * diff / DIV(delta + diff); 867 else 868 linek = 1000; 869 870 di->sm_chrg_dsoc = di->dsoc * 1000; 871 872 DBG("<%s>. meet=%d, diff=%d, link=%d, calc: dsoc=%d, rsoc=%d\n", 873 __func__, di->sm_meet_soc, diff, linek, 874 di->calc_dsoc, di->calc_rsoc); 875 876 return linek; 877 } 878 879 static int rk816_bat_get_coffset(struct battery_priv *di) 880 { 881 int val = 0; 882 883 val |= rk816_bat_read(di, CAL_OFFSET_REGL) << 0; 884 val |= rk816_bat_read(di, CAL_OFFSET_REGH) << 8; 885 886 return val; 887 } 888 889 static void rk816_bat_init_poffset(struct battery_priv *di) 890 { 891 int coffset, ioffset; 892 893 coffset = rk816_bat_get_coffset(di); 894 ioffset = rk816_bat_get_ioffset(di); 895 di->poffset = coffset - ioffset; 896 } 897 898 static bool is_rk816_bat_exist(struct battery_priv *di) 899 { 900 return (rk816_bat_read(di, SUP_STS_REG) & BAT_EXS) ? true : false; 901 } 902 903 static void rk816_bat_set_current(struct battery_priv *di, int input_current) 904 { 905 u8 usb_ctrl; 906 907 usb_ctrl = rk816_bat_read(di, USB_CTRL_REG); 908 usb_ctrl &= ~INPUT_CUR_MSK; 909 usb_ctrl |= (input_current); 910 rk816_bat_write(di, USB_CTRL_REG, usb_ctrl); 911 } 912 913 static void rk816_bat_charger_setting(struct battery_priv *di, int charger) 914 { 915 static u8 old_charger = UNDEF_CHARGER; 916 917 /*charger changed*/ 918 if (old_charger != charger) { 919 if (charger == NO_CHARGER) 920 rk816_bat_set_current(di, ILIM_450MA); 921 else if (charger == USB_CHARGER) 922 rk816_bat_set_current(di, ILIM_450MA); 923 else if (charger == DC_CHARGER || charger == AC_CHARGER) 924 rk816_bat_set_current(di, di->chrg_cur_input); 925 else 926 BAT_INFO("charger setting error %d\n", charger); 927 928 old_charger = charger; 929 } 930 } 931 932 static int rk816_bat_get_dc_state(struct battery_priv *di) 933 { 934 /* struct adc_channel val; */ 935 936 if (di->dc_type == DC_TYPE_OF_NONE) { 937 return NO_CHARGER; 938 } else if (di->dc_type == DC_TYPE_OF_ADC) { 939 /* 940 if (adc_channels_single_shot("saradc", 0, &val)) { 941 printf("read saradc value failed\n"); 942 return NO_CHARGER; 943 } 944 945 return (val.data >= DC_ADC_TRIGGER) ? DC_CHARGER : NO_CHARGER; 946 */ 947 return NO_CHARGER; 948 } else { 949 return (dm_gpio_get_value(&di->dc_det)) ? 950 DC_CHARGER : NO_CHARGER; 951 } 952 } 953 954 static int rk816_bat_get_charger_type(struct battery_priv *di) 955 { 956 int charger_type = NO_CHARGER; 957 958 /* check by ic hardware: this check make check work safer */ 959 if ((rk816_bat_read(di, VB_MON_REG) & PLUG_IN_STS) == 0) 960 return NO_CHARGER; 961 962 /* virtual or bat not exist */ 963 if (di->virtual_power) 964 return DC_CHARGER; 965 966 /* check DC first */ 967 charger_type = rk816_bat_get_dc_state(di); 968 if (charger_type == DC_CHARGER) 969 return charger_type; 970 971 /* check USB second */ 972 return rk816_bat_get_usb_state(di); 973 } 974 975 static bool rk816_bat_need_initialize(struct battery_priv *di) 976 { 977 bool initialize = false; 978 #ifdef CONFIG_DM_CHARGE_DISPLAY 979 struct charge_animation_pdata *pdata; 980 struct udevice *dev; 981 int est_voltage; 982 983 if (!uclass_find_first_device(UCLASS_CHARGE_DISPLAY, &dev)) { 984 pdata = dev_get_platdata(dev); 985 est_voltage = rk816_bat_get_avg_voltage(di); 986 if ((pdata->uboot_charge) || 987 (pdata->low_power_voltage >= est_voltage)) 988 initialize = true; 989 } 990 #endif 991 992 return initialize; 993 } 994 995 void rk816_bat_init_rsoc(struct battery_priv *di) 996 { 997 bool initialize = false; 998 999 di->is_first_power_on = is_rk816_bat_first_poweron(di); 1000 /* If first power on, we must do initialization */ 1001 if (di->is_first_power_on) 1002 initialize = true; 1003 /* Only charger online and under threshold, we do initialization */ 1004 else if (rk816_bat_get_charger_type(di) != NO_CHARGER) 1005 initialize = rk816_bat_need_initialize(di); 1006 1007 printf("Fuel gauge initialize = %d\n", initialize); 1008 1009 if (!initialize) 1010 return; 1011 1012 di->pwroff_min = rk816_bat_get_pwroff_min(di); 1013 di->is_sw_reset = rk816_bat_ocv_sw_reset(di); 1014 1015 if (di->is_first_power_on || di->is_sw_reset) 1016 rk816_bat_first_pwron(di); 1017 else 1018 rk816_bat_not_first_pwron(di); 1019 1020 rk816_bat_save_dsoc(di, di->dsoc); 1021 rk816_bat_save_cap(di, di->remain_cap); 1022 } 1023 1024 static int rk816_fg_init(struct battery_priv *di) 1025 { 1026 rk816_bat_enable_input_current(di); 1027 rk816_bat_enable_gauge(di); 1028 rk816_bat_set_vol_instant_mode(di); 1029 rk816_bat_init_voltage_kb(di); 1030 rk816_bat_init_poffset(di); 1031 rk816_bat_clr_initialized_state(di); 1032 di->dsoc = rk816_bat_get_dsoc(di); 1033 di->remain_cap = rk816_bat_get_prev_cap(di); 1034 1035 /* 1036 * It's better to init fg in kernel, 1037 * so avoid init in uboot as far as possible. 1038 */ 1039 rk816_bat_init_rsoc(di); 1040 rk816_bat_init_chrg_config(di); 1041 di->chrg_type = rk816_bat_get_charger_type(di); 1042 di->voltage_avg = rk816_bat_get_avg_voltage(di); 1043 di->voltage_ocv = rk816_bat_get_ocv_voltage(di); 1044 di->current_avg = rk816_bat_get_avg_current(di); 1045 di->sm_linek = rk816_bat_calc_linek(di); 1046 di->finish_chrg_base = get_timer(0); 1047 di->pwr_vol = di->voltage_avg; 1048 rk816_bat_charger_setting(di, di->chrg_type); 1049 1050 printf("Battery: soc=%d%%, cap=%dmAh, voltage=%dmv, Charger: %s%s\n", 1051 di->dsoc, di->remain_cap, di->voltage_avg, 1052 charger_type_to_name[di->chrg_type], 1053 di->virtual_power ? "(virtual)" : ""); 1054 1055 return 0; 1056 } 1057 1058 static u8 rk816_bat_get_chrg_status(struct battery_priv *di) 1059 { 1060 u8 status; 1061 1062 status = rk816_bat_read(di, SUP_STS_REG) & BAT_STATUS_MSK; 1063 switch (status) { 1064 case CHARGE_OFF: 1065 DBG("CHARGE-OFF...\n"); 1066 break; 1067 case DEAD_CHARGE: 1068 DBG("DEAD CHARGE...\n"); 1069 break; 1070 case TRICKLE_CHARGE: 1071 DBG("TRICKLE CHARGE...\n "); 1072 break; 1073 case CC_OR_CV: 1074 DBG("CC or CV...\n"); 1075 break; 1076 case CHARGE_FINISH: 1077 DBG("CHARGE FINISH...\n"); 1078 break; 1079 case USB_OVER_VOL: 1080 DBG("USB OVER VOL...\n"); 1081 break; 1082 case BAT_TMP_ERR: 1083 DBG("BAT TMP ERROR...\n"); 1084 break; 1085 case TIMER_ERR: 1086 DBG("TIMER ERROR...\n"); 1087 break; 1088 case USB_EXIST: 1089 DBG("USB EXIST...\n"); 1090 break; 1091 case USB_EFF: 1092 DBG(" USB EFF...\n"); 1093 break; 1094 default: 1095 return -EINVAL; 1096 } 1097 1098 return status; 1099 } 1100 1101 static void rk816_bat_finish_chrg(struct battery_priv *di) 1102 { 1103 u32 tgt_sec = 0; 1104 1105 if (di->dsoc < 100) { 1106 tgt_sec = di->fcc * 3600 / 100 / FINISH_CALI_CURR; 1107 if (get_timer(di->finish_chrg_base) > SECONDS(tgt_sec)) { 1108 di->finish_chrg_base = get_timer(0); 1109 di->dsoc++; 1110 } 1111 } 1112 DBG("<%s>. sec=%d, finish_sec=%lu\n", __func__, SECONDS(tgt_sec), 1113 get_timer(di->finish_chrg_base)); 1114 } 1115 1116 static void rk816_bat_debug_info(struct battery_priv *di) 1117 { 1118 u8 sup_sts, ggcon, ggsts, vb_mod, rtc, thermal, misc; 1119 u8 usb_ctrl, chrg_ctrl1, chrg_ctrl2, chrg_ctrl3; 1120 static const char *name[] = {"NONE", "USB", "AC", "DC", "UNDEF"}; 1121 1122 if (!dbg_enable) 1123 return; 1124 ggcon = rk816_bat_read(di, GGCON_REG); 1125 ggsts = rk816_bat_read(di, GGSTS_REG); 1126 sup_sts = rk816_bat_read(di, SUP_STS_REG); 1127 usb_ctrl = rk816_bat_read(di, USB_CTRL_REG); 1128 thermal = rk816_bat_read(di, THERMAL_REG); 1129 vb_mod = rk816_bat_read(di, VB_MON_REG); 1130 misc = rk816_bat_read(di, MISC_MARK_REG); 1131 rtc = rk816_bat_read(di, SECONDS_REG); 1132 chrg_ctrl1 = rk816_bat_read(di, CHRG_CTRL_REG1); 1133 chrg_ctrl2 = rk816_bat_read(di, CHRG_CTRL_REG2); 1134 chrg_ctrl3 = rk816_bat_read(di, CHRG_CTRL_REG3); 1135 1136 DBG("\n---------------------- DEBUG REGS ------------------------\n" 1137 "GGCON=0x%2x, GGSTS=0x%2x, RTC=0x%2x, SUP_STS= 0x%2x\n" 1138 "VB_MOD=0x%2x, USB_CTRL=0x%2x, THERMAL=0x%2x, MISC=0x%2x\n" 1139 "CHRG_CTRL:REG1=0x%2x, REG2=0x%2x, REG3=0x%2x\n", 1140 ggcon, ggsts, rtc, sup_sts, vb_mod, usb_ctrl, 1141 thermal, misc, chrg_ctrl1, chrg_ctrl2, chrg_ctrl3 1142 ); 1143 DBG("----------------------------------------------------------\n" 1144 "Dsoc=%d, Rsoc=%d, Vavg=%d, Iavg=%d, Cap=%d, Fcc=%d, d=%d\n" 1145 "K=%d, old_cap=%d, charger=%s, Is=%d, Ip=%d, Vs=%d\n" 1146 "min=%d, meet: soc=%d, calc: dsoc=%d, rsoc=%d, Vocv=%d\n" 1147 "off: i=0x%x, c=0x%x, max=%d, ocv_c=%d, halt: st=%d, cnt=%d\n" 1148 "pwr: dsoc=%d, rsoc=%d, vol=%d, exist=%d\n", 1149 di->dsoc, rk816_bat_get_rsoc(di), rk816_bat_get_avg_voltage(di), 1150 rk816_bat_get_avg_current(di), di->remain_cap, di->fcc, 1151 di->rsoc - di->dsoc, 1152 di->sm_linek, di->sm_old_cap, name[di->chrg_type], 1153 CHRG_CUR_SEL[chrg_ctrl1 & 0x0f], 1154 CHRG_CUR_INPUT[usb_ctrl & 0x0f], 1155 CHRG_VOL_SEL[(chrg_ctrl1 & 0x70) >> 4], di->pwroff_min, 1156 di->sm_meet_soc, di->calc_dsoc, di->calc_rsoc, 1157 rk816_bat_get_ocv_voltage(di), rk816_bat_get_ioffset(di), 1158 rk816_bat_get_coffset(di), di->is_max_soc_offset, 1159 di->is_ocv_calib, di->is_halt, di->halt_cnt, di->pwr_dsoc, 1160 di->pwr_rsoc, di->pwr_vol, is_rk816_bat_exist(di) 1161 ); 1162 rk816_bat_get_chrg_status(di); 1163 DBG("###########################################################\n"); 1164 } 1165 1166 static void rk816_bat_linek_algorithm(struct battery_priv *di) 1167 { 1168 int delta_cap, ydsoc, tmp; 1169 u8 chg_st = rk816_bat_get_chrg_status(di); 1170 1171 /* slow down */ 1172 if (di->dsoc == 99) 1173 di->sm_linek = CHRG_FULL_K; 1174 else if (di->dsoc >= CHRG_TERM_DSOC && di->current_avg > TERM_CALI_CURR) 1175 di->sm_linek = CHRG_TERM_K; 1176 1177 delta_cap = di->remain_cap - di->sm_old_cap; 1178 ydsoc = di->sm_linek * delta_cap * 100 / DIV(di->fcc); 1179 if (ydsoc > 0) { 1180 tmp = (di->sm_chrg_dsoc + 1) / 1000; 1181 if (tmp != di->dsoc) 1182 di->sm_chrg_dsoc = di->dsoc * 1000; 1183 di->sm_chrg_dsoc += ydsoc; 1184 di->dsoc = (di->sm_chrg_dsoc + 1) / 1000; 1185 di->sm_old_cap = di->remain_cap; 1186 if (di->dsoc == di->rsoc && di->sm_linek != CHRG_FULL_K && 1187 di->sm_linek != CHRG_TERM_K) 1188 di->sm_linek = 1000; 1189 } 1190 1191 if ((di->sm_linek == 1000 || di->dsoc >= 100) && 1192 (chg_st != CHARGE_FINISH)) { 1193 if (di->sm_linek == 1000) 1194 di->dsoc = di->rsoc; 1195 di->sm_chrg_dsoc = di->dsoc * 1000; 1196 } 1197 1198 DBG("linek=%d, sm_dsoc=%d, delta_cap=%d, ydsoc=%d, old_cap=%d\n" 1199 "calc: dsoc=%d, rsoc=%d, meet=%d\n", 1200 di->sm_linek, di->sm_chrg_dsoc, delta_cap, ydsoc, di->sm_old_cap, 1201 di->calc_dsoc, di->calc_rsoc, di->sm_meet_soc); 1202 } 1203 1204 static int rk816_bat_get_iadc(struct battery_priv *di) 1205 { 1206 int val = 0; 1207 1208 val |= rk816_bat_read(di, BAT_CUR_AVG_REGL) << 0; 1209 val |= rk816_bat_read(di, BAT_CUR_AVG_REGH) << 8; 1210 if (val > 2047) 1211 val -= 4096; 1212 1213 return val; 1214 } 1215 1216 static bool rk816_bat_adc_calib(struct battery_priv *di) 1217 { 1218 int i, ioffset, coffset, adc; 1219 1220 if (abs(di->current_avg) < ADC_CALIB_THRESHOLD) 1221 return false; 1222 1223 for (i = 0; i < 5; i++) { 1224 adc = rk816_bat_get_iadc(di); 1225 coffset = rk816_bat_get_coffset(di); 1226 rk816_bat_set_coffset(di, coffset + adc); 1227 mdelay(200); 1228 adc = rk816_bat_get_iadc(di); 1229 if (abs(adc) < ADC_CALIB_THRESHOLD) { 1230 coffset = rk816_bat_get_coffset(di); 1231 ioffset = rk816_bat_get_ioffset(di); 1232 di->poffset = coffset - ioffset; 1233 rk816_bat_write(di, POFFSET_REG, di->poffset); 1234 BAT_INFO("new offset:c=0x%x, i=0x%x, p=0x%x\n", 1235 coffset, ioffset, di->poffset); 1236 return true; 1237 } else { 1238 BAT_INFO("coffset calib again %d..\n", i); 1239 rk816_bat_set_coffset(di, coffset); 1240 mdelay(200); 1241 } 1242 } 1243 1244 return false; 1245 } 1246 1247 static void rk816_bat_smooth_charge(struct battery_priv *di) 1248 { 1249 u8 chg_st = rk816_bat_get_chrg_status(di); 1250 1251 if (di->vol_mode_base && get_timer(di->vol_mode_base) > SECONDS(10)) { 1252 rk816_bat_set_vol_avg_mode(di); 1253 di->vol_mode_base = 0; 1254 } 1255 1256 /* not charge mode and not keep in uboot charge: exit */ 1257 if ((di->chrg_type == NO_CHARGER) || 1258 !rk816_bat_is_initialized(di)) { 1259 DBG("chrg=%d, initialized=%d\n", di->chrg_type, 1260 rk816_bat_is_initialized(di)); 1261 goto out; 1262 } 1263 1264 /* update rsoc and remain cap */ 1265 di->remain_cap = rk816_bat_get_coulomb_cap(di); 1266 di->rsoc = rk816_bat_get_rsoc(di); 1267 if (di->remain_cap > di->fcc) { 1268 di->sm_old_cap -= (di->remain_cap - di->fcc); 1269 rk816_bat_init_capacity(di, di->fcc); 1270 } 1271 1272 /* finish charge step */ 1273 if (chg_st == CHARGE_FINISH) { 1274 DBG("finish charge step...\n"); 1275 if (di->adc_allow_update) 1276 di->adc_allow_update = !rk816_bat_adc_calib(di); 1277 rk816_bat_finish_chrg(di); 1278 rk816_bat_init_capacity(di, di->fcc); 1279 } else { 1280 DBG("smooth charge step...\n"); 1281 di->adc_allow_update = true; 1282 di->finish_chrg_base = get_timer(0); 1283 rk816_bat_linek_algorithm(di); 1284 } 1285 1286 /* dsoc limit */ 1287 if (di->dsoc > 100) 1288 di->dsoc = 100; 1289 else if (di->dsoc < 0) 1290 di->dsoc = 0; 1291 1292 rk816_bat_save_dsoc(di, di->dsoc); 1293 rk816_bat_save_cap(di, di->remain_cap); 1294 out: 1295 rk816_bat_debug_info(di); 1296 } 1297 1298 static int rk816_bat_bat_is_exit(struct udevice *dev) 1299 { 1300 struct battery_priv *di = dev_get_priv(dev); 1301 1302 return is_rk816_bat_exist(di); 1303 } 1304 1305 static int rk816_bat_update_get_soc(struct udevice *dev) 1306 { 1307 struct battery_priv *di = dev_get_priv(dev); 1308 static ulong seconds; 1309 1310 /* set charge current */ 1311 di->chrg_type = 1312 rk816_bat_get_charger_type(di); 1313 rk816_bat_charger_setting(di, di->chrg_type); 1314 1315 /* fg calc every 5 seconds */ 1316 if (!seconds) 1317 seconds = get_timer(0); 1318 if (get_timer(seconds) >= SECONDS(5)) { 1319 seconds = get_timer(0); 1320 rk816_bat_smooth_charge(di); 1321 } 1322 1323 /* bat exist, fg init success(dts pass) and uboot charge: report data */ 1324 if (!di->virtual_power && di->voltage_k) 1325 return di->dsoc; 1326 else 1327 return VIRTUAL_POWER_SOC; 1328 } 1329 1330 static int rk816_bat_update_get_voltage(struct udevice *dev) 1331 { 1332 struct battery_priv *di = dev_get_priv(dev); 1333 1334 if (!di->virtual_power && di->voltage_k) 1335 return rk816_bat_get_est_voltage(di); 1336 else 1337 return VIRTUAL_POWER_VOL; 1338 } 1339 1340 static int rk816_bat_update_get_current(struct udevice *dev) 1341 { 1342 struct battery_priv *di = dev_get_priv(dev); 1343 1344 if (!di->virtual_power && di->voltage_k) 1345 return rk816_bat_get_avg_current(di); 1346 else 1347 return VIRTUAL_POWER_CUR; 1348 } 1349 1350 static bool rk816_bat_update_get_chrg_online(struct udevice *dev) 1351 { 1352 struct battery_priv *di = dev_get_priv(dev); 1353 1354 return rk816_bat_get_charger_type(di); 1355 } 1356 1357 static struct dm_fuel_gauge_ops fg_ops = { 1358 .bat_is_exist = rk816_bat_bat_is_exit, 1359 .get_soc = rk816_bat_update_get_soc, 1360 .get_voltage = rk816_bat_update_get_voltage, 1361 .get_current = rk816_bat_update_get_current, 1362 .get_chrg_online = rk816_bat_update_get_chrg_online, 1363 }; 1364 1365 static int rk816_fg_ofdata_to_platdata(struct udevice *dev) 1366 { 1367 struct rk8xx_priv *rk8xx = dev_get_priv(dev->parent); 1368 struct battery_priv *di = dev_get_priv(dev); 1369 const char *prop; 1370 int len; 1371 1372 if (rk8xx->variant != 0x8160) { 1373 debug("%s: Not support pmic variant: rk%x\n", 1374 __func__, rk8xx->variant); 1375 return -EINVAL; 1376 } else { 1377 di->dev = dev; 1378 } 1379 1380 /* Parse ocv table */ 1381 prop = dev_read_prop(dev, "ocv_table", &len); 1382 if (!prop) { 1383 printf("can't find ocv_table prop\n"); 1384 return -EINVAL; 1385 } 1386 1387 di->ocv_table = calloc(len, 1); 1388 if (!di->ocv_table) { 1389 printf("can't calloc ocv_table\n"); 1390 return -ENOMEM; 1391 } 1392 1393 di->ocv_size = len / 4; 1394 if (dev_read_u32_array(dev, "ocv_table", 1395 di->ocv_table, di->ocv_size)) { 1396 printf("can't read ocv_table\n"); 1397 free(di->ocv_table); 1398 return -EINVAL; 1399 } 1400 1401 /* Parse neccessay */ 1402 di->design_cap = dev_read_u32_default(dev, "design_capacity", -1); 1403 if (di->design_cap < 0) { 1404 printf("can't read design_capacity\n"); 1405 return -EINVAL; 1406 } 1407 1408 di->qmax = dev_read_u32_default(dev, "design_qmax", -1); 1409 if (di->qmax < 0) { 1410 printf("can't read design_qmax\n"); 1411 return -EINVAL; 1412 } 1413 1414 /* Parse un-neccessay */ 1415 di->dts_vol_sel = dev_read_u32_default(dev, "max_chrg_voltage", 4200); 1416 di->dts_cur_input = dev_read_u32_default(dev, "max_input_current", 2000); 1417 di->dts_cur_sel = dev_read_u32_default(dev, "max_chrg_current", 1200); 1418 di->max_soc_offset = dev_read_u32_default(dev, "max_soc_offset", 70); 1419 di->virtual_power = dev_read_u32_default(dev, "virtual_power", 0); 1420 di->bat_res = dev_read_u32_default(dev, "bat_res", 135); 1421 1422 /* Parse dc type */ 1423 di->dc_det_adc = dev_read_u32_default(dev, "dc_det_adc", 0); 1424 if (di->dc_det_adc <= 0) { 1425 if (!gpio_request_by_name_nodev(dev_ofnode(dev), "dc_det_gpio", 1426 0, &di->dc_det, GPIOD_IS_IN)) { 1427 di->dc_type = DC_TYPE_OF_GPIO; 1428 } else { 1429 di->dc_type = DC_TYPE_OF_NONE; 1430 } 1431 } else { 1432 di->dc_type = DC_TYPE_OF_ADC; 1433 } 1434 1435 /* Is battery attached */ 1436 if (!is_rk816_bat_exist(di)) 1437 di->virtual_power = 1; 1438 1439 DBG("-------------------------------:\n"); 1440 DBG("max_input_current:%d\n", di->dts_cur_input); 1441 DBG("max_chrg_current:%d\n", di->dts_cur_sel); 1442 DBG("max_chrg_voltage:%d\n", di->dts_vol_sel); 1443 DBG("design_capacity :%d\n", di->design_cap); 1444 DBG("design_qmax:%d\n", di->qmax); 1445 DBG("max_soc_offset:%d\n", di->max_soc_offset); 1446 DBG("dc_det_adc:%d\n", di->dc_det_adc); 1447 1448 return 0; 1449 } 1450 1451 static int rk816_fg_probe(struct udevice *dev) 1452 { 1453 struct rk8xx_priv *rk8xx = dev_get_priv(dev->parent); 1454 struct battery_priv *di = dev_get_priv(dev); 1455 1456 if (rk8xx->variant != 0x8160) { 1457 printf("Not support pmic variant: rk%x\n", rk8xx->variant); 1458 return -EINVAL; 1459 } 1460 1461 return rk816_fg_init(di); 1462 } 1463 1464 U_BOOT_DRIVER(rk816_fg) = { 1465 .name = "rk816_fg", 1466 .id = UCLASS_FG, 1467 .probe = rk816_fg_probe, 1468 .ops = &fg_ops, 1469 .ofdata_to_platdata = rk816_fg_ofdata_to_platdata, 1470 .priv_auto_alloc_size = sizeof(struct battery_priv), 1471 }; 1472