1 /* drivers/power/rk29_adc_battery.c
3 * battery detect driver for the rk2918
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>
39 static struct wake_lock batt_wake_lock;
42 #define DBG(x...) printk(x)
47 int rk29_battery_dbg_level = 0;
48 module_param_named(dbg_level, rk29_battery_dbg_level, int, 0644);
50 /*******************ÒÔϲÎÊý¿ÉÒÔÐÞ¸Ä******************************/
51 #define TIMER_MS_COUNTS 50 //¶¨Ê±Æ÷µÄ³¤¶Èms
52 //ÒÔϲÎÊýÐèÒª¸ù¾Ýʵ¼Ê²âÊÔµ÷Õû
53 #define SLOPE_SECOND_COUNTS 15 //ͳ¼ÆµçѹбÂʵÄʱ¼ä¼ä¸ôs
54 #define DISCHARGE_MIN_SECOND 45 //×î¿ì·Åµçµç1%ʱ¼ä
55 #define CHARGE_MIN_SECOND 45 //×î¿ì³äµçµç1%ʱ¼ä
56 #define CHARGE_MID_SECOND 90 //ÆÕͨ³äµçµç1%ʱ¼ä
57 #define CHARGE_MAX_SECOND 250 //×³äµçµç1%ʱ¼ä
58 #define CHARGE_FULL_DELAY_TIMES 10 //³äµçÂú¼ì²â·À¶¶Ê±¼ä
59 #define USBCHARGE_IDENTIFY_TIMES 5 //²åÈëUSB»ìÁ÷£¬pcʶ±ð¼ì²âʱ¼ä
61 #define NUM_VOLTAGE_SAMPLE ((SLOPE_SECOND_COUNTS * 1000) / TIMER_MS_COUNTS) //´æ´¢µÄ²ÉÑùµã¸öÊý
62 #define NUM_DISCHARGE_MIN_SAMPLE ((DISCHARGE_MIN_SECOND * 1000) / TIMER_MS_COUNTS) //´æ´¢µÄ²ÉÑùµã¸öÊý
63 #define NUM_CHARGE_MIN_SAMPLE ((CHARGE_MIN_SECOND * 1000) / TIMER_MS_COUNTS) //´æ´¢µÄ²ÉÑùµã¸öÊý
64 #define NUM_CHARGE_MID_SAMPLE ((CHARGE_MID_SECOND * 1000) / TIMER_MS_COUNTS) //´æ´¢µÄ²ÉÑùµã¸öÊý
65 #define NUM_CHARGE_MAX_SAMPLE ((CHARGE_MAX_SECOND * 1000) / TIMER_MS_COUNTS) //´æ´¢µÄ²ÉÑùµã¸öÊý
66 #define NUM_CHARGE_FULL_DELAY_TIMES ((CHARGE_FULL_DELAY_TIMES * 1000) / TIMER_MS_COUNTS) //³äµçÂú״̬³ÖÐøʱ¼ä³¤¶È
67 #define NUM_USBCHARGE_IDENTIFY_TIMES ((USBCHARGE_IDENTIFY_TIMES * 1000) / TIMER_MS_COUNTS) //³äµçÂú״̬³ÖÐøʱ¼ä³¤¶È
69 #define BAT_2V5_VALUE 2500
70 #define BATT_MAX_VOL_VALUE 8284 // 4180 //ÂúµçʱµÄµç³Øµçѹ FOR A7
71 #define BATT_ZERO_VOL_VALUE 6800 // 3500 //¹Ø»úʱµÄµç³Øµçѹ
72 #define BATT_NOMAL_VOL_VALUE 7600 // 3800
74 //¶¨ÒåADC²ÉÑù·Öѹµç×裬ÒÔʵ¼ÊֵΪ׼£¬µ¥Î»K
75 #define BAT_PULL_UP_R 300 ////200
77 #define BAT_PULL_DOWN_R 100// 200
78 #define BAT_ADC_TABLE_LEN 11
79 #define adc_to_voltage(adc_val) ((adc_val * BAT_2V5_VALUE * (BAT_PULL_UP_R + BAT_PULL_DOWN_R)) / (1024 * BAT_PULL_DOWN_R))
81 static int adc_raw_table_bat[BAT_ADC_TABLE_LEN] =
83 // 3490, 3597, 3628, 3641, 3660, 3697, 3747, 3809, 3879, 3945, 4165
84 6800,7242,7332,7404,7470,7520,7610,7744,7848,8016,8284
88 static int adc_raw_table_ac[BAT_ADC_TABLE_LEN] =
90 // 3600, 3760, 3800, 3827, 3845, 3885, 3950, 4007, 4078, 4140, 4200
91 7630, 7754, 7852, 7908, 7956, 8024, 8112, 8220, 8306, 8318, 8328
95 extern int dwc_vbus_status(void);
96 extern int get_msc_connect_flag(void);
98 struct rk29_adc_battery_data {
101 struct timer_list timer;
102 struct work_struct timer_work;
103 struct work_struct dcwakeup_work;
104 struct work_struct resume_work;
106 struct rk29_adc_battery_platform_data *pdata;
110 struct adc_client *client;
112 int adc_samples[NUM_VOLTAGE_SAMPLE+2];
122 static struct rk29_adc_battery_data *gBatteryData;
128 BATTERY_CAPACITY = 3,
129 BATTERY_AC_ONLINE = 4,
130 BATTERY_STATUS_CHANGED = 5,
131 AC_STATUS_CHANGED = 6,
132 BATTERY_INT_STATUS = 7,
133 BATTERY_INT_ENABLE = 8,
143 #define BATT_FILENAME "/data/bat_last_capacity.dat"
144 #include <linux/fs.h>
146 static void rk29_adc_battery_capacity_samples(struct rk29_adc_battery_data *bat);
147 static int rk29_adc_battery_voltage_to_capacity(struct rk29_adc_battery_data *bat, int BatVoltage);
148 static struct power_supply rk29_battery_supply;
150 static int rk29_adc_battery_load_capacity(void)
153 int* p = (int *)value;
154 long fd = sys_open(BATT_FILENAME,O_RDONLY,0);
158 printk("rk29_adc_battery_load_capacity: open file /data/bat_last_capacity.dat failed\n");
162 sys_read(fd,(char __user *)value,4);
169 static void rk29_adc_battery_put_capacity(int loadcapacity)
172 int* p = (int *)value;
173 long fd = sys_open(BATT_FILENAME,O_CREAT | O_RDWR,0);
177 printk("rk29_adc_battery_put_capacity: open file /data/bat_last_capacity.dat failed\n");
181 sys_write(fd, (const char __user *)value, 4);
186 static void rk29_adc_battery_charge_enable(struct rk29_adc_battery_data *bat)
188 struct rk29_adc_battery_platform_data *pdata = bat->pdata;
190 if (pdata->charge_set_pin != INVALID_GPIO)
192 gpio_direction_output(pdata->charge_set_pin, pdata->charge_set_level);
196 static void rk29_adc_battery_charge_disable(struct rk29_adc_battery_data *bat)
198 struct rk29_adc_battery_platform_data *pdata = bat->pdata;
200 if (pdata->charge_set_pin != INVALID_GPIO)
202 gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
206 extern int suspend_flag;
207 static int rk29_adc_battery_get_charge_level(struct rk29_adc_battery_data *bat)
210 struct rk29_adc_battery_platform_data *pdata = bat->pdata;
212 #if defined(CONFIG_BATTERY_RK29_AC_CHARGE)
213 if (pdata->dc_det_pin != INVALID_GPIO)
215 if (gpio_get_value (pdata->dc_det_pin) == pdata->dc_det_level)
222 #if defined(CONFIG_BATTERY_RK29_USB_CHARGE)
225 if (suspend_flag) return;
227 if (1 == dwc_vbus_status()) //¼ì²âµ½USB²åÈ룬µ«ÊÇÎÞ·¨Ê¶±ðÊÇ·ñÊdzäµçÆ÷
228 { //ͨ¹ýÑÓʱ¼ì²âPCʶ±ð±êÖ¾£¬Èç¹û³¬Ê±¼ì²â²»µ½£¬ËµÃ÷Êdzäµç
229 if (0 == get_msc_connect_flag())
230 { //²åÈë³äµçÆ÷ʱ¼ä´óÓÚÒ»¶¨Ê±¼äÖ®ºó£¬¿ªÊ¼½øÈë³äµç״̬
231 if (++gBatUsbChargeCnt >= NUM_USBCHARGE_IDENTIFY_TIMES)
233 gBatUsbChargeCnt = NUM_USBCHARGE_IDENTIFY_TIMES + 1;
236 } //·ñÔò£¬²»½øÈë³äµçģʽ
240 gBatUsbChargeCnt = 0;
241 if (2 == dwc_vbus_status())
252 int old_charge_level;
253 static int rk29_adc_battery_status_samples(struct rk29_adc_battery_data *bat)
256 struct rk29_adc_battery_platform_data *pdata = bat->pdata;
258 charge_level = rk29_adc_battery_get_charge_level(bat);
260 //¼ì²â³äµç״̬±ä»¯Çé¿ö
261 if (charge_level != old_charge_level)
263 old_charge_level = charge_level;
267 rk29_adc_battery_charge_enable(bat);
271 rk29_adc_battery_charge_disable(bat);
273 bat->bat_status_cnt = 0; //״̬±ä»¯¿ªÊ¼¼ÆÊý
277 if(charge_level == 0)
281 bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
286 if (pdata->charge_ok_pin == INVALID_GPIO)
288 //ûÓÐcharge_ok_pin£¬¼ì²âÈÝÁ¿
289 if (bat->bat_capacity == 100)
291 if (bat->bat_status != POWER_SUPPLY_STATUS_FULL)
293 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
299 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
305 if (gpio_get_value(pdata->charge_ok_pin) != pdata->charge_ok_level)
307 //ûÓмì²âµ½³äµçÂúµçƽ±êÖ¾
309 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
313 //¼ì²âµ½³äµçÂúµçƽ±êÖ¾
315 if (bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES)
317 bat->full_times = NUM_CHARGE_FULL_DELAY_TIMES + 1;
320 if ((bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) && (bat->bat_capacity >= 99))
322 if (bat->bat_status != POWER_SUPPLY_STATUS_FULL)
324 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
325 bat->bat_capacity = 100;
331 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
340 int AdcTestvalue = 0;
341 static int gFlagLoop = 0;
342 static int *pSamples;
343 static void rk29_adc_battery_voltage_samples(struct rk29_adc_battery_data *bat)
346 int i,*pStart = bat->adc_samples, num = 0;
348 value = bat->adc_val;
349 AdcTestvalue = value;
350 adc_async_read(bat->client);
352 *pSamples++ = adc_to_voltage(value);
354 bat->bat_status_cnt++;
355 if (bat->bat_status_cnt > NUM_VOLTAGE_SAMPLE) bat->bat_status_cnt = NUM_VOLTAGE_SAMPLE + 1;
357 num = pSamples - pStart;
358 if (num >= NUM_VOLTAGE_SAMPLE)
365 num = NUM_VOLTAGE_SAMPLE;
368 for (i = 0; i < num; i++)
370 value += bat->adc_samples[i];
372 bat->bat_voltage = value / num;
375 if(bat->bat_voltage >= BATT_MAX_VOL_VALUE + 10)
376 bat->bat_voltage = BATT_MAX_VOL_VALUE + 10;
377 else if(bat->bat_voltage <= BATT_ZERO_VOL_VALUE - 10)
378 bat->bat_voltage = BATT_ZERO_VOL_VALUE - 10;
382 static int rk29_adc_battery_voltage_to_capacity(struct rk29_adc_battery_data *bat, int BatVoltage)
386 int *p = adc_raw_table_bat;
388 if (rk29_adc_battery_get_charge_level(bat))
390 p = adc_raw_table_ac;
393 if(BatVoltage >= p[BAT_ADC_TABLE_LEN - 1])
398 else if(BatVoltage <= p[0])
406 for(i = 0; i < BAT_ADC_TABLE_LEN - 1; i++)
409 if((p[i] <= BatVoltage) && (BatVoltage < p[i+1]))
411 capacity = i * 10 + ((BatVoltage - p[i]) * 10) / (p[i+1] - p[i]);
419 static int gBatCapacityDisChargeCnt = 0;
420 static int gBatCapacityChargeCnt = 0;
421 //static int rk29_adc_battery_get_capacity_ext(int BatVoltage)
422 static void rk29_adc_battery_capacity_samples(struct rk29_adc_battery_data *bat)
425 struct rk29_adc_battery_platform_data *pdata = bat->pdata;
427 //³ä·Åµç״̬±ä»¯ºó£¬BufferÌîÂú֮ǰ£¬²»¸üÐÂ
428 if (bat->bat_status_cnt < NUM_VOLTAGE_SAMPLE)
430 gBatCapacityDisChargeCnt = 0;
431 gBatCapacityChargeCnt = 0;
435 capacity = rk29_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
437 if (rk29_adc_battery_get_charge_level(bat))
439 if (capacity > bat->bat_capacity)
441 //ʵ¼Ê²ÉÑùµ½µÄµçѹ±ÈÏÔʾµÄµçѹ´ó£¬Öð¼¶ÉÏÉý
442 if (++gBatCapacityDisChargeCnt >= NUM_CHARGE_MIN_SAMPLE)
444 gBatCapacityDisChargeCnt = 0;
445 if (bat->bat_capacity < 99)
451 gBatCapacityChargeCnt = 0;
455 gBatCapacityDisChargeCnt = 0;
456 gBatCapacityChargeCnt++;
458 if (pdata->charge_ok_pin != INVALID_GPIO)
460 if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level)
462 //¼ì²âµ½µç³Ø³äÂú±êÖ¾£¬Í¬Ê±³¤Ê±¼äÄÚ³äµçµçѹÎޱ仯£¬¿ªÊ¼Æô¶¯¼Æʱ³äµç£¬¿ìËÙÉÏÉýÈÝÁ¿
463 if (gBatCapacityChargeCnt >= NUM_CHARGE_MIN_SAMPLE)
465 gBatCapacityChargeCnt = 0;
466 if (bat->bat_capacity < 99)
475 if (capacity > capacitytmp)
477 //¹ý³ÌÖÐÈç¹ûµçѹÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±Èʵ¼Ê³äµç¿ì
478 gBatCapacityChargeCnt = 0;
480 if (/*(bat->bat_capacity >= 80) && */(gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE))
482 gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
483 if (bat->bat_capacity < 99)
493 //ûÓгäµçÂú¼ì²â½Å£¬³¤Ê±¼äÄÚµçѹÎޱ仯£¬¶¨Ê±Æ÷Ä£Äâ³äµç
494 if (capacity > capacitytmp)
496 //¹ý³ÌÖÐÈç¹ûµçѹÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±Èʵ¼Ê³äµç¿ì
497 gBatCapacityChargeCnt = 0;
499 if (gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)
501 gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
502 if (bat->bat_capacity < 100)
513 //·Åµçʱ,Ö»ÔÊÐíµçѹϽµ
514 if (capacity < bat->bat_capacity)
516 if (++gBatCapacityDisChargeCnt >= NUM_DISCHARGE_MIN_SAMPLE)
518 gBatCapacityDisChargeCnt = 0;
519 if (bat->bat_capacity > 0)
521 bat->bat_capacity-- ;
528 gBatCapacityDisChargeCnt = 0;
531 gBatCapacityChargeCnt = 0;
533 capacitytmp = capacity;
536 static int poweron_check = 0;
537 static void rk29_adc_battery_poweron_capacity_check(void)
539 int new_capacity, old_capacity;
541 new_capacity = gBatteryData->bat_capacity;
542 old_capacity = rk29_adc_battery_load_capacity();
543 if ((old_capacity <= 0) || (old_capacity >= 100))
545 old_capacity = new_capacity;
548 if (gBatteryData->bat_status == POWER_SUPPLY_STATUS_FULL)
550 if (new_capacity > 80)
552 gBatteryData->bat_capacity = 100;
555 else if (gBatteryData->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING)
559 //1£©³¤Ê±¼ä¹Ø»ú·ÅÖú󣬿ª»úºó¶ÁÈ¡µÄÈÝÁ¿Ô¶Ô¶´óÓÚʵ¼ÊÈÝÁ¿Ôõô°ì£¿
560 //2£©Èç¹û²»ÕâÑù×ö£¬¶Ìʱ¼ä¹Ø»úÔÙ¿ª»ú£¬Ç°ºóÈÝÁ¿²»Ò»ÖÂÓÖ¸ÃÔõô°ì£¿
561 //3£©Ò»ÏÂÄÇÖÖ·½Ê½ºÏÊÊ£¿
562 //gBatteryData->bat_capacity = new_capacity;
563 gBatteryData->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
567 gBatteryData->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity;
571 printk("capacity = %d, new_capacity = %d, old_capacity = %d\n",gBatteryData->bat_capacity, new_capacity, old_capacity);
573 gBatteryData->bat_change = 1;
576 unsigned long AdcTestCnt = 0;
577 static void rk29_adc_battery_timer_work(struct work_struct *work)
579 rk29_adc_battery_status_samples(gBatteryData);
584 rk29_adc_battery_poweron_capacity_check();
587 rk29_adc_battery_voltage_samples(gBatteryData);
588 rk29_adc_battery_capacity_samples(gBatteryData);
590 /*update battery parameter after adc and capacity has been changed*/
591 if(gBatteryData->bat_change)
593 gBatteryData->bat_change = 0;
594 rk29_adc_battery_put_capacity(gBatteryData->bat_capacity);
595 power_supply_changed(&rk29_battery_supply);
598 if (rk29_battery_dbg_level)
600 if (++AdcTestCnt >= 20)
603 printk("Status = %d, RealAdcVal = %d, RealVol = %d,gBatVol = %d, gBatCap = %d, RealCapacity = %d, dischargecnt = %d, chargecnt = %d\n",
604 gBatteryData->bat_status, AdcTestvalue, adc_to_voltage(AdcTestvalue),
605 gBatteryData->bat_voltage, gBatteryData->bat_capacity, capacitytmp, gBatCapacityDisChargeCnt, gBatCapacityChargeCnt);
613 static void rk29_adc_battery_scan_timer(unsigned long data)
615 gBatteryData->timer.expires = jiffies + msecs_to_jiffies(TIMER_MS_COUNTS);
616 add_timer(&gBatteryData->timer);
618 schedule_work(&gBatteryData->timer_work);
621 #if defined(CONFIG_BATTERY_RK29_USB_CHARGE)
622 static int rk29_adc_battery_get_usb_property(struct power_supply *psy,
623 enum power_supply_property psp,
624 union power_supply_propval *val)
626 charger_type_t charger;
627 charger = CHARGER_USB;
630 case POWER_SUPPLY_PROP_ONLINE:
631 if (psy->type == POWER_SUPPLY_TYPE_USB)
632 val->intval = get_msc_connect_flag();
633 printk("%s:%d\n",__FUNCTION__,val->intval);
644 static enum power_supply_property rk29_adc_battery_usb_props[] = {
646 POWER_SUPPLY_PROP_ONLINE,
649 static struct power_supply rk29_usb_supply =
652 .type = POWER_SUPPLY_TYPE_USB,
654 .get_property = rk29_adc_battery_get_usb_property,
656 .properties = rk29_adc_battery_usb_props,
657 .num_properties = ARRAY_SIZE(rk29_adc_battery_usb_props),
661 #if defined(CONFIG_BATTERY_RK29_AC_CHARGE)
662 static irqreturn_t rk29_adc_battery_dc_wakeup(int irq, void *dev_id)
664 schedule_work(&gBatteryData->dcwakeup_work);
669 static int rk29_adc_battery_get_ac_property(struct power_supply *psy,
670 enum power_supply_property psp,
671 union power_supply_propval *val)
674 charger_type_t charger;
675 charger = CHARGER_USB;
677 case POWER_SUPPLY_PROP_ONLINE:
678 if (psy->type == POWER_SUPPLY_TYPE_MAINS)
680 printk("POWER_SUPPLY_TYPE_MAINS\n");
681 if (rk29_adc_battery_get_charge_level(gBatteryData))
690 DBG("%s:%d\n",__FUNCTION__,val->intval);
701 static enum power_supply_property rk29_adc_battery_ac_props[] =
703 POWER_SUPPLY_PROP_ONLINE,
706 static struct power_supply rk29_ac_supply =
709 .type = POWER_SUPPLY_TYPE_MAINS,
711 .get_property = rk29_adc_battery_get_ac_property,
713 .properties = rk29_adc_battery_ac_props,
714 .num_properties = ARRAY_SIZE(rk29_adc_battery_ac_props),
717 static void rk29_adc_battery_dcdet_delaywork(struct work_struct *work)
720 struct rk29_adc_battery_platform_data *pdata = gBatteryData->pdata;
721 int irq = gpio_to_irq(pdata->dc_det_pin);
722 int irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
724 rk28_send_wakeup_key();
727 ret = request_irq(irq, rk29_adc_battery_dc_wakeup, irq_flag, "rk29_adc_battery", NULL);
732 power_supply_changed(&rk29_ac_supply);
734 gBatteryData->bat_status_cnt = 0; //״̬±ä»¯¿ªÊ¼¼ÆÊý
736 wake_lock_timeout(&batt_wake_lock, 30 * HZ);
743 static int rk29_adc_battery_get_status(struct rk29_adc_battery_data *bat)
745 return (bat->bat_status);
748 static int rk29_adc_battery_get_health(struct rk29_adc_battery_data *bat)
750 return POWER_SUPPLY_HEALTH_GOOD;
753 static int rk29_adc_battery_get_present(struct rk29_adc_battery_data *bat)
755 return (bat->bat_voltage < BATT_MAX_VOL_VALUE) ? 0 : 1;
758 static int rk29_adc_battery_get_voltage(struct rk29_adc_battery_data *bat)
760 return (bat->bat_voltage );
763 static int rk29_adc_battery_get_capacity(struct rk29_adc_battery_data *bat)
765 return (bat->bat_capacity);
768 static int rk29_adc_battery_get_property(struct power_supply *psy,
769 enum power_supply_property psp,
770 union power_supply_propval *val)
775 case POWER_SUPPLY_PROP_STATUS:
776 val->intval = rk29_adc_battery_get_status(gBatteryData);
777 DBG("gBatStatus=%d\n",val->intval);
779 case POWER_SUPPLY_PROP_HEALTH:
780 val->intval = rk29_adc_battery_get_health(gBatteryData);
781 DBG("gBatHealth=%d\n",val->intval);
783 case POWER_SUPPLY_PROP_PRESENT:
784 val->intval = rk29_adc_battery_get_present(gBatteryData);
785 DBG("gBatPresent=%d\n",val->intval);
787 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
788 val ->intval = rk29_adc_battery_get_voltage(gBatteryData);
789 DBG("gBatVoltage=%d\n",val->intval);
791 // case POWER_SUPPLY_PROP_CURRENT_NOW:
792 // val->intval = 1100;
794 case POWER_SUPPLY_PROP_CAPACITY:
795 val->intval = rk29_adc_battery_get_capacity(gBatteryData);
796 DBG("gBatCapacity=%d%%\n",val->intval);
798 case POWER_SUPPLY_PROP_TECHNOLOGY:
799 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
801 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
802 val->intval = BATT_MAX_VOL_VALUE;
804 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
805 val->intval = BATT_ZERO_VOL_VALUE;
815 static enum power_supply_property rk29_adc_battery_props[] = {
817 POWER_SUPPLY_PROP_STATUS,
818 POWER_SUPPLY_PROP_HEALTH,
819 POWER_SUPPLY_PROP_PRESENT,
820 POWER_SUPPLY_PROP_VOLTAGE_NOW,
821 // POWER_SUPPLY_PROP_CURRENT_NOW,
822 POWER_SUPPLY_PROP_TECHNOLOGY,
823 POWER_SUPPLY_PROP_CAPACITY,
824 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
825 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
828 static struct power_supply rk29_battery_supply =
831 .type = POWER_SUPPLY_TYPE_BATTERY,
833 .get_property = rk29_adc_battery_get_property,
835 .properties = rk29_adc_battery_props,
836 .num_properties = ARRAY_SIZE(rk29_adc_battery_props),
841 int suspend_capacity = 0;
842 static void rk29_adc_battery_resume_check(struct work_struct *work)
846 int new_capacity, old_capacity;
847 struct rk29_adc_battery_data *bat = gBatteryData;
849 old_charge_level = -1;
850 pSamples = bat->adc_samples;
852 adc_sync_read(bat->client); //start adc sample
853 level = oldlevel = rk29_adc_battery_status_samples(bat);//init charge status
855 for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++) //0.3 s
858 rk29_adc_battery_voltage_samples(bat); //get voltage
859 level = rk29_adc_battery_status_samples(bat); //check charge status
860 if (oldlevel != level)
862 oldlevel = level; //if charge status changed, reset sample
866 new_capacity = rk29_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
867 old_capacity = suspend_capacity;
869 if (bat->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING)
872 bat->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
876 bat->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity;
879 printk("rk29_adc_battery_resume: status = %d, voltage = %d, capacity = %d, new_capacity = %d, old_capacity = %d\n",
880 bat->bat_status, bat->bat_voltage, bat->bat_capacity, new_capacity, old_capacity);
883 schedule_work(&bat->timer_work);
884 bat->timer.expires = jiffies + 10;
885 add_timer(&bat->timer);
888 static int rk29_adc_battery_suspend(struct platform_device *dev, pm_message_t state)
890 /* flush all pending status updates */
891 suspend_capacity = gBatteryData->bat_capacity;
892 del_timer(&gBatteryData->timer);
893 //flush_scheduled_work();
897 static int rk29_adc_battery_resume(struct platform_device *dev)
899 /* things may have changed while we were away */
900 schedule_work(&gBatteryData->resume_work);
904 #define rk29_adc_battery_suspend NULL
905 #define rk29_adc_battery_resume NULL
909 static int rk29_adc_battery_io_init(struct rk29_adc_battery_data *data, struct rk29_adc_battery_platform_data *pdata)
921 if (pdata->charge_set_pin != INVALID_GPIO)
923 ret = gpio_request(pdata->charge_set_pin, NULL);
925 printk("failed to request dc_det gpio\n");
928 gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
931 //dc charge detect pin
932 if (pdata->dc_det_pin != INVALID_GPIO)
934 ret = gpio_request(pdata->dc_det_pin, NULL);
936 printk("failed to request dc_det gpio\n");
940 gpio_pull_updown(pdata->dc_det_pin, GPIOPullUp);//important
941 ret = gpio_direction_input(pdata->dc_det_pin);
943 printk("failed to set gpio dc_det input\n");
949 if (pdata->charge_ok_pin != INVALID_GPIO)
951 ret = gpio_request(pdata->charge_ok_pin, NULL);
953 printk("failed to request charge_ok gpio\n");
957 gpio_pull_updown(pdata->charge_ok_pin, GPIOPullUp);//important
958 ret = gpio_direction_input(pdata->charge_ok_pin);
960 printk("failed to set gpio charge_ok input\n");
970 #define POWER_ON_PIN RK29_PIN4_PA4
971 static void rk29_adc_battery_lowpower_check(struct rk29_adc_battery_data *bat)
976 struct rk29_adc_battery_platform_data *pdata = bat->pdata;
978 printk("%s--%d:\n",__FUNCTION__,__LINE__);
980 old_charge_level = -1;
981 pSamples = bat->adc_samples;
983 adc_sync_read(bat->client); //start adc sample
984 level = oldlevel = rk29_adc_battery_status_samples(bat);//init charge status
987 for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++) //0.3 s
990 rk29_adc_battery_voltage_samples(bat); //get voltage
991 //level = rk29_adc_battery_status_samples(bat); //check charge status
992 level = rk29_adc_battery_get_charge_level(bat);
993 if (oldlevel != level)
995 oldlevel = level; //if charge status changed, reset sample
1000 bat->bat_capacity = rk29_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
1001 bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1002 if (rk29_adc_battery_get_charge_level(bat))
1004 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
1005 if (pdata->charge_ok_pin != INVALID_GPIO)
1007 if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level)
1009 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
1010 bat->bat_capacity = 100;
1016 rk29_adc_battery_poweron_capacity_check();
1022 /*******************************************
1023 //¿ª»ú²ÉÑùµ½µÄµçѹºÍÉϴιػú±£´æµçѹÏà²î½Ï´ó£¬Ôõô´¦Àí£¿
1024 if (bat->bat_capacity > old_capacity)
1026 if ((bat->bat_capacity - old_capacity) > 20)
1031 else if (bat->bat_capacity < old_capacity)
1033 if ((old_capacity > bat->bat_capacity) > 20)
1038 *********************************************/
1039 if (bat->bat_capacity == 0) bat->bat_capacity = 1;
1041 if (bat->bat_voltage <= BATT_ZERO_VOL_VALUE + 50)
1043 printk("low battery: powerdown\n");
1044 gpio_direction_output(POWER_ON_PIN, GPIO_LOW);
1048 if(gpio_get_value(POWER_ON_PIN) == GPIO_HIGH)
1050 gpio_set_value(POWER_ON_PIN,GPIO_LOW);
1053 if (++tmp > 50) break;
1056 gpio_direction_output(POWER_ON_PIN, GPIO_HIGH);
1059 static void rk29_adc_battery_callback(struct adc_client *client, void *param, int result)
1061 gBatteryData->adc_val = result;
1065 static int rk29_adc_battery_probe(struct platform_device *pdev)
1070 struct adc_client *client;
1071 struct rk29_adc_battery_data *data;
1072 struct rk29_adc_battery_platform_data *pdata = pdev->dev.platform_data;
1074 printk("%s--%d:\n",__FUNCTION__,__LINE__);
1076 data = kzalloc(sizeof(*data), GFP_KERNEL);
1079 goto err_data_alloc_failed;
1081 gBatteryData = data;
1082 platform_set_drvdata(pdev, data);
1084 ret = rk29_adc_battery_io_init(data, pdata);
1090 //register adc for battery sample
1091 memset(data->adc_samples, 0, sizeof(int)*(NUM_VOLTAGE_SAMPLE + 2));
1092 client = adc_register(0, rk29_adc_battery_callback, NULL);
1094 goto err_adc_register_failed;
1097 data->client = client;
1098 data->adc_val = adc_sync_read(client);
1100 ret = power_supply_register(&pdev->dev, &rk29_battery_supply);
1103 printk(KERN_INFO "fail to battery power_supply_register\n");
1104 goto err_battery_failed;
1108 #if defined(CONFIG_BATTERY_RK29_USB_CHARGE)
1109 ret = power_supply_register(&pdev->dev, &rk29_usb_supply);
1112 printk(KERN_INFO "fail to usb power_supply_register\n");
1113 goto err_usb_failed;
1117 INIT_WORK(&data->timer_work, rk29_adc_battery_timer_work);
1118 INIT_WORK(&data->resume_work, rk29_adc_battery_resume_check);
1120 //init a timer for adc sample
1121 //init a delay work for adc timer work
1122 setup_timer(&data->timer, rk29_adc_battery_scan_timer, (unsigned long)data);
1123 data->timer.expires = jiffies + 2000;
1124 add_timer(&data->timer);
1127 wake_lock_init(&batt_wake_lock, WAKE_LOCK_SUSPEND, "batt_lock");
1129 #if defined(CONFIG_BATTERY_RK29_AC_CHARGE)
1131 ret = power_supply_register(&pdev->dev, &rk29_ac_supply);
1133 printk(KERN_INFO "fail to ac power_supply_register\n");
1136 //init dc dectet irq & delay work
1137 if (pdata->dc_det_pin != INVALID_GPIO)
1139 INIT_WORK(&data->dcwakeup_work, rk29_adc_battery_dcdet_delaywork);
1140 irq = gpio_to_irq(pdata->dc_det_pin);
1142 irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1143 ret = request_irq(irq, rk29_adc_battery_dc_wakeup, irq_flag, "rk29_adc_battery", NULL);
1145 printk("failed to request dc det irq\n");
1146 goto err_dcirq_failed;
1148 enable_irq_wake(irq);
1153 //Power on Battery detect
1154 rk29_adc_battery_lowpower_check(data);
1157 printk(KERN_INFO "rk29_adc_battery: driver initialized\n");
1161 #if defined(CONFIG_BATTERY_RK29_USB_CHARGE)
1163 power_supply_unregister(&rk29_usb_supply);
1167 #if defined(CONFIG_BATTERY_RK29_AC_CHARGE)
1168 power_supply_unregister(&rk29_ac_supply);
1172 power_supply_unregister(&rk29_battery_supply);
1175 free_irq(gpio_to_irq(pdata->dc_det_pin), data);
1177 err_adc_register_failed:
1179 err_data_alloc_failed:
1182 printk("rk29_adc_battery: error!\n");
1187 static int rk29_adc_battery_remove(struct platform_device *pdev)
1189 struct rk29_adc_battery_data *data = platform_get_drvdata(pdev);
1190 struct rk29_adc_battery_platform_data *pdata = pdev->dev.platform_data;
1192 #if defined(CONFIG_BATTERY_RK29_USB_CHARGE)
1193 power_supply_unregister(&rk29_usb_supply);
1195 #if defined(CONFIG_BATTERY_RK29_AC_CHARGE)
1196 power_supply_unregister(&rk29_ac_supply);
1198 power_supply_unregister(&rk29_battery_supply);
1200 free_irq(gpio_to_irq(pdata->dc_det_pin), data);
1207 static struct platform_driver rk29_adc_battery_driver = {
1208 .probe = rk29_adc_battery_probe,
1209 .remove = rk29_adc_battery_remove,
1210 .suspend = rk29_adc_battery_suspend,
1211 .resume = rk29_adc_battery_resume,
1213 .name = "rk2918-battery",
1214 .owner = THIS_MODULE,
1218 static int __init rk29_adc_battery_init(void)
1220 return platform_driver_register(&rk29_adc_battery_driver);
1223 static void __exit rk29_adc_battery_exit(void)
1225 platform_driver_unregister(&rk29_adc_battery_driver);
1228 subsys_initcall(rk29_adc_battery_init);
1229 module_exit(rk29_adc_battery_exit);
1231 MODULE_DESCRIPTION("Battery detect driver for the rk2918");
1232 MODULE_AUTHOR("luowei lw@rock-chips.com");
1233 MODULE_LICENSE("GPL");