drivers/power/rk818_battery.c

   1 /*
   2  * rk818/rk819 battery driver
   3  *
   4  *  Copyright (C) 2014 Rockchip Electronics Co., Ltd
   5  *  Author: zhangqing <zhangqing@rock-chips.com>
   6  *          chenjh    <chenjh@rock-chips.com>
   7  *          Andy Yan  <andy.yan@rock-chips.com>
   8  *
   9  *  Copyright (C) 2008-2009 Texas Instruments, Inc.
  10  *  Author: Texas Instruments, Inc.
  11  *
  12  * Copyright (C) 2008-2009 Texas Instruments, Inc.
  13  * Author: Texas Instruments, Inc.
  14  * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
  15  * Author: zhangqing <zhangqing@rock-chips.com>
  16  * Copyright (C) 2014-2015 Intel Mobile Communications GmbH
  17  *
  18  * This program is free software; you can redistribute it and/or modify it
  19  * under the terms and conditions of the GNU General Public License,
  20  * version 2, as published by the Free Software Foundation.
  21  *
  22  * This program is distributed in the hope it will be useful, but WITHOUT
  23  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  24  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  25  * more details.
  26  *
  27  */
  28 #include <linux/kernel.h>
  29 #include <linux/module.h>
  30 #include <linux/param.h>
  31 #include <linux/jiffies.h>
  32 #include <linux/workqueue.h>
  33 #include <linux/delay.h>
  34 #include <linux/platform_device.h>
  35 #include <linux/power_supply.h>
  36 #include <linux/idr.h>
  37 #include <linux/i2c.h>
  38 #include <linux/slab.h>
  39 #include <asm/unaligned.h>
  40 #include <linux/gpio.h>
  41 #include <linux/proc_fs.h>
  42 #include <linux/uaccess.h>
  43 #include <linux/mfd/rk818.h>
  44 #include <linux/time.h>
  45 #include <linux/interrupt.h>
  46 #include <linux/rtc.h>
  47 #include <linux/wakelock.h>
  48 #include <linux/of_gpio.h>
  49 #include <linux/irq.h>
  50 #include <linux/irqdomain.h>
  51 #include <linux/usb/phy.h>
  52 #include <linux/fb.h>
  53
  54 #if defined(CONFIG_X86_INTEL_SOFIA)
  55 #include <linux/usb/phy-intel.h>
  56 #else
  57 #include <linux/power/rk_usbbc.h>
  58 #endif
  59 #include "rk818_battery.h"
  60
  61 /* if you  want to disable, don't set it as 0,
  62 just be: "static int dbg_enable;" is ok*/
  63
  64 static int dbg_enable;
  65 #define RK818_SYS_DBG 1
  66
  67 module_param_named(dbg_level, dbg_enable, int, 0644);
  68
  69 #define DBG(args...) \
  70         do { \
  71                 if (dbg_enable) { \
  72                         pr_info(args); \
  73                 } \
  74         } while (0)
  75
  76 #define DEFAULT_BAT_RES                 135
  77 #define DEFAULT_CHRG_VOL                4200
  78 #define DEFAULT_CHRG_CUR                1000
  79 #define DEFAULT_INPUT_CUR               1400
  80 #define DEFAULT_SLP_ENTER_CUR           600
  81 #define DEFAULT_SLP_EXIT_CUR            600
  82
  83 #define DSOC_DISCHRG_EMU_CURR           1200
  84 #define DSOC_DISCHRG_FAST_DEC_SEC       120     /*seconds*/
  85 #define DSOC_DISCHRG_FAST_EER_RANGE     10
  86 #define DSOC_CHRG_FAST_CALIB_CURR_MAX   400     /*mA*/
  87 #define DSOC_CHRG_FAST_INC_SEC          120     /*seconds*/
  88 #define DSOC_CHRG_FAST_EER_RANGE        10
  89 #define DSOC_CHRG_EMU_CURR              1200
  90 #define DSOC_CHRG_TERM_CURR             600
  91 #define DSOC_CHRG_TERM_VOL              4100
  92 #define CHRG_FINISH_VOL                 4100
  93
  94 /*realtime RSOC calib param*/
  95 #define RSOC_DISCHRG_ERR_LOWER  40
  96 #define RSOC_DISCHRG_ERR_UPPER  50
  97 #define RSOC_ERR_CHCK_CNT       15
  98 #define RSOC_COMPS              20      /*compensation*/
  99 #define RSOC_CALIB_CURR_MAX     900     /*mA*/
 100 #define RSOC_CALIB_DISCHRGR_TIME        3       /*min*/
 101
 102 #define RSOC_RESUME_ERR         10
 103 #define REBOOT_INTER_MIN        1
 104
 105 #define INTERPOLATE_MAX         1000
 106 #define MAX_INT                 0x7FFF
 107 #define TIME_10MIN_SEC          600
 108
 109 #define CHRG_VOL_SHIFT          4
 110 #define CHRG_ILIM_SHIFT         0
 111 #define CHRG_ICUR_SHIFT         0
 112 #define DEF_CHRG_VOL            CHRG_VOL4200
 113 #define DEF_CHRG_CURR_SEL       CHRG_CUR1400mA
 114 #define DEF_CHRG_CURR_LMT       ILIM_2000MA
 115
 116 /*TEST_POWER_MODE params*/
 117 #define TEST_CURRENT            1000
 118 #define TEST_VOLTAGE            3800
 119 #define TEST_SOC                66
 120 #define TEST_STATUS             POWER_SUPPLY_STATUS_CHARGING
 121 #define TEST_PRESET             1
 122 #define TEST_AC_ONLINE          1
 123 #define TEST_USB_ONLINE         0
 124
 125 #define ZERO_ALGOR_THRESD       3800
 126 #define DISCHRG_ZERO_MODE       1
 127 #define DISCHRG_NORMAL_MODE     0
 128 #define DEF_LAST_ZERO_MODE_SOC  -1
 129
 130 #define DISCHRG_MODE            0
 131 #define CHRG_MODE               1
 132
 133 #define TREND_STAT_FLAT         0
 134 #define TREND_STAT_DOWN         -1
 135 #define TREND_STAT_UP           1
 136 #define TREND_CAP_DIFF          5
 137
 138 #define MINUTE                  60
 139
 140 #define SLP_CURR_MAX            40
 141 #define SLP_CURR_MIN            6
 142 #define WAKEUP_SEC_THRESD       40
 143 #define CHRG_TIME_STEP          (60)
 144 #define DISCHRG_TIME_STEP_0     (30 * 60)
 145 #define DISCHRG_TIME_STEP_1     (60 * 60)
 146
 147 #define DEF_PCB_OFFSET          42
 148 #define DEF_CAL_OFFSET          0x832
 149 #define DEF_PWRPATH_RES         50
 150 #define SEC_TO_EMPTY            300
 151 #define DSOC_CHRG_FINISH_CURR   1100
 152 #define SLP_CHRG_CURR           1000
 153 #define SLP_DSOC_VOL_THRESD     3600
 154 /*if voltage is lower than this thresd,
 155    we consider it as invalid
 156  */
 157 #define INVALID_VOL_THRESD      2500
 158 #define PWR_OFF_THRESD          3400
 159 #define MIN_ZERO_ACCURACY       5       /*0.01%*/
 160 #define MIN_ROUND_ACCURACY      1
 161
 162 #define MAX_FCC                 10000
 163 #define MIN_FCC                 500
 164 /*
 165  * the following table value depends on datasheet
 166  */
 167 int CHRG_V_LMT[] = {4050, 4100, 4150, 4200, 4300, 4350};
 168
 169 int CHRG_I_CUR[] = {1000, 1200, 1400, 1600, 1800, 2000,
 170                    2250, 2400, 2600, 2800, 3000};
 171
 172 int CHRG_I_LMT[] = {450, 800, 850, 1000, 1250, 1500, 1750,
 173                    2000, 2250, 2500, 2750, 3000};
 174
 175 u8 CHRG_CVCC_HOUR[] = {4, 5, 6, 8, 10, 12, 14, 16};
 176
 177 #define RK818_DC_IN             0
 178 #define RK818_DC_OUT            1
 179
 180 #define OCV_VALID_SHIFT         (0)
 181 #define OCV_CALIB_SHIFT         (1)
 182 #define FIRST_PWRON_SHIFT       (2)
 183
 184 #define SEC_TO_MIN(x)           ((x) / 60)
 185
 186 struct rk81x_battery {
 187         struct device                   *dev;
 188         struct cell_state               cell;
 189         struct power_supply             bat;
 190         struct power_supply             ac;
 191         struct power_supply             usb;
 192         struct delayed_work             work;
 193         struct rk818                    *rk818;
 194         struct pinctrl                  *pinctrl;
 195         struct pinctrl_state            *pins_default;
 196
 197         struct battery_platform_data    *pdata;
 198
 199         int                             dc_det_pin;
 200         int                             dc_det_level;
 201         int                             dc_det_irq;
 202         int                             irq;
 203         int                             ac_online;
 204         int                             usb_online;
 205         int                             otg_online;
 206         int                             psy_status;
 207         int                             current_avg;
 208         int                             current_offset;
 209
 210         uint16_t                        voltage;
 211         uint16_t                        voltage_ocv;
 212         uint16_t                        relax_voltage;
 213         u8                              chrg_status;
 214         u8                              slp_chrg_status;
 215
 216         u8                              otg_status;
 217         int                             pcb_ioffset;
 218         bool                            pcb_ioffset_updated;
 219
 220         int                             design_capacity;
 221         int                             fcc;
 222         int                             qmax;
 223         int                             remain_capacity;
 224         int                             nac;
 225         int                             temp_nac;
 226         int                             dsoc;
 227         int                             display_soc;
 228         int                             rsoc;
 229         int                             trend_start_cap;
 230
 231         int                             est_ocv_vol;
 232         int                             est_ocv_soc;
 233         u8                              err_chck_cnt;
 234         int                             err_soc_sum;
 235         int                             bat_res_update_cnt;
 236         int                             soc_counter;
 237         int                             dod0;
 238         int                             dod0_status;
 239         int                             dod0_voltage;
 240         int                             dod0_capacity;
 241         unsigned long                   dod0_time;
 242         u8                              dod0_level;
 243         int                             adjust_cap;
 244
 245         int                             enter_flatzone;
 246         int                             exit_flatzone;
 247
 248         int                             time2empty;
 249         int                             time2full;
 250
 251         int                             *ocv_table;
 252         int                             *res_table;
 253
 254         int                             current_k;/* (ICALIB0, ICALIB1) */
 255         int                             current_b;
 256
 257         int                             voltage_k;/* VCALIB0 VCALIB1 */
 258         int                             voltage_b;
 259         bool                            enter_finish;
 260         int                             zero_timeout_cnt;
 261         int                             zero_old_remain_cap;
 262
 263         int                             line_k;
 264         u8                              check_count;
 265
 266         int                             charge_smooth_time;
 267         int                             sum_suspend_cap;
 268         int                             suspend_cap;
 269
 270         unsigned long                   suspend_time_sum;
 271
 272         int                             suspend_rsoc;
 273         int                             slp_psy_status;
 274         int                             suspend_charge_current;
 275         int                             resume_soc;
 276         int                             bat_res;
 277         bool                            charge_smooth_status;
 278         bool                            discharge_smooth_status;
 279
 280         u32                             plug_in_min;
 281         u32                             plug_out_min;
 282         u32                             finish_sig_min;
 283
 284         struct notifier_block           battery_nb;
 285         struct usb_phy                  *usb_phy;
 286         struct notifier_block           usb_nb;
 287         struct notifier_block           fb_nb;
 288         int                             fb_blank;
 289         int                             early_resume;
 290         int                             s2r; /*suspend to resume*/
 291         struct workqueue_struct         *wq;
 292         struct delayed_work             battery_monitor_work;
 293         struct delayed_work             otg_check_work;
 294         struct delayed_work             usb_phy_delay_work;
 295         struct delayed_work             chrg_term_mode_switch_work;
 296         struct delayed_work             ac_usb_check_work;
 297         struct delayed_work             dc_det_check_work;
 298         enum bc_port_type               charge_otg;
 299         int                             ma;
 300
 301         struct wake_lock                resume_wake_lock;
 302         unsigned long                   plug_in_base;
 303         unsigned long                   plug_out_base;
 304         unsigned long                   finish_sig_base;
 305         unsigned long                   power_on_base;
 306
 307         int                             chrg_time2full;
 308         int                             chrg_cap2full;
 309
 310         bool                            is_first_poweron;
 311
 312         int                             fg_drv_mode;
 313         int                             debug_finish_real_soc;
 314         int                             debug_finish_temp_soc;
 315         int                             chrg_min[10];
 316         int                             chrg_v_lmt;
 317         int                             chrg_i_lmt;
 318         int                             chrg_i_cur;
 319         uint16_t                        pwroff_min;
 320         unsigned long                   wakeup_sec;
 321         u32                             delta_vol_smooth;
 322         unsigned long                   dischrg_normal_base;
 323         unsigned long                   dischrg_emu_base;
 324         unsigned long                   chrg_normal_base;
 325         unsigned long                   chrg_term_base;
 326         unsigned long                   chrg_emu_base;
 327         unsigned long                   chrg_finish_base;
 328         unsigned long                   fcc_update_sec;
 329         int                             loader_charged;
 330         u8                              dischrg_algorithm_mode;
 331         int                             last_zero_mode_dsoc;
 332         u8                              current_mode;
 333         unsigned long                   dischrg_save_sec;
 334         unsigned long                   chrg_save_sec;
 335         struct timeval                  suspend_rtc_base;
 336 };
 337
 338 u32 support_usb_adp, support_dc_adp;
 339
 340 #define to_device_info(x) container_of((x), \
 341                                 struct rk81x_battery, bat)
 342
 343 #define to_ac_device_info(x) container_of((x), \
 344                                 struct rk81x_battery, ac)
 345
 346 #define to_usb_device_info(x) container_of((x), \
 347                                 struct rk81x_battery, usb)
 348
 349 static int loader_charged;
 350
 351 static int __init rk81x_bat_loader_charged(char *__unused)
 352 {
 353         loader_charged = 1;
 354
 355         pr_info("battery charged in loader\n");
 356
 357         return 0;
 358 }
 359 __setup("loader_charged", rk81x_bat_loader_charged);
 360
 361 static u64 get_runtime_sec(void)
 362 {
 363         struct timespec ts;
 364
 365         get_monotonic_boottime(&ts);
 366         return ts.tv_sec;
 367 }
 368
 369 static inline unsigned long  BASE_TO_SEC(unsigned long x)
 370 {
 371         if (x)
 372                 return (get_runtime_sec() > x) ? (get_runtime_sec() - x) : 0;
 373         else
 374                 return 0;
 375 }
 376
 377 static inline unsigned long BASE_TO_MIN(unsigned long x)
 378 {
 379         return  BASE_TO_SEC(x) / 60;
 380 }
 381
 382 static bool rk81x_bat_support_adp_type(enum hw_support_adp type)
 383 {
 384         bool bl = false;
 385
 386         switch (type) {
 387         case HW_ADP_TYPE_USB:
 388                 if (support_usb_adp)
 389                         bl = true;
 390                 break;
 391         case HW_ADP_TYPE_DC:
 392                 if (support_dc_adp)
 393                         bl = true;
 394                 break;
 395         case HW_ADP_TYPE_DUAL:
 396                 if (support_usb_adp && support_dc_adp)
 397                         bl = true;
 398                 break;
 399         default:
 400                         break;
 401         }
 402
 403         return bl;
 404 }
 405
 406 static bool rk81x_chrg_online(struct rk81x_battery *di)
 407 {
 408         return di->usb_online || di->ac_online;
 409 }
 410
 411 static u32 interpolate(int value, u32 *table, int size)
 412 {
 413         uint8_t i;
 414         uint16_t d;
 415
 416         for (i = 0; i < size; i++) {
 417                 if (value < table[i])
 418                         break;
 419         }
 420
 421         if ((i > 0) && (i < size)) {
 422                 d = (value - table[i-1]) * (INTERPOLATE_MAX / (size - 1));
 423                 d /= table[i] - table[i-1];
 424                 d = d + (i-1) * (INTERPOLATE_MAX / (size - 1));
 425         } else {
 426                 d = i * ((INTERPOLATE_MAX + size / 2) / size);
 427         }
 428
 429         if (d > 1000)
 430                 d = 1000;
 431
 432         return d;
 433 }
 434
 435 /* Returns (a * b) / c */
 436 static int32_t ab_div_c(u32 a, u32 b, u32 c)
 437 {
 438         bool sign;
 439         u32 ans = MAX_INT;
 440         int32_t tmp;
 441
 442         sign = ((((a^b)^c) & 0x80000000) != 0);
 443
 444         if (c != 0) {
 445                 if (sign)
 446                         c = -c;
 447
 448                 tmp = (a * b + (c >> 1)) / c;
 449
 450                 if (tmp < MAX_INT)
 451                         ans = tmp;
 452         }
 453
 454         if (sign)
 455                 ans = -ans;
 456
 457         return ans;
 458 }
 459
 460 static int div(int val)
 461 {
 462         return (val == 0) ? 1 : val;
 463 }
 464
 465 static int rk81x_bat_read(struct rk81x_battery *di, u8 reg,
 466                           u8 buf[], unsigned len)
 467 {
 468         int ret = -1;
 469         int i;
 470
 471         for (i = 0; ret < 0 && i < 3; i++) {
 472                 ret = rk818_i2c_read(di->rk818, reg, len, buf);
 473                 if (ret < 0)
 474                         dev_err(di->dev, "read reg:0x%02x failed\n", reg);
 475         }
 476
 477         return (ret < 0) ? ret : 0;
 478 }
 479
 480 static int rk81x_bat_write(struct rk81x_battery *di, u8 reg,
 481                            u8 const buf[], unsigned len)
 482 {
 483         int ret = -1;
 484         int i;
 485
 486         for (i = 0; ret < 0 && i < 3; i++) {
 487                 ret = rk818_i2c_write(di->rk818, reg, (int)len, *buf);
 488                 if (ret < 0)
 489                         dev_err(di->dev, "write reg:0x%02x failed\n", reg);
 490         }
 491
 492         return (ret < 0) ? ret : 0;
 493 }
 494
 495 static int rk81x_bat_set_bit(struct rk81x_battery *di, u8 reg, u8 shift)
 496 {
 497         int ret = -1;
 498         int i;
 499
 500         for (i = 0; ret < 0 && i < 3; i++) {
 501                 ret = rk818_set_bits(di->rk818, reg, 1 << shift, 1 << shift);
 502                 if (ret < 0)
 503                         dev_err(di->dev, "set reg:0x%02x failed\n", reg);
 504         }
 505
 506         return ret;
 507 }
 508
 509 static int rk81x_bat_clr_bit(struct rk81x_battery *di, u8 reg, u8 shift)
 510 {
 511         int ret = -1;
 512         int i;
 513
 514         for (i = 0; ret < 0 && i < 3; i++) {
 515                 ret = rk818_set_bits(di->rk818, reg, 1 << shift, 0 << shift);
 516                 if (ret < 0)
 517                         dev_err(di->dev, "set reg:0x%02x failed\n", reg);
 518         }
 519
 520         return ret;
 521 }
 522
 523 static u8 rk81x_bat_read_bit(struct rk81x_battery *di, u8 reg, u8 shift)
 524 {
 525         u8 buf;
 526         u8 val;
 527
 528         rk81x_bat_read(di, reg, &buf, 1);
 529         val = (buf & BIT(shift)) >> shift;
 530         return val;
 531 }
 532
 533 static void rk81x_dbg_dmp_gauge_regs(struct rk81x_battery *di)
 534 {
 535         int i = 0;
 536         u8 buf;
 537
 538         DBG("%s dump charger register start:\n", __func__);
 539         for (i = 0xAC; i < 0xEE; i++) {
 540                 rk81x_bat_read(di, i, &buf, 1);
 541                 DBG("0x%02x : 0x%02x\n", i, buf);
 542         }
 543         DBG("demp end!\n");
 544 }
 545
 546 static void rk81x_dbg_dmp_charger_regs(struct rk81x_battery *di)
 547 {
 548         int i = 0;
 549         char buf;
 550
 551         DBG("%s dump the register start:\n", __func__);
 552         for (i = 0x99; i < 0xAB; i++) {
 553                 rk81x_bat_read(di, i, &buf, 1);
 554                 DBG(" the register is  0x%02x, the value is 0x%02x\n", i, buf);
 555         }
 556         DBG("demp end!\n");
 557 }
 558
 559 static void rk81x_bat_reset_zero_var(struct rk81x_battery *di)
 560 {
 561         di->dischrg_algorithm_mode = DISCHRG_NORMAL_MODE;
 562         di->last_zero_mode_dsoc = DEF_LAST_ZERO_MODE_SOC;
 563 }
 564
 565 static void rk81x_bat_capacity_init_post(struct rk81x_battery *di)
 566 {
 567         rk81x_bat_reset_zero_var(di);
 568         di->trend_start_cap = di->remain_capacity;
 569 }
 570
 571 static void rk81x_bat_capacity_init(struct rk81x_battery *di, u32 capacity)
 572 {
 573         u8 buf;
 574         u32 capacity_ma;
 575         int delta_cap;
 576
 577         delta_cap = capacity - di->remain_capacity;
 578         if (!delta_cap)
 579                 return;
 580
 581         di->adjust_cap += delta_cap;
 582
 583         capacity_ma = capacity * 2390;/* 2134;//36*14/900*4096/521*500; */
 584         do {
 585                 buf = (capacity_ma >> 24) & 0xff;
 586                 rk81x_bat_write(di, GASCNT_CAL_REG3, &buf, 1);
 587                 buf = (capacity_ma >> 16) & 0xff;
 588                 rk81x_bat_write(di, GASCNT_CAL_REG2, &buf, 1);
 589                 buf = (capacity_ma >> 8) & 0xff;
 590                 rk81x_bat_write(di, GASCNT_CAL_REG1, &buf, 1);
 591                 buf = (capacity_ma & 0xff) | 0x01;
 592                 rk81x_bat_write(di, GASCNT_CAL_REG0, &buf, 1);
 593                 rk81x_bat_read(di, GASCNT_CAL_REG0, &buf, 1);
 594
 595         } while (buf == 0);
 596
 597         if (di->chrg_status != CHARGE_FINISH || di->dod0_status == 1)
 598                 dev_dbg(di->dev, "update capacity :%d--remain_cap:%d\n",
 599                         capacity, di->remain_capacity);
 600 }
 601
 602 #if RK818_SYS_DBG
 603 /*
 604  * interface for debug: do rk81x_bat_first_pwron() without unloading battery
 605  */
 606 static ssize_t bat_calib_read(struct device *dev,
 607                               struct device_attribute *attr, char *buf)
 608 {
 609         struct power_supply *psy_bat = dev_get_drvdata(dev);
 610         struct rk81x_battery *di = to_device_info(psy_bat);
 611         int val;
 612
 613         val = rk81x_bat_read_bit(di, MISC_MARK_REG, OCV_CALIB_SHIFT);
 614
 615         return sprintf(buf, "%d\n", val);
 616 }
 617
 618 static ssize_t bat_calib_write(struct device *dev,
 619                                struct device_attribute *attr,
 620                                const char *buf, size_t count)
 621 {
 622         u8 val;
 623         int ret;
 624         struct power_supply *psy_bat = dev_get_drvdata(dev);
 625         struct rk81x_battery *di = to_device_info(psy_bat);
 626
 627         ret = kstrtou8(buf, 0, &val);
 628         if (ret < 0)
 629                 return ret;
 630
 631         if (val)
 632                 rk81x_bat_set_bit(di, MISC_MARK_REG, OCV_CALIB_SHIFT);
 633         else
 634                 rk81x_bat_clr_bit(di, MISC_MARK_REG, OCV_CALIB_SHIFT);
 635         return count;
 636 }
 637
 638 /*
 639  * interface for debug: force battery to over discharge
 640  */
 641 static ssize_t bat_test_power_read(struct device *dev,
 642                                    struct device_attribute *attr, char *buf)
 643 {
 644         struct power_supply *psy_bat = dev_get_drvdata(dev);
 645         struct rk81x_battery *di = to_device_info(psy_bat);
 646
 647         return sprintf(buf, "%d\n", di->fg_drv_mode);
 648 }
 649
 650 static ssize_t bat_test_power_write(struct device *dev,
 651                                     struct device_attribute *attr,
 652                                     const char *buf, size_t count)
 653 {
 654         u8 val;
 655         int ret;
 656         struct power_supply *psy_bat = dev_get_drvdata(dev);
 657         struct rk81x_battery *di = to_device_info(psy_bat);
 658
 659         ret = kstrtou8(buf, 0, &val);
 660         if (ret < 0)
 661                 return ret;
 662
 663         if (val == 1)
 664                 di->fg_drv_mode = TEST_POWER_MODE;
 665         else
 666                 di->fg_drv_mode = FG_NORMAL_MODE;
 667
 668         return count;
 669 }
 670
 671 static ssize_t bat_fcc_read(struct device *dev,
 672                             struct device_attribute *attr, char *buf)
 673 {
 674         struct power_supply *psy_bat = dev_get_drvdata(dev);
 675         struct rk81x_battery *di = to_device_info(psy_bat);
 676
 677         return sprintf(buf, "%d\n", di->fcc);
 678 }
 679
 680 static ssize_t bat_fcc_write(struct device *dev,
 681                              struct device_attribute *attr,
 682                              const char *buf, size_t count)
 683 {
 684         u16 val;
 685         int ret;
 686         struct power_supply *psy_bat = dev_get_drvdata(dev);
 687         struct rk81x_battery *di = to_device_info(psy_bat);
 688
 689         ret = kstrtou16(buf, 0, &val);
 690         if (ret < 0)
 691                 return ret;
 692
 693         di->fcc = val;
 694
 695         return count;
 696 }
 697
 698 static ssize_t bat_dsoc_read(struct device *dev,
 699                              struct device_attribute *attr, char *buf)
 700 {
 701         struct power_supply *psy_bat = dev_get_drvdata(dev);
 702         struct rk81x_battery *di = to_device_info(psy_bat);
 703
 704         return sprintf(buf, "%d\n", di->dsoc);
 705 }
 706
 707 static ssize_t bat_dsoc_write(struct device *dev,
 708                               struct device_attribute *attr,
 709                              const char *buf, size_t count)
 710 {
 711         u8 val;
 712         int ret;
 713         struct power_supply *psy_bat = dev_get_drvdata(dev);
 714         struct rk81x_battery *di = to_device_info(psy_bat);
 715
 716         ret = kstrtou8(buf, 0, &val);
 717         if (ret < 0)
 718                 return ret;
 719
 720         di->dsoc = val;
 721
 722         return count;
 723 }
 724
 725 static ssize_t bat_rsoc_read(struct device *dev,
 726                              struct device_attribute *attr, char *buf)
 727 {
 728         struct power_supply *psy_bat = dev_get_drvdata(dev);
 729         struct rk81x_battery *di = to_device_info(psy_bat);
 730
 731         return sprintf(buf, "%d\n", di->rsoc);
 732 }
 733
 734 static ssize_t bat_rsoc_write(struct device *dev,
 735                               struct device_attribute *attr,
 736                               const char *buf, size_t count)
 737 {
 738         u8 val;
 739         int ret;
 740         u32 capacity;
 741         struct power_supply *psy_bat = dev_get_drvdata(dev);
 742         struct rk81x_battery *di = to_device_info(psy_bat);
 743
 744         ret = kstrtou8(buf, 0, &val);
 745         if (ret < 0)
 746                 return ret;
 747
 748         capacity = di->fcc * val / 100;
 749         rk81x_bat_capacity_init(di, capacity);
 750         rk81x_bat_capacity_init_post(di);
 751
 752         return count;
 753 }
 754
 755 static ssize_t bat_remain_cap_read(struct device *dev,
 756                                    struct device_attribute *attr,
 757                                    char *buf)
 758 {
 759         struct power_supply *psy_bat = dev_get_drvdata(dev);
 760         struct rk81x_battery *di = to_device_info(psy_bat);
 761
 762         return sprintf(buf, "%d\n", di->remain_capacity);
 763 }
 764
 765 static struct device_attribute rk818_bat_attr[] = {
 766         __ATTR(fcc, 0664, bat_fcc_read, bat_fcc_write),
 767         __ATTR(dsoc, 0664, bat_dsoc_read, bat_dsoc_write),
 768         __ATTR(rsoc, 0664, bat_rsoc_read, bat_rsoc_write),
 769         __ATTR(remain_capacity, 0664, bat_remain_cap_read, NULL),
 770         __ATTR(test_power, 0664, bat_test_power_read, bat_test_power_write),
 771         __ATTR(calib, 0664, bat_calib_read, bat_calib_write),
 772 };
 773 #endif
 774
 775 static int rk81x_bat_gauge_enable(struct rk81x_battery *di)
 776 {
 777         int ret;
 778         u8 buf;
 779
 780         ret = rk81x_bat_read(di, TS_CTRL_REG, &buf, 1);
 781         if (ret < 0) {
 782                 dev_err(di->dev, "error reading TS_CTRL_REG");
 783                 return ret;
 784         }
 785
 786         buf |= GG_EN;
 787         rk81x_bat_write(di, TS_CTRL_REG, &buf, 1);
 788
 789         return 0;
 790 }
 791
 792 static void rk81x_bat_save_level(struct  rk81x_battery *di, u8 save_soc)
 793 {
 794         rk81x_bat_write(di, UPDAT_LEVE_REG, &save_soc, 1);
 795 }
 796
 797 static u8 rk81x_bat_get_level(struct  rk81x_battery *di)
 798 {
 799         u8 soc;
 800
 801         rk81x_bat_read(di, UPDAT_LEVE_REG, &soc, 1);
 802
 803         return soc;
 804 }
 805
 806 static int rk81x_bat_get_vcalib0(struct rk81x_battery *di)
 807 {
 808         int ret;
 809         int temp = 0;
 810         u8 buf;
 811
 812         ret = rk81x_bat_read(di, VCALIB0_REGL, &buf, 1);
 813         temp = buf;
 814         ret = rk81x_bat_read(di, VCALIB0_REGH, &buf, 1);
 815         temp |= buf << 8;
 816
 817         DBG("%s voltage0 offset vale is %d\n", __func__, temp);
 818         return temp;
 819 }
 820
 821 static int rk81x_bat_get_vcalib1(struct  rk81x_battery *di)
 822 {
 823         int ret;
 824         int temp = 0;
 825         u8 buf;
 826
 827         ret = rk81x_bat_read(di, VCALIB1_REGL, &buf, 1);
 828         temp = buf;
 829         ret = rk81x_bat_read(di, VCALIB1_REGH, &buf, 1);
 830         temp |= buf << 8;
 831
 832         DBG("%s voltage1 offset vale is %d\n", __func__, temp);
 833         return temp;
 834 }
 835
 836 static int rk81x_bat_get_ioffset(struct rk81x_battery *di)
 837 {
 838         int ret;
 839         int temp = 0;
 840         u8 buf;
 841
 842         ret = rk81x_bat_read(di, IOFFSET_REGL, &buf, 1);
 843         temp = buf;
 844         ret = rk81x_bat_read(di, IOFFSET_REGH, &buf, 1);
 845         temp |= buf << 8;
 846
 847         return temp;
 848 }
 849
 850 static uint16_t rk81x_bat_get_cal_offset(struct rk81x_battery *di)
 851 {
 852         int ret;
 853         uint16_t temp = 0;
 854         u8 buf;
 855
 856         ret = rk81x_bat_read(di, CAL_OFFSET_REGL, &buf, 1);
 857         temp = buf;
 858         ret = rk81x_bat_read(di, CAL_OFFSET_REGH, &buf, 1);
 859         temp |= buf << 8;
 860
 861         return temp;
 862 }
 863
 864 static int rk81x_bat_set_cal_offset(struct rk81x_battery *di, u32 value)
 865 {
 866         int ret;
 867         u8 buf;
 868
 869         buf = value & 0xff;
 870         ret = rk81x_bat_write(di, CAL_OFFSET_REGL, &buf, 1);
 871         buf = (value >> 8) & 0xff;
 872         ret = rk81x_bat_write(di, CAL_OFFSET_REGH, &buf, 1);
 873
 874         return 0;
 875 }
 876
 877 static void rk81x_bat_get_vol_offset(struct rk81x_battery *di)
 878 {
 879         int vcalib0, vcalib1;
 880
 881         vcalib0 = rk81x_bat_get_vcalib0(di);
 882         vcalib1 = rk81x_bat_get_vcalib1(di);
 883
 884         di->voltage_k = (4200 - 3000) * 1000 / div((vcalib1 - vcalib0));
 885         di->voltage_b = 4200 - (di->voltage_k * vcalib1) / 1000;
 886         DBG("voltage_k=%d(x1000),voltage_b=%d\n", di->voltage_k, di->voltage_b);
 887 }
 888
 889 static uint16_t rk81x_bat_get_ocv_vol(struct rk81x_battery *di)
 890 {
 891         int ret;
 892         u8 buf;
 893         uint16_t temp;
 894         uint16_t voltage_now = 0;
 895         int i;
 896         int val[3];
 897
 898         for (i = 0; i < 3; i++) {
 899                 ret = rk81x_bat_read(di, BAT_OCV_REGL, &buf, 1);
 900                 val[i] = buf;
 901                 ret = rk81x_bat_read(di, BAT_OCV_REGH, &buf, 1);
 902                 val[i] |= buf << 8;
 903
 904                 if (ret < 0) {
 905                         dev_err(di->dev, "error read BAT_OCV_REGH");
 906                         return ret;
 907                 }
 908         }
 909
 910         if (val[0] == val[1])
 911                 temp = val[0];
 912         else
 913                 temp = val[2];
 914
 915         voltage_now = di->voltage_k * temp / 1000 + di->voltage_b;
 916
 917         return voltage_now;
 918 }
 919
 920 static int rk81x_bat_get_vol(struct rk81x_battery *di)
 921 {
 922         int ret;
 923         int vol;
 924         u8 buf;
 925         int temp;
 926         int val[3];
 927         int i;
 928
 929         for (i = 0; i < 3; i++) {
 930                 ret = rk81x_bat_read(di, BAT_VOL_REGL, &buf, 1);
 931                 val[i] = buf;
 932                 ret = rk81x_bat_read(di, BAT_VOL_REGH, &buf, 1);
 933                 val[i] |= buf << 8;
 934
 935                 if (ret < 0) {
 936                         dev_err(di->dev, "error read BAT_VOL_REGH");
 937                         return ret;
 938                 }
 939         }
 940         /*check value*/
 941         if (val[0] == val[1])
 942                 temp = val[0];
 943         else
 944                 temp = val[2];
 945
 946         vol = di->voltage_k * temp / 1000 + di->voltage_b;
 947
 948         return vol;
 949 }
 950
 951 static bool is_rk81x_bat_relax_mode(struct rk81x_battery *di)
 952 {
 953         int ret;
 954         u8 status;
 955
 956         ret = rk81x_bat_read(di, GGSTS, &status, 1);
 957
 958         if ((!(status & RELAX_VOL1_UPD)) || (!(status & RELAX_VOL2_UPD)))
 959                 return false;
 960         else
 961                 return true;
 962 }
 963
 964 static uint16_t rk81x_bat_get_relax_vol1(struct rk81x_battery *di)
 965 {
 966         int ret;
 967         u8 buf;
 968         uint16_t temp = 0, voltage_now;
 969
 970         ret = rk81x_bat_read(di, RELAX_VOL1_REGL, &buf, 1);
 971         temp = buf;
 972         ret = rk81x_bat_read(di, RELAX_VOL1_REGH, &buf, 1);
 973         temp |= (buf << 8);
 974
 975         voltage_now = di->voltage_k * temp / 1000 + di->voltage_b;
 976
 977         return voltage_now;
 978 }
 979
 980 static uint16_t rk81x_bat_get_relax_vol2(struct rk81x_battery *di)
 981 {
 982         int ret;
 983         u8 buf;
 984         uint16_t temp = 0, voltage_now;
 985
 986         ret = rk81x_bat_read(di, RELAX_VOL2_REGL, &buf, 1);
 987         temp = buf;
 988         ret = rk81x_bat_read(di, RELAX_VOL2_REGH, &buf, 1);
 989         temp |= (buf << 8);
 990
 991         voltage_now = di->voltage_k * temp / 1000 + di->voltage_b;
 992
 993         return voltage_now;
 994 }
 995
 996 static uint16_t rk81x_bat_get_relax_vol(struct rk81x_battery *di)
 997 {
 998         int ret;
 999         u8 status;
1000         uint16_t relax_vol1, relax_vol2;
1001         u8 ggcon;
1002
1003         ret = rk81x_bat_read(di, GGSTS, &status, 1);
1004         ret = rk81x_bat_read(di, GGCON, &ggcon, 1);
1005
1006         relax_vol1 = rk81x_bat_get_relax_vol1(di);
1007         relax_vol2 = rk81x_bat_get_relax_vol2(di);
1008         DBG("<%s>. GGSTS=0x%x, GGCON=0x%x, relax_vol1=%d, relax_vol2=%d\n",
1009             __func__, status, ggcon, relax_vol1, relax_vol2);
1010
1011         if (is_rk81x_bat_relax_mode(di))
1012                 return relax_vol1 > relax_vol2 ? relax_vol1 : relax_vol2;
1013         else
1014                 return 0;
1015 }
1016
1017 /* OCV Lookup table
1018  * Open Circuit Voltage (OCV) correction routine. This function estimates SOC,
1019  * based on the voltage.
1020  */
1021 static int rk81x_bat_vol_to_capacity(struct rk81x_battery *di, int voltage)
1022 {
1023         u32 *ocv_table;
1024         int ocv_size;
1025         u32 tmp;
1026         int ocv_soc;
1027
1028         ocv_table = di->pdata->battery_ocv;
1029         ocv_size = di->pdata->ocv_size;
1030         tmp = interpolate(voltage, ocv_table, ocv_size);
1031         ocv_soc = ab_div_c(tmp, MAX_PERCENTAGE, INTERPOLATE_MAX);
1032         di->temp_nac = ab_div_c(tmp, di->fcc, INTERPOLATE_MAX);
1033
1034         return ocv_soc;
1035 }
1036
1037 static int rk81x_bat_get_raw_adc_current(struct rk81x_battery *di)
1038 {
1039         u8 buf;
1040         int ret;
1041         int val;
1042
1043         ret = rk81x_bat_read(di, BAT_CUR_AVG_REGL, &buf, 1);
1044         if (ret < 0) {
1045                 dev_err(di->dev, "error reading BAT_CUR_AVG_REGL");
1046                 return ret;
1047         }
1048         val = buf;
1049         ret = rk81x_bat_read(di, BAT_CUR_AVG_REGH, &buf, 1);
1050         if (ret < 0) {
1051                 dev_err(di->dev, "error reading BAT_CUR_AVG_REGH");
1052                 return ret;
1053         }
1054         val |= (buf << 8);
1055
1056         if (ret < 0) {
1057                 dev_err(di->dev, "error reading BAT_CUR_AVG_REGH");
1058                 return ret;
1059         }
1060
1061         if (val > 2047)
1062                 val -= 4096;
1063
1064         return val;
1065 }
1066
1067 static void rk81x_bat_ioffset_sample_set(struct rk81x_battery *di, int time)
1068 {
1069         u8 ggcon;
1070
1071         rk81x_bat_read(di, GGCON, &ggcon, 1);
1072         ggcon &= ~(0x30); /*clear <5:4>*/
1073         ggcon |= time;
1074         rk81x_bat_write(di, GGCON, &ggcon, 1);
1075 }
1076
1077 /*
1078  * when charger finish signal comes, we need calibrate the current, make it
1079  * close to 0.
1080  */
1081 static bool rk81x_bat_zero_current_calib(struct rk81x_battery *di)
1082 {
1083         int adc_value;
1084         uint16_t C0;
1085         uint16_t C1;
1086         int ioffset;
1087         u8 pcb_offset = 0;
1088         u8 retry = 0;
1089         bool ret = true;
1090
1091         if ((di->chrg_status == CHARGE_FINISH) &&
1092             (BASE_TO_MIN(di->power_on_base) >= 3) &&
1093             (abs(di->current_avg) > 4)) {
1094                 for (retry = 0; retry < 5; retry++) {
1095                         adc_value = rk81x_bat_get_raw_adc_current(di);
1096                         if (!rk81x_chrg_online(di) || abs(adc_value) > 30) {
1097                                 dev_warn(di->dev, "charger plugout\n");
1098                                 ret = true;
1099                                 break;
1100                         }
1101
1102                         DBG("<%s>. adc_value = %d\n", __func__, adc_value);
1103                         C0 = rk81x_bat_get_cal_offset(di);
1104                         C1 = adc_value + C0;
1105                         DBG("<%s>. C0(cal_offset) = %d, C1 = %d\n",
1106                             __func__, C0, C1);
1107                         rk81x_bat_set_cal_offset(di, C1);
1108                         DBG("<%s>. new cal_offset = %d\n",
1109                             __func__, rk81x_bat_get_cal_offset(di));
1110                         msleep(3000);
1111                         adc_value = rk81x_bat_get_raw_adc_current(di);
1112                         DBG("<%s>. adc_value = %d\n", __func__, adc_value);
1113                         if (abs(adc_value) < 4) {
1114                                 if (rk81x_bat_get_cal_offset(di) < 0x7ff) {
1115                                         ioffset = rk81x_bat_get_ioffset(di);
1116                                         rk81x_bat_set_cal_offset(di,
1117                                                                  ioffset + 42);
1118                                 } else {
1119                                         ioffset = rk81x_bat_get_ioffset(di);
1120                                         pcb_offset = C1 - ioffset;
1121                                         di->pcb_ioffset = pcb_offset;
1122                                         di->pcb_ioffset_updated  = true;
1123                                         rk81x_bat_write(di,
1124                                                         PCB_IOFFSET_REG,
1125                                                         &pcb_offset, 1);
1126                                 }
1127                                 DBG("<%s>. update the cal_offset, C1 = %d\n"
1128                                     "i_offset = %d, pcb_offset = %d\n",
1129                                         __func__, C1, ioffset, pcb_offset);
1130                                 ret = false;
1131                                 break;
1132                         } else {
1133                                 dev_dbg(di->dev, "ioffset cal failed\n");
1134                                 rk81x_bat_set_cal_offset(di, C0);
1135                         }
1136
1137                         di->pcb_ioffset_updated  = false;
1138                 }
1139         }
1140
1141         return ret;
1142 }
1143
1144 static void rk81x_bat_set_relax_thres(struct rk81x_battery *di)
1145 {
1146         u8 buf;
1147         int enter_thres, exit_thres;
1148         struct cell_state *cell = &di->cell;
1149
1150         enter_thres = (cell->config->ocv->sleep_enter_current) * 1000 / 1506;
1151         exit_thres = (cell->config->ocv->sleep_exit_current) * 1000 / 1506;
1152         DBG("<%s>. sleep_enter_current = %d, sleep_exit_current = %d\n",
1153             __func__, cell->config->ocv->sleep_enter_current,
1154         cell->config->ocv->sleep_exit_current);
1155
1156         buf  = enter_thres & 0xff;
1157         rk81x_bat_write(di, RELAX_ENTRY_THRES_REGL, &buf, 1);
1158         buf = (enter_thres >> 8) & 0xff;
1159         rk81x_bat_write(di, RELAX_ENTRY_THRES_REGH, &buf, 1);
1160
1161         buf  = exit_thres & 0xff;
1162         rk81x_bat_write(di, RELAX_EXIT_THRES_REGL, &buf, 1);
1163         buf = (exit_thres >> 8) & 0xff;
1164         rk81x_bat_write(di, RELAX_EXIT_THRES_REGH, &buf, 1);
1165
1166         /* set sample time */
1167         rk81x_bat_read(di, GGCON, &buf, 1);
1168         buf &= ~(3 << 2);/*8min*/
1169         buf &= ~0x01; /* clear bat_res calc*/
1170         rk81x_bat_write(di, GGCON, &buf, 1);
1171 }
1172
1173 static void rk81x_bat_restart_relax(struct rk81x_battery *di)
1174 {
1175         u8 ggcon;
1176         u8 ggsts;
1177
1178         rk81x_bat_read(di, GGCON, &ggcon, 1);
1179         ggcon &= ~0x0c;
1180         rk81x_bat_write(di, GGCON, &ggcon, 1);
1181
1182         rk81x_bat_read(di, GGSTS, &ggsts, 1);
1183         ggsts &= ~0x0c;
1184         rk81x_bat_write(di, GGSTS, &ggsts, 1);
1185 }
1186
1187 static int rk81x_bat_get_avg_current(struct rk81x_battery *di)
1188 {
1189         u8  buf;
1190         int ret;
1191         int current_now;
1192         int temp;
1193         int val[3];
1194         int i;
1195
1196         for (i = 0; i < 3; i++) {
1197                 ret = rk81x_bat_read(di, BAT_CUR_AVG_REGL, &buf, 1);
1198                 if (ret < 0) {
1199                         dev_err(di->dev, "error read BAT_CUR_AVG_REGL");
1200                         return ret;
1201                 }
1202                 val[i] = buf;
1203
1204                 ret = rk81x_bat_read(di, BAT_CUR_AVG_REGH, &buf, 1);
1205                 if (ret < 0) {
1206                         dev_err(di->dev, "error read BAT_CUR_AVG_REGH");
1207                         return ret;
1208                 }
1209                 val[i] |= (buf<<8);
1210         }
1211         /*check value*/
1212         if (val[0] == val[1])
1213                 current_now = val[0];
1214         else
1215                 current_now = val[2];
1216
1217         if (current_now & 0x800)
1218                 current_now -= 4096;
1219
1220         temp = current_now * 1506 / 1000;/*1000*90/14/4096*500/521;*/
1221
1222         return temp;
1223 }
1224
1225 static void rk81x_bat_set_power_supply_state(struct rk81x_battery *di,
1226                                              enum charger_type  charger_type)
1227 {
1228         di->usb_online = OFFLINE;
1229         di->ac_online = OFFLINE;
1230
1231         switch (charger_type) {
1232         case NO_CHARGER:
1233                 di->psy_status = POWER_SUPPLY_STATUS_DISCHARGING;
1234                 break;
1235         case USB_CHARGER:
1236                 di->usb_online = ONLINE;
1237                 di->psy_status = POWER_SUPPLY_STATUS_CHARGING;
1238                 break;
1239         case DC_CHARGER:/*treat dc as ac*/
1240         case AC_CHARGER:
1241                 di->ac_online = ONLINE;
1242                 di->psy_status = POWER_SUPPLY_STATUS_CHARGING;
1243                 break;
1244         default:
1245                 di->psy_status = POWER_SUPPLY_STATUS_DISCHARGING;
1246         }
1247
1248         if (di->wq)
1249                 queue_delayed_work(di->wq, &di->chrg_term_mode_switch_work,
1250                                    msecs_to_jiffies(1000));
1251 }
1252
1253 /* high load: current < 0 with charger in.
1254  * System will not shutdown while dsoc=0% with charging state(ac_online),
1255  * which will cause over discharge, so oppose status before report states.
1256  */
1257 static void rk81x_bat_lowpwr_check(struct rk81x_battery *di)
1258 {
1259         static u64 time;
1260         int pwr_off_thresd = di->pdata->power_off_thresd;
1261
1262         if (di->current_avg < 0 &&  di->voltage < pwr_off_thresd) {
1263                 if (!time)
1264                         time = get_runtime_sec();
1265
1266                 if (BASE_TO_SEC(time) > (MINUTE)) {
1267                         rk81x_bat_set_power_supply_state(di, NO_CHARGER);
1268                         dev_info(di->dev, "low power....\n");
1269                 }
1270
1271                 if (di->voltage <= pwr_off_thresd - 50) {
1272                         di->dsoc--;
1273                         rk81x_bat_set_power_supply_state(di, NO_CHARGER);
1274                 }
1275         } else {
1276                 time = 0;
1277         }
1278 }
1279
1280 static int is_rk81x_bat_exist(struct  rk81x_battery *di)
1281 {
1282         u8 buf;
1283
1284         rk81x_bat_read(di, SUP_STS_REG, &buf, 1);
1285
1286         return (buf & 0x80) ? 1 : 0;
1287 }
1288
1289 static bool is_rk81x_bat_first_poweron(struct  rk81x_battery *di)
1290 {
1291         u8 buf;
1292         u8 temp;
1293
1294         rk81x_bat_read(di, GGSTS, &buf, 1);
1295         DBG("%s GGSTS value is 0x%2x\n", __func__, buf);
1296         /*di->pwron_bat_con = buf;*/
1297         if (buf&BAT_CON) {
1298                 buf &= ~(BAT_CON);
1299                 do {
1300                         rk81x_bat_write(di, GGSTS, &buf, 1);
1301                         rk81x_bat_read(di, GGSTS, &temp, 1);
1302                 } while (temp & BAT_CON);
1303                 return true;
1304         }
1305
1306         return false;
1307 }
1308
1309 static void rk81x_bat_flatzone_vol_init(struct rk81x_battery *di)
1310 {
1311         u32 *ocv_table;
1312         int ocv_size;
1313         int temp_table[21];
1314         int i, j;
1315
1316         ocv_table = di->pdata->battery_ocv;
1317         ocv_size = di->pdata->ocv_size;
1318
1319         for (j = 0; j < 21; j++)
1320                 temp_table[j] = 0;
1321
1322         j = 0;
1323         for (i = 1; i < ocv_size-1; i++) {
1324                 if (ocv_table[i+1] < ocv_table[i] + 20)
1325                         temp_table[j++] = i;
1326         }
1327
1328         temp_table[j] = temp_table[j-1] + 1;
1329         i = temp_table[0];
1330         di->enter_flatzone = ocv_table[i];
1331         j = 0;
1332
1333         for (i = 0; i < 20; i++) {
1334                 if (temp_table[i] < temp_table[i+1])
1335                         j = i + 1;
1336         }
1337
1338         i = temp_table[j];
1339         di->exit_flatzone = ocv_table[i];
1340
1341         DBG("enter_flatzone = %d exit_flatzone = %d\n",
1342             di->enter_flatzone, di->exit_flatzone);
1343 }
1344
1345 static void rk81x_bat_power_on_save(struct rk81x_battery *di, int ocv_voltage)
1346 {
1347         u8 ocv_valid, first_pwron;
1348         u8 soc_level;
1349         u8 ocv_soc;
1350
1351         /*buf==1: OCV_VOL is valid*/
1352         ocv_valid = rk81x_bat_read_bit(di, MISC_MARK_REG, OCV_VALID_SHIFT);
1353         first_pwron = rk81x_bat_read_bit(di, MISC_MARK_REG, FIRST_PWRON_SHIFT);
1354         DBG("readbit: ocv_valid=%d, first_pwron=%d\n", ocv_valid, first_pwron);
1355
1356         if (first_pwron == 1 || ocv_valid == 1) {
1357                 DBG("<%s> enter.\n", __func__);
1358                 ocv_soc = rk81x_bat_vol_to_capacity(di, ocv_voltage);
1359                 if ((ocv_soc < 20) && (ocv_voltage > 2750)) {
1360                         di->dod0_voltage = ocv_voltage;
1361                         di->dod0_capacity = di->temp_nac;
1362                         di->adjust_cap = 0;
1363                         di->dod0 = ocv_soc;
1364
1365                         if (ocv_soc <= 0)
1366                                 di->dod0_level = 100;
1367                         else if (ocv_soc < 5)
1368                                 di->dod0_level = 95;
1369                         else if (ocv_soc < 10)
1370                                 di->dod0_level = 90;
1371                         else
1372                                 di->dod0_level = 80;
1373                         /* save_soc = di->dod0_level; */
1374                         soc_level = rk81x_bat_get_level(di);
1375                         if (soc_level >  di->dod0_level) {
1376                                 di->dod0_status = 0;
1377                                 soc_level -= 5;
1378                                 if (soc_level <= 80)
1379                                         soc_level = 80;
1380                                 rk81x_bat_save_level(di, soc_level);
1381                         } else {
1382                                 di->dod0_status = 1;
1383                                 /*time start*/
1384                                 di->fcc_update_sec = get_runtime_sec();
1385                         }
1386
1387                         dev_info(di->dev, "dod0_vol:%d, dod0_cap:%d\n"
1388                                  "dod0:%d, soc_level:%d: dod0_status:%d\n"
1389                                  "dod0_level:%d",
1390                                  di->dod0_voltage, di->dod0_capacity,
1391                                  ocv_soc, soc_level, di->dod0_status,
1392                                  di->dod0_level);
1393                 }
1394         }
1395 }
1396
1397 static int rk81x_bat_get_rsoc(struct   rk81x_battery *di)
1398 {
1399         return (di->remain_capacity + di->fcc / 200) * 100 / div(di->fcc);
1400 }
1401
1402 static enum power_supply_property rk_battery_props[] = {
1403         POWER_SUPPLY_PROP_STATUS,
1404         POWER_SUPPLY_PROP_CURRENT_NOW,
1405         POWER_SUPPLY_PROP_VOLTAGE_NOW,
1406         POWER_SUPPLY_PROP_PRESENT,
1407         POWER_SUPPLY_PROP_HEALTH,
1408         POWER_SUPPLY_PROP_CAPACITY,
1409 };
1410
1411 static int rk81x_battery_get_property(struct power_supply *psy,
1412                                       enum power_supply_property psp,
1413                                       union power_supply_propval *val)
1414 {
1415         struct rk81x_battery *di = to_device_info(psy);
1416
1417         switch (psp) {
1418         case POWER_SUPPLY_PROP_CURRENT_NOW:
1419                 val->intval = di->current_avg * 1000;/*uA*/
1420                 if (di->fg_drv_mode == TEST_POWER_MODE)
1421                         val->intval = TEST_CURRENT * 1000;
1422                 break;
1423         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1424                 val->intval = di->voltage * 1000;/*uV*/
1425                 if (di->fg_drv_mode == TEST_POWER_MODE)
1426                         val->intval = TEST_VOLTAGE * 1000;
1427
1428                 break;
1429         case POWER_SUPPLY_PROP_PRESENT:
1430                 val->intval = is_rk81x_bat_exist(di);
1431                 if (di->fg_drv_mode == TEST_POWER_MODE)
1432                         val->intval = TEST_PRESET;
1433
1434                 break;
1435         case POWER_SUPPLY_PROP_CAPACITY:
1436                 val->intval = di->dsoc;
1437                 if (di->fg_drv_mode == TEST_POWER_MODE)
1438                         val->intval = TEST_SOC;
1439
1440                 DBG("<%s>, report dsoc: %d\n", __func__, val->intval);
1441                 break;
1442         case POWER_SUPPLY_PROP_HEALTH:
1443                 val->intval = POWER_SUPPLY_HEALTH_GOOD;
1444                 break;
1445         case POWER_SUPPLY_PROP_STATUS:
1446                 val->intval = di->psy_status;
1447                 if (di->fg_drv_mode == TEST_POWER_MODE)
1448                         val->intval = TEST_STATUS;
1449
1450                 break;
1451         default:
1452                 return -EINVAL;
1453         }
1454
1455         return 0;
1456 }
1457
1458 static enum power_supply_property rk_battery_ac_props[] = {
1459         POWER_SUPPLY_PROP_ONLINE,
1460 };
1461
1462 static enum power_supply_property rk_battery_usb_props[] = {
1463         POWER_SUPPLY_PROP_ONLINE,
1464 };
1465
1466 static int rk81x_battery_ac_get_property(struct power_supply *psy,
1467                                          enum power_supply_property psp,
1468                                          union power_supply_propval *val)
1469 {
1470         int ret = 0;
1471         struct rk81x_battery *di = to_ac_device_info(psy);
1472
1473         switch (psp) {
1474         case POWER_SUPPLY_PROP_ONLINE:
1475                 if (rk81x_chrg_online(di))
1476                         rk81x_bat_lowpwr_check(di);
1477                 val->intval = di->ac_online;    /*discharging*/
1478                 if (di->fg_drv_mode == TEST_POWER_MODE)
1479                         val->intval = TEST_AC_ONLINE;
1480
1481                 break;
1482         default:
1483                 ret = -EINVAL;
1484                 break;
1485         }
1486         return ret;
1487 }
1488
1489 static int rk81x_battery_usb_get_property(struct power_supply *psy,
1490                                           enum power_supply_property psp,
1491                                           union power_supply_propval *val)
1492 {
1493         int ret = 0;
1494         struct rk81x_battery *di = to_usb_device_info(psy);
1495
1496         switch (psp) {
1497         case POWER_SUPPLY_PROP_ONLINE:
1498                 if (rk81x_chrg_online(di))
1499                         rk81x_bat_lowpwr_check(di);
1500                 val->intval = di->usb_online;
1501                 if (di->fg_drv_mode == TEST_POWER_MODE)
1502                         val->intval = TEST_USB_ONLINE;
1503                 break;
1504         default:
1505                 ret = -EINVAL;
1506                 break;
1507         }
1508
1509         return ret;
1510 }
1511
1512 static int rk81x_bat_power_supply_init(struct rk81x_battery *di)
1513 {
1514         int ret;
1515
1516         di->bat.name = "BATTERY";
1517         di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
1518         di->bat.properties = rk_battery_props;
1519         di->bat.num_properties = ARRAY_SIZE(rk_battery_props);
1520         di->bat.get_property = rk81x_battery_get_property;
1521
1522         di->ac.name = "AC";
1523         di->ac.type = POWER_SUPPLY_TYPE_MAINS;
1524         di->ac.properties = rk_battery_ac_props;
1525         di->ac.num_properties = ARRAY_SIZE(rk_battery_ac_props);
1526         di->ac.get_property = rk81x_battery_ac_get_property;
1527
1528         di->usb.name = "USB";
1529         di->usb.type = POWER_SUPPLY_TYPE_USB;
1530         di->usb.properties = rk_battery_usb_props;
1531         di->usb.num_properties = ARRAY_SIZE(rk_battery_usb_props);
1532         di->usb.get_property = rk81x_battery_usb_get_property;
1533
1534         ret = power_supply_register(di->dev, &di->bat);
1535         if (ret) {
1536                 dev_err(di->dev, "failed to register main battery\n");
1537                 goto batt_failed;
1538         }
1539         ret = power_supply_register(di->dev, &di->usb);
1540         if (ret) {
1541                 dev_err(di->dev, "failed to register usb power supply\n");
1542                 goto usb_failed;
1543         }
1544         ret = power_supply_register(di->dev, &di->ac);
1545         if (ret) {
1546                 dev_err(di->dev, "failed to register ac power supply\n");
1547                 goto ac_failed;
1548         }
1549
1550         return 0;
1551
1552 ac_failed:
1553         power_supply_unregister(&di->ac);
1554 usb_failed:
1555         power_supply_unregister(&di->usb);
1556 batt_failed:
1557         power_supply_unregister(&di->bat);
1558
1559         return ret;
1560 }
1561
1562 static void rk81x_bat_save_remain_capacity(struct rk81x_battery *di,
1563                                            int capacity)
1564 {
1565         u8 buf;
1566         static u32 capacity_ma;
1567
1568         if (capacity >= di->qmax)
1569                 capacity = di->qmax;
1570
1571         if (capacity <= 0)
1572                 capacity = 0;
1573
1574         if (capacity_ma == capacity)
1575                 return;
1576
1577         capacity_ma = capacity;
1578
1579         buf = (capacity_ma >> 24) & 0xff;
1580         rk81x_bat_write(di, REMAIN_CAP_REG3, &buf, 1);
1581         buf = (capacity_ma >> 16) & 0xff;
1582         rk81x_bat_write(di, REMAIN_CAP_REG2, &buf, 1);
1583         buf = (capacity_ma >> 8) & 0xff;
1584         rk81x_bat_write(di, REMAIN_CAP_REG1, &buf, 1);
1585         buf = (capacity_ma & 0xff) | 0x01;
1586         rk81x_bat_write(di, REMAIN_CAP_REG0, &buf, 1);
1587 }
1588
1589 static int rk81x_bat_get_remain_capacity(struct rk81x_battery *di)
1590 {
1591         int ret;
1592         u8 buf;
1593         u32 capacity;
1594         int i;
1595         int val[3];
1596
1597         for (i = 0; i < 3; i++) {
1598                 ret = rk81x_bat_read(di, REMAIN_CAP_REG3, &buf, 1);
1599                 val[i] = buf << 24;
1600                 ret = rk81x_bat_read(di, REMAIN_CAP_REG2, &buf, 1);
1601                 val[i] |= buf << 16;
1602                 ret = rk81x_bat_read(di, REMAIN_CAP_REG1, &buf, 1);
1603                 val[i] |= buf << 8;
1604                 ret = rk81x_bat_read(di, REMAIN_CAP_REG0, &buf, 1);
1605                 val[i] |= buf;
1606         }
1607
1608         if (val[0] == val[1])
1609                 capacity = val[0];
1610         else
1611                 capacity = val[2];
1612
1613         return capacity;
1614 }
1615
1616 static void rk81x_bat_save_fcc(struct rk81x_battery *di, u32 capacity)
1617 {
1618         u8 buf;
1619         u32 capacity_ma;
1620
1621         capacity_ma = capacity;
1622         buf = (capacity_ma >> 24) & 0xff;
1623         rk81x_bat_write(di, NEW_FCC_REG3, &buf, 1);
1624         buf = (capacity_ma >> 16) & 0xff;
1625         rk81x_bat_write(di, NEW_FCC_REG2, &buf, 1);
1626         buf = (capacity_ma >> 8) & 0xff;
1627         rk81x_bat_write(di, NEW_FCC_REG1, &buf, 1);
1628         buf = (capacity_ma & 0xff) | 0x01;
1629         rk81x_bat_write(di, NEW_FCC_REG0, &buf, 1);
1630
1631         dev_info(di->dev, "update fcc : %d\n", capacity);
1632 }
1633
1634 static int rk81x_bat_get_fcc(struct rk81x_battery *di)
1635 {
1636         u8 buf;
1637         u32 capacity;
1638
1639         rk81x_bat_read(di, NEW_FCC_REG3, &buf, 1);
1640         capacity = buf << 24;
1641         rk81x_bat_read(di, NEW_FCC_REG2, &buf, 1);
1642         capacity |= buf << 16;
1643         rk81x_bat_read(di, NEW_FCC_REG1, &buf, 1);
1644         capacity |= buf << 8;
1645         rk81x_bat_read(di, NEW_FCC_REG0, &buf, 1);
1646         capacity |= buf;
1647
1648         if (capacity < MIN_FCC) {
1649                 dev_warn(di->dev, "invalid fcc(0x%x), use design capacity",
1650                          capacity);
1651                 capacity = di->design_capacity;
1652                 rk81x_bat_save_fcc(di, capacity);
1653         } else if (capacity > di->qmax) {
1654                 dev_warn(di->dev, "invalid fcc(0x%x), use qmax", capacity);
1655                 capacity = di->qmax;
1656                 rk81x_bat_save_fcc(di, capacity);
1657         }
1658
1659         return capacity;
1660 }
1661
1662 static int rk81x_bat_get_realtime_capacity(struct rk81x_battery *di)
1663 {
1664         int ret;
1665         int temp = 0;
1666         u8 buf;
1667         u32 capacity;
1668         int i;
1669         int val[3];
1670
1671         for (i = 0; i < 3; i++) {
1672                 ret = rk81x_bat_read(di, GASCNT3, &buf, 1);
1673                 val[i] = buf << 24;
1674                 ret = rk81x_bat_read(di, GASCNT2, &buf, 1);
1675                 val[i] |= buf << 16;
1676                 ret = rk81x_bat_read(di, GASCNT1, &buf, 1);
1677                 val[i] |= buf << 8;
1678                 ret = rk81x_bat_read(di, GASCNT0, &buf, 1);
1679                 val[i] |= buf;
1680         }
1681         if (val[0] == val[1])
1682                 temp = val[0];
1683         else
1684                 temp = val[2];
1685
1686         capacity = temp / 2390;/* 4096*900/14/36*500/521; */
1687
1688         return capacity;
1689 }
1690
1691 static int rk81x_bat_save_dsoc(struct  rk81x_battery *di, u8 save_soc)
1692 {
1693         static u8 last_soc;
1694
1695         if (last_soc != save_soc) {
1696                 rk81x_bat_write(di, SOC_REG, &save_soc, 1);
1697                 last_soc = save_soc;
1698         }
1699
1700         return 0;
1701 }
1702
1703 static int rk81x_bat_save_reboot_cnt(struct  rk81x_battery *di, u8 save_cnt)
1704 {
1705         u8 cnt;
1706
1707         cnt = save_cnt;
1708         rk81x_bat_write(di, REBOOT_CNT_REG, &cnt, 1);
1709         return 0;
1710 }
1711
1712 static void rk81x_bat_set_current(struct rk81x_battery *di, int charge_current)
1713 {
1714         u8 usb_ctrl_reg;
1715
1716         rk81x_bat_read(di, USB_CTRL_REG, &usb_ctrl_reg, 1);
1717         usb_ctrl_reg &= (~0x0f);/* (VLIM_4400MV | ILIM_1200MA) |(0x01 << 7); */
1718         usb_ctrl_reg |= (charge_current | CHRG_CT_EN);
1719         rk81x_bat_write(di, USB_CTRL_REG, &usb_ctrl_reg, 1);
1720 }
1721
1722 static void rk81x_bat_set_chrg_current(struct rk81x_battery *di,
1723                                        enum charger_type charger_type)
1724 {
1725         switch (charger_type) {
1726         case NO_CHARGER:
1727         case USB_CHARGER:
1728                 rk81x_bat_set_current(di, ILIM_450MA);
1729                 break;
1730         case AC_CHARGER:
1731         case DC_CHARGER:
1732                 rk81x_bat_set_current(di, di->chrg_i_lmt);
1733                 break;
1734         default:
1735                 rk81x_bat_set_current(di, ILIM_450MA);
1736         }
1737 }
1738
1739 #if defined(CONFIG_ARCH_ROCKCHIP)
1740
1741 static void rk81x_bat_set_charger_param(struct rk81x_battery *di,
1742                                         enum charger_type charger_type)
1743 {
1744         rk81x_bat_set_chrg_current(di, charger_type);
1745         rk81x_bat_set_power_supply_state(di, charger_type);
1746
1747         switch (charger_type) {
1748         case NO_CHARGER:
1749                 power_supply_changed(&di->bat);
1750                 break;
1751         case USB_CHARGER:
1752         case AC_CHARGER:
1753                 power_supply_changed(&di->usb);
1754                 break;
1755         case DC_CHARGER:
1756                 power_supply_changed(&di->ac);
1757                 break;
1758         default:
1759                 break;
1760         }
1761 }
1762
1763 static enum charger_type rk81x_bat_get_dc_state(struct rk81x_battery *di)
1764 {
1765         int ret;
1766         enum charger_type charger_type = NO_CHARGER;
1767
1768         if (di->fg_drv_mode == TEST_POWER_MODE) {
1769                 charger_type = DC_CHARGER;
1770                 goto out;
1771         }
1772         /*
1773         if (di->otg_online)
1774                 goto out;
1775         */
1776         if (!gpio_is_valid(di->dc_det_pin))
1777                 goto out;
1778
1779         ret = gpio_request(di->dc_det_pin, "rk818_dc_det");
1780         if (ret < 0) {
1781                 pr_err("Failed to request gpio %d with ret:""%d\n",
1782                        di->dc_det_pin, ret);
1783                 goto out;
1784         }
1785
1786         gpio_direction_input(di->dc_det_pin);
1787         ret = gpio_get_value(di->dc_det_pin);
1788         if (ret == di->dc_det_level)
1789                 charger_type = DC_CHARGER;
1790         else
1791                 charger_type = NO_CHARGER;
1792         gpio_free(di->dc_det_pin);
1793 out:
1794         return charger_type;
1795 }
1796
1797 static void rk81x_battery_dc_delay_work(struct work_struct *work)
1798 {
1799         enum charger_type charger_type;
1800         struct rk81x_battery *di = container_of(work,
1801                                 struct rk81x_battery, dc_det_check_work.work);
1802
1803         charger_type = rk81x_bat_get_dc_state(di);
1804
1805         if (charger_type == DC_CHARGER)
1806                 rk81x_bat_set_charger_param(di, DC_CHARGER);
1807         else/*NO_CHARGER: maybe usb charger still plugin*/
1808                 queue_delayed_work(di->wq,
1809                                    &di->ac_usb_check_work,
1810                                    msecs_to_jiffies(10));
1811 }
1812
1813 static void rk81x_battery_acusb_delay_work(struct work_struct *work)
1814 {
1815         u8 buf;
1816         int gadget_flag, usb_id;
1817         struct rk81x_battery *di = container_of(work,
1818                         struct rk81x_battery, ac_usb_check_work.work);
1819
1820         rk81x_bat_read(di, VB_MOD_REG, &buf, 1);
1821         usb_id = dwc_otg_check_dpdm(0);
1822         switch (usb_id) {
1823         case 0:
1824                 if ((buf & PLUG_IN_STS) != 0)
1825                         rk81x_bat_set_charger_param(di, DC_CHARGER);
1826                 else
1827                         rk81x_bat_set_charger_param(di, NO_CHARGER);
1828                 break;
1829         case 1:
1830         case 3:
1831                 rk81x_bat_set_charger_param(di, USB_CHARGER);
1832                 break;
1833         case 2:
1834                 rk81x_bat_set_charger_param(di, AC_CHARGER);
1835                 break;
1836         default:
1837                 break;
1838         }
1839         /*check unstanderd charger*/
1840         if (usb_id == 1 || usb_id == 3) {
1841                 gadget_flag = get_gadget_connect_flag();
1842                 if (0 == gadget_flag) {
1843                         di->check_count++;
1844                         if (di->check_count >= 5) {
1845                                 di->check_count = 0;
1846                                 rk81x_bat_set_charger_param(di, AC_CHARGER);
1847                         } else {
1848                                 queue_delayed_work(di->wq,
1849                                                    &di->ac_usb_check_work,
1850                                                    msecs_to_jiffies(1000));
1851                         }
1852                 } else {/*confirm: USB_CHARGER*/
1853                         di->check_count = 0;
1854                 }
1855         }
1856 }
1857 #endif
1858
1859 #if defined(CONFIG_X86_INTEL_SOFIA)
1860 static int rk81x_get_chrg_type_by_usb_phy(struct rk81x_battery *di, int ma)
1861 {
1862         enum charger_type charger_type;
1863
1864         if (ma > 500)
1865                 charger_type =  AC_CHARGER;
1866         else if (ma >= 100)
1867                 charger_type = USB_CHARGER;
1868         else
1869                 charger_type = NO_CHARGER;
1870
1871         di->ma = ma;
1872
1873         dev_info(di->dev, "limit current:%d\n", ma);
1874
1875         return charger_type;
1876 }
1877
1878 static void rk81x_battery_usb_notifier_delayed_work(struct work_struct *work)
1879 {
1880         struct rk81x_battery *di;
1881         enum charger_type type;
1882
1883         di = container_of(work, struct rk81x_battery, usb_phy_delay_work.work);
1884         type = rk81x_get_chrg_type_by_usb_phy(di, di->ma);
1885
1886         rk81x_bat_set_chrg_current(di, type);
1887         power_supply_changed(&di->usb);
1888 }
1889
1890 static int rk81x_battery_usb_notifier(struct notifier_block *nb,
1891                                       unsigned long event, void *data)
1892 {
1893         struct rk81x_battery *di;
1894         struct power_supply_cable_props *cable_props;
1895         enum charger_type type;
1896
1897         di = container_of(nb, struct rk81x_battery, usb_nb);
1898
1899         if (!data)
1900                 return NOTIFY_BAD;
1901
1902         switch (event) {
1903         case USB_EVENT_CHARGER:
1904                 cable_props = (struct power_supply_cable_props *)data;
1905                 type = rk81x_get_chrg_type_by_usb_phy(di, cable_props->ma);
1906                 rk81x_bat_set_power_supply_state(di, type);
1907                 queue_delayed_work(di->wq, &di->usb_phy_delay_work,
1908                                    msecs_to_jiffies(50));
1909                 break;
1910
1911         default:
1912                 break;
1913         }
1914
1915         return NOTIFY_OK;
1916 }
1917 #endif
1918
1919 static int rk81x_battery_fb_notifier(struct notifier_block *nb,
1920                                      unsigned long event, void *data)
1921 {
1922         struct rk81x_battery *di;
1923         struct fb_event *evdata = data;
1924         int blank;
1925
1926         di = container_of(nb, struct rk81x_battery, fb_nb);
1927
1928         if (event != FB_EVENT_BLANK && event != FB_EVENT_CONBLANK)
1929                 return 0;
1930
1931         blank = *(int *)evdata->data;
1932
1933         if (di->fb_blank != blank)
1934                 di->fb_blank = blank;
1935         else
1936                 return 0;
1937
1938         if (blank == FB_BLANK_UNBLANK)
1939                 di->early_resume = 1;
1940
1941         return 0;
1942 }
1943
1944 static int rk81x_battery_register_fb_notify(struct rk81x_battery *di)
1945 {
1946         memset(&di->fb_nb, 0, sizeof(di->fb_nb));
1947         di->fb_nb.notifier_call = rk81x_battery_fb_notifier;
1948
1949         return fb_register_client(&di->fb_nb);
1950 }
1951
1952 /*
1953  * it is first time for battery to be weld, init by ocv table
1954  */
1955 static void rk81x_bat_first_pwron(struct rk81x_battery *di)
1956 {
1957         rk81x_bat_save_fcc(di, di->design_capacity);
1958         di->fcc = rk81x_bat_get_fcc(di);
1959
1960         di->rsoc = rk81x_bat_vol_to_capacity(di, di->voltage_ocv);
1961         di->dsoc = di->rsoc;
1962         di->nac  = di->temp_nac;
1963
1964         rk81x_bat_set_bit(di, MISC_MARK_REG, OCV_VALID_SHIFT);
1965         rk81x_bat_set_bit(di, MISC_MARK_REG, FIRST_PWRON_SHIFT);/*save*/
1966         DBG("<%s>.this is first poweron: OCV-SOC:%d, OCV-CAP:%d, FCC:%d\n",
1967             __func__, di->dsoc, di->nac, di->fcc);
1968 }
1969
1970 static int rk81x_bat_get_calib_vol(struct rk81x_battery *di)
1971 {
1972         int calib_vol;
1973         int init_cur, diff;
1974         int est_vol;
1975         int relax_vol = di->relax_voltage;
1976         int ocv_vol = di->voltage_ocv;
1977
1978         init_cur = rk81x_bat_get_avg_current(di);
1979         diff = (di->bat_res + di->pdata->chrg_diff_vol) * init_cur;
1980         diff /= 1000;
1981         est_vol = di->voltage - diff;
1982
1983         if (di->loader_charged) {
1984                 calib_vol = est_vol;
1985                 return calib_vol;
1986         }
1987
1988         if (di->pwroff_min > 8) {
1989                 if (abs(relax_vol - ocv_vol) < 100) {
1990                         calib_vol = ocv_vol;
1991                 } else {
1992                         if (abs(relax_vol - est_vol) > abs(ocv_vol - est_vol))
1993                                 calib_vol = ocv_vol;
1994                         else
1995                                 calib_vol = relax_vol;
1996                 }
1997         } else if (di->pwroff_min > 2) {
1998                 calib_vol = ocv_vol;
1999         } else {
2000                 calib_vol = -1;
2001         }
2002
2003         dev_info(di->dev, "c=%d, v=%d, relax=%d, ocv=%d, est=%d, calib=%d\n",
2004                  init_cur, di->voltage, relax_vol, ocv_vol, est_vol, calib_vol);
2005
2006         return calib_vol;
2007 }
2008
2009 /*
2010  * it is not first time for battery to be weld, init by last record info
2011  */
2012 static void rk81x_bat_not_first_pwron(struct rk81x_battery *di)
2013 {
2014         u8 pwron_soc;
2015         u8 init_soc;
2016         int remain_capacity;
2017         int ocv_soc;
2018         int calib_vol, calib_soc, calib_capacity;
2019
2020         rk81x_bat_clr_bit(di, MISC_MARK_REG, FIRST_PWRON_SHIFT);
2021         rk81x_bat_read(di, SOC_REG, &pwron_soc, 1);
2022         init_soc = pwron_soc;
2023         remain_capacity = rk81x_bat_get_remain_capacity(di);
2024
2025         /* check if support uboot charge,
2026          * if support, uboot charge driver should have done init work,
2027          * so here we should skip init work
2028          */
2029 #if defined(CONFIG_ARCH_ROCKCHIP)
2030         if (di->loader_charged) {
2031                 dev_info(di->dev, "loader charged\n");
2032                 goto out;
2033         }
2034 #endif
2035         calib_vol = rk81x_bat_get_calib_vol(di);
2036         if (calib_vol > 0) {
2037                 calib_soc = rk81x_bat_vol_to_capacity(di, calib_vol);
2038                 calib_capacity = di->temp_nac;
2039
2040                 if (abs(calib_soc - init_soc) >= 70 || di->loader_charged) {
2041                         init_soc = calib_soc;
2042                         remain_capacity = calib_capacity;
2043                 }
2044                 dev_info(di->dev, "calib_vol %d, init soc %d, remain_cap %d\n",
2045                          calib_vol, init_soc, remain_capacity);
2046         }
2047
2048         ocv_soc = rk81x_bat_vol_to_capacity(di, di->voltage_ocv);
2049         DBG("<%s>, Not first pwron, real_remain_cap = %d, ocv-remain_cp=%d\n",
2050             __func__, remain_capacity, di->temp_nac);
2051
2052         if (di->pwroff_min > 0) {
2053                 if (di->pwroff_min > 30) {
2054                         rk81x_bat_set_bit(di, MISC_MARK_REG, OCV_VALID_SHIFT);
2055
2056                         remain_capacity = di->temp_nac;
2057                         DBG("<%s>pwroff > 30 minute, remain_cap = %d\n",
2058                             __func__, remain_capacity);
2059
2060                 } else if ((di->pwroff_min > 5) &&
2061                                 (abs(ocv_soc - init_soc) >= 10)) {
2062                         if (remain_capacity >= di->temp_nac * 120/100)
2063                                 remain_capacity = di->temp_nac * 110/100;
2064                         else if (remain_capacity < di->temp_nac * 8/10)
2065                                 remain_capacity = di->temp_nac * 9/10;
2066                         DBG("<%s> pwroff > 5 minute, remain_cap = %d\n",
2067                             __func__, remain_capacity);
2068                 }
2069         } else {
2070                 rk81x_bat_clr_bit(di, MISC_MARK_REG, OCV_VALID_SHIFT);
2071         }
2072 out:
2073         di->dsoc = init_soc;
2074         di->nac = remain_capacity;
2075         if (di->nac <= 0)
2076                 di->nac = 0;
2077         dev_info(di->dev, "reg soc=%d, init soc = %d, init cap=%d\n",
2078                  pwron_soc, di->dsoc, di->nac);
2079 }
2080
2081 static u8 rk81x_bat_get_pwroff_min(struct rk81x_battery *di)
2082 {
2083         u8 curr_pwroff_min, last_pwroff_min;
2084
2085         rk81x_bat_read(di, NON_ACT_TIMER_CNT_REG,
2086                        &curr_pwroff_min, 1);
2087         rk81x_bat_read(di, NON_ACT_TIMER_CNT_REG_SAVE,
2088                        &last_pwroff_min, 1);
2089
2090         rk81x_bat_write(di, NON_ACT_TIMER_CNT_REG_SAVE,
2091                         &curr_pwroff_min, 1);
2092
2093         return (curr_pwroff_min != last_pwroff_min) ? curr_pwroff_min : 0;
2094 }
2095
2096 static int rk81x_bat_rsoc_init(struct rk81x_battery *di)
2097 {
2098         u8 calib_en;/*debug*/
2099
2100         di->voltage  = rk81x_bat_get_vol(di);
2101         di->voltage_ocv = rk81x_bat_get_ocv_vol(di);
2102         di->pwroff_min = rk81x_bat_get_pwroff_min(di);
2103         di->relax_voltage = rk81x_bat_get_relax_vol(di);
2104         di->current_avg = rk81x_bat_get_avg_current(di);
2105
2106         dev_info(di->dev, "v=%d, ov=%d, rv=%d, c=%d, pwroff_min=%d\n",
2107                  di->voltage, di->voltage_ocv, di->relax_voltage,
2108                  di->current_avg, di->pwroff_min);
2109
2110         calib_en = rk81x_bat_read_bit(di, MISC_MARK_REG, OCV_CALIB_SHIFT);
2111         DBG("readbit: calib_en=%d\n", calib_en);
2112         if (is_rk81x_bat_first_poweron(di) ||
2113             ((di->pwroff_min >= 30) && (calib_en == 1))) {
2114                 rk81x_bat_first_pwron(di);
2115                 rk81x_bat_clr_bit(di, MISC_MARK_REG, OCV_CALIB_SHIFT);
2116
2117         } else {
2118                 rk81x_bat_not_first_pwron(di);
2119         }
2120
2121         return 0;
2122 }
2123
2124 static u8 rk81x_bat_get_chrg_status(struct rk81x_battery *di)
2125 {
2126         u8 status;
2127         u8 ret = 0;
2128
2129         rk81x_bat_read(di, SUP_STS_REG, &status, 1);
2130         status &= (0x70);
2131         switch (status) {
2132         case CHARGE_OFF:
2133                 ret = CHARGE_OFF;
2134                 DBG("  CHARGE-OFF ...\n");
2135                 break;
2136         case DEAD_CHARGE:
2137                 ret = DEAD_CHARGE;
2138                 DBG("  DEAD CHARGE ...\n");
2139                 break;
2140         case  TRICKLE_CHARGE:
2141                 ret = DEAD_CHARGE;
2142                 DBG("  TRICKLE CHARGE ...\n ");
2143                 break;
2144         case  CC_OR_CV:
2145                 ret = CC_OR_CV;
2146                 DBG("  CC or CV ...\n");
2147                 break;
2148         case  CHARGE_FINISH:
2149                 ret = CHARGE_FINISH;
2150                 DBG("  CHARGE FINISH ...\n");
2151                 break;
2152         case  USB_OVER_VOL:
2153                 ret = USB_OVER_VOL;
2154                 DBG("  USB OVER VOL ...\n");
2155                 break;
2156         case  BAT_TMP_ERR:
2157                 ret = BAT_TMP_ERR;
2158                 DBG("  BAT TMP ERROR ...\n");
2159                 break;
2160         case  TIMER_ERR:
2161                 ret = TIMER_ERR;
2162                 DBG("  TIMER ERROR ...\n");
2163                 break;
2164         case  USB_EXIST:
2165                 ret = USB_EXIST;
2166                 DBG("  USB EXIST ...\n");
2167                 break;
2168         case  USB_EFF:
2169                 ret = USB_EFF;
2170                 DBG("  USB EFF...\n");
2171                 break;
2172         default:
2173                 return -EINVAL;
2174         }
2175
2176         return ret;
2177 }
2178
2179 static void rk81x_bat_match_param(struct rk81x_battery *di, int chrg_vol,
2180                                   int chrg_ilim, int chrg_cur)
2181 {
2182         int i;
2183
2184         di->chrg_v_lmt = DEF_CHRG_VOL;
2185         di->chrg_i_lmt = DEF_CHRG_CURR_LMT;
2186         di->chrg_i_cur = DEF_CHRG_CURR_SEL;
2187
2188         for (i = 0; i < ARRAY_SIZE(CHRG_V_LMT); i++) {
2189                 if (chrg_vol < CHRG_V_LMT[i])
2190                         break;
2191
2192                 di->chrg_v_lmt = (i << CHRG_VOL_SHIFT);
2193         }
2194
2195         for (i = 0; i < ARRAY_SIZE(CHRG_I_LMT); i++) {
2196                 if (chrg_ilim < CHRG_I_LMT[i])
2197                         break;
2198
2199                 di->chrg_i_lmt = (i << CHRG_ILIM_SHIFT);
2200         }
2201
2202         for (i = 0; i < ARRAY_SIZE(CHRG_I_CUR); i++) {
2203                 if (chrg_cur < CHRG_I_CUR[i])
2204                         break;
2205
2206                 di->chrg_i_cur = (i << CHRG_ICUR_SHIFT);
2207         }
2208         DBG("<%s>. vol = 0x%x, i_lim = 0x%x, cur=0x%x\n",
2209             __func__, di->chrg_v_lmt, di->chrg_i_lmt, di->chrg_i_cur);
2210 }
2211
2212 static u8 rk81x_bat_select_finish_ma(int fcc)
2213 {
2214         u8 ma = FINISH_150MA;
2215
2216         if (fcc > 5000)
2217                 ma = FINISH_250MA;
2218
2219         else if (fcc >= 4000)
2220                 ma = FINISH_200MA;
2221
2222         else if (fcc >= 3000)
2223                 ma = FINISH_150MA;
2224
2225         else
2226                 ma = FINISH_100MA;
2227
2228         return ma;
2229 }
2230 #if 0
2231 /*
2232  * there is a timer inside rk81x to calc how long the battery is in charging
2233  * state. rk81x will close PowerPath inside IC when timer reach, which will
2234  * stop the charging work. we have to reset the corresponding bits to restart
2235  * the timer to avoid that case.
2236  */
2237 static void rk81x_bat_init_chrg_timer(struct rk81x_battery *di)
2238 {
2239         u8 buf;
2240
2241         rk81x_bat_read(di, CHRG_CTRL_REG3, &buf, 1);
2242         buf &= ~CHRG_TIMER_CCCV_EN;
2243         rk81x_bat_write(di, CHRG_CTRL_REG3, &buf, 1);
2244         udelay(40);
2245         rk81x_bat_read(di, CHRG_CTRL_REG3, &buf, 1);
2246         buf |= CHRG_TIMER_CCCV_EN;
2247         rk81x_bat_write(di, CHRG_CTRL_REG3, &buf, 1);
2248         dev_info(di->dev, "reset cccv charge timer\n");
2249 }
2250 #endif
2251
2252 static void rk81x_bat_charger_init(struct  rk81x_battery *di)
2253 {
2254         u8 chrg_ctrl_reg1, usb_ctrl_reg, chrg_ctrl_reg2, chrg_ctrl_reg3;
2255         u8 sup_sts_reg, thremal_reg, ggcon;
2256         int chrg_vol, chrg_cur, chrg_ilim;
2257         u8 finish_ma;
2258
2259         chrg_vol = di->pdata->max_charger_voltagemV;
2260         chrg_cur = di->pdata->max_charger_currentmA;
2261         chrg_ilim = di->pdata->max_charger_ilimitmA;
2262
2263         rk81x_bat_match_param(di, chrg_vol, chrg_ilim, chrg_cur);
2264         finish_ma = rk81x_bat_select_finish_ma(di->fcc);
2265
2266         /*rk81x_bat_init_chrg_timer(di);*/
2267
2268         rk81x_bat_read(di, THERMAL_REG, &thremal_reg, 1);
2269         rk81x_bat_read(di, USB_CTRL_REG, &usb_ctrl_reg, 1);
2270         rk81x_bat_read(di, CHRG_CTRL_REG1, &chrg_ctrl_reg1, 1);
2271         rk81x_bat_read(di, CHRG_CTRL_REG2, &chrg_ctrl_reg2, 1);
2272         rk81x_bat_read(di, SUP_STS_REG, &sup_sts_reg, 1);
2273         rk81x_bat_read(di, CHRG_CTRL_REG3, &chrg_ctrl_reg3, 1);
2274         rk81x_bat_read(di, GGCON, &ggcon, 1);
2275
2276         usb_ctrl_reg &= (~0x0f);
2277
2278         if (rk81x_bat_support_adp_type(HW_ADP_TYPE_USB))
2279                 usb_ctrl_reg |= (CHRG_CT_EN | ILIM_450MA);/*en temp feed back*/
2280         else
2281                 usb_ctrl_reg |= (CHRG_CT_EN | di->chrg_i_lmt);
2282
2283         if (di->fg_drv_mode == TEST_POWER_MODE)
2284                 usb_ctrl_reg |= (CHRG_CT_EN | di->chrg_i_lmt);
2285
2286         chrg_ctrl_reg1 &= (0x00);
2287         chrg_ctrl_reg1 |= (CHRG_EN) | (di->chrg_v_lmt | di->chrg_i_cur);
2288
2289         chrg_ctrl_reg3 |= CHRG_TERM_DIG_SIGNAL;/* digital finish mode*/
2290         chrg_ctrl_reg3 &= ~CHRG_TIMER_CCCV_EN;/*disable*/
2291
2292         chrg_ctrl_reg2 &= ~(0xc7);
2293         chrg_ctrl_reg2 |= finish_ma | CHG_CCCV_6HOUR;
2294
2295         sup_sts_reg &= ~(0x01 << 3);
2296         sup_sts_reg |= (0x01 << 2);
2297
2298         thremal_reg &= (~0x0c);
2299         thremal_reg |= TEMP_105C;/*temp feed back: 105c*/
2300         ggcon |= ADC_CURRENT_MODE;
2301
2302         rk81x_bat_write(di, THERMAL_REG, &thremal_reg, 1);
2303         rk81x_bat_write(di, CHRG_CTRL_REG3, &chrg_ctrl_reg3, 1);
2304         /*don't touch charge  setting when boot int loader charge mode*/
2305         if (!di->loader_charged)
2306                 rk81x_bat_write(di, USB_CTRL_REG, &usb_ctrl_reg, 1);
2307         rk81x_bat_write(di, CHRG_CTRL_REG1, &chrg_ctrl_reg1, 1);
2308         rk81x_bat_write(di, CHRG_CTRL_REG2, &chrg_ctrl_reg2, 1);
2309         rk81x_bat_write(di, SUP_STS_REG, &sup_sts_reg, 1);
2310         rk81x_bat_write(di, GGCON, &ggcon, 1);
2311 }
2312
2313 static void rk81x_bat_fg_init(struct rk81x_battery *di)
2314 {
2315         u8 pcb_offset;
2316         int cal_offset;
2317         u8 val;
2318
2319         val = 0x30;
2320         rk81x_bat_write(di, ADC_CTRL_REG, &val, 1);
2321
2322         rk81x_bat_gauge_enable(di);
2323         /* get the volatege offset */
2324         rk81x_bat_get_vol_offset(di);
2325         rk81x_bat_charger_init(di);
2326         rk81x_bat_set_relax_thres(di);
2327
2328         /* get the current offset , the value write to the CAL_OFFSET */
2329         di->current_offset = rk81x_bat_get_ioffset(di);
2330         rk81x_bat_read(di, PCB_IOFFSET_REG, &pcb_offset, 1);
2331         DBG("<%s>. pcb_offset = 0x%x, io_offset = 0x%x\n",
2332             __func__, pcb_offset, di->current_offset);
2333         if (!pcb_offset)
2334                 pcb_offset = DEF_PCB_OFFSET;
2335         cal_offset = pcb_offset + di->current_offset;
2336         if (cal_offset < 0x7ff || cal_offset > 0x8ff)
2337                 cal_offset = DEF_CAL_OFFSET;
2338         rk81x_bat_set_cal_offset(di, cal_offset);
2339         /* set sample time for cal_offset interval*/
2340         rk81x_bat_ioffset_sample_set(di, SAMP_TIME_8MIN);
2341
2342         rk81x_bat_rsoc_init(di);
2343         rk81x_bat_capacity_init(di, di->nac);
2344         rk81x_bat_capacity_init_post(di);
2345
2346         di->remain_capacity = rk81x_bat_get_realtime_capacity(di);
2347         di->current_avg = rk81x_bat_get_avg_current(di);
2348
2349         rk81x_bat_restart_relax(di);
2350         rk81x_bat_power_on_save(di, di->voltage_ocv);
2351         val = 0;
2352         rk81x_bat_write(di, OCV_VOL_VALID_REG, &val, 1);
2353
2354         rk81x_dbg_dmp_gauge_regs(di);
2355         rk81x_dbg_dmp_charger_regs(di);
2356
2357         DBG("<%s> :\n"
2358             "nac = %d , remain_capacity = %d\n"
2359             "OCV_voltage = %d, voltage = %d\n"
2360             "SOC = %d, fcc = %d\n, current=%d\n"
2361             "cal_offset = 0x%x\n",
2362             __func__,
2363             di->nac, di->remain_capacity,
2364             di->voltage_ocv, di->voltage,
2365             di->dsoc, di->fcc, di->current_avg,
2366             cal_offset);
2367 }
2368
2369 static void rk81x_bat_zero_calc_linek(struct rk81x_battery *di)
2370 {
2371         int dead_voltage, ocv_voltage;
2372         int voltage, voltage_old, voltage_now;
2373         int i, rsoc;
2374         int q_ocv, q_dead;
2375         int count_num = 0;
2376         int currentnow;
2377         int ocv_soc, dead_soc;
2378         int power_off_thresd = di->pdata->power_off_thresd;
2379
2380         do {
2381                 voltage_old = rk81x_bat_get_vol(di);
2382                 msleep(100);
2383                 voltage_now = rk81x_bat_get_vol(di);
2384                 count_num++;
2385         } while ((voltage_old == voltage_now) && (count_num < 11));
2386         DBG("<%s>. current calc count=%d\n", __func__, count_num);
2387
2388         voltage = 0;
2389         for (i = 0; i < 10; i++) {
2390                 voltage += rk81x_bat_get_vol(di);
2391                 msleep(100);
2392         }
2393         voltage /= 10;
2394
2395         currentnow = rk81x_bat_get_avg_current(di);
2396
2397         /* 50 mo power-path mos */
2398         dead_voltage = power_off_thresd - currentnow *
2399                                 (di->bat_res + DEF_PWRPATH_RES) / 1000;
2400
2401         ocv_voltage = voltage - (currentnow * di->bat_res) / 1000;
2402         DBG("ZERO0: dead_voltage(shtd) = %d, ocv_voltage(now) = %d\n",
2403             dead_voltage, ocv_voltage);
2404
2405         dead_soc = rk81x_bat_vol_to_capacity(di, dead_voltage);
2406         q_dead = di->temp_nac;
2407         DBG("ZERO0: dead_voltage_soc = %d, q_dead = %d\n",
2408             dead_soc, q_dead);
2409
2410         ocv_soc = rk81x_bat_vol_to_capacity(di, ocv_voltage);
2411         q_ocv = di->temp_nac;
2412         DBG("ZERO0: ocv_voltage_soc = %d, q_ocv = %d\n",
2413             ocv_soc, q_ocv);
2414
2415         rsoc = ocv_soc - dead_soc;
2416         if ((di->dsoc == 1) && (rsoc > 0)) {/*discharge*/
2417                 di->line_k = 1000;
2418         } else if (rsoc > 0) {
2419                 di->line_k = (di->display_soc + rsoc / 2) / div(rsoc);
2420         } else {
2421                 di->dsoc--;
2422                 di->display_soc = di->dsoc * 1000;
2423         }
2424
2425         di->zero_old_remain_cap = di->remain_capacity;
2426
2427         DBG("ZERO-new: new-line_k=%d, dsoc=%d, X0soc=%d\n"
2428             "ZERO-new: di->display_soc=%d, old_remain_cap=%d\n\n",
2429             di->line_k, di->dsoc, rsoc,
2430             di->display_soc, di->zero_old_remain_cap);
2431 }
2432
2433 static void rk81x_bat_zero_algorithm(struct rk81x_battery *di)
2434 {
2435         int delta_cap, delta_soc;
2436         int tmp_dsoc;
2437
2438         di->zero_timeout_cnt++;
2439         delta_cap = di->zero_old_remain_cap - di->remain_capacity;
2440         delta_soc = di->line_k * (delta_cap * 100) / div(di->fcc);
2441
2442         DBG("ZERO1: line_k=%d, display_soc(Y0)=%d, dsoc=%d, rsoc=%d\n"
2443             "ZERO1: delta_soc(X0)=%d, delta_cap=%d, old_remain_cap = %d\n"
2444             "ZERO1: timeout_cnt=%d\n\n",
2445             di->line_k, di->display_soc, di->dsoc, di->rsoc,
2446             delta_soc, delta_cap, di->zero_old_remain_cap,
2447             di->zero_timeout_cnt);
2448
2449         if ((delta_soc >= MIN_ZERO_ACCURACY) ||
2450             (di->zero_timeout_cnt > 500)) {
2451                 DBG("ZERO1:--------- enter calc -----------\n");
2452                 di->zero_timeout_cnt = 0;
2453                 di->display_soc -= delta_soc;
2454                 tmp_dsoc = (di->display_soc + MIN_ROUND_ACCURACY) / 1000;
2455                 di->dsoc = tmp_dsoc;
2456                 /* need to be init, otherwise when switch between discharge and
2457                  * charge display_soc will be init as: dsoc * 1000
2458                  */
2459                 di->last_zero_mode_dsoc = tmp_dsoc;
2460                 DBG("ZERO1: display_soc(Y0)=%d, dsoc=%d, rsoc=%d, tmp_soc=%d",
2461                     di->display_soc, di->dsoc, di->rsoc, tmp_dsoc);
2462
2463                 rk81x_bat_zero_calc_linek(di);
2464         }
2465 }
2466
2467 static int rk81x_bat_est_ocv_vol(struct rk81x_battery *di)
2468 {
2469         return (di->voltage -
2470                                 (di->bat_res * di->current_avg) / 1000);
2471 }
2472
2473 static int rk81x_bat_est_ocv_soc(struct rk81x_battery *di)
2474 {
2475         int ocv_soc, ocv_voltage;
2476
2477         ocv_voltage = rk81x_bat_est_ocv_vol(di);
2478         ocv_soc = rk81x_bat_vol_to_capacity(di, ocv_voltage);
2479
2480         return ocv_soc;
2481 }
2482
2483 /* we will estimate a ocv voltage to get a ocv soc.
2484  * if there is a big offset between ocv_soc and rsoc,
2485  * we will decide whether we should reinit capacity or not
2486  */
2487 static void rk81x_bat_rsoc_dischrg_check(struct rk81x_battery *di)
2488 {
2489         int ocv_soc = di->est_ocv_soc;
2490         int ocv_volt = di->est_ocv_vol;
2491         int rsoc = rk81x_bat_get_rsoc(di);
2492         int max_volt = di->pdata->max_charger_voltagemV;
2493
2494         if (ocv_volt > max_volt)
2495                 goto out;
2496
2497         if (di->plug_out_min >= RSOC_CALIB_DISCHRGR_TIME) {
2498                 if ((ocv_soc-rsoc >= RSOC_DISCHRG_ERR_LOWER) ||
2499                     (di->rsoc == 0) ||
2500                     (rsoc-ocv_soc >= RSOC_DISCHRG_ERR_UPPER)) {
2501                         di->err_chck_cnt++;
2502                         di->err_soc_sum += ocv_soc;
2503                 } else {
2504                         goto out;
2505                 }
2506                 DBG("<%s>. rsoc err_chck_cnt = %d, err_soc_sum = %d\n",
2507                     __func__, di->err_chck_cnt, di->err_soc_sum);
2508
2509                 if (di->err_chck_cnt >= RSOC_ERR_CHCK_CNT) {
2510                         ocv_soc = di->err_soc_sum / RSOC_ERR_CHCK_CNT;
2511                         if (rsoc-ocv_soc >= RSOC_DISCHRG_ERR_UPPER)
2512                                 ocv_soc += RSOC_COMPS;
2513
2514                         di->temp_nac = ocv_soc * di->fcc / 100;
2515                         rk81x_bat_capacity_init(di, di->temp_nac);
2516                         rk81x_bat_capacity_init_post(di);
2517                         di->rsoc = rk81x_bat_get_rsoc(di);
2518                         di->remain_capacity =
2519                                         rk81x_bat_get_realtime_capacity(di);
2520                         di->err_soc_sum = 0;
2521                         di->err_chck_cnt = 0;
2522                         DBG("<%s>. update: rsoc = %d\n", __func__, ocv_soc);
2523                 }
2524          } else {
2525 out:
2526                 di->err_chck_cnt = 0;
2527                 di->err_soc_sum = 0;
2528         }
2529 }
2530
2531 static void rk81x_bat_rsoc_check(struct rk81x_battery *di)
2532 {
2533         u8 status = di->psy_status;
2534
2535         if ((status == POWER_SUPPLY_STATUS_CHARGING) ||
2536             (status == POWER_SUPPLY_STATUS_FULL)) {
2537                 if ((di->current_avg < 0) &&
2538                     (di->chrg_status != CHARGE_FINISH))
2539                         rk81x_bat_rsoc_dischrg_check(di);
2540                 /*
2541                 else
2542                         rsoc_chrg_calib(di);
2543                 */
2544
2545         } else if (status == POWER_SUPPLY_STATUS_DISCHARGING) {
2546                 rk81x_bat_rsoc_dischrg_check(di);
2547         }
2548 }
2549
2550 static void rk81x_bat_emulator_dischrg(struct rk81x_battery *di)
2551 {
2552         u32 temp, soc_time = 0;
2553         unsigned long sec_unit;
2554
2555         if (!di->dischrg_emu_base)
2556                 di->dischrg_emu_base = get_runtime_sec();
2557
2558         sec_unit = BASE_TO_SEC(di->dischrg_emu_base) + di->dischrg_save_sec;
2559
2560         temp = di->fcc * 3600 / 100;
2561
2562         if (abs(di->current_avg) < DSOC_DISCHRG_EMU_CURR)
2563                 soc_time = temp / div(abs(DSOC_DISCHRG_EMU_CURR));
2564         else
2565                 soc_time = temp / div(abs(di->current_avg));
2566
2567         if  (sec_unit > soc_time) {
2568                 di->dsoc--;
2569                 di->dischrg_emu_base = get_runtime_sec();
2570                 di->dischrg_save_sec = 0;
2571         }
2572
2573         DBG("<%s> soc_time=%d, sec_unit=%lu\n",
2574             __func__, soc_time, sec_unit);
2575 }
2576
2577 /*
2578  * when there is a big offset between dsoc and rsoc, dsoc needs to
2579  * speed up to keep pace witch rsoc.
2580  */
2581 static void rk81x_bat_emulator_chrg(struct rk81x_battery *di)
2582 {
2583         u32 soc_time = 0, temp;
2584         int plus_soc;
2585         unsigned long chrg_emu_sec;
2586
2587         if (!di->chrg_emu_base)
2588                 di->chrg_emu_base = get_runtime_sec();
2589
2590         chrg_emu_sec = BASE_TO_SEC(di->chrg_emu_base) + di->chrg_save_sec;
2591         temp = di->fcc * 3600 / 100;
2592
2593         if (di->ac_online) {
2594                 if (di->current_avg < DSOC_CHRG_EMU_CURR)
2595                         soc_time = temp / abs(DSOC_CHRG_EMU_CURR);
2596                 else
2597                         soc_time = temp / div(abs(di->current_avg));
2598         } else {
2599                 soc_time = temp / 450;
2600         }
2601
2602         plus_soc = chrg_emu_sec / soc_time;
2603         if  (chrg_emu_sec > soc_time) {
2604                 di->dsoc += plus_soc;
2605                 di->chrg_emu_base = get_runtime_sec();
2606                 di->chrg_save_sec = 0;
2607         }
2608
2609         DBG("<%s>. soc_time=%d, chrg_emu_sec=%lu, plus_soc=%d\n",
2610             __func__, soc_time, chrg_emu_sec, plus_soc);
2611 }
2612
2613 /* check voltage and current when dsoc is close to full.
2614  * we will do a fake charge to adjust charing speed which
2615  * aims to make battery full charged and match finish signal.
2616  */
2617 static void rk81x_bat_terminal_chrg(struct rk81x_battery *di)
2618 {
2619         u32 soc_time;
2620         int plus_soc;
2621         unsigned long chrg_term_sec;
2622
2623         if (!di->chrg_term_base)
2624                 di->chrg_term_base = get_runtime_sec();
2625
2626         chrg_term_sec = BASE_TO_SEC(di->chrg_term_base) + di->chrg_save_sec;
2627         /*check current and voltage*/
2628
2629         soc_time = di->fcc * 3600 / 100 / (abs(DSOC_CHRG_TERM_CURR));
2630
2631         plus_soc = chrg_term_sec / soc_time;
2632         if  (chrg_term_sec > soc_time) {
2633                 di->dsoc += plus_soc;
2634                 di->chrg_term_base = get_runtime_sec();
2635                 di->chrg_save_sec = 0;
2636         }
2637         DBG("<%s>. soc_time=%d, chrg_term_sec=%lu, plus_soc=%d\n",
2638             __func__, soc_time, chrg_term_sec, plus_soc);
2639 }
2640
2641 static void rk81x_bat_normal_dischrg(struct rk81x_battery *di)
2642 {
2643         int soc_time = 0;
2644         int now_current = di->current_avg;
2645         unsigned long dischrg_normal_sec;
2646
2647         if (!di->dischrg_normal_base)
2648                 di->dischrg_normal_base = get_runtime_sec();
2649
2650         dischrg_normal_sec = BASE_TO_SEC(di->dischrg_normal_base) +
2651                                                 di->dischrg_save_sec;
2652
2653         soc_time = di->fcc * 3600 / 100 / div(abs(now_current));
2654         DBG("<%s>. rsoc=%d, dsoc=%d, dischrg_st=%d\n",
2655             __func__, di->rsoc, di->dsoc, di->discharge_smooth_status);
2656
2657         if (di->rsoc == di->dsoc) {
2658                 DBG("<%s>. rsoc == dsoc\n", __func__);
2659                 di->dsoc = di->rsoc;
2660                 di->dischrg_normal_base = get_runtime_sec();
2661                 di->dischrg_save_sec = 0;
2662                 /*di->discharge_smooth_status = false;*/
2663         } else if (di->rsoc > di->dsoc - 1) {
2664                 DBG("<%s>. rsoc > dsoc - 1\n", __func__);
2665                 if (dischrg_normal_sec > soc_time * 3 / 2) {
2666                         di->dsoc--;
2667                         di->dischrg_normal_base = get_runtime_sec();
2668                         di->dischrg_save_sec = 0;
2669                 }
2670                 di->discharge_smooth_status = true;
2671
2672         } else if (di->rsoc < di->dsoc - 1) {
2673                 DBG("<%s>. rsoc < dsoc - 1\n", __func__);
2674                 if (dischrg_normal_sec > soc_time * 3 / 4) {
2675                         di->dsoc--;
2676                         di->dischrg_normal_base = get_runtime_sec();
2677                         di->dischrg_save_sec = 0;
2678                 }
2679                 di->discharge_smooth_status = true;
2680
2681         } else if (di->rsoc == di->dsoc - 1) {
2682                 DBG("<%s>. rsoc == dsoc - 1\n", __func__);
2683                 if (di->discharge_smooth_status) {
2684                         if (dischrg_normal_sec > soc_time * 3 / 4) {
2685                                 di->dsoc--;
2686                                 di->dischrg_normal_base = get_runtime_sec();
2687                                 di->dischrg_save_sec = 0;
2688                                 di->discharge_smooth_status = false;
2689                         }
2690                 } else {
2691                         di->dsoc--;
2692                         di->dischrg_normal_base = get_runtime_sec();
2693                         di->dischrg_save_sec = 0;
2694                         di->discharge_smooth_status = false;
2695                 }
2696         }
2697
2698         DBG("<%s>, rsoc = %d, dsoc = %d, discharge_smooth_status = %d\n"
2699             "dischrg_normal_sec = %lu, soc_time = %d, delta_vol=%d\n",
2700             __func__, di->rsoc, di->dsoc, di->discharge_smooth_status,
2701             dischrg_normal_sec, soc_time, di->delta_vol_smooth);
2702 }
2703
2704 static void rk81x_bat_dischrg_smooth(struct rk81x_battery *di)
2705 {
2706         int delta_soc;
2707         int tmp_dsoc;
2708
2709         /* first resume from suspend: we don't run this,
2710          * the sleep_dischrg will handle dsoc, and what
2711          * ever this is fake wakeup or not, we should clean
2712          * zero algorithm mode, or it will handle the dsoc.
2713          */
2714         if (di->s2r) {
2715                 rk81x_bat_reset_zero_var(di);
2716                 return;
2717         }
2718
2719         di->rsoc = rk81x_bat_get_rsoc(di);
2720
2721         DBG("<%s>. rsoc = %d, dsoc = %d, dischrg_algorithm_mode=%d\n",
2722             __func__, di->rsoc, di->dsoc, di->dischrg_algorithm_mode);
2723
2724         if (di->dischrg_algorithm_mode == DISCHRG_NORMAL_MODE) {
2725                 delta_soc = di->dsoc - di->rsoc;
2726
2727                 if (delta_soc > DSOC_DISCHRG_FAST_EER_RANGE) {
2728                         di->dischrg_normal_base = 0;
2729                         rk81x_bat_emulator_dischrg(di);
2730                 } else {
2731                         di->chrg_emu_base = 0;
2732                         rk81x_bat_normal_dischrg(di);
2733                 }
2734
2735                 if (di->voltage < ZERO_ALGOR_THRESD) {
2736                         di->dischrg_normal_base = 0;
2737                         di->chrg_emu_base = 0;
2738                         di->dischrg_algorithm_mode = DISCHRG_ZERO_MODE;
2739                         di->zero_timeout_cnt = 0;
2740
2741                         DBG("<%s>. dsoc=%d, last_zero_mode_dsoc=%d\n",
2742                             __func__, di->dsoc, di->last_zero_mode_dsoc);
2743                         if (di->dsoc != di->last_zero_mode_dsoc) {
2744                                 tmp_dsoc = (di->display_soc +
2745                                                 MIN_ROUND_ACCURACY) / 1000;
2746                                 /* if last display_soc invalid, recalc.
2747                                  * otherwise keep this value(in case: plugin and
2748                                  * plugout quickly or wakeup from deep sleep,
2749                                  * we need't init display_soc)
2750                                  */
2751                                 if (tmp_dsoc != di->dsoc)
2752                                         /* first init value should round up,
2753                                          * other wise dsoc will quickly turn to
2754                                          * dsoc-- if MIN_ROUND_ACCURACY value is
2755                                          * small,eg:1.(in case: power on system)
2756                                          */
2757                                         di->display_soc = (di->dsoc + 1) *
2758                                                 1000 - MIN_ROUND_ACCURACY;
2759                                 di->last_zero_mode_dsoc = di->dsoc;
2760                                 rk81x_bat_zero_calc_linek(di);
2761                                 DBG("<%s>. first calc, init linek\n", __func__);
2762                         }
2763                 }
2764         } else {
2765                 rk81x_bat_zero_algorithm(di);
2766
2767                 if (di->voltage > ZERO_ALGOR_THRESD + 50) {
2768                         di->dischrg_algorithm_mode = DISCHRG_NORMAL_MODE;
2769                         di->zero_timeout_cnt = 0;
2770                         DBG("<%s>. exit zero_algorithm\n", __func__);
2771                 }
2772         }
2773 }
2774
2775 static void rk81x_bat_dbg_time_table(struct rk81x_battery *di)
2776 {
2777         u8 i;
2778         static int old_index;
2779         static int old_min;
2780         u32 time;
2781         int mod = di->dsoc % 10;
2782         int index = di->dsoc / 10;
2783
2784         if (rk81x_chrg_online(di))
2785                 time = di->plug_in_min;
2786         else
2787                 time = di->plug_out_min;
2788
2789         if ((mod == 0) && (index > 0) && (old_index != index)) {
2790                 di->chrg_min[index-1] = time - old_min;
2791                 old_min = time;
2792                 old_index = index;
2793         }
2794
2795         for (i = 1; i < 11; i++)
2796                 DBG("Time[%d]=%d, ", (i * 10), di->chrg_min[i-1]);
2797         DBG("\n");
2798 }
2799
2800 static void rk81x_bat_dbg_dmp_info(struct rk81x_battery *di)
2801 {
2802         u8 sup_tst_reg, ggcon_reg, ggsts_reg, vb_mod_reg;
2803         u8 usb_ctrl_reg, chrg_ctrl_reg1, thremal_reg;
2804         u8 chrg_ctrl_reg2, chrg_ctrl_reg3, rtc_val, misc_reg;
2805
2806         if (dbg_enable) {
2807                 rk81x_bat_read(di, MISC_MARK_REG, &misc_reg, 1);
2808                 rk81x_bat_read(di, GGCON, &ggcon_reg, 1);
2809                 rk81x_bat_read(di, GGSTS, &ggsts_reg, 1);
2810                 rk81x_bat_read(di, SUP_STS_REG, &sup_tst_reg, 1);
2811                 rk81x_bat_read(di, VB_MOD_REG, &vb_mod_reg, 1);
2812                 rk81x_bat_read(di, USB_CTRL_REG, &usb_ctrl_reg, 1);
2813                 rk81x_bat_read(di, CHRG_CTRL_REG1, &chrg_ctrl_reg1, 1);
2814                 rk81x_bat_read(di, CHRG_CTRL_REG2, &chrg_ctrl_reg2, 1);
2815                 rk81x_bat_read(di, CHRG_CTRL_REG3, &chrg_ctrl_reg3, 1);
2816                 rk81x_bat_read(di, 0x00, &rtc_val, 1);
2817                 rk81x_bat_read(di, THERMAL_REG, &thremal_reg, 1);
2818         }
2819
2820         DBG("\n------------- dump_debug_regs -----------------\n"
2821             "GGCON = 0x%2x, GGSTS = 0x%2x, RTC  = 0x%2x\n"
2822             "SUP_STS_REG  = 0x%2x, VB_MOD_REG   = 0x%2x\n"
2823             "USB_CTRL_REG  = 0x%2x, CHRG_CTRL_REG1 = 0x%2x\n"
2824             "THERMAL_REG = 0x%2x, MISC_MARK_REG = 0x%x\n"
2825             "CHRG_CTRL_REG2 = 0x%2x, CHRG_CTRL_REG3 = 0x%2x\n\n",
2826             ggcon_reg, ggsts_reg, rtc_val,
2827             sup_tst_reg, vb_mod_reg,
2828             usb_ctrl_reg, chrg_ctrl_reg1,
2829             thremal_reg, misc_reg,
2830             chrg_ctrl_reg2, chrg_ctrl_reg3
2831            );
2832
2833         DBG("#######################################################\n"
2834             "voltage = %d, current-avg = %d\n"
2835             "fcc = %d, remain_capacity = %d, ocv_volt = %d\n"
2836             "check_ocv = %d, check_soc = %d, bat_res = %d\n"
2837             "display_soc = %d, cpapacity_soc = %d\n"
2838             "AC-ONLINE = %d, USB-ONLINE = %d, charging_status = %d\n"
2839             "i_offset=0x%x, cal_offset=0x%x, adjust_cap=%d\n"
2840             "plug_in = %d, plug_out = %d, finish_sig = %d, finish_chrg=%lu\n"
2841             "sec: chrg=%lu, dischrg=%lu, term_chrg=%lu, emu_chrg=%lu\n"
2842             "emu_dischrg = %lu, power_on_sec = %lu\n"
2843             "mode:%d, save_chrg_sec = %lu, save_dischrg_sec = %lu\n"
2844             "#########################################################\n",
2845             di->voltage, di->current_avg,
2846             di->fcc, di->remain_capacity, di->voltage_ocv,
2847             di->est_ocv_vol, di->est_ocv_soc, di->bat_res,
2848             di->dsoc, di->rsoc,
2849             di->ac_online, di->usb_online, di->psy_status,
2850             rk81x_bat_get_ioffset(di), rk81x_bat_get_cal_offset(di),
2851             di->adjust_cap, di->plug_in_min, di->plug_out_min,
2852             di->finish_sig_min, BASE_TO_SEC(di->chrg_finish_base),
2853             BASE_TO_SEC(di->chrg_normal_base),
2854             BASE_TO_SEC(di->dischrg_normal_base),
2855             BASE_TO_SEC(di->chrg_term_base),
2856             BASE_TO_SEC(di->chrg_emu_base),
2857             BASE_TO_SEC(di->dischrg_emu_base),
2858             BASE_TO_SEC(di->power_on_base),
2859             di->current_mode, di->chrg_save_sec, di->dischrg_save_sec
2860            );
2861 }
2862
2863 static void rk81x_bat_update_fcc(struct rk81x_battery *di)
2864 {
2865         int fcc0;
2866         int remain_cap;
2867         int dod0_to_soc100_min;
2868
2869         remain_cap = di->remain_capacity - di->dod0_capacity - di->adjust_cap;
2870         dod0_to_soc100_min = BASE_TO_MIN(di->fcc_update_sec);
2871
2872         DBG("%s: remain_cap:%d, ajust_cap:%d, dod0_status=%d\n"
2873             "dod0_capacity:%d, dod0_to_soc100_min:%d\n",
2874             __func__, remain_cap, di->adjust_cap, di->dod0_status,
2875             di->dod0_capacity, dod0_to_soc100_min);
2876
2877         if ((di->chrg_status == CHARGE_FINISH) && (di->dod0_status == 1) &&
2878             (dod0_to_soc100_min < 1200)) {
2879                 DBG("%s: dod0:%d, dod0_cap:%d, dod0_level:%d\n",
2880                     __func__, di->dod0, di->dod0_capacity, di->dod0_level);
2881
2882                 fcc0 = remain_cap * 100 / div(100 - di->dod0);
2883
2884                 dev_info(di->dev, "%s: fcc0:%d, fcc:%d\n",
2885                          __func__, fcc0, di->fcc);
2886
2887                 if ((fcc0 < di->qmax) && (fcc0 > 1000)) {
2888                         di->dod0_status = 0;
2889                         di->fcc = fcc0;
2890                         rk81x_bat_capacity_init(di, di->fcc);
2891                         rk81x_bat_capacity_init_post(di);
2892                         rk81x_bat_save_fcc(di, di->fcc);
2893                         rk81x_bat_save_level(di, di->dod0_level);
2894                         DBG("%s: new fcc0:%d\n", __func__, di->fcc);
2895                 }
2896
2897                 di->dod0_status = 0;
2898         }
2899 }
2900
2901 static void rk81x_bat_dbg_get_finish_soc(struct rk81x_battery *di)
2902 {
2903         if (di->chrg_status == CHARGE_FINISH) {
2904                 di->debug_finish_real_soc = di->dsoc;
2905                 di->debug_finish_temp_soc = di->rsoc;
2906         }
2907 }
2908
2909 static void rk81x_bat_wait_finish_sig(struct rk81x_battery *di)
2910 {
2911         int chrg_finish_vol = di->pdata->max_charger_voltagemV;
2912         bool ret;
2913
2914         if ((di->chrg_status == CHARGE_FINISH) &&
2915             (di->voltage > chrg_finish_vol - 150) &&  di->enter_finish) {
2916                 rk81x_bat_update_fcc(di);/* save new fcc*/
2917                 ret = rk81x_bat_zero_current_calib(di);
2918                 if (ret)
2919                         di->enter_finish = false;
2920                 /* debug msg*/
2921                 rk81x_bat_dbg_get_finish_soc(di);
2922         }
2923 }
2924
2925 static void rk81x_bat_finish_chrg(struct rk81x_battery *di)
2926 {
2927         unsigned long sec_finish;
2928         int soc_time = 0, plus_soc;
2929         int temp;
2930
2931         if (di->dsoc < 100) {
2932                 if (!di->chrg_finish_base)
2933                         di->chrg_finish_base = get_runtime_sec();
2934
2935                 sec_finish = BASE_TO_SEC(di->chrg_finish_base) +
2936                                                 di->chrg_save_sec;
2937                 temp = di->fcc * 3600 / 100;
2938                 if (di->ac_online)
2939                         soc_time = temp / DSOC_CHRG_FINISH_CURR;
2940                 else
2941                         soc_time = temp / 450;
2942
2943                 plus_soc = sec_finish / soc_time;
2944                 if (sec_finish > soc_time) {
2945                         di->dsoc += plus_soc;
2946                         di->chrg_finish_base = get_runtime_sec();
2947                         di->chrg_save_sec = 0;
2948                 }
2949                 DBG("<%s>,CHARGE_FINISH:dsoc<100,dsoc=%d\n"
2950                     "soc_time=%d, sec_finish=%lu, plus_soc=%d\n",
2951                     __func__, di->dsoc, soc_time, sec_finish, plus_soc);
2952         }
2953 }
2954
2955 static u8 rk81x_bat_get_valid_soc(unsigned long soc)
2956 {
2957         return (soc <= 100) ? soc : 0;
2958 }
2959
2960 static void rk81x_bat_normal_chrg(struct rk81x_battery *di)
2961 {
2962         int now_current;
2963         u32 soc_time, unit_sec;
2964         int plus_soc = 0;
2965         unsigned long chrg_normal_sec;
2966
2967         now_current = rk81x_bat_get_avg_current(di);
2968         soc_time = di->fcc * 3600 / 100 / div(abs(now_current)); /*1% time*/
2969
2970         if (!di->chrg_normal_base)
2971                 di->chrg_normal_base = get_runtime_sec();
2972
2973         chrg_normal_sec = BASE_TO_SEC(di->chrg_normal_base) + di->chrg_save_sec;
2974         di->rsoc = rk81x_bat_get_rsoc(di);
2975
2976         DBG("<%s>. rsoc=%d, dsoc=%d, chrg_st=%d\n",
2977             __func__, di->rsoc, di->dsoc, di->charge_smooth_status);
2978
2979         if (di->dsoc == di->rsoc) {
2980                 DBG("<%s>. rsoc == dsoc + 1\n", __func__);
2981                 di->rsoc = rk81x_bat_get_rsoc(di);
2982                 di->chrg_normal_base = get_runtime_sec();
2983                 di->chrg_save_sec = 0;
2984                 /*di->charge_smooth_status = false;*/
2985         } else if (di->rsoc < di->dsoc + 1) {
2986                 DBG("<%s>. rsoc < dsoc + 1\n", __func__);
2987                 unit_sec = soc_time * 3 / 2;
2988                 plus_soc = rk81x_bat_get_valid_soc(chrg_normal_sec / unit_sec);
2989                 if  (chrg_normal_sec > unit_sec) {
2990                         di->dsoc += plus_soc;
2991                         di->chrg_normal_base = get_runtime_sec();
2992                         di->chrg_save_sec = 0;
2993                 }
2994                 di->charge_smooth_status = true;
2995         } else if (di->rsoc > di->dsoc + 1) {
2996                 DBG("<%s>. rsoc > dsoc + 1\n", __func__);
2997                 unit_sec = soc_time * 3 / 4;
2998                 plus_soc = rk81x_bat_get_valid_soc(chrg_normal_sec / unit_sec);
2999                 if  (chrg_normal_sec > unit_sec) {
3000                         di->dsoc += plus_soc;
3001                         di->chrg_normal_base = get_runtime_sec();
3002                         di->chrg_save_sec = 0;
3003                 }
3004                 di->charge_smooth_status = true;
3005         } else if (di->rsoc == di->dsoc + 1) {
3006                 DBG("<%s>. rsoc == dsoc + 1\n", __func__);
3007                 if (di->charge_smooth_status) {
3008                         unit_sec = soc_time * 3 / 4;
3009                         if (chrg_normal_sec > unit_sec) {
3010                                 di->dsoc = di->rsoc;
3011                                 di->chrg_normal_base = get_runtime_sec();
3012                                 di->charge_smooth_status = false;
3013                                 di->chrg_save_sec = 0;
3014                         }
3015                 } else {
3016                         di->dsoc = di->rsoc;
3017                         di->chrg_normal_base = get_runtime_sec();
3018                         di->charge_smooth_status = false;
3019                         di->chrg_save_sec = 0;
3020                 }
3021         }
3022
3023         DBG("<%s>, rsoc = %d, dsoc = %d, charge_smooth_status = %d\n"
3024             "chrg_normal_sec = %lu, soc_time = %d, plus_soc=%d\n",
3025             __func__, di->rsoc, di->dsoc, di->charge_smooth_status,
3026             chrg_normal_sec, soc_time, plus_soc);
3027 }
3028
3029 static void rk81x_bat_update_time(struct rk81x_battery *di)
3030 {
3031         u64 runtime_sec;
3032
3033         runtime_sec = get_runtime_sec();
3034
3035         /*update by charger type*/
3036         if (rk81x_chrg_online(di))
3037                 di->plug_out_base = runtime_sec;
3038         else
3039                 di->plug_in_base = runtime_sec;
3040
3041         /*update by current*/
3042         if (di->chrg_status != CHARGE_FINISH) {
3043                 di->finish_sig_base = runtime_sec;
3044                 di->chrg_finish_base = runtime_sec;
3045         }
3046
3047         di->plug_in_min = BASE_TO_MIN(di->plug_in_base);
3048         di->plug_out_min = BASE_TO_MIN(di->plug_out_base);
3049         di->finish_sig_min = BASE_TO_MIN(di->finish_sig_base);
3050
3051         rk81x_bat_dbg_time_table(di);
3052 }
3053
3054 static int rk81x_bat_get_rsoc_trend(struct rk81x_battery *di, int *trend_mult)
3055 {
3056         int trend_start_cap = di->trend_start_cap;
3057         int remain_cap = di->remain_capacity;
3058         int diff_cap;
3059         int state;
3060
3061         if (di->s2r && !di->slp_psy_status)
3062                 di->trend_start_cap = di->remain_capacity;
3063
3064         diff_cap = remain_cap - trend_start_cap;
3065         DBG("<%s>. trend_start_cap = %d, diff_cap = %d\n",
3066             __func__, trend_start_cap, diff_cap);
3067         *trend_mult = abs(diff_cap) / TREND_CAP_DIFF;
3068
3069         if (abs(diff_cap) >= TREND_CAP_DIFF) {
3070                 di->trend_start_cap = di->remain_capacity;
3071                 state = (diff_cap > 0) ? TREND_STAT_UP : TREND_STAT_DOWN;
3072                 DBG("<%s>. new trend_start_cap=%d", __func__, trend_start_cap);
3073         } else {
3074                 state = TREND_STAT_FLAT;
3075         }
3076
3077         return state;
3078 }
3079
3080 static void rk81x_bat_arbitrate_rsoc_trend(struct rk81x_battery *di)
3081 {
3082         int state, soc_time;
3083         static int trend_down_cnt, trend_up_cnt;
3084         int trend_cnt_thresd;
3085         int now_current = di->current_avg;
3086         int trend_mult = 0;
3087
3088         trend_cnt_thresd = di->fcc / 100 / TREND_CAP_DIFF;
3089         state = rk81x_bat_get_rsoc_trend(di, &trend_mult);
3090         DBG("<%s>. TREND_STAT = %d, trend_mult = %d\n",
3091             __func__, state, trend_mult);
3092         if (di->chrg_status == CHARGE_FINISH)
3093                 return;
3094
3095         if (state == TREND_STAT_UP) {
3096                 rk81x_bat_reset_zero_var(di);
3097                 trend_down_cnt = 0;
3098                 trend_up_cnt += trend_mult;
3099                 if (trend_up_cnt >= trend_cnt_thresd) {
3100                         trend_up_cnt = 0;
3101                         di->dischrg_save_sec = 0;
3102                 }
3103         } else if (state == TREND_STAT_DOWN) {
3104                 trend_up_cnt = 0;
3105                 trend_down_cnt += trend_mult;
3106                 if (trend_down_cnt >= trend_cnt_thresd) {
3107                         trend_down_cnt = 0;
3108                         di->chrg_save_sec = 0;
3109                 }
3110         }
3111
3112         soc_time = di->fcc * 3600 / 100 / div(abs(now_current));
3113         if ((di->chrg_save_sec * 3 / 4 > soc_time) &&
3114             (trend_up_cnt <= trend_cnt_thresd / 2) &&
3115             (now_current >= 0))
3116                 di->chrg_save_sec = 0;
3117
3118         else if ((di->dischrg_save_sec * 3 / 4 > soc_time) &&
3119                  (trend_down_cnt <= trend_cnt_thresd / 2) &&
3120                  (now_current < 0))
3121                 di->dischrg_save_sec = 0;
3122
3123         DBG("<%s>. state=%d, cnt_thresd=%d, soc_time=%d\n"
3124             "up_cnt=%d, down_cnt=%d\n",
3125             __func__, state, trend_cnt_thresd, soc_time,
3126             trend_up_cnt, trend_down_cnt);
3127 }
3128
3129 static void rk81x_bat_chrg_smooth(struct rk81x_battery *di)
3130 {
3131         u32 *ocv_table = di->pdata->battery_ocv;
3132         int delta_soc = di->rsoc - di->dsoc;
3133
3134         if (di->chrg_status == CHARGE_FINISH ||
3135             di->slp_chrg_status == CHARGE_FINISH) {
3136                 /*clear sleep charge status*/
3137                 di->slp_chrg_status = rk81x_bat_get_chrg_status(di);
3138                 di->chrg_emu_base = 0;
3139                 di->chrg_normal_base = 0;
3140                 di->chrg_term_base = 0;
3141                 rk81x_bat_finish_chrg(di);
3142                 rk81x_bat_capacity_init(di, di->fcc);
3143                 rk81x_bat_capacity_init_post(di);
3144         } else if ((di->ac_online == ONLINE && di->dsoc >= 90) &&
3145                    ((di->current_avg > DSOC_CHRG_TERM_CURR) ||
3146                     (di->voltage < ocv_table[18] + 20))) {
3147                 di->chrg_emu_base = 0;
3148                 di->chrg_normal_base = 0;
3149                 di->chrg_finish_base = 0;
3150                 rk81x_bat_terminal_chrg(di);
3151         } else if (di->chrg_status != CHARGE_FINISH &&
3152                    delta_soc >= DSOC_CHRG_FAST_EER_RANGE) {
3153                 di->chrg_term_base = 0;
3154                 di->chrg_normal_base = 0;
3155                 di->chrg_finish_base = 0;
3156                 rk81x_bat_emulator_chrg(di);
3157         } else {
3158                 di->chrg_emu_base = 0;
3159                 di->chrg_term_base = 0;
3160                 di->chrg_finish_base = 0;
3161                 rk81x_bat_normal_chrg(di);
3162         }
3163 }
3164
3165 static unsigned long rk81x_bat_save_dischrg_sec(struct rk81x_battery *di)
3166 {
3167         unsigned long dischrg_normal_sec = BASE_TO_SEC(di->dischrg_normal_base);
3168         unsigned long dischrg_emu_sec = BASE_TO_SEC(di->dischrg_emu_base);
3169
3170         DBG("dischrg_normal_sec=%lu, dischrg_emu_sec=%lu\n",
3171             dischrg_normal_sec, dischrg_emu_sec);
3172
3173         return (dischrg_normal_sec > dischrg_emu_sec) ?
3174                 dischrg_normal_sec : dischrg_emu_sec;
3175 }
3176
3177 static unsigned long rk81x_bat_save_chrg_sec(struct rk81x_battery *di)
3178 {
3179         unsigned long sec1, sec2;
3180         unsigned long chrg_normal_sec = BASE_TO_SEC(di->chrg_normal_base);
3181         unsigned long chrg_term_sec = BASE_TO_SEC(di->chrg_term_base);
3182         unsigned long chrg_emu_sec = BASE_TO_SEC(di->chrg_emu_base);
3183         unsigned long chrg_finish_sec = BASE_TO_SEC(di->chrg_finish_base);
3184
3185         sec1 = (chrg_normal_sec > chrg_term_sec) ?
3186                 chrg_normal_sec : chrg_term_sec;
3187
3188         sec2 = (chrg_emu_sec > chrg_finish_sec) ?
3189                 chrg_emu_sec : chrg_finish_sec;
3190         DBG("chrg_normal_sec=%lu, chrg_term_sec=%lu\n"
3191             "chrg_emu_sec=%lu, chrg_finish_sec=%lu\n",
3192             chrg_normal_sec, chrg_term_sec,
3193             chrg_emu_sec, chrg_finish_sec);
3194
3195         return (sec1 > sec2) ? sec1 : sec2;
3196 }
3197
3198 static void rk81x_bat_display_smooth(struct rk81x_battery *di)
3199 {
3200         if ((di->current_avg >= 0) || (di->chrg_status == CHARGE_FINISH)) {
3201                 if (di->current_mode == DISCHRG_MODE) {
3202                         di->current_mode = CHRG_MODE;
3203                         di->dischrg_save_sec += rk81x_bat_save_dischrg_sec(di);
3204                         di->dischrg_normal_base = 0;
3205                         di->dischrg_emu_base = 0;
3206                         if (di->chrg_status == CHARGE_FINISH)
3207                                 di->dischrg_save_sec = 0;
3208                         if ((di->chrg_status == CHARGE_FINISH) &&
3209                             (di->dsoc >= 100))
3210                                 di->chrg_save_sec = 0;
3211
3212                         DBG("<%s>---dischrg_save_sec = %lu\n",
3213                             __func__, di->dischrg_save_sec);
3214                 }
3215
3216                 if (!rk81x_chrg_online(di)) {
3217                         dev_err(di->dev, "discharge, current error:%d\n",
3218                                 di->current_avg);
3219                 } else {
3220                         rk81x_bat_chrg_smooth(di);
3221                         di->discharge_smooth_status = true;
3222                 }
3223         } else {
3224                 if (di->current_mode == CHRG_MODE) {
3225                         di->current_mode = DISCHRG_MODE;
3226                         di->chrg_save_sec += rk81x_bat_save_chrg_sec(di);
3227                         di->chrg_normal_base = 0;
3228                         di->chrg_emu_base = 0;
3229                         di->chrg_term_base = 0;
3230                         di->chrg_finish_base = 0;
3231                         DBG("<%s>---chrg_save_sec = %lu\n",
3232                             __func__, di->chrg_save_sec);
3233                 }
3234                 rk81x_bat_dischrg_smooth(di);
3235                 di->charge_smooth_status = true;
3236         }
3237 }
3238
3239 /*
3240  * update rsoc by relax voltage
3241  */
3242 static void rk81x_bat_relax_vol_calib(struct rk81x_battery *di)
3243 {
3244         int relax_vol = di->relax_voltage;
3245         int ocv_soc, capacity;
3246
3247         ocv_soc = rk81x_bat_vol_to_capacity(di, relax_vol);
3248         capacity = (ocv_soc * di->fcc / 100);
3249         rk81x_bat_capacity_init(di, capacity);
3250         di->remain_capacity = rk81x_bat_get_realtime_capacity(di);
3251         di->rsoc = rk81x_bat_get_rsoc(di);
3252         rk81x_bat_capacity_init_post(di);
3253         DBG("%s, RSOC=%d, CAP=%d\n", __func__, ocv_soc, capacity);
3254 }
3255
3256 /* condition:
3257  * 1: must do it, 0: when necessary
3258  */
3259 static void rk81x_bat_vol_calib(struct rk81x_battery *di, int condition)
3260 {
3261         int ocv_vol = di->est_ocv_vol;
3262         int ocv_soc = 0, capacity = 0;
3263
3264         ocv_soc = rk81x_bat_vol_to_capacity(di, ocv_vol);
3265         capacity = (ocv_soc * di->fcc / 100);
3266         if (condition || (abs(ocv_soc-di->rsoc) >= RSOC_RESUME_ERR)) {
3267                 rk81x_bat_capacity_init(di, capacity);
3268                 di->remain_capacity = rk81x_bat_get_realtime_capacity(di);
3269                 di->rsoc = rk81x_bat_get_rsoc(di);
3270                 rk81x_bat_capacity_init_post(di);
3271                 DBG("<%s>, rsoc updated!\n", __func__);
3272         }
3273         DBG("<%s>, OCV_VOL=%d,OCV_SOC=%d, CAP=%d\n",
3274             __func__, ocv_vol, ocv_soc, capacity);
3275 }
3276
3277 static int  rk81x_bat_sleep_dischrg(struct rk81x_battery *di)
3278 {
3279         int delta_soc = 0;
3280         int temp_dsoc;
3281         unsigned long sleep_sec = di->suspend_time_sum;
3282         int power_off_thresd = di->pdata->power_off_thresd;
3283
3284         DBG("<%s>, enter: dsoc=%d, rsoc=%d\n"
3285             "relax_vol=%d, vol=%d, sleep_min=%lu\n",
3286             __func__, di->dsoc, di->rsoc,
3287             di->relax_voltage, di->voltage, sleep_sec / 60);
3288
3289         if (di->relax_voltage >= di->voltage) {
3290                 rk81x_bat_relax_vol_calib(di);
3291                 rk81x_bat_restart_relax(di);
3292
3293         /* current_avg < 0: make sure the system is not
3294          * wakeup by charger plugin.
3295          */
3296         /* even if relax voltage is not caught rightly, realtime voltage
3297          * is quite close to relax voltage, we should not do nothing after
3298          * sleep 30min
3299          */
3300         } else  {
3301                 rk81x_bat_vol_calib(di, 1);
3302         }
3303
3304         /*handle dsoc*/
3305         if (di->dsoc <= di->rsoc) {
3306                 di->sum_suspend_cap = (SLP_CURR_MIN * sleep_sec / 3600);
3307                 delta_soc = di->sum_suspend_cap * 100 / di->fcc;
3308                 temp_dsoc = di->dsoc - delta_soc;
3309
3310                 pr_info("battery calib0: rl=%d, dl=%d, intl=%d\n",
3311                         di->rsoc, di->dsoc, delta_soc);
3312
3313                 if (delta_soc > 0) {
3314                         if ((temp_dsoc < di->dsoc) && (di->dsoc < 5))
3315                                 di->dsoc--;
3316                         else if ((temp_dsoc < 5) && (di->dsoc >= 5))
3317                                 di->dsoc = 5;
3318                         else if (temp_dsoc > 5)
3319                                 di->dsoc = temp_dsoc;
3320                 }
3321
3322                 DBG("%s: dsoc<=rsoc, sum_cap=%d==>delta_soc=%d,temp_dsoc=%d\n",
3323                     __func__, di->sum_suspend_cap, delta_soc, temp_dsoc);
3324         } else {
3325                 /*di->dsoc > di->rsoc*/
3326                 di->sum_suspend_cap = (SLP_CURR_MAX * sleep_sec / 3600);
3327                 delta_soc = di->sum_suspend_cap / (di->fcc / 100);
3328                 temp_dsoc = di->dsoc - di->rsoc;
3329
3330                 pr_info("battery calib1: rsoc=%d, dsoc=%d, intsoc=%d\n",
3331                         di->rsoc, di->dsoc, delta_soc);
3332
3333                 if ((di->est_ocv_vol > SLP_DSOC_VOL_THRESD) &&
3334                     (temp_dsoc > delta_soc))
3335                         di->dsoc -= delta_soc;
3336                 else
3337                         di->dsoc = di->rsoc;
3338
3339                 DBG("%s: dsoc > rsoc, sum_cap=%d==>delta_soc=%d,temp_dsoc=%d\n",
3340                     __func__, di->sum_suspend_cap, delta_soc, temp_dsoc);
3341         }
3342
3343         if (!di->relax_voltage && di->voltage <= power_off_thresd)
3344                 di->dsoc = 0;
3345
3346         if (di->dsoc <= 0)
3347                 di->dsoc = 0;
3348
3349         DBG("<%s>, out: dsoc=%d, rsoc=%d, sum_cap=%d\n",
3350             __func__, di->dsoc, di->rsoc, di->sum_suspend_cap);
3351
3352         return delta_soc;
3353 }
3354
3355 static int rk81x_bat_sleep_chrg(struct rk81x_battery *di)
3356 {
3357         int sleep_soc = 0;
3358         unsigned long sleep_sec;
3359
3360         sleep_sec = di->suspend_time_sum;
3361         if (((di->suspend_charge_current < 800) &&
3362              (di->ac_online == ONLINE)) ||
3363              (di->chrg_status == CHARGE_FINISH)) {
3364                 DBG("<%s>,sleep: ac online current < 800\n", __func__);
3365                 if (sleep_sec > 0) {
3366                         /*default charge current: 1000mA*/
3367                         sleep_soc = SLP_CHRG_CURR * sleep_sec * 100
3368                                                 / 3600 / div(di->fcc);
3369                 }
3370         } else {
3371                 DBG("<%s>, usb charge\n", __func__);
3372         }
3373
3374         return sleep_soc;
3375 }
3376
3377 /*
3378  * only do report when there is a change.
3379  *
3380  * if ((di->dsoc == 0) && (di->fg_drv_mode == FG_NORMAL_MODE)):
3381  * when dsoc == 0, we must do report. But it will generate too much android
3382  * info when we enter test_power mode without battery, so we add a fg_drv_mode
3383  * ajudgement.
3384  */
3385 static void rk81x_bat_power_supply_changed(struct rk81x_battery *di)
3386 {
3387         static u32 old_soc;
3388         static u32 old_ac_status;
3389         static u32 old_usb_status;
3390         static u32 old_charge_status;
3391         bool state_changed;
3392
3393         state_changed = false;
3394         if ((di->dsoc == 0) && (di->fg_drv_mode == FG_NORMAL_MODE))
3395                 state_changed = true;
3396         else if (di->dsoc != old_soc)
3397                 state_changed = true;
3398         else if (di->ac_online != old_ac_status)
3399                 state_changed = true;
3400         else if (di->usb_online != old_usb_status)
3401                 state_changed = true;
3402         else if (old_charge_status != di->psy_status)
3403                 state_changed = true;
3404
3405         if (rk81x_chrg_online(di)) {
3406                 if (di->dsoc == 100)
3407                         di->psy_status = POWER_SUPPLY_STATUS_FULL;
3408                 else
3409                         di->psy_status = POWER_SUPPLY_STATUS_CHARGING;
3410         }
3411
3412         if (state_changed) {
3413                 power_supply_changed(&di->bat);
3414                 power_supply_changed(&di->usb);
3415                 power_supply_changed(&di->ac);
3416                 old_soc = di->dsoc;
3417                 old_ac_status = di->ac_online;
3418                 old_usb_status = di->usb_online;
3419                 old_charge_status = di->psy_status;
3420                 dev_info(di->dev, "changed: dsoc=%d, rsoc=%d\n",
3421                          di->dsoc, di->rsoc);
3422         }
3423 }
3424
3425 #if 0
3426 static u8 rk81x_bat_get_cvcc_chrg_hour(struct rk81x_battery *di)
3427 {
3428         u8 hour, buf;
3429
3430         rk81x_bat_read(di, CHRG_CTRL_REG2, &buf, 1);
3431         hour = buf & 0x07;
3432
3433         return CHRG_CVCC_HOUR[hour];
3434 }
3435
3436 /* we have to estimate the charging finish time from now, to decide
3437  * whether we should reset the timer or not.
3438  */
3439 static void rk81x_bat_chrg_over_time_check(struct rk81x_battery *di)
3440 {
3441         u8 cvcc_hour;
3442         int remain_capacity;
3443
3444         cvcc_hour = rk81x_bat_get_cvcc_chrg_hour(di);
3445         if (di->dsoc < di->rsoc)
3446                 remain_capacity = di->dsoc * di->fcc / 100;
3447         else
3448                 remain_capacity = di->remain_capacity;
3449
3450         DBG("CHRG_TIME(min): %ld, cvcc hour: %d",
3451             BASE_TO_MIN(di->plug_in_base), cvcc_hour);
3452
3453         if (BASE_TO_MIN(di->plug_in_base) >= (cvcc_hour - 2) * 60) {
3454                 di->chrg_cap2full = di->fcc - remain_capacity;
3455                 if (di->current_avg <= 0)
3456                         di->current_avg = 1;
3457
3458                 di->chrg_time2full = di->chrg_cap2full * 3600 /
3459                                         div(abs(di->current_avg));
3460
3461                 DBG("CHRG_TIME2FULL(min):%d, chrg_cap2full=%d, current=%d\n",
3462                     SEC_TO_MIN(di->chrg_time2full), di->chrg_cap2full,
3463                     di->current_avg);
3464
3465                 if (SEC_TO_MIN(di->chrg_time2full) > 60) {
3466                         /*rk81x_bat_init_chrg_timer(di);*/
3467                         di->plug_in_base = get_runtime_sec();
3468                         DBG("%s: reset charge timer\n", __func__);
3469                 }
3470         }
3471 }
3472 #endif
3473
3474 /*
3475  * in case that we will do reboot stress test, we need a special way
3476  * to ajust the dsoc.
3477  */
3478 static void rk81x_bat_check_reboot(struct rk81x_battery *di)
3479 {
3480         u8 rsoc = di->rsoc;
3481         u8 dsoc = di->dsoc;
3482         u8 cnt;
3483         int unit_time;
3484         int smooth_time;
3485
3486         rk81x_bat_read(di, REBOOT_CNT_REG, &cnt, 1);
3487         cnt++;
3488
3489         unit_time = di->fcc * 3600 / 100 / 1200;/*1200mA default*/
3490         smooth_time = cnt * BASE_TO_SEC(di->power_on_base);
3491
3492         DBG("%s: cnt:%d, unit:%d, sm:%d, sec:%lu, dsoc:%d, rsoc:%d\n",
3493             __func__, cnt, unit_time, smooth_time,
3494             BASE_TO_SEC(di->power_on_base), dsoc, rsoc);
3495
3496         if (di->current_avg >= 0 || di->chrg_status == CHARGE_FINISH) {
3497                 DBG("chrg, sm:%d, aim:%d\n", smooth_time, unit_time * 3 / 5);
3498                 if ((dsoc < rsoc - 1) && (smooth_time > unit_time * 3 / 5)) {
3499                         cnt = 0;
3500                         dsoc++;
3501                         if (dsoc >= 100)
3502                                 dsoc = 100;
3503                         rk81x_bat_save_dsoc(di, dsoc);
3504                 }
3505         } else {
3506                 DBG("dischrg, sm:%d, aim:%d\n", smooth_time, unit_time * 3 / 5);
3507                 if ((dsoc > rsoc) && (smooth_time > unit_time * 3 / 5)) {
3508                         cnt = 0;
3509                         dsoc--;
3510                         if (dsoc <= 0)
3511                                 dsoc = 0;
3512                         rk81x_bat_save_dsoc(di, dsoc);
3513                 }
3514         }
3515
3516         rk81x_bat_save_reboot_cnt(di, cnt);
3517 }
3518
3519 static void rk81x_bat_update_calib_param(struct rk81x_battery *di)
3520 {
3521         static u32 old_min;
3522         u32 min;
3523         int current_offset;
3524         uint16_t cal_offset;
3525         u8 pcb_offset = DEF_PCB_OFFSET;
3526
3527         min = BASE_TO_MIN(di->power_on_base);
3528         if ((min % 8) && (old_min != min)) {
3529                 old_min = min;
3530                 rk81x_bat_get_vol_offset(di);
3531                 if (di->pcb_ioffset_updated)
3532                         rk81x_bat_read(di, PCB_IOFFSET_REG, &pcb_offset, 1);
3533
3534                 current_offset = rk81x_bat_get_ioffset(di);
3535                 rk81x_bat_set_cal_offset(di, current_offset + pcb_offset);
3536                 cal_offset = rk81x_bat_get_cal_offset(di);
3537                 if (cal_offset < 0x7ff)
3538                         rk81x_bat_set_cal_offset(di, di->current_offset +
3539                                                  DEF_PCB_OFFSET);
3540                 DBG("<%s>. k=%d, b=%d, cal_offset=%d, i_offset=%d\n",
3541                     __func__, di->voltage_k, di->voltage_b, cal_offset,
3542                     rk81x_bat_get_ioffset(di));
3543         }
3544 }
3545
3546 static void rk81x_bat_update_info(struct rk81x_battery *di)
3547 {
3548         if (di->dsoc > 100)
3549                 di->dsoc = 100;
3550         else if (di->dsoc < 0)
3551                 di->dsoc = 0;
3552
3553         /*
3554          * we need update fcc in continuous charging state, if discharge state
3555          * keep at least 2 hour, we decide not to update fcc, so clear the
3556          * fcc update flag: dod0_status.
3557          */
3558         if (BASE_TO_MIN(di->plug_out_base) > 120)
3559                 di->dod0_status = 0;
3560
3561         di->voltage  = rk81x_bat_get_vol(di);
3562         di->current_avg = rk81x_bat_get_avg_current(di);
3563         di->chrg_status = rk81x_bat_get_chrg_status(di);
3564         di->relax_voltage = rk81x_bat_get_relax_vol(di);
3565         di->est_ocv_vol = rk81x_bat_est_ocv_vol(di);
3566         di->est_ocv_soc = rk81x_bat_est_ocv_soc(di);
3567         /*rk81x_bat_chrg_over_time_check(di);*/
3568         rk81x_bat_update_calib_param(di);
3569         if (di->chrg_status == CC_OR_CV)
3570                 di->enter_finish = true;
3571
3572         if (!rk81x_chrg_online(di) && di->s2r)
3573                 return;
3574
3575         di->remain_capacity = rk81x_bat_get_realtime_capacity(di);
3576         if (di->remain_capacity > di->fcc) {
3577                 rk81x_bat_capacity_init(di, di->fcc);
3578                 rk81x_bat_capacity_init_post(di);
3579                 di->remain_capacity = di->fcc;
3580         }
3581
3582         di->rsoc = rk81x_bat_get_rsoc(di);
3583 }
3584
3585 static int rk81x_bat_update_resume_state(struct rk81x_battery *di)
3586 {
3587         if (di->slp_psy_status)
3588                 return rk81x_bat_sleep_chrg(di);
3589         else
3590                 return rk81x_bat_sleep_dischrg(di);
3591 }
3592
3593 static void rk81x_bat_fcc_flag_check(struct rk81x_battery *di)
3594 {
3595         u8 ocv_soc, soc_level;
3596         int relax_vol = di->relax_voltage;
3597
3598         if (relax_vol <= 0)
3599                 return;
3600
3601         ocv_soc = rk81x_bat_vol_to_capacity(di, relax_vol);
3602         DBG("<%s>. ocv_soc=%d, min=%lu, vol=%d\n", __func__,
3603             ocv_soc, SEC_TO_MIN(di->suspend_time_sum), relax_vol);
3604
3605         if ((SEC_TO_MIN(di->suspend_time_sum) > 30) &&
3606             (di->dod0_status == 0) &&
3607             (ocv_soc <= 10)) {
3608                 di->dod0_voltage = relax_vol;
3609                 di->dod0_capacity = di->temp_nac;
3610                 di->adjust_cap = 0;
3611                 di->dod0 = ocv_soc;
3612
3613                 if (ocv_soc <= 1)
3614                         di->dod0_level = 100;
3615                 else if (ocv_soc < 5)
3616                         di->dod0_level = 90;
3617                 else
3618                         di->dod0_level = 80;
3619
3620                 /* save_soc = di->dod0_level; */
3621                 soc_level = rk81x_bat_get_level(di);
3622                 if (soc_level >  di->dod0_level) {
3623                         di->dod0_status = 0;
3624                 } else {
3625                         di->dod0_status = 1;
3626                         /*time start*/
3627                         di->fcc_update_sec = get_runtime_sec();
3628                 }
3629
3630                 dev_info(di->dev, "resume: relax_vol:%d, dod0_cap:%d\n"
3631                          "dod0:%d, soc_level:%d: dod0_status:%d\n"
3632                          "dod0_level:%d",
3633                          di->dod0_voltage, di->dod0_capacity,
3634                          ocv_soc, soc_level, di->dod0_status,
3635                          di->dod0_level);
3636         }
3637 }
3638
3639 static void rk81x_chrg_term_mode_set(struct rk81x_battery *di, int mode)
3640 {
3641         u8 buf;
3642         u8 mask = 0x20;
3643
3644         rk81x_bat_read(di, CHRG_CTRL_REG3, &buf, 1);
3645         buf &= ~mask;
3646         buf |= mode;
3647         rk81x_bat_write(di, CHRG_CTRL_REG3, &buf, 1);
3648
3649         dev_info(di->dev, "set charge to %s termination mode\n",
3650                  mode ? "digital" : "analog");
3651 }
3652
3653 static void rk81x_chrg_term_mode_switch_work(struct work_struct *work)
3654 {
3655         struct rk81x_battery *di;
3656
3657         di = container_of(work, struct rk81x_battery,
3658                           chrg_term_mode_switch_work.work);
3659
3660         if (rk81x_chrg_online(di))
3661                 rk81x_chrg_term_mode_set(di, CHRG_TERM_DIG_SIGNAL);
3662         else
3663                 rk81x_chrg_term_mode_set(di, CHRG_TERM_ANA_SIGNAL);
3664 }
3665
3666 static void rk81x_battery_work(struct work_struct *work)
3667 {
3668         struct rk81x_battery *di;
3669         int ms = TIMER_MS_COUNTS;
3670
3671         di = container_of(work, struct rk81x_battery,
3672                           battery_monitor_work.work);
3673         if (rk81x_chrg_online(di)) {
3674                 rk81x_bat_wait_finish_sig(di);
3675                 /*rk81x_bat_chrg_finish_routine(di);*/
3676         }
3677         rk81x_bat_fcc_flag_check(di);
3678         rk81x_bat_arbitrate_rsoc_trend(di);
3679         rk81x_bat_display_smooth(di);
3680         rk81x_bat_update_time(di);
3681         rk81x_bat_update_info(di);
3682         rk81x_bat_rsoc_check(di);
3683         rk81x_bat_power_supply_changed(di);
3684         rk81x_bat_save_dsoc(di, di->dsoc);
3685         rk81x_bat_save_remain_capacity(di, di->remain_capacity);
3686
3687         rk81x_bat_dbg_dmp_info(di);
3688
3689         if (!di->early_resume && di->s2r && !di->slp_psy_status)
3690                 ms = 30 * TIMER_MS_COUNTS;
3691         else
3692                 di->early_resume = 0;
3693
3694         di->s2r = 0;
3695
3696         queue_delayed_work(di->wq, &di->battery_monitor_work,
3697                            msecs_to_jiffies(ms));
3698 }
3699
3700 #if defined(CONFIG_ARCH_ROCKCHIP)
3701 static void rk81x_battery_otg_delay_work(struct work_struct *work)
3702 {
3703         struct rk81x_battery *di = container_of(work,
3704                         struct rk81x_battery, otg_check_work.work);
3705
3706         enum bc_port_type event = di->charge_otg;
3707
3708         /* do not touch CHRG_CTRL_REG1[7]: CHRG_EN, hardware can
3709          * recognize otg plugin and will auto ajust this bit
3710          */
3711         switch (event) {
3712         case USB_OTG_POWER_ON:
3713                 dev_info(di->dev, "charge disable, otg enable\n");
3714                 di->otg_online = ONLINE;
3715                 /*rk81x_bat_set_charger_param(di, NO_CHARGER);*/
3716                 rk81x_bat_set_bit(di, NT_STS_MSK_REG2, PLUG_IN_INT);
3717                 rk81x_bat_set_bit(di, NT_STS_MSK_REG2, PLUG_OUT_INT);
3718                 rk818_set_bits(di->rk818, DCDC_EN_REG, OTG_EN_MASK, OTG_EN);
3719                 break;
3720
3721         case USB_OTG_POWER_OFF:
3722                 dev_info(di->dev, "charge enable, otg disable\n");
3723                 di->otg_online = OFFLINE;
3724                 rk81x_bat_clr_bit(di, NT_STS_MSK_REG2, PLUG_IN_INT);
3725                 rk81x_bat_clr_bit(di, NT_STS_MSK_REG2, PLUG_OUT_INT);
3726                 rk818_set_bits(di->rk818, DCDC_EN_REG, OTG_EN_MASK, OTG_DIS);
3727                 /*maybe dc still plugin*/
3728                 queue_delayed_work(di->wq, &di->dc_det_check_work,
3729                                    msecs_to_jiffies(10));
3730                 break;
3731
3732         default:
3733                 break;
3734         }
3735 }
3736
3737 static BLOCKING_NOTIFIER_HEAD(battery_chain_head);
3738
3739 int register_battery_notifier(struct notifier_block *nb)
3740 {
3741         return blocking_notifier_chain_register(&battery_chain_head, nb);
3742 }
3743 EXPORT_SYMBOL_GPL(register_battery_notifier);
3744
3745 int unregister_battery_notifier(struct notifier_block *nb)
3746 {
3747         return blocking_notifier_chain_unregister(&battery_chain_head, nb);
3748 }
3749 EXPORT_SYMBOL_GPL(unregister_battery_notifier);
3750
3751 int battery_notifier_call_chain(unsigned long val)
3752 {
3753         return (blocking_notifier_call_chain(&battery_chain_head, val, NULL)
3754                 == NOTIFY_BAD) ? -EINVAL : 0;
3755 }
3756 EXPORT_SYMBOL_GPL(battery_notifier_call_chain);
3757
3758 static int rk81x_bat_usb_notifier_call(struct notifier_block *nb,
3759                                        unsigned long event, void *data)
3760 {
3761         enum charger_type charger_type;
3762         struct rk81x_battery *di =
3763             container_of(nb, struct rk81x_battery, battery_nb);
3764
3765         if (di->fg_drv_mode == TEST_POWER_MODE)
3766                 return NOTIFY_OK;
3767
3768         /*if dc is pluging, ignore usb*/
3769         charger_type = rk81x_bat_get_dc_state(di);
3770         if ((charger_type == DC_CHARGER) &&
3771             (event != USB_OTG_POWER_OFF) &&
3772             (event != USB_OTG_POWER_ON))
3773                 return NOTIFY_OK;
3774
3775         switch (event) {
3776         case USB_BC_TYPE_DISCNT:/*maybe dc still plugin*/
3777                 queue_delayed_work(di->wq, &di->dc_det_check_work,
3778                                    msecs_to_jiffies(10));
3779                 break;
3780         case USB_BC_TYPE_SDP:
3781         case USB_BC_TYPE_CDP:/*nonstandard charger*/
3782         case USB_BC_TYPE_DCP:/*standard charger*/
3783                 queue_delayed_work(di->wq, &di->ac_usb_check_work,
3784                                    msecs_to_jiffies(10));
3785                 break;
3786         case USB_OTG_POWER_ON:/*otg on*/
3787                 di->charge_otg  = USB_OTG_POWER_ON;
3788                 queue_delayed_work(di->wq, &di->otg_check_work,
3789                                    msecs_to_jiffies(10));
3790                 break;
3791         case USB_OTG_POWER_OFF:/*otg off*/
3792                 di->charge_otg = USB_OTG_POWER_OFF;
3793                 queue_delayed_work(di->wq, &di->otg_check_work,
3794                                    msecs_to_jiffies(10));
3795                 break;
3796         default:
3797                 return NOTIFY_OK;
3798         }
3799         return NOTIFY_OK;
3800 }
3801 #endif
3802 static irqreturn_t rk81x_vbat_lo_irq(int irq, void *bat)
3803 {
3804         pr_info("\n------- %s:lower power warning!\n", __func__);
3805
3806         rk_send_wakeup_key();
3807         kernel_power_off();
3808         return IRQ_HANDLED;
3809 }
3810
3811 static irqreturn_t rk81x_vbat_plug_in(int irq, void *bat)
3812 {
3813         pr_info("\n------- %s:irq = %d\n", __func__, irq);
3814         rk_send_wakeup_key();
3815         return IRQ_HANDLED;
3816 }
3817
3818 static irqreturn_t rk81x_vbat_plug_out(int irq, void  *bat)
3819 {
3820         pr_info("\n-------- %s:irq = %d\n", __func__, irq);
3821         rk_send_wakeup_key();
3822         return IRQ_HANDLED;
3823 }
3824
3825 static irqreturn_t rk81x_vbat_charge_ok(int irq, void  *bat)
3826 {
3827         struct rk81x_battery *di = (struct rk81x_battery *)bat;
3828
3829         pr_info("\n---------- %s:irq = %d\n", __func__, irq);
3830         di->finish_sig_base = get_runtime_sec();
3831         rk_send_wakeup_key();
3832         return IRQ_HANDLED;
3833 }
3834
3835 static irqreturn_t rk81x_vbat_dc_det(int irq, void *bat)
3836 {
3837         struct rk81x_battery *di = (struct rk81x_battery *)bat;
3838
3839         queue_delayed_work(di->wq,
3840                            &di->dc_det_check_work,
3841                            msecs_to_jiffies(10));
3842         rk_send_wakeup_key();
3843
3844         return IRQ_HANDLED;
3845 }
3846
3847 static int rk81x_bat_sysfs_init(struct rk81x_battery *di)
3848 {
3849         int ret;
3850         int i;
3851
3852         for (i = 0; i < ARRAY_SIZE(rk818_bat_attr); i++) {
3853                 ret = sysfs_create_file(&di->bat.dev->kobj,
3854                                         &rk818_bat_attr[i].attr);
3855                 if (ret != 0)
3856                         dev_err(di->dev, "create battery node(%s) error\n",
3857                                 rk818_bat_attr[i].attr.name);
3858         }
3859
3860         return ret;
3861 }
3862
3863 static void rk81x_bat_irq_init(struct rk81x_battery *di)
3864 {
3865         int plug_in_irq, plug_out_irq, chrg_ok_irq, vb_lo_irq;
3866         int ret;
3867         struct rk818 *chip = di->rk818;
3868
3869 #if defined(CONFIG_X86_INTEL_SOFIA)
3870         vb_lo_irq = chip->irq_base + RK818_IRQ_VB_LO;
3871         chrg_ok_irq = chip->irq_base + RK818_IRQ_CHG_OK;
3872         plug_in_irq = chip->irq_base + RK818_IRQ_PLUG_IN;
3873         plug_out_irq = chip->irq_base + RK818_IRQ_PLUG_OUT;
3874 #else
3875         vb_lo_irq = irq_create_mapping(chip->irq_domain, RK818_IRQ_VB_LO);
3876         plug_in_irq = irq_create_mapping(chip->irq_domain, RK818_IRQ_PLUG_IN);
3877         plug_out_irq = irq_create_mapping(chip->irq_domain, RK818_IRQ_PLUG_OUT);
3878         chrg_ok_irq = irq_create_mapping(chip->irq_domain, RK818_IRQ_CHG_OK);
3879 #endif
3880
3881         ret = request_threaded_irq(vb_lo_irq, NULL, rk81x_vbat_lo_irq,
3882                                    IRQF_TRIGGER_HIGH, "rk818_vbatlow", di);
3883         if (ret != 0)
3884                 dev_err(chip->dev, "vb_lo_irq request failed!\n");
3885
3886         di->irq = vb_lo_irq;
3887         enable_irq_wake(di->irq);
3888
3889         ret = request_threaded_irq(plug_in_irq, NULL, rk81x_vbat_plug_in,
3890                                    IRQF_TRIGGER_RISING, "rk81x_vbat_plug_in",
3891                                    di);
3892         if (ret != 0)
3893                 dev_err(chip->dev, "plug_in_irq request failed!\n");
3894
3895         ret = request_threaded_irq(plug_out_irq, NULL, rk81x_vbat_plug_out,
3896                                    IRQF_TRIGGER_FALLING, "rk81x_vbat_plug_out",
3897                                    di);
3898         if (ret != 0)
3899                 dev_err(chip->dev, "plug_out_irq request failed!\n");
3900
3901         ret = request_threaded_irq(chrg_ok_irq, NULL, rk81x_vbat_charge_ok,
3902                                    IRQF_TRIGGER_RISING, "rk81x_vbat_charge_ok",
3903                                    di);
3904         if (ret != 0)
3905                 dev_err(chip->dev, "chrg_ok_irq request failed!\n");
3906 }
3907
3908 static void rk81x_bat_info_init(struct rk81x_battery *di,
3909                                 struct rk818 *chip)
3910 {
3911         u8 val;
3912         unsigned long time_base = get_runtime_sec();
3913
3914         rk81x_bat_read(di, RK818_VB_MON_REG, &val, 1);
3915         if (val & PLUG_IN_STS)
3916                 rk81x_bat_set_power_supply_state(di, USB_CHARGER);
3917
3918         di->cell.config = di->pdata->cell_cfg;
3919         di->design_capacity = di->pdata->cell_cfg->design_capacity;
3920         di->qmax = di->pdata->cell_cfg->design_qmax;
3921         di->early_resume = 1;
3922         di->psy_status = POWER_SUPPLY_STATUS_DISCHARGING;
3923         di->bat_res = di->pdata->sense_resistor_mohm;
3924         di->dischrg_algorithm_mode = DISCHRG_NORMAL_MODE;
3925         di->last_zero_mode_dsoc = DEF_LAST_ZERO_MODE_SOC;
3926         di->slp_chrg_status = rk81x_bat_get_chrg_status(di);
3927         di->loader_charged = loader_charged;
3928         di->chrg_finish_base = time_base;
3929         di->power_on_base = time_base;
3930         di->plug_in_base = time_base;
3931         di->plug_out_base = time_base;
3932         di->finish_sig_base = time_base;
3933         di->fcc = rk81x_bat_get_fcc(di);
3934 }
3935
3936 static void rk81x_bat_dc_det_init(struct rk81x_battery *di,
3937                                   struct device_node *np)
3938 {
3939         struct device *dev = di->dev;
3940         enum of_gpio_flags flags;
3941         int ret;
3942
3943         di->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio", 0, &flags);
3944         if (di->dc_det_pin == -EPROBE_DEFER) {
3945                 dev_err(dev, "dc_det_gpio error\n");
3946                 return;
3947         }
3948
3949         if (gpio_is_valid(di->dc_det_pin)) {
3950                 di->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW) ?
3951                                                 RK818_DC_IN : RK818_DC_OUT;
3952                 di->dc_det_irq = gpio_to_irq(di->dc_det_pin);
3953
3954                 ret = request_irq(di->dc_det_irq, rk81x_vbat_dc_det,
3955                                   IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
3956                                   "rk81x_dc_det", di);
3957                 if (ret != 0) {
3958                         dev_err(di->dev, "rk818_dc_det_irq request failed!\n");
3959                         goto err;
3960                 }
3961                 enable_irq_wake(di->dc_det_irq);
3962         }
3963
3964         return;
3965 err:
3966         gpio_free(di->dc_det_pin);
3967 }
3968
3969 static int rk81x_bat_get_suspend_sec(struct rk81x_battery *di)
3970 {
3971         int err;
3972         int delta_sec = 0;
3973         struct rtc_time tm;
3974         struct timespec tv = {
3975                 .tv_nsec = NSEC_PER_SEC >> 1,
3976         };
3977         struct rtc_device *rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
3978
3979         err = rtc_read_time(rtc, &tm);
3980         if (err) {
3981                 dev_err(rtc->dev.parent,
3982                         "hctosys: unable to read the hardware clock\n");
3983                 goto out;
3984         }
3985         err = rtc_valid_tm(&tm);
3986         if (err) {
3987                 dev_err(rtc->dev.parent,
3988                         "hctosys: invalid date/time\n");
3989                 goto out;
3990         }
3991
3992         rtc_tm_to_time(&tm, &tv.tv_sec);
3993         delta_sec = tv.tv_sec - di->suspend_rtc_base.tv_sec;
3994 out:
3995         return (delta_sec > 0) ? delta_sec : 0;
3996 }
3997
3998 #ifdef CONFIG_OF
3999 static int rk81x_bat_parse_dt(struct rk81x_battery *di)
4000 {
4001         struct device_node *np;
4002         struct battery_platform_data *pdata;
4003         struct cell_config *cell_cfg;
4004         struct ocv_config *ocv_cfg;
4005         struct property *prop;
4006         struct rk818 *rk818 = di->rk818;
4007         struct device *dev = di->dev;
4008         u32 out_value;
4009         int length, ret;
4010         size_t size;
4011
4012         np = of_find_node_by_name(rk818->dev->of_node, "battery");
4013         if (!np) {
4014                 dev_err(dev, "battery node not found!\n");
4015                 return -EINVAL;
4016         }
4017
4018         pdata = devm_kzalloc(rk818->dev, sizeof(*pdata), GFP_KERNEL);
4019         if (!pdata)
4020                 return -ENOMEM;
4021
4022         cell_cfg = devm_kzalloc(rk818->dev, sizeof(*cell_cfg), GFP_KERNEL);
4023         if (!cell_cfg)
4024                 return -ENOMEM;
4025
4026         ocv_cfg = devm_kzalloc(rk818->dev, sizeof(*ocv_cfg), GFP_KERNEL);
4027         if (!ocv_cfg)
4028                 return -ENOMEM;
4029
4030         prop = of_find_property(np, "ocv_table", &length);
4031         if (!prop) {
4032                 dev_err(dev, "ocv_table not found!\n");
4033                 return -EINVAL;
4034         }
4035         pdata->ocv_size = length / sizeof(u32);
4036         if (pdata->ocv_size <= 0) {
4037                 dev_err(dev, "invalid ocv table\n");
4038                 return -EINVAL;
4039         }
4040
4041         size = sizeof(*pdata->battery_ocv) * pdata->ocv_size;
4042
4043         pdata->battery_ocv = devm_kzalloc(rk818->dev, size, GFP_KERNEL);
4044         if (!pdata->battery_ocv)
4045                 return -ENOMEM;
4046
4047         ret = of_property_read_u32_array(np, "ocv_table", pdata->battery_ocv,
4048                                          pdata->ocv_size);
4049         if (ret < 0)
4050                 return ret;
4051
4052         /******************** charger param  ****************************/
4053         ret = of_property_read_u32(np, "max_chrg_currentmA", &out_value);
4054         if (ret < 0) {
4055                 dev_err(dev, "max_chrg_currentmA not found!\n");
4056                 out_value = DEFAULT_CHRG_CUR;
4057         }
4058         pdata->max_charger_currentmA = out_value;
4059
4060         ret = of_property_read_u32(np, "max_input_currentmA", &out_value);
4061         if (ret < 0) {
4062                 dev_err(dev, "max_charger_ilimitmA not found!\n");
4063                 out_value = DEFAULT_INPUT_CUR;
4064         }
4065         pdata->max_charger_ilimitmA = out_value;
4066
4067         ret = of_property_read_u32(np, "bat_res", &out_value);
4068         if (ret < 0) {
4069                 dev_err(dev, "bat_res not found!\n");
4070                 out_value = DEFAULT_BAT_RES;
4071         }
4072         pdata->sense_resistor_mohm = out_value;
4073
4074         ret = of_property_read_u32(np, "max_charge_voltagemV", &out_value);
4075         if (ret < 0) {
4076                 dev_err(dev, "max_charge_voltagemV not found!\n");
4077                 out_value = DEFAULT_CHRG_VOL;
4078         }
4079         pdata->max_charger_voltagemV = out_value;
4080
4081         ret = of_property_read_u32(np, "design_capacity", &out_value);
4082         if (ret < 0) {
4083                 dev_err(dev, "design_capacity not found!\n");
4084                 return ret;
4085         }
4086         cell_cfg->design_capacity  = out_value;
4087
4088         ret = of_property_read_u32(np, "design_qmax", &out_value);
4089         if (ret < 0) {
4090                 dev_err(dev, "design_qmax not found!\n");
4091                 return ret;
4092         }
4093         cell_cfg->design_qmax = out_value;
4094
4095         ret = of_property_read_u32(np, "sleep_enter_current", &out_value);
4096         if (ret < 0) {
4097                 dev_err(dev, "sleep_enter_current not found!\n");
4098                 out_value = DEFAULT_SLP_ENTER_CUR;
4099         }
4100         ocv_cfg->sleep_enter_current = out_value;
4101
4102         ret = of_property_read_u32(np, "sleep_exit_current", &out_value);
4103         if (ret < 0) {
4104                 dev_err(dev, "sleep_exit_current not found!\n");
4105                 out_value = DEFAULT_SLP_EXIT_CUR;
4106         }
4107         ocv_cfg->sleep_exit_current = out_value;
4108
4109         ret = of_property_read_u32(np, "power_off_thresd", &out_value);
4110         if (ret < 0) {
4111                 dev_warn(dev, "power_off_thresd not found!\n");
4112                 out_value = PWR_OFF_THRESD;
4113         }
4114         pdata->power_off_thresd = out_value;
4115
4116         of_property_read_u32(np, "chrg_diff_voltagemV", &pdata->chrg_diff_vol);
4117         of_property_read_u32(np, "virtual_power", &di->fg_drv_mode);
4118         di->fg_drv_mode = di->fg_drv_mode ? TEST_POWER_MODE : FG_NORMAL_MODE;
4119
4120         /*************  charger support adp types **********************/
4121         ret = of_property_read_u32(np, "support_usb_adp", &support_usb_adp);
4122         ret = of_property_read_u32(np, "support_dc_adp", &support_dc_adp);
4123
4124         if (!support_usb_adp && !support_dc_adp) {
4125                 dev_err(dev, "miss both: usb_adp and dc_adp,default:usb_adp!\n");
4126                 support_usb_adp = 1;
4127         }
4128
4129         /*if (support_dc_adp)*/
4130         rk81x_bat_dc_det_init(di, np);
4131
4132         cell_cfg->ocv = ocv_cfg;
4133         pdata->cell_cfg = cell_cfg;
4134         di->pdata = pdata;
4135
4136         DBG("\nthe battery dts info dump:\n"
4137             "bat_res:%d\n"
4138             "max_input_currentmA:%d\n"
4139             "max_chrg_currentmA:%d\n"
4140             "max_charge_voltagemV:%d\n"
4141             "design_capacity:%d\n"
4142             "design_qmax :%d\n"
4143             "sleep_enter_current:%d\n"
4144             "sleep_exit_current:%d\n"
4145             "support_usb_adp:%d\n"
4146             "support_dc_adp:%d\n"
4147             "power_off_thresd:%d\n",
4148             pdata->sense_resistor_mohm, pdata->max_charger_ilimitmA,
4149             pdata->max_charger_currentmA, pdata->max_charger_voltagemV,
4150             cell_cfg->design_capacity, cell_cfg->design_qmax,
4151             cell_cfg->ocv->sleep_enter_current,
4152             cell_cfg->ocv->sleep_exit_current,
4153             support_usb_adp, support_dc_adp, pdata->power_off_thresd);
4154
4155         return 0;
4156 }
4157
4158 #else
4159 static int rk81x_bat_parse_dt(struct rk81x_battery *di)
4160 {
4161         return -ENODEV;
4162 }
4163 #endif
4164
4165 static int rk81x_battery_probe(struct platform_device *pdev)
4166 {
4167         struct rk818 *chip = dev_get_drvdata(pdev->dev.parent);
4168         struct rk81x_battery *di;
4169         int ret;
4170
4171         di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
4172         if (!di)
4173                 return -ENOMEM;
4174         di->rk818 = chip;
4175         di->dev = &pdev->dev;
4176         platform_set_drvdata(pdev, di);
4177
4178         ret = rk81x_bat_parse_dt(di);
4179         if (ret < 0) {
4180                 dev_err(&pdev->dev, "rk81x battery parse dt failed!\n");
4181                 return ret;
4182         }
4183
4184         rk81x_bat_info_init(di, chip);
4185         if (!is_rk81x_bat_exist(di)) {
4186                 dev_info(di->dev, "not battery, enter test power mode\n");
4187                 di->fg_drv_mode = TEST_POWER_MODE;
4188         }
4189
4190         ret = rk81x_bat_power_supply_init(di);
4191         if (ret) {
4192                 dev_err(&pdev->dev, "rk81x power supply register failed!\n");
4193                 return ret;
4194         }
4195
4196         rk81x_bat_irq_init(di);
4197         rk81x_bat_sysfs_init(di);
4198
4199         rk81x_bat_fg_init(di);
4200         wake_lock_init(&di->resume_wake_lock, WAKE_LOCK_SUSPEND,
4201                        "resume_charging");
4202         rk81x_bat_flatzone_vol_init(di);
4203
4204 #if defined(CONFIG_X86_INTEL_SOFIA)
4205         di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
4206         if (IS_ERR_OR_NULL(di->usb_phy)) {
4207                 dev_err(di->dev, "get usb phy failed\n");
4208                 return PTR_ERR(di->usb_phy);
4209         }
4210         di->usb_nb.notifier_call = rk81x_battery_usb_notifier;
4211         ret = usb_register_notifier(di->usb_phy, &di->usb_nb);
4212         if (ret)
4213                 dev_err(di->dev, "registr usb phy notification failed\n");
4214         INIT_DELAYED_WORK(&di->usb_phy_delay_work,
4215                           rk81x_battery_usb_notifier_delayed_work);
4216 #endif
4217
4218         rk81x_battery_register_fb_notify(di);
4219         di->wq = alloc_ordered_workqueue("%s", WQ_MEM_RECLAIM | WQ_FREEZABLE,
4220                                          "rk81x-battery-work");
4221         INIT_DELAYED_WORK(&di->battery_monitor_work, rk81x_battery_work);
4222         INIT_DELAYED_WORK(&di->chrg_term_mode_switch_work,
4223                           rk81x_chrg_term_mode_switch_work);
4224
4225         queue_delayed_work(di->wq, &di->battery_monitor_work,
4226                            msecs_to_jiffies(TIMER_MS_COUNTS * 5));
4227
4228 #if defined(CONFIG_ARCH_ROCKCHIP)
4229         INIT_DELAYED_WORK(&di->otg_check_work,
4230                           rk81x_battery_otg_delay_work);
4231         INIT_DELAYED_WORK(&di->ac_usb_check_work,
4232                           rk81x_battery_acusb_delay_work);
4233         INIT_DELAYED_WORK(&di->dc_det_check_work,
4234                           rk81x_battery_dc_delay_work);
4235         /*power on check*/
4236         queue_delayed_work(di->wq, &di->dc_det_check_work,
4237                            msecs_to_jiffies(TIMER_MS_COUNTS * 5));
4238
4239         di->battery_nb.notifier_call = rk81x_bat_usb_notifier_call;
4240         rk_bc_detect_notifier_register(&di->battery_nb, &di->charge_otg);
4241 #endif
4242         dev_info(di->dev, "battery driver version %s\n", DRIVER_VERSION);
4243
4244         return ret;
4245 }
4246
4247 static int rk81x_battery_suspend(struct platform_device *dev,
4248                                  pm_message_t state)
4249 {
4250         struct rk81x_battery *di = platform_get_drvdata(dev);
4251
4252         /*while otg and dc both plugin*/
4253         rk81x_bat_set_bit(di, NT_STS_MSK_REG2, CHRG_CVTLMT_INT);
4254
4255         di->slp_psy_status = rk81x_chrg_online(di);
4256         di->chrg_status = rk81x_bat_get_chrg_status(di);
4257         di->slp_chrg_status = rk81x_bat_get_chrg_status(di);
4258         di->suspend_charge_current = rk81x_bat_get_avg_current(di);
4259         di->dischrg_save_sec += rk81x_bat_save_dischrg_sec(di);
4260         di->dischrg_normal_base = 0;
4261         di->dischrg_emu_base = 0;
4262         do_gettimeofday(&di->suspend_rtc_base);
4263
4264         if (!rk81x_chrg_online(di)) {
4265                 di->chrg_save_sec += rk81x_bat_save_chrg_sec(di);
4266                 di->chrg_normal_base = 0;
4267                 di->chrg_emu_base = 0;
4268                 di->chrg_term_base = 0;
4269                 di->chrg_finish_base = 0;
4270         }
4271
4272         di->s2r = 0;
4273
4274         pr_info("battery suspend dl=%d rl=%d c=%d v=%d at=%ld st=0x%x chg=%d\n",
4275                 di->dsoc, di->rsoc, di->suspend_charge_current, di->voltage,
4276                 di->suspend_time_sum, di->chrg_status, di->slp_psy_status);
4277
4278         return 0;
4279 }
4280
4281 static int rk81x_battery_resume(struct platform_device *dev)
4282 {
4283         struct rk81x_battery *di = platform_get_drvdata(dev);
4284         int pwroff_thresd = di->pdata->power_off_thresd;
4285         int delta_time;
4286         int time_step;
4287         int delta_soc;
4288         int vol;
4289
4290         /*while otg and dc both plugin*/
4291         rk81x_bat_clr_bit(di, NT_STS_MSK_REG2, CHRG_CVTLMT_INT);
4292
4293         di->discharge_smooth_status = true;
4294         di->charge_smooth_status = true;
4295         di->s2r = 1;
4296         vol  = rk81x_bat_get_vol(di);
4297         if (vol < INVALID_VOL_THRESD) {
4298                 dev_err(di->dev, "invalid voltage :%d", vol);
4299                 vol = di->voltage;
4300                 dbg_enable = 1;
4301         }
4302         di->voltage = vol;
4303         di->current_avg = rk81x_bat_get_avg_current(di);
4304         di->relax_voltage = rk81x_bat_get_relax_vol(di);
4305         di->est_ocv_vol = rk81x_bat_est_ocv_vol(di);
4306         di->est_ocv_soc = rk81x_bat_est_ocv_soc(di);
4307         delta_time = rk81x_bat_get_suspend_sec(di);
4308         di->suspend_time_sum += delta_time;
4309 #if defined(CONFIG_ARCH_ROCKCHIP)
4310         di->remain_capacity = rk81x_bat_get_realtime_capacity(di);
4311 #endif
4312
4313         if (di->slp_psy_status) {
4314                 time_step = CHRG_TIME_STEP;
4315         } else {
4316                 if (di->voltage <= pwroff_thresd + 50)
4317                         time_step = DISCHRG_TIME_STEP_0;
4318                 else
4319                         time_step = DISCHRG_TIME_STEP_1;
4320         }
4321
4322         pr_info("battery resume c=%d v=%d ev=%d rv=%d dt=%d at=%ld chg=%d\n",
4323                 di->current_avg, di->voltage, di->est_ocv_vol,
4324                 di->relax_voltage, delta_time, di->suspend_time_sum,
4325                 di->slp_psy_status);
4326
4327         if (di->suspend_time_sum > time_step) {
4328                 delta_soc = rk81x_bat_update_resume_state(di);
4329                 if (delta_soc)
4330                         di->suspend_time_sum = 0;
4331         }
4332
4333         if ((!rk81x_chrg_online(di) && di->voltage <= pwroff_thresd) ||
4334             rk81x_chrg_online(di))
4335                 wake_lock_timeout(&di->resume_wake_lock, 5 * HZ);
4336         return 0;
4337 }
4338
4339 static int rk81x_battery_remove(struct platform_device *dev)
4340 {
4341         struct rk81x_battery *di = platform_get_drvdata(dev);
4342
4343         cancel_delayed_work_sync(&di->battery_monitor_work);
4344         return 0;
4345 }
4346
4347 static void rk81x_battery_shutdown(struct platform_device *dev)
4348 {
4349         struct rk81x_battery *di = platform_get_drvdata(dev);
4350
4351         cancel_delayed_work_sync(&di->battery_monitor_work);
4352         rk_bc_detect_notifier_unregister(&di->battery_nb);
4353
4354         if (BASE_TO_MIN(di->power_on_base) <= REBOOT_INTER_MIN)
4355                 rk81x_bat_check_reboot(di);
4356         else
4357                 rk81x_bat_save_reboot_cnt(di, 0);
4358         rk81x_chrg_term_mode_set(di, CHRG_TERM_ANA_SIGNAL);
4359 }
4360
4361 static struct platform_driver rk81x_battery_driver = {
4362         .driver     = {
4363                 .name   = "rk818-battery",
4364                 .owner  = THIS_MODULE,
4365         },
4366
4367         .probe      = rk81x_battery_probe,
4368         .remove     = rk81x_battery_remove,
4369         .suspend    = rk81x_battery_suspend,
4370         .resume     = rk81x_battery_resume,
4371         .shutdown   = rk81x_battery_shutdown,
4372 };
4373
4374 static int __init battery_init(void)
4375 {
4376         return platform_driver_register(&rk81x_battery_driver);
4377 }
4378
4379 fs_initcall_sync(battery_init);
4380 static void __exit battery_exit(void)
4381 {
4382         platform_driver_unregister(&rk81x_battery_driver);
4383 }
4384 module_exit(battery_exit);
4385
4386 MODULE_LICENSE("GPL");
4387 MODULE_ALIAS("platform:rk818-battery");
4388 MODULE_AUTHOR("ROCKCHIP");