drivers/power/rk818_battery.c

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