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