1 /* drivers/power/rt5025-battery.c
2 * I2C Driver for Richtek RT5025 PMIC
3 * Multi function device - multi functional baseband PMIC Battery part
5 * Copyright (C) 2014 Richtek Technology Corp.
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; either version 2
11 * of the License, or (at your option) any later version.
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/delay.h>
17 #include <linux/err.h>
18 #include <linux/init.h>
19 #include <linux/i2c.h>
20 #include <linux/interrupt.h>
21 #include <linux/platform_device.h>
22 #include <linux/power_supply.h>
23 #include <linux/slab.h>
24 #include <linux/wakelock.h>
25 #include <linux/workqueue.h>
26 #include <linux/jiffies.h>
27 #include <linux/timer.h>
28 #include <linux/alarmtimer.h>
29 #include <linux/mfd/rt5025.h>
30 #include <linux/power/rt5025-battery.h>
33 #define VOLTAGE_ALERT 0
34 #define TEMPERATURE_ALERT 0
38 #define RT5025_TEST_WAKE_LOCK 0
40 u8 irq_thres[LAST_TYPE];
42 static unsigned char gauge_init_regval[] = {
50 static u16 crctab16[256] = {
51 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
52 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
53 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
54 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
55 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
56 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
57 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
58 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
59 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
60 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
61 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
62 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
63 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
64 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
65 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
66 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
67 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
68 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
69 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
70 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
71 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
72 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
73 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
74 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
75 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
76 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
77 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
78 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
79 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
80 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
81 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
82 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78,
85 static int rt5025_battery_parameter_backup(struct rt5025_battery_info *);
86 static void rt5025_get_external_temp(struct rt5025_battery_info *);
87 static void rt5025_get_internal_temp(struct rt5025_battery_info *);
88 static void rt5025_get_vcell(struct rt5025_battery_info *);
89 static void rt5025_get_current(struct rt5025_battery_info *);
90 static void rt5025_temp_comp(struct rt5025_battery_info *);
93 static int rt5025_read_reg(struct i2c_client *client,
94 u8 reg, u8 *data, u8 len)
96 return rt5025_reg_block_read(client, reg, len, data);
99 static int rt5025_write_reg(struct i2c_client *client,
100 u8 reg, u8 *data, u8 len)
102 return rt5025_reg_block_write(client, reg, len, data);
105 static void rt5025_set_battery_led(struct rt5025_battery_info *bi, int status)
108 case POWER_SUPPLY_STATUS_CHARGING:
110 case POWER_SUPPLY_STATUS_DISCHARGING:
112 case POWER_SUPPLY_STATUS_FULL:
119 static int rt5025_set_property(struct power_supply *psy,
120 enum power_supply_property psp,
121 const union power_supply_propval *val)
123 struct rt5025_battery_info *bi = dev_get_drvdata(psy->dev->parent);
127 case POWER_SUPPLY_PROP_STATUS:
128 if (val->intval == POWER_SUPPLY_STATUS_FULL) {
130 pr_info("%s: Battery is full \n", __func__);
132 mutex_lock(&bi->status_change_lock);
133 bi->status = val->intval;
134 if (bi->status == POWER_SUPPLY_STATUS_DISCHARGING)
136 rt5025_set_battery_led(bi, bi->status);
137 mutex_unlock(&bi->status_change_lock);
139 wake_lock_timeout(&bi->status_wake_lock, 1.5*HZ);
140 schedule_delayed_work(&bi->monitor_work, msecs_to_jiffies(100));
142 case POWER_SUPPLY_PROP_PRESENT:
143 bi->batt_present = val->intval;
152 static int rt5025_get_property(struct power_supply *psy,
153 enum power_supply_property psp,
154 union power_supply_propval *val)
156 struct rt5025_battery_info *bi = dev_get_drvdata(psy->dev->parent);
159 case POWER_SUPPLY_PROP_STATUS:
160 val->intval = bi->status;
161 /*val->intval = POWER_SUPPLY_STATUS_CHARGING;*/
163 case POWER_SUPPLY_PROP_HEALTH:
164 val->intval = bi->health;
165 /*If there's no battery, always show battery health to good.*/
166 if (!bi->present || !bi->batt_present)
167 val->intval = POWER_SUPPLY_HEALTH_GOOD;
169 case POWER_SUPPLY_PROP_PRESENT:
170 val->intval = bi->present;
172 case POWER_SUPPLY_PROP_TEMP:
173 if (val->intval == 23) {
174 rt5025_get_external_temp(bi);
175 val->intval = bi->ext_temp;
177 /*If there's no battery, always show battery temperature to 25'c.*/
178 if (!bi->present || !bi->batt_present)
181 val->intval = bi->ext_temp;
184 case POWER_SUPPLY_PROP_TEMP_AMBIENT:
185 rt5025_get_internal_temp(bi);
186 val->intval = bi->int_temp;
188 case POWER_SUPPLY_PROP_ONLINE:
189 val->intval = bi->online;
191 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
192 rt5025_get_vcell(bi);
193 val->intval = bi->vcell * 1000; /*uv*/
195 case POWER_SUPPLY_PROP_CURRENT_NOW:
196 rt5025_get_current(bi);
197 val->intval = bi->curr * 1000; /*uA*/
199 case POWER_SUPPLY_PROP_CAPACITY:
200 val->intval = bi->soc;
201 if (val->intval > 100)
203 /*If there's no battery, always show capacity to 50*/
204 if (!bi->present || !bi->batt_present)
207 case POWER_SUPPLY_PROP_TECHNOLOGY:
208 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
216 static void rt5025_get_vcell(struct rt5025_battery_info *bi)
220 if (rt5025_read_reg(bi->client, RT5025_REG_VBATSH, data, 2) < 0)
221 pr_err("%s: Failed to read Voltage\n", __func__);
224 bi->vcell = ((data[0] << 8) + data[1]) * 61 / 100;
227 (bi->vcell + ((data[0] << 8) + data[1]) * 61 / 100) / 2;
230 /*b. Remove current offset compensation; 2013/12/17*/
232 /*bi->curr_offset = (15444 * bi->vcell - 27444000) / 10000;*/
235 if (37 * bi->vcell > 92000)
236 bi->curr_offset = (37 * bi->vcell - 92000) / 1000;
242 /* if (!bi->avg_flag)*/
243 /* pr_info("%d,%d,", bi->vcell, bi->curr_offset);*/
246 RTINFO("vcell_pre: %d, offset: %d\n", bi->vcell, bi->curr_offset);
248 RTINFO("vcell_avg: %d, offset: %d\n", bi->vcell, bi->curr_offset);
252 static void rt5025_get_current(struct rt5025_battery_info *bi)
259 if (rt5025_read_reg(bi->client, RT5025_REG_CURRH, data, 2) < 0)
260 pr_err("%s: Failed to read CURRENT\n", __func__);
263 temp = (data[0] << 8) | data[1];
264 bi->curr_raw = ((temp & 0x7FFF) * 3125) / 10000;
266 if (data[0] & (1 << 7)) {
268 temp = (((temp & 0x7FFF) * 3125) / 10 + bi->curr_offset) / 1000;
270 if ((temp * 3125) / 10 > bi->curr_offset)
271 temp = ((temp * 3125) / 10 - bi->curr_offset) / 1000;
280 temp = (data[0] << 8) | data[1];
281 if (data[0] & (1 << 7)) {
283 temp = temp & 0x7FFF;
284 if (temp > bi->curr_offset)
285 temp = temp - bi->curr_offset;
287 temp = temp + bi->curr_offset;
289 temp = (temp * 37375) / 100000; /*Unit: 0.3125mA*/
299 bi->curr = (bi->curr + temp) / 2;
303 else if (bi->curr <= -500 && bi->curr > -1500)
308 if (curr_region != bi->edv_region) {
309 switch (curr_region) {
311 bi->empty_edv = rt5025_battery_param2[4].x;
314 bi->empty_edv = rt5025_battery_param2[4].x - 75;
317 bi->empty_edv = rt5025_battery_param2[4].x - 100;
320 bi->edv_region = curr_region;
322 RTINFO("empty_voltage=%d\n", bi->empty_edv);
325 bi->internal_status = POWER_SUPPLY_STATUS_CHARGING;
326 bi->last_tp_flag = false;
327 /*b. add fcc update flag; 2013/12/18*/
328 bi->fcc_update_flag = true;
330 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)
350 if (rt5025_read_reg(bi->client, RT5025_REG_INTEMPH, data, 2) < 0)
351 pr_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_AINH, data, 2) < 0)
368 pr_err("%s: Failed to read TEMPERATURE\n", __func__);
369 bi->ain_volt = (data[0] * 256 + data[1]) * 61 / 100;
370 if (bi->ain_volt < 1150)
375 temp = (bi->ain_volt * (-91738) + 81521000) / 100000;
376 bi->ext_temp = (int)temp;
377 /*test bi->ext_temp = 250;*/
379 if (bi->ext_temp >= HIGH_TEMP_THRES) {
380 if (bi->health != POWER_SUPPLY_HEALTH_OVERHEAT)
382 } else if (bi->ext_temp <= HIGH_TEMP_RECOVER
383 && bi->ext_temp >= LOW_TEMP_RECOVER) {
384 if (bi->health == POWER_SUPPLY_HEALTH_OVERHEAT
385 || bi->health == POWER_SUPPLY_HEALTH_COLD)
386 bi->temp_recover_cnt++;
387 } else if (bi->ext_temp <= LOW_TEMP_THRES) {
388 if (bi->health != POWER_SUPPLY_HEALTH_COLD)
391 bi->temp_high_cnt = 0;
392 bi->temp_low_cnt = 0;
393 bi->temp_recover_cnt = 0;
396 if (bi->temp_high_cnt >= TEMP_ABNORMAL_COUNT) {
397 bi->health = POWER_SUPPLY_HEALTH_OVERHEAT;
398 bi->temp_high_cnt = 0;
399 } else if (bi->temp_low_cnt >= TEMP_ABNORMAL_COUNT) {
400 bi->health = POWER_SUPPLY_HEALTH_COLD;
401 bi->temp_low_cnt = 0;
402 } else if (bi->temp_recover_cnt >= TEMP_ABNORMAL_COUNT) {
403 bi->health = POWER_SUPPLY_HEALTH_GOOD;
404 bi->temp_recover_cnt = 0;
406 RTINFO("external temperature: %d\n", bi->ext_temp);
409 static void rt5025_clear_cc(struct rt5025_battery_info *bi, operation_mode mode)
413 if (rt5025_read_reg(bi->client, RT5025_REG_CHANNELH, data, 2) < 0)
414 pr_err("%s: failed to read channel\n", __func__);
417 data[0] = data[0] | CHANNEL_H_BIT_CLRQCHG;
419 data[0] = data[0] | CHANNEL_H_BIT_CLRQDCHG;
421 if (rt5025_write_reg(bi->client, RT5025_REG_CHANNELH, data, 2) < 0)
422 pr_err("%s: failed to write channel\n", __func__);
425 static void rt5025_get_chg_cc(struct rt5025_battery_info *bi)
428 u32 qh_old, ql_old, qh_new, ql_new;
429 u32 cc_masec, offset = 0;
431 if (rt5025_read_reg(bi->client, RT5025_REG_QCHGHH, data, 4) < 0)
432 pr_err("%s: Failed to read QCHG\n", __func__);
434 qh_old = (data[0]<<8) + data[1];
435 ql_old = (data[2]<<8) + data[3];
436 RTINFO("qh_old=%d, ql_old=%d\n", qh_old, ql_old);
438 if (rt5025_read_reg(bi->client, RT5025_REG_QCHGHH, data, 4) < 0)
439 pr_err("%s: Failed to read QCHG\n", __func__);
441 qh_new = (data[0]<<8) + data[1];
442 ql_new = (data[2]<<8) + data[3];
443 RTINFO("qh_new=%d, ql_new=%d\n", qh_new, ql_new);
446 if (qh_new > qh_old) {
447 /*cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;*/
448 cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
449 } else if (qh_new == qh_old) {
450 if (ql_new >= ql_old) {
451 /*cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;*/
452 cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
454 /*cc_masec = (((qh_old<<16) + ql_old) * 50134) / 10;*/
455 cc_masec = qh_old*328558+(qh_old*1824+ql_old*50134)/10000;
460 offset = bi->curr_offset * bi->time_interval;
461 if (cc_masec > offset)
462 cc_masec = cc_masec - (offset / 1000);
464 if (qh_new > qh_old) {
465 cc_masec = (((qh_new << 16) + ql_new) * 5996) / 1000;
466 } else if (qh_new == qh_old) {
467 if (ql_new >= ql_old)
468 cc_masec = (((qh_new<<16) + ql_new) * 5996) / 1000;
470 cc_masec = (((qh_old<<16) + ql_old) * 5996) / 1000;
473 offset = (bi->curr_offset * bi->time_interval * 37375) / 100000;
476 cc_masec = cc_masec - offset;
478 if (cc_masec < (DEADBAND * bi->time_interval))
483 RTINFO("chg_cc_mAsec: %d\n", cc_masec);
486 /*if (!bi->init_once)*/
487 bi->chg_cc = cc_masec;
488 /*bi->chg_cc = (cc_masec + bi->chg_cc_unuse) / 3600;*/
489 /*bi->chg_cc_unuse = (cc_masec + bi->chg_cc_unuse) % 3600;*/
490 rt5025_clear_cc(bi, CHG);
493 static void rt5025_get_dchg_cc(struct rt5025_battery_info *bi)
496 u32 qh_old, ql_old, qh_new, ql_new;
497 u32 cc_masec, offset = 0;
499 if (rt5025_read_reg(bi->client, RT5025_REG_QDCHGHH, data, 4) < 0)
500 pr_err("%s: Failed to read QDCHG\n",
503 qh_old = (data[0] << 8) + data[1];
504 ql_old = (data[2] << 8) + data[3];
506 if (rt5025_read_reg(bi->client, RT5025_REG_QDCHGHH, data, 4) < 0)
507 pr_err("%s: Failed to read QDCHG\n",
510 qh_new = (data[0] << 8) + data[1];
511 ql_new = (data[2] << 8) + data[3];
514 if (qh_new > qh_old) {
515 /*cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;*/
516 cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
517 } else if (qh_new == qh_old) {
518 if (ql_new >= ql_old) {
519 /*cc_masec = (((qh_new<<16) + ql_new) * 50134) / 10;*/
520 cc_masec = qh_new*328558+(qh_new*1824+ql_new*50134)/10000;
522 /*cc_masec = (((qh_old<<16) + ql_old) * 50134) / 10;*/
523 cc_masec = qh_old*328558+(qh_old*1824+ql_old*50134)/10000;
527 offset = bi->curr_offset * bi->time_interval;
529 cc_masec = cc_masec + (offset / 1000);
531 if (qh_new > qh_old) {
532 cc_masec = (((qh_new<<16) + ql_new) * 5996) / 1000;
533 } else if (qh_new == qh_old) {
534 if (ql_new >= ql_old)
535 cc_masec = (((qh_new<<16) + ql_new) * 5996) / 1000;
537 cc_masec = (((qh_old<<16) + ql_old) * 5996) / 1000;
540 offset = (bi->curr_offset * bi->time_interval * 37375) / 100000;
542 if (cc_masec > offset)
543 cc_masec = cc_masec - offset;
545 if (cc_masec < (DEADBAND * bi->time_interval))
550 RTINFO("dchg_cc_mAsec: %d\n", cc_masec);
552 bi->dchg_cc = cc_masec;
553 /*b. add fcc update flag; 2013/12/18*/
554 if ((bi->last_tp_flag) && (bi->fcc_update_flag))
555 bi->cal_fcc += cc_masec;
559 RTINFO("bi->cal_fcc=%d, bi->last_tp_flag=%d\n",
560 bi->cal_fcc, bi->last_tp_flag);
561 /*bi->dchg_cc = (cc_masec + bi->dchg_cc_unuse) / 3600;*/
562 /*bi->dchg_cc_unuse = (cc_masec + bi->dchg_cc_unuse) % 3600;*/
563 rt5025_clear_cc(bi, DCHG);
567 static void rt5025_cycle_count(struct rt5025_battery_info *bi)
569 bi->acc_dchg_cap += bi->dchg_cc;
570 if (bi->acc_dchg_cap >= (bi->dc * 3600)) {
572 bi->acc_dchg_cap -= (bi->dc * 3600);
576 static void rt5025_get_irq_flag(struct rt5025_battery_info *bi, u8 flag)
579 /*RTINFO("IRQ_FLG 0x%x\n", bi->irq_flag);*/
582 static void rt5025_get_timer(struct rt5025_battery_info *bi)
586 if (rt5025_read_reg(bi->client, RT5025_REG_TIMERH, data, 2) < 0)
587 pr_err("%s: Failed to read Timer\n", __func__);
589 bi->gauge_timer = (data[0] << 8) + data[1];
590 if (!bi->device_suspend) {
591 if (bi->gauge_timer > bi->pre_gauge_timer)
592 bi->time_interval = bi->gauge_timer - bi->pre_gauge_timer;
594 bi->time_interval = 65536 - bi->pre_gauge_timer + bi->gauge_timer;
597 bi->pre_gauge_timer = bi->gauge_timer;
599 /*pr_info("%d,%d,", bi->gauge_timer,bi->time_interval);*/
601 RTINFO("timer %d , interval %d\n", bi->gauge_timer, bi->time_interval);
605 static void rt5025_alert_setting(struct rt5025_battery_info *bi,
606 alert_type type, bool enable)
610 if (rt5025_read_reg(bi->client, RT5025_REG_IRQCTL, data, 1) < 0)
611 pr_err("%s: Failed to read CONFIG\n", __func__);
616 data[0] |= IRQ_CTL_BIT_TMX;
617 /*Enable max temperature alert*/
618 bi->max_temp_irq = true;
619 /*RTDBG("Enable min temperature alert");*/
622 data[0] |= IRQ_CTL_BIT_TMN;
623 /*Enable min temperature alert*/
624 bi->min_temp_irq = true;
625 /*RTDBG("Enable max temperature alert");*/
628 data[0] |= IRQ_CTL_BIT_VMX;
629 /*Enable max voltage alert*/
630 bi->max_volt_irq = true;
631 /*RTDBG("Enable max voltage alert");*/
634 data[0] |= IRQ_CTL_BIT_VMN1;
635 /*Enable min1 voltage alert*/
636 bi->min_volt1_irq = true;
637 /*RTDBG("Enable min1 voltage alert");*/
640 data[0] |= IRQ_CTL_BIT_VMN2;
641 /*Enable min2 voltage alert*/
642 bi->min_volt2_irq = true;
643 /*RTDBG("Enable min2 voltage alert");*/
651 data[0] = data[0] & ~IRQ_CTL_BIT_TMX;
652 /*Disable max temperature alert*/
653 bi->max_temp_irq = false;
654 /*RTDBG("Disable min temperature alert");*/
657 data[0] = data[0] & ~IRQ_CTL_BIT_TMN;
658 /*Disable min temperature alert*/
659 bi->min_temp_irq = false;
660 /*RTDBG("Disable max temperature alert");*/
663 data[0] = data[0] & ~IRQ_CTL_BIT_VMX;
664 /*Disable max voltage alert*/
665 bi->max_volt_irq = false;
666 /*RTDBG("Disable max voltage alert");*/
669 data[0] = data[0] & ~IRQ_CTL_BIT_VMN1;
670 /*Disable min1 voltage alert*/
671 bi->min_volt1_irq = false;
672 /*RTDBG("Disable min1 voltage alert");*/
675 data[0] = data[0] & ~IRQ_CTL_BIT_VMN2;
676 /*Disable min2 voltage alert*/
677 bi->min_volt2_irq = false;
678 /*RTDBG("Disable min2 voltage alert");*/
684 if (rt5025_write_reg(bi->client, RT5025_REG_IRQCTL, data, 1) < 0)
685 pr_err("%s: failed to write IRQ control\n", __func__);
688 static void rt5025_alert_threshold_init(struct i2c_client *client)
692 /* VALRT MAX threshold setting */
693 data[0] = irq_thres[MAXVOLT];
694 if (rt5025_write_reg(client, RT5025_REG_VALRTMAX, data, 1) < 0)
695 pr_err("%s: failed to write VALRT MAX threshold\n",
697 /* VALRT MIN1 threshold setting */
698 data[0] = irq_thres[MINVOLT1];
699 if (rt5025_write_reg(client, RT5025_REG_VALRTMIN1, data, 1) < 0)
700 pr_err("%s: failed to write VALRT MIN1 threshold\n",
702 /* VALRT MIN2 threshold setting */
703 data[0] = irq_thres[MINVOLT2];
704 if (rt5025_write_reg(client, RT5025_REG_VALRTMIN2, data, 1) < 0)
705 pr_err("%s: failed to write VALRT MIN2 threshold\n",
709 static void rt5025_alert_init(struct rt5025_battery_info *bi)
712 /* Set RT5025 gauge alert configuration */
713 rt5025_alert_threshold_init(bi->client);
714 /* Enable gauge alert function */
715 rt5025_alert_setting(bi, MINVOLT2, VOLTAGE_ALERT);
718 void rt5025_gauge_irq_handler(struct rt5025_battery_info *bi,
719 unsigned int irq_flag)
721 rt5025_get_irq_flag(bi, irq_flag);
723 if ((bi->irq_flag) & IRQ_FLG_BIT_TMX) {
724 /*printk(KERN_INFO "[RT5025]: Min temperature IRQ received\n");*/
725 rt5025_alert_setting(bi, MAXTEMP, false);
726 bi->max_temp_irq = false;
728 if ((bi->irq_flag) & IRQ_FLG_BIT_TMN) {
729 /*printk(KERN_INFO "[RT5025]: Max temperature IRQ received\n");*/
730 rt5025_alert_setting(bi, MINTEMP, false);
731 bi->min_temp_irq = false;
733 if ((bi->irq_flag) & IRQ_FLG_BIT_VMX) {
734 /*printk(KERN_INFO "[RT5025]: Max voltage IRQ received\n");*/
735 rt5025_alert_setting(bi, MAXVOLT, false);
736 bi->max_volt_irq = false;
738 if ((bi->irq_flag) & IRQ_FLG_BIT_VMN1) {
739 /*printk(KERN_INFO "[RT5025]: Min voltage1 IRQ received\n");*/
740 rt5025_alert_setting(bi, MINVOLT1, false);
741 bi->min_volt1_irq = false;
743 if ((bi->irq_flag) & IRQ_FLG_BIT_VMN2) {
744 /*printk(KERN_INFO "[RT5025]: Min voltage2 IRQ received\n");*/
745 rt5025_alert_setting(bi, MINVOLT2, false);
746 bi->min_volt2_irq = false;
747 bi->min_volt2_alert = true;
748 wake_lock_timeout(&bi->low_battery_wake_lock,
749 msecs_to_jiffies(LOW_BAT_WAKE_LOK_TIME *
753 EXPORT_SYMBOL(rt5025_gauge_irq_handler);
755 static void rt5025_convert_masec_to_permille(struct rt5025_battery_info *bi)
757 bi->permille = bi->rm / 3600 * 1000 / bi->fcc;
758 RTINFO("permille=%d\n", bi->permille);
762 static void rt5025_convert_permille_to_masec(struct rt5025_battery_info *bi)
764 bi->rm = bi->permille * bi->fcc / 1000 * 3600;
768 static void rt5025_init_capacity(struct rt5025_battery_info *bi)
772 int slope, const_term;
773 int delta_y, delta_x;
775 size = ARRAY_SIZE(rt5025_battery_param1);
776 while ((bi->vcell < rt5025_battery_param1[i].x) &&
781 delta_x = rt5025_battery_param1[i-1].x - rt5025_battery_param1[i].x;
782 delta_y = (rt5025_battery_param1[i-1].y - rt5025_battery_param1[i].y);
784 slope = delta_y * 1000 / delta_x;
786 const_term = (rt5025_battery_param1[i].y) - ((rt5025_battery_param1[i].x * slope) / 1000);
788 if (bi->vcell >= rt5025_battery_param1[0].x)
789 bi->permille = rt5025_battery_param1[0].y;
790 else if (bi->vcell <= rt5025_battery_param1[size-1].x)
791 bi->permille = rt5025_battery_param1[size-1].y;
793 bi->permille = (bi->vcell * slope) / 1000 + const_term;
794 rt5025_convert_permille_to_masec(bi);
795 bi->soc = bi->rm / 36 / bi->fcc_aging;
796 bi->init_cap = false;
798 rt5025_battery_parameter_backup(bi);
800 RTINFO("voltage=%d, permille=%d, soc=%d, rm=%d\n",
801 bi->vcell, bi->permille, bi->soc, bi->rm);
805 static void rt5025_smooth_soc(struct rt5025_battery_info *bi)
807 if ((bi->internal_status == POWER_SUPPLY_STATUS_CHARGING || bi->tp_flag) &&
809 if (bi->last_suspend == true) {
811 bi->last_suspend = false;
815 bi->rm = bi->fcc * bi->soc * 36;
816 rt5025_convert_masec_to_permille(bi);
818 if (bi->soc == 100) {
819 /*fcc update in soc smooth 100%.*/
820 if (bi->cal_soc_offset != 0) {
821 bi->fcc_aging -= bi->cal_soc_offset;
822 if ((200 <= bi->ext_temp) && (bi->ext_temp <= 300)) {
823 bi->fcc = bi->fcc_aging;
824 bi->rm = bi->fcc * bi->soc * 36;
826 rt5025_temp_comp(bi);
828 bi->cal_soc_offset = 0;
830 wake_unlock(&bi->smooth100_wake_lock);
833 bi->pre_soc = bi->soc;
835 /*c. Only EOC occurs and full discharge to update FCC; 2013/12/17*/
836 bi->last_tp_flag = true;
837 mutex_lock(&bi->status_change_lock);
838 if (bi->status != POWER_SUPPLY_STATUS_DISCHARGING) {
839 bi->status = POWER_SUPPLY_STATUS_FULL;
840 rt5025_set_battery_led(bi, bi->status);
842 mutex_unlock(&bi->status_change_lock);
844 } else if ((bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
846 if (bi->last_suspend == true) {
848 bi->last_suspend = false;
852 bi->rm = bi->fcc * bi->soc * 36;
853 rt5025_convert_masec_to_permille(bi);
855 wake_unlock(&bi->smooth0_wake_lock);
857 bi->smooth_flag = false;
858 bi->update_time = NORMAL_POLL;
863 static void rt5025_soc_irreversible(struct rt5025_battery_info *bi)
865 if (!bi->init_once) {
866 if (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING) {
867 if (bi->soc < bi->pre_soc)
868 bi->soc = bi->pre_soc;
869 } else if ((bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
870 (bi->tp_flag == 0)) {
871 if (bi->soc > bi->pre_soc)
872 bi->soc = bi->pre_soc;
875 bi->init_once = false;
878 if (bi->pre_soc != bi->soc)
879 rt5025_battery_parameter_backup(bi);
881 bi->pre_soc = bi->soc;
882 RTINFO("pre_soc=%d, soc=%d, internal status=%d\n",
883 bi->pre_soc, bi->soc, bi->internal_status);
886 static void rt5025_soc_lock(struct rt5025_battery_info *bi)
891 RTINFO("internal status=%d, tp_flag=%d, soc=%d, soc99_lock_cnt=%d\n",
892 bi->internal_status, bi->tp_flag, bi->soc,
894 RTINFO("init_once=%d, rm=%d, soc=%d\n",
895 bi->init_once, bi->rm, bi->soc);
898 if (bi->soc99_lock_cnt >= 3600) {
901 /*eoc fcc update function: when flag is true, update FCC.*/
902 if (bi->cal_eoc_fcc != 0) {
903 /*eoc fcc update function: fcc update limitation 3%*/
904 eoc_fcc_new = bi->fcc_aging + bi->cal_eoc_fcc / 3600;
905 if (eoc_fcc_new > ((bi->fcc_aging * 103) / 100))
906 bi->fcc_aging = (bi->fcc_aging * 103) / 100;
908 bi->fcc_aging = eoc_fcc_new;
910 if ((200 <= bi->ext_temp) && (bi->ext_temp <= 300)) {
911 bi->fcc = bi->fcc_aging;
912 bi->rm = bi->fcc * bi->permille * 36 / 10;
914 rt5025_temp_comp(bi);
918 wake_unlock(&bi->full_battery_wake_lock);
919 bi->soc99_lock_cnt = 0;
922 bi->pre_soc = bi->soc;
923 /*b. add fcc update flag; 2013/12/18*/
924 bi->fcc_update_flag = false;
926 /*a. When SOC = 100, report battery status is full; 2013/12/17
927 bi->status = POWER_SUPPLY_STATUS_FULL;
929 } else if (bi->tp_flag) {
930 RTINFO("before_eoc_fcc_new=%d\n", eoc_fcc_new);
931 RTINFO("before_cal_eoc_fcc=%d\n", bi->cal_eoc_fcc);
932 RTINFO("before_fcc_aging=%d\n", bi->fcc_aging);
935 if (bi->cal_eoc_fcc != 0) {
936 /*fcc update in eoc occurs. */
937 eoc_fcc_new = bi->fcc_aging + bi->cal_eoc_fcc/3600;
938 if (eoc_fcc_new > ((bi->fcc_aging*103)/100))
939 bi->fcc_aging = (bi->fcc_aging*103)/100;
941 bi->fcc_aging = eoc_fcc_new;
943 RTINFO("after_eoc_fcc_new=%d\n", eoc_fcc_new);
944 RTINFO("after_cal_eoc_fcc=%d\n", bi->cal_eoc_fcc);
945 RTINFO("after_fcc_aging=%d\n", bi->fcc_aging);
946 if ((200 <= bi->ext_temp) && (bi->ext_temp <= 300)) {
947 bi->fcc = bi->fcc_aging;
948 bi->rm = bi->fcc * bi->permille * 36 / 10;
950 rt5025_temp_comp(bi);
953 } else if (bi->cal_soc_offset != 0) {
954 bi->fcc_aging -= bi->cal_soc_offset;
955 if ((200 <= bi->ext_temp) && (bi->ext_temp <= 300)) {
956 bi->fcc = bi->fcc_aging;
957 bi->rm = bi->fcc * bi->permille * 36 / 10;
959 rt5025_temp_comp(bi);
961 bi->cal_soc_offset = 0;
964 wake_unlock(&bi->full_battery_wake_lock);
965 bi->soc99_lock_cnt = 0;
968 bi->pre_soc = bi->soc;
970 /*c. Only EOC occurs and full discharge to update FCC; 2013/12/17*/
971 bi->last_tp_flag = true;
973 mutex_lock(&bi->status_change_lock);
974 if (bi->status != POWER_SUPPLY_STATUS_DISCHARGING) {
975 bi->status = POWER_SUPPLY_STATUS_FULL;
976 rt5025_set_battery_led(bi, bi->status);
978 mutex_unlock(&bi->status_change_lock);
979 } else if ((bi->internal_status == POWER_SUPPLY_STATUS_CHARGING) &&
980 (bi->last_tp == false)) {
983 bi->soc99_lock_cnt += bi->time_interval;
985 } else if ((bi->soc < 99) && (bi->tp_flag)) {
986 /*calculate soc offset */
987 if (bi->cal_soc_offset == 0) {
988 bi->cal_soc_offset = bi->fcc*3600 - bi->rm;
989 if (bi->cal_soc_offset > (bi->fcc_aging*3/100))
990 bi->cal_soc_offset = bi->fcc_aging*3/100;
992 wake_lock(&bi->smooth100_wake_lock);
993 bi->update_time = SMOOTH_POLL;
994 bi->smooth_flag = true;
995 rt5025_smooth_soc(bi);
997 wake_unlock(&bi->smooth100_wake_lock);
999 bi->soc99_lock_cnt = 0;
1001 /* a. When SOC = 100, report battery status is full; 2013/12/17
1002 /// a. judge charging status to check battery full condition; 2013/12/18*/
1003 if ((bi->soc == 100) &&
1004 (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING)) {
1005 mutex_lock(&bi->status_change_lock);
1006 if (bi->status != POWER_SUPPLY_STATUS_DISCHARGING) {
1007 bi->status = POWER_SUPPLY_STATUS_FULL;
1008 rt5025_set_battery_led(bi, bi->status);
1010 mutex_unlock(&bi->status_change_lock);
1014 if ((bi->soc <= 1) &&
1015 (bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING)) {
1020 bi->soc1_lock_cnt += bi->time_interval;
1021 if (bi->soc1_lock_cnt >= 600) {
1023 bi->soc1_lock_cnt = 0;
1031 bi->soc1_lock_cnt = 0;
1034 } else if ((bi->soc > 1) &&
1035 (bi->internal_status == POWER_SUPPLY_STATUS_DISCHARGING) &&
1037 wake_lock(&bi->smooth0_wake_lock);
1038 bi->update_time = SMOOTH_POLL;
1039 bi->smooth_flag = true;
1040 rt5025_smooth_soc(bi);
1042 bi->edv_flag = false;
1043 wake_unlock(&bi->smooth0_wake_lock);
1045 RTINFO("cal_soc_offset=%d\n", bi->cal_soc_offset);
1048 static void rt5025_get_soc(struct rt5025_battery_info *bi)
1050 if (bi->smooth_flag) {
1051 bi->smooth_flag = false;
1052 bi->update_time = NORMAL_POLL;
1054 RTINFO("before rm=%d\n", bi->rm);
1055 if ((!bi->tp_flag) && (!bi->edv_flag)) {
1056 bi->rm = (bi->rm + bi->chg_cc) > bi->dchg_cc ?
1057 bi->rm + bi->chg_cc - bi->dchg_cc : 0;
1058 if (bi->rm > (bi->fcc * 3600))
1059 bi->rm = bi->fcc * 3600;
1061 /* accumulate coulomb counter when rm = fcc and enable flag = true.*/
1062 if (bi->rm == (bi->fcc * 3600))
1063 bi->cal_eoc_fcc += (bi->chg_cc - bi->dchg_cc);
1065 bi->cal_eoc_fcc = 0;
1067 RTINFO("cal_eoc_fcc=%d\n", bi->cal_eoc_fcc);
1068 rt5025_convert_masec_to_permille(bi);
1069 /*a. When SOC = 100, report battery status is full; 2113/12/17*/
1070 bi->soc = DIV_ROUND_UP(bi->permille, 10);
1073 bi->temp_soc = bi->soc;
1074 /*pr_info("%d", bi->soc);*/
1076 RTINFO("after rm=%d\n", bi->rm);
1077 RTINFO("temp_soc=%d\n", bi->soc);
1080 RTINFO("soc=%d, permille=%d, rm=%d, fcc=%d, smooth_flag=%d\n",
1081 bi->soc, bi->permille, bi->rm,
1082 bi->fcc, bi->smooth_flag);
1083 /*pr_info("%d,%d,%d,%d,%d", bi->soc,bi->permille,bi->rm,bi->fcc,bi->smooth_flag);*/
1085 RTINFO("soc=%d, permille=%d, rm=%d, fcc=%d, smooth_flag=%d\n",
1086 bi->soc, bi->permille, bi->rm,
1087 bi->fcc, bi->smooth_flag);
1092 static void rt5025_soc_relearn_check(struct rt5025_battery_info *bi)
1095 if (bi->tp_flag == true) {
1096 bi->rm = bi->fcc * 3600;
1097 rt5025_convert_masec_to_permille(bi);
1098 bi->update_time = NORMAL_POLL;
1101 if (bi->vcell <= bi->empty_edv) {
1102 if (bi->edv_cnt < 2)
1108 if (bi->empty_edv < bi->vcell && bi->vcell <= bi->empty_edv + 300) {
1109 bi->update_time = EDV_POLL;
1110 bi->edv_detection = true;
1111 } else if ((bi->vcell >= bi->empty_edv + 300 + EDV_HYS)
1112 && (bi->edv_detection == true)) {
1113 bi->update_time = NORMAL_POLL;
1114 bi->edv_detection = false;
1115 } else if ((bi->vcell <= bi->empty_edv && bi->edv_cnt == 2)) {
1116 bi->edv_flag = true;
1118 rt5025_convert_masec_to_permille(bi);
1119 bi->edv_detection = false;
1120 bi->update_time = NORMAL_POLL;
1121 } else if ((bi->vcell > bi->empty_edv + EDV_HYS)) {
1122 bi->min_volt2_alert = false;
1123 bi->edv_flag = false;
1126 if (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING)
1127 bi->edv_flag = false;
1131 RTINFO("tp_cnt=%d, tp_flag=%d, edv_detection=%d, edv_cnt=%d, edv_flag=%d\n",
1132 bi->tp_cnt, bi->tp_flag, bi->edv_detection,
1133 bi->edv_cnt, bi->edv_flag);
1139 static u16 get_crc16_value(u8 *data, int size)
1147 fcs = (u16)((fcs >> 8) ^ crctab16[(fcs ^ data[i]) & 0xff]);
1155 static int IsCrc16Good(u8 *data, int size)
1162 fcs = (u16)((fcs >> 8) ^ crctab16[((fcs ^ data[i]) & 0xff)]);
1166 return (fcs == 0xf0b8);
1169 static int rt5025_battery_parameter_backup(struct rt5025_battery_info *bi)
1175 /*backup fcc_aging, rm, cycle_count, acc_dchg_cap*/
1177 data[0] = (bi->fcc_aging >> 8) & 0xff;
1178 data[1] = (bi->fcc_aging) & 0xff;
1180 data[2] = (bi->acc_dchg_cap >> 24) & 0xff;
1181 data[3] = (bi->acc_dchg_cap >> 16) & 0xff;
1182 data[4] = (bi->acc_dchg_cap >> 8) & 0xff;
1183 data[5] = (bi->acc_dchg_cap) & 0xff;
1185 data[6] = (bi->cycle_cnt) & 0xff;
1187 data[7] = (bi->permille >> 8) & 0xff;
1188 data[8] = (bi->permille) & 0xff;
1190 data[9] = (bi->pre_gauge_timer >> 8) & 0xff;
1191 data[10] = bi->pre_gauge_timer & 0xff;
1193 crc_value = get_crc16_value(data, 13);
1194 data[13] = crc_value & 0xff;
1195 data[14] = (crc_value >> 8) & 0xff;
1196 rt5025_write_reg(bi->client, RT5025_REG_RESV1, data, 15);
1200 static int rt5025_battery_parameter_restore(struct rt5025_battery_info *bi)
1205 rt5025_read_reg(bi->client, RT5025_REG_RESV1, data, 15);
1206 /*restore fcc_aging, rm ,cycle_count, acc_dchg_cap*/
1208 bi->fcc = bi->fcc_aging = data[0] << 8 | data[1];
1210 bi->acc_dchg_cap = data[2] << 24 | data[3] << 16 | data[4] << 8 | data[5];
1212 bi->cycle_cnt = data[6];
1214 bi->permille = data[7] << 8 | data[8];
1216 bi->pre_gauge_timer = bi->gauge_timer = (data[9] << 8) + data[10];
1221 /*return value; 1-> initialized, 0-> no initial value*/
1222 static int rt5025_battery_parameter_initcheck(struct rt5025_battery_info *bi)
1227 if (rt5025_read_reg(bi->client, RT5025_REG_RESV1, data, 15) < 0) {
1228 pr_err("%s: check initial value error\n", __func__);
1231 ret = IsCrc16Good(data, 15);
1233 RTINFO("initial check = %d\n", ret);
1238 static void rt5025_register_init(struct rt5025_battery_info *bi)
1242 /* enable the channel of current,qc,ain,vbat and vadc */
1243 if (rt5025_read_reg(bi->client, RT5025_REG_CHANNELL, data, 1) < 0)
1244 pr_err("%s: failed to read channel\n", __func__);
1246 RTINFO("initial change enable=%02x\n", data[0]);
1247 data[0] = data[0] | CHANNEL_L_BIT_CADC_EN | CHANNEL_L_BIT_AINCH | \
1248 CHANNEL_L_BIT_VBATSCH | CHANNEL_L_BIT_VADC_EN | CHANNEL_L_BIT_INTEMPCH;
1249 if (rt5025_write_reg(bi->client, RT5025_REG_CHANNELL, data, 1) < 0)
1250 pr_err("%s: failed to write channel\n", __func__);
1252 /* set the alert threshold value */
1253 irq_thres[MINVOLT2] = VALRTMIN2_VALUE;
1254 irq_thres[VOLT_RLS] = VRLS_VALUE;
1256 bi->chg_cc_unuse = 0;
1257 bi->dchg_cc_unuse = 0;
1258 bi->pre_gauge_timer = 0;
1260 bi->batt_present = 1;
1261 bi->status = bi->internal_status = POWER_SUPPLY_STATUS_DISCHARGING;
1262 bi->health = POWER_SUPPLY_HEALTH_GOOD;
1264 bi->init_cap = true;
1265 bi->avg_flag = true;
1267 bi->fcc_aging = rt5025_battery_param2[4].y;
1268 bi->fcc = rt5025_battery_param2[4].y;
1269 bi->dc = rt5025_battery_param2[4].y;
1273 bi->edv_flag = false;
1274 bi->edv_detection = false;
1275 bi->init_once = true;
1278 bi->tp_flag = false;
1280 bi->acc_dchg_cap = 0;
1282 bi->empty_edv = rt5025_battery_param2[4].x;
1284 bi->soc1_lock_cnt = 0;
1285 /*eoc fcc update function: initial variable. */
1286 bi->cal_eoc_fcc = 0;
1287 bi->cal_soc_offset = 0;
1290 /*if has initial data, rewrite to the stored data*/
1291 if (rt5025_battery_parameter_initcheck(bi)) {
1292 bi->init_cap = false;
1293 rt5025_battery_parameter_restore(bi);
1294 bi->rm = bi->permille*bi->fcc_aging * 36 / 10;
1297 bi->update_time = NORMAL_POLL;
1298 bi->device_suspend = false;
1299 RTINFO("register initialized\n");
1302 static void rt5025_soc_aging(struct rt5025_battery_info *bi)
1304 if (bi->cycle_cnt >= rt5025_battery_param2[3].x) {
1305 bi->fcc_aging = bi->fcc_aging * (1000 - rt5025_battery_param2[3].y) / 1000;
1306 bi->rm = bi->rm * (1000 - rt5025_battery_param2[3].y) / 1000;
1307 bi->cycle_cnt -= rt5025_battery_param2[3].x;
1309 RTINFO("fcc_aging=%d, rm=%d, cycle_cnt=%d\n",
1310 bi->fcc_aging, bi->rm, bi->cycle_cnt);
1313 static void rt5025_temp_comp(struct rt5025_battery_info *bi)
1317 int slope, const_term;
1318 int delta_y, delta_x;
1321 while ((bi->ext_temp < rt5025_battery_param2[i].x) &&
1326 delta_x = rt5025_battery_param2[i-1].x - rt5025_battery_param2[i].x;
1327 delta_y = (rt5025_battery_param2[i-1].y - rt5025_battery_param2[i].y);
1329 slope = delta_y * 1000 / delta_x;
1331 const_term = (rt5025_battery_param2[i].y) - ((rt5025_battery_param2[i].x * slope) / 1000);
1333 if (bi->ext_temp >= rt5025_battery_param2[0].x)
1334 bi->tempcmp = rt5025_battery_param2[0].y;
1335 else if (bi->ext_temp <= rt5025_battery_param2[size-1].x)
1336 bi->tempcmp = rt5025_battery_param2[size-1].y;
1338 bi->tempcmp = (bi->ext_temp * slope) / 1000 + const_term;
1340 bi->fcc = bi->fcc_aging + bi->fcc_aging * bi->tempcmp / 1000;
1341 if (bi->fcc >= (bi->dc*3>>1))
1342 bi->fcc = bi->dc*3>>1;
1343 if (bi->fcc <= (bi->dc>>1))
1344 bi->fcc = bi->dc>>1;
1345 bi->rm = bi->fcc * bi->permille * 36 / 10;
1346 RTINFO("tempcmp=%d, ext_temp=%d, fcc=%d, rm=%d\n",
1347 bi->tempcmp, bi->ext_temp, bi->fcc, bi->rm);
1351 static void rt5025_soc_temp_comp(struct rt5025_battery_info *bi)
1353 RTINFO("soc->%d++\n", bi->soc);
1354 bi->temp_range_0_5 = 0;
1355 bi->temp_range_5_10 = 0;
1356 bi->temp_range_10_15 = 0;
1357 bi->temp_range_15_20 = 0;
1358 bi->temp_range_20_30 = 0;
1359 bi->temp_range_30_35 = 0;
1360 bi->temp_range_35_40 = 0;
1361 bi->temp_range_40_45 = 0;
1362 bi->temp_range_45_50 = 0;
1364 if (bi->ext_temp < 50)
1365 bi->temp_range_0_5 = 1;
1366 else if (50 <= bi->ext_temp && bi->ext_temp < 100)
1367 bi->temp_range_5_10 = 1;
1368 else if (100 <= bi->ext_temp && bi->ext_temp < 150)
1369 bi->temp_range_10_15 = 1;
1370 else if (150 <= bi->ext_temp && bi->ext_temp < 200)
1371 bi->temp_range_15_20 = 1;
1372 else if (200 <= bi->ext_temp && bi->ext_temp <= 300)
1373 bi->temp_range_20_30 = 1;
1374 else if (300 < bi->ext_temp && bi->ext_temp <= 350)
1375 bi->temp_range_30_35 = 1;
1376 else if (350 < bi->ext_temp && bi->ext_temp <= 400)
1377 bi->temp_range_35_40 = 1;
1378 else if (400 < bi->ext_temp && bi->ext_temp <= 450)
1379 bi->temp_range_40_45 = 1;
1380 else if (450 < bi->ext_temp)
1381 bi->temp_range_45_50 = 1;
1383 if ((bi->temp_range_0_5 == 1) && (bi->range_0_5_done == 0)) {
1384 rt5025_temp_comp(bi);
1385 bi->range_0_5_done = 1;
1386 bi->range_5_10_done = 0;
1387 bi->range_10_15_done = 0;
1388 bi->range_15_20_done = 0;
1389 bi->range_20_30_done = 0;
1390 bi->range_30_35_done = 0;
1391 bi->range_35_40_done = 0;
1392 bi->range_40_45_done = 0;
1393 bi->range_45_50_done = 0;
1394 } else if ((bi->temp_range_5_10 == 1)
1395 && (bi->range_5_10_done == 0)) {
1396 rt5025_temp_comp(bi);
1397 bi->range_0_5_done = 0;
1398 bi->range_5_10_done = 1;
1399 bi->range_10_15_done = 0;
1400 bi->range_15_20_done = 0;
1401 bi->range_20_30_done = 0;
1402 bi->range_30_35_done = 0;
1403 bi->range_35_40_done = 0;
1404 bi->range_40_45_done = 0;
1405 bi->range_45_50_done = 0;
1406 } else if ((bi->temp_range_10_15 == 1)
1407 && (bi->range_10_15_done == 0)) {
1408 rt5025_temp_comp(bi);
1409 bi->range_0_5_done = 0;
1410 bi->range_5_10_done = 0;
1411 bi->range_10_15_done = 1;
1412 bi->range_15_20_done = 0;
1413 bi->range_20_30_done = 0;
1414 bi->range_30_35_done = 0;
1415 bi->range_35_40_done = 0;
1416 bi->range_40_45_done = 0;
1417 bi->range_45_50_done = 0;
1418 } else if ((bi->temp_range_15_20 == 1)
1419 && (bi->range_15_20_done == 0)) {
1420 rt5025_temp_comp(bi);
1421 bi->range_0_5_done = 0;
1422 bi->range_5_10_done = 0;
1423 bi->range_10_15_done = 0;
1424 bi->range_15_20_done = 1;
1425 bi->range_20_30_done = 0;
1426 bi->range_30_35_done = 0;
1427 bi->range_35_40_done = 0;
1428 bi->range_40_45_done = 0;
1429 bi->range_45_50_done = 0;
1430 } else if ((bi->temp_range_20_30 == 1)
1431 && (bi->range_20_30_done == 0)) {
1432 bi->fcc = bi->fcc_aging;
1433 bi->rm = bi->fcc * bi->permille * 36 / 10;
1434 bi->range_0_5_done = 0;
1435 bi->range_5_10_done = 0;
1436 bi->range_10_15_done = 0;
1437 bi->range_15_20_done = 0;
1438 bi->range_20_30_done = 1;
1439 bi->range_30_35_done = 0;
1440 bi->range_35_40_done = 0;
1441 bi->range_40_45_done = 0;
1442 bi->range_45_50_done = 0;
1443 } else if ((bi->temp_range_30_35 == 1)
1444 && (bi->range_30_35_done == 0)) {
1445 rt5025_temp_comp(bi);
1446 bi->range_0_5_done = 0;
1447 bi->range_5_10_done = 0;
1448 bi->range_10_15_done = 0;
1449 bi->range_15_20_done = 0;
1450 bi->range_20_30_done = 0;
1451 bi->range_30_35_done = 1;
1452 bi->range_35_40_done = 0;
1453 bi->range_40_45_done = 0;
1454 bi->range_45_50_done = 0;
1455 } else if ((bi->temp_range_35_40 == 1)
1456 && (bi->range_35_40_done == 0)) {
1457 rt5025_temp_comp(bi);
1458 bi->range_0_5_done = 0;
1459 bi->range_5_10_done = 0;
1460 bi->range_10_15_done = 0;
1461 bi->range_15_20_done = 0;
1462 bi->range_20_30_done = 0;
1463 bi->range_30_35_done = 0;
1464 bi->range_35_40_done = 1;
1465 bi->range_40_45_done = 0;
1466 bi->range_45_50_done = 0;
1467 } else if ((bi->temp_range_40_45 == 1)
1468 && (bi->range_40_45_done == 0)) {
1469 rt5025_temp_comp(bi);
1470 bi->range_0_5_done = 0;
1471 bi->range_5_10_done = 0;
1472 bi->range_10_15_done = 0;
1473 bi->range_15_20_done = 0;
1474 bi->range_20_30_done = 0;
1475 bi->range_30_35_done = 0;
1476 bi->range_35_40_done = 0;
1477 bi->range_40_45_done = 1;
1478 bi->range_45_50_done = 0;
1479 } else if ((bi->temp_range_45_50 == 1)
1480 && (bi->range_45_50_done == 0)) {
1481 rt5025_temp_comp(bi);
1482 bi->range_0_5_done = 0;
1483 bi->range_5_10_done = 0;
1484 bi->range_10_15_done = 0;
1485 bi->range_15_20_done = 0;
1486 bi->range_20_30_done = 0;
1487 bi->range_30_35_done = 0;
1488 bi->range_35_40_done = 0;
1489 bi->range_40_45_done = 0;
1490 bi->range_45_50_done = 1;
1492 RTINFO("soc->%d--\n", bi->soc);
1495 static void rt5025_update(struct rt5025_battery_info *bi)
1498 /* Update voltage */
1499 rt5025_get_vcell(bi);
1500 /* Update current */
1501 rt5025_get_current(bi);
1502 /* Update internal temperature */
1503 rt5025_get_internal_temp(bi);
1504 /* Update external temperature */
1505 rt5025_get_external_temp(bi);
1507 rt5025_get_timer(bi);
1509 rt5025_get_chg_cc(bi);
1510 /* Update dchg cc */
1511 rt5025_get_dchg_cc(bi);
1512 /* Update cycle count check */
1513 rt5025_cycle_count(bi);
1514 /* Calculate cycle count */
1515 rt5025_soc_aging(bi);
1516 /* calculate initial soc */
1518 rt5025_init_capacity(bi);
1520 pr_info("vcell,offset,current,timer,interval,QCHG,QDCHG,tp_cnt,tp_flag,edv_det,edv_cnt,edv_flag,soc,permille,RM,FCC,smooth_flag,acc_QD,cycle,update_time\n");
1525 rt5025_soc_relearn_check(bi);
1527 rt5025_soc_temp_comp(bi);
1531 /* SOC Control Process */
1532 rt5025_soc_lock(bi);
1533 rt5025_soc_irreversible(bi);
1536 bi->last_tp = false;
1538 if (rt5025_battery_param1[0].x >= 4250)
1540 else if (rt5025_battery_param1[0].x >= 4100)
1543 switch (batt_type) {
1545 if ((bi->vcell >= 4250) && (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING))
1546 wake_lock(&bi->full_battery_wake_lock);
1548 wake_unlock(&bi->full_battery_wake_lock);
1552 if ((bi->vcell >= 4100) && (bi->internal_status == POWER_SUPPLY_STATUS_CHARGING))
1553 wake_lock(&bi->full_battery_wake_lock);
1555 wake_unlock(&bi->full_battery_wake_lock);
1559 /* Update RTTF or RTTE */
1561 #if TEMPERATURE_ALERT
1562 if ((bi->max_temp_irq == false) &&
1563 (((irq_thres[MAXTEMP] * IRQ_THRES_UNIT) / 100 - bi->ain_volt) > irq_thres[TEMP_RLS])) {
1564 rt5025_alert_setting(bi, MAXTEMP, true);
1565 } else if ((bi->min_temp_irq == false) &&
1566 ((bi->ain_volt - (irq_thres[MINTEMP] * IRQ_THRES_UNIT) / 100) > irq_thres[TEMP_RLS])) {
1567 rt5025_alert_setting(bi, MINTEMP, true);
1572 if ((bi->min_volt2_irq == false) &&
1573 (bi->vcell > (bi->empty_edv + EDV_HYS)))
1574 rt5025_alert_setting(bi, MINVOLT2, true);
1576 bi->last_suspend = false;
1578 printk(KERN_INFO "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
1579 bi->vcell, bi->curr_offset, bi->curr, bi->gauge_timer,
1580 bi->time_interval, bi->chg_cc, bi->dchg_cc,
1581 bi->tp_cnt, bi->tp_flag, bi->edv_detection,
1582 bi->edv_cnt, bi->edv_flag, bi->soc, bi->permille,
1583 bi->rm, bi->fcc, bi->smooth_flag, bi->acc_dchg_cap,
1584 bi->cycle_cnt, bi->update_time);
1586 RTINFO("[RT5025] update_time=%d\n", bi->update_time);
1591 static void rt5025_update_work(struct work_struct *work)
1593 struct delayed_work *delayed_work = (struct delayed_work *)container_of(work,
1594 struct delayed_work, work);
1595 struct rt5025_battery_info *bi = (struct rt5025_battery_info *)container_of(delayed_work,
1596 struct rt5025_battery_info, monitor_work);
1598 wake_lock(&bi->monitor_wake_lock);
1600 if (bi->soc != bi->last_soc) {
1601 power_supply_changed(&bi->battery);
1602 bi->last_soc = bi->soc;
1605 wake_unlock(&bi->monitor_wake_lock);
1606 if (!bi->device_suspend)
1607 schedule_delayed_work(&bi->monitor_work, bi->update_time*HZ);
1610 static enum power_supply_property rt5025_battery_props[] = {
1611 POWER_SUPPLY_PROP_STATUS,
1612 POWER_SUPPLY_PROP_HEALTH,
1613 POWER_SUPPLY_PROP_PRESENT,
1614 POWER_SUPPLY_PROP_TEMP,
1615 POWER_SUPPLY_PROP_TEMP_AMBIENT,
1616 POWER_SUPPLY_PROP_ONLINE,
1617 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1618 POWER_SUPPLY_PROP_CURRENT_NOW,
1619 POWER_SUPPLY_PROP_CAPACITY,
1620 POWER_SUPPLY_PROP_TECHNOLOGY,
1622 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
1623 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
1627 static int rt5025_battery_sleepvth_setting(struct rt5025_battery_info *bi)
1630 u8 vmax_th, vmin_th;
1634 rt5025_read_reg(bi->client, RT5025_REG_VBATSH, vbat, 2);
1635 temp = ((vbat[0] << 8) + vbat[1]) * 61;
1636 vmax_th = (temp + 5000) / 1953;
1637 vmin_th = (temp - 5000) / 1953;
1639 rt5025_write_reg(bi->client, RT5025_REG_VALRTMAX, &vmax_th, 1);
1640 rt5025_write_reg(bi->client, RT5025_REG_VALRTMIN1, &vmin_th, 1);
1642 RTINFO("vmax_th=0x%02x, vmin_th=0x%02x\n", vmax_th, vmin_th);
1646 static int rt5025_gauge_reginit(struct i2c_client *client)
1648 rt5025_reg_block_write(client, RT5025_REG_VALRTMAX,
1649 5, gauge_init_regval);
1650 rt5025_reg_write(client, RT5025_REG_IRQCTL, 0x00);
1651 rt5025_reg_read(client, RT5025_REG_IRQFLG);
1656 static int rt5025_battery_suspend(struct platform_device *pdev,
1659 struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1662 /*rt5025_get_timer(bi);*/
1663 /*bi->last_event = ktime_get();*/
1664 bi->last_event = current_kernel_time();
1666 /*cy add for battery parameter backup
1667 //rt5025_battery_parameter_backup(bi);
1669 //rt5025_channel_cc(bi, false);
1670 //rt5025_update(bi);*/
1671 bi->device_suspend = true;
1672 cancel_delayed_work_sync(&bi->monitor_work);
1673 /* prevent suspend before starting the alarm */
1674 /*bi->update_time = SUSPEND_POLL;*/
1675 rt5025_alert_setting(bi, MAXVOLT, false);
1676 rt5025_alert_setting(bi, MINVOLT1, false);
1677 rt5025_battery_sleepvth_setting(bi);
1678 if (bi->status == POWER_SUPPLY_STATUS_CHARGING)
1679 rt5025_alert_setting(bi, MAXVOLT, true);
1680 else if (bi->status == POWER_SUPPLY_STATUS_DISCHARGING)
1681 rt5025_alert_setting(bi, MINVOLT1, true);
1682 RTINFO("RM=%d\n", bi->rm);
1686 static int rt5025_battery_resume(struct platform_device *pdev)
1688 struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1691 //struct timespec now = current_kernel_time();
1692 //struct timeval tv;
1693 //long time_interval;
1695 //now = ktime_get();
1696 //tv = ktime_to_timeval(ktime_sub(now, bi->last_event));
1697 //RTINFO("Sleep time = %d\n",(u32)tv.tv_sec);
1698 //bi->rm = bi->rm - ((u32)tv.tv_sec * SLEEP_CURRENT);
1700 //time_interval = now.tv_sec - bi->last_event.tv_sec;
1701 //bi->rm = bi->rm - (time_interval * SLEEP_CURRENT);
1702 //RTINFO("Sleep time=%d, RM=%d",(int)time_interval,bi->rm);
1704 //rt5025_channel_cc(bi, true);*/
1705 bi->last_suspend = true;
1706 bi->device_suspend = false;
1707 schedule_delayed_work(&bi->monitor_work, 0);
1712 static int rt5025_battery_remove(struct platform_device *pdev)
1714 struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1716 power_supply_unregister(&bi->battery);
1717 cancel_delayed_work(&bi->monitor_work);
1718 wake_lock_destroy(&bi->monitor_wake_lock);
1724 static int rt5025_battery_probe(struct platform_device *pdev)
1726 struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
1727 struct rt5025_battery_info *bi;
1730 bi = devm_kzalloc(&pdev->dev, sizeof(*bi), GFP_KERNEL);
1734 bi->client = chip->i2c;
1736 INIT_DELAYED_WORK(&bi->monitor_work, rt5025_update_work);
1738 wake_lock_init(&bi->monitor_wake_lock,
1739 WAKE_LOCK_SUSPEND, "rt-battery-monitor");
1740 wake_lock_init(&bi->low_battery_wake_lock,
1741 WAKE_LOCK_SUSPEND, "low_battery_wake_lock");
1742 wake_lock_init(&bi->status_wake_lock,
1743 WAKE_LOCK_SUSPEND, "battery-status-changed");
1744 wake_lock_init(&bi->smooth100_wake_lock,
1745 WAKE_LOCK_SUSPEND, "smooth100_soc_wake_lock");
1746 wake_lock_init(&bi->smooth0_wake_lock,
1747 WAKE_LOCK_SUSPEND, "smooth0_soc_wake_lock");
1748 wake_lock_init(&bi->full_battery_wake_lock,
1749 WAKE_LOCK_SUSPEND, "full_battery_wake_lock");
1750 #if RT5025_TEST_WAKE_LOCK
1751 wake_lock_init(&bi->test_wake_lock, WAKE_LOCK_SUSPEND, "rt-test");
1753 mutex_init(&bi->status_change_lock);
1754 /* Write trimed data */
1755 /*rt5025_pretrim(client);*/
1756 rt5025_gauge_reginit(bi->client);
1757 /* enable channel */
1758 rt5025_register_init(bi);
1759 /* enable gauge IRQ */
1760 rt5025_alert_init(bi);
1762 /* register callback functions */
1764 chip->cb.rt5025_gauge_irq_handler = rt5025_irq_handler;
1765 chip->cb.rt5025_gauge_set_status = rt5025_set_status;
1766 chip->cb.rt5025_gauge_set_online = rt5025_set_online;
1767 chip->cb.rt5025_gauge_suspend = rt5025_gauge_suspend;
1768 chip->cb.rt5025_gauge_resume = rt5025_gauge_resume;
1769 chip->cb.rt5025_gauge_remove = rt5025_gauge_remove;
1770 rt5025_register_gauge_callbacks(&chip->cb);
1773 platform_set_drvdata(pdev, bi);
1775 bi->battery.name = RT_BATT_NAME;
1776 bi->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1777 bi->battery.set_property = rt5025_set_property;
1778 bi->battery.get_property = rt5025_get_property;
1779 bi->battery.properties = rt5025_battery_props;
1780 bi->battery.num_properties = ARRAY_SIZE(rt5025_battery_props);
1782 ret = power_supply_register(&pdev->dev, &bi->battery);
1784 pr_err("[RT5025] power supply register failed\n");
1788 /*wake_lock(&bi->monitor_wake_lock);*/
1789 #if RT5025_TEST_WAKE_LOCK
1790 wake_lock(&bi->test_wake_lock);
1792 schedule_delayed_work(&bi->monitor_work, INIT_POLL*HZ);
1793 chip->battery_info = bi;
1795 pr_info("rt5025-battery driver is successfully loaded\n");
1799 wake_lock_destroy(&bi->monitor_wake_lock);
1803 static void rt5025_battery_shutdown(struct platform_device *pdev)
1805 struct rt5025_battery_info *bi = platform_get_drvdata(pdev);
1808 if (bi->soc == 0 && bi->cal_fcc != 0) {
1809 /*d. FCC update limitation +/-3%; 2013/12/27
1810 //bi->fcc_aging = bi->cal_fcc/3600 - (bi->fcc -bi->fcc_aging);*/
1813 fcc_new = bi->cal_fcc / 3600 - (bi->fcc - bi->fcc_aging);
1814 if (fcc_new > ((bi->fcc_aging * 103) / 100))
1815 bi->fcc_aging = (bi->fcc_aging * 103) / 100;
1816 else if (fcc_new < ((bi->fcc_aging * 97) / 100))
1817 bi->fcc_aging = (bi->fcc_aging * 97) / 100;
1819 bi->fcc_aging = fcc_new;
1821 RTINFO("bi->cal_fcc=%d\n", bi->cal_fcc);
1823 rt5025_battery_parameter_backup(bi);
1827 static struct of_device_id rt_match_table[] = {
1828 { .compatible = "rt,rt5025-battery",},
1832 static struct platform_driver rt5025_battery_driver = {
1834 .name = RT5025_DEV_NAME "-battery",
1835 .owner = THIS_MODULE,
1836 .of_match_table = rt_match_table,
1838 .probe = rt5025_battery_probe,
1839 .remove = rt5025_battery_remove,
1840 .shutdown = rt5025_battery_shutdown,
1841 .suspend = rt5025_battery_suspend,
1842 .resume = rt5025_battery_resume,
1845 static int rt5025_battery_init(void)
1847 return platform_driver_register(&rt5025_battery_driver);
1849 fs_initcall_sync(rt5025_battery_init);
1851 static void rt5025_battery_exit(void)
1853 platform_driver_unregister(&rt5025_battery_driver);
1855 module_exit(rt5025_battery_exit);
1858 MODULE_LICENSE("GPL");
1859 MODULE_AUTHOR("Nick Hung <nick_hung@richtek.com>");
1860 MODULE_DESCRIPTION("battery gauge driver for RT5025");
1861 MODULE_ALIAS("platform:" RT5025_DEV_NAME "-battery");
1862 MODULE_VERSION(RT5025_DRV_VER);