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=0;
 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         RTINFO("soc=%d, permille=%d, rm=%d, fcc=%d, smooth_flag=%d\n", bi->soc,bi->permille,bi->rm,bi->fcc,bi->smooth_flag);
 960  // pr_info("%d,%d,%d,%d,%d", bi->soc,bi->permille,bi->rm,bi->fcc,bi->smooth_flag);
 961 #else
 962         RTINFO("soc=%d, permille=%d, rm=%d, fcc=%d, smooth_flag=%d\n", bi->soc,bi->permille,bi->rm,bi->fcc,bi->smooth_flag);
 963 #endif
 964   return;
 965 }
 966
 967 static void rt5025_soc_relearn_check(struct rt5025_battery_info *bi)
 968 {
 969   // TP relearn
 970 /*  if ((bi->vcell >= TP_VOLT) &&
 971                         (bi->curr <= TP_CURR) &&
 972                         (bi->status == POWER_SUPPLY_STATUS_CHARGING) &&
 973                         (!bi->tp_flag)){
 974                 bi->tp_cnt++;
 975                 bi->update_time = TP_POLL;
 976         }else {
 977                 bi->tp_cnt = 0;
 978                 bi->update_time = NORMAL_POLL;
 979         }
 980
 981   if (bi->tp_cnt == TP_TOTAL_COUNT){
 982                 bi->tp_cnt = 0;
 983                 bi->tp_flag = true;
 984                 bi->rm = bi->fcc * 3600;
 985                 rt5025_convert_masec_to_permille();
 986                 bi->update_time = NORMAL_POLL;
 987         }*/
 988
 989         // if EOC happened, the tp_flag should be set 1.
 990         if(bi->tp_flag == true)
 991         {
 992                 bi->rm = bi->fcc * 3600;
 993                 rt5025_convert_masec_to_permille(bi);
 994                 bi->update_time = NORMAL_POLL;
 995         }
 996
 997         if (bi->vcell <= bi->empty_edv)
 998         {
 999                 if (bi->edv_cnt < 2)
1000                         bi->edv_cnt++;
1001         }
1002         else
1003                 bi->edv_cnt=0;
1004
1005         if(bi->empty_edv < bi->vcell && bi->vcell <= bi->empty_edv+300)
1006         {
1007                 bi->update_time = EDV_POLL;
1008                 bi->edv_detection = true;
1009         }
1010         else if((bi->vcell >= bi->empty_edv + 300 +EDV_HYS) && (bi->edv_detection == true))
1011         {
1012                  bi->update_time = NORMAL_POLL;
1013                  bi->edv_detection = false;
1014         }
1015         else if((bi->vcell <= bi->empty_edv && bi->edv_cnt == 2)) //&& (bi->min_volt2_alert == true))
1016         {
1017                 bi->edv_flag = true;
1018                 bi->rm = 0;
1019                 rt5025_convert_masec_to_permille(bi);
1020                 bi->edv_detection = false;
1021                 bi->update_time = NORMAL_POLL;
1022         }
1023         else if((bi->vcell > bi->empty_edv + EDV_HYS)) //&& (bi->min_volt2_alert == true))
1024         {
1025                 bi->min_volt2_alert = false;
1026                 bi->edv_flag = false;
1027         }
1028
1029         /*// EDV relearn
1030   if (bi->vcell <= EDV_VOLT){
1031                 if ((bi->curr <= EDV_CURR) ||
1032                                 (bi->vcell <= rt5025_battery_param2[4].x))
1033                         bi->edv_cnt++;
1034                 else
1035                 {
1036                         bi->edv_cnt = 0;
1037                 }
1038                 bi->edv_detection = true;
1039                 bi->update_time = EDV_POLL;
1040         }else if ((bi->vcell > (EDV_VOLT + EDV_HYS)) &&
1041                   (bi->edv_detection)) {
1042                 bi->edv_cnt = 0;
1043                 bi->edv_detection = false;
1044                 bi->edv_flag = false;
1045                 bi->update_time = NORMAL_POLL;
1046         }
1047         else
1048         {
1049                 bi->edv_cnt = 0;
1050         }
1051
1052   if (bi->edv_cnt == EDV_TOTAL_COUNT){
1053                 bi->edv_cnt = 0;
1054                 bi->edv_flag = true;
1055                 bi->rm = 0;
1056                 rt5025_convert_masec_to_permille();
1057                 bi->edv_detection = false;
1058                 bi->update_time = NORMAL_POLL;
1059         }
1060   if(bi->edv_detection)
1061   {
1062         bi->update_time = EDV_POLL;
1063   }*/
1064   if (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING)
1065           bi->edv_flag = false;
1066   if (bi->status != POWER_SUPPLY_STATUS_FULL)
1067     bi->tp_flag = false;
1068
1069 #if RT5025_CSV
1070   //pr_err("%d,%d,%d,%d,%d",
1071    // bi->tp_cnt,bi->tp_flag,bi->edv_detection,bi->edv_cnt,bi->edv_flag);
1072 #else
1073         RTINFO("tp_cnt=%d, tp_flag=%d, edv_detection=%d, edv_cnt=%d, edv_flag=%d\n",
1074     bi->tp_cnt,bi->tp_flag,bi->edv_detection,bi->edv_cnt,bi->edv_flag);
1075 #endif
1076
1077   return;
1078 }
1079
1080 #if 0
1081 static void rt5025_channel_cc(struct rt5025_battery_info *bi, bool enable)
1082 {
1083   u8 data[1];
1084
1085   if (rt5025_read_reg(bi->client, RT5025_REG_CHANNEL_LSB, data, 1) < 0){
1086     printk(KERN_INFO "%s: failed to read channel\n", __func__);
1087   }
1088
1089   if (enable){
1090     data[0] = data[0] | 0x80;
1091   }else {
1092     data[0] = data[0] & 0x7F;
1093   }
1094
1095   if (rt5025_write_reg(bi->client, RT5025_REG_CHANNEL_LSB, data, 1) < 0){
1096     printk(KERN_INFO "%s: failed to write channel\n", __func__);
1097   }
1098 }
1099 #endif
1100
1101 #if 0
1102 static void rt5025_pretrim(struct rt5025_battery_info *bi)
1103 {
1104         u8 data0[2];
1105         u8 data1[1];
1106
1107         data0[0] = 0x55;
1108         data0[1] = 0xAA;
1109   if (rt5025_write_reg(bi->client, 0xF0, data0, 2) < 0){
1110     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1111   }
1112         data0[0] = 0x07;
1113   if (rt5025_write_reg(bi->client, 0xF1, data0, 1) < 0){
1114     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1115   }
1116   // write trim data D0
1117         data0[0] = 0xDE;
1118   if (rt5025_write_reg(bi->client, 0xD0, data0, 1) < 0){
1119     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1120   }
1121   // Read back to verify
1122   if (rt5025_read_reg(bi->client, 0xD0, data1, 1) < 0){
1123     printk(KERN_ERR "%s: failed to read channel\n", __func__);
1124   }
1125   if (data1[0] != data0[0])
1126                 printk(KERN_ERR "%s: 0xD0 write fail\n", __func__);
1127         // write trim data D1
1128         data0[0] = 0x01;
1129   if (rt5025_write_reg(bi->client, 0xD1, data0, 1) < 0){
1130     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1131   }
1132   // Read back to verify
1133   if (rt5025_read_reg(bi->client, 0xD1, data1, 1) < 0){
1134     printk(KERN_ERR "%s: failed to read channel\n", __func__);
1135   }
1136   if (data1[0] != data0[0])
1137                 printk(KERN_ERR "%s: 0xD1 write fail\n", __func__);
1138   // write trim data D2
1139         data0[0] = 0x10;
1140   if (rt5025_write_reg(bi->client, 0xD2, data0, 1) < 0){
1141     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1142   }
1143   // Read back to verify
1144   if (rt5025_read_reg(bi->client, 0xD2, data1, 1) < 0){
1145     printk(KERN_ERR "%s: failed to read channel\n", __func__);
1146   }
1147   if(data1[0] != data0[0])
1148                 printk(KERN_ERR "%s: 0xD2 write fail\n", __func__);
1149   // write trim data D3
1150         data0[0] = 0x89;
1151   if (rt5025_write_reg(bi->client, 0xD3, data0, 1) < 0){
1152     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1153   }
1154   // Read back to verify
1155   if (rt5025_read_reg(bi->client, 0xD3, data1, 1) < 0){
1156     printk(KERN_ERR "%s: failed to read channel\n", __func__);
1157   }
1158   if(data1[0] != data0[0])
1159                 printk(KERN_ERR "%s: 0xD3 write fail\n", __func__);
1160   // write trim data D4
1161         data0[0] = 0xF2;
1162   if (rt5025_write_reg(bi->client, 0xD4, data0, 1) < 0){
1163     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1164   }
1165   // Read back to verify
1166   if (rt5025_read_reg(bi->client, 0xD4, data1, 1) < 0){
1167     printk(KERN_ERR "%s: failed to read channel\n", __func__);
1168   }
1169   if (data1[0] != data0[0])
1170                 printk(KERN_ERR "%s: 0xD4 write fail\n", __func__);
1171
1172         data0[0] = 0x55;
1173         data0[1] = 0x55;
1174   if (rt5025_write_reg(bi->client, 0xF0, data0, 2) < 0){
1175     printk(KERN_ERR "%s: failed to write channel\n", __func__);
1176   }
1177 }
1178 #endif
1179
1180 static u16 get_crc16_value(u8* data, int size)
1181 {
1182         u16 fcs = 0xffff;
1183         int len = size;
1184         int i = 0;
1185         u16 temp = 0;
1186
1187         while (len > 0)
1188         {
1189                 fcs = (u16)((fcs>>8)^crctab16[(fcs^data[i])&0xff]);
1190                 len--;
1191                 i++;
1192         }
1193         temp = (u16)~fcs;
1194         return temp;
1195 }
1196
1197 static int IsCrc16Good(u8* data, int size)
1198 {
1199         u16 fcs = 0xffff;
1200         int len = size;
1201         int i = 0;
1202
1203         while (len>0)
1204         {
1205                 fcs = (u16)((fcs>>8)^crctab16[((fcs^data[i])&0xff)]);
1206                 len--;
1207                 i++;
1208         }
1209         return (fcs == 0xf0b8);
1210 }
1211
1212 static int rt5025_battery_parameter_backup(struct rt5025_battery_info *bi)
1213 {
1214         u16 crc_value = 0;
1215         u8 data[12]= {0};
1216         RTINFO("\n");
1217         //backup fcc_aging, rm, cycle_count, acc_dchg_cap
1218         //fcc_aging
1219         data[0] = (bi->fcc_aging>>8)&0xff;
1220         data[1] = (bi->fcc_aging)&0xff;
1221         rt5025_write_reg(bi->client, 0x21, &data[0], 2);
1222         //acc_dchg_cap
1223         data[2] = (bi->acc_dchg_cap>>24)&0xff;
1224         data[3] = (bi->acc_dchg_cap>>16)&0xff;
1225         data[4] = (bi->acc_dchg_cap>>8)&0xff;
1226         data[5] = (bi->acc_dchg_cap)&0xff;
1227         rt5025_write_reg(bi->client, 0x23, &data[2], 4);
1228         //cycle_count
1229         data[6] = (bi->cycle_cnt)&0xff;
1230         rt5025_write_reg(bi->client, 0x27, &data[6], 1);
1231         //soc
1232         data[7] = (bi->soc)&0xff;
1233         rt5025_write_reg(bi->client, 0x28, &data[7], 1);
1234         //gauge_timer
1235         data[8] = (bi->pre_gauge_timer>>8)&0xff;
1236         data[9] = bi->pre_gauge_timer&0xff;
1237         rt5025_write_reg(bi->client, 0x29, &data[8], 2);
1238         //CRC value
1239         crc_value = get_crc16_value(data, 10);
1240         data[10] = crc_value&0xff;
1241         data[11] = (crc_value>>8)&0xff;
1242         rt5025_write_reg(bi->client, 0x2b, &data[10], 2);
1243         return 0;
1244 }
1245
1246 static int rt5025_battery_parameter_restore(struct rt5025_battery_info *bi)
1247 {
1248         u8 data[4];
1249         RTINFO("\n");
1250         //restore fcc_aging, rm ,cycle_count, acc_dchg_cap
1251         //fcc_aging
1252         rt5025_read_reg(bi->client, 0x21, data, 2);
1253         bi->fcc = bi->fcc_aging = data[0]<<8 | data[1];
1254         //acc_dchg_cap
1255         rt5025_read_reg(bi->client, 0x23, data, 4);
1256         bi->acc_dchg_cap = data[0]<<24 | data[1]<<16 | data[2]<<8 | data[3];
1257         //cycle_count
1258         rt5025_read_reg(bi->client, 0x27, data, 1);
1259         bi->cycle_cnt = data[0];
1260         //soc
1261         rt5025_read_reg(bi->client, 0x28, data, 1);
1262         bi->soc = bi->pre_soc = data[0];
1263         //pre_gauge_timer
1264         rt5025_read_reg(bi->client, 0x29, data, 2);
1265         bi->pre_gauge_timer = bi->gauge_timer = (data[0]<<8) + data[1];
1266
1267         return 0;
1268 }
1269
1270
1271 // return value; 1-> initialized, 0-> no initial value
1272 static int rt5025_battery_parameter_initcheck(struct rt5025_battery_info *bi)
1273 {
1274         u8 data[12] = {0};
1275         int ret = 0;
1276
1277         if (rt5025_read_reg(bi->client, 0x21, data, 12)<0)
1278         {
1279                 pr_err("%s: check initial value error\n", __func__);
1280                 return 0;
1281         }
1282         else
1283         {
1284                 ret = IsCrc16Good(data, 12);
1285         }
1286         RTINFO("initial check = %d\n", ret);
1287
1288         return ret;
1289 }
1290
1291 static void rt5025_register_init(struct rt5025_battery_info *bi)
1292 {
1293         u8 data[1];
1294
1295         /* enable the channel of current,qc,ain,vbat and vadc */
1296         if (rt5025_read_reg(bi->client, RT5025_REG_CHANNEL_LSB, data, 1) < 0){
1297                 pr_err("%s: failed to read channel\n", __func__);
1298         }
1299         RTINFO("initial change enable=%02x\n", data[0]);
1300         data[0] = data[0] | CHANNEL_L_BIT_CADC_EN | CHANNEL_L_BIT_AINCH | \
1301                 CHANNEL_L_BIT_VBATSCH | CHANNEL_L_BIT_VADC_EN | CHANNEL_L_BIT_INTEMPCH;
1302         if (rt5025_write_reg(bi->client, RT5025_REG_CHANNEL_LSB, data, 1) < 0){
1303                 pr_err("%s: failed to write channel\n", __func__);
1304         }
1305         /* set the alert threshold value */
1306         irq_thres[MINVOLT2] = VALRTMIN2_VALUE;
1307         irq_thres[VOLT_RLS] = VRLS_VALUE;
1308
1309         bi->chg_cc_unuse = 0;
1310         bi->dchg_cc_unuse = 0;
1311         bi->pre_gauge_timer = 0;
1312         bi->online = 1;
1313         bi->status = bi->internal_status = POWER_SUPPLY_STATUS_DISCHARGING;
1314         bi->health = POWER_SUPPLY_HEALTH_GOOD;
1315
1316         bi->init_cap = true;
1317         bi->avg_flag = true;
1318
1319         bi->fcc_aging = rt5025_battery_param2[4].y;
1320         bi->fcc = rt5025_battery_param2[4].y;
1321         bi->dc = rt5025_battery_param2[4].y;
1322         bi->rm = 0;
1323
1324         bi->edv_cnt = 0;
1325         bi->edv_flag = false;
1326         bi->edv_detection = false;
1327         bi->init_once = true;
1328
1329         bi->tp_cnt = 0;
1330         bi->tp_flag = false;
1331
1332         bi->acc_dchg_cap = 0;
1333         bi->cycle_cnt = 0;
1334         bi->empty_edv = rt5025_battery_param2[4].x;
1335         bi->edv_region = 0;
1336
1337         // if has initial data, rewrite to the stored data
1338         if (rt5025_battery_parameter_initcheck(bi))
1339         {
1340                 bi->init_cap = false;
1341                 rt5025_battery_parameter_restore(bi);
1342                 //bi->soc = bi->rm/36/bi->fcc_aging;
1343                 bi->rm = bi->soc*bi->fcc_aging*36;
1344         }
1345
1346         bi->update_time = NORMAL_POLL;
1347         bi->device_suspend = false;
1348         RTINFO("register initialized\n");
1349 }
1350
1351 static void rt5025_soc_aging(struct rt5025_battery_info *bi)
1352 {
1353         if (bi->cycle_cnt >= rt5025_battery_param2[3].x)
1354         {
1355                 bi->fcc_aging = bi->fcc_aging*(1000-rt5025_battery_param2[3].y)/1000;
1356                 bi->rm = bi->rm*(1000-rt5025_battery_param2[3].y)/1000;
1357                 bi->cycle_cnt -= rt5025_battery_param2[3].x;
1358         }
1359         RTINFO("fcc_aging=%d, rm=%d, cycle_cnt=%d\n", bi->fcc_aging, bi->rm, bi->cycle_cnt);
1360 }
1361
1362 static void rt5025_temp_comp(struct rt5025_battery_info *bi)
1363 {
1364         int i = 1;
1365   int size;
1366   int slope, const_term;
1367   int delta_y, delta_x;
1368
1369   size = 3;
1370   while((bi->ext_temp < rt5025_battery_param2[i].x) &&
1371                                 (i < (size - 1))){
1372     i++;
1373   }
1374
1375   delta_x = rt5025_battery_param2[i-1].x - rt5025_battery_param2[i].x;
1376   delta_y = (rt5025_battery_param2[i-1].y - rt5025_battery_param2[i].y);
1377
1378   slope = delta_y  * 1000 / delta_x;
1379
1380   const_term = (rt5025_battery_param2[i].y) - ((rt5025_battery_param2[i].x * slope) / 1000);
1381
1382   if (bi->ext_temp >= rt5025_battery_param2[0].x)
1383     bi->tempcmp = rt5025_battery_param2[0].y;
1384   else if (bi->ext_temp <= rt5025_battery_param2[size-1].x)
1385     bi->tempcmp = rt5025_battery_param2[size-1].y;
1386   else
1387     bi->tempcmp = (bi->ext_temp * slope) / 1000 + const_term;
1388
1389   bi->fcc = bi->fcc_aging + bi->fcc_aging * bi->tempcmp /1000;
1390   if (bi->fcc >= (bi->dc*3>>1))
1391         bi->fcc = bi->dc*3>>1;
1392   if (bi->fcc <= (bi->dc>>1))
1393         bi->fcc = bi->dc>>1;
1394   bi->rm = bi->fcc * bi->soc * 36;
1395   //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);
1396   RTINFO("tempcmp=%d, ext_temp=%d, fcc=%d, rm=%d\n", bi->tempcmp, bi->ext_temp, bi->fcc, bi->rm);
1397   return;
1398 }
1399
1400 static void rt5025_soc_temp_comp(struct rt5025_battery_info *bi)
1401 {
1402   RTINFO("soc->%d++\n", bi->soc);
1403   bi->temp_range_0_5 = false;
1404   bi->temp_range_5_10 = false;
1405   bi->temp_range_10_15 = false;
1406   bi->temp_range_15_20 = false;
1407   bi->temp_range_20_30 = false;
1408   bi->temp_range_30_35 = false;
1409   bi->temp_range_35_40 = false;
1410   bi->temp_range_40_45 = false;
1411   bi->temp_range_45_50 = false;
1412
1413   if (bi->ext_temp < 50)
1414         bi->temp_range_0_5 = true;
1415   else if (50 <= bi->ext_temp && bi->ext_temp < 100)
1416         bi->temp_range_5_10 = true;
1417   else if (100 <= bi->ext_temp && bi->ext_temp < 150)
1418         bi->temp_range_10_15 = true;
1419   else if (150 <= bi->ext_temp && bi->ext_temp < 200)
1420                 bi->temp_range_15_20 = true;
1421   else if (200 <= bi->ext_temp && bi->ext_temp <= 300)
1422         bi->temp_range_20_30 = true;
1423   else if (300 < bi->ext_temp && bi->ext_temp <= 350)
1424         bi->temp_range_30_35 = true;
1425   else if (350 < bi->ext_temp && bi->ext_temp <= 400)
1426         bi->temp_range_35_40 = true;
1427   else if (400 < bi->ext_temp && bi->ext_temp <= 450)
1428         bi->temp_range_40_45 = true;
1429   else if (450 < bi->ext_temp)
1430         bi->temp_range_45_50 = true;
1431
1432   if((bi->temp_range_0_5 == true) && (bi->range_0_5_done == false))
1433   {
1434         rt5025_temp_comp(bi);
1435         bi->range_0_5_done = true;
1436         bi->range_5_10_done = false;
1437         bi->range_10_15_done = false;
1438         bi->range_15_20_done = false;
1439         bi->range_20_30_done = false;
1440         bi->range_30_35_done = false;
1441         bi->range_35_40_done = false;
1442         bi->range_40_45_done = false;
1443         bi->range_45_50_done = false;
1444   }
1445         else if((bi->temp_range_5_10 == true) && (bi->range_5_10_done == false))
1446   {
1447         rt5025_temp_comp(bi);
1448         bi->range_0_5_done = false;
1449         bi->range_5_10_done = true;
1450         bi->range_10_15_done = false;
1451         bi->range_15_20_done = false;
1452         bi->range_20_30_done = false;
1453         bi->range_30_35_done = false;
1454         bi->range_35_40_done = false;
1455         bi->range_40_45_done = false;
1456         bi->range_45_50_done = false;
1457   }
1458   else if((bi->temp_range_10_15 == true) && (bi->range_10_15_done == false))
1459   {
1460     rt5025_temp_comp(bi);
1461     bi->range_0_5_done = false;
1462         bi->range_5_10_done = false;
1463         bi->range_10_15_done = true;
1464         bi->range_15_20_done = false;
1465         bi->range_20_30_done = false;
1466         bi->range_30_35_done = false;
1467         bi->range_35_40_done = false;
1468         bi->range_40_45_done = false;
1469         bi->range_45_50_done = false;
1470   }
1471   else if((bi->temp_range_15_20 == true) && (bi->range_15_20_done == false))
1472   {
1473         rt5025_temp_comp(bi);
1474         bi->range_0_5_done = false;
1475         bi->range_5_10_done = false;
1476         bi->range_10_15_done = false;
1477         bi->range_15_20_done = true;
1478         bi->range_20_30_done = false;
1479         bi->range_30_35_done = false;
1480         bi->range_35_40_done = false;
1481         bi->range_40_45_done = false;
1482         bi->range_45_50_done = false;
1483   }
1484   else if((bi->temp_range_20_30 == true) && (bi->range_20_30_done == false))
1485   {
1486         bi->fcc = bi->fcc_aging;
1487         bi->rm = bi->fcc*bi->soc*36;
1488         bi->range_0_5_done = false;
1489         bi->range_5_10_done = false;
1490         bi->range_10_15_done = false;
1491         bi->range_15_20_done = false;
1492         bi->range_20_30_done = true;
1493         bi->range_30_35_done = false;
1494         bi->range_35_40_done = false;
1495         bi->range_40_45_done = false;
1496         bi->range_45_50_done = false;
1497   }
1498   else if((bi->temp_range_30_35 == true) && (bi->range_30_35_done == false))
1499   {
1500         rt5025_temp_comp(bi);
1501         bi->range_0_5_done = false;
1502         bi->range_5_10_done = false;
1503         bi->range_10_15_done = false;
1504         bi->range_15_20_done = false;
1505         bi->range_20_30_done = false;
1506         bi->range_30_35_done = true;
1507         bi->range_35_40_done = false;
1508         bi->range_40_45_done = false;
1509         bi->range_45_50_done = false;
1510   }
1511   else if((bi->temp_range_35_40 == true) && (bi->range_35_40_done == false))
1512   {
1513         rt5025_temp_comp(bi);
1514         bi->range_0_5_done = false;
1515         bi->range_5_10_done = false;
1516         bi->range_10_15_done = false;
1517         bi->range_15_20_done = false;
1518         bi->range_20_30_done = false;
1519         bi->range_30_35_done = false;
1520         bi->range_35_40_done = true;
1521         bi->range_40_45_done = false;
1522         bi->range_45_50_done = false;
1523   }
1524   else if((bi->temp_range_40_45 == true) && (bi->range_40_45_done == false))
1525   {
1526         rt5025_temp_comp(bi);
1527         bi->range_0_5_done = false;
1528         bi->range_5_10_done = false;
1529         bi->range_10_15_done = false;
1530         bi->range_15_20_done = false;
1531         bi->range_20_30_done = false;
1532         bi->range_30_35_done = false;
1533         bi->range_35_40_done = false;
1534         bi->range_40_45_done = true;
1535         bi->range_45_50_done = false;
1536   }
1537   else if((bi->temp_range_45_50 == true) && (bi->range_45_50_done == false))
1538   {
1539         rt5025_temp_comp(bi);
1540         bi->range_0_5_done = false;
1541         bi->range_5_10_done = false;
1542         bi->range_10_15_done = false;
1543         bi->range_15_20_done = false;
1544         bi->range_20_30_done = false;
1545         bi->range_30_35_done = false;
1546         bi->range_35_40_done = false;
1547         bi->range_40_45_done = false;
1548         bi->range_45_50_done = true;
1549   }
1550   RTINFO("soc->%d--\n", bi->soc);
1551 }
1552
1553 static void rt5025_update(struct rt5025_battery_info *bi)
1554 {
1555   /* Update voltage */
1556   rt5025_get_vcell(bi);
1557   /* Update current */
1558   rt5025_get_current(bi);
1559   /* Update internal temperature */
1560   rt5025_get_internal_temp(bi);
1561   /* Update external temperature */
1562   rt5025_get_external_temp(bi);
1563   /* Read timer */
1564   rt5025_get_timer(bi);
1565   /* Update chg cc */
1566   rt5025_get_chg_cc(bi);
1567   /* Update dchg cc */
1568   rt5025_get_dchg_cc(bi);
1569   /* Update cycle count check */
1570   rt5025_cycle_count(bi);
1571   /* Calculate cycle count */
1572   rt5025_soc_aging(bi);
1573   /* calculate initial soc */
1574   if (bi->init_cap){
1575     rt5025_init_capacity(bi);
1576 #if RT5025_CSV
1577     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");
1578 #endif
1579   }
1580
1581         /* Relearn SOC */
1582         rt5025_soc_relearn_check(bi);
1583         /* SOC_Temp_Comp*/
1584         rt5025_soc_temp_comp(bi);
1585   /* Update SOC */
1586   rt5025_get_soc(bi);
1587
1588   /* SOC Control Process */
1589   rt5025_soc_lock(bi);
1590   rt5025_soc_irreversible(bi);
1591
1592   /* Update RTTF or RTTE */
1593   //rt5025_run_time(bi);
1594
1595 #if TEMPERATURE_ALERT
1596   if ((bi->max_temp_irq == false) &&
1597                   (((irq_thres[MAXTEMP] * IRQ_THRES_UNIT) / 100 - bi->ain_volt) > irq_thres[TEMP_RLS])){
1598                 rt5025_alert_setting(bi,MAXTEMP,true);
1599         }else if ((bi->min_temp_irq == false) &&
1600                                           ((bi->ain_volt - (irq_thres[MINTEMP] * IRQ_THRES_UNIT) / 100) > irq_thres[TEMP_RLS])){
1601                 rt5025_alert_setting(bi,MINTEMP,true);
1602   }
1603 #endif
1604 #if 0
1605         }else if ((bi->min_volt1_irq == false) &&
1606                                         ((bi->vcell - ((irq_thres[MINVOLT1] * IRQ_THRES_UNIT) / 100)) > irq_thres[VOLT_RLS])){
1607                 rt5025_alert_setting(bi,MINVOLT1,true);
1608         }else if ((bi->min_volt2_irq == false) &&
1609                                         ((bi->vcell - ((irq_thres[MINVOLT2] * IRQ_THRES_UNIT) / 100)) > irq_thres[VOLT_RLS])){
1610                 rt5025_alert_setting(bi,MINVOLT2,true);
1611         }
1612 #endif
1613
1614 #if VOLTAGE_ALERT
1615         if ((bi->min_volt2_irq == false) &&
1616                                 (bi->vcell > (bi->empty_edv + EDV_HYS))){
1617                 rt5025_alert_setting(bi,MINVOLT2,true);
1618         }
1619 #endif
1620 #if RT5025_CSV
1621   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,
1622                 bi->dchg_cc,bi->tp_cnt,bi->tp_flag,bi->edv_detection,bi->edv_cnt,bi->edv_flag,bi->soc,
1623                 bi->permille,bi->rm,bi->fcc,bi->smooth_flag,bi->acc_dchg_cap,bi->cycle_cnt,bi->update_time);
1624 #else
1625   RTINFO("[RT5025] update_time=%d\n",bi->update_time);
1626   RTINFO("\n");
1627 #endif
1628 }
1629
1630 static void rt5025_update_work(struct work_struct *work)
1631 {
1632         struct delayed_work *delayed_work = (struct delayed_work *)container_of(work, struct delayed_work, work);
1633         struct rt5025_battery_info *bi = (struct rt5025_battery_info *)container_of(delayed_work, struct rt5025_battery_info, monitor_work);
1634         unsigned long flags;
1635
1636         wake_lock(&bi->monitor_wake_lock);
1637         rt5025_update(bi);
1638         power_supply_changed(&bi->battery);
1639
1640         /* prevent suspend before starting the alarm */
1641         local_irq_save(flags);
1642         bi->last_poll = alarm_get_elapsed_realtime();
1643         rt5025_program_alarm(bi);
1644         local_irq_restore(flags);
1645
1646         wake_unlock(&bi->monitor_wake_lock);
1647         if (!bi->device_suspend)
1648                 schedule_delayed_work(&bi->monitor_work, bi->update_time*HZ);
1649 }
1650
1651 static enum power_supply_property rt5025_battery_props[] = {
1652   POWER_SUPPLY_PROP_STATUS,
1653   POWER_SUPPLY_PROP_HEALTH,
1654   POWER_SUPPLY_PROP_PRESENT,
1655   POWER_SUPPLY_PROP_TEMP,
1656   POWER_SUPPLY_PROP_ONLINE,
1657   POWER_SUPPLY_PROP_VOLTAGE_NOW,
1658   POWER_SUPPLY_PROP_CURRENT_NOW,
1659   POWER_SUPPLY_PROP_CAPACITY,
1660   POWER_SUPPLY_PROP_TECHNOLOGY,
1661   #if 0
1662   POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
1663   POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
1664   #endif
1665 };
1666
1667 static int rt5025_battery_sleepvth_setting(struct rt5025_battery_info* bi)
1668 {
1669         u32 temp;
1670         u8 vmax_th, vmin_th;
1671         u8 vbat[2];
1672         RTINFO("\n");
1673         rt5025_read_reg(bi->client, RT5025_REG_VCELL_MSB, vbat, 2);
1674         temp = ((vbat[0]<<8) + vbat[1])*61;
1675         vmax_th = (temp+5000)/1953;
1676         vmin_th = (temp-5000)/1953;
1677
1678         rt5025_write_reg(bi->client, RT5025_REG_VALRT_MAXTH, &vmax_th, 1);
1679         rt5025_write_reg(bi->client, RT5025_REG_VALRT_MIN1TH, &vmin_th, 1);
1680
1681         RTINFO("vmax_th=0x%02x, vmin_th=0x%02x\n", vmax_th, vmin_th);
1682         return 0;
1683 }
1684
1685 static int rt5025_battery_suspend(struct platform_device *pdev, pm_message_t state)
1686 {
1687         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1688         RTINFO("\n");
1689         //rt5025_get_timer(bi);
1690         //bi->last_event = ktime_get();
1691         bi->last_event = current_kernel_time();
1692
1693         //cy add for battery parameter backup
1694         //rt5025_battery_parameter_backup(bi);
1695
1696         //rt5025_channel_cc(bi, false);
1697         //rt5025_update(bi);
1698         bi->device_suspend = true;
1699         cancel_delayed_work_sync(&bi->monitor_work);
1700         /* prevent suspend before starting the alarm */
1701         //bi->update_time = SUSPEND_POLL;
1702         rt5025_alert_setting(bi,MAXVOLT, false);
1703         rt5025_alert_setting(bi,MINVOLT1,false);
1704         rt5025_battery_sleepvth_setting(bi);
1705         rt5025_alert_setting(bi,MAXVOLT, true);
1706         rt5025_alert_setting(bi,MINVOLT1,true);
1707         RTINFO("RM=%d\n",bi->rm);
1708         return 0;
1709 }
1710
1711 static int rt5025_battery_resume(struct platform_device *pdev)
1712 {
1713         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1714         //ktime_t now;
1715         //struct timespec now = current_kernel_time();
1716         //struct timeval tv;
1717         //long time_interval;
1718
1719         //now = ktime_get();
1720         //tv = ktime_to_timeval(ktime_sub(now, bi->last_event));
1721         //RTINFO("Sleep time = %d\n",(u32)tv.tv_sec);
1722         //bi->rm = bi->rm - ((u32)tv.tv_sec * SLEEP_CURRENT);
1723
1724         //time_interval = now.tv_sec - bi->last_event.tv_sec;
1725         //bi->rm = bi->rm - (time_interval * SLEEP_CURRENT);
1726         //RTINFO("Sleep time=%d, RM=%d",(int)time_interval,bi->rm);
1727
1728         //rt5025_channel_cc(bi, true);
1729         bi->last_suspend = true;
1730         bi->device_suspend = false;
1731         schedule_delayed_work(&bi->monitor_work, 0);
1732         RTINFO("\n");
1733         return 0;
1734 }
1735
1736 static int rt5025_battery_remove(struct platform_device *pdev)
1737 {
1738         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1739
1740         power_supply_unregister(&bi->battery);
1741         cancel_delayed_work(&bi->monitor_work);
1742         wake_lock_destroy(&bi->monitor_wake_lock);
1743         kfree(bi);
1744         RTINFO("\n");
1745         return 0;
1746 }
1747
1748 static int rt5025_battery_probe(struct platform_device *pdev)
1749 {
1750         struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
1751         struct rt5025_battery_info *bi;
1752         int ret;
1753
1754         bi = kzalloc(sizeof(*bi), GFP_KERNEL);
1755         if (!bi)
1756                 return -ENOMEM;
1757
1758         bi->client = chip->i2c;
1759         bi->chip = chip;
1760
1761
1762         bi->last_poll = alarm_get_elapsed_realtime();
1763         alarm_init(&bi->wakeup_alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
1764                 rt5025_gauge_alarm);
1765
1766         INIT_DELAYED_WORK(&bi->monitor_work, rt5025_update_work);
1767
1768         wake_lock_init(&bi->monitor_wake_lock, WAKE_LOCK_SUSPEND, "rt-battery-monitor");
1769         wake_lock_init(&bi->low_battery_wake_lock, WAKE_LOCK_SUSPEND, "low_battery_wake_lock");
1770         wake_lock_init(&bi->status_wake_lock, WAKE_LOCK_SUSPEND, "battery-status-changed");
1771 #if RT5025_TEST_WAKE_LOCK
1772         wake_lock_init(&bi->test_wake_lock, WAKE_LOCK_SUSPEND, "rt-test");
1773 #endif
1774         /* Write trimed data */
1775         //rt5025_pretrim(client);
1776         /* enable channel */
1777         rt5025_register_init(bi);
1778         /* enable gauge IRQ */
1779         rt5025_alert_init(bi);
1780
1781         /* register callback functions */
1782         /*
1783         chip->cb.rt5025_gauge_irq_handler = rt5025_irq_handler;
1784         chip->cb.rt5025_gauge_set_status = rt5025_set_status;
1785         chip->cb.rt5025_gauge_set_online = rt5025_set_online;
1786         chip->cb.rt5025_gauge_suspend = rt5025_gauge_suspend;
1787         chip->cb.rt5025_gauge_resume = rt5025_gauge_resume;
1788         chip->cb.rt5025_gauge_remove = rt5025_gauge_remove;
1789
1790         rt5025_register_gauge_callbacks(&chip->cb);
1791         */
1792
1793         platform_set_drvdata(pdev, bi);
1794
1795         bi->battery.name = "rt5025-battery";
1796         bi->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1797         bi->battery.get_property = rt5025_get_property;
1798         bi->battery.properties = rt5025_battery_props;
1799         bi->battery.num_properties = ARRAY_SIZE(rt5025_battery_props);
1800
1801         ret = power_supply_register(&pdev->dev, &bi->battery);
1802         if (ret) {
1803                 printk(KERN_ERR "[RT5025] power supply register failed\n");
1804                 goto err_wake_lock;
1805         }
1806
1807
1808         //wake_lock(&bi->monitor_wake_lock);
1809 #if RT5025_TEST_WAKE_LOCK
1810         wake_lock(&bi->test_wake_lock);
1811 #endif
1812         schedule_delayed_work(&bi->monitor_work, msecs_to_jiffies(INIT_POLL*MSEC_PER_SEC));
1813         chip->battery_info = bi;
1814
1815         pr_info("rt5025-battery driver is successfully loaded\n");
1816
1817   return 0;
1818
1819 err_wake_lock:
1820         wake_lock_destroy(&bi->monitor_wake_lock);
1821         kfree(bi);
1822
1823         return ret;
1824 }
1825
1826 static void rt5025_battery_shutdown(struct platform_device *pdev)
1827 {
1828         struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1829         RTINFO("\n");
1830         if (bi->soc == 0 && bi->cal_fcc != 0 )
1831         {
1832                 bi->fcc_aging = bi->cal_fcc/3600 - (bi->fcc -bi->fcc_aging);
1833                 RTINFO("bi->cal_fcc=%d\n", bi->cal_fcc);
1834         }
1835         rt5025_battery_parameter_backup(bi);
1836         RTINFO("\n");
1837 }
1838
1839 static struct platform_driver rt5025_battery_driver =
1840 {
1841         .driver = {
1842                 .name = RT5025_DEVICE_NAME "-battery",
1843                 .owner = THIS_MODULE,
1844         },
1845         .probe = rt5025_battery_probe,
1846         .remove = __devexit_p(rt5025_battery_remove),
1847         .shutdown = rt5025_battery_shutdown,
1848         .suspend = rt5025_battery_suspend,
1849         .resume = rt5025_battery_resume,
1850 };
1851
1852 static int __init rt5025_battery_init(void)
1853 {
1854         return platform_driver_register(&rt5025_battery_driver);
1855 }
1856 module_init(rt5025_battery_init);
1857
1858 static void __exit rt5025_battery_exit(void)
1859 {
1860         platform_driver_unregister(&rt5025_battery_driver);
1861 }
1862 module_exit(rt5025_battery_exit);
1863
1864
1865 MODULE_LICENSE("GPL v2");
1866 MODULE_AUTHOR("Nick Hung <nick_hung@richtek.com");
1867 MODULE_DESCRIPTION("battery gauge driver for RT5025");
1868 MODULE_ALIAS("platform:" RT5025_DEVICE_NAME "-battery");
1869 MODULE_VERSION(RT5025_DRV_VER);