1 /* drivers/power/rk30_adc_battery.c
3 * battery detect driver for the rk30
5 * This software is licensed under the terms of the GNU General Public
6 * License version 2, as published by the Free Software Foundation, and
7 * may be copied, distributed, and modified under those terms.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
16 #include <linux/module.h>
17 #include <linux/err.h>
18 #include <linux/platform_device.h>
19 #include <linux/power_supply.h>
20 #include <linux/regulator/consumer.h>
21 #include <linux/types.h>
22 #include <linux/pci.h>
23 #include <linux/interrupt.h>
25 #include <asm/mach-types.h>
26 #include <asm/mach/arch.h>
27 #include <asm/mach/map.h>
28 #include <mach/gpio.h>
29 #include <linux/adc.h>
30 #include <mach/iomux.h>
31 #include <mach/board.h>
32 #include <linux/delay.h>
33 #include <linux/ktime.h>
34 #include <linux/slab.h>
35 #include <linux/syscalls.h>
37 #include <linux/wakelock.h>
40 #define DBG(x...) printk(x)
45 static int rk30_battery_dbg_level = 0;
46 module_param_named(dbg_level, rk30_battery_dbg_level, int, 0644);
47 #define pr_bat( args...) \
49 if (rk30_battery_dbg_level) { \
55 /*******************ÒÔϲÎÊý¿ÉÒÔÐÞ¸Ä******************************/
56 #define TIMER_MS_COUNTS 1000 //¶¨Ê±Æ÷µÄ³¤¶Èms
57 //ÒÔϲÎÊýÐèÒª¸ù¾Ýʵ¼Ê²âÊÔµ÷Õû
58 #define SLOPE_SECOND_COUNTS 15 //ͳ¼ÆµçѹбÂʵÄʱ¼ä¼ä¸ôs
59 #define DISCHARGE_MIN_SECOND 45 //×î¿ì·Åµçµç1%ʱ¼ä
60 #define CHARGE_MIN_SECOND 45 //×î¿ì³äµçµç1%ʱ¼ä
61 #define CHARGE_MID_SECOND 90 //ÆÕͨ³äµçµç1%ʱ¼ä
62 #define CHARGE_MAX_SECOND 250 //×³äµçµç1%ʱ¼ä
63 #define CHARGE_FULL_DELAY_TIMES 10 //³äµçÂú¼ì²â·À¶¶Ê±¼ä
64 #define USBCHARGE_IDENTIFY_TIMES 5 //²åÈëUSB»ìÁ÷£¬pcʶ±ð¼ì²âʱ¼ä
66 #define NUM_VOLTAGE_SAMPLE ((SLOPE_SECOND_COUNTS * 1000) / TIMER_MS_COUNTS)
67 #define NUM_DISCHARGE_MIN_SAMPLE ((DISCHARGE_MIN_SECOND * 1000) / TIMER_MS_COUNTS)
68 #define NUM_CHARGE_MIN_SAMPLE ((CHARGE_MIN_SECOND * 1000) / TIMER_MS_COUNTS)
69 #define NUM_CHARGE_MID_SAMPLE ((CHARGE_MID_SECOND * 1000) / TIMER_MS_COUNTS)
70 #define NUM_CHARGE_MAX_SAMPLE ((CHARGE_MAX_SECOND * 1000) / TIMER_MS_COUNTS)
71 #define NUM_CHARGE_FULL_DELAY_TIMES ((CHARGE_FULL_DELAY_TIMES * 1000) / TIMER_MS_COUNTS) //³äµçÂú״̬³ÖÐøʱ¼ä³¤¶È
72 #define NUM_USBCHARGE_IDENTIFY_TIMES ((USBCHARGE_IDENTIFY_TIMES * 1000) / TIMER_MS_COUNTS) //³äµçÂú״̬³ÖÐøʱ¼ä³¤¶È
74 #define CHARGE_IS_OK 1
75 #define INVALID_CHARGE_CHECK -1
76 #if defined(CONFIG_ARCH_RK3066B)
77 #define BAT_DEFINE_VALUE 1800
78 #elif defined(CONFIG_ARCH_RK2928)
79 #define BAT_DEFINE_VALUE 3300
81 #define BAT_DEFINE_VALUE 2500
85 #define BATT_FILENAME "/data/bat_last_capacity.dat"
87 static struct wake_lock batt_wake_lock;
97 #ifdef CONFIG_BATTERY_RK30_VOL3V8
99 #define BATT_MAX_VOL_VALUE 4120 //ÂúµçʱµÄµç³Øµçѹ
100 #define BATT_ZERO_VOL_VALUE 3400 //¹Ø»úʱµÄµç³Øµçѹ
101 #define BATT_NOMAL_VOL_VALUE 3800
103 #define BAT_PULL_UP_R 200
104 #define BAT_PULL_DOWN_R 200
106 static struct batt_vol_cal batt_table[] = {
107 {0,3400,3520},{1,3420,3525},{2,3420,3575},{3,3475,3600},{5,3505,3620},{7,3525,3644},
108 {9,3540,3662},{11,3557,3670},{13,3570,3684},{15,3580,3700},{17,3610,3715},
109 {19,3630,3720},{21,3640,3748},{23,3652,3756},{25,3662,3775},{27,3672,3790},
110 {29,3680,3810},{31,3687,3814},{33,3693,3818},{35,3699,3822},{37,3705,3825},
111 {39,3710,3830},{41,3714,3832},{43,3718,3834},{45,3722,3836},{47,3726,3837},
112 {49,3730,3839},{51,3734,3841},{53,3738,3842},{55,3742,3844},{57,3746,3844},
113 {59,3750,3855},{61,3756,3860},{63,3764,3864},{65,3774,3871},{67,3786,3890},
114 {69,3800,3910},{71,3808,3930},{73,3817,3977},{75,3827,3977},{77,3845,3997},
115 {79,3950,4030},{81,3964,4047},{83,3982,4064},{85,4002,4080},{87,4026,4096},
116 {89,4030,4132},{91,4034,4144},{93,4055,4150},{95,4085,4195},{97,4085,4195},{100,4120,4200},
119 #define BATT_MAX_VOL_VALUE 8284 //Full charge voltage
120 #define BATT_ZERO_VOL_VALUE 6800 // power down voltage
121 #define BATT_NOMAL_VOL_VALUE 7600
123 //¶¨ÒåADC²ÉÑù·Öѹµç×裬ÒÔʵ¼ÊֵΪ׼£¬µ¥Î»K
125 #define BAT_PULL_UP_R 300
126 #define BAT_PULL_DOWN_R 100
128 static struct batt_vol_cal batt_table[] = {
129 {0,6800,7400}, {1,6840,7440}, {2,6880,7480}, {3,6950,7450}, {5,7010,7510}, {7,7050,7550},
130 {9,7080,7580}, {11,7104,7604}, {13,7140,7640}, {15,7160,7660}, {17,7220,7720},
131 {19,7260,7760}, {21,7280,7780}, {23,7304,7802}, {25,7324,7824}, {27,7344,7844},
132 {29,7360,7860}, {31,7374,7874}, {33,7386,7886}, {35,7398,7898}, {37,7410,7910},//500
133 {39,7420,7920}, {41,7424,7928}, {43,7436,7947}, {45,7444,7944}, {47,7450,7958}, //508
134 {49,7460,7965}, {51,7468,7975}, {53, 7476,7990}, {55,7482,8000}, {57,7492,8005}, // 5 14
135 {59,7500,8011}, {61,7510,8033}, {63,7528,8044}, {65,7548,8055}, {67,7560,8066},//506
136 {69,7600,8070}, {71,7618,8075}, {73,7634,8080}, {75,7654,8085}, {77,7690,8100}, //400
137 {79,7900,8180}, {81,7920,8210}, {83,7964,8211}, {85,8000,8214}, {87,8002,8218},//290
138 {89,8012, 8220}, {91,8022,8235}, {93,8110,8260}, {95,8140,8290}, {97,8170,8300}, {100,8200 ,8310},//110
145 #define BATT_NUM ARRAY_SIZE(batt_table)
153 #include <linux/fs.h>
154 int battery_dbg_level = 0;
155 int battery_test_flag = 0;
156 int gVoltageCnt = 3400;
157 int gDoubleVoltageCnt = 6800;
158 #ifdef CONFIG_BATTERY_RK30_VOL3V8
159 #define BATT_MAX_VOL_VALUE 4120 //ÂúµçʱµÄµç³Øµçѹ
160 #define BATT_ZERO_VOL_VALUE 3400 //¹Ø»úʱµÄµç³Øµçѹ
161 #define BATT_NOMAL_VOL_VALUE 3800
163 //int pull_up_res =100;
164 //int pull_down_res = 100;
167 static int batt_table[2*BATT_NUM+6] =
169 0x4B434F52,0x7461625F,0x79726574,0,100,100,
170 3496, 3548, 3599, 3626, 3655, 3697, 3751, 3812, 3877, 3949, 4030, //discharge
171 3540, 3785, 3842, 3861, 3915, 3980, 4041, 4135, 4169, 4175, 4185 //charge
173 #define adc_to_voltage(adc_val) ((adc_val * BAT_DEFINE_VALUE * (batt_table[4] +batt_table[5])) / (1024 *batt_table[5]))
175 #define BATT_MAX_VOL_VALUE 8284 //Full charge voltage
176 #define BATT_ZERO_VOL_VALUE 6800 // power down voltage
177 #define BATT_NOMAL_VOL_VALUE 7600
178 //int pull_up_res =300;
179 //int pull_down_res = 100;
180 //¶¨ÒåADC²ÉÑù·Öѹµç×裬ÒÔʵ¼ÊֵΪ׼£¬µ¥Î»K
182 static int batt_table[2*BATT_NUM+6] =
184 0x4B434F52,0x7461625F,0x79726574,1,300,100,
185 6800,7242,7332,7404,7470,7520,7610,7744,7848,8016,8284,
186 7630, 7754, 7852, 7908, 7956, 8024, 8112, 8220, 8306, 8318, 8328
188 #define adc_to_voltage(adc_val) ((adc_val * BAT_DEFINE_VALUE * (batt_table[4] +batt_table[5])) / (1024 *batt_table[5]))
193 //#define adc_to_voltage(adc_val) ((adc_val * BAT_2V5_VALUE * (BAT_PULL_UP_R + BAT_PULL_DOWN_R)) / (1024 * BAT_PULL_DOWN_R))
196 unsigned long gSecondsCnt = 0;
198 char gDischargeFlag[3] = {"on "};
201 /********************************************************************************/
203 extern int dwc_vbus_status(void);
204 extern int get_msc_connect_flag(void);
206 struct rk30_adc_battery_data {
209 //struct timer_list timer;
210 struct workqueue_struct *wq;
211 struct delayed_work delay_work;
212 struct work_struct dcwakeup_work;
213 struct work_struct lowerpower_work;
216 struct rk30_adc_battery_platform_data *pdata;
220 struct adc_client *client;
222 int adc_samples[NUM_VOLTAGE_SAMPLE+2];
232 int old_charge_level;
234 int gBatCapacityDisChargeCnt;
235 int gBatCapacityChargeCnt;
238 int suspend_capacity;
239 int gBatUsbChargeCnt;
247 static struct rk30_adc_battery_data *gBatteryData;
251 #define BAT_ADC_TABLE_LEN 11
252 static ssize_t bat_param_read(struct device *dev,struct device_attribute *attr, char *buf)
256 for(i=0;i<BATT_NUM;i++)
257 printk("i=%d batt_table=%d\n",i+6,batt_table[i+6]);
259 for(i=0;i<BATT_NUM;i++)
260 printk("i=%d batt_table=%d\n",i+17,batt_table[i+17]);
264 DEVICE_ATTR(batparam, 0664, bat_param_read,NULL);
267 static ssize_t rkbatt_show_debug_attrs(struct device *dev,
268 struct device_attribute *attr, char *buf)
270 return sprintf(buf, "%d\n", battery_dbg_level);
273 static ssize_t rkbatt_restore_debug_attrs(struct device *dev,
274 struct device_attribute *attr,
275 const char *buf, size_t size)
279 sscanf(buf, "%d", &liTmp);
281 if(liTmp != 0 && liTmp != 1)
283 dev_err(dev, "rk29adc_restore_debug_attrs err\n");
287 battery_dbg_level = liTmp;
291 static int is_charge_ok(struct rk30_adc_battery_data *bat);
293 static ssize_t rkbatt_show_state_attrs(struct device *dev,
294 struct device_attribute *attr,
297 // struct rk30_adc_battery_platform_data *pdata = gBatteryData->pdata;
298 int charge_ok_value =0 ;
299 charge_ok_value = is_charge_ok(gBatteryData) ;
302 "gBatVol=%d,gBatCap=%d,charge_ok=%d,%s\n",
303 gBatteryData->bat_voltage,gBatteryData->bat_capacity,
304 charge_ok_value,gDischargeFlag);
307 static ssize_t rkbatt_restore_state_attrs(struct device *dev,
308 struct device_attribute *attr,
309 const char *buf, size_t size)
314 static ssize_t rkbatt_show_value_attrs(struct device *dev,
315 struct device_attribute *attr, char *buf)
317 return sprintf(buf, "pull_up_res =%d,\npull_down_res=%d\n", batt_table[4],batt_table[5]);
320 static ssize_t rkbatt_restore_value_attrs(struct device *dev,
321 struct device_attribute *attr,
322 const char *buf, size_t size)
327 sscanf(buf, "%d,%d", &liUp,&liDown);
329 if(liUp != 0 && liDown != 0)
331 batt_table[4] = liUp;
332 batt_table[5] = liDown;
341 static ssize_t rkbatt_show_flag_attrs(struct device *dev,
342 struct device_attribute *attr, char *buf)
344 return sprintf(buf, "rk29_battery_test_flag=%d\n", battery_test_flag);
346 static ssize_t rkbatt_restore_flag_attrs(struct device *dev,
347 struct device_attribute *attr,
348 const char *buf, size_t size)
352 sscanf(buf, "%d", &liFlag);
356 battery_test_flag = liFlag;
360 static struct device_attribute rkbatt_attrs[] = {
361 __ATTR(state, 0664, rkbatt_show_state_attrs, rkbatt_restore_state_attrs),
362 __ATTR(debug, 0664, rkbatt_show_debug_attrs, rkbatt_restore_debug_attrs),
363 __ATTR(value, 0666, rkbatt_show_value_attrs, rkbatt_restore_value_attrs),
364 __ATTR(flag, 0666, rkbatt_show_flag_attrs, rkbatt_restore_flag_attrs),
367 static int create_sysfs_interfaces(struct device *dev)
370 for (liTmep = 0; liTmep < ARRAY_SIZE(rkbatt_attrs); liTmep++)
372 if (device_create_file(dev, rkbatt_attrs + liTmep))
381 for ( ; liTmep >= 0; liTmep--)
383 device_remove_file(dev, rkbatt_attrs + liTmep);
386 dev_err(dev, "%s:Unable to create sysfs interface\n", __func__);
398 BATTERY_CAPACITY = 3,
399 BATTERY_AC_ONLINE = 4,
400 BATTERY_STATUS_CHANGED = 5,
401 AC_STATUS_CHANGED = 6,
402 BATTERY_INT_STATUS = 7,
403 BATTERY_INT_ENABLE = 8,
416 static int rk30_adc_battery_load_capacity(void)
419 int* p = (int *)value;
420 long fd = sys_open(BATT_FILENAME,O_RDONLY,0);
423 pr_bat("rk30_adc_battery_load_capacity: open file /data/bat_last_capacity.dat failed\n");
427 sys_read(fd,(char __user *)value,4);
433 static void rk30_adc_battery_put_capacity(int loadcapacity)
436 int* p = (int *)value;
437 long fd = sys_open(BATT_FILENAME,O_CREAT | O_RDWR,0);
440 pr_bat("rk30_adc_battery_put_capacity: open file /data/bat_last_capacity.dat failed\n");
445 sys_write(fd, (const char __user *)value, 4);
450 static void rk30_adc_battery_charge_enable(struct rk30_adc_battery_data *bat)
452 struct rk30_adc_battery_platform_data *pdata = bat->pdata;
454 if (pdata->charge_set_pin != INVALID_GPIO){
455 gpio_direction_output(pdata->charge_set_pin, pdata->charge_set_level);
459 static void rk30_adc_battery_charge_disable(struct rk30_adc_battery_data *bat)
461 struct rk30_adc_battery_platform_data *pdata = bat->pdata;
463 if (pdata->charge_set_pin != INVALID_GPIO){
464 gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
468 //extern int suspend_flag;
469 static int rk30_adc_battery_get_charge_level(struct rk30_adc_battery_data *bat)
472 struct rk30_adc_battery_platform_data *pdata = bat->pdata;
474 #if defined (CONFIG_BATTERY_RK30_AC_CHARGE)
475 if (pdata->dc_det_pin != INVALID_GPIO){
476 if (gpio_get_value (pdata->dc_det_pin) == pdata->dc_det_level){
478 bat -> ac_charging = 1;
481 bat -> ac_charging = 0;
486 if(pdata->is_dc_charging){
487 //charge_on =pdata->is_dc_charging();
488 bat ->ac_charging = pdata->is_dc_charging();;
492 if(1 == pdata->spport_usb_charging){
494 if (1 == dwc_vbus_status()) {
495 if (0 == get_msc_connect_flag()){
496 if (++bat->gBatUsbChargeCnt >= NUM_USBCHARGE_IDENTIFY_TIMES){
497 bat->gBatUsbChargeCnt = NUM_USBCHARGE_IDENTIFY_TIMES + 1;
499 bat->usb_charging =1;
500 if(bat -> pdata ->control_usb_charging)
501 bat -> pdata ->control_usb_charging(0);
503 //printk("1 == dwc_vbus_status\n");
507 bat->gBatUsbChargeCnt = 0;
508 if (2 == dwc_vbus_status()) {
510 bat->usb_charging =1;
511 if(bat -> pdata ->control_usb_charging)
512 bat -> pdata ->control_usb_charging(1);
513 //printk("2 == dwc_vbus_status\n");
515 bat->usb_charging =0;
521 if (pdata->spport_usb_charging) //is usb charging
522 if(pdata->is_usb_charging)
523 charge_on = pdata->is_usb_charging();
526 if((bat->usb_charging == 1)||(bat ->ac_charging ==1))
530 static int is_charge_ok(struct rk30_adc_battery_data *bat)
532 int charge_is_ok = 0;
533 struct rk30_adc_battery_platform_data *pdata = bat->pdata;
535 if((pdata->charge_ok_pin == INVALID_GPIO)&& ( pdata->charging_ok == NULL))
538 if (pdata->charge_ok_pin != INVALID_GPIO){
539 if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level)
543 }else if( pdata->charging_ok)
545 charge_is_ok = pdata->charging_ok();
553 //int old_charge_level;
554 static int rk30_adc_battery_status_samples(struct rk30_adc_battery_data *bat)
558 // struct rk30_adc_battery_platform_data *pdata = bat->pdata;
560 charge_level = rk30_adc_battery_get_charge_level(bat);
562 //¼ì²â³äµç״̬±ä»¯Çé¿ö
563 if (charge_level != bat->old_charge_level){
564 bat->old_charge_level = charge_level;
568 rk30_adc_battery_charge_enable(bat);
571 rk30_adc_battery_charge_disable(bat);
573 bat->bat_status_cnt = 0; //״̬±ä»¯¿ªÊ¼¼ÆÊý
576 if(charge_level == 0){
579 bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
583 if( is_charge_ok(bat) == INVALID_CHARGE_CHECK){
585 if (bat->bat_capacity == 100){
586 if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){
587 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
592 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
595 else{ // pin of charge_ok_pin
596 if (is_charge_ok(bat) != CHARGE_IS_OK ){
599 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
602 //¼ì²âµ½³äµçÂúµçƽ±êÖ¾
605 if (bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) {
606 bat->full_times = NUM_CHARGE_FULL_DELAY_TIMES + 1;
609 if ((bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) && (bat->bat_capacity >= 99)){
610 if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){
611 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
612 bat->bat_capacity = 100;
617 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
625 static int rk_adc_voltage(int value)
629 int ref_voltage; //reference_voltage
633 ref_voltage = gBatteryData ->pdata->reference_voltage;
634 pullup_res = gBatteryData ->pdata->pull_up_res;
635 pulldown_res = gBatteryData ->pdata->pull_down_res;
637 if(ref_voltage && pullup_res && pulldown_res){
639 voltage = ((value * ref_voltage * (pullup_res + pulldown_res)) / (1024 * pulldown_res));
642 voltage = adc_to_voltage(value);
649 static void rk_handle_ripple(struct rk30_adc_battery_data *bat, int status)
654 if(bat->bat_voltage >= bat->pdata->charge_table[bat->pdata->table_size-1]+ 10)
655 bat->bat_voltage = bat->pdata->charge_table[bat->pdata->table_size-1] + 10;
656 else if(bat->bat_voltage <= bat->pdata->charge_table[0] - 10)
657 bat->bat_voltage = bat->pdata->charge_table[0] - 10;
660 if(bat->bat_voltage >= bat->pdata->discharge_table[bat->pdata->table_size-1]+ 10)
661 bat->bat_voltage = bat->pdata->discharge_table[ bat->pdata->table_size-1] + 10;
662 else if(bat->bat_voltage <= bat->pdata->discharge_table[ 0] - 10)
663 bat->bat_voltage = bat->pdata->discharge_table[ 0] - 10;
669 if (bat->pdata->use_board_table){
670 p_table = bat->pdata->board_batt_table;
673 if(bat->bat_voltage >= p_table[2*BATT_NUM +5]+ 10)
674 bat->bat_voltage = p_table[2*BATT_NUM +5] + 10;
675 else if(bat->bat_voltage <= p_table[BATT_NUM +6] - 10)
676 bat->bat_voltage = p_table[BATT_NUM +6] - 10;
679 if(bat->bat_voltage >= p_table[BATT_NUM +5]+ 10)
680 bat->bat_voltage = p_table[BATT_NUM +5] + 10;
681 else if(bat->bat_voltage <= p_table[6] - 10)
682 bat->bat_voltage = p_table[6] - 10;
688 static int *pSamples;
689 static void rk30_adc_battery_voltage_samples(struct rk30_adc_battery_data *bat)
692 int i,*pStart = bat->adc_samples, num = 0;
693 int level = rk30_adc_battery_get_charge_level(bat);
696 value = bat->adc_val;
697 adc_async_read(bat->client);
699 *pSamples++ = rk_adc_voltage(value);
701 bat->bat_status_cnt++;
702 if (bat->bat_status_cnt > NUM_VOLTAGE_SAMPLE) bat->bat_status_cnt = NUM_VOLTAGE_SAMPLE + 1;
704 num = pSamples - pStart;
706 if (num >= NUM_VOLTAGE_SAMPLE){
708 num = NUM_VOLTAGE_SAMPLE;
713 for (i = 0; i < num; i++){
714 value += bat->adc_samples[i];
716 bat->bat_voltage = value / num;
719 if(battery_test_flag == 0)
721 if(0 == bat->pdata->use_board_table){
723 if(bat->bat_voltage >= batt_table[2*BATT_NUM +5]+ 10)
724 bat->bat_voltage = batt_table[2*BATT_NUM +5] + 10;
725 else if(bat->bat_voltage <= batt_table[BATT_NUM +6] - 10)
726 bat->bat_voltage = batt_table[BATT_NUM +6] - 10;
729 if(bat->bat_voltage >= batt_table[BATT_NUM +5]+ 10)
730 bat->bat_voltage = batt_table[BATT_NUM +5] + 10;
731 else if(bat->bat_voltage <= batt_table[6] - 10)
732 bat->bat_voltage = batt_table[6] - 10;
735 rk_handle_ripple(bat, level);
738 }else if(battery_test_flag == 2){
740 if(batt_table[3] == 0){
741 if(bat->bat_voltage < 3400){
742 //printk("gSecondsCnt=%ld,get_seconds()=%ld,(get_seconds() - gSecondsCnt)=%ld-------------------1\n",gSecondsCnt,get_seconds(),(get_seconds() - gSecondsCnt));
743 if((get_seconds() - gSecondsCnt) > 30){
744 gSecondsCnt = get_seconds();
745 //printk("gSecondsCnt=%ld,gVoltageCnt=%d,(gVoltageCnt - bat->bat_voltage)=%d,bat->bat_voltage=%d-------------------2\n",gSecondsCnt,gVoltageCnt,(gVoltageCnt - bat->bat_voltage),bat->bat_voltage);
746 if((gVoltageCnt - bat->bat_voltage) > 15){
747 //gVoltageCnt = bat->bat_voltage;
748 //printk("gVoltageCnt=%d-------------------3\n",gVoltageCnt);
749 strncpy(gDischargeFlag, "off" ,3);
751 gVoltageCnt = bat->bat_voltage;
756 if(bat->bat_voltage < 3400){
757 bat->bat_voltage = 3400;
761 if(bat->bat_voltage < 6800){
762 //printk("gSecondsCnt=%ld,get_seconds()=%ld,(get_seconds() - gSecondsCnt)=%ld-------------------1\n",gSecondsCnt,get_seconds(),(get_seconds() - gSecondsCnt));
763 if((get_seconds() - gSecondsCnt) > 30){
764 gSecondsCnt = get_seconds();
765 //printk("gSecondsCnt=%ld,gVoltageCnt=%d,(gVoltageCnt - bat->bat_voltage)=%d,bat->bat_voltage=%d-------------------2\n",gSecondsCnt,gVoltageCnt,(gVoltageCnt - bat->bat_voltage),bat->bat_voltage);
766 if((gDoubleVoltageCnt - bat->bat_voltage) > 30){
767 //gVoltageCnt = bat->bat_voltage;
768 //printk("gVoltageCnt=%d-------------------3\n",gVoltageCnt);
769 strncpy(gDischargeFlag, "off" ,3);
771 gDoubleVoltageCnt =bat->bat_voltage;
774 if(bat->bat_voltage < 6800){
775 bat->bat_voltage = 6800;
779 /****************************************************/
782 static int rk_voltage_capacity(struct rk30_adc_battery_data *bat, int BatVoltage)
787 int size =bat->pdata->table_size;
789 int *p_capacity = bat->pdata->property_tabel;
791 if (rk30_adc_battery_get_charge_level(bat)){ //charge
792 p = bat->pdata->charge_table;
793 if(BatVoltage >= (p[size - 1])){
797 if(BatVoltage <= (p[0])){
801 for(i = 0; i < size - 1; i++){
803 if(((p[i]) <= BatVoltage) && (BatVoltage < (p[i+1]))){
804 capacity = p_capacity[i] + ((BatVoltage - p[i]) * (p_capacity[i+1] -p_capacity[i]))/ (p[i+1]- p[i]);
813 p = bat->pdata->discharge_table;
814 if(BatVoltage >= (p[size - 1])){
818 if(BatVoltage <= p[0]){
822 for(i = 0; i < size - 1; i++){
823 if((p[i] <= BatVoltage) &&( BatVoltage < p[i+1])){
824 capacity = p_capacity[i]+ ((BatVoltage - p[i]) * (p_capacity[i+1] -p_capacity[i] ) )/ (p[i+1]- p[i]) ;
840 static int rk30_adc_battery_voltage_to_capacity(struct rk30_adc_battery_data *bat, int BatVoltage)
846 if (bat->pdata->use_board_table)
847 p = bat->pdata->board_batt_table;
851 // rk30_battery_table_info_dump(p);
853 if (rk30_adc_battery_get_charge_level(bat)){ //charge
854 if(BatVoltage >= (p[2*BATT_NUM +5])){
858 if(BatVoltage <= (p[BATT_NUM +6])){
862 for(i = BATT_NUM +6; i <2*BATT_NUM +6; i++){
864 if(((p[i]) <= BatVoltage) && (BatVoltage < (p[i+1]))){
865 capacity = (i-(BATT_NUM +6))*10 + ((BatVoltage - p[i]) * 10)/ (p[i+1]- p[i]);
873 if(BatVoltage >= (p[BATT_NUM +5])){
877 if(BatVoltage <= (p[6])){
881 for(i = 6; i < BATT_NUM +6; i++){
882 if(((p[i]) <= BatVoltage) && (BatVoltage < (p[i+1]))){
883 capacity = (i-6)*10+ ((BatVoltage - p[i]) *10 )/ (p[i+1]- p[i]) ;
898 static void rk30_adc_battery_capacity_samples(struct rk30_adc_battery_data *bat)
901 // struct rk30_adc_battery_platform_data *pdata = bat->pdata;
902 int timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE;
903 int timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE;
905 //³ä·Åµç״̬±ä»¯ºó£¬BufferÌîÂú֮ǰ£¬²»¸üÐÂ
906 if (bat->bat_status_cnt < NUM_VOLTAGE_SAMPLE) {
907 bat->gBatCapacityDisChargeCnt = 0;
908 bat->gBatCapacityChargeCnt = 0;
912 capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
914 if (rk30_adc_battery_get_charge_level(bat)){
915 if (capacity > bat->bat_capacity){
916 if(capacity > bat->bat_capacity + 10 )
917 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -10; //5s
918 else if(capacity > bat->bat_capacity + 7 )
919 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -5; //10s
920 else if(capacity > bat->bat_capacity + 3 )
921 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE - 2; // 13
922 //ʵ¼Ê²ÉÑùµ½µÄÈÝÁ¿±ÈÏÔʾµÄÈÝÁ¿´ó£¬Öð¼¶ÉÏÉý
923 if (++(bat->gBatCapacityDisChargeCnt) >= timer_of_charge_sample){
924 bat->gBatCapacityDisChargeCnt = 0;
925 if (bat->bat_capacity < 99){
930 bat->gBatCapacityChargeCnt = 0;
932 else{ // ʵ¼ÊµÄÈÝÁ¿±È²ÉÑù±È ÏÔʾµÄÈÝÁ¿Ð¡
933 bat->gBatCapacityDisChargeCnt = 0;
934 (bat->gBatCapacityChargeCnt)++;
935 if( is_charge_ok(bat) != INVALID_CHARGE_CHECK){
936 //if (pdata->charge_ok_pin != INVALID_GPIO){
937 //if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level){
938 if( is_charge_ok(bat) == CHARGE_IS_OK){
939 if(capacity > bat->bat_capacity + 10 )
940 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -13; // 2s
941 else if(capacity > bat->bat_capacity + 7 )
942 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -10; //10s
943 else if(capacity > bat->bat_capacity + 2 )
944 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -8; //7s
945 //¼ì²âµ½µç³Ø³äÂú±êÖ¾£¬Í¬Ê±³¤Ê±¼äÄÚ³äµçµçѹÎޱ仯£¬¿ªÊ¼Æô¶¯¼Æʱ³äµç£¬¿ìËÙÉÏÉýÈÝÁ¿
946 if (bat->gBatCapacityChargeCnt >= timer_of_charge_sample){
947 bat->gBatCapacityChargeCnt = 0;
948 if (bat->bat_capacity < 99){
956 if (capacity > capacitytmp){
957 //¹ý³ÌÖÐÈç¹ûµçѹÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±Èʵ¼Ê³äµç¿ì
958 gBatCapacityChargeCnt = 0;
960 else if (/*bat->bat_capacity >= 85) &&*/ (gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)){
961 gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
963 if (bat->bat_capacity < 99){
969 #else // ·ÀÖ¹µç³ØÀÏ»¯ºó³öÏֳ岻ÂúµÄÇé¿ö£¬
970 if (capacity > bat->capacitytmp){
971 //¹ý³ÌÖÐÈç¹ûµçѹÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±Èʵ¼Ê³äµç¿ì
972 bat->gBatCapacityChargeCnt = 0;
976 if ((bat->bat_capacity >= 85) &&((bat->gBatCapacityChargeCnt) > NUM_CHARGE_MAX_SAMPLE)){
977 bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
979 if (bat->bat_capacity < 99){
990 //ûÓгäµçÂú¼ì²â½Å£¬³¤Ê±¼äÄÚµçѹÎޱ仯£¬¶¨Ê±Æ÷Ä£Äâ³äµç
991 if (capacity > bat->capacitytmp){
992 //¹ý³ÌÖÐÈç¹ûµçѹÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±Èʵ¼Ê³äµç¿ì
993 bat->gBatCapacityChargeCnt = 0;
997 if ((bat->bat_capacity >= 85) &&(bat->gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)){
998 bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
1000 if (bat->bat_capacity < 99){
1001 bat->bat_capacity++;
1002 bat->bat_change = 1;
1012 //·Åµçʱ,Ö»ÔÊÐíµçѹϽµ
1013 if (capacity < bat->bat_capacity){
1014 if(capacity + 10 > bat->bat_capacity )
1015 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -10; //5s
1016 else if(capacity + 7 > bat->bat_capacity )
1017 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -5; //10s
1018 else if(capacity + 3> bat->bat_capacity )
1019 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 2; // 13
1021 if (++(bat->gBatCapacityDisChargeCnt) >= timer_of_discharge_sample){
1022 bat->gBatCapacityDisChargeCnt = 0;
1023 if (bat->bat_capacity > 0){
1024 bat->bat_capacity-- ;
1025 bat->bat_change = 1;
1030 bat->gBatCapacityDisChargeCnt = 0;
1032 bat->gBatCapacityChargeCnt = 0;
1034 bat->capacitytmp = capacity;
1037 //static int poweron_check = 0;
1038 static void rk30_adc_battery_poweron_capacity_check(void)
1041 int new_capacity, old_capacity;
1044 new_capacity = gBatteryData->bat_capacity;
1047 old_capacity = rk30_adc_battery_load_capacity();
1048 // printk("------------------->> : %d \n",old_capacity);
1049 if( old_capacity >= 0 ){
1054 // printk("---------------------------------------------------------->> : %d \n",old_capacity);
1055 if ((old_capacity < 0) || (old_capacity > 100)){
1056 old_capacity = new_capacity;
1059 if (gBatteryData->bat_status == POWER_SUPPLY_STATUS_FULL){
1060 if (new_capacity > 80){
1061 gBatteryData->bat_capacity = 100;
1064 else if (gBatteryData->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING){
1067 // //1£©³¤Ê±¼ä¹Ø»ú·ÅÖú󣬿ª»úºó¶ÁÈ¡µÄÈÝÁ¿Ô¶Ô¶´óÓÚʵ¼ÊÈÝÁ¿Ôõô°ì£¿
1068 // //2£©Èç¹û²»ÕâÑù×ö£¬¶Ìʱ¼ä¹Ø»úÔÙ¿ª»ú£¬Ç°ºóÈÝÁ¿²»Ò»ÖÂÓÖ¸ÃÔõô°ì£¿
1069 // //3£©Ò»ÏÂÄÇÖÖ·½Ê½ºÏÊÊ£¿
1070 //gBatteryData->bat_capacity = new_capacity;
1071 gBatteryData->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
1074 if(new_capacity > old_capacity + 50 )
1075 gBatteryData->bat_capacity = new_capacity;
1077 gBatteryData->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity; //avoid the value of capacity increase
1081 printk("capacity = %d, new_capacity = %d, old_capacity = %d\n",gBatteryData->bat_capacity, new_capacity, old_capacity);
1083 gBatteryData->bat_change = 1;
1086 static int rk30_adc_battery_get_usb_property(struct power_supply *psy,
1087 enum power_supply_property psp,
1088 union power_supply_propval *val)
1090 charger_type_t charger;
1091 charger = CHARGER_USB;
1094 case POWER_SUPPLY_PROP_ONLINE:
1095 if (psy->type == POWER_SUPPLY_TYPE_USB)
1096 val->intval = gBatteryData ->usb_charging;
1097 //printk("%s:%d\n",__FUNCTION__,val->intval);
1108 static enum power_supply_property rk30_adc_battery_usb_props[] = {
1110 POWER_SUPPLY_PROP_ONLINE,
1113 static struct power_supply rk30_usb_supply =
1116 .type = POWER_SUPPLY_TYPE_USB,
1118 .get_property = rk30_adc_battery_get_usb_property,
1120 .properties = rk30_adc_battery_usb_props,
1121 .num_properties = ARRAY_SIZE(rk30_adc_battery_usb_props),
1124 #if defined(CONFIG_BATTERY_RK30_AC_CHARGE)
1125 static irqreturn_t rk30_adc_battery_dc_wakeup(int irq, void *dev_id)
1127 queue_work(gBatteryData->wq, &gBatteryData->dcwakeup_work);
1132 static int rk30_adc_battery_get_ac_property(struct power_supply *psy,
1133 enum power_supply_property psp,
1134 union power_supply_propval *val)
1137 charger_type_t charger;
1138 charger = CHARGER_USB;
1140 case POWER_SUPPLY_PROP_ONLINE:
1141 if (psy->type == POWER_SUPPLY_TYPE_MAINS)
1143 //if (rk30_adc_battery_get_charge_level(gBatteryData))
1144 val->intval = gBatteryData ->ac_charging;
1146 DBG("%s:%d\n",__FUNCTION__,val->intval);
1157 static enum power_supply_property rk30_adc_battery_ac_props[] =
1159 POWER_SUPPLY_PROP_ONLINE,
1162 static struct power_supply rk30_ac_supply =
1165 .type = POWER_SUPPLY_TYPE_MAINS,
1167 .get_property = rk30_adc_battery_get_ac_property,
1169 .properties = rk30_adc_battery_ac_props,
1170 .num_properties = ARRAY_SIZE(rk30_adc_battery_ac_props),
1173 static void rk30_adc_battery_dcdet_delaywork(struct work_struct *work)
1176 struct rk30_adc_battery_platform_data *pdata;
1180 pdata = gBatteryData->pdata;
1181 irq = gpio_to_irq(pdata->dc_det_pin);
1182 irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1184 rk28_send_wakeup_key(); // wake up the system
1186 free_irq(irq, NULL);
1187 ret = request_irq(irq, rk30_adc_battery_dc_wakeup, irq_flag, "ac_charge_irq", NULL);// reinitialize the DC irq
1189 free_irq(irq, NULL);
1192 power_supply_changed(&rk30_ac_supply);
1194 gBatteryData->bat_status_cnt = 0; //the state of battery is change
1201 static int rk30_adc_battery_get_status(struct rk30_adc_battery_data *bat)
1203 return (bat->bat_status);
1206 static int rk30_adc_battery_get_health(struct rk30_adc_battery_data *bat)
1208 return POWER_SUPPLY_HEALTH_GOOD;
1211 static int rk30_adc_battery_get_present(struct rk30_adc_battery_data *bat)
1213 return (bat->bat_voltage < BATT_MAX_VOL_VALUE) ? 0 : 1;
1216 static int rk30_adc_battery_get_voltage(struct rk30_adc_battery_data *bat)
1218 return (bat->bat_voltage );
1221 static int rk30_adc_battery_get_capacity(struct rk30_adc_battery_data *bat)
1223 return (bat->bat_capacity);
1226 static int rk30_adc_battery_get_property(struct power_supply *psy,
1227 enum power_supply_property psp,
1228 union power_supply_propval *val)
1233 case POWER_SUPPLY_PROP_STATUS:
1234 val->intval = rk30_adc_battery_get_status(gBatteryData);
1235 DBG("gBatStatus=%d\n",val->intval);
1237 case POWER_SUPPLY_PROP_HEALTH:
1238 val->intval = rk30_adc_battery_get_health(gBatteryData);
1239 DBG("gBatHealth=%d\n",val->intval);
1241 case POWER_SUPPLY_PROP_PRESENT:
1242 val->intval = rk30_adc_battery_get_present(gBatteryData);
1243 DBG("gBatPresent=%d\n",val->intval);
1245 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1246 val ->intval = rk30_adc_battery_get_voltage(gBatteryData);
1247 DBG("gBatVoltage=%d\n",val->intval);
1249 // case POWER_SUPPLY_PROP_CURRENT_NOW:
1250 // val->intval = 1100;
1252 case POWER_SUPPLY_PROP_CAPACITY:
1253 if(battery_test_flag == 2)
1256 val->intval = rk30_adc_battery_get_capacity(gBatteryData);
1257 DBG("gBatCapacity=%d%%\n",val->intval);
1259 case POWER_SUPPLY_PROP_TECHNOLOGY:
1260 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
1262 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
1263 val->intval = BATT_MAX_VOL_VALUE;
1265 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
1266 val->intval = BATT_ZERO_VOL_VALUE;
1276 static enum power_supply_property rk30_adc_battery_props[] = {
1278 POWER_SUPPLY_PROP_STATUS,
1279 POWER_SUPPLY_PROP_HEALTH,
1280 POWER_SUPPLY_PROP_PRESENT,
1281 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1282 // POWER_SUPPLY_PROP_CURRENT_NOW,
1283 POWER_SUPPLY_PROP_TECHNOLOGY,
1284 POWER_SUPPLY_PROP_CAPACITY,
1285 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
1286 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
1289 static struct power_supply rk30_battery_supply =
1292 .type = POWER_SUPPLY_TYPE_BATTERY,
1294 .get_property = rk30_adc_battery_get_property,
1296 .properties = rk30_adc_battery_props,
1297 .num_properties = ARRAY_SIZE(rk30_adc_battery_props),
1301 static void rk30_adc_battery_resume_check(void)
1305 int new_capacity, old_capacity;
1306 struct rk30_adc_battery_data *bat = gBatteryData;
1308 bat->old_charge_level = -1;
1309 pSamples = bat->adc_samples;
1311 adc_sync_read(bat->client); //start adc sample
1312 level = oldlevel = rk30_adc_battery_status_samples(bat);//init charge status
1314 for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++) { //0.3 s
1317 rk30_adc_battery_voltage_samples(bat); //get voltage
1318 level = rk30_adc_battery_status_samples(bat); //check charge status
1319 if (oldlevel != level){
1320 oldlevel = level; //if charge status changed, reset sample
1324 new_capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
1325 old_capacity =gBatteryData-> suspend_capacity;
1327 if (bat->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING){
1329 bat->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
1332 bat->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity; // aviod the value of capacity increase dicharge
1337 static int rk30_adc_battery_suspend(struct platform_device *dev, pm_message_t state)
1340 gBatteryData->suspend_capacity = gBatteryData->bat_capacity;
1341 cancel_delayed_work(&gBatteryData->delay_work);
1343 if( gBatteryData->pdata->batt_low_pin != INVALID_GPIO){
1345 irq = gpio_to_irq(gBatteryData->pdata->batt_low_pin);
1347 enable_irq_wake(irq);
1353 static int rk30_adc_battery_resume(struct platform_device *dev)
1356 gBatteryData->resume = true;
1357 queue_delayed_work(gBatteryData->wq, &gBatteryData->delay_work, msecs_to_jiffies(100));
1358 if( gBatteryData->pdata->batt_low_pin != INVALID_GPIO){
1360 irq = gpio_to_irq(gBatteryData->pdata->batt_low_pin);
1361 disable_irq_wake(irq);
1367 #define rk30_adc_battery_suspend NULL
1368 #define rk30_adc_battery_resume NULL
1372 unsigned long AdcTestCnt = 0;
1373 static void rk30_adc_battery_timer_work(struct work_struct *work)
1376 if (gBatteryData->resume) {
1377 rk30_adc_battery_resume_check();
1378 gBatteryData->resume = false;
1383 rk30_adc_battery_status_samples(gBatteryData);
1385 if (gBatteryData->poweron_check){
1386 gBatteryData->poweron_check = 0;
1387 rk30_adc_battery_poweron_capacity_check();
1390 rk30_adc_battery_voltage_samples(gBatteryData);
1391 rk30_adc_battery_capacity_samples(gBatteryData);
1393 if( 0 == gBatteryData ->pdata ->charging_sleep){
1394 if( 1 == rk30_adc_battery_get_charge_level(gBatteryData)){ // charge
1395 if(0 == gBatteryData->status_lock ){
1396 wake_lock(&batt_wake_lock); //lock
1397 gBatteryData->status_lock = 1;
1401 if(1 == gBatteryData->status_lock ){
1402 wake_unlock(&batt_wake_lock); //unlock
1403 gBatteryData->status_lock = 0;
1410 /*update battery parameter after adc and capacity has been changed*/
1411 if(gBatteryData->bat_change){
1412 gBatteryData->bat_change = 0;
1413 rk30_adc_battery_put_capacity(gBatteryData->bat_capacity);
1414 power_supply_changed(&rk30_battery_supply);
1415 #if defined (CONFIG_BATTERY_RK30_AC_CHARGE)
1416 if (gBatteryData->pdata->dc_det_pin == INVALID_GPIO){
1417 power_supply_changed(&rk30_ac_supply);
1421 if(1 == gBatteryData->pdata->spport_usb_charging){
1422 power_supply_changed(&rk30_usb_supply);
1428 if (rk30_battery_dbg_level){
1429 if (++AdcTestCnt >= 2)
1433 pr_bat("Status = %d, RealAdcVal = %d, RealVol = %d,gBatVol = %d, gBatCap = %d, RealCapacity = %d, dischargecnt = %d, chargecnt = %d\n",
1434 gBatteryData->bat_status, gBatteryData->adc_val, rk_adc_voltage(gBatteryData->adc_val),
1435 gBatteryData->bat_voltage, gBatteryData->bat_capacity, gBatteryData->capacitytmp, gBatteryData->gBatCapacityDisChargeCnt,gBatteryData-> gBatCapacityChargeCnt);
1439 queue_delayed_work(gBatteryData->wq, &gBatteryData->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS));
1444 static int rk30_adc_battery_io_init(struct rk30_adc_battery_platform_data *pdata)
1448 if (pdata->io_init) {
1453 //charge control pin
1454 if (pdata->charge_set_pin != INVALID_GPIO){
1455 ret = gpio_request(pdata->charge_set_pin, NULL);
1457 printk("failed to request dc_det gpio\n");
1460 gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
1463 //dc charge detect pin
1464 if (pdata->dc_det_pin != INVALID_GPIO){
1465 ret = gpio_request(pdata->dc_det_pin, NULL);
1467 printk("failed to request dc_det gpio\n");
1471 gpio_pull_updown(pdata->dc_det_pin, GPIOPullUp);//important
1472 ret = gpio_direction_input(pdata->dc_det_pin);
1474 printk("failed to set gpio dc_det input\n");
1480 if (pdata->charge_ok_pin != INVALID_GPIO){
1481 ret = gpio_request(pdata->charge_ok_pin, NULL);
1483 printk("failed to request charge_ok gpio\n");
1487 gpio_pull_updown(pdata->charge_ok_pin, GPIOPullUp);//important
1488 ret = gpio_direction_input(pdata->charge_ok_pin);
1490 printk("failed to set gpio charge_ok input\n");
1495 if( pdata->batt_low_pin != INVALID_GPIO){
1496 ret = gpio_request(pdata->batt_low_pin, NULL);
1498 printk("failed to request batt_low_pin gpio\n");
1502 gpio_pull_updown(pdata->batt_low_pin, GPIOPullUp);
1503 ret = gpio_direction_input(pdata->batt_low_pin);
1505 printk("failed to set gpio batt_low_pin input\n");
1515 extern void kernel_power_off(void);
1516 static void rk30_adc_battery_check(struct rk30_adc_battery_data *bat)
1520 struct rk30_adc_battery_platform_data *pdata = bat->pdata;
1521 //printk("%s--%d:\n",__FUNCTION__,__LINE__);
1523 bat->old_charge_level = -1;
1524 bat->capacitytmp = 0;
1525 bat->suspend_capacity = 0;
1527 pSamples = bat->adc_samples;
1529 adc_sync_read(bat->client); //start adc sample
1530 level = oldlevel = rk30_adc_battery_status_samples(bat);//init charge status
1532 bat->full_times = 0;
1533 for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++){ //0.3 s
1535 rk30_adc_battery_voltage_samples(bat); //get voltage
1536 //level = rk30_adc_battery_status_samples(bat); //check charge status
1537 level = rk30_adc_battery_get_charge_level(bat);
1539 if (oldlevel != level){
1540 oldlevel = level; //if charge status changed, reset sample
1545 bat->bat_capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage); //init bat_capacity
1548 bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1549 if (rk30_adc_battery_get_charge_level(bat)){
1550 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
1552 if (pdata->charge_ok_pin != INVALID_GPIO){
1553 if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level){
1554 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
1555 bat->bat_capacity = 100;
1564 rk30_adc_battery_poweron_capacity_check();
1566 gBatteryData->poweron_check = 1;
1568 gBatteryData->poweron_check = 0;
1570 /*******************************************
1571 //¿ª»ú²ÉÑùµ½µÄµçѹºÍÉϴιػú±£´æµçѹÏà²î½Ï´ó£¬Ôõô´¦Àí£¿
1572 if (bat->bat_capacity > old_capacity)
1574 if ((bat->bat_capacity - old_capacity) > 20)
1579 else if (bat->bat_capacity < old_capacity)
1581 if ((old_capacity > bat->bat_capacity) > 20)
1586 *********************************************/
1587 if (bat->bat_capacity == 0) bat->bat_capacity = 1;
1590 if(1==gBatteryData -> pdata->low_voltage_protection)
1591 if ((bat->bat_voltage <= BATT_ZERO_VOL_VALUE)&&(bat->bat_status != POWER_SUPPLY_STATUS_CHARGING)){
1597 static void rk30_adc_battery_callback(struct adc_client *client, void *param, int result)
1600 struct rk30_adc_battery_data *info = container_of(client, struct rk30_adc_battery_data,
1602 info->adc_val = result;
1605 pr_bat("adc_battery_callback resule < 0 , the value ");
1609 gBatteryData->adc_val = result;
1610 pr_bat("result = %d, gBatteryData->adc_val = %d\n", result, gBatteryData->adc_val );
1616 static void rk30_adc_battery_lowerpower_delaywork(struct work_struct *work)
1619 if( gBatteryData->pdata->batt_low_pin != INVALID_GPIO){
1620 irq = gpio_to_irq(gBatteryData->pdata->batt_low_pin);
1624 printk("lowerpower\n");
1625 rk28_send_wakeup_key(); // wake up the system
1630 static irqreturn_t rk30_adc_battery_low_wakeup(int irq,void *dev_id)
1632 queue_work(gBatteryData->wq, &gBatteryData->lowerpower_work);
1638 static int rk30_adc_battery_probe(struct platform_device *pdev)
1643 struct adc_client *client;
1644 struct rk30_adc_battery_data *data;
1645 struct rk30_adc_battery_platform_data *pdata = pdev->dev.platform_data;
1646 gSecondsCnt = get_seconds();
1647 data = kzalloc(sizeof(*data), GFP_KERNEL);
1650 goto err_data_alloc_failed;
1652 memset(data, 0, sizeof(struct rk30_adc_battery_data));
1653 gBatteryData = data;
1655 platform_set_drvdata(pdev, data);
1657 data->pdata = pdata;
1658 data->status_lock = 0;
1659 ret = rk30_adc_battery_io_init(pdata);
1664 memset(data->adc_samples, 0, sizeof(int)*(NUM_VOLTAGE_SAMPLE + 2));
1666 //register adc for battery sample
1667 if(0 == pdata->adc_channel)
1668 client = adc_register(0, rk30_adc_battery_callback, NULL); //pdata->adc_channel = ani0
1670 client = adc_register(pdata->adc_channel, rk30_adc_battery_callback, NULL);
1672 goto err_adc_register_failed;
1675 data->client = client;
1676 data->adc_val = adc_sync_read(client);
1678 ret = power_supply_register(&pdev->dev, &rk30_battery_supply);
1680 printk(KERN_INFO "fail to battery power_supply_register\n");
1681 goto err_battery_failed;
1684 ret = device_create_file(&pdev->dev,&dev_attr_batparam);
1687 printk(KERN_ERR "failed to create bat param file\n");
1688 goto err_battery_failed;
1692 if(1 == pdata->spport_usb_charging){
1693 ret = power_supply_register(&pdev->dev, &rk30_usb_supply);
1695 printk(KERN_INFO "fail to usb power_supply_register\n");
1696 goto err_usb_failed;
1699 wake_lock_init(&batt_wake_lock, WAKE_LOCK_SUSPEND, "batt_lock");
1701 data->wq = create_singlethread_workqueue("adc_battd");
1702 INIT_DELAYED_WORK(&data->delay_work, rk30_adc_battery_timer_work);
1703 //Power on Battery detect
1704 rk30_adc_battery_check(data);
1705 if(1 == pdata->save_capacity ){
1706 queue_delayed_work(data->wq, &data->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS*10));
1707 gBatteryData->poweron_check = 1;
1709 queue_delayed_work(data->wq, &data->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS));
1710 gBatteryData->poweron_check = 0;
1713 #if defined (CONFIG_BATTERY_RK30_AC_CHARGE)
1714 ret = power_supply_register(&pdev->dev, &rk30_ac_supply);
1716 printk(KERN_INFO "fail to ac power_supply_register\n");
1719 //init dc dectet irq & delay work
1720 if (pdata->dc_det_pin != INVALID_GPIO){
1721 INIT_WORK(&data->dcwakeup_work, rk30_adc_battery_dcdet_delaywork);
1723 irq = gpio_to_irq(pdata->dc_det_pin);
1724 irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1725 ret = request_irq(irq, rk30_adc_battery_dc_wakeup, irq_flag, "ac_charge_irq", NULL);
1727 printk("failed to request dc det irq\n");
1728 goto err_dcirq_failed;
1730 enable_irq_wake(irq);
1736 // batt low irq lowerpower_work
1737 if( pdata->batt_low_pin != INVALID_GPIO){
1738 INIT_WORK(&data->lowerpower_work, rk30_adc_battery_lowerpower_delaywork);
1740 irq = gpio_to_irq(pdata->batt_low_pin);
1741 ret = request_irq(irq, rk30_adc_battery_low_wakeup, IRQF_TRIGGER_LOW, "batt_low_irq", NULL);
1744 printk("failed to request batt_low_irq irq\n");
1745 goto err_lowpowerirq_failed;
1753 ret = create_sysfs_interfaces(&pdev->dev);
1757 "device rk30_adc_batterry sysfs register failed\n");
1762 printk(KERN_INFO "rk30_adc_battery: driver initialized\n");
1767 power_supply_unregister(&rk30_usb_supply);
1770 #if defined (CONFIG_BATTERY_RK30_AC_CHARGE)
1771 power_supply_unregister(&rk30_ac_supply);
1775 power_supply_unregister(&rk30_battery_supply);
1778 free_irq(gpio_to_irq(pdata->dc_det_pin), data);
1780 err_lowpowerirq_failed:
1781 free_irq(gpio_to_irq(pdata->batt_low_pin), data);
1783 err_adc_register_failed:
1785 err_data_alloc_failed:
1788 printk("rk30_adc_battery: error!\n");
1793 static int rk30_adc_battery_remove(struct platform_device *pdev)
1795 struct rk30_adc_battery_data *data = platform_get_drvdata(pdev);
1796 struct rk30_adc_battery_platform_data *pdata = pdev->dev.platform_data;
1798 cancel_delayed_work(&gBatteryData->delay_work);
1799 if(1 == pdata->spport_usb_charging){
1800 power_supply_unregister(&rk30_usb_supply);
1802 #if defined(CONFIG_BATTERY_RK30_AC_CHARGE)
1803 power_supply_unregister(&rk30_ac_supply);
1805 power_supply_unregister(&rk30_battery_supply);
1807 free_irq(gpio_to_irq(pdata->dc_det_pin), data);
1814 static struct platform_driver rk30_adc_battery_driver = {
1815 .probe = rk30_adc_battery_probe,
1816 .remove = rk30_adc_battery_remove,
1817 .suspend = rk30_adc_battery_suspend,
1818 .resume = rk30_adc_battery_resume,
1820 .name = "rk30-battery",
1821 .owner = THIS_MODULE,
1825 static int __init rk30_adc_battery_init(void)
1827 return platform_driver_register(&rk30_adc_battery_driver);
1830 static void __exit rk30_adc_battery_exit(void)
1832 platform_driver_unregister(&rk30_adc_battery_driver);
1835 module_init(rk30_adc_battery_init);//module_init(rk30_adc_battery_init);//subsys_initcall(rk30_adc_battery_init);
1836 module_exit(rk30_adc_battery_exit);
1838 MODULE_DESCRIPTION("Battery detect driver for the rk30");
1839 MODULE_AUTHOR("luowei lw@rock-chips.com");
1840 MODULE_LICENSE("GPL");