drivers/power/rt5025-battery.c

   1 /* drivers/power/rt5025-battery.c
   2  * I2C Driver for Richtek RT5025 PMIC
   3  * Multi function device - multi functional baseband PMIC Battery part
   4  *
   5  *  Copyright (C) 2014 Richtek Technology Corp.
   6  * Author: Nick Hung <nick_hung@richtek.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/delay.h>
  17 #include <linux/err.h>
  18 #include <linux/init.h>
  19 #include <linux/i2c.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/power_supply.h>
  23 #include <linux/slab.h>
  24 #include <linux/wakelock.h>
  25 #include <linux/workqueue.h>
  26 #include <linux/jiffies.h>
  27 #include <linux/timer.h>
  28 #include <linux/alarmtimer.h>
  29 #include <linux/mfd/rt5025.h>
  30 #include <linux/power/rt5025-battery.h>
  31
  32
  33 #define VOLTAGE_ALERT 0
  34 #define TEMPERATURE_ALERT 0
  35
  36 #define RT5025_CSV 0
  37 #define RT5025_B 1
  38 #define RT5025_TEST_WAKE_LOCK 0
  39
  40 u8 irq_thres[LAST_TYPE];
  41
  42 static unsigned char gauge_init_regval[] = {
  43         0xFF, /*REG 0x53*/
  44         0x00, /*REG 0x54*/
  45         0x00, /*REG 0x55*/
  46         0xFF, /*REG 0x56*/
  47         0x00, /*REG 0x57*/
  48 };
  49
  50 static u16 crctab16[256] = {
  51         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  52         0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  53         0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  54         0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  55         0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  56         0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  57         0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  58         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  59         0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  60         0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  61         0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  62         0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  63         0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  64         0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  65         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  66         0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  67         0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  68         0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  69         0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  70         0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  71         0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  72         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  73         0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  74         0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  75         0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  76         0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  77         0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  78         0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  79         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  80         0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  81         0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  82         0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78,
  83 };
  84
  85 static int rt5025_battery_parameter_backup(struct rt5025_battery_info *);
  86 static void rt5025_get_external_temp(struct rt5025_battery_info *);
  87 static void rt5025_get_internal_temp(struct rt5025_battery_info *);
  88 static void rt5025_get_vcell(struct rt5025_battery_info *);
  89 static void rt5025_get_current(struct rt5025_battery_info *);
  90 static void rt5025_temp_comp(struct rt5025_battery_info *);
  91
  92 /* 20140415 CY */
  93 static int rt5025_read_reg(struct i2c_client *client,
  94                                 u8 reg, u8 *data, u8 len)
  95 {
  96         return rt5025_reg_block_read(client, reg, len, data);
  97 }
  98
  99 static int rt5025_write_reg(struct i2c_client *client,
 100                                 u8 reg, u8 *data, u8 len)
 101 {
 102         return rt5025_reg_block_write(client, reg, len, data);
 103 }
 104
 105 static void rt5025_set_battery_led(struct rt5025_battery_info *bi, int status)
 106 {
 107         switch (status) {
 108         case POWER_SUPPLY_STATUS_CHARGING:
 109                 break;
 110         case POWER_SUPPLY_STATUS_DISCHARGING:
 111                 break;
 112         case POWER_SUPPLY_STATUS_FULL:
 113                 break;
 114         default:
 115                 break;
 116         }
 117 }
 118
 119 static int rt5025_set_property(struct power_supply *psy,
 120                                enum power_supply_property psp,
 121                                const union power_supply_propval *val)
 122 {
 123         struct rt5025_battery_info *bi = dev_get_drvdata(psy->dev->parent);
 124         int rc = 0;
 125
 126         switch (psp) {
 127         case POWER_SUPPLY_PROP_STATUS:
 128                 if (val->intval == POWER_SUPPLY_STATUS_FULL) {
 129                                 bi->tp_flag = true;
 130                                 pr_info("%s: Battery is full \n", __func__);
 131                 } else {
 132                                 mutex_lock(&bi->status_change_lock);
 133                                 bi->status = val->intval;
 134                                 if (bi->status == POWER_SUPPLY_STATUS_DISCHARGING)
 135                                         bi->tp_flag = false;
 136                                 rt5025_set_battery_led(bi, bi->status);
 137                                 mutex_unlock(&bi->status_change_lock);
 138                                 }
 139                 wake_lock_timeout(&bi->status_wake_lock, 1.5*HZ);
 140                 schedule_delayed_work(&bi->monitor_work, msecs_to_jiffies(100));
 141                 break;
 142         case POWER_SUPPLY_PROP_PRESENT:
 143                 bi->batt_present = val->intval;
 144                 break;
 145         default:
 146                 rc = -EINVAL;
 147                 break;
 148         }
 149         return rc;
 150 }
 151
 152 static int rt5025_get_property(struct power_supply *psy,
 153                             enum power_supply_property psp,
 154                             union power_supply_propval *val)
 155 {
 156         struct rt5025_battery_info *bi = dev_get_drvdata(psy->dev->parent);
 157
 158         switch (psp) {
 159         case POWER_SUPPLY_PROP_STATUS:
 160                 val->intval = bi->status;
 161                 /*val->intval = POWER_SUPPLY_STATUS_CHARGING;*/
 162                 break;
 163         case POWER_SUPPLY_PROP_HEALTH:
 164                 val->intval = bi->health;
 165                 /*If there's no battery, always show battery health to good.*/
 166                 if (!bi->present || !bi->batt_present)
 167                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
 168                 break;
 169         case POWER_SUPPLY_PROP_PRESENT:
 170                 val->intval = bi->present;
 171                 break;
 172         case POWER_SUPPLY_PROP_TEMP:
 173                 if (val->intval == 23) {
 174                         rt5025_get_external_temp(bi);
 175                         val->intval = bi->ext_temp;
 176                 } else {
 177                         /*If there's no battery, always show battery temperature to 25'c.*/
 178                         if (!bi->present || !bi->batt_present)
 179                                 val->intval = 250;
 180                         else
 181                                 val->intval = bi->ext_temp;
 182                 }
 183                 break;
 184         case POWER_SUPPLY_PROP_TEMP_AMBIENT:
 185                 rt5025_get_internal_temp(bi);
 186                 val->intval = bi->int_temp;
 187                 break;
 188         case POWER_SUPPLY_PROP_ONLINE:
 189                 val->intval = bi->online;
 190                 break;
 191         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 192                 rt5025_get_vcell(bi);
 193                 val->intval = bi->vcell * 1000; /*uv*/
 194                 break;
 195         case POWER_SUPPLY_PROP_CURRENT_NOW:
 196                 rt5025_get_current(bi);
 197                 val->intval = bi->curr * 1000; /*uA*/
 198                 break;
 199         case POWER_SUPPLY_PROP_CAPACITY:
 200                 val->intval = bi->soc;
 201                 if (val->intval > 100)
 202                         val->intval = 100;
 203                 /*If there's no battery, always show capacity to 50*/
 204                 if (!bi->present || !bi->batt_present)
 205                         val->intval = 50;
 206                 break;
 207         case POWER_SUPPLY_PROP_TECHNOLOGY:
 208                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 209                 break;
 210         default:
 211                 return -EINVAL;
 212         }
 213         return 0;
 214 }
 215
 216 static void rt5025_get_vcell(struct rt5025_battery_info *bi)
 217 {
 218         u8 data[2];
 219
 220         if (rt5025_read_reg(bi->client, RT5025_REG_VBATSH, data, 2) < 0)
 221                 pr_err("%s: Failed to read Voltage\n", __func__);
 222
 223         if (bi->avg_flag)
 224                 bi->vcell = ((data[0] << 8) + data[1]) * 61 / 100;
 225         else
 226                 bi->vcell =
 227                     (bi->vcell + ((data[0] << 8) + data[1]) * 61 / 100) / 2;
 228 #if RT5025_B
 229
 230         /*b. Remove current offset compensation; 2013/12/17*/
 231         bi->curr_offset = 0;
 232         /*bi->curr_offset = (15444 * bi->vcell - 27444000) / 10000;*/
 233
 234 #else
 235         if (37 * bi->vcell > 92000)
 236                 bi->curr_offset = (37 * bi->vcell - 92000) / 1000;
 237         else
 238                 bi->curr_offset = 0;
 239 #endif
 240
 241 #if RT5025_CSV
 242         /* if (!bi->avg_flag)*/
 243         /*  pr_info("%d,%d,", bi->vcell, bi->curr_offset);*/
 244 #else
 245         if (bi->avg_flag)
 246                 RTINFO("vcell_pre: %d, offset: %d\n", bi->vcell, bi->curr_offset);
 247         else
 248                 RTINFO("vcell_avg: %d, offset: %d\n", bi->vcell, bi->curr_offset);
 249 #endif
 250 }
 251
 252 static void rt5025_get_current(struct rt5025_battery_info *bi)
 253 {
 254         u8 data[2];
 255         s32 temp;
 256         int sign = 0;
 257         u8 curr_region;
 258
 259         if (rt5025_read_reg(bi->client, RT5025_REG_CURRH, data, 2) < 0)
 260                 pr_err("%s: Failed to read CURRENT\n", __func__);
 261
 262 #if RT5025_B
 263         temp = (data[0] << 8) | data[1];
 264         bi->curr_raw = ((temp & 0x7FFF) * 3125) / 10000;
 265
 266         if (data[0] & (1 << 7)) {
 267                 sign = 1;
 268                 temp = (((temp & 0x7FFF) * 3125) / 10 + bi->curr_offset) / 1000;
 269         } else {
 270                 if ((temp * 3125) / 10 > bi->curr_offset)
 271                         temp = ((temp * 3125) / 10 - bi->curr_offset) / 1000;
 272         }
 273         if (temp < DEADBAND)
 274                 temp = 0;
 275         if (sign) {
 276                 temp *= -1;
 277                 bi->curr_raw *= -1;
 278         }
 279 #else
 280         temp = (data[0] << 8) | data[1];
 281         if (data[0] & (1 << 7)) {
 282                 sign = 1;
 283                 temp = temp & 0x7FFF;
 284                 if (temp > bi->curr_offset)
 285                         temp = temp - bi->curr_offset;
 286         } else {
 287                         temp = temp + bi->curr_offset;
 288         }
 289         temp = (temp * 37375) / 100000; /*Unit: 0.3125mA*/
 290         if (temp < DEADBAND)
 291                 temp = 0;
 292         if (sign)
 293                 temp *= -1;
 294 #endif
 295
 296         if (bi->avg_flag)
 297                 bi->curr = temp;
 298         else
 299                 bi->curr = (bi->curr + temp) / 2;
 300
 301         if (bi->curr > -500)
 302                 curr_region = 0;
 303         else if (bi->curr <= -500 && bi->curr > -1500)
 304                 curr_region = 1;
 305         else
 306                 curr_region = 2;
 307
 308         if (curr_region != bi->edv_region) {
 309                 switch (curr_region) {
 310                 case 0:
 311                         bi->empty_edv = rt5025_battery_param2[4].x;
 312                         break;
 313                 case 1:
 314                         bi->empty_edv = rt5025_battery_param2[4].x - 75;
 315                         break;
 316                 case 2:
 317                         bi->empty_edv = rt5025_battery_param2[4].x - 100;
 318                         break;
 319                 }
 320         bi->edv_region = curr_region;
 321         }
 322         RTINFO("empty_voltage=%d\n", bi->empty_edv);
 323
 324         if (bi->curr > 0) {
 325                 bi->internal_status = POWER_SUPPLY_STATUS_CHARGING;
 326                 bi->last_tp_flag = false;
 327                 /*b. add fcc update flag; 2013/12/18*/
 328                 bi->fcc_update_flag = true;
 329         } else {
 330                 bi->internal_status = POWER_SUPPLY_STATUS_DISCHARGING;
 331         }
 332         RTINFO("current=%d, internal_status=%d\n", bi->curr, bi->internal_status);
 333
 334 #if RT5025_CSV
 335         /*if (!bi->avg_flag)*/
 336         /*pr_info("%d,",bi->curr);*/
 337 #else
 338         if (bi->avg_flag)
 339                 RTINFO("current_pre: %d\n", bi->curr);
 340         else
 341                 RTINFO("current_avg: %d\n", bi->curr);
 342 #endif
 343 }
 344
 345 static void rt5025_get_internal_temp(struct rt5025_battery_info *bi)
 346 {
 347         u8 data[2];
 348         s32 temp;
 349
 350         if (rt5025_read_reg(bi->client, RT5025_REG_INTEMPH, data, 2) < 0)
 351                 pr_err("%s: Failed to read internal TEMPERATURE\n", __func__);
 352
 353         temp = ((data[0] & 0x1F) << 8) + data[1];
 354         temp *= 15625;
 355         temp /= 100000;
 356
 357         temp = (data[0] & 0x20) ? -temp : temp;
 358         bi->int_temp = temp;
 359         RTINFO("internal temperature: %d\n", bi->int_temp);
 360 }
 361
 362 static void rt5025_get_external_temp(struct rt5025_battery_info *bi)
 363 {
 364         u8 data[2];
 365         s32 temp;
 366
 367         if (rt5025_read_reg(bi->client, RT5025_REG_AINH, data, 2) < 0)
 368                 pr_err("%s: Failed to read TEMPERATURE\n", __func__);
 369         bi->ain_volt = (data[0] * 256 + data[1]) * 61 / 100;
 370         if (bi->ain_volt < 1150)
 371                 bi->present = 1;
 372         else
 373                 bi->present = 0;
 374
 375         temp =  (bi->ain_volt * (-91738) + 81521000) / 100000;
 376         bi->ext_temp = (int)temp;
 377         /*test bi->ext_temp = 250;*/
 378
 379         if (bi->ext_temp >= HIGH_TEMP_THRES) {
 380                 if (bi->health != POWER_SUPPLY_HEALTH_OVERHEAT)
 381                         bi->temp_high_cnt++;
 382         } else if (bi->ext_temp <= HIGH_TEMP_RECOVER
 383                    && bi->ext_temp >= LOW_TEMP_RECOVER) {
 384                 if (bi->health == POWER_SUPPLY_HEALTH_OVERHEAT
 385                     || bi->health == POWER_SUPPLY_HEALTH_COLD)
 386                         bi->temp_recover_cnt++;
 387         } else if (bi->ext_temp <= LOW_TEMP_THRES) {
 388                 if (bi->health != POWER_SUPPLY_HEALTH_COLD)
 389                         bi->temp_low_cnt++;
 390         } else {
 391                         bi->temp_high_cnt = 0;
 392                         bi->temp_low_cnt = 0;
 393                         bi->temp_recover_cnt = 0;
 394         }
 395
 396         if (bi->temp_high_cnt >= TEMP_ABNORMAL_COUNT) {
 397                 bi->health = POWER_SUPPLY_HEALTH_OVERHEAT;
 398                 bi->temp_high_cnt = 0;
 399         } else if (bi->temp_low_cnt >= TEMP_ABNORMAL_COUNT) {
 400                 bi->health = POWER_SUPPLY_HEALTH_COLD;
 401                 bi->temp_low_cnt = 0;
 402         } else if (bi->temp_recover_cnt >= TEMP_ABNORMAL_COUNT) {
 403                 bi->health = POWER_SUPPLY_HEALTH_GOOD;
 404                 bi->temp_recover_cnt = 0;
 405         }
 406         RTINFO("external temperature: %d\n", bi->ext_temp);
 407 }
 408
 409 static void rt5025_clear_cc(struct rt5025_battery_info *bi, operation_mode mode)
 410 {
 411         u8 data[2];
 412
 413         if (rt5025_read_reg(bi->client, RT5025_REG_CHANNELH, data, 2) < 0)
 414         pr_err("%s: failed to read channel\n", __func__);
 415
 416         if (mode == CHG)
 417                 data[0] = data[0] | CHANNEL_H_BIT_CLRQCHG;
 418         else
 419                 data[0] = data[0] | CHANNEL_H_BIT_CLRQDCHG;
 420
 421         if (rt5025_write_reg(bi->client, RT5025_REG_CHANNELH, data, 2) < 0)
 422                 pr_err("%s: failed to write channel\n", __func__);
 423 }
 424
 425 static void rt5025_get_chg_cc(struct rt5025_battery_info *bi)
 426 {
 427         u8 data[4];
 428         u32 qh_old, ql_old, qh_new, ql_new;
 429         u32 cc_masec, offset = 0;
 430
 431         if (rt5025_read_reg(bi->client, RT5025_REG_QCHGHH, data, 4) < 0)
 432                 pr_err("%s: Failed to read QCHG\n", __func__);
 433
 434         qh_old = (data[0]<<8) + data[1];
 435         ql_old = (data[2]<<8) + data[3];
 436         RTINFO("qh_old=%d, ql_old=%d\n", qh_old, ql_old);
 437
 438         if (rt5025_read_reg(bi->client, RT5025_REG_QCHGHH, data, 4) < 0)
 439                 pr_err("%s: Failed to read QCHG\n", __func__);
 440
 441         qh_new = (data[0]<<8) + data[1];
 442         ql_new = (data[2]<<8) + data[3];
 443         RTINFO("qh_new=%d, ql_new=%d\n", qh_new, ql_new);
 444
 445 #if RT5025_B
 446         if (qh_new > qh_old) {
 447         /*cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;*/
 448         cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
 449         } else if (qh_new == qh_old) {
 450                 if (ql_new >= ql_old) {
 451                         /*cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;*/
 452                         cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
 453                 } else {
 454                         /*cc_masec = (((qh_old<<16) + ql_old) * 50134) / 10;*/
 455                         cc_masec = qh_old*328558+(qh_old*1824+ql_old*50134)/10000;
 456                 }
 457         }
 458
 459         if (!bi->init_once)
 460                 offset = bi->curr_offset * bi->time_interval;
 461         if (cc_masec > offset)
 462                 cc_masec = cc_masec - (offset / 1000);
 463 #else
 464         if (qh_new > qh_old) {
 465         cc_masec = (((qh_new << 16) + ql_new) * 5996) / 1000;
 466         } else if (qh_new == qh_old) {
 467                 if (ql_new >= ql_old)
 468                         cc_masec = (((qh_new<<16) + ql_new) * 5996) / 1000;
 469                 else
 470                         cc_masec = (((qh_old<<16) + ql_old) * 5996) / 1000;
 471         }
 472
 473         offset = (bi->curr_offset * bi->time_interval * 37375) / 100000;
 474
 475         if (cc_masec != 0)
 476                 cc_masec = cc_masec - offset;
 477 #endif
 478         if (cc_masec < (DEADBAND * bi->time_interval))
 479                 cc_masec = 0;
 480
 481 #if RT5025_CSV
 482 #else
 483         RTINFO("chg_cc_mAsec: %d\n", cc_masec);
 484 #endif
 485
 486         /*if (!bi->init_once)*/
 487         bi->chg_cc = cc_masec;
 488         /*bi->chg_cc = (cc_masec + bi->chg_cc_unuse) / 3600;*/
 489         /*bi->chg_cc_unuse = (cc_masec + bi->chg_cc_unuse) % 3600;*/
 490         rt5025_clear_cc(bi, CHG);
 491 }
 492
 493 static void rt5025_get_dchg_cc(struct rt5025_battery_info *bi)
 494 {
 495         u8 data[4];
 496         u32 qh_old, ql_old, qh_new, ql_new;
 497         u32 cc_masec, offset = 0;
 498
 499         if (rt5025_read_reg(bi->client, RT5025_REG_QDCHGHH, data, 4) < 0)
 500                 pr_err("%s: Failed to read QDCHG\n",
 501                         __func__);
 502
 503         qh_old = (data[0] << 8) + data[1];
 504         ql_old = (data[2] << 8) + data[3];
 505
 506         if (rt5025_read_reg(bi->client, RT5025_REG_QDCHGHH, data, 4) < 0)
 507                 pr_err("%s: Failed to read QDCHG\n",
 508                         __func__);
 509
 510         qh_new = (data[0] << 8) + data[1];
 511         ql_new = (data[2] << 8) + data[3];
 512
 513 #if RT5025_B
 514         if (qh_new > qh_old) {
 515                 /*cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;*/
 516                 cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
 517         } else if (qh_new == qh_old) {
 518                 if (ql_new >= ql_old) {
 519                         /*cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;*/
 520                         cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
 521                 } else {
 522                         /*cc_masec = (((qh_old<<16) + ql_old) * 50134) / 10;*/
 523                         cc_masec = qh_old*328558+(qh_old*1824+ql_old*50134)/10000;
 524                 }
 525         }
 526         if (!bi->init_once)
 527                 offset = bi->curr_offset * bi->time_interval;
 528         if (cc_masec != 0)
 529                 cc_masec = cc_masec + (offset / 1000);
 530 #else
 531         if (qh_new > qh_old) {
 532                 cc_masec = (((qh_new<<16) + ql_new) * 5996) / 1000;
 533         } else if (qh_new == qh_old) {
 534                 if (ql_new >= ql_old)
 535                         cc_masec = (((qh_new<<16) + ql_new) * 5996) / 1000;
 536                 else
 537                         cc_masec = (((qh_old<<16) + ql_old) * 5996) / 1000;
 538         }
 539
 540         offset = (bi->curr_offset * bi->time_interval * 37375) / 100000;
 541
 542         if (cc_masec > offset)
 543                 cc_masec = cc_masec - offset;
 544 #endif
 545         if (cc_masec < (DEADBAND * bi->time_interval))
 546                 cc_masec = 0;
 547
 548 #if RT5025_CSV
 549 #else
 550         RTINFO("dchg_cc_mAsec: %d\n", cc_masec);
 551 #endif
 552         bi->dchg_cc = cc_masec;
 553         /*b. add fcc update flag; 2013/12/18*/
 554         if ((bi->last_tp_flag) && (bi->fcc_update_flag))
 555                 bi->cal_fcc += cc_masec;
 556         else
 557                 bi->cal_fcc = 0;
 558
 559         RTINFO("bi->cal_fcc=%d, bi->last_tp_flag=%d\n",
 560                 bi->cal_fcc, bi->last_tp_flag);
 561         /*bi->dchg_cc = (cc_masec + bi->dchg_cc_unuse) / 3600;*/
 562         /*bi->dchg_cc_unuse = (cc_masec + bi->dchg_cc_unuse) % 3600;*/
 563         rt5025_clear_cc(bi, DCHG);
 564
 565 }
 566
 567 static void rt5025_cycle_count(struct rt5025_battery_info *bi)
 568 {
 569         bi->acc_dchg_cap +=  bi->dchg_cc;
 570         if (bi->acc_dchg_cap >= (bi->dc * 3600)) {
 571                 bi->cycle_cnt++;
 572                 bi->acc_dchg_cap -= (bi->dc * 3600);
 573         }
 574 }
 575
 576 static void rt5025_get_irq_flag(struct rt5025_battery_info *bi, u8 flag)
 577 {
 578         bi->irq_flag = flag;
 579         /*RTINFO("IRQ_FLG 0x%x\n", bi->irq_flag);*/
 580 }
 581
 582 static void rt5025_get_timer(struct rt5025_battery_info *bi)
 583 {
 584         u8 data[2];
 585
 586         if (rt5025_read_reg(bi->client, RT5025_REG_TIMERH, data, 2) < 0)
 587                 pr_err("%s: Failed to read Timer\n", __func__);
 588
 589         bi->gauge_timer = (data[0] << 8) + data[1];
 590         if (!bi->device_suspend) {
 591                 if (bi->gauge_timer > bi->pre_gauge_timer)
 592                         bi->time_interval = bi->gauge_timer - bi->pre_gauge_timer;
 593                 else
 594                         bi->time_interval = 65536 - bi->pre_gauge_timer + bi->gauge_timer;
 595         }
 596
 597         bi->pre_gauge_timer = bi->gauge_timer;
 598 #if RT5025_CSV
 599         /*pr_info("%d,%d,", bi->gauge_timer,bi->time_interval);*/
 600 #else
 601         RTINFO("timer %d , interval %d\n", bi->gauge_timer, bi->time_interval);
 602 #endif
 603 }
 604
 605 static void rt5025_alert_setting(struct rt5025_battery_info *bi,
 606         alert_type type, bool enable)
 607 {
 608         u8 data[1];
 609
 610         if (rt5025_read_reg(bi->client, RT5025_REG_IRQCTL, data, 1) < 0)
 611                 pr_err("%s: Failed to read CONFIG\n", __func__);
 612
 613         if (enable) {
 614                 switch (type) {
 615                 case MAXTEMP:
 616                         data[0] |= IRQ_CTL_BIT_TMX;
 617                         /*Enable max temperature alert*/
 618                         bi->max_temp_irq = true;
 619                         /*RTDBG("Enable min temperature alert");*/
 620                         break;
 621                 case MINTEMP:
 622                         data[0] |= IRQ_CTL_BIT_TMN;
 623                         /*Enable min temperature alert*/
 624                         bi->min_temp_irq = true;
 625                         /*RTDBG("Enable max temperature alert");*/
 626                         break;
 627                 case MAXVOLT:
 628                         data[0] |= IRQ_CTL_BIT_VMX;
 629                         /*Enable max voltage alert*/
 630                         bi->max_volt_irq = true;
 631                         /*RTDBG("Enable max voltage alert");*/
 632                         break;
 633                 case MINVOLT1:
 634                         data[0] |= IRQ_CTL_BIT_VMN1;
 635                         /*Enable min1 voltage alert*/
 636                         bi->min_volt1_irq = true;
 637                         /*RTDBG("Enable min1 voltage alert");*/
 638                         break;
 639                 case MINVOLT2:
 640                         data[0] |= IRQ_CTL_BIT_VMN2;
 641                         /*Enable min2 voltage alert*/
 642                         bi->min_volt2_irq = true;
 643                         /*RTDBG("Enable min2 voltage alert");*/
 644                         break;
 645                 default:
 646                         break;
 647                 }
 648         } else {
 649                 switch (type) {
 650                 case MAXTEMP:
 651                         data[0] = data[0] & ~IRQ_CTL_BIT_TMX;
 652                         /*Disable max temperature alert*/
 653                         bi->max_temp_irq = false;
 654                         /*RTDBG("Disable min temperature alert");*/
 655                         break;
 656                 case MINTEMP:
 657                         data[0] = data[0] & ~IRQ_CTL_BIT_TMN;
 658                         /*Disable min temperature alert*/
 659                         bi->min_temp_irq = false;
 660                         /*RTDBG("Disable max temperature alert");*/
 661                         break;
 662                 case MAXVOLT:
 663                         data[0] = data[0] & ~IRQ_CTL_BIT_VMX;
 664                         /*Disable max voltage alert*/
 665                         bi->max_volt_irq = false;
 666                         /*RTDBG("Disable max voltage alert");*/
 667                         break;
 668                 case MINVOLT1:
 669                         data[0] = data[0] & ~IRQ_CTL_BIT_VMN1;
 670                         /*Disable min1 voltage alert*/
 671                         bi->min_volt1_irq = false;
 672                         /*RTDBG("Disable min1 voltage alert");*/
 673                         break;
 674                 case MINVOLT2:
 675                         data[0] = data[0] & ~IRQ_CTL_BIT_VMN2;
 676                         /*Disable min2 voltage alert*/
 677                         bi->min_volt2_irq = false;
 678                         /*RTDBG("Disable min2 voltage alert");*/
 679                         break;
 680                 default:
 681                         break;
 682                 }
 683         }
 684         if (rt5025_write_reg(bi->client, RT5025_REG_IRQCTL, data, 1) < 0)
 685                 pr_err("%s: failed to write IRQ control\n", __func__);
 686 }
 687
 688 static void rt5025_alert_threshold_init(struct i2c_client *client)
 689 {
 690         u8 data[1];
 691
 692         /* VALRT MAX threshold setting */
 693         data[0] = irq_thres[MAXVOLT];
 694         if (rt5025_write_reg(client, RT5025_REG_VALRTMAX, data, 1) < 0)
 695                 pr_err("%s: failed to write VALRT MAX threshold\n",
 696                         __func__);
 697         /* VALRT MIN1 threshold setting */
 698         data[0] = irq_thres[MINVOLT1];
 699         if (rt5025_write_reg(client, RT5025_REG_VALRTMIN1, data, 1) < 0)
 700                 pr_err("%s: failed to write VALRT MIN1 threshold\n",
 701                         __func__);
 702         /* VALRT MIN2 threshold setting */
 703         data[0] = irq_thres[MINVOLT2];
 704         if (rt5025_write_reg(client, RT5025_REG_VALRTMIN2, data, 1) < 0)
 705                 pr_err("%s: failed to write VALRT MIN2 threshold\n",
 706                         __func__);
 707 }
 708
 709 static void rt5025_alert_init(struct rt5025_battery_info *bi)
 710 {
 711
 712         /* Set RT5025 gauge alert configuration */
 713         rt5025_alert_threshold_init(bi->client);
 714         /* Enable gauge alert function */
 715         rt5025_alert_setting(bi, MINVOLT2, VOLTAGE_ALERT);
 716 }
 717
 718 void rt5025_gauge_irq_handler(struct rt5025_battery_info *bi,
 719         unsigned int irq_flag)
 720 {
 721         rt5025_get_irq_flag(bi, irq_flag);
 722
 723         if ((bi->irq_flag) & IRQ_FLG_BIT_TMX) {
 724                 /*printk(KERN_INFO "[RT5025]: Min temperature IRQ received\n");*/
 725                 rt5025_alert_setting(bi, MAXTEMP, false);
 726                 bi->max_temp_irq = false;
 727         }
 728         if ((bi->irq_flag) & IRQ_FLG_BIT_TMN) {
 729                 /*printk(KERN_INFO "[RT5025]: Max temperature IRQ received\n");*/
 730                 rt5025_alert_setting(bi, MINTEMP, false);
 731                 bi->min_temp_irq = false;
 732         }
 733         if ((bi->irq_flag) & IRQ_FLG_BIT_VMX) {
 734                 /*printk(KERN_INFO "[RT5025]: Max voltage IRQ received\n");*/
 735                 rt5025_alert_setting(bi, MAXVOLT, false);
 736                 bi->max_volt_irq = false;
 737         }
 738         if ((bi->irq_flag) & IRQ_FLG_BIT_VMN1) {
 739                 /*printk(KERN_INFO "[RT5025]: Min voltage1 IRQ received\n");*/
 740                 rt5025_alert_setting(bi, MINVOLT1, false);
 741                 bi->min_volt1_irq = false;
 742         }
 743         if ((bi->irq_flag) & IRQ_FLG_BIT_VMN2) {
 744                 /*printk(KERN_INFO "[RT5025]: Min voltage2 IRQ received\n");*/
 745                 rt5025_alert_setting(bi, MINVOLT2, false);
 746                 bi->min_volt2_irq = false;
 747                 bi->min_volt2_alert = true;
 748                 wake_lock_timeout(&bi->low_battery_wake_lock,
 749                                   msecs_to_jiffies(LOW_BAT_WAKE_LOK_TIME *
 750                                                    MSEC_PER_SEC));
 751         }
 752 }
 753 EXPORT_SYMBOL(rt5025_gauge_irq_handler);
 754
 755 static void rt5025_convert_masec_to_permille(struct rt5025_battery_info *bi)
 756 {
 757         bi->permille = bi->rm / 3600 * 1000 / bi->fcc;
 758         RTINFO("permille=%d\n", bi->permille);
 759         /*return;*/
 760 }
 761
 762 static void rt5025_convert_permille_to_masec(struct rt5025_battery_info *bi)
 763 {
 764         bi->rm = bi->permille * bi->fcc / 1000 * 3600;
 765         /*return;*/
 766 }
 767
 768 static void rt5025_init_capacity(struct rt5025_battery_info *bi)
 769 {
 770         int i = 1;
 771         int size;
 772         int slope, const_term;
 773         int delta_y, delta_x;
 774
 775         size = ARRAY_SIZE(rt5025_battery_param1);
 776         while ((bi->vcell < rt5025_battery_param1[i].x) &&
 777                 (i < (size - 1))) {
 778                 i++;
 779         }
 780
 781         delta_x = rt5025_battery_param1[i-1].x - rt5025_battery_param1[i].x;
 782         delta_y = (rt5025_battery_param1[i-1].y - rt5025_battery_param1[i].y);
 783
 784         slope = delta_y  * 1000 / delta_x;
 785
 786         const_term = (rt5025_battery_param1[i].y) - ((rt5025_battery_param1[i].x * slope) / 1000);
 787
 788         if (bi->vcell >= rt5025_battery_param1[0].x)
 789                 bi->permille = rt5025_battery_param1[0].y;
 790         else if (bi->vcell <= rt5025_battery_param1[size-1].x)
 791                 bi->permille = rt5025_battery_param1[size-1].y;
 792         else
 793                 bi->permille = (bi->vcell * slope) / 1000 + const_term;
 794         rt5025_convert_permille_to_masec(bi);
 795         bi->soc = bi->rm / 36 / bi->fcc_aging;
 796         bi->init_cap = false;
 797
 798         rt5025_battery_parameter_backup(bi);
 799
 800         RTINFO("voltage=%d, permille=%d, soc=%d, rm=%d\n",
 801                 bi->vcell, bi->permille, bi->soc, bi->rm);
 802         /*return;*/
 803 }
 804
 805 static void rt5025_smooth_soc(struct rt5025_battery_info *bi)
 806 {
 807         if ((bi->internal_status == POWER_SUPPLY_STATUS_CHARGING || bi->tp_flag) &&
 808             (bi->soc < 100)) {
 809                 if (bi->last_suspend  == true) {
 810                         bi->soc = 100;
 811                         bi->last_suspend = false;
 812                 } else {
 813                         bi->soc++;
 814                 }
 815                 bi->rm = bi->fcc * bi->soc * 36;
 816                 rt5025_convert_masec_to_permille(bi);
 817
 818                 if (bi->soc == 100) {
 819                         /*fcc update in soc smooth 100%.*/
 820                         if (bi->cal_soc_offset != 0) {
 821                                 bi->fcc_aging -= bi->cal_soc_offset;
 822                                 if ((200 <= bi->ext_temp) && (bi->ext_temp <= 300)) {
 823                                         bi->fcc = bi->fcc_aging;
 824                                         bi->rm = bi->fcc * bi->soc * 36;
 825                                 } else {
 826                                         rt5025_temp_comp(bi);
 827                                 }
 828                                 bi->cal_soc_offset = 0;
 829                         }
 830                         wake_unlock(&bi->smooth100_wake_lock);
 831                         bi->last_tp = true;
 832                         bi->tp_flag = false;
 833                         bi->pre_soc = bi->soc;
 834
 835                         /*c. Only EOC occurs and full discharge to update FCC; 2013/12/17*/
 836                         bi->last_tp_flag = true;
 837                         mutex_lock(&bi->status_change_lock);
 838                         if (bi->status != POWER_SUPPLY_STATUS_DISCHARGING) {
 839                                 bi->status = POWER_SUPPLY_STATUS_FULL;
 840                                 rt5025_set_battery_led(bi, bi->status);
 841                         }
 842                         mutex_unlock(&bi->status_change_lock);
 843                 }
 844         } else if ((bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
 845                 (bi->soc > 0)) {
 846                 if (bi->last_suspend  == true) {
 847                         bi->soc = 0;
 848                         bi->last_suspend = false;
 849                 } else {
 850                         bi->soc--;
 851                 }
 852                 bi->rm = bi->fcc * bi->soc * 36;
 853                 rt5025_convert_masec_to_permille(bi);
 854                 if (bi->soc == 0)
 855                         wake_unlock(&bi->smooth0_wake_lock);
 856         } else {
 857           bi->smooth_flag = false;
 858           bi->update_time = NORMAL_POLL;
 859   }
 860 }
 861
 862
 863 static void rt5025_soc_irreversible(struct rt5025_battery_info *bi)
 864 {
 865         if (!bi->init_once) {
 866                 if (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING) {
 867                         if (bi->soc < bi->pre_soc)
 868                                 bi->soc = bi->pre_soc;
 869                 } else if ((bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
 870                                                 (bi->tp_flag == 0)) {
 871                         if (bi->soc > bi->pre_soc)
 872                                 bi->soc = bi->pre_soc;
 873                 }
 874         } else {
 875                 bi->init_once = false;
 876         }
 877
 878         if (bi->pre_soc != bi->soc)
 879                 rt5025_battery_parameter_backup(bi);
 880
 881         bi->pre_soc = bi->soc;
 882         RTINFO("pre_soc=%d, soc=%d, internal status=%d\n",
 883                 bi->pre_soc, bi->soc, bi->internal_status);
 884 }
 885
 886 static void rt5025_soc_lock(struct rt5025_battery_info *bi)
 887 {
 888          /*lock 99%*/
 889         u16 eoc_fcc_new  = 0;
 890
 891         RTINFO("internal status=%d, tp_flag=%d, soc=%d, soc99_lock_cnt=%d\n",
 892                 bi->internal_status, bi->tp_flag, bi->soc,
 893                 bi->soc99_lock_cnt);
 894         RTINFO("init_once=%d, rm=%d, soc=%d\n",
 895                 bi->init_once, bi->rm, bi->soc);
 896
 897         if (bi->soc >= 99) {
 898                 if (bi->soc99_lock_cnt >= 3600) {
 899                         bi->soc = 100;
 900                         bi->permille = 1000;
 901                         /*eoc fcc update function: when flag is true, update FCC.*/
 902                         if (bi->cal_eoc_fcc != 0) {
 903                                 /*eoc fcc update function: fcc update limitation 3%*/
 904                                 eoc_fcc_new = bi->fcc_aging + bi->cal_eoc_fcc / 3600;
 905                                 if (eoc_fcc_new > ((bi->fcc_aging * 103) / 100))
 906                                         bi->fcc_aging = (bi->fcc_aging * 103) / 100;
 907                                 else
 908                                         bi->fcc_aging = eoc_fcc_new;
 909
 910                                 if ((200 <= bi->ext_temp) && (bi->ext_temp <= 300)) {
 911                                         bi->fcc = bi->fcc_aging;
 912                                         bi->rm = bi->fcc * bi->permille * 36 / 10;
 913                                 } else {
 914                                         rt5025_temp_comp(bi);
 915                                         }
 916                                 bi->cal_eoc_fcc = 0;
 917                         }
 918                         wake_unlock(&bi->full_battery_wake_lock);
 919                         bi->soc99_lock_cnt = 0;
 920                         bi->last_tp = true;
 921                         bi->tp_flag = false;
 922                         bi->pre_soc = bi->soc;
 923                         /*b. add fcc update flag; 2013/12/18*/
 924                         bi->fcc_update_flag = false;
 925
 926                         /*a. When SOC = 100, report battery status is full; 2013/12/17
 927                         bi->status = POWER_SUPPLY_STATUS_FULL;
 928                         */
 929                 } else if (bi->tp_flag) {
 930                         RTINFO("before_eoc_fcc_new=%d\n", eoc_fcc_new);
 931                         RTINFO("before_cal_eoc_fcc=%d\n", bi->cal_eoc_fcc);
 932                         RTINFO("before_fcc_aging=%d\n", bi->fcc_aging);
 933                         bi->soc = 100;
 934                         bi->permille = 1000;
 935                         if (bi->cal_eoc_fcc != 0) {
 936                                 /*fcc update in eoc occurs. */
 937                                 eoc_fcc_new = bi->fcc_aging + bi->cal_eoc_fcc/3600;
 938                                 if (eoc_fcc_new > ((bi->fcc_aging*103)/100))
 939                                         bi->fcc_aging = (bi->fcc_aging*103)/100;
 940                                 else
 941                                         bi->fcc_aging = eoc_fcc_new;
 942
 943                                 RTINFO("after_eoc_fcc_new=%d\n", eoc_fcc_new);
 944                                 RTINFO("after_cal_eoc_fcc=%d\n", bi->cal_eoc_fcc);
 945                                 RTINFO("after_fcc_aging=%d\n", bi->fcc_aging);
 946                                 if ((200 <= bi->ext_temp) && (bi->ext_temp <= 300)) {
 947                                         bi->fcc = bi->fcc_aging;
 948                                         bi->rm = bi->fcc * bi->permille * 36 / 10;
 949                                 } else {
 950                                         rt5025_temp_comp(bi);
 951                                 }
 952                                 bi->cal_eoc_fcc = 0;
 953                         } else if (bi->cal_soc_offset != 0) {
 954                                 bi->fcc_aging -= bi->cal_soc_offset;
 955                                 if ((200 <= bi->ext_temp) && (bi->ext_temp <= 300)) {
 956                                         bi->fcc = bi->fcc_aging;
 957                                         bi->rm = bi->fcc * bi->permille * 36 / 10;
 958                                 } else {
 959                                         rt5025_temp_comp(bi);
 960                                 }
 961                                 bi->cal_soc_offset = 0;
 962                         }
 963
 964                         wake_unlock(&bi->full_battery_wake_lock);
 965                         bi->soc99_lock_cnt = 0;
 966                         bi->last_tp = true;
 967                         bi->tp_flag = false;
 968                         bi->pre_soc = bi->soc;
 969
 970                         /*c. Only EOC occurs and full discharge to update FCC; 2013/12/17*/
 971                         bi->last_tp_flag = true;
 972
 973                         mutex_lock(&bi->status_change_lock);
 974                         if (bi->status != POWER_SUPPLY_STATUS_DISCHARGING) {
 975                                 bi->status = POWER_SUPPLY_STATUS_FULL;
 976                                 rt5025_set_battery_led(bi, bi->status);
 977                         }
 978                         mutex_unlock(&bi->status_change_lock);
 979                 } else if ((bi->internal_status == POWER_SUPPLY_STATUS_CHARGING)  &&
 980                                                 (bi->last_tp == false)) {
 981                         bi->soc = 99;
 982                         bi->pre_soc = 99;
 983                         bi->soc99_lock_cnt += bi->time_interval;
 984                 }
 985         } else if ((bi->soc < 99) && (bi->tp_flag)) {
 986                 /*calculate soc offset */
 987                 if (bi->cal_soc_offset == 0) {
 988                         bi->cal_soc_offset = bi->fcc*3600 - bi->rm;
 989                         if (bi->cal_soc_offset > (bi->fcc_aging*3/100))
 990                                 bi->cal_soc_offset = bi->fcc_aging*3/100;
 991                 }
 992                 wake_lock(&bi->smooth100_wake_lock);
 993                 bi->update_time = SMOOTH_POLL;
 994                 bi->smooth_flag = true;
 995                 rt5025_smooth_soc(bi);
 996         } else {
 997                 wake_unlock(&bi->smooth100_wake_lock);
 998                 bi->tp_flag = false;
 999                 bi->soc99_lock_cnt = 0;
1000         }
1001                 /* a. When SOC = 100, report battery status is full; 2013/12/17
1002                 /// a. judge charging status to check battery full condition; 2013/12/18*/
1003         if ((bi->soc == 100) &&
1004                 (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING)) {
1005                 mutex_lock(&bi->status_change_lock);
1006                 if (bi->status != POWER_SUPPLY_STATUS_DISCHARGING) {
1007                         bi->status = POWER_SUPPLY_STATUS_FULL;
1008                         rt5025_set_battery_led(bi, bi->status);
1009                 }
1010                 mutex_unlock(&bi->status_change_lock);
1011         }
1012
1013         /*lock 1%   */
1014         if ((bi->soc <= 1) &&
1015           (bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING)) {
1016                 if (bi->edv_flag) {
1017                         bi->soc = 0;
1018                 } else {
1019                         if (bi->rm <= 0) {
1020                                 bi->soc1_lock_cnt += bi->time_interval;
1021                                 if (bi->soc1_lock_cnt >= 600) {
1022                                         bi->soc = 0;
1023                                         bi->soc1_lock_cnt = 0;
1024                                 } else {
1025                                         bi->soc = 1;
1026                                         bi->pre_soc = 1;
1027                                 }
1028                         } else {
1029                                 bi->soc = 1;
1030                                 bi->pre_soc = 1;
1031                                 bi->soc1_lock_cnt = 0;
1032                         }
1033                 }
1034         } else if ((bi->soc > 1) &&
1035                 (bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
1036                         (bi->edv_flag)) {
1037                 wake_lock(&bi->smooth0_wake_lock);
1038                 bi->update_time = SMOOTH_POLL;
1039                 bi->smooth_flag = true;
1040                 rt5025_smooth_soc(bi);
1041         } else {
1042                 bi->edv_flag = false;
1043                 wake_unlock(&bi->smooth0_wake_lock);
1044         }
1045         RTINFO("cal_soc_offset=%d\n", bi->cal_soc_offset);
1046 }
1047
1048 static void rt5025_get_soc(struct rt5025_battery_info *bi)
1049 {
1050         if (bi->smooth_flag) {
1051                 bi->smooth_flag = false;
1052                 bi->update_time = NORMAL_POLL;
1053         }
1054         RTINFO("before rm=%d\n", bi->rm);
1055         if ((!bi->tp_flag) && (!bi->edv_flag)) {
1056                 bi->rm = (bi->rm + bi->chg_cc) > bi->dchg_cc ?
1057                         bi->rm + bi->chg_cc - bi->dchg_cc : 0;
1058                 if (bi->rm > (bi->fcc * 3600))
1059                         bi->rm = bi->fcc * 3600;
1060
1061                 /* accumulate coulomb counter when rm = fcc and enable flag = true.*/
1062                 if (bi->rm == (bi->fcc * 3600))
1063                         bi->cal_eoc_fcc += (bi->chg_cc - bi->dchg_cc);
1064                 else
1065                         bi->cal_eoc_fcc = 0;
1066
1067                 RTINFO("cal_eoc_fcc=%d\n", bi->cal_eoc_fcc);
1068                 rt5025_convert_masec_to_permille(bi);
1069                 /*a. When SOC = 100, report battery status is full; 2113/12/17*/
1070                 bi->soc = DIV_ROUND_UP(bi->permille, 10);
1071         }
1072 #if RT5025_CSV
1073         bi->temp_soc = bi->soc;
1074         /*pr_info("%d", bi->soc);*/
1075 #else
1076         RTINFO("after rm=%d\n", bi->rm);
1077         RTINFO("temp_soc=%d\n", bi->soc);
1078 #endif
1079 #if RT5025_CSV
1080         RTINFO("soc=%d, permille=%d, rm=%d, fcc=%d, smooth_flag=%d\n",
1081                 bi->soc, bi->permille, bi->rm,
1082                 bi->fcc, bi->smooth_flag);
1083         /*pr_info("%d,%d,%d,%d,%d", bi->soc,bi->permille,bi->rm,bi->fcc,bi->smooth_flag);*/
1084 #else
1085         RTINFO("soc=%d, permille=%d, rm=%d, fcc=%d, smooth_flag=%d\n",
1086                 bi->soc, bi->permille, bi->rm,
1087                 bi->fcc, bi->smooth_flag);
1088 #endif
1089         /*return;*/
1090 }
1091
1092 static void rt5025_soc_relearn_check(struct rt5025_battery_info *bi)
1093 {
1094
1095         if (bi->tp_flag == true) {
1096                 bi->rm = bi->fcc * 3600;
1097                 rt5025_convert_masec_to_permille(bi);
1098                 bi->update_time = NORMAL_POLL;
1099         }
1100
1101         if (bi->vcell <= bi->empty_edv) {
1102                 if (bi->edv_cnt < 2)
1103                         bi->edv_cnt++;
1104         } else {
1105                 bi->edv_cnt = 0;
1106         }
1107
1108         if (bi->empty_edv < bi->vcell && bi->vcell <= bi->empty_edv + 300) {
1109                 bi->update_time = EDV_POLL;
1110                 bi->edv_detection = true;
1111         } else if ((bi->vcell >= bi->empty_edv + 300 + EDV_HYS)
1112                 && (bi->edv_detection == true)) {
1113                  bi->update_time = NORMAL_POLL;
1114                  bi->edv_detection = false;
1115         } else if ((bi->vcell <= bi->empty_edv && bi->edv_cnt == 2)) {
1116                 bi->edv_flag = true;
1117                 bi->rm = 0;
1118                 rt5025_convert_masec_to_permille(bi);
1119                 bi->edv_detection = false;
1120                 bi->update_time = NORMAL_POLL;
1121         } else if ((bi->vcell > bi->empty_edv + EDV_HYS)) {
1122                 bi->min_volt2_alert = false;
1123                 bi->edv_flag = false;
1124         }
1125
1126         if (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING)
1127                 bi->edv_flag = false;
1128
1129 #if RT5025_CSV
1130 #else
1131         RTINFO("tp_cnt=%d, tp_flag=%d, edv_detection=%d, edv_cnt=%d, edv_flag=%d\n",
1132         bi->tp_cnt, bi->tp_flag, bi->edv_detection,
1133         bi->edv_cnt, bi->edv_flag);
1134 #endif
1135
1136  /* return;*/
1137 }
1138
1139 static u16 get_crc16_value(u8 *data, int size)
1140 {
1141         u16 fcs = 0xffff;
1142         int len = size;
1143         int i = 0;
1144         u16 temp = 0;
1145
1146         while (len > 0) {
1147                 fcs = (u16)((fcs >> 8) ^ crctab16[(fcs ^ data[i]) & 0xff]);
1148                 len--;
1149                 i++;
1150         }
1151         temp = (u16)~fcs;
1152         return temp;
1153 }
1154
1155 static int IsCrc16Good(u8 *data, int size)
1156 {
1157         u16 fcs = 0xffff;
1158         int len = size;
1159         int i = 0;
1160
1161         while (len > 0) {
1162                 fcs = (u16)((fcs >> 8) ^ crctab16[((fcs ^ data[i]) & 0xff)]);
1163                 len--;
1164                 i++;
1165         }
1166         return (fcs == 0xf0b8);
1167 }
1168
1169 static int rt5025_battery_parameter_backup(struct rt5025_battery_info *bi)
1170 {
1171         u16 crc_value = 0;
1172         u8 data[15] = {0};
1173
1174         RTINFO("\n");
1175         /*backup fcc_aging, rm, cycle_count, acc_dchg_cap*/
1176         /*fcc_aging*/
1177         data[0] = (bi->fcc_aging >> 8) & 0xff;
1178         data[1] = (bi->fcc_aging) & 0xff;
1179         /*acc_dchg_cap*/
1180         data[2] = (bi->acc_dchg_cap >> 24) & 0xff;
1181         data[3] = (bi->acc_dchg_cap >> 16) & 0xff;
1182         data[4] = (bi->acc_dchg_cap >> 8) & 0xff;
1183         data[5] = (bi->acc_dchg_cap) & 0xff;
1184         /*cycle_count*/
1185         data[6] = (bi->cycle_cnt) & 0xff;
1186         /*soc*/
1187         data[7] = (bi->permille >> 8) & 0xff;
1188         data[8] = (bi->permille) & 0xff;
1189         /*gauge_timer*/
1190         data[9] = (bi->pre_gauge_timer >> 8) & 0xff;
1191         data[10] = bi->pre_gauge_timer & 0xff;
1192         /*CRC value*/
1193         crc_value = get_crc16_value(data, 13);
1194         data[13] = crc_value & 0xff;
1195         data[14] = (crc_value >> 8) & 0xff;
1196         rt5025_write_reg(bi->client, RT5025_REG_RESV1, data, 15);
1197         return 0;
1198 }
1199
1200 static int rt5025_battery_parameter_restore(struct rt5025_battery_info *bi)
1201 {
1202         u8 data[15];
1203
1204         RTINFO("\n");
1205         rt5025_read_reg(bi->client, RT5025_REG_RESV1, data, 15);
1206         /*restore fcc_aging, rm ,cycle_count, acc_dchg_cap*/
1207         /*fcc_aging*/
1208         bi->fcc = bi->fcc_aging = data[0] << 8 | data[1];
1209         /*acc_dchg_cap*/
1210         bi->acc_dchg_cap = data[2] << 24 | data[3] << 16 | data[4] << 8 | data[5];
1211         /*cycle_count*/
1212         bi->cycle_cnt = data[6];
1213         /*soc*/
1214         bi->permille = data[7] << 8 | data[8];
1215         /*pre_gauge_timer*/
1216         bi->pre_gauge_timer = bi->gauge_timer = (data[9] << 8) + data[10];
1217
1218         return 0;
1219 }
1220
1221 /*return value; 1-> initialized, 0-> no initial value*/
1222 static int rt5025_battery_parameter_initcheck(struct rt5025_battery_info *bi)
1223 {
1224         u8 data[15] = {0};
1225         int ret = 0;
1226
1227         if (rt5025_read_reg(bi->client, RT5025_REG_RESV1, data, 15) < 0) {
1228                 pr_err("%s: check initial value error\n", __func__);
1229                 return 0;
1230         } else {
1231                 ret = IsCrc16Good(data, 15);
1232         }
1233         RTINFO("initial check = %d\n", ret);
1234
1235         return ret;
1236 }
1237
1238 static void rt5025_register_init(struct rt5025_battery_info *bi)
1239 {
1240         u8 data[1];
1241
1242         /* enable the channel of current,qc,ain,vbat and vadc */
1243         if (rt5025_read_reg(bi->client, RT5025_REG_CHANNELL, data, 1) < 0)
1244                 pr_err("%s: failed to read channel\n", __func__);
1245
1246         RTINFO("initial change enable=%02x\n", data[0]);
1247         data[0] = data[0] | CHANNEL_L_BIT_CADC_EN | CHANNEL_L_BIT_AINCH | \
1248                 CHANNEL_L_BIT_VBATSCH | CHANNEL_L_BIT_VADC_EN | CHANNEL_L_BIT_INTEMPCH;
1249         if (rt5025_write_reg(bi->client, RT5025_REG_CHANNELL, data, 1) < 0)
1250                 pr_err("%s: failed to write channel\n", __func__);
1251
1252         /* set the alert threshold value */
1253         irq_thres[MINVOLT2] = VALRTMIN2_VALUE;
1254         irq_thres[VOLT_RLS] = VRLS_VALUE;
1255
1256         bi->chg_cc_unuse = 0;
1257         bi->dchg_cc_unuse = 0;
1258         bi->pre_gauge_timer = 0;
1259         bi->online = 1;
1260         bi->batt_present = 1;
1261         bi->status = bi->internal_status = POWER_SUPPLY_STATUS_DISCHARGING;
1262         bi->health = POWER_SUPPLY_HEALTH_GOOD;
1263
1264         bi->init_cap = true;
1265         bi->avg_flag = true;
1266
1267         bi->fcc_aging = rt5025_battery_param2[4].y;
1268         bi->fcc = rt5025_battery_param2[4].y;
1269         bi->dc = rt5025_battery_param2[4].y;
1270         bi->rm = 0;
1271
1272         bi->edv_cnt = 0;
1273         bi->edv_flag = false;
1274         bi->edv_detection = false;
1275         bi->init_once = true;
1276
1277         bi->tp_cnt = 0;
1278         bi->tp_flag = false;
1279
1280         bi->acc_dchg_cap = 0;
1281         bi->cycle_cnt = 0;
1282         bi->empty_edv = rt5025_battery_param2[4].x;
1283         bi->edv_region = 0;
1284         bi->soc1_lock_cnt = 0;
1285         /*eoc fcc update function: initial variable.  */
1286         bi->cal_eoc_fcc = 0;
1287         bi->cal_soc_offset = 0;
1288
1289
1290         /*if has initial data, rewrite to the stored data*/
1291         if (rt5025_battery_parameter_initcheck(bi)) {
1292                 bi->init_cap = false;
1293                 rt5025_battery_parameter_restore(bi);
1294                 bi->rm = bi->permille*bi->fcc_aging * 36 / 10;
1295         }
1296
1297         bi->update_time = NORMAL_POLL;
1298         bi->device_suspend = false;
1299         RTINFO("register initialized\n");
1300 }
1301
1302 static void rt5025_soc_aging(struct rt5025_battery_info *bi)
1303 {
1304         if (bi->cycle_cnt >= rt5025_battery_param2[3].x) {
1305                 bi->fcc_aging = bi->fcc_aging * (1000 - rt5025_battery_param2[3].y) / 1000;
1306                 bi->rm = bi->rm * (1000 - rt5025_battery_param2[3].y) / 1000;
1307                 bi->cycle_cnt -= rt5025_battery_param2[3].x;
1308         }
1309         RTINFO("fcc_aging=%d, rm=%d, cycle_cnt=%d\n",
1310                 bi->fcc_aging, bi->rm, bi->cycle_cnt);
1311 }
1312
1313 static void rt5025_temp_comp(struct rt5025_battery_info *bi)
1314 {
1315         int i = 1;
1316         int size;
1317         int slope, const_term;
1318         int delta_y, delta_x;
1319
1320         size = 3;
1321         while ((bi->ext_temp < rt5025_battery_param2[i].x) &&
1322                                 (i < (size - 1))) {
1323                 i++;
1324         }
1325
1326         delta_x = rt5025_battery_param2[i-1].x - rt5025_battery_param2[i].x;
1327         delta_y = (rt5025_battery_param2[i-1].y - rt5025_battery_param2[i].y);
1328
1329         slope = delta_y  * 1000 / delta_x;
1330
1331         const_term = (rt5025_battery_param2[i].y) - ((rt5025_battery_param2[i].x * slope) / 1000);
1332
1333         if (bi->ext_temp >= rt5025_battery_param2[0].x)
1334                 bi->tempcmp = rt5025_battery_param2[0].y;
1335         else if (bi->ext_temp <= rt5025_battery_param2[size-1].x)
1336                 bi->tempcmp = rt5025_battery_param2[size-1].y;
1337         else
1338                 bi->tempcmp = (bi->ext_temp * slope) / 1000 + const_term;
1339
1340         bi->fcc = bi->fcc_aging + bi->fcc_aging * bi->tempcmp  / 1000;
1341         if (bi->fcc >= (bi->dc*3>>1))
1342                 bi->fcc = bi->dc*3>>1;
1343         if (bi->fcc <= (bi->dc>>1))
1344                 bi->fcc = bi->dc>>1;
1345         bi->rm = bi->fcc * bi->permille * 36 / 10;
1346         RTINFO("tempcmp=%d, ext_temp=%d, fcc=%d, rm=%d\n",
1347                 bi->tempcmp, bi->ext_temp, bi->fcc, bi->rm);
1348         /*return;       */
1349 }
1350
1351 static void rt5025_soc_temp_comp(struct rt5025_battery_info *bi)
1352 {
1353         RTINFO("soc->%d++\n", bi->soc);
1354         bi->temp_range_0_5 = 0;
1355         bi->temp_range_5_10 = 0;
1356         bi->temp_range_10_15 = 0;
1357         bi->temp_range_15_20 = 0;
1358         bi->temp_range_20_30 = 0;
1359         bi->temp_range_30_35 = 0;
1360         bi->temp_range_35_40 = 0;
1361         bi->temp_range_40_45 = 0;
1362         bi->temp_range_45_50 = 0;
1363
1364         if (bi->ext_temp < 50)
1365                 bi->temp_range_0_5 = 1;
1366         else if (50 <= bi->ext_temp && bi->ext_temp < 100)
1367                 bi->temp_range_5_10 = 1;
1368         else if (100 <= bi->ext_temp && bi->ext_temp < 150)
1369                 bi->temp_range_10_15 = 1;
1370         else if (150 <= bi->ext_temp && bi->ext_temp < 200)
1371                         bi->temp_range_15_20 = 1;
1372         else if (200 <= bi->ext_temp && bi->ext_temp <= 300)
1373                 bi->temp_range_20_30 = 1;
1374         else if (300 < bi->ext_temp && bi->ext_temp <= 350)
1375                 bi->temp_range_30_35 = 1;
1376         else if (350 < bi->ext_temp && bi->ext_temp <= 400)
1377                 bi->temp_range_35_40 = 1;
1378         else if (400 < bi->ext_temp && bi->ext_temp <= 450)
1379                 bi->temp_range_40_45 = 1;
1380         else if (450 < bi->ext_temp)
1381                 bi->temp_range_45_50 = 1;
1382
1383         if ((bi->temp_range_0_5 == 1) && (bi->range_0_5_done == 0)) {
1384                 rt5025_temp_comp(bi);
1385                 bi->range_0_5_done = 1;
1386                 bi->range_5_10_done = 0;
1387                 bi->range_10_15_done = 0;
1388                 bi->range_15_20_done = 0;
1389                 bi->range_20_30_done = 0;
1390                 bi->range_30_35_done = 0;
1391                 bi->range_35_40_done = 0;
1392                 bi->range_40_45_done = 0;
1393                 bi->range_45_50_done = 0;
1394         } else if ((bi->temp_range_5_10 == 1)
1395                 && (bi->range_5_10_done == 0)) {
1396                 rt5025_temp_comp(bi);
1397                 bi->range_0_5_done = 0;
1398                 bi->range_5_10_done = 1;
1399                 bi->range_10_15_done = 0;
1400                 bi->range_15_20_done = 0;
1401                 bi->range_20_30_done = 0;
1402                 bi->range_30_35_done = 0;
1403                 bi->range_35_40_done = 0;
1404                 bi->range_40_45_done = 0;
1405                 bi->range_45_50_done = 0;
1406         } else if ((bi->temp_range_10_15 == 1)
1407                 && (bi->range_10_15_done == 0)) {
1408                 rt5025_temp_comp(bi);
1409                 bi->range_0_5_done = 0;
1410                 bi->range_5_10_done = 0;
1411                 bi->range_10_15_done = 1;
1412                 bi->range_15_20_done = 0;
1413                 bi->range_20_30_done = 0;
1414                 bi->range_30_35_done = 0;
1415                 bi->range_35_40_done = 0;
1416                 bi->range_40_45_done = 0;
1417                 bi->range_45_50_done = 0;
1418         } else if ((bi->temp_range_15_20 == 1)
1419                 && (bi->range_15_20_done == 0)) {
1420                 rt5025_temp_comp(bi);
1421                 bi->range_0_5_done = 0;
1422                 bi->range_5_10_done = 0;
1423                 bi->range_10_15_done = 0;
1424                 bi->range_15_20_done = 1;
1425                 bi->range_20_30_done = 0;
1426                 bi->range_30_35_done = 0;
1427                 bi->range_35_40_done = 0;
1428                 bi->range_40_45_done = 0;
1429                 bi->range_45_50_done = 0;
1430         } else if ((bi->temp_range_20_30 == 1)
1431                 && (bi->range_20_30_done == 0)) {
1432                 bi->fcc = bi->fcc_aging;
1433                 bi->rm = bi->fcc * bi->permille * 36 / 10;
1434                 bi->range_0_5_done = 0;
1435                 bi->range_5_10_done = 0;
1436                 bi->range_10_15_done = 0;
1437                 bi->range_15_20_done = 0;
1438                 bi->range_20_30_done = 1;
1439                 bi->range_30_35_done = 0;
1440                 bi->range_35_40_done = 0;
1441                 bi->range_40_45_done = 0;
1442                 bi->range_45_50_done = 0;
1443         } else if ((bi->temp_range_30_35 == 1)
1444                 && (bi->range_30_35_done == 0)) {
1445                 rt5025_temp_comp(bi);
1446                 bi->range_0_5_done = 0;
1447                 bi->range_5_10_done = 0;
1448                 bi->range_10_15_done = 0;
1449                 bi->range_15_20_done = 0;
1450                 bi->range_20_30_done = 0;
1451                 bi->range_30_35_done = 1;
1452                 bi->range_35_40_done = 0;
1453                 bi->range_40_45_done = 0;
1454                 bi->range_45_50_done = 0;
1455         } else if ((bi->temp_range_35_40 == 1)
1456                 && (bi->range_35_40_done == 0)) {
1457                 rt5025_temp_comp(bi);
1458                 bi->range_0_5_done = 0;
1459                 bi->range_5_10_done = 0;
1460                 bi->range_10_15_done = 0;
1461                 bi->range_15_20_done = 0;
1462                 bi->range_20_30_done = 0;
1463                 bi->range_30_35_done = 0;
1464                 bi->range_35_40_done = 1;
1465                 bi->range_40_45_done = 0;
1466                 bi->range_45_50_done = 0;
1467         } else if ((bi->temp_range_40_45 == 1)
1468                 && (bi->range_40_45_done == 0)) {
1469                 rt5025_temp_comp(bi);
1470                 bi->range_0_5_done = 0;
1471                 bi->range_5_10_done = 0;
1472                 bi->range_10_15_done = 0;
1473                 bi->range_15_20_done = 0;
1474                 bi->range_20_30_done = 0;
1475                 bi->range_30_35_done = 0;
1476                 bi->range_35_40_done = 0;
1477                 bi->range_40_45_done = 1;
1478                 bi->range_45_50_done = 0;
1479         } else if ((bi->temp_range_45_50 == 1)
1480                 && (bi->range_45_50_done == 0)) {
1481                 rt5025_temp_comp(bi);
1482                 bi->range_0_5_done = 0;
1483                 bi->range_5_10_done = 0;
1484                 bi->range_10_15_done = 0;
1485                 bi->range_15_20_done = 0;
1486                 bi->range_20_30_done = 0;
1487                 bi->range_30_35_done = 0;
1488                 bi->range_35_40_done = 0;
1489                 bi->range_40_45_done = 0;
1490                 bi->range_45_50_done = 1;
1491         }
1492         RTINFO("soc->%d--\n", bi->soc);
1493 }
1494
1495 static void rt5025_update(struct rt5025_battery_info *bi)
1496 {
1497         int batt_type = 1;
1498         /* Update voltage */
1499         rt5025_get_vcell(bi);
1500         /* Update current */
1501         rt5025_get_current(bi);
1502         /* Update internal temperature */
1503         rt5025_get_internal_temp(bi);
1504         /* Update external temperature */
1505         rt5025_get_external_temp(bi);
1506         /* Read timer */
1507         rt5025_get_timer(bi);
1508         /* Update chg cc */
1509         rt5025_get_chg_cc(bi);
1510         /* Update dchg cc */
1511         rt5025_get_dchg_cc(bi);
1512         /* Update cycle count check */
1513         rt5025_cycle_count(bi);
1514         /* Calculate cycle count */
1515         rt5025_soc_aging(bi);
1516         /* calculate initial soc */
1517         if (bi->init_cap) {
1518                 rt5025_init_capacity(bi);
1519                 #if RT5025_CSV
1520                 pr_info("vcell,offset,current,timer,interval,QCHG,QDCHG,tp_cnt,tp_flag,edv_det,edv_cnt,edv_flag,soc,permille,RM,FCC,smooth_flag,acc_QD,cycle,update_time\n");
1521                 #endif
1522         }
1523
1524         /* Relearn SOC */
1525         rt5025_soc_relearn_check(bi);
1526         /* SOC_Temp_Comp*/
1527         rt5025_soc_temp_comp(bi);
1528         /* Update SOC */
1529         rt5025_get_soc(bi);
1530
1531         /* SOC Control Process */
1532         rt5025_soc_lock(bi);
1533         rt5025_soc_irreversible(bi);
1534
1535         if (bi->soc <= 99)
1536                 bi->last_tp = false;
1537
1538         if (rt5025_battery_param1[0].x >= 4250)
1539                 batt_type = 0;
1540         else if (rt5025_battery_param1[0].x >= 4100)
1541                 batt_type = 1;
1542
1543         switch (batt_type) {
1544         case 0:
1545                         if ((bi->vcell >= 4250) && (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING))
1546                                 wake_lock(&bi->full_battery_wake_lock);
1547                         else
1548                                 wake_unlock(&bi->full_battery_wake_lock);
1549                 break;
1550         case 1:
1551         default:
1552                         if ((bi->vcell >= 4100) && (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING))
1553                                 wake_lock(&bi->full_battery_wake_lock);
1554                         else
1555                                 wake_unlock(&bi->full_battery_wake_lock);
1556                 break;
1557         }
1558
1559         /* Update RTTF or RTTE */
1560
1561 #if TEMPERATURE_ALERT
1562         if ((bi->max_temp_irq == false) &&
1563                   (((irq_thres[MAXTEMP] * IRQ_THRES_UNIT) / 100 - bi->ain_volt) > irq_thres[TEMP_RLS])) {
1564                 rt5025_alert_setting(bi, MAXTEMP, true);
1565         } else if ((bi->min_temp_irq == false) &&
1566                                           ((bi->ain_volt - (irq_thres[MINTEMP] * IRQ_THRES_UNIT) / 100) > irq_thres[TEMP_RLS])) {
1567                 rt5025_alert_setting(bi, MINTEMP, true);
1568         }
1569 #endif
1570
1571 #if VOLTAGE_ALERT
1572         if ((bi->min_volt2_irq == false) &&
1573                 (bi->vcell > (bi->empty_edv + EDV_HYS)))
1574                 rt5025_alert_setting(bi, MINVOLT2, true);
1575 #endif
1576         bi->last_suspend = false;
1577 #if RT5025_CSV
1578         printk(KERN_INFO "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
1579         bi->vcell, bi->curr_offset, bi->curr, bi->gauge_timer,
1580         bi->time_interval, bi->chg_cc, bi->dchg_cc,
1581         bi->tp_cnt, bi->tp_flag, bi->edv_detection,
1582         bi->edv_cnt, bi->edv_flag, bi->soc, bi->permille,
1583         bi->rm, bi->fcc, bi->smooth_flag, bi->acc_dchg_cap,
1584         bi->cycle_cnt, bi->update_time);
1585 #else
1586         RTINFO("[RT5025] update_time=%d\n", bi->update_time);
1587         RTINFO("\n");
1588 #endif
1589 }
1590
1591 static void rt5025_update_work(struct work_struct *work)
1592 {
1593         struct delayed_work *delayed_work = (struct delayed_work *)container_of(work,
1594                 struct delayed_work, work);
1595         struct rt5025_battery_info *bi = (struct rt5025_battery_info *)container_of(delayed_work,
1596                 struct rt5025_battery_info, monitor_work);
1597
1598         wake_lock(&bi->monitor_wake_lock);
1599         rt5025_update(bi);
1600         if (bi->soc != bi->last_soc) {
1601                 power_supply_changed(&bi->battery);
1602                 bi->last_soc = bi->soc;
1603         }
1604
1605         wake_unlock(&bi->monitor_wake_lock);
1606         if (!bi->device_suspend)
1607                 schedule_delayed_work(&bi->monitor_work, bi->update_time*HZ);
1608 }
1609
1610 static enum power_supply_property rt5025_battery_props[] = {
1611         POWER_SUPPLY_PROP_STATUS,
1612         POWER_SUPPLY_PROP_HEALTH,
1613         POWER_SUPPLY_PROP_PRESENT,
1614         POWER_SUPPLY_PROP_TEMP,
1615         POWER_SUPPLY_PROP_TEMP_AMBIENT,
1616         POWER_SUPPLY_PROP_ONLINE,
1617         POWER_SUPPLY_PROP_VOLTAGE_NOW,
1618         POWER_SUPPLY_PROP_CURRENT_NOW,
1619         POWER_SUPPLY_PROP_CAPACITY,
1620         POWER_SUPPLY_PROP_TECHNOLOGY,
1621 #if 0
1622         POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
1623         POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
1624 #endif
1625 };
1626
1627 static int rt5025_battery_sleepvth_setting(struct rt5025_battery_info *bi)
1628 {
1629         u32 temp;
1630         u8 vmax_th, vmin_th;
1631         u8 vbat[2];
1632
1633         RTINFO("\n");
1634         rt5025_read_reg(bi->client, RT5025_REG_VBATSH, vbat, 2);
1635         temp = ((vbat[0] << 8) + vbat[1]) * 61;
1636         vmax_th = (temp + 5000) / 1953;
1637         vmin_th = (temp - 5000) / 1953;
1638
1639         rt5025_write_reg(bi->client, RT5025_REG_VALRTMAX, &vmax_th, 1);
1640         rt5025_write_reg(bi->client, RT5025_REG_VALRTMIN1, &vmin_th, 1);
1641
1642         RTINFO("vmax_th=0x%02x, vmin_th=0x%02x\n", vmax_th, vmin_th);
1643         return 0;
1644 }
1645
1646 static int rt5025_gauge_reginit(struct i2c_client *client)
1647 {
1648         rt5025_reg_block_write(client, RT5025_REG_VALRTMAX,
1649                 5, gauge_init_regval);
1650         rt5025_reg_write(client, RT5025_REG_IRQCTL, 0x00);
1651         rt5025_reg_read(client, RT5025_REG_IRQFLG);
1652         RTINFO("\n");
1653         return 0;
1654 }
1655
1656 static int rt5025_battery_suspend(struct platform_device *pdev,
1657         pm_message_t state)
1658 {
1659         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1660
1661         RTINFO("\n");
1662         /*rt5025_get_timer(bi);*/
1663         /*bi->last_event = ktime_get();*/
1664         bi->last_event = current_kernel_time();
1665
1666         /*cy add for battery parameter backup
1667         //rt5025_battery_parameter_backup(bi);
1668
1669         //rt5025_channel_cc(bi, false);
1670         //rt5025_update(bi);*/
1671         bi->device_suspend = true;
1672         cancel_delayed_work_sync(&bi->monitor_work);
1673         /* prevent suspend before starting the alarm */
1674         /*bi->update_time = SUSPEND_POLL;*/
1675         rt5025_alert_setting(bi, MAXVOLT, false);
1676         rt5025_alert_setting(bi, MINVOLT1, false);
1677         rt5025_battery_sleepvth_setting(bi);
1678         if (bi->status == POWER_SUPPLY_STATUS_CHARGING)
1679                 rt5025_alert_setting(bi, MAXVOLT, true);
1680         else if (bi->status == POWER_SUPPLY_STATUS_DISCHARGING)
1681                 rt5025_alert_setting(bi, MINVOLT1, true);
1682         RTINFO("RM=%d\n", bi->rm);
1683         return 0;
1684 }
1685
1686 static int rt5025_battery_resume(struct platform_device *pdev)
1687 {
1688         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1689
1690         /*ktime_t now;
1691         //struct timespec now = current_kernel_time();
1692         //struct timeval tv;
1693         //long time_interval;
1694
1695         //now = ktime_get();
1696         //tv = ktime_to_timeval(ktime_sub(now, bi->last_event));
1697         //RTINFO("Sleep time = %d\n",(u32)tv.tv_sec);
1698         //bi->rm = bi->rm - ((u32)tv.tv_sec * SLEEP_CURRENT);
1699
1700         //time_interval = now.tv_sec - bi->last_event.tv_sec;
1701         //bi->rm = bi->rm - (time_interval * SLEEP_CURRENT);
1702         //RTINFO("Sleep time=%d, RM=%d",(int)time_interval,bi->rm);
1703
1704         //rt5025_channel_cc(bi, true);*/
1705         bi->last_suspend = true;
1706         bi->device_suspend = false;
1707         schedule_delayed_work(&bi->monitor_work, 0);
1708         RTINFO("\n");
1709         return 0;
1710 }
1711
1712 static int rt5025_battery_remove(struct platform_device *pdev)
1713 {
1714         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1715
1716         power_supply_unregister(&bi->battery);
1717         cancel_delayed_work(&bi->monitor_work);
1718         wake_lock_destroy(&bi->monitor_wake_lock);
1719         RTINFO("\n");
1720         return 0;
1721 }
1722
1723 static int rt5025_battery_probe(struct platform_device *pdev)
1724 {
1725         struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
1726         struct rt5025_battery_info *bi;
1727         int ret;
1728
1729         bi = devm_kzalloc(&pdev->dev, sizeof(*bi), GFP_KERNEL);
1730         if (!bi)
1731                 return -ENOMEM;
1732
1733         bi->client = chip->i2c;
1734
1735         INIT_DELAYED_WORK(&bi->monitor_work, rt5025_update_work);
1736
1737         wake_lock_init(&bi->monitor_wake_lock,
1738                 WAKE_LOCK_SUSPEND, "rt-battery-monitor");
1739         wake_lock_init(&bi->low_battery_wake_lock,
1740                 WAKE_LOCK_SUSPEND, "low_battery_wake_lock");
1741         wake_lock_init(&bi->status_wake_lock,
1742                 WAKE_LOCK_SUSPEND, "battery-status-changed");
1743         wake_lock_init(&bi->smooth100_wake_lock,
1744                 WAKE_LOCK_SUSPEND, "smooth100_soc_wake_lock");
1745         wake_lock_init(&bi->smooth0_wake_lock,
1746                 WAKE_LOCK_SUSPEND, "smooth0_soc_wake_lock");
1747         wake_lock_init(&bi->full_battery_wake_lock,
1748                 WAKE_LOCK_SUSPEND, "full_battery_wake_lock");
1749 #if RT5025_TEST_WAKE_LOCK
1750         wake_lock_init(&bi->test_wake_lock, WAKE_LOCK_SUSPEND, "rt-test");
1751 #endif
1752         mutex_init(&bi->status_change_lock);
1753         /* Write trimed data */
1754         /*rt5025_pretrim(client);*/
1755         rt5025_gauge_reginit(bi->client);
1756         /* enable channel */
1757         rt5025_register_init(bi);
1758         /* enable gauge IRQ */
1759         rt5025_alert_init(bi);
1760
1761         /* register callback functions */
1762         /*
1763         chip->cb.rt5025_gauge_irq_handler = rt5025_irq_handler;
1764         chip->cb.rt5025_gauge_set_status = rt5025_set_status;
1765         chip->cb.rt5025_gauge_set_online = rt5025_set_online;
1766         chip->cb.rt5025_gauge_suspend = rt5025_gauge_suspend;
1767         chip->cb.rt5025_gauge_resume = rt5025_gauge_resume;
1768         chip->cb.rt5025_gauge_remove = rt5025_gauge_remove;
1769         rt5025_register_gauge_callbacks(&chip->cb);
1770         */
1771
1772         platform_set_drvdata(pdev, bi);
1773
1774         bi->battery.name = RT_BATT_NAME;
1775         bi->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1776         bi->battery.set_property = rt5025_set_property;
1777         bi->battery.get_property = rt5025_get_property;
1778         bi->battery.properties = rt5025_battery_props;
1779         bi->battery.num_properties = ARRAY_SIZE(rt5025_battery_props);
1780
1781         ret = power_supply_register(&pdev->dev, &bi->battery);
1782         if (ret) {
1783                 pr_err("[RT5025] power supply register failed\n");
1784                 goto err_wake_lock;
1785         }
1786
1787         /*wake_lock(&bi->monitor_wake_lock);*/
1788 #if RT5025_TEST_WAKE_LOCK
1789         wake_lock(&bi->test_wake_lock);
1790 #endif
1791         schedule_delayed_work(&bi->monitor_work, INIT_POLL*HZ);
1792         chip->battery_info = bi;
1793
1794         pr_info("rt5025-battery driver is successfully loaded\n");
1795
1796         return 0;
1797 err_wake_lock:
1798         wake_lock_destroy(&bi->monitor_wake_lock);
1799         return ret;
1800 }
1801
1802 static void rt5025_battery_shutdown(struct platform_device *pdev)
1803 {
1804         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1805
1806         RTINFO("\n");
1807         if (bi->soc == 0 && bi->cal_fcc != 0) {
1808                 /*d. FCC update limitation +/-3%; 2013/12/27
1809                 //bi->fcc_aging = bi->cal_fcc/3600 - (bi->fcc -bi->fcc_aging);*/
1810                 u16 fcc_new  = 0;
1811
1812                 fcc_new = bi->cal_fcc / 3600 - (bi->fcc - bi->fcc_aging);
1813                 if (fcc_new > ((bi->fcc_aging * 103) / 100))
1814                         bi->fcc_aging = (bi->fcc_aging * 103) / 100;
1815                 else if (fcc_new < ((bi->fcc_aging * 97) / 100))
1816                         bi->fcc_aging = (bi->fcc_aging * 97) / 100;
1817                 else
1818                         bi->fcc_aging = fcc_new;
1819
1820                 RTINFO("bi->cal_fcc=%d\n", bi->cal_fcc);
1821         }
1822         rt5025_battery_parameter_backup(bi);
1823         RTINFO("\n");
1824 }
1825
1826 static struct of_device_id rt_match_table[] = {
1827         { .compatible = "rt,rt5025-battery",},
1828         {},
1829 };
1830
1831 static struct platform_driver rt5025_battery_driver = {
1832         .driver = {
1833                 .name = RT5025_DEV_NAME "-battery",
1834                 .owner = THIS_MODULE,
1835                 .of_match_table = rt_match_table,
1836         },
1837         .probe = rt5025_battery_probe,
1838         .remove = rt5025_battery_remove,
1839         .shutdown = rt5025_battery_shutdown,
1840         .suspend = rt5025_battery_suspend,
1841         .resume = rt5025_battery_resume,
1842 };
1843
1844 static int rt5025_battery_init(void)
1845 {
1846         return platform_driver_register(&rt5025_battery_driver);
1847 }
1848 fs_initcall_sync(rt5025_battery_init);
1849
1850 static void rt5025_battery_exit(void)
1851 {
1852         platform_driver_unregister(&rt5025_battery_driver);
1853 }
1854 module_exit(rt5025_battery_exit);
1855
1856
1857 MODULE_LICENSE("GPL");
1858 MODULE_AUTHOR("Nick Hung <nick_hung@richtek.com>");
1859 MODULE_DESCRIPTION("battery gauge driver for RT5025");
1860 MODULE_ALIAS("platform:" RT5025_DEV_NAME "-battery");
1861 MODULE_VERSION(RT5025_DRV_VER);