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) 2013
   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.
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/delay.h>
  16 #include <linux/err.h>
  17 #include <linux/init.h>
  18 #include <linux/i2c.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/power_supply.h>
  22 #include <linux/slab.h>
  23 #include <linux/wakelock.h>
  24 #include <linux/workqueue.h>
  25 #include <linux/jiffies.h>
  26 #include <linux/timer.h>
  27 #include <linux/android_alarm.h>
  28 #include <linux/mfd/rt5025.h>
  29 #include <linux/power/rt5025-battery.h>
  30
  31 #define VOLTAGE_ALERT 0
  32 #define TEMPERATURE_ALERT 0
  33
  34 #define RT5025_CSV 0
  35 #define RT5025_B 1
  36 #define RT5025_TEST_WAKE_LOCK 0
  37
  38 u8 irq_thres[LAST_TYPE];
  39
  40 static int rt5025_battery_parameter_backup(struct rt5025_battery_info *);
  41
  42 void rt5025_gauge_set_status(struct rt5025_battery_info *bi, int status)
  43 {
  44   bi->status = status;
  45   if (status == POWER_SUPPLY_STATUS_FULL)
  46   {
  47         bi->tp_flag = true;
  48         bi->last_tp_flag = true;
  49   }
  50   else
  51         power_supply_changed(&bi->battery);
  52   wake_lock_timeout(&bi->status_wake_lock, 1.5*HZ);
  53   schedule_delayed_work(&bi->monitor_work, 0);
  54 }
  55 EXPORT_SYMBOL(rt5025_gauge_set_status);
  56
  57 void rt5025_gauge_set_online(struct rt5025_battery_info *bi, bool present)
  58 {
  59   bi->online = present;
  60 }
  61 EXPORT_SYMBOL(rt5025_gauge_set_online);
  62
  63 static int rt5025_read_reg(struct i2c_client *client,
  64                                 u8 reg, u8 *data, u8 len)
  65 {
  66         #if 1
  67         return rt5025_reg_block_read(client, reg, len, data);
  68         #else
  69         struct i2c_adapter *adap = client->adapter;
  70         struct i2c_msg msgs[2];
  71         int ret;
  72
  73         msgs[0].addr = client->addr;
  74         msgs[0].flags = client->flags;
  75         msgs[0].len = 1;
  76         msgs[0].buf = &reg;
  77
  78         msgs[1].addr = client->addr;
  79         msgs[1].flags = client->flags | I2C_M_RD;
  80         msgs[1].len = len;
  81         msgs[1].buf = data;
  82
  83         ret = i2c_transfer(adap, msgs, 2);
  84
  85         return (ret == 2)? len : ret;
  86         #endif
  87 }
  88
  89 static int rt5025_write_reg(struct i2c_client *client,
  90                                 u8 reg, u8 *data, u8 len)
  91 {
  92         #if 1
  93         return rt5025_reg_block_write(client, reg, len, data);
  94         #else
  95         struct i2c_adapter *adap = client->adapter;
  96         struct i2c_msg msg;
  97         int ret;
  98         char *tx_buf = (char *)kmalloc(len + 1, GFP_KERNEL);
  99
 100         if(!tx_buf)
 101                 return -ENOMEM;
 102         tx_buf[0] = reg;
 103         memcpy(tx_buf+1, data, len);
 104
 105         msg.addr = client->addr;
 106         msg.flags = client->flags;
 107         msg.len = len + 1;
 108         msg.buf = (char *)tx_buf;
 109
 110         ret = i2c_transfer(adap, &msg, 1);
 111         kfree(tx_buf);
 112         return (ret == 1) ? len : ret;
 113         #endif
 114 }
 115
 116 static void rt5025_gauge_alarm(struct alarm *alarm)
 117 {
 118         struct rt5025_battery_info *bi = (struct rt5025_battery_info *)container_of(alarm, struct rt5025_battery_info, wakeup_alarm);
 119
 120         //wake_lock(&bi->monitor_wake_lock);
 121         schedule_delayed_work(&bi->monitor_work, 0);
 122 }
 123
 124 static void rt5025_program_alarm(struct rt5025_battery_info *bi)
 125 {
 126         ktime_t low_interval = ktime_set(bi->update_time, 0);
 127         //ktime_t slack = ktime_set(20, 0);
 128         ktime_t next;
 129
 130         next = ktime_add(bi->last_poll, low_interval);
 131         //alarm_start_range(&bi->wakeup_alarm, next, ktime_add(next, slack));
 132 }
 133
 134 #if 0
 135 static void rt5025_run_time(struct rt5025_battery_info *bi)
 136 {
 137         if(bi->curr <= 0)
 138         {
 139                 bi->time_to_empty = bi->rm / (bi->curr*(-1));
 140         }
 141         else
 142         {
 143                 bi->time_to_full = (bi->fcc * 3600 - bi->rm) / bi->curr;
 144         }
 145         RTINFO("RTTF = %d\n",bi->time_to_full);
 146         RTINFO("RTTE = %d\n",bi->time_to_empty);
 147 }
 148 #endif
 149
 150 static int rt5025_get_property(struct power_supply *psy,
 151                             enum power_supply_property psp,
 152                             union power_supply_propval *val)
 153 {
 154   struct rt5025_battery_info *bi = dev_get_drvdata(psy->dev->parent);
 155
 156   switch (psp) {
 157     case POWER_SUPPLY_PROP_STATUS:
 158       val->intval = bi->status;
 159       //val->intval = POWER_SUPPLY_STATUS_CHARGING;
 160       break;
 161     case POWER_SUPPLY_PROP_HEALTH:
 162       val->intval = bi->health;
 163       break;
 164     case POWER_SUPPLY_PROP_PRESENT:
 165       val->intval = bi->present;
 166       break;
 167     case POWER_SUPPLY_PROP_TEMP:
 168       val->intval = bi->ext_temp;
 169       break;
 170     case POWER_SUPPLY_PROP_ONLINE:
 171       val->intval = bi->online;
 172       break;
 173     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 174       val->intval = bi->vcell * 1000; //uV
 175       break;
 176     case POWER_SUPPLY_PROP_CURRENT_NOW:
 177       val->intval = bi->curr * 1000; //uA
 178       break;
 179     case POWER_SUPPLY_PROP_CAPACITY:
 180       val->intval = bi->soc;
 181                         //val->intval = 50;
 182       if (val->intval > 100)
 183                                 val->intval = 100;
 184       break;
 185     case POWER_SUPPLY_PROP_TECHNOLOGY:
 186       val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 187       break;
 188     #if 0
 189     case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
 190                         val->intval = bi->time_to_empty;
 191     break;
 192     case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
 193                         val->intval = bi->time_to_full;
 194     #endif
 195     break;
 196     default:
 197       return -EINVAL;
 198   }
 199   return 0;
 200 }
 201
 202 static void rt5025_get_vcell(struct rt5025_battery_info *bi)
 203 {
 204   u8 data[2];
 205
 206   if (bi->init_once)
 207   {
 208     rt5025_clr_bits(bi->client, 0x07, 0x10);
 209     RTINFO("set_current switch off\n");
 210     mdelay(1000);
 211   }
 212
 213   if (rt5025_read_reg(bi->client, RT5025_REG_VCELL_MSB, data, 2) < 0){
 214     printk(KERN_ERR "%s: Failed to read Voltage\n", __func__);
 215   }
 216
 217   if (bi->init_once)
 218   {
 219     rt5025_set_bits(bi->client, 0x07, 0x10);
 220     RTINFO("set_current switch on\n");
 221   }
 222
 223   if (bi->avg_flag)
 224     bi->vcell = ((data[0] << 8) + data[1]) * 61 / 100;
 225   else
 226           bi->vcell = (bi->vcell + ((data[0] << 8) + data[1]) * 61 / 100) / 2;
 227 #if RT5025_B
 228         bi->curr_offset = (15444 * bi->vcell - 27444000) / 10000;
 229 #else
 230   if (37 * bi->vcell > 92000)
 231                 bi->curr_offset = (37 * bi->vcell - 92000) / 1000;
 232         else
 233                 bi->curr_offset = 0;
 234 #endif
 235
 236 #if RT5025_CSV
 237  // if (!bi->avg_flag)
 238   //  pr_info("%d,%d,", bi->vcell, bi->curr_offset);
 239 #else
 240   if (bi->avg_flag)
 241                 RTINFO("vcell_pre: %d, offset: %d\n", bi->vcell, bi->curr_offset);
 242   else
 243                 RTINFO("vcell_avg: %d, offset: %d\n", bi->vcell, bi->curr_offset);
 244 #endif
 245 }
 246
 247 static void rt5025_get_current(struct rt5025_battery_info *bi)
 248 {
 249   u8 data[2];
 250   s32 temp;
 251   int sign = 0;
 252   u8 curr_region;
 253
 254   if (rt5025_read_reg(bi->client, RT5025_REG_CURRENT_MSB, data, 2) < 0) {
 255     printk(KERN_ERR "%s: Failed to read CURRENT\n", __func__);
 256   }
 257 #if RT5025_B
 258   temp = (data[0]<<8) | data[1];
 259   bi->curr_raw = ((temp & 0x7FFF) * 3125) / 10000;
 260
 261   if (data[0] & (1 << 7)) {
 262     sign = 1;
 263     temp = (((temp & 0x7FFF) * 3125) / 10 + bi->curr_offset) / 1000;
 264   }else{
 265                 if ((temp * 3125) / 10 > bi->curr_offset)
 266                         temp = ((temp * 3125) / 10 - bi->curr_offset) / 1000;
 267         }
 268
 269   if (temp < DEADBAND)
 270                 temp = 0;
 271
 272   if (sign){
 273     temp *= -1;
 274     bi->curr_raw *= -1;
 275         }
 276 #else
 277   temp = (data[0]<<8) | data[1];
 278   if (data[0] & (1 << 7)) {
 279     sign = 1;
 280     temp = temp & 0x7FFF;
 281     if(temp > bi->curr_offset)
 282                         temp = temp - bi->curr_offset;
 283   }else {
 284     temp = temp + bi->curr_offset;
 285         }
 286
 287   temp = (temp * 37375) / 100000; //Unit: 0.3125mA
 288   if (temp < DEADBAND)
 289                 temp = 0;
 290
 291   if (sign)
 292     temp *= -1;
 293 #endif
 294
 295   if (bi->avg_flag)
 296     bi->curr = temp;
 297   else
 298           bi->curr = (bi->curr + temp) / 2;
 299
 300   if (bi->curr > -500)
 301         curr_region = 0;
 302   else if (bi->curr <= -500 && bi->curr > -1500)
 303         curr_region = 1;
 304   else
 305         curr_region = 2;
 306
 307   if (curr_region != bi->edv_region)
 308   {
 309         switch (curr_region)
 310         {
 311                 case 0:
 312                         bi->empty_edv = rt5025_battery_param2[4].x;
 313                         break;
 314                 case 1:
 315                         bi->empty_edv = rt5025_battery_param2[4].x - 75;
 316                         break;
 317                 case 2:
 318                         bi->empty_edv = rt5025_battery_param2[4].x - 100 ;
 319                         break;
 320         }
 321         bi->edv_region = curr_region;
 322   }
 323   RTINFO("empty_voltage=%d\n", bi->empty_edv);
 324
 325   if(bi->curr > 0)
 326   {
 327     bi->internal_status = POWER_SUPPLY_STATUS_CHARGING;
 328     bi->last_tp_flag = false;
 329   }
 330   else
 331     bi->internal_status = POWER_SUPPLY_STATUS_DISCHARGING;
 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         if (rt5025_read_reg(bi->client, RT5025_REG_INT_TEMPERATUE_MSB, data, 2) < 0){
 350                 printk(KERN_ERR "%s: Failed to read internal TEMPERATURE\n", __func__);
 351         }
 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_EXT_TEMPERATUE_MSB, data, 2) < 0) {
 368     printk(KERN_ERR "%s: Failed to read TEMPERATURE\n", __func__);
 369   }
 370   bi->ain_volt = (data[0] * 256 + data[1]) * 61 / 100;
 371   if(bi->ain_volt < 1150)
 372   {
 373         bi->present = 1;
 374   }
 375   else
 376   {
 377         bi->present = 0;
 378   }
 379
 380   temp =  (bi->ain_volt * (-91738) + 81521000) / 100000;
 381   bi->ext_temp = (int)temp;
 382         //test
 383         //bi->ext_temp = 250;
 384
 385         if (bi->ext_temp >= HIGH_TEMP_THRES) {
 386                 if (bi->health != POWER_SUPPLY_HEALTH_OVERHEAT)
 387                         bi->temp_high_cnt++;
 388         } else if (bi->ext_temp <= HIGH_TEMP_RECOVER && bi->ext_temp >= LOW_TEMP_RECOVER) {
 389                 if (bi->health == POWER_SUPPLY_HEALTH_OVERHEAT ||
 390                     bi->health == POWER_SUPPLY_HEALTH_COLD)
 391                         bi->temp_recover_cnt++;
 392         } else if (bi->ext_temp <= LOW_TEMP_THRES) {
 393                 if (bi->health != POWER_SUPPLY_HEALTH_COLD)
 394                         bi->temp_low_cnt++;
 395         }else {
 396                 bi->temp_high_cnt = 0;
 397                 bi->temp_low_cnt = 0;
 398                 bi->temp_recover_cnt = 0;
 399         }
 400
 401         if (bi->temp_high_cnt >= TEMP_ABNORMAL_COUNT) {
 402          bi->health = POWER_SUPPLY_HEALTH_OVERHEAT;
 403          bi->temp_high_cnt = 0;
 404         } else if (bi->temp_low_cnt >= TEMP_ABNORMAL_COUNT) {
 405          bi->health = POWER_SUPPLY_HEALTH_COLD;
 406          bi->temp_low_cnt = 0;
 407         } else if (bi->temp_recover_cnt >= TEMP_ABNORMAL_COUNT) {
 408          bi->health = POWER_SUPPLY_HEALTH_GOOD;
 409          bi->temp_recover_cnt = 0;
 410         }
 411         RTINFO("external temperature: %d\n", bi->ext_temp);
 412 }
 413
 414 static void rt5025_clear_cc(struct rt5025_battery_info *bi, operation_mode mode)
 415 {
 416   u8 data[2];
 417
 418   if (rt5025_read_reg(bi->client, RT5025_REG_CHANNEL_MSB, data, 2) < 0){
 419     pr_err("%s: failed to read channel\n", __func__);
 420   }
 421
 422   if (mode == CHG)
 423                 data[0] = data[0] | CHANNEL_H_BIT_CLRQCHG;
 424         else
 425                 data[0] = data[0] | CHANNEL_H_BIT_CLRQDCHG;
 426
 427   if (rt5025_write_reg(bi->client, RT5025_REG_CHANNEL_MSB, data, 2) < 0){
 428     pr_err("%s: failed to write channel\n", __func__);
 429   }
 430 }
 431
 432 static void rt5025_get_chg_cc(struct rt5025_battery_info *bi)
 433 {
 434   u8 data[4];
 435   u32 qh_old,ql_old,qh_new,ql_new;
 436   u32 cc_masec,offset=0;
 437
 438   if (rt5025_read_reg(bi->client, RT5025_REG_QCHGH_MSB, data, 4) < 0){
 439     pr_err("%s: Failed to read QCHG\n", __func__);
 440   }
 441   qh_old = (data[0]<<8) + data[1];
 442   ql_old = (data[2]<<8) + data[3];
 443   RTINFO("qh_old=%d, ql_old=%d\n", qh_old, ql_old);
 444
 445   if (rt5025_read_reg(bi->client, RT5025_REG_QCHGH_MSB, data, 4) < 0){
 446     pr_err("%s: Failed to read QCHG\n", __func__);
 447   }
 448   qh_new = (data[0]<<8) + data[1];
 449   ql_new = (data[2]<<8) + data[3];
 450   RTINFO("qh_new=%d, ql_new=%d\n", qh_new, ql_new);
 451
 452 #if RT5025_B
 453   if (qh_new > qh_old){
 454      //cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;
 455      cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
 456   }else if (qh_new == qh_old){
 457     if (ql_new >= ql_old){
 458      //cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;
 459      cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
 460     }else {
 461       //cc_masec = (((qh_old<<16) + ql_old) * 50134) / 10;
 462      cc_masec = qh_old*328558+(qh_old*1824+ql_old*50134)/10000;
 463                 }
 464   }
 465
 466   if (!bi->init_once)
 467         offset = bi->curr_offset * bi->time_interval;
 468
 469   if (cc_masec > offset){
 470                 cc_masec = cc_masec - (offset / 1000);
 471         }
 472 #else
 473   if (qh_new > qh_old){
 474      cc_masec = (((qh_new<<16) + ql_new) * 5996) / 1000;
 475   }else if (qh_new == qh_old){
 476     if (ql_new >= ql_old){
 477       cc_masec = (((qh_new<<16) + ql_new) * 5996) / 1000;
 478     }else {
 479       cc_masec = (((qh_old<<16) + ql_old) * 5996) / 1000;
 480                 }
 481   }
 482
 483         offset = (bi->curr_offset * bi->time_interval * 37375) / 100000;
 484
 485   if (cc_masec != 0){
 486                 cc_masec = cc_masec - offset;
 487         }
 488 #endif
 489         if (cc_masec < (DEADBAND * bi->time_interval))
 490                 cc_masec = 0;
 491
 492 #if RT5025_CSV
 493   //pr_info("%d,\n", cc_masec);
 494 #else
 495         RTINFO("chg_cc_mAsec: %d\n", cc_masec);
 496 #endif
 497
 498         //if (!bi->init_once)
 499                 bi->chg_cc = cc_masec;
 500         //bi->chg_cc = (cc_masec + bi->chg_cc_unuse) / 3600;
 501   //bi->chg_cc_unuse = (cc_masec + bi->chg_cc_unuse) % 3600;
 502   rt5025_clear_cc(bi, CHG);
 503 }
 504
 505 static void rt5025_get_dchg_cc(struct rt5025_battery_info *bi)
 506 {
 507   u8 data[4];
 508   u32 qh_old,ql_old,qh_new,ql_new;
 509   u32 cc_masec,offset;
 510
 511   if (rt5025_read_reg(bi->client, RT5025_REG_QDCHGH_MSB, data, 4) < 0){
 512     printk(KERN_ERR "%s: Failed to read QDCHG\n", __func__);
 513   }
 514   qh_old = (data[0]<<8) + data[1];
 515   ql_old = (data[2]<<8) + data[3];
 516
 517   if (rt5025_read_reg(bi->client, RT5025_REG_QDCHGH_MSB, data, 4) < 0){
 518     printk(KERN_ERR "%s: Failed to read QDCHG\n", __func__);
 519   }
 520   qh_new = (data[0]<<8) + data[1];
 521   ql_new = (data[2]<<8) + data[3];
 522
 523 #if RT5025_B
 524   if (qh_new > qh_old){
 525      //cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;
 526      cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
 527   }else if (qh_new == qh_old){
 528     if (ql_new >= ql_old){
 529      //cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;
 530      cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
 531     }else {
 532      //cc_masec = (((qh_old<<16) + ql_old) * 50134) / 10;
 533      cc_masec = qh_old*328558+(qh_old*1824+ql_old*50134)/10000;
 534                 }
 535   }
 536
 537   if (!bi->init_once)
 538         offset = bi->curr_offset * bi->time_interval;
 539
 540   if (cc_masec != 0){
 541                 cc_masec = cc_masec + (offset / 1000);
 542         }
 543 #else
 544   if (qh_new > qh_old){
 545      cc_masec = (((qh_new<<16) + ql_new) * 5996) / 1000;
 546   }else if (qh_new == qh_old){
 547     if (ql_new >= ql_old){
 548       cc_masec = (((qh_new<<16) + ql_new) * 5996) / 1000;
 549     }else {
 550       cc_masec = (((qh_old<<16) + ql_old) * 5996) / 1000;
 551                 }
 552   }
 553
 554         offset = (bi->curr_offset * bi->time_interval * 37375) / 100000;
 555
 556   if (cc_masec > offset){
 557                 cc_masec = cc_masec - offset;
 558         }
 559 #endif
 560         if (cc_masec < (DEADBAND * bi->time_interval))
 561                 cc_masec = 0;
 562
 563 #if RT5025_CSV
 564   //pr_info("%d,", cc_masec);
 565 #else
 566         RTINFO("dchg_cc_mAsec: %d\n", cc_masec);
 567 #endif
 568         bi->dchg_cc = cc_masec;
 569         if (bi->last_tp_flag)
 570                 bi->cal_fcc += cc_masec;
 571         else
 572                 bi->cal_fcc = 0;
 573         RTINFO("bi->cal_fcc=%d, bi->last_tp_flag=%d\n", bi->cal_fcc, bi->last_tp_flag);
 574         //bi->dchg_cc = (cc_masec + bi->dchg_cc_unuse) / 3600;
 575   //bi->dchg_cc_unuse = (cc_masec + bi->dchg_cc_unuse) % 3600;
 576         rt5025_clear_cc(bi, DCHG);
 577
 578 }
 579
 580 static void rt5025_cycle_count(struct rt5025_battery_info *bi)
 581 {
 582         bi->acc_dchg_cap +=  bi->dchg_cc;
 583         if(bi->acc_dchg_cap >= (bi->dc * 3600)){
 584                 bi->cycle_cnt++;
 585                 bi->acc_dchg_cap -= (bi->dc * 3600);
 586         }
 587 }
 588
 589 static void rt5025_get_irq_flag(struct rt5025_battery_info *bi, u8 flag)
 590 {
 591 #if 0
 592   u8 data[1];
 593
 594   if (rt5025_read_reg(bi->client, RT5025_REG_IRQ_FLAG, data, 1) < 0){
 595     pr_err("%s: Failed to read irq_flag\n", __func__);
 596   }
 597 #endif
 598
 599   bi->irq_flag = flag;
 600         //RTINFO("IRQ_FLG 0x%x\n", bi->irq_flag);
 601 }
 602
 603 static void rt5025_get_timer(struct rt5025_battery_info *bi)
 604 {
 605   u8 data[2];
 606   //frankie
 607         //u16 gauge_timer;
 608
 609   if (rt5025_read_reg(bi->client, RT5025_REG_TIMER, data, 2) < 0){
 610         pr_err("%s: Failed to read Timer\n", __func__);
 611   }
 612
 613   bi->gauge_timer = (data[0] << 8) + data[1];
 614   if (!bi->device_suspend){
 615     if (bi->gauge_timer > bi->pre_gauge_timer)
 616                   bi->time_interval = bi->gauge_timer - bi->pre_gauge_timer;
 617           else
 618                   bi->time_interval = 65536 - bi->pre_gauge_timer + bi->gauge_timer;
 619   }
 620
 621   bi->pre_gauge_timer = bi->gauge_timer;
 622 #if RT5025_CSV
 623  // pr_info("%d,%d,", bi->gauge_timer,bi->time_interval);
 624 #else
 625         RTINFO("timer %d , interval %d\n", bi->gauge_timer,bi->time_interval);
 626 #endif
 627 }
 628
 629 static void rt5025_alert_setting(struct rt5025_battery_info *bi, alert_type type, bool enable)
 630 {
 631         u8 data[1];
 632
 633         if (rt5025_read_reg(bi->client, RT5025_REG_IRQ_CTL, data, 1) < 0){
 634                 printk(KERN_ERR "%s: Failed to read CONFIG\n", __func__);
 635         }
 636
 637         if(enable){
 638                 switch(type){
 639                         case MAXTEMP:
 640                                 data[0] |= IRQ_CTL_BIT_TMX; //Enable max temperature alert
 641                                 bi->max_temp_irq = true;
 642                                 //RTDBG("Enable min temperature alert");
 643                                 break;
 644                         case MINTEMP:
 645                                 data[0] |= IRQ_CTL_BIT_TMN; //Enable min temperature alert
 646                                 bi->min_temp_irq = true;
 647                                 //RTDBG("Enable max temperature alert");
 648                                 break;
 649                         case MAXVOLT:
 650                                 data[0] |= IRQ_CTL_BIT_VMX; //Enable max voltage alert
 651                                 bi->max_volt_irq = true;
 652                                 //RTDBG("Enable max voltage alert");
 653                                 break;
 654                         case MINVOLT1:
 655                                 data[0] |= IRQ_CTL_BIT_VMN1; //Enable min1 voltage alert
 656                                 bi->min_volt1_irq = true;
 657                                 //RTDBG("Enable min1 voltage alert");
 658                                 break;
 659                         case MINVOLT2:
 660                                 data[0] |= IRQ_CTL_BIT_VMN2; //Enable min2 voltage alert
 661                                 bi->min_volt2_irq = true;
 662                                 //RTDBG("Enable min2 voltage alert");
 663                                 break;
 664                         default:
 665                                 break;
 666                 }
 667         }else{
 668                 switch(type){
 669                         case MAXTEMP:
 670                                 data[0] = data[0] &~ IRQ_CTL_BIT_TMX; //Disable max temperature alert
 671                                 bi->max_temp_irq = false;
 672                                 //RTDBG("Disable min temperature alert");
 673                                 break;
 674                         case MINTEMP:
 675                                 data[0] = data[0] &~ IRQ_CTL_BIT_TMN; //Disable min temperature alert
 676                                 bi->min_temp_irq = false;
 677                                 //RTDBG("Disable max temperature alert");
 678                                 break;
 679                         case MAXVOLT:
 680                                 data[0] = data[0] &~ IRQ_CTL_BIT_VMX; //Disable max voltage alert
 681                                 bi->max_volt_irq = false;
 682                                 //RTDBG("Disable max voltage alert");
 683                                 break;
 684                         case MINVOLT1:
 685                                 data[0] = data[0] &~ IRQ_CTL_BIT_VMN1; //Disable min1 voltage alert
 686                                 bi->min_volt1_irq = false;
 687                                 //RTDBG("Disable min1 voltage alert");
 688                                 break;
 689                         case MINVOLT2:
 690                                 data[0] = data[0] &~ IRQ_CTL_BIT_VMN2; //Disable min2 voltage alert
 691                                 bi->min_volt2_irq = false;
 692                                 //RTDBG("Disable min2 voltage alert");
 693                                 break;
 694                         default:
 695                                 break;
 696                 }
 697         }
 698         if (rt5025_write_reg(bi->client, RT5025_REG_IRQ_CTL, data, 1) < 0)
 699                 pr_err("%s: failed to write IRQ control\n", __func__);
 700 }
 701
 702 static void rt5025_alert_threshold_init(struct i2c_client *client)
 703 {
 704         u8 data[1];
 705
 706         #if 0 //change the operating right to jeita driver
 707         /* TALRT MAX threshold setting */
 708         data[0] = irq_thres[MAXTEMP];
 709         if (rt5025_write_reg(client, RT5025_REG_TALRT_MAXTH, data, 1) < 0)
 710                 printk(KERN_ERR "%s: failed to write TALRT MAX threshold\n", __func__);
 711         /* TALRT MIN threshold setting */
 712         data[0] = irq_thres[MINTEMP];
 713         if (rt5025_write_reg(client, RT5025_REG_TALRT_MINTH, data, 1) < 0)
 714                 printk(KERN_ERR "%s: failed to write TALRT MIN threshold\n", __func__);
 715         #endif
 716         /* VALRT MAX threshold setting */
 717         data[0] = irq_thres[MAXVOLT];
 718         if (rt5025_write_reg(client, RT5025_REG_VALRT_MAXTH, data, 1) < 0)
 719                 printk(KERN_ERR "%s: failed to write VALRT MAX threshold\n", __func__);
 720         /* VALRT MIN1 threshold setting */
 721         data[0] = irq_thres[MINVOLT1];
 722         if (rt5025_write_reg(client, RT5025_REG_VALRT_MIN1TH, data, 1) < 0)
 723                 printk(KERN_ERR "%s: failed to write VALRT MIN1 threshold\n", __func__);
 724         /* VALRT MIN2 threshold setting */
 725         data[0] = irq_thres[MINVOLT2];
 726         if (rt5025_write_reg(client, RT5025_REG_VALRT_MIN2TH, data, 1) < 0)
 727                 printk(KERN_ERR "%s: failed to write VALRT MIN2 threshold\n", __func__);
 728 }
 729
 730 static void rt5025_alert_init(struct rt5025_battery_info *bi)
 731 {
 732
 733         /* Set RT5025 gauge alert configuration */
 734         rt5025_alert_threshold_init(bi->client);
 735         /* Enable gauge alert function */
 736         //rt5025_alert_setting(bi, MINVOLT2,VOLTAGE_ALERT);
 737 }
 738
 739 void rt5025_gauge_irq_handler(struct rt5025_battery_info *bi, u8 irq_flag)
 740 {
 741   rt5025_get_irq_flag(bi, irq_flag);
 742
 743   if ((bi->irq_flag) & IRQ_FLG_BIT_TMX){
 744                 //printk(KERN_INFO "[RT5025]: Min temperature IRQ received\n");
 745                 rt5025_alert_setting(bi,MAXTEMP,false);
 746                 bi->max_temp_irq = false;
 747         }
 748   if ((bi->irq_flag) & IRQ_FLG_BIT_TMN){
 749                 //printk(KERN_INFO "[RT5025]: Max temperature IRQ received\n");
 750                 rt5025_alert_setting(bi,MINTEMP,false);
 751                 bi->min_temp_irq = false;
 752         }
 753   if ((bi->irq_flag) & IRQ_FLG_BIT_VMX){
 754                 //printk(KERN_INFO "[RT5025]: Max voltage IRQ received\n");
 755                 rt5025_alert_setting(bi,MAXVOLT,false);
 756                 bi->max_volt_irq = false;
 757         }
 758   if ((bi->irq_flag) & IRQ_FLG_BIT_VMN1){
 759                 //printk(KERN_INFO "[RT5025]: Min voltage1 IRQ received\n");
 760                 rt5025_alert_setting(bi,MINVOLT1,false);
 761                 bi->min_volt1_irq = false;
 762         }
 763   if ((bi->irq_flag) & IRQ_FLG_BIT_VMN2){
 764                 //printk(KERN_INFO "[RT5025]: Min voltage2 IRQ received\n");
 765                 rt5025_alert_setting(bi,MINVOLT2,false);
 766                 bi->min_volt2_irq = false;
 767                 bi->min_volt2_alert = true;
 768                 wake_lock_timeout(&bi->low_battery_wake_lock, msecs_to_jiffies(LOW_BAT_WAKE_LOK_TIME*MSEC_PER_SEC));
 769         }
 770
 771         //wake_lock(&bi->monitor_wake_lock);
 772         wake_lock_timeout(&bi->status_wake_lock, 1.5*HZ);
 773         schedule_delayed_work(&bi->monitor_work, 0);
 774 }
 775 EXPORT_SYMBOL(rt5025_gauge_irq_handler);
 776
 777 static void rt5025_convert_masec_to_permille(struct rt5025_battery_info *bi)
 778 {
 779   bi->permille = bi->rm / 3600 * 1000 / bi->fcc;
 780   RTINFO("permille=%d\n", bi->permille);
 781   return;
 782 }
 783
 784 static void rt5025_convert_permille_to_masec(struct rt5025_battery_info *bi)
 785 {
 786   bi->rm = bi->permille * bi->fcc / 1000 * 3600;
 787   return;
 788 }
 789
 790 static void rt5025_init_capacity(struct rt5025_battery_info *bi)
 791 {
 792   int i = 1;
 793   int size;
 794   int slope, const_term;
 795   int delta_y, delta_x;
 796
 797   size = ARRAY_SIZE(rt5025_battery_param1);
 798   while((bi->vcell < rt5025_battery_param1[i].x) &&
 799                                 (i < (size - 1))){
 800     i++;
 801   }
 802
 803   delta_x = rt5025_battery_param1[i-1].x - rt5025_battery_param1[i].x;
 804   delta_y = (rt5025_battery_param1[i-1].y - rt5025_battery_param1[i].y);
 805
 806   slope = delta_y  * 1000 / delta_x;
 807
 808   const_term = (rt5025_battery_param1[i].y) - ((rt5025_battery_param1[i].x * slope) / 1000);
 809
 810   if (bi->vcell >= rt5025_battery_param1[0].x)
 811     bi->permille = rt5025_battery_param1[0].y;
 812   else if (bi->vcell <= rt5025_battery_param1[size-1].x)
 813     bi->permille = rt5025_battery_param1[size-1].y;
 814   else
 815     bi->permille = (bi->vcell * slope) / 1000 + const_term;
 816   rt5025_convert_permille_to_masec(bi);
 817   bi->soc = bi->rm /36/bi->fcc_aging;
 818         bi->init_cap = false;
 819
 820   rt5025_battery_parameter_backup(bi);
 821
 822   //pr_err("[rt5025] i=%d, delta_x=%d, delta_y=%d, slope=%d, const_term=%d\n", i, delta_x, delta_y, slope, const_term);
 823         RTINFO("voltage=%d, permille=%d, soc=%d, rm=%d\n", bi->vcell, bi->permille, bi->soc, bi->rm);
 824   return;
 825 }
 826
 827 static void rt5025_smooth_soc(struct rt5025_battery_info *bi)
 828 {
 829         if ((bi->internal_status == POWER_SUPPLY_STATUS_CHARGING || bi->tp_flag == 1) &&
 830             (bi->soc < 100))
 831         {
 832                 bi->soc++;
 833                 bi->rm = bi->fcc * bi->soc * 36;
 834                 rt5025_convert_masec_to_permille(bi);
 835         }
 836         else if ((bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
 837                   (bi->soc > 0))
 838         {
 839                 bi->soc--;
 840                 bi->rm = bi->fcc * bi->soc * 36;
 841                 rt5025_convert_masec_to_permille(bi);
 842         }
 843         else
 844         {
 845           bi->smooth_flag = false;
 846           bi->update_time = NORMAL_POLL;
 847   }
 848 }
 849
 850
 851 static void rt5025_soc_irreversible(struct rt5025_battery_info *bi)
 852 {
 853         // Prevent inverse
 854         //if (!bi->init_cap){
 855         if (!bi->init_once){
 856                 if (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING)
 857                 {
 858                         if (bi->soc < bi->pre_soc)
 859                                 bi->soc = bi->pre_soc;
 860                 }
 861                 else if ((bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
 862                                                 (bi->tp_flag == 0))
 863                 {
 864                         if (bi->soc > bi->pre_soc)
 865                                 bi->soc = bi->pre_soc;
 866                 }
 867         }
 868         else
 869                 bi->init_once = false;
 870
 871         if (bi->pre_soc != bi->soc)
 872                 rt5025_battery_parameter_backup(bi);
 873
 874         bi->pre_soc = bi->soc;
 875         RTINFO("pre_soc=%d, soc=%d, internal status=%d\n", bi->pre_soc,bi->soc,bi->internal_status);
 876 }
 877
 878 static void rt5025_soc_lock(struct rt5025_battery_info *bi)
 879 {
 880          // lock 99%
 881   RTINFO("internal status=%d, tp_flag=%d, soc=%d\n", bi->internal_status, bi->tp_flag, bi->soc);
 882   if (bi->soc >= 99)
 883   {
 884         if (bi->tp_flag)
 885                 bi->soc = 100;
 886                 else if(bi->internal_status == POWER_SUPPLY_STATUS_CHARGING)
 887                 {
 888                                 bi->soc = 99;
 889                                 bi->pre_soc = 99;
 890                 }
 891   }
 892   else if ((bi->soc < 99) && (bi->tp_flag))
 893   {
 894                 if (!bi->last_suspend)
 895                 {
 896                         bi->update_time = SMOOTH_POLL;
 897                         bi->smooth_flag = true;
 898                         rt5025_smooth_soc(bi);
 899                 }
 900                 else
 901                         bi->last_suspend=false;
 902   }
 903   else
 904   {
 905                 bi->tp_flag = false;
 906   }
 907
 908   // lock 1%
 909   if ((bi->soc <= 1) &&
 910       (bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING)){
 911     if (bi->edv_flag)
 912       bi->soc = 0;
 913     else
 914     {
 915                         bi->soc = 1;
 916                         bi->pre_soc = 1;
 917                 }
 918
 919         }else if ((bi->soc > 1) &&
 920             (bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
 921             (bi->edv_flag)){
 922                 if (!bi->last_suspend)
 923                 {
 924                         bi->update_time = SMOOTH_POLL;
 925                         bi->smooth_flag = true;
 926                         rt5025_smooth_soc(bi);
 927                 }
 928                 else
 929                         bi->last_suspend=false;
 930         }else{
 931                 bi->edv_flag = false;
 932         }
 933 }
 934
 935 static void rt5025_get_soc(struct rt5025_battery_info *bi)
 936 {
 937   if (bi->smooth_flag){
 938     bi->smooth_flag = false;
 939     bi->update_time = NORMAL_POLL;
 940   }
 941         RTINFO("before rm=%d\n", bi->rm);
 942         if ((!bi->tp_flag) &&
 943                         (!bi->edv_flag)){
 944                 bi->rm = (bi->rm + bi->chg_cc) > bi->dchg_cc ?
 945                             bi->rm + bi->chg_cc - bi->dchg_cc : 0;
 946                 if (bi->rm > (bi->fcc * 3600))
 947                                         bi->rm = bi->fcc * 3600;
 948                 rt5025_convert_masec_to_permille(bi);
 949                 bi->soc = DIV_ROUND_UP(bi->permille, 10);
 950 #if RT5025_CSV
 951     bi->temp_soc = bi->soc;
 952     //pr_info("%d", bi->soc);
 953 #else
 954         RTINFO("after rm=%d\n", bi->rm);
 955                 RTINFO("temp_soc=%d\n", bi->soc);
 956 #endif
 957   }
 958 #if RT5025_CSV
 959  // pr_info("%d,%d,%d,%d,%d", bi->soc,bi->permille,bi->rm,bi->fcc,bi->smooth_flag);
 960 #else
 961         RTINFO("soc=%d, permille=%d, rm=%d, fcc=%d, smooth_flag=%d\n", bi->soc,bi->permille,bi->rm,bi->fcc,bi->smooth_flag);
 962 #endif
 963   return;
 964 }
 965
 966 static void rt5025_soc_relearn_check(struct rt5025_battery_info *bi)
 967 {
 968   // TP relearn
 969 /*  if ((bi->vcell >= TP_VOLT) &&
 970                         (bi->curr <= TP_CURR) &&
 971                         (bi->status == POWER_SUPPLY_STATUS_CHARGING) &&
 972                         (!bi->tp_flag)){
 973                 bi->tp_cnt++;
 974                 bi->update_time = TP_POLL;
 975         }else {
 976                 bi->tp_cnt = 0;
 977                 bi->update_time = NORMAL_POLL;
 978         }
 979
 980   if (bi->tp_cnt == TP_TOTAL_COUNT){
 981                 bi->tp_cnt = 0;
 982                 bi->tp_flag = true;
 983                 bi->rm = bi->fcc * 3600;
 984                 rt5025_convert_masec_to_permille();
 985                 bi->update_time = NORMAL_POLL;
 986         }*/
 987
 988         // if EOC happened, the tp_flag should be set 1.
 989         if(bi->tp_flag == true)
 990         {
 991                 bi->rm = bi->fcc * 3600;
 992                 rt5025_convert_masec_to_permille(bi);
 993                 bi->update_time = NORMAL_POLL;
 994         }
 995
 996         if (bi->vcell <= bi->empty_edv)
 997         {
 998                 if (bi->edv_cnt < 2)
 999                         bi->edv_cnt++;
1000         }
1001         else
1002                 bi->edv_cnt=0;
1003
1004         if(bi->empty_edv < bi->vcell && bi->vcell <= bi->empty_edv+300)
1005         {
1006                 bi->update_time = EDV_POLL;
1007                 bi->edv_detection = true;
1008         }
1009         else if((bi->vcell >= bi->empty_edv + 300 +EDV_HYS) && (bi->edv_detection == true))
1010         {
1011                  bi->update_time = NORMAL_POLL;
1012                  bi->edv_detection = false;
1013         }
1014         else if((bi->vcell <= bi->empty_edv && bi->edv_cnt == 2)) //&& (bi->min_volt2_alert == true))
1015         {
1016                 bi->edv_flag = true;
1017                 bi->rm = 0;
1018                 rt5025_convert_masec_to_permille(bi);
1019                 bi->edv_detection = false;
1020                 bi->update_time = NORMAL_POLL;
1021         }
1022         else if((bi->vcell > bi->empty_edv + EDV_HYS)) //&& (bi->min_volt2_alert == true))
1023         {
1024                 bi->min_volt2_alert = false;
1025                 bi->edv_flag = false;
1026         }
1027
1028         /*// EDV relearn
1029   if (bi->vcell <= EDV_VOLT){
1030                 if ((bi->curr <= EDV_CURR) ||
1031                                 (bi->vcell <= rt5025_battery_param2[4].x))
1032                         bi->edv_cnt++;
1033                 else
1034                 {
1035                         bi->edv_cnt = 0;
1036                 }
1037                 bi->edv_detection = true;
1038                 bi->update_time = EDV_POLL;
1039         }else if ((bi->vcell > (EDV_VOLT + EDV_HYS)) &&
1040                   (bi->edv_detection)) {
1041                 bi->edv_cnt = 0;
1042                 bi->edv_detection = false;
1043                 bi->edv_flag = false;
1044                 bi->update_time = NORMAL_POLL;
1045         }
1046         else
1047         {
1048                 bi->edv_cnt = 0;
1049         }
1050
1051   if (bi->edv_cnt == EDV_TOTAL_COUNT){
1052                 bi->edv_cnt = 0;
1053                 bi->edv_flag = true;
1054                 bi->rm = 0;
1055                 rt5025_convert_masec_to_permille();
1056                 bi->edv_detection = false;
1057                 bi->update_time = NORMAL_POLL;
1058         }
1059   if(bi->edv_detection)
1060   {
1061         bi->update_time = EDV_POLL;
1062   }*/
1063   if (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING)
1064           bi->edv_flag = false;
1065   if (bi->status != POWER_SUPPLY_STATUS_FULL)
1066     bi->tp_flag = false;
1067
1068 #if RT5025_CSV
1069   //pr_err("%d,%d,%d,%d,%d",
1070    // bi->tp_cnt,bi->tp_flag,bi->edv_detection,bi->edv_cnt,bi->edv_flag);
1071 #else
1072         RTINFO("tp_cnt=%d, tp_flag=%d, edv_detection=%d, edv_cnt=%d, edv_flag=%d\n",
1073     bi->tp_cnt,bi->tp_flag,bi->edv_detection,bi->edv_cnt,bi->edv_flag);
1074 #endif
1075
1076   return;
1077 }
1078
1079 #if 0
1080 static void rt5025_channel_cc(struct rt5025_battery_info *bi, bool enable)
1081 {
1082   u8 data[1];
1083
1084   if (rt5025_read_reg(bi->client, RT5025_REG_CHANNEL_LSB, data, 1) < 0){
1085     printk(KERN_INFO "%s: failed to read channel\n", __func__);
1086   }
1087
1088   if (enable){
1089     data[0] = data[0] | 0x80;
1090   }else {
1091     data[0] = data[0] & 0x7F;
1092   }
1093
1094   if (rt5025_write_reg(bi->client, RT5025_REG_CHANNEL_LSB, data, 1) < 0){
1095     printk(KERN_INFO "%s: failed to write channel\n", __func__);
1096   }
1097 }
1098 #endif
1099
1100 #if 0
1101 static void rt5025_pretrim(struct rt5025_battery_info *bi)
1102 {
1103         u8 data0[2];
1104         u8 data1[1];
1105
1106         data0[0] = 0x55;
1107         data0[1] = 0xAA;
1108   if (rt5025_write_reg(bi->client, 0xF0, data0, 2) < 0){
1109     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1110   }
1111         data0[0] = 0x07;
1112   if (rt5025_write_reg(bi->client, 0xF1, data0, 1) < 0){
1113     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1114   }
1115   // write trim data D0
1116         data0[0] = 0xDE;
1117   if (rt5025_write_reg(bi->client, 0xD0, data0, 1) < 0){
1118     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1119   }
1120   // Read back to verify
1121   if (rt5025_read_reg(bi->client, 0xD0, data1, 1) < 0){
1122     printk(KERN_ERR "%s: failed to read channel\n", __func__);
1123   }
1124   if (data1[0] != data0[0])
1125                 printk(KERN_ERR "%s: 0xD0 write fail\n", __func__);
1126         // write trim data D1
1127         data0[0] = 0x01;
1128   if (rt5025_write_reg(bi->client, 0xD1, data0, 1) < 0){
1129     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1130   }
1131   // Read back to verify
1132   if (rt5025_read_reg(bi->client, 0xD1, data1, 1) < 0){
1133     printk(KERN_ERR "%s: failed to read channel\n", __func__);
1134   }
1135   if (data1[0] != data0[0])
1136                 printk(KERN_ERR "%s: 0xD1 write fail\n", __func__);
1137   // write trim data D2
1138         data0[0] = 0x10;
1139   if (rt5025_write_reg(bi->client, 0xD2, data0, 1) < 0){
1140     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1141   }
1142   // Read back to verify
1143   if (rt5025_read_reg(bi->client, 0xD2, data1, 1) < 0){
1144     printk(KERN_ERR "%s: failed to read channel\n", __func__);
1145   }
1146   if(data1[0] != data0[0])
1147                 printk(KERN_ERR "%s: 0xD2 write fail\n", __func__);
1148   // write trim data D3
1149         data0[0] = 0x89;
1150   if (rt5025_write_reg(bi->client, 0xD3, data0, 1) < 0){
1151     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1152   }
1153   // Read back to verify
1154   if (rt5025_read_reg(bi->client, 0xD3, data1, 1) < 0){
1155     printk(KERN_ERR "%s: failed to read channel\n", __func__);
1156   }
1157   if(data1[0] != data0[0])
1158                 printk(KERN_ERR "%s: 0xD3 write fail\n", __func__);
1159   // write trim data D4
1160         data0[0] = 0xF2;
1161   if (rt5025_write_reg(bi->client, 0xD4, data0, 1) < 0){
1162     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1163   }
1164   // Read back to verify
1165   if (rt5025_read_reg(bi->client, 0xD4, data1, 1) < 0){
1166     printk(KERN_ERR "%s: failed to read channel\n", __func__);
1167   }
1168   if (data1[0] != data0[0])
1169                 printk(KERN_ERR "%s: 0xD4 write fail\n", __func__);
1170
1171         data0[0] = 0x55;
1172         data0[1] = 0x55;
1173   if (rt5025_write_reg(bi->client, 0xF0, data0, 2) < 0){
1174     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1175   }
1176 }
1177 #endif
1178
1179 static int rt5025_battery_parameter_backup(struct rt5025_battery_info *bi)
1180 {
1181         u8 data[4];
1182         RTINFO("\n");
1183         //backup fcc_aging, rm, cycle_count, acc_dchg_cap
1184         //fcc_aging
1185         data[0] = (bi->fcc_aging>>8)&0xff;
1186         data[1] = (bi->fcc_aging)&0xff;
1187         rt5025_write_reg(bi->client, 0x21, data, 2);
1188         //rm
1189         data[0] = (bi->rm>>24)&0xff;
1190         data[1] = (bi->rm>>16)&0xff;
1191         data[2] = (bi->rm>>8)&0xff;
1192         data[3] = (bi->rm)&0xff;
1193         rt5025_write_reg(bi->client, 0x23, data, 4);
1194         //acc_dchg_cap
1195         data[0] = (bi->acc_dchg_cap>>24)&0xff;
1196         data[1] = (bi->acc_dchg_cap>>16)&0xff;
1197         data[2] = (bi->acc_dchg_cap>>8)&0xff;
1198         data[3] = (bi->acc_dchg_cap)&0xff;
1199         rt5025_write_reg(bi->client, 0x27, data, 4);
1200         //cycle_count
1201         data[0] = (bi->cycle_cnt)&0xff;
1202         rt5025_write_reg(bi->client, 0x2B, data, 1);
1203         //soc
1204         data[0] = (bi->soc)&0xff;
1205         rt5025_write_reg(bi->client, 0x2C, data, 1);
1206         //gauge_timer
1207         data[0] = (bi->pre_gauge_timer>>8)&0xff;
1208         data[1] = bi->pre_gauge_timer&0xff;
1209         rt5025_write_reg(bi->client, 0x2D, data, 2);
1210         return 0;
1211 }
1212
1213 static int rt5025_battery_parameter_restore(struct rt5025_battery_info *bi)
1214 {
1215         u8 data[4];
1216         RTINFO("\n");
1217         //restore fcc_aging, rm ,cycle_count, acc_dchg_cap
1218         //fcc_aging
1219         rt5025_read_reg(bi->client, 0x21, data, 2);
1220         bi->fcc = bi->fcc_aging = data[0]<<8 | data[1];
1221         //rm
1222         //rt5025_read_reg(bi->client, 0x23, data, 4);
1223         //bi->rm = data[0]<<24 | data[1]<<16 | data[2]<<8 | data[3];
1224         //acc_dchg_cap
1225         rt5025_read_reg(bi->client, 0x27, data, 4);
1226         bi->acc_dchg_cap = data[0]<<24 | data[1]<<16 | data[2]<<8 | data[3];
1227         //cycle_count
1228         rt5025_read_reg(bi->client, 0x2B, data, 1);
1229         bi->cycle_cnt = data[0];
1230         //soc
1231         rt5025_read_reg(bi->client, 0x2C, data, 1);
1232         bi->soc = bi->pre_soc = data[0];
1233         //pre_gauge_timer
1234         rt5025_read_reg(bi->client, 0x2D, data, 2);
1235         bi->pre_gauge_timer = bi->gauge_timer = (data[0]<<8) + data[1];
1236
1237         return 0;
1238 }
1239
1240
1241 // return value; 1-> initialized, 0-> no initial value
1242 static int rt5025_battery_parameter_initcheck(struct rt5025_battery_info *bi)
1243 {
1244         u8 data[2];
1245         u16 value;
1246         int ret = 0;
1247
1248         if (rt5025_read_reg(bi->client, 0x21, data, 2) < 0)
1249         {
1250                 pr_err("%s: check initial value error\n", __func__);
1251         }
1252         else
1253         {
1254                 value = data[1]<<8 | data[0];
1255                 if (value)
1256                         ret = 1;
1257         }
1258         RTINFO("initial check = %d\n", ret);
1259
1260         return ret;
1261 }
1262
1263 static void rt5025_register_init(struct rt5025_battery_info *bi)
1264 {
1265         u8 data[1];
1266
1267         /* enable the channel of current,qc,ain,vbat and vadc */
1268         if (rt5025_read_reg(bi->client, RT5025_REG_CHANNEL_LSB, data, 1) < 0){
1269                 pr_err("%s: failed to read channel\n", __func__);
1270         }
1271         RTINFO("initial change enable=%02x\n", data[0]);
1272         data[0] = data[0] | CHANNEL_L_BIT_CADC_EN | CHANNEL_L_BIT_AINCH | \
1273                 CHANNEL_L_BIT_VBATSCH | CHANNEL_L_BIT_VADC_EN | CHANNEL_L_BIT_INTEMPCH;
1274         if (rt5025_write_reg(bi->client, RT5025_REG_CHANNEL_LSB, data, 1) < 0){
1275                 pr_err("%s: failed to write channel\n", __func__);
1276         }
1277         /* set the alert threshold value */
1278         irq_thres[MINVOLT2] = VALRTMIN2_VALUE;
1279         irq_thres[VOLT_RLS] = VRLS_VALUE;
1280
1281         bi->chg_cc_unuse = 0;
1282         bi->dchg_cc_unuse = 0;
1283         bi->pre_gauge_timer = 0;
1284         bi->online = 1;
1285         bi->status = bi->internal_status = POWER_SUPPLY_STATUS_DISCHARGING;
1286         bi->health = POWER_SUPPLY_HEALTH_GOOD;
1287
1288         bi->init_cap = true;
1289         bi->avg_flag = true;
1290
1291         bi->fcc_aging = rt5025_battery_param2[4].y;
1292         bi->fcc = rt5025_battery_param2[4].y;
1293         bi->dc = rt5025_battery_param2[4].y;
1294         bi->rm = 0;
1295
1296         bi->edv_cnt = 0;
1297         bi->edv_flag = false;
1298         bi->edv_detection = false;
1299         bi->init_once = true;
1300
1301         bi->tp_cnt = 0;
1302         bi->tp_flag = false;
1303
1304         bi->acc_dchg_cap = 0;
1305         bi->cycle_cnt = 0;
1306         bi->empty_edv = rt5025_battery_param2[4].x;
1307         bi->edv_region = 0;
1308
1309         // if has initial data, rewrite to the stored data
1310         if (rt5025_battery_parameter_initcheck(bi))
1311         {
1312                 bi->init_cap = false;
1313                 rt5025_battery_parameter_restore(bi);
1314                 //bi->soc = bi->rm/36/bi->fcc_aging;
1315                 bi->rm = bi->soc*bi->fcc_aging*36;
1316         }
1317
1318         bi->update_time = NORMAL_POLL;
1319         bi->device_suspend = false;
1320         RTINFO("register initialized\n");
1321 }
1322
1323 static void rt5025_soc_aging(struct rt5025_battery_info *bi)
1324 {
1325         if (bi->cycle_cnt >= rt5025_battery_param2[3].x)
1326         {
1327                 bi->fcc_aging = bi->fcc_aging*(1000-rt5025_battery_param2[3].y)/1000;
1328                 bi->rm = bi->rm*(1000-rt5025_battery_param2[3].y)/1000;
1329                 bi->cycle_cnt -= rt5025_battery_param2[3].x;
1330         }
1331         RTINFO("fcc_aging=%d, rm=%d, cycle_cnt=%d\n", bi->fcc_aging, bi->rm, bi->cycle_cnt);
1332 }
1333
1334 static void rt5025_temp_comp(struct rt5025_battery_info *bi)
1335 {
1336         int i = 1;
1337   int size;
1338   int slope, const_term;
1339   int delta_y, delta_x;
1340
1341   size = 3;
1342   while((bi->ext_temp < rt5025_battery_param2[i].x) &&
1343                                 (i < (size - 1))){
1344     i++;
1345   }
1346
1347   delta_x = rt5025_battery_param2[i-1].x - rt5025_battery_param2[i].x;
1348   delta_y = (rt5025_battery_param2[i-1].y - rt5025_battery_param2[i].y);
1349
1350   slope = delta_y  * 1000 / delta_x;
1351
1352   const_term = (rt5025_battery_param2[i].y) - ((rt5025_battery_param2[i].x * slope) / 1000);
1353
1354   if (bi->ext_temp >= rt5025_battery_param2[0].x)
1355     bi->tempcmp = rt5025_battery_param2[0].y;
1356   else if (bi->ext_temp <= rt5025_battery_param2[size-1].x)
1357     bi->tempcmp = rt5025_battery_param2[size-1].y;
1358   else
1359     bi->tempcmp = (bi->ext_temp * slope) / 1000 + const_term;
1360
1361   bi->fcc = bi->fcc_aging + bi->fcc_aging * bi->tempcmp /1000;
1362   if (bi->fcc >= (bi->dc*3>>1))
1363         bi->fcc = bi->dc*3>>1;
1364   if (bi->fcc <= (bi->dc>>1))
1365         bi->fcc = bi->dc>>1;
1366   bi->rm = bi->fcc * bi->soc * 36;
1367   //pr_err("[rt5025] i=%d, delta_x=%d, delta_y=%d, slope=%d, const_term=%d\n", i, delta_x, delta_y, slope, const_term);
1368   RTINFO("tempcmp=%d, ext_temp=%d, fcc=%d, rm=%d\n", bi->tempcmp, bi->ext_temp, bi->fcc, bi->rm);
1369   return;
1370 }
1371
1372 static void rt5025_soc_temp_comp(struct rt5025_battery_info *bi)
1373 {
1374   RTINFO("soc->%d++\n", bi->soc);
1375   bi->temp_range_0_5 = false;
1376   bi->temp_range_5_10 = false;
1377   bi->temp_range_10_15 = false;
1378   bi->temp_range_15_20 = false;
1379   bi->temp_range_20_30 = false;
1380   bi->temp_range_30_35 = false;
1381   bi->temp_range_35_40 = false;
1382   bi->temp_range_40_45 = false;
1383   bi->temp_range_45_50 = false;
1384
1385   if (bi->ext_temp < 50)
1386         bi->temp_range_0_5 = true;
1387   else if (50 <= bi->ext_temp && bi->ext_temp < 100)
1388         bi->temp_range_5_10 = true;
1389   else if (100 <= bi->ext_temp && bi->ext_temp < 150)
1390         bi->temp_range_10_15 = true;
1391   else if (150 <= bi->ext_temp && bi->ext_temp < 200)
1392                 bi->temp_range_15_20 = true;
1393   else if (200 <= bi->ext_temp && bi->ext_temp <= 300)
1394         bi->temp_range_20_30 = true;
1395   else if (300 < bi->ext_temp && bi->ext_temp <= 350)
1396         bi->temp_range_30_35 = true;
1397   else if (350 < bi->ext_temp && bi->ext_temp <= 400)
1398         bi->temp_range_35_40 = true;
1399   else if (400 < bi->ext_temp && bi->ext_temp <= 450)
1400         bi->temp_range_40_45 = true;
1401   else if (450 < bi->ext_temp)
1402         bi->temp_range_45_50 = true;
1403
1404   if((bi->temp_range_0_5 == true) && (bi->range_0_5_done == false))
1405   {
1406         rt5025_temp_comp(bi);
1407         bi->range_0_5_done = true;
1408         bi->range_5_10_done = false;
1409         bi->range_10_15_done = false;
1410         bi->range_15_20_done = false;
1411         bi->range_20_30_done = false;
1412         bi->range_30_35_done = false;
1413         bi->range_35_40_done = false;
1414         bi->range_40_45_done = false;
1415         bi->range_45_50_done = false;
1416   }
1417         else if((bi->temp_range_5_10 == true) && (bi->range_5_10_done == false))
1418   {
1419         rt5025_temp_comp(bi);
1420         bi->range_0_5_done = false;
1421         bi->range_5_10_done = true;
1422         bi->range_10_15_done = false;
1423         bi->range_15_20_done = false;
1424         bi->range_20_30_done = false;
1425         bi->range_30_35_done = false;
1426         bi->range_35_40_done = false;
1427         bi->range_40_45_done = false;
1428         bi->range_45_50_done = false;
1429   }
1430   else if((bi->temp_range_10_15 == true) && (bi->range_10_15_done == false))
1431   {
1432     rt5025_temp_comp(bi);
1433     bi->range_0_5_done = false;
1434         bi->range_5_10_done = false;
1435         bi->range_10_15_done = true;
1436         bi->range_15_20_done = false;
1437         bi->range_20_30_done = false;
1438         bi->range_30_35_done = false;
1439         bi->range_35_40_done = false;
1440         bi->range_40_45_done = false;
1441         bi->range_45_50_done = false;
1442   }
1443   else if((bi->temp_range_15_20 == true) && (bi->range_15_20_done == false))
1444   {
1445         rt5025_temp_comp(bi);
1446         bi->range_0_5_done = false;
1447         bi->range_5_10_done = false;
1448         bi->range_10_15_done = false;
1449         bi->range_15_20_done = true;
1450         bi->range_20_30_done = false;
1451         bi->range_30_35_done = false;
1452         bi->range_35_40_done = false;
1453         bi->range_40_45_done = false;
1454         bi->range_45_50_done = false;
1455   }
1456   else if((bi->temp_range_20_30 == true) && (bi->range_20_30_done == false))
1457   {
1458         bi->fcc = bi->fcc_aging;
1459         bi->rm = bi->fcc*bi->soc*36;
1460         bi->range_0_5_done = false;
1461         bi->range_5_10_done = false;
1462         bi->range_10_15_done = false;
1463         bi->range_15_20_done = false;
1464         bi->range_20_30_done = true;
1465         bi->range_30_35_done = false;
1466         bi->range_35_40_done = false;
1467         bi->range_40_45_done = false;
1468         bi->range_45_50_done = false;
1469   }
1470   else if((bi->temp_range_30_35 == true) && (bi->range_30_35_done == false))
1471   {
1472         rt5025_temp_comp(bi);
1473         bi->range_0_5_done = false;
1474         bi->range_5_10_done = false;
1475         bi->range_10_15_done = false;
1476         bi->range_15_20_done = false;
1477         bi->range_20_30_done = false;
1478         bi->range_30_35_done = true;
1479         bi->range_35_40_done = false;
1480         bi->range_40_45_done = false;
1481         bi->range_45_50_done = false;
1482   }
1483   else if((bi->temp_range_35_40 == true) && (bi->range_35_40_done == false))
1484   {
1485         rt5025_temp_comp(bi);
1486         bi->range_0_5_done = false;
1487         bi->range_5_10_done = false;
1488         bi->range_10_15_done = false;
1489         bi->range_15_20_done = false;
1490         bi->range_20_30_done = false;
1491         bi->range_30_35_done = false;
1492         bi->range_35_40_done = true;
1493         bi->range_40_45_done = false;
1494         bi->range_45_50_done = false;
1495   }
1496   else if((bi->temp_range_40_45 == true) && (bi->range_40_45_done == false))
1497   {
1498         rt5025_temp_comp(bi);
1499         bi->range_0_5_done = false;
1500         bi->range_5_10_done = false;
1501         bi->range_10_15_done = false;
1502         bi->range_15_20_done = false;
1503         bi->range_20_30_done = false;
1504         bi->range_30_35_done = false;
1505         bi->range_35_40_done = false;
1506         bi->range_40_45_done = true;
1507         bi->range_45_50_done = false;
1508   }
1509   else if((bi->temp_range_45_50 == true) && (bi->range_45_50_done == false))
1510   {
1511         rt5025_temp_comp(bi);
1512         bi->range_0_5_done = false;
1513         bi->range_5_10_done = false;
1514         bi->range_10_15_done = false;
1515         bi->range_15_20_done = false;
1516         bi->range_20_30_done = false;
1517         bi->range_30_35_done = false;
1518         bi->range_35_40_done = false;
1519         bi->range_40_45_done = false;
1520         bi->range_45_50_done = true;
1521   }
1522   RTINFO("soc->%d--\n", bi->soc);
1523 }
1524
1525 static void rt5025_update(struct rt5025_battery_info *bi)
1526 {
1527   /* Update voltage */
1528   rt5025_get_vcell(bi);
1529   /* Update current */
1530   rt5025_get_current(bi);
1531   /* Update internal temperature */
1532   rt5025_get_internal_temp(bi);
1533   /* Update external temperature */
1534   rt5025_get_external_temp(bi);
1535   /* Read timer */
1536   rt5025_get_timer(bi);
1537   /* Update chg cc */
1538   rt5025_get_chg_cc(bi);
1539   /* Update dchg cc */
1540   rt5025_get_dchg_cc(bi);
1541   /* Update cycle count check */
1542   rt5025_cycle_count(bi);
1543   /* Calculate cycle count */
1544   rt5025_soc_aging(bi);
1545   /* calculate initial soc */
1546   if (bi->init_cap){
1547     rt5025_init_capacity(bi);
1548 #if RT5025_CSV
1549     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");
1550 #endif
1551   }
1552
1553         /* Relearn SOC */
1554         rt5025_soc_relearn_check(bi);
1555         /* SOC_Temp_Comp*/
1556         rt5025_soc_temp_comp(bi);
1557   /* Update SOC */
1558   rt5025_get_soc(bi);
1559
1560   /* SOC Control Process */
1561   rt5025_soc_lock(bi);
1562   rt5025_soc_irreversible(bi);
1563
1564   /* Update RTTF or RTTE */
1565   //rt5025_run_time(bi);
1566
1567 #if TEMPERATURE_ALERT
1568   if ((bi->max_temp_irq == false) &&
1569                   (((irq_thres[MAXTEMP] * IRQ_THRES_UNIT) / 100 - bi->ain_volt) > irq_thres[TEMP_RLS])){
1570                 rt5025_alert_setting(bi,MAXTEMP,true);
1571         }else if ((bi->min_temp_irq == false) &&
1572                                           ((bi->ain_volt - (irq_thres[MINTEMP] * IRQ_THRES_UNIT) / 100) > irq_thres[TEMP_RLS])){
1573                 rt5025_alert_setting(bi,MINTEMP,true);
1574   }
1575 #endif
1576 #if 0
1577         }else if ((bi->min_volt1_irq == false) &&
1578                                         ((bi->vcell - ((irq_thres[MINVOLT1] * IRQ_THRES_UNIT) / 100)) > irq_thres[VOLT_RLS])){
1579                 rt5025_alert_setting(bi,MINVOLT1,true);
1580         }else if ((bi->min_volt2_irq == false) &&
1581                                         ((bi->vcell - ((irq_thres[MINVOLT2] * IRQ_THRES_UNIT) / 100)) > irq_thres[VOLT_RLS])){
1582                 rt5025_alert_setting(bi,MINVOLT2,true);
1583         }
1584 #endif
1585
1586 #if VOLTAGE_ALERT
1587         if ((bi->min_volt2_irq == false) &&
1588                                 (bi->vcell > (bi->empty_edv + EDV_HYS))){
1589                 rt5025_alert_setting(bi,MINVOLT2,true);
1590         }
1591 #endif
1592 #if RT5025_CSV
1593   printk(KERN_INFO "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",bi->vcell,bi->curr_offset,bi->curr,bi->gauge_timer,bi->time_interval,bi->chg_cc,
1594                 bi->dchg_cc,bi->tp_cnt,bi->tp_flag,bi->edv_detection,bi->edv_cnt,bi->edv_flag,bi->soc,
1595                 bi->permille,bi->rm,bi->fcc,bi->smooth_flag,bi->acc_dchg_cap,bi->cycle_cnt,bi->update_time);
1596 #else
1597   RTINFO("[RT5025] update_time=%d\n",bi->update_time);
1598   RTINFO("\n");
1599 #endif
1600 }
1601
1602 static void rt5025_update_work(struct work_struct *work)
1603 {
1604         struct delayed_work *delayed_work = (struct delayed_work *)container_of(work, struct delayed_work, work);
1605         struct rt5025_battery_info *bi = (struct rt5025_battery_info *)container_of(delayed_work, struct rt5025_battery_info, monitor_work);
1606         unsigned long flags;
1607
1608         wake_lock(&bi->monitor_wake_lock);
1609         rt5025_update(bi);
1610         power_supply_changed(&bi->battery);
1611
1612         /* prevent suspend before starting the alarm */
1613         local_irq_save(flags);
1614         bi->last_poll = alarm_get_elapsed_realtime();
1615         rt5025_program_alarm(bi);
1616         local_irq_restore(flags);
1617
1618         wake_unlock(&bi->monitor_wake_lock);
1619         schedule_delayed_work(&bi->monitor_work, bi->update_time*HZ);
1620 }
1621
1622 static enum power_supply_property rt5025_battery_props[] = {
1623   POWER_SUPPLY_PROP_STATUS,
1624   POWER_SUPPLY_PROP_HEALTH,
1625   POWER_SUPPLY_PROP_PRESENT,
1626   POWER_SUPPLY_PROP_TEMP,
1627   POWER_SUPPLY_PROP_ONLINE,
1628   POWER_SUPPLY_PROP_VOLTAGE_NOW,
1629   POWER_SUPPLY_PROP_CURRENT_NOW,
1630   POWER_SUPPLY_PROP_CAPACITY,
1631   POWER_SUPPLY_PROP_TECHNOLOGY,
1632   #if 0
1633   POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
1634   POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
1635   #endif
1636 };
1637
1638 static int rt5025_battery_sleepvth_setting(struct rt5025_battery_info* bi)
1639 {
1640         u32 temp;
1641         u8 vmax_th, vmin_th;
1642         u8 vbat[2];
1643         RTINFO("\n");
1644         rt5025_read_reg(bi->client, RT5025_REG_VCELL_MSB, vbat, 2);
1645         temp = ((vbat[0]<<8) + vbat[1])*61;
1646         vmax_th = (temp+5000)/1953;
1647         vmin_th = (temp-5000)/1953;
1648
1649         rt5025_write_reg(bi->client, RT5025_REG_VALRT_MAXTH, &vmax_th, 1);
1650         rt5025_write_reg(bi->client, RT5025_REG_VALRT_MIN1TH, &vmin_th, 1);
1651
1652         RTINFO("vmax_th=0x%02x, vmin_th=0x%02x\n", vmax_th, vmin_th);
1653         return 0;
1654 }
1655
1656 static int rt5025_battery_suspend(struct platform_device *pdev, pm_message_t state)
1657 {
1658         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1659         RTINFO("\n");
1660         //rt5025_get_timer(bi);
1661         //bi->last_event = ktime_get();
1662         bi->last_event = current_kernel_time();
1663
1664         //cy add for battery parameter backup
1665         //rt5025_battery_parameter_backup(bi);
1666
1667         //rt5025_channel_cc(bi, false);
1668         cancel_delayed_work_sync(&bi->monitor_work);
1669         //rt5025_update(bi);
1670         bi->device_suspend = true;
1671         /* prevent suspend before starting the alarm */
1672         //bi->update_time = SUSPEND_POLL;
1673         rt5025_alert_setting(bi,MAXVOLT, false);
1674         rt5025_alert_setting(bi,MINVOLT1,false);
1675         rt5025_battery_sleepvth_setting(bi);
1676         rt5025_alert_setting(bi,MAXVOLT, true);
1677         rt5025_alert_setting(bi,MINVOLT1,true);
1678         RTINFO("RM=%d\n",bi->rm);
1679         return 0;
1680 }
1681
1682 static int rt5025_battery_resume(struct platform_device *pdev)
1683 {
1684         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1685         //ktime_t now;
1686         //struct timespec now = current_kernel_time();
1687         //struct timeval tv;
1688         //long time_interval;
1689
1690         //now = ktime_get();
1691         //tv = ktime_to_timeval(ktime_sub(now, bi->last_event));
1692         //RTINFO("Sleep time = %d\n",(u32)tv.tv_sec);
1693         //bi->rm = bi->rm - ((u32)tv.tv_sec * SLEEP_CURRENT);
1694
1695         //time_interval = now.tv_sec - bi->last_event.tv_sec;
1696         //bi->rm = bi->rm - (time_interval * SLEEP_CURRENT);
1697         //RTINFO("Sleep time=%d, RM=%d",(int)time_interval,bi->rm);
1698
1699         //rt5025_channel_cc(bi, true);
1700         bi->last_suspend = true;
1701         bi->device_suspend = false;
1702         schedule_delayed_work(&bi->monitor_work, 0);
1703         RTINFO("\n");
1704         return 0;
1705 }
1706
1707 static int rt5025_battery_remove(struct platform_device *pdev)
1708 {
1709         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1710
1711         power_supply_unregister(&bi->battery);
1712         cancel_delayed_work(&bi->monitor_work);
1713         wake_lock_destroy(&bi->monitor_wake_lock);
1714         kfree(bi);
1715         return 0;
1716 }
1717
1718 static int rt5025_battery_probe(struct platform_device *pdev)
1719 {
1720         struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
1721         struct rt5025_battery_info *bi;
1722         int ret;
1723
1724         bi = kzalloc(sizeof(*bi), GFP_KERNEL);
1725         if (!bi)
1726                 return -ENOMEM;
1727
1728         bi->client = chip->i2c;
1729         bi->chip = chip;
1730
1731
1732         bi->last_poll = alarm_get_elapsed_realtime();
1733         alarm_init(&bi->wakeup_alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
1734                 rt5025_gauge_alarm);
1735
1736         INIT_DELAYED_WORK(&bi->monitor_work, rt5025_update_work);
1737
1738         wake_lock_init(&bi->monitor_wake_lock, WAKE_LOCK_SUSPEND, "rt-battery-monitor");
1739         wake_lock_init(&bi->low_battery_wake_lock, WAKE_LOCK_SUSPEND, "low_battery_wake_lock");
1740         wake_lock_init(&bi->status_wake_lock, WAKE_LOCK_SUSPEND, "battery-status-changed");
1741 #if RT5025_TEST_WAKE_LOCK
1742         wake_lock_init(&bi->test_wake_lock, WAKE_LOCK_SUSPEND, "rt-test");
1743 #endif
1744         /* Write trimed data */
1745         //rt5025_pretrim(client);
1746         /* enable channel */
1747         rt5025_register_init(bi);
1748         /* enable gauge IRQ */
1749         rt5025_alert_init(bi);
1750
1751         /* register callback functions */
1752         /*
1753         chip->cb.rt5025_gauge_irq_handler = rt5025_irq_handler;
1754         chip->cb.rt5025_gauge_set_status = rt5025_set_status;
1755         chip->cb.rt5025_gauge_set_online = rt5025_set_online;
1756         chip->cb.rt5025_gauge_suspend = rt5025_gauge_suspend;
1757         chip->cb.rt5025_gauge_resume = rt5025_gauge_resume;
1758         chip->cb.rt5025_gauge_remove = rt5025_gauge_remove;
1759
1760         rt5025_register_gauge_callbacks(&chip->cb);
1761         */
1762
1763         platform_set_drvdata(pdev, bi);
1764
1765         bi->battery.name = "rt5025-battery";
1766         bi->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1767         bi->battery.get_property = rt5025_get_property;
1768         bi->battery.properties = rt5025_battery_props;
1769         bi->battery.num_properties = ARRAY_SIZE(rt5025_battery_props);
1770
1771         ret = power_supply_register(&pdev->dev, &bi->battery);
1772         if (ret) {
1773                 printk(KERN_ERR "[RT5025] power supply register failed\n");
1774                 goto err_wake_lock;
1775         }
1776
1777
1778         //wake_lock(&bi->monitor_wake_lock);
1779 #if RT5025_TEST_WAKE_LOCK
1780         wake_lock(&bi->test_wake_lock);
1781 #endif
1782         schedule_delayed_work(&bi->monitor_work, msecs_to_jiffies(INIT_POLL*MSEC_PER_SEC));
1783         chip->battery_info = bi;
1784
1785         pr_info("rt5025-battery driver is successfully loaded\n");
1786
1787   return 0;
1788
1789 err_wake_lock:
1790         wake_lock_destroy(&bi->monitor_wake_lock);
1791         kfree(bi);
1792
1793         return ret;
1794 }
1795
1796 static void rt5025_battery_shutdown(struct platform_device *pdev)
1797 {
1798         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1799         RTINFO("\n");
1800         if (bi->soc == 0 && bi->cal_fcc != 0 )
1801         {
1802                 bi->fcc_aging = bi->cal_fcc/3600 - (bi->fcc -bi->fcc_aging);
1803                 RTINFO("bi->cal_fcc=%d\n", bi->cal_fcc);
1804         }
1805         rt5025_battery_parameter_backup(bi);
1806 }
1807
1808 static struct platform_driver rt5025_battery_driver =
1809 {
1810         .driver = {
1811                 .name = RT5025_DEVICE_NAME "-battery",
1812                 .owner = THIS_MODULE,
1813         },
1814         .probe = rt5025_battery_probe,
1815         .remove = __devexit_p(rt5025_battery_remove),
1816         .shutdown = rt5025_battery_shutdown,
1817         .suspend = rt5025_battery_suspend,
1818         .resume = rt5025_battery_resume,
1819 };
1820
1821 static int __init rt5025_battery_init(void)
1822 {
1823         return platform_driver_register(&rt5025_battery_driver);
1824 }
1825 module_init(rt5025_battery_init);
1826
1827 static void __exit rt5025_battery_exit(void)
1828 {
1829         platform_driver_unregister(&rt5025_battery_driver);
1830 }
1831 module_exit(rt5025_battery_exit);
1832
1833
1834 MODULE_LICENSE("GPL v2");
1835 MODULE_AUTHOR("Nick Hung <nick_hung@richtek.com");
1836 MODULE_DESCRIPTION("battery gauge driver for RT5025");
1837 MODULE_ALIAS("platform:" RT5025_DEVICE_NAME "-battery");
1838 MODULE_VERSION(RT5025_DRV_VER);