1 /* drivers/power/rt5025-battery.c
2 * I2C Driver for Richtek RT5025 PMIC
3 * Multi function device - multi functional baseband PMIC Battery part
6 * Author: Nick Hung <nick_hung@richtek.com>
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.
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>
31 #define VOLTAGE_ALERT 0
32 #define TEMPERATURE_ALERT 0
36 #define RT5025_TEST_WAKE_LOCK 0
38 u8 irq_thres[LAST_TYPE];
40 static int rt5025_battery_parameter_backup(struct rt5025_battery_info *);
42 void rt5025_gauge_set_status(struct rt5025_battery_info *bi, int status)
45 if (status == POWER_SUPPLY_STATUS_FULL)
48 bi->last_tp_flag = true;
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);
55 EXPORT_SYMBOL(rt5025_gauge_set_status);
57 void rt5025_gauge_set_online(struct rt5025_battery_info *bi, bool present)
61 EXPORT_SYMBOL(rt5025_gauge_set_online);
63 static int rt5025_read_reg(struct i2c_client *client,
64 u8 reg, u8 *data, u8 len)
67 return rt5025_reg_block_read(client, reg, len, data);
69 struct i2c_adapter *adap = client->adapter;
70 struct i2c_msg msgs[2];
73 msgs[0].addr = client->addr;
74 msgs[0].flags = client->flags;
78 msgs[1].addr = client->addr;
79 msgs[1].flags = client->flags | I2C_M_RD;
83 ret = i2c_transfer(adap, msgs, 2);
85 return (ret == 2)? len : ret;
89 static int rt5025_write_reg(struct i2c_client *client,
90 u8 reg, u8 *data, u8 len)
93 return rt5025_reg_block_write(client, reg, len, data);
95 struct i2c_adapter *adap = client->adapter;
98 char *tx_buf = (char *)kmalloc(len + 1, GFP_KERNEL);
103 memcpy(tx_buf+1, data, len);
105 msg.addr = client->addr;
106 msg.flags = client->flags;
108 msg.buf = (char *)tx_buf;
110 ret = i2c_transfer(adap, &msg, 1);
112 return (ret == 1) ? len : ret;
116 static void rt5025_gauge_alarm(struct alarm *alarm)
118 struct rt5025_battery_info *bi = (struct rt5025_battery_info *)container_of(alarm, struct rt5025_battery_info, wakeup_alarm);
120 //wake_lock(&bi->monitor_wake_lock);
121 schedule_delayed_work(&bi->monitor_work, 0);
124 static void rt5025_program_alarm(struct rt5025_battery_info *bi)
126 ktime_t low_interval = ktime_set(bi->update_time, 0);
127 //ktime_t slack = ktime_set(20, 0);
130 next = ktime_add(bi->last_poll, low_interval);
131 //alarm_start_range(&bi->wakeup_alarm, next, ktime_add(next, slack));
135 static void rt5025_run_time(struct rt5025_battery_info *bi)
139 bi->time_to_empty = bi->rm / (bi->curr*(-1));
143 bi->time_to_full = (bi->fcc * 3600 - bi->rm) / bi->curr;
145 RTINFO("RTTF = %d\n",bi->time_to_full);
146 RTINFO("RTTE = %d\n",bi->time_to_empty);
150 static int rt5025_get_property(struct power_supply *psy,
151 enum power_supply_property psp,
152 union power_supply_propval *val)
154 struct rt5025_battery_info *bi = dev_get_drvdata(psy->dev->parent);
157 case POWER_SUPPLY_PROP_STATUS:
158 val->intval = bi->status;
159 //val->intval = POWER_SUPPLY_STATUS_CHARGING;
161 case POWER_SUPPLY_PROP_HEALTH:
162 val->intval = bi->health;
164 case POWER_SUPPLY_PROP_PRESENT:
165 val->intval = bi->present;
167 case POWER_SUPPLY_PROP_TEMP:
168 val->intval = bi->ext_temp;
170 case POWER_SUPPLY_PROP_ONLINE:
171 val->intval = bi->online;
173 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
174 val->intval = bi->vcell * 1000; //uV
176 case POWER_SUPPLY_PROP_CURRENT_NOW:
177 val->intval = bi->curr * 1000; //uA
179 case POWER_SUPPLY_PROP_CAPACITY:
180 val->intval = bi->soc;
182 if (val->intval > 100)
185 case POWER_SUPPLY_PROP_TECHNOLOGY:
186 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
189 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
190 val->intval = bi->time_to_empty;
192 case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
193 val->intval = bi->time_to_full;
202 static void rt5025_get_vcell(struct rt5025_battery_info *bi)
208 rt5025_clr_bits(bi->client, 0x07, 0x10);
209 RTINFO("set_current switch off\n");
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__);
219 rt5025_set_bits(bi->client, 0x07, 0x10);
220 RTINFO("set_current switch on\n");
224 bi->vcell = ((data[0] << 8) + data[1]) * 61 / 100;
226 bi->vcell = (bi->vcell + ((data[0] << 8) + data[1]) * 61 / 100) / 2;
228 bi->curr_offset = (15444 * bi->vcell - 27444000) / 10000;
230 if (37 * bi->vcell > 92000)
231 bi->curr_offset = (37 * bi->vcell - 92000) / 1000;
237 // if (!bi->avg_flag)
238 // pr_info("%d,%d,", bi->vcell, bi->curr_offset);
241 RTINFO("vcell_pre: %d, offset: %d\n", bi->vcell, bi->curr_offset);
243 RTINFO("vcell_avg: %d, offset: %d\n", bi->vcell, bi->curr_offset);
247 static void rt5025_get_current(struct rt5025_battery_info *bi)
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__);
258 temp = (data[0]<<8) | data[1];
259 bi->curr_raw = ((temp & 0x7FFF) * 3125) / 10000;
261 if (data[0] & (1 << 7)) {
263 temp = (((temp & 0x7FFF) * 3125) / 10 + bi->curr_offset) / 1000;
265 if ((temp * 3125) / 10 > bi->curr_offset)
266 temp = ((temp * 3125) / 10 - bi->curr_offset) / 1000;
277 temp = (data[0]<<8) | data[1];
278 if (data[0] & (1 << 7)) {
280 temp = temp & 0x7FFF;
281 if(temp > bi->curr_offset)
282 temp = temp - bi->curr_offset;
284 temp = temp + bi->curr_offset;
287 temp = (temp * 37375) / 100000; //Unit: 0.3125mA
298 bi->curr = (bi->curr + temp) / 2;
302 else if (bi->curr <= -500 && bi->curr > -1500)
307 if (curr_region != bi->edv_region)
312 bi->empty_edv = rt5025_battery_param2[4].x;
315 bi->empty_edv = rt5025_battery_param2[4].x - 75;
318 bi->empty_edv = rt5025_battery_param2[4].x - 100 ;
321 bi->edv_region = curr_region;
323 RTINFO("empty_voltage=%d\n", bi->empty_edv);
327 bi->internal_status = POWER_SUPPLY_STATUS_CHARGING;
328 bi->last_tp_flag = false;
331 bi->internal_status = POWER_SUPPLY_STATUS_DISCHARGING;
332 RTINFO("current=%d, internal_status=%d\n", bi->curr, bi->internal_status);
335 // if (!bi->avg_flag)
336 // pr_info("%d,",bi->curr);
339 RTINFO("current_pre: %d\n", bi->curr);
341 RTINFO("current_avg: %d\n", bi->curr);
345 static void rt5025_get_internal_temp(struct rt5025_battery_info *bi)
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__);
353 temp = ((data[0]&0x1F)<<8) + data[1];
357 temp = (data[0]&0x20)?-temp:temp;
359 RTINFO("internal temperature: %d\n", bi->int_temp);
362 static void rt5025_get_external_temp(struct rt5025_battery_info *bi)
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__);
370 bi->ain_volt = (data[0] * 256 + data[1]) * 61 / 100;
371 if(bi->ain_volt < 1150)
380 temp = (bi->ain_volt * (-91738) + 81521000) / 100000;
381 bi->ext_temp = (int)temp;
383 //bi->ext_temp = 250;
385 if (bi->ext_temp >= HIGH_TEMP_THRES) {
386 if (bi->health != POWER_SUPPLY_HEALTH_OVERHEAT)
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)
396 bi->temp_high_cnt = 0;
397 bi->temp_low_cnt = 0;
398 bi->temp_recover_cnt = 0;
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;
411 RTINFO("external temperature: %d\n", bi->ext_temp);
414 static void rt5025_clear_cc(struct rt5025_battery_info *bi, operation_mode mode)
418 if (rt5025_read_reg(bi->client, RT5025_REG_CHANNEL_MSB, data, 2) < 0){
419 pr_err("%s: failed to read channel\n", __func__);
423 data[0] = data[0] | CHANNEL_H_BIT_CLRQCHG;
425 data[0] = data[0] | CHANNEL_H_BIT_CLRQDCHG;
427 if (rt5025_write_reg(bi->client, RT5025_REG_CHANNEL_MSB, data, 2) < 0){
428 pr_err("%s: failed to write channel\n", __func__);
432 static void rt5025_get_chg_cc(struct rt5025_battery_info *bi)
435 u32 qh_old,ql_old,qh_new,ql_new;
436 u32 cc_masec,offset=0;
438 if (rt5025_read_reg(bi->client, RT5025_REG_QCHGH_MSB, data, 4) < 0){
439 pr_err("%s: Failed to read QCHG\n", __func__);
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);
445 if (rt5025_read_reg(bi->client, RT5025_REG_QCHGH_MSB, data, 4) < 0){
446 pr_err("%s: Failed to read QCHG\n", __func__);
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);
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;
461 //cc_masec = (((qh_old<<16) + ql_old) * 50134) / 10;
462 cc_masec = qh_old*328558+(qh_old*1824+ql_old*50134)/10000;
467 offset = bi->curr_offset * bi->time_interval;
469 if (cc_masec > offset){
470 cc_masec = cc_masec - (offset / 1000);
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;
479 cc_masec = (((qh_old<<16) + ql_old) * 5996) / 1000;
483 offset = (bi->curr_offset * bi->time_interval * 37375) / 100000;
486 cc_masec = cc_masec - offset;
489 if (cc_masec < (DEADBAND * bi->time_interval))
493 //pr_info("%d,\n", cc_masec);
495 RTINFO("chg_cc_mAsec: %d\n", cc_masec);
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);
505 static void rt5025_get_dchg_cc(struct rt5025_battery_info *bi)
508 u32 qh_old,ql_old,qh_new,ql_new;
509 u32 cc_masec,offset=0;
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__);
514 qh_old = (data[0]<<8) + data[1];
515 ql_old = (data[2]<<8) + data[3];
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__);
520 qh_new = (data[0]<<8) + data[1];
521 ql_new = (data[2]<<8) + data[3];
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;
532 //cc_masec = (((qh_old<<16) + ql_old) * 50134) / 10;
533 cc_masec = qh_old*328558+(qh_old*1824+ql_old*50134)/10000;
538 offset = bi->curr_offset * bi->time_interval;
541 cc_masec = cc_masec + (offset / 1000);
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;
550 cc_masec = (((qh_old<<16) + ql_old) * 5996) / 1000;
554 offset = (bi->curr_offset * bi->time_interval * 37375) / 100000;
556 if (cc_masec > offset){
557 cc_masec = cc_masec - offset;
560 if (cc_masec < (DEADBAND * bi->time_interval))
564 //pr_info("%d,", cc_masec);
566 RTINFO("dchg_cc_mAsec: %d\n", cc_masec);
568 bi->dchg_cc = cc_masec;
569 if (bi->last_tp_flag)
570 bi->cal_fcc += cc_masec;
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);
580 static void rt5025_cycle_count(struct rt5025_battery_info *bi)
582 bi->acc_dchg_cap += bi->dchg_cc;
583 if(bi->acc_dchg_cap >= (bi->dc * 3600)){
585 bi->acc_dchg_cap -= (bi->dc * 3600);
589 static void rt5025_get_irq_flag(struct rt5025_battery_info *bi, u8 flag)
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__);
600 //RTINFO("IRQ_FLG 0x%x\n", bi->irq_flag);
603 static void rt5025_get_timer(struct rt5025_battery_info *bi)
609 if (rt5025_read_reg(bi->client, RT5025_REG_TIMER, data, 2) < 0){
610 pr_err("%s: Failed to read Timer\n", __func__);
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;
618 bi->time_interval = 65536 - bi->pre_gauge_timer + bi->gauge_timer;
621 bi->pre_gauge_timer = bi->gauge_timer;
623 // pr_info("%d,%d,", bi->gauge_timer,bi->time_interval);
625 RTINFO("timer %d , interval %d\n", bi->gauge_timer,bi->time_interval);
629 static void rt5025_alert_setting(struct rt5025_battery_info *bi, alert_type type, bool enable)
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__);
640 data[0] |= IRQ_CTL_BIT_TMX; //Enable max temperature alert
641 bi->max_temp_irq = true;
642 //RTDBG("Enable min temperature alert");
645 data[0] |= IRQ_CTL_BIT_TMN; //Enable min temperature alert
646 bi->min_temp_irq = true;
647 //RTDBG("Enable max temperature alert");
650 data[0] |= IRQ_CTL_BIT_VMX; //Enable max voltage alert
651 bi->max_volt_irq = true;
652 //RTDBG("Enable max voltage alert");
655 data[0] |= IRQ_CTL_BIT_VMN1; //Enable min1 voltage alert
656 bi->min_volt1_irq = true;
657 //RTDBG("Enable min1 voltage alert");
660 data[0] |= IRQ_CTL_BIT_VMN2; //Enable min2 voltage alert
661 bi->min_volt2_irq = true;
662 //RTDBG("Enable min2 voltage alert");
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");
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");
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");
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");
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");
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__);
702 static void rt5025_alert_threshold_init(struct i2c_client *client)
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__);
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__);
730 static void rt5025_alert_init(struct rt5025_battery_info *bi)
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);
739 void rt5025_gauge_irq_handler(struct rt5025_battery_info *bi, u8 irq_flag)
741 rt5025_get_irq_flag(bi, irq_flag);
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;
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;
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;
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;
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));
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);
775 EXPORT_SYMBOL(rt5025_gauge_irq_handler);
777 static void rt5025_convert_masec_to_permille(struct rt5025_battery_info *bi)
779 bi->permille = bi->rm / 3600 * 1000 / bi->fcc;
780 RTINFO("permille=%d\n", bi->permille);
784 static void rt5025_convert_permille_to_masec(struct rt5025_battery_info *bi)
786 bi->rm = bi->permille * bi->fcc / 1000 * 3600;
790 static void rt5025_init_capacity(struct rt5025_battery_info *bi)
794 int slope, const_term;
795 int delta_y, delta_x;
797 size = ARRAY_SIZE(rt5025_battery_param1);
798 while((bi->vcell < rt5025_battery_param1[i].x) &&
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);
806 slope = delta_y * 1000 / delta_x;
808 const_term = (rt5025_battery_param1[i].y) - ((rt5025_battery_param1[i].x * slope) / 1000);
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;
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;
820 rt5025_battery_parameter_backup(bi);
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);
827 static void rt5025_smooth_soc(struct rt5025_battery_info *bi)
829 if ((bi->internal_status == POWER_SUPPLY_STATUS_CHARGING || bi->tp_flag == 1) &&
833 bi->rm = bi->fcc * bi->soc * 36;
834 rt5025_convert_masec_to_permille(bi);
836 else if ((bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
840 bi->rm = bi->fcc * bi->soc * 36;
841 rt5025_convert_masec_to_permille(bi);
845 bi->smooth_flag = false;
846 bi->update_time = NORMAL_POLL;
851 static void rt5025_soc_irreversible(struct rt5025_battery_info *bi)
854 //if (!bi->init_cap){
856 if (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING)
858 if (bi->soc < bi->pre_soc)
859 bi->soc = bi->pre_soc;
861 else if ((bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
864 if (bi->soc > bi->pre_soc)
865 bi->soc = bi->pre_soc;
869 bi->init_once = false;
871 if (bi->pre_soc != bi->soc)
872 rt5025_battery_parameter_backup(bi);
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);
878 static void rt5025_soc_lock(struct rt5025_battery_info *bi)
881 RTINFO("internal status=%d, tp_flag=%d, soc=%d\n", bi->internal_status, bi->tp_flag, bi->soc);
886 else if(bi->internal_status == POWER_SUPPLY_STATUS_CHARGING)
892 else if ((bi->soc < 99) && (bi->tp_flag))
894 if (!bi->last_suspend)
896 bi->update_time = SMOOTH_POLL;
897 bi->smooth_flag = true;
898 rt5025_smooth_soc(bi);
901 bi->last_suspend=false;
909 if ((bi->soc <= 1) &&
910 (bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING)){
919 }else if ((bi->soc > 1) &&
920 (bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
922 if (!bi->last_suspend)
924 bi->update_time = SMOOTH_POLL;
925 bi->smooth_flag = true;
926 rt5025_smooth_soc(bi);
929 bi->last_suspend=false;
931 bi->edv_flag = false;
935 static void rt5025_get_soc(struct rt5025_battery_info *bi)
937 if (bi->smooth_flag){
938 bi->smooth_flag = false;
939 bi->update_time = NORMAL_POLL;
941 RTINFO("before rm=%d\n", bi->rm);
942 if ((!bi->tp_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);
951 bi->temp_soc = bi->soc;
952 //pr_info("%d", bi->soc);
954 RTINFO("after rm=%d\n", bi->rm);
955 RTINFO("temp_soc=%d\n", bi->soc);
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);
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);
967 static void rt5025_soc_relearn_check(struct rt5025_battery_info *bi)
970 /* if ((bi->vcell >= TP_VOLT) &&
971 (bi->curr <= TP_CURR) &&
972 (bi->status == POWER_SUPPLY_STATUS_CHARGING) &&
975 bi->update_time = TP_POLL;
978 bi->update_time = NORMAL_POLL;
981 if (bi->tp_cnt == TP_TOTAL_COUNT){
984 bi->rm = bi->fcc * 3600;
985 rt5025_convert_masec_to_permille();
986 bi->update_time = NORMAL_POLL;
989 // if EOC happened, the tp_flag should be set 1.
990 if(bi->tp_flag == true)
992 bi->rm = bi->fcc * 3600;
993 rt5025_convert_masec_to_permille(bi);
994 bi->update_time = NORMAL_POLL;
997 if (bi->vcell <= bi->empty_edv)
1005 if(bi->empty_edv < bi->vcell && bi->vcell <= bi->empty_edv+300)
1007 bi->update_time = EDV_POLL;
1008 bi->edv_detection = true;
1010 else if((bi->vcell >= bi->empty_edv + 300 +EDV_HYS) && (bi->edv_detection == true))
1012 bi->update_time = NORMAL_POLL;
1013 bi->edv_detection = false;
1015 else if((bi->vcell <= bi->empty_edv && bi->edv_cnt == 2)) //&& (bi->min_volt2_alert == true))
1017 bi->edv_flag = true;
1019 rt5025_convert_masec_to_permille(bi);
1020 bi->edv_detection = false;
1021 bi->update_time = NORMAL_POLL;
1023 else if((bi->vcell > bi->empty_edv + EDV_HYS)) //&& (bi->min_volt2_alert == true))
1025 bi->min_volt2_alert = false;
1026 bi->edv_flag = false;
1030 if (bi->vcell <= EDV_VOLT){
1031 if ((bi->curr <= EDV_CURR) ||
1032 (bi->vcell <= rt5025_battery_param2[4].x))
1038 bi->edv_detection = true;
1039 bi->update_time = EDV_POLL;
1040 }else if ((bi->vcell > (EDV_VOLT + EDV_HYS)) &&
1041 (bi->edv_detection)) {
1043 bi->edv_detection = false;
1044 bi->edv_flag = false;
1045 bi->update_time = NORMAL_POLL;
1052 if (bi->edv_cnt == EDV_TOTAL_COUNT){
1054 bi->edv_flag = true;
1056 rt5025_convert_masec_to_permille();
1057 bi->edv_detection = false;
1058 bi->update_time = NORMAL_POLL;
1060 if(bi->edv_detection)
1062 bi->update_time = EDV_POLL;
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;
1070 //pr_err("%d,%d,%d,%d,%d",
1071 // bi->tp_cnt,bi->tp_flag,bi->edv_detection,bi->edv_cnt,bi->edv_flag);
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);
1081 static void rt5025_channel_cc(struct rt5025_battery_info *bi, bool enable)
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__);
1090 data[0] = data[0] | 0x80;
1092 data[0] = data[0] & 0x7F;
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__);
1102 static void rt5025_pretrim(struct rt5025_battery_info *bi)
1109 if (rt5025_write_reg(bi->client, 0xF0, data0, 2) < 0){
1110 printk(KERN_ERR "%s: failed to write channel\n", __func__);
1113 if (rt5025_write_reg(bi->client, 0xF1, data0, 1) < 0){
1114 printk(KERN_ERR "%s: failed to write channel\n", __func__);
1116 // write trim data D0
1118 if (rt5025_write_reg(bi->client, 0xD0, data0, 1) < 0){
1119 printk(KERN_ERR "%s: failed to write channel\n", __func__);
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__);
1125 if (data1[0] != data0[0])
1126 printk(KERN_ERR "%s: 0xD0 write fail\n", __func__);
1127 // write trim data D1
1129 if (rt5025_write_reg(bi->client, 0xD1, data0, 1) < 0){
1130 printk(KERN_ERR "%s: failed to write channel\n", __func__);
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__);
1136 if (data1[0] != data0[0])
1137 printk(KERN_ERR "%s: 0xD1 write fail\n", __func__);
1138 // write trim data D2
1140 if (rt5025_write_reg(bi->client, 0xD2, data0, 1) < 0){
1141 printk(KERN_ERR "%s: failed to write channel\n", __func__);
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__);
1147 if(data1[0] != data0[0])
1148 printk(KERN_ERR "%s: 0xD2 write fail\n", __func__);
1149 // write trim data D3
1151 if (rt5025_write_reg(bi->client, 0xD3, data0, 1) < 0){
1152 printk(KERN_ERR "%s: failed to write channel\n", __func__);
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__);
1158 if(data1[0] != data0[0])
1159 printk(KERN_ERR "%s: 0xD3 write fail\n", __func__);
1160 // write trim data D4
1162 if (rt5025_write_reg(bi->client, 0xD4, data0, 1) < 0){
1163 printk(KERN_ERR "%s: failed to write channel\n", __func__);
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__);
1169 if (data1[0] != data0[0])
1170 printk(KERN_ERR "%s: 0xD4 write fail\n", __func__);
1174 if (rt5025_write_reg(bi->client, 0xF0, data0, 2) < 0){
1175 printk(KERN_ERR "%s: failed to write channel\n", __func__);
1180 static u16 get_crc16_value(u8* data, int size)
1189 fcs = (u16)((fcs>>8)^crctab16[(fcs^data[i])&0xff]);
1197 static int IsCrc16Good(u8* data, int size)
1205 fcs = (u16)((fcs>>8)^crctab16[((fcs^data[i])&0xff)]);
1209 return (fcs == 0xf0b8);
1212 static int rt5025_battery_parameter_backup(struct rt5025_battery_info *bi)
1217 //backup fcc_aging, rm, cycle_count, acc_dchg_cap
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);
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);
1229 data[6] = (bi->cycle_cnt)&0xff;
1230 rt5025_write_reg(bi->client, 0x27, &data[6], 1);
1232 data[7] = (bi->soc)&0xff;
1233 rt5025_write_reg(bi->client, 0x28, &data[7], 1);
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);
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);
1246 static int rt5025_battery_parameter_restore(struct rt5025_battery_info *bi)
1250 //restore fcc_aging, rm ,cycle_count, acc_dchg_cap
1252 rt5025_read_reg(bi->client, 0x21, data, 2);
1253 bi->fcc = bi->fcc_aging = data[0]<<8 | data[1];
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];
1258 rt5025_read_reg(bi->client, 0x27, data, 1);
1259 bi->cycle_cnt = data[0];
1261 rt5025_read_reg(bi->client, 0x28, data, 1);
1262 bi->soc = bi->pre_soc = data[0];
1264 rt5025_read_reg(bi->client, 0x29, data, 2);
1265 bi->pre_gauge_timer = bi->gauge_timer = (data[0]<<8) + data[1];
1271 // return value; 1-> initialized, 0-> no initial value
1272 static int rt5025_battery_parameter_initcheck(struct rt5025_battery_info *bi)
1277 if (rt5025_read_reg(bi->client, 0x21, data, 12)<0)
1279 pr_err("%s: check initial value error\n", __func__);
1284 ret = IsCrc16Good(data, 12);
1286 RTINFO("initial check = %d\n", ret);
1291 static void rt5025_register_init(struct rt5025_battery_info *bi)
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__);
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__);
1305 /* set the alert threshold value */
1306 irq_thres[MINVOLT2] = VALRTMIN2_VALUE;
1307 irq_thres[VOLT_RLS] = VRLS_VALUE;
1309 bi->chg_cc_unuse = 0;
1310 bi->dchg_cc_unuse = 0;
1311 bi->pre_gauge_timer = 0;
1313 bi->status = bi->internal_status = POWER_SUPPLY_STATUS_DISCHARGING;
1314 bi->health = POWER_SUPPLY_HEALTH_GOOD;
1316 bi->init_cap = true;
1317 bi->avg_flag = true;
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;
1325 bi->edv_flag = false;
1326 bi->edv_detection = false;
1327 bi->init_once = true;
1330 bi->tp_flag = false;
1332 bi->acc_dchg_cap = 0;
1334 bi->empty_edv = rt5025_battery_param2[4].x;
1337 // if has initial data, rewrite to the stored data
1338 if (rt5025_battery_parameter_initcheck(bi))
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;
1346 bi->update_time = NORMAL_POLL;
1347 bi->device_suspend = false;
1348 RTINFO("register initialized\n");
1351 static void rt5025_soc_aging(struct rt5025_battery_info *bi)
1353 if (bi->cycle_cnt >= rt5025_battery_param2[3].x)
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;
1359 RTINFO("fcc_aging=%d, rm=%d, cycle_cnt=%d\n", bi->fcc_aging, bi->rm, bi->cycle_cnt);
1362 static void rt5025_temp_comp(struct rt5025_battery_info *bi)
1366 int slope, const_term;
1367 int delta_y, delta_x;
1370 while((bi->ext_temp < rt5025_battery_param2[i].x) &&
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);
1378 slope = delta_y * 1000 / delta_x;
1380 const_term = (rt5025_battery_param2[i].y) - ((rt5025_battery_param2[i].x * slope) / 1000);
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;
1387 bi->tempcmp = (bi->ext_temp * slope) / 1000 + const_term;
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);
1400 static void rt5025_soc_temp_comp(struct rt5025_battery_info *bi)
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;
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;
1432 if((bi->temp_range_0_5 == true) && (bi->range_0_5_done == false))
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;
1445 else if((bi->temp_range_5_10 == true) && (bi->range_5_10_done == false))
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;
1458 else if((bi->temp_range_10_15 == true) && (bi->range_10_15_done == false))
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;
1471 else if((bi->temp_range_15_20 == true) && (bi->range_15_20_done == false))
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;
1484 else if((bi->temp_range_20_30 == true) && (bi->range_20_30_done == false))
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;
1498 else if((bi->temp_range_30_35 == true) && (bi->range_30_35_done == false))
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;
1511 else if((bi->temp_range_35_40 == true) && (bi->range_35_40_done == false))
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;
1524 else if((bi->temp_range_40_45 == true) && (bi->range_40_45_done == false))
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;
1537 else if((bi->temp_range_45_50 == true) && (bi->range_45_50_done == false))
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;
1550 RTINFO("soc->%d--\n", bi->soc);
1553 static void rt5025_update(struct rt5025_battery_info *bi)
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);
1564 rt5025_get_timer(bi);
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 */
1575 rt5025_init_capacity(bi);
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");
1582 rt5025_soc_relearn_check(bi);
1584 rt5025_soc_temp_comp(bi);
1588 /* SOC Control Process */
1589 rt5025_soc_lock(bi);
1590 rt5025_soc_irreversible(bi);
1592 /* Update RTTF or RTTE */
1593 //rt5025_run_time(bi);
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);
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);
1615 if ((bi->min_volt2_irq == false) &&
1616 (bi->vcell > (bi->empty_edv + EDV_HYS))){
1617 rt5025_alert_setting(bi,MINVOLT2,true);
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);
1625 RTINFO("[RT5025] update_time=%d\n",bi->update_time);
1630 static void rt5025_update_work(struct work_struct *work)
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;
1636 wake_lock(&bi->monitor_wake_lock);
1638 power_supply_changed(&bi->battery);
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);
1646 wake_unlock(&bi->monitor_wake_lock);
1647 if (!bi->device_suspend)
1648 schedule_delayed_work(&bi->monitor_work, bi->update_time*HZ);
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,
1662 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
1663 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
1667 static int rt5025_battery_sleepvth_setting(struct rt5025_battery_info* bi)
1670 u8 vmax_th, vmin_th;
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;
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);
1681 RTINFO("vmax_th=0x%02x, vmin_th=0x%02x\n", vmax_th, vmin_th);
1685 static int rt5025_battery_suspend(struct platform_device *pdev, pm_message_t state)
1687 struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1689 //rt5025_get_timer(bi);
1690 //bi->last_event = ktime_get();
1691 bi->last_event = current_kernel_time();
1693 //cy add for battery parameter backup
1694 //rt5025_battery_parameter_backup(bi);
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);
1711 static int rt5025_battery_resume(struct platform_device *pdev)
1713 struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1715 //struct timespec now = current_kernel_time();
1716 //struct timeval tv;
1717 //long time_interval;
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);
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);
1728 //rt5025_channel_cc(bi, true);
1729 bi->last_suspend = true;
1730 bi->device_suspend = false;
1731 schedule_delayed_work(&bi->monitor_work, 0);
1736 static int rt5025_battery_remove(struct platform_device *pdev)
1738 struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1740 power_supply_unregister(&bi->battery);
1741 cancel_delayed_work(&bi->monitor_work);
1742 wake_lock_destroy(&bi->monitor_wake_lock);
1748 static int rt5025_battery_probe(struct platform_device *pdev)
1750 struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
1751 struct rt5025_battery_info *bi;
1754 bi = kzalloc(sizeof(*bi), GFP_KERNEL);
1758 bi->client = chip->i2c;
1762 bi->last_poll = alarm_get_elapsed_realtime();
1763 alarm_init(&bi->wakeup_alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
1764 rt5025_gauge_alarm);
1766 INIT_DELAYED_WORK(&bi->monitor_work, rt5025_update_work);
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");
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);
1781 /* register callback functions */
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;
1790 rt5025_register_gauge_callbacks(&chip->cb);
1793 platform_set_drvdata(pdev, bi);
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);
1801 ret = power_supply_register(&pdev->dev, &bi->battery);
1803 printk(KERN_ERR "[RT5025] power supply register failed\n");
1808 //wake_lock(&bi->monitor_wake_lock);
1809 #if RT5025_TEST_WAKE_LOCK
1810 wake_lock(&bi->test_wake_lock);
1812 schedule_delayed_work(&bi->monitor_work, msecs_to_jiffies(INIT_POLL*MSEC_PER_SEC));
1813 chip->battery_info = bi;
1815 pr_info("rt5025-battery driver is successfully loaded\n");
1820 wake_lock_destroy(&bi->monitor_wake_lock);
1826 static void rt5025_battery_shutdown(struct platform_device *pdev)
1828 struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1830 if (bi->soc == 0 && bi->cal_fcc != 0 )
1832 bi->fcc_aging = bi->cal_fcc/3600 - (bi->fcc -bi->fcc_aging);
1833 RTINFO("bi->cal_fcc=%d\n", bi->cal_fcc);
1835 rt5025_battery_parameter_backup(bi);
1839 static struct platform_driver rt5025_battery_driver =
1842 .name = RT5025_DEVICE_NAME "-battery",
1843 .owner = THIS_MODULE,
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,
1852 static int __init rt5025_battery_init(void)
1854 return platform_driver_register(&rt5025_battery_driver);
1856 module_init(rt5025_battery_init);
1858 static void __exit rt5025_battery_exit(void)
1860 platform_driver_unregister(&rt5025_battery_driver);
1862 module_exit(rt5025_battery_exit);
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);