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 <linux/adc.h>
29 #include <linux/delay.h>
30 #include <linux/ktime.h>
31 #include <linux/slab.h>
32 #include <linux/syscalls.h>
34 #include <linux/wakelock.h>
36 #include <linux/string.h>
37 #include <linux/init.h>
38 #include <linux/suspend.h>
39 #include <linux/gpio.h>
40 #include <linux/of_gpio.h>
41 #include <linux/power/rockchip-adc-battery.h>
42 #include <linux/iio/iio.h>
43 #include <linux/iio/machine.h>
44 #include <linux/iio/driver.h>
45 #include <linux/iio/consumer.h>
47 #ifdef CONFIG_EARLYSUSPEND
48 /* kernel/power/earlysuspend.c */
49 extern suspend_state_t get_suspend_state(void);
52 static int rk30_battery_dbg_level;
53 module_param_named(dbg_level, rk30_battery_dbg_level, int, 0644);
54 #define DBG( args...) \
56 if (rk30_battery_dbg_level) {\
61 #define TIMER_MS_COUNTS 1000
62 #define SLOPE_SECOND_COUNTS 15
63 #define DISCHARGE_MIN_SECOND 30
64 #define CHARGE_MIN_SECOND 30
65 #define CHARGE_MID_SECOND 90
66 #define CHARGE_MAX_SECOND 250
67 #define CHARGE_FULL_DELAY_TIMES 10
68 #define USBCHARGE_IDENTIFY_TIMES 2
70 #define NUM_VOLTAGE_SAMPLE ((SLOPE_SECOND_COUNTS * 1000) / TIMER_MS_COUNTS)
71 #define NUM_DISCHARGE_MIN_SAMPLE ((DISCHARGE_MIN_SECOND * 1000) / TIMER_MS_COUNTS)
72 #define NUM_CHARGE_MIN_SAMPLE ((CHARGE_MIN_SECOND * 1000) / TIMER_MS_COUNTS)
73 #define NUM_CHARGE_MID_SAMPLE ((CHARGE_MID_SECOND * 1000) / TIMER_MS_COUNTS)
74 #define NUM_CHARGE_MAX_SAMPLE ((CHARGE_MAX_SECOND * 1000) / TIMER_MS_COUNTS)
75 #define NUM_CHARGE_FULL_DELAY_TIMES ((CHARGE_FULL_DELAY_TIMES * 1000) / TIMER_MS_COUNTS)
76 #define NUM_USBCHARGE_IDENTIFY_TIMES ((USBCHARGE_IDENTIFY_TIMES * 1000) / TIMER_MS_COUNTS)
78 #define CHARGE_IS_OK 1
79 #define INVALID_CHARGE_CHECK -1
81 #if defined(CONFIG_ARCH_RK3066B)
82 #define BAT_DEFINE_VALUE 1800
83 #elif defined(CONFIG_ARCH_RK2928)
84 #define BAT_DEFINE_VALUE 3300
86 #define BAT_DEFINE_VALUE 3300 /*2500*/
89 #define RK30_GPIO_LOW 0
90 #define RK30_GPIO_HIGH 1
94 //#define BATT_FILENAME "/data/bat_last_capacity.dat"
100 int battery_dbg_level = 0;
101 int battery_test_flag = 0;
102 int gVoltageCnt = 3400;
103 int gDoubleVoltageCnt = 6800;
104 unsigned long gSecondsCnt = 0;
105 char gDischargeFlag[4] = {"on "};
106 static int g_old_cap = -1;
107 static int g_uboot_incre = 0;
110 #define BATT_MAX_VOL_VALUE 4250/*Full charge volatge*/
111 #define BATT_ZERO_VOL_VALUE 3500/*power down voltage*/
112 #define BATT_NOMAL_VOL_VALUE 3800
114 static int batt_table[2*BATT_NUM+6] =
116 0x4B434F52,0x7461625F,0x79726574,0,100,100,
117 3496, 3548, 3599, 3626, 3655, 3697, 3751, 3812, 3877, 3949, 4030, //discharge
118 3540, 3785, 3842, 3861, 3915, 3980, 4041, 4135, 4169, 4175, 4185 //charge
120 #define adc_to_voltage(adc_val) ((adc_val * BAT_DEFINE_VALUE * (batt_table[4] +batt_table[5])) / (1024 *batt_table[5]))
122 #define BATT_MAX_VOL_VALUE 8284 //Full charge voltage
123 #define BATT_ZERO_VOL_VALUE 6900 // power down voltage
124 #define BATT_NOMAL_VOL_VALUE 7600
127 static int batt_table[2*BATT_NUM+6] =
129 0x4B434F52,0x7461625F,0x79726574,1,300,100,
130 6800, 7242, 7332, 7404, 7470, 7520, 7610, 7744, 7848, 8016, 8284,//discharge
131 7630, 7754, 7852, 7908, 7956, 8024, 8112, 8220, 8306, 8318, 8328//charge
133 #define adc_to_voltage(adc_val) ((adc_val * BAT_DEFINE_VALUE * (batt_table[4] +batt_table[5])) / (1024 *batt_table[5]))
140 /********************************************************************************/
147 BATTERY_CAPACITY = 3,
148 BATTERY_AC_ONLINE = 4,
149 BATTERY_STATUS_CHANGED = 5,
150 AC_STATUS_CHANGED = 6,
151 BATTERY_INT_STATUS = 7,
152 BATTERY_INT_ENABLE = 8,
163 struct rk30_adc_battery_data {
166 //struct timer_list timer;
167 struct workqueue_struct *wq;
168 struct delayed_work delay_work;
169 struct delayed_work check_work;
170 struct work_struct dcwakeup_work;
171 struct work_struct lowerpower_work;
174 struct rk30_adc_battery_platform_data *pdata;
176 struct adc_client *client;
178 int adc_samples[NUM_VOLTAGE_SAMPLE+2];
188 int old_charge_level;
190 int gBatCapacityDisChargeCnt;
191 int gBatCapacityChargeCnt;
192 int gBatCapacityacChargeCnt;
193 int gBatCapacityusbChargeCnt ;
194 int gBatCapacityusbdisChargeCnt;
196 int suspend_capacity;
197 int gBatUsbChargeCnt;
200 struct power_supply bat;
201 struct power_supply usb;
202 struct power_supply ac;
203 struct power_supply bk_bat;
211 int charge_source_now;
212 int charge_soure_old;
213 int charge_start_capacity;
214 int charge_start_voltage;
215 int start_voltage_status;
216 int charge_up_proprotion;
217 int charge_down_proportion;
218 int voltage_to_local;
219 unsigned long suspend_time;
220 unsigned long resume_time;
224 int charge_full_flag;
226 struct notifier_block battery_nb;
228 int lower_power_flag;
232 static struct rk30_adc_battery_data *gBatteryData;
233 static struct wake_lock batt_wake_lock;
234 static struct wake_lock batt_wake_lock_detect_lowpower;
235 static struct wake_lock charge_display_lock;
236 int system_lowerpower = 0;
237 extern void kernel_power_off(void);
238 extern int dwc_vbus_status(void);
239 extern int get_gadget_connect_flag(void);
240 extern int dwc_otg_check_dpdm(void);
241 static int is_charge_ok(struct rk30_adc_battery_data *bat);
242 static void rk30_adc_battery_voltage_samples(struct rk30_adc_battery_data *bat);
243 extern void rk_send_wakeup_key(void);
244 static bool batt_gpio_is_valid(int number)
246 return number > 0 && number < 256;
249 //#define BAT_ADC_TABLE_LEN 11
250 static ssize_t bat_param_read(struct device *dev,struct device_attribute *attr, char *buf)
253 for(i=0;i<BATT_NUM;i++)
254 printk("i=%d batt_table=%d\n",i+6,batt_table[i+6]);
256 for(i=0;i<BATT_NUM;i++)
257 printk("i=%d batt_table=%d\n",i+17,batt_table[i+17]);
260 DEVICE_ATTR(batparam, 0444, bat_param_read, NULL);
263 static ssize_t rkbatt_show_debug_attrs(struct device *dev,
264 struct device_attribute *attr, char *buf)
266 return sprintf(buf, "%d\n", battery_dbg_level);
269 static ssize_t rkbatt_restore_debug_attrs(struct device *dev,
270 struct device_attribute *attr, const char *buf, size_t size)
274 sscanf(buf, "%d", &liTmp);
276 if(liTmp != 0 && liTmp != 1)
278 dev_err(dev, "rk29adc_restore_debug_attrs err\n");
282 battery_dbg_level = liTmp;
287 static ssize_t rkbatt_show_state_attrs(struct device *dev,
288 struct device_attribute *attr, char *buf)
290 // struct rk30_adc_battery_platform_data *pdata = gBatteryData->pdata;
291 int charge_ok_value =0 ;
292 charge_ok_value = is_charge_ok(gBatteryData) ;
295 "gBatVol=%d,gBatCap=%d,charge_ok=%d,%s\n",
296 gBatteryData->bat_voltage,gBatteryData->bat_capacity,
297 charge_ok_value,gDischargeFlag);
300 static ssize_t rkbatt_restore_state_attrs(struct device *dev,
301 struct device_attribute *attr, const char *buf, size_t size)
306 static ssize_t rkbatt_show_value_attrs(struct device *dev,
307 struct device_attribute *attr, char *buf)
309 return sprintf(buf, "pull_up_res =%d,\npull_down_res=%d\n", batt_table[4],batt_table[5]);
312 static ssize_t rkbatt_restore_value_attrs(struct device *dev,
313 struct device_attribute *attr, const char *buf, size_t size)
318 sscanf(buf, "%d,%d", &liUp,&liDown);
320 if(liUp != 0 && liDown != 0)
322 batt_table[4] = liUp;
323 batt_table[5] = liDown;
328 static ssize_t rkbatt_show_flag_attrs(struct device *dev,
329 struct device_attribute *attr, char *buf)
331 return sprintf(buf, "rk29_battery_test_flag=%d\n", battery_test_flag);
333 static ssize_t rkbatt_restore_flag_attrs(struct device *dev,
334 struct device_attribute *attr, const char *buf, size_t size)
338 sscanf(buf, "%d", &liFlag);
342 battery_test_flag = liFlag;
347 static int __init adc_bootloader_setup(char *str)
351 printk("adc.incre is %s\n", str);
352 sscanf(str, "%d", &g_uboot_incre);
356 early_param("adc.incre", adc_bootloader_setup);
358 static ssize_t rkbatt_show_oldcap_attrs(struct device *dev, struct device_attribute *attr, char *buf)
360 return sprintf(buf, "%d\n", g_old_cap);
363 static ssize_t rkbatt_restore_oldcap_attrs(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
367 sscanf(buf, "%d", &old_cap);
369 if(old_cap >= 0 && old_cap <= 100)
375 dev_err(dev, "rk29adc_restore_oldcap_attrs err\n");
381 static struct device_attribute rkbatt_attrs[] = {
382 __ATTR(state, 0664, rkbatt_show_state_attrs, rkbatt_restore_state_attrs),
383 __ATTR(debug, 0664, rkbatt_show_debug_attrs, rkbatt_restore_debug_attrs),
384 __ATTR(value, 0555, rkbatt_show_value_attrs, rkbatt_restore_value_attrs),
385 __ATTR(flag, 0555, rkbatt_show_flag_attrs, rkbatt_restore_flag_attrs),
386 __ATTR(oldcap, 0664, rkbatt_show_oldcap_attrs, rkbatt_restore_oldcap_attrs),
389 static int rk_adc_battery_iio_read(struct rk30_adc_battery_platform_data *data)
391 struct iio_channel *channel = data->chan;
394 ret = iio_read_channel_raw(channel, &val);
396 pr_err("read channel() error: %d\n", ret);
403 static int create_sysfs_interfaces(struct device *dev)
406 for (liTmep = 0; liTmep < ARRAY_SIZE(rkbatt_attrs); liTmep++) {
408 if (device_create_file(dev, rkbatt_attrs + liTmep)){
416 for ( ; liTmep >= 0; liTmep--){
417 device_remove_file(dev, rkbatt_attrs + liTmep);
420 dev_err(dev, "%s:Unable to create sysfs interface\n", __func__);
427 static int rk30_adc_battery_load_capacity(void)
430 int* p = (int *)value;
431 long fd = sys_open(BATT_FILENAME,O_RDONLY,0);
434 DBG("rk30_adc_battery_load_capacity: open file /data/bat_last_capacity.dat failed\n");
438 sys_read(fd,(char __user *)value,4);
444 static void rk30_adc_battery_put_capacity(int loadcapacity)
447 int* p = (int *)value;
448 long fd = sys_open(BATT_FILENAME,O_CREAT | O_RDWR,0);
451 DBG("rk30_adc_battery_put_capacity: open file /data/bat_last_capacity.dat failed\n");
456 sys_write(fd, (const char __user *)value, 4);
460 static BLOCKING_NOTIFIER_HEAD(adc_battery_chain_head);
462 int register_adc_battery_notifier(struct notifier_block *nb)
464 return blocking_notifier_chain_register(&adc_battery_chain_head, nb);
466 EXPORT_SYMBOL_GPL(register_adc_battery_notifier);
468 int unregister_adc_battery_notifier(struct notifier_block *nb)
470 return blocking_notifier_chain_unregister(&adc_battery_chain_head, nb);
472 EXPORT_SYMBOL_GPL(unregister_adc_battery_notifier);
474 int adc_battery_notifier_call_chain(unsigned long val)
476 return (blocking_notifier_call_chain(&adc_battery_chain_head, val, NULL)
477 == NOTIFY_BAD) ? -EINVAL : 0;
479 EXPORT_SYMBOL_GPL(adc_battery_notifier_call_chain);
481 static void rk_start_charge(struct rk30_adc_battery_data *bat)
483 struct rk30_adc_battery_platform_data *pdata = bat->pdata;
484 if (batt_gpio_is_valid(pdata->charge_set_pin))
485 gpio_direction_output(pdata->charge_set_pin, pdata->charge_set_level);
488 static void rk_stop_charge(struct rk30_adc_battery_data *bat)
490 struct rk30_adc_battery_platform_data *pdata = bat->pdata;
493 if (batt_gpio_is_valid(pdata->charge_set_pin))
494 gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
497 static int get_ac_status(struct rk30_adc_battery_data *bat){
499 struct rk30_adc_battery_platform_data *pdata = bat->pdata;
501 if (batt_gpio_is_valid(pdata->dc_det_pin)) {
502 if (gpio_get_value (pdata->dc_det_pin) == pdata->dc_det_level){
508 if(pdata->is_dc_charging){
509 status = pdata->is_dc_charging();
515 #if defined CONFIG_BATTERY_RK30_USB_CHARGE
517 //state of charge ----running
518 static int get_usb_status2(struct rk30_adc_battery_data *bat){
520 // struct rk30_adc_battery_platform_data *pdata = bat->pdata;
521 int usb_status = 0; // 0--dischage ,1 ---usb charge, 2 ---ac charge
522 int vbus_status = dwc_vbus_status();
524 if (1 == vbus_status) {
525 if (0 == get_gadget_connect_flag()){
526 if (++bat->gBatUsbChargeCnt >= NUM_USBCHARGE_IDENTIFY_TIMES){
527 bat->gBatUsbChargeCnt = NUM_USBCHARGE_IDENTIFY_TIMES + 1;
528 usb_status = 2; // non-standard AC charger
529 if(bat ->pdata ->control_usb_charging)
530 bat ->pdata ->control_usb_charging(1);
532 usb_status = 1; // connect to pc
533 if(bat ->pdata ->control_usb_charging)
534 bat ->pdata ->control_usb_charging(0);
538 usb_status = 1; // connect to pc
539 if(bat ->pdata ->control_usb_charging)
540 bat ->pdata ->control_usb_charging(0);
545 bat->gBatUsbChargeCnt = 0;
546 if (2 == vbus_status) {
547 usb_status = 2; //standard AC charger
549 if(bat ->pdata ->control_usb_charging)
550 bat ->pdata ->control_usb_charging(1);
561 static int rk_battery_get_status(struct rk30_adc_battery_data *bat)
564 /* struct rk30_adc_battery_platform_data *pdata = bat->pdata;*/
565 int ac_ac_charging = 0, usb_ac_charging = 0;
568 ac_ac_charging = get_ac_status(bat);
569 if(1 == ac_ac_charging)
572 #if defined (CONFIG_BATTERY_RK30_USB_CHARGE)
573 if (strstr(saved_command_line,"charger")){
574 wake_lock(&charge_display_lock); //lock
575 if (batt_gpio_is_valid(bat->pdata->usb_det_pin)) {
576 if( gpio_get_value(bat->pdata->usb_det_pin)== bat->pdata->usb_det_level){
577 if(( 1 == usb_ac_charging )||( 1 == ac_ac_charging ))
578 bat -> ac_charging = 1;
579 if(( 1 == bat->usb_charging)||(1 == bat ->ac_charging))
583 if(( 0 == usb_ac_charging )&&( 0 == ac_ac_charging ))
584 bat -> ac_charging = 0;
586 bat->ac_charging = 1;
588 bat->usb_charging = 0;
589 if(1 == bat->ac_charging)
597 if(dwc_otg_check_dpdm() == 0){
598 bat->usb_charging = 0;
600 }else if(dwc_otg_check_dpdm() == 1){
601 bat->usb_charging = 1;
602 if(bat -> pdata ->control_usb_charging)
603 bat -> pdata ->control_usb_charging(0);
604 }else if(dwc_otg_check_dpdm() == 2){
605 bat->usb_charging = 0;
607 if(bat -> pdata ->control_usb_charging)
608 bat -> pdata ->control_usb_charging(1);
610 if((1 == usb_ac_charging)||(1 == ac_ac_charging))
611 bat ->ac_charging = 1;
613 bat ->ac_charging = 0;
615 if(( 0 == bat ->ac_charging )&&(0 == bat->usb_charging )){
626 usb_ac_charging = get_usb_status2(bat); //0 --discharge, 1---usb charging,2----AC charging;
627 if(1 == usb_ac_charging)
628 bat->usb_charging = 1;
630 bat->usb_charging = 0;
633 if((usb_ac_charging == 2)||(ac_ac_charging == 1))
634 bat -> ac_charging = 1;
636 bat -> ac_charging = 0;
638 if((bat->usb_charging == 1)||(bat ->ac_charging ==1))
641 if(1 == bat->ac_charging )
642 bat->charge_source_now = 1; //ac charge
643 else if( 1 == bat->usb_charging){
644 bat->charge_source_now = 2; //ac charge
646 bat->charge_soure_old =0;
647 bat->charge_source_now=0;
649 if(bat->charge_source_now != bat->charge_soure_old){
651 for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++){ //0.3 s
652 msleep(1); //mdelay --- > msleep
653 rk30_adc_battery_voltage_samples(bat); //get new voltage
656 bat->charge_soure_old = bat->charge_source_now;
659 DBG("ac_status=%d,usb_status=%d bat->bat_change = %d\n",bat -> ac_charging, bat->usb_charging ,bat->bat_change );
664 static int is_charge_ok(struct rk30_adc_battery_data *bat)
666 int charge_is_ok = 0;
667 struct rk30_adc_battery_platform_data *pdata = bat->pdata;
669 if( 1 != bat->charge_level)
672 if ((!(batt_gpio_is_valid(pdata->charge_ok_pin))) && (
673 pdata->charging_ok == NULL))
676 if (batt_gpio_is_valid(pdata->charge_ok_pin)) {
677 if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level){
680 }else if( pdata->charging_ok){
682 charge_is_ok = pdata->charging_ok();
690 static int rk30_adc_battery_status_samples(struct rk30_adc_battery_data *bat)
694 charge_level = bat ->charge_level;//rk_battery_get_status(bat);
696 if (charge_level != bat->old_charge_level){
697 bat->old_charge_level = charge_level;
701 rk_start_charge(bat);
707 bat->bat_status_cnt = 0;
709 if(( 1 == charge_level )&&(1 == bat->charge_full_flag) && (bat->bat_capacity < 90)){
710 rk_start_charge(bat); //recharge
711 if(bat->pdata->ctrl_charge_led != NULL)
712 bat->pdata->ctrl_charge_led(0);
714 }else if (charge_level) {
715 rk_start_charge(bat);
722 if(charge_level == 0){
724 bat->charge_full_flag = 0;
726 bat->time_to_full = 0;
727 bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
730 if( is_charge_ok(bat) == INVALID_CHARGE_CHECK){
731 if (bat->bat_capacity == 100){
732 if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){
733 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
735 bat->charge_full_flag = 1;
736 if(bat->pdata->ctrl_charge_led != NULL)
737 bat->pdata->ctrl_charge_led(1);
742 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
743 if((bat->bat_capacity == 99)&&(bat->time_to_full == 0)){
744 bat->time_to_full = get_seconds();
745 }else if(bat->bat_capacity == 99)
747 if(get_seconds() - bat->time_to_full > 1800){
748 bat->bat_capacity = 100;
749 bat->time_to_full = 0;
754 if(bat->pdata->ctrl_charge_led != NULL)
755 bat->pdata->ctrl_charge_led(0);
757 }else{ // pin of charge_ok_pin
758 if (is_charge_ok(bat) != CHARGE_IS_OK ){
761 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
763 if((bat->bat_capacity == 99)&&(bat->time_to_full == 0)){
764 bat->time_to_full = get_seconds();
765 }else if(bat->bat_capacity == 99)
767 if(get_seconds() - bat->time_to_full > 1800){
768 bat->bat_capacity = 100;
769 bat->time_to_full = 0;
778 if (bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) {
779 bat->full_times = NUM_CHARGE_FULL_DELAY_TIMES + 1;
782 if ((bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) && (bat->bat_capacity >= 99)){
783 if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){
784 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
786 bat->bat_capacity = 100;
791 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
800 static int rk_adc_battery_iio_read_refvol(struct rk30_adc_battery_platform_data *data)
802 struct iio_channel *channel = data->ref_voltage_chan;
805 ret = iio_read_channel_raw(channel, &val);
807 pr_err("read channel() error: %d\n", ret);
813 static int get_ref_voltage(struct rk30_adc_battery_data *bat)
816 struct regulator *logic;
817 int voltage, ref_voltage;
819 logic = regulator_get(NULL, "vdd_arm");
820 voltage = regulator_get_voltage(logic);
821 data_value = rk_adc_battery_iio_read_refvol(bat->pdata);
822 ref_voltage = voltage*1024/data_value/1000;
826 static int rk_adc_voltage(struct rk30_adc_battery_data *bat, int value)
831 ref_voltage = bat ->pdata->reference_voltage;
834 if (bat->pdata->auto_calibration == 1)
835 ref_voltage = get_ref_voltage(bat);
836 voltage = (value * ref_voltage * (batt_table[4] + batt_table[5])) / (1024 * batt_table[5]);
837 DBG("ref_voltage =%d, voltage=%d\n", ref_voltage, voltage);
840 voltage = adc_to_voltage(value);
842 DBG("ref_voltage =%d, voltage=%d\n", ref_voltage, voltage);
846 static void rk_handle_ripple(struct rk30_adc_battery_data *bat, int status)
851 if (bat->pdata->use_board_table){
852 p_table = bat->pdata->board_batt_table;
855 if(bat->bat_voltage >= p_table[2*BATT_NUM +5]+ 10)
856 bat->bat_voltage = p_table[2*BATT_NUM +5] + 10;
857 else if(bat->bat_voltage <= p_table[BATT_NUM +6] - 10)
858 bat->bat_voltage = p_table[BATT_NUM +6] - 10;
861 if(bat->bat_voltage >= p_table[BATT_NUM +5]+ 10)
862 bat->bat_voltage = p_table[BATT_NUM +5] + 10;
863 else if(bat->bat_voltage <= p_table[6] - 10)
864 bat->bat_voltage = p_table[6] - 10;
870 //static int *pSamples;
871 static void rk30_adc_battery_voltage_samples(struct rk30_adc_battery_data *bat)
874 int i,*pStart = bat->adc_samples, num = 0;
875 int level = bat->charge_level;
878 value = bat->adc_val;
879 bat->adc_val = rk_adc_battery_iio_read(bat->pdata);
881 *(bat->pSamples++) = rk_adc_voltage(bat,value);
883 bat->bat_status_cnt++;
884 if (bat->bat_status_cnt > NUM_VOLTAGE_SAMPLE) bat->bat_status_cnt = NUM_VOLTAGE_SAMPLE + 1;
886 num = bat->pSamples - pStart;
888 if (num >= NUM_VOLTAGE_SAMPLE){
889 bat ->pSamples = pStart;
890 num = NUM_VOLTAGE_SAMPLE;
895 for (i = 0; i < num; i++){
896 value += bat->adc_samples[i];
898 bat->bat_voltage = value / num;
901 if(battery_test_flag == 0)
903 if(0 == bat->pdata->use_board_table){
905 if(bat->bat_voltage >= batt_table[2*BATT_NUM +5]+ 10)
906 bat->bat_voltage = batt_table[2*BATT_NUM +5] + 10;
907 else if(bat->bat_voltage <= batt_table[BATT_NUM +6] - 10)
908 bat->bat_voltage = batt_table[BATT_NUM +6] - 10;
911 if(bat->bat_voltage >= batt_table[BATT_NUM +5]+ 10)
912 bat->bat_voltage = batt_table[BATT_NUM +5] + 10;
913 else if(bat->bat_voltage <= batt_table[6] - 10)
914 bat->bat_voltage = batt_table[6] - 10;
917 rk_handle_ripple(bat, level);
920 }else if(battery_test_flag == 2){
922 if(batt_table[3] == 0){
923 if(bat->bat_voltage < 3400){
924 if((get_seconds() - gSecondsCnt) > 30){
925 gSecondsCnt = get_seconds();
926 if((gVoltageCnt - bat->bat_voltage) > 15){
927 strncpy(gDischargeFlag, "off" ,4);
929 gVoltageCnt = bat->bat_voltage;
934 if(bat->bat_voltage < 3400){
935 bat->bat_voltage = 3400;
939 if(bat->bat_voltage < 6800){
940 if((get_seconds() - gSecondsCnt) > 30){
941 gSecondsCnt = get_seconds();
942 if((gDoubleVoltageCnt - bat->bat_voltage) > 30){
943 strncpy(gDischargeFlag, "off" ,4);
945 gDoubleVoltageCnt =bat->bat_voltage;
948 if(bat->bat_voltage < 6800){
949 bat->bat_voltage = 6800;
955 static int rk30_adc_battery_voltage_to_capacity(struct rk30_adc_battery_data *bat, int BatVoltage)
962 if (bat->pdata->use_board_table)
963 p = bat->pdata->board_batt_table;
964 else if (bat->pdata->dts_batt_table)
965 p = bat->pdata->dts_batt_table;
970 if (1 == bat->charge_level){ //charge
971 if(0 == bat->start_voltage_status ){
972 if(BatVoltage >= (p[2*BATT_NUM +5])){
976 if(BatVoltage <= (p[BATT_NUM +6])){
980 for(i = BATT_NUM +6; i <2*BATT_NUM +5; i++){
982 if(((p[i]) <= BatVoltage) && (BatVoltage < (p[i+1]))){
984 capacity = (i-(BATT_NUM +6))*10 + ((BatVoltage - p[i]) * 10)/ (p[i+1]- p[i]);
993 DBG("start_voltage=%d,start_capacity =%d\n", bat->charge_start_voltage, bat->charge_start_capacity);
994 DBG("charge_down_proportion =%d,charge_up_proprotion=%d\n",bat ->charge_down_proportion,bat ->charge_up_proprotion);
995 for(i = BATT_NUM +6; i <2*BATT_NUM +5; i++)
996 if(((p[i]) <= bat->charge_start_voltage) && (bat->charge_start_voltage < (p[i+1])))
997 bat->voltage_to_local = i;
998 if(BatVoltage >= (p[2*BATT_NUM +5])){
1002 if(BatVoltage <= (p[BATT_NUM +6])){
1006 if(BatVoltage <bat->charge_start_voltage){
1007 for(i = BATT_NUM +6; i <2*BATT_NUM +5; i++)
1008 if(((p[i]) <= BatVoltage) && (BatVoltage < (p[i+1]))){
1009 if( p[i+1] < bat->charge_start_voltage ){
1010 capacity =bat->charge_start_capacity - ((p[i+1] -BatVoltage) * bat->charge_start_capacity/(bat->voltage_to_local -17+1))/ (p[i+1]- p[i]) - (bat->voltage_to_local- (i ))*bat->charge_start_capacity/(bat->voltage_to_local -17+1);
1011 DBG("1<<<<<<< %d bat->voltage_to_local =%d capacity = %d BatVoltage =%d p[i] = %d,p[i+1] = %d \n", i, bat->voltage_to_local,capacity,BatVoltage,p[i], p[i+1]);
1015 capacity =bat->charge_start_capacity - ((bat->charge_start_voltage -BatVoltage) * bat->charge_start_capacity/(bat->voltage_to_local -17+1) )/ (bat->charge_start_voltage - p[i]);
1016 DBG("2<<<<<< %d capacity = %d BatVoltage =%d p[i] = %d,p[i+1] = %d \n", i,capacity,BatVoltage,p[i], p[i+1]);
1024 if(BatVoltage > bat->charge_start_voltage){
1025 for(i = BATT_NUM +6; i <2*BATT_NUM +5; i++)
1026 if(((p[i]) <= BatVoltage) && (BatVoltage < (p[i+1]))){
1027 if( p[i] > bat->charge_start_voltage ){
1028 capacity = bat->charge_start_capacity + (i +1- (bat->voltage_to_local))*(100- bat->charge_start_capacity )/( 10 - (bat->voltage_to_local - 17)) + (BatVoltage - p[i]) * (100- bat->charge_start_capacity )/( 10 - (bat->voltage_to_local -17))/ (p[i+1]- p[i]);
1029 DBG("3<<<<<<<< %d bat->voltage_to_local =%d capacity = %d BatVoltage =%d p[i] = %d,p[i+1] = %d \n", i, bat->voltage_to_local,capacity,BatVoltage,p[i], p[i+1]);
1032 capacity = bat->charge_start_capacity + (BatVoltage - bat->charge_start_voltage) * (100- bat->charge_start_capacity )/( 10 - (bat->voltage_to_local-17 )) /(p[i+1] - bat->charge_start_voltage );
1033 DBG(" 4<<<<<<<<<%d bat->voltage_to_local =%d capacity = %d BatVoltage =%d p[i] = %d,p[i+1] = %d \n", i,bat->voltage_to_local,capacity,BatVoltage,p[i], p[i+1]);
1040 if(BatVoltage == bat->charge_start_voltage)
1041 capacity = bat ->charge_start_capacity;
1051 if(BatVoltage >= (p[BATT_NUM +5])){
1055 if(BatVoltage <= (p[6])){
1059 for(i = 6; i < BATT_NUM +5; i++){
1060 if(((p[i]) <= BatVoltage) && (BatVoltage < (p[i+1]))){
1061 capacity = (i-6)*10+ ((BatVoltage - p[i]) *10 )/ (p[i+1]- p[i]) ;
1072 DBG("real_voltage_to_capacity =%d\n" ,capacity);
1076 #if defined CONFIG_BATTERY_RK30_USB_CHARGE
1078 static void rk_usb_charger(struct rk30_adc_battery_data *bat)
1081 int timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE;
1082 int timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE;
1084 if((1 == bat ->charge_level)&&( 0 == bat ->start_voltage_status)){
1085 bat ->charge_start_voltage = bat ->bat_voltage;
1086 bat ->start_voltage_status = 1;
1087 bat ->charge_start_capacity = bat ->bat_capacity;
1088 if(bat ->charge_start_capacity%10 != 0){
1089 bat ->charge_up_proprotion = (100 - bat ->charge_start_capacity)/10+1;
1090 bat ->charge_down_proportion = bat ->charge_start_capacity/10+1;
1092 bat ->charge_up_proprotion = (100 - bat ->charge_start_capacity)/10;
1093 bat ->charge_down_proportion = bat ->charge_start_capacity/10;
1099 capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
1101 if (capacity > bat->bat_capacity){
1102 if(capacity > bat->bat_capacity + 10 )
1103 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -10; //5s
1104 else if(capacity > bat->bat_capacity + 7 )
1105 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -5; //10s
1106 else if(capacity > bat->bat_capacity + 3 )
1107 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE - 2; // 13
1108 if (++(bat->gBatCapacityusbChargeCnt) >= timer_of_charge_sample){
1109 bat->gBatCapacityusbChargeCnt = 0;
1110 if (bat->bat_capacity < 99){
1111 bat->bat_capacity++;
1112 bat->bat_change = 1;
1115 bat->gBatCapacityChargeCnt = 0;
1116 bat ->gBatCapacityusbdisChargeCnt = 0;//get_suspend_state(void)
1117 }else //if(( get_suspend_state() != PM_SUSPEND_MEM)&&(capacity < bat->bat_capacity)){
1118 // if((gpio_get_value (bat->pdata->back_light_pin) == 1)&&(capacity < bat->bat_capacity)){
1119 if((capacity < bat->bat_capacity)){
1120 DBG("USB CHARGE DOWN\n");
1122 // if (capacity < bat->bat_capacity){
1124 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 40; // 13
1125 }else if(capacity < 20){
1126 if(capacity + 3 > bat->bat_capacity )
1127 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -5; //5s
1128 else if(capacity + 7 > bat->bat_capacity )
1129 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -10; //10s
1130 else if(capacity + 10> bat->bat_capacity )
1131 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -25; // 13
1133 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 35; // 13
1135 if(capacity + 3 > bat->bat_capacity )
1136 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -5; //5s
1137 else if(capacity + 7 > bat->bat_capacity )
1138 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -10; //10s
1139 else if(capacity + 10> bat->bat_capacity )
1140 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 15; // 13
1142 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 20; // 13
1145 if (++(bat->gBatCapacityusbdisChargeCnt) >= timer_of_discharge_sample){
1146 bat->gBatCapacityusbdisChargeCnt = 0;
1147 if (bat->bat_capacity > 0){
1148 bat->bat_capacity-- ;
1149 bat->bat_change = 1;
1154 bat->gBatCapacityusbChargeCnt = 0;
1157 else //if(get_suspend_state() == PM_SUSPEND_MEM){
1158 //if(gpio_get_value (bat->pdata->back_light_pin) == 0){
1162 bat->gBatCapacityusbdisChargeCnt = 0;
1163 // (bat->gBatCapacityusbChargeCnt)++;
1164 if( is_charge_ok(bat) != INVALID_CHARGE_CHECK){
1165 if( is_charge_ok(bat) == CHARGE_IS_OK){
1167 if (++bat->gBatCapacityusbChargeCnt >= timer_of_charge_sample-30){
1168 bat->gBatCapacityusbChargeCnt = 0;
1169 if (bat->bat_capacity <= 99){
1170 bat->bat_capacity++;
1171 bat->bat_change = 1;
1175 if (capacity > bat->capacitytmp){
1176 bat->gBatCapacityChargeCnt = 0;
1179 if ((bat->bat_capacity >= 85) &&((bat->gBatCapacityChargeCnt) > NUM_CHARGE_MAX_SAMPLE)){
1180 bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
1182 if (bat->bat_capacity < 99){
1183 bat->bat_capacity++;
1184 bat->bat_change = 1;
1192 if (capacity > bat->capacitytmp){
1193 bat->gBatCapacityChargeCnt = 0;
1195 if ((bat->bat_capacity >= 85) &&(bat->gBatCapacityusbChargeCnt > NUM_CHARGE_MAX_SAMPLE)){
1196 bat->gBatCapacityusbChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
1197 if (bat->bat_capacity <= 99){
1198 bat->bat_capacity++;
1199 bat->bat_change = 1;
1206 bat->capacitytmp = capacity;
1210 static void rk_ac_charger(struct rk30_adc_battery_data *bat)
1213 int timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE;
1215 if((1 == bat->charge_level)&&( 0 == bat->start_voltage_status)){
1216 bat->charge_start_voltage = bat->bat_voltage;
1217 bat->start_voltage_status = 1;
1218 bat->charge_start_capacity = bat->bat_capacity;
1219 if(bat ->charge_start_capacity%10 != 0){
1220 bat ->charge_up_proprotion = (100 - bat ->charge_start_capacity)/10+1;
1221 bat ->charge_down_proportion = bat ->charge_start_capacity/10+1;
1223 bat ->charge_up_proprotion = (100 - bat ->charge_start_capacity)/10;
1224 bat ->charge_down_proportion = bat ->charge_start_capacity/10;
1229 capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
1230 if (capacity > bat->bat_capacity){
1231 if(capacity > bat->bat_capacity + 10 )
1232 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -10; //5s
1233 else if(capacity > bat->bat_capacity + 7 )
1234 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -5; //10s
1235 else if(capacity > bat->bat_capacity + 3 )
1236 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE - 2; // 13
1237 if (++(bat->gBatCapacityacChargeCnt) >= timer_of_charge_sample){
1238 bat->gBatCapacityacChargeCnt = 0;
1239 if (bat->bat_capacity < 99){
1240 bat->bat_capacity++;
1241 bat->bat_change = 1;
1244 bat->gBatCapacityChargeCnt = 0;
1247 bat->gBatCapacityacChargeCnt = 0;
1248 (bat->gBatCapacityChargeCnt)++;
1249 if( is_charge_ok(bat) != INVALID_CHARGE_CHECK){
1250 if( is_charge_ok(bat) == CHARGE_IS_OK){
1251 if (bat->gBatCapacityChargeCnt >= timer_of_charge_sample){
1252 bat->gBatCapacityChargeCnt = 0;
1253 if (bat->bat_capacity < 99){
1254 bat->bat_capacity++;
1255 bat->bat_change = 1;
1259 if (capacity > bat->capacitytmp){
1260 bat->gBatCapacityChargeCnt = 0;
1264 if ((bat->bat_capacity >= 85) &&((bat->gBatCapacityChargeCnt) > NUM_CHARGE_MAX_SAMPLE)){
1265 bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
1267 if (bat->bat_capacity < 99){
1268 bat->bat_capacity++;
1269 bat->bat_change = 1;
1276 if (capacity > bat->capacitytmp){
1277 bat->gBatCapacityChargeCnt = 0;
1281 if ((bat->bat_capacity >= 85) &&(bat->gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)){
1282 bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
1284 if (bat->bat_capacity <= 99){
1285 bat->bat_capacity++;
1286 bat->bat_change = 1;
1294 bat->capacitytmp = capacity;
1296 static void rk_battery_charger(struct rk30_adc_battery_data *bat)
1300 int timer_of_discharge_sample = DISCHARGE_MIN_SECOND;
1302 capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
1304 if (capacity < bat->bat_capacity){
1307 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 40; // 13
1311 if(capacity + 3 > bat->bat_capacity )
1312 timer_of_discharge_sample = DISCHARGE_MIN_SECOND -5; //5s
1313 else if(capacity + 7 > bat->bat_capacity )
1314 timer_of_discharge_sample = DISCHARGE_MIN_SECOND -10; //10s
1315 else if(capacity + 10> bat->bat_capacity )
1316 timer_of_discharge_sample = DISCHARGE_MIN_SECOND -25; // 13
1318 timer_of_discharge_sample = DISCHARGE_MIN_SECOND - 35; // 13
1320 if(capacity + 3 > bat->bat_capacity )
1321 timer_of_discharge_sample = DISCHARGE_MIN_SECOND -5; //5s
1322 else if(capacity + 7 > bat->bat_capacity )
1323 timer_of_discharge_sample = DISCHARGE_MIN_SECOND -10; //10s
1324 else if(capacity + 10> bat->bat_capacity )
1325 timer_of_discharge_sample = DISCHARGE_MIN_SECOND - 15; // 13
1327 timer_of_discharge_sample = DISCHARGE_MIN_SECOND - 20; // 13
1330 if (++(bat->gBatCapacityDisChargeCnt) >= timer_of_discharge_sample){
1331 bat->gBatCapacityDisChargeCnt = 0;
1332 if (bat->bat_capacity > 0){
1333 bat->bat_capacity-- ;
1334 bat->bat_change = 1;
1339 bat->gBatCapacityDisChargeCnt = 0;
1341 bat->gBatCapacityChargeCnt = 0;
1342 bat->gBatCapacityusbdisChargeCnt=0 ;
1343 bat->gBatCapacityusbChargeCnt =0;
1344 bat->gBatCapacityacChargeCnt = 0;
1345 bat->start_voltage_status = 0;
1347 bat->capacitytmp = capacity;
1353 static void rk30_adc_battery_capacity_samples(struct rk30_adc_battery_data *bat)
1355 // int capacity = 0;
1356 // int timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE;
1357 // int timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE;
1359 if (bat->bat_status_cnt < NUM_VOLTAGE_SAMPLE) {
1360 bat->gBatCapacityDisChargeCnt = 0;
1361 bat->gBatCapacityChargeCnt = 0;
1362 bat->gBatCapacityacChargeCnt = 0;
1366 if(1 == bat->charge_level){
1367 #if defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1368 if(1 == bat->usb_charging)
1369 rk_usb_charger(bat);
1376 rk_battery_charger(bat);
1382 //static int poweron_check = 0;
1383 static void rk30_adc_battery_poweron_capacity_check(struct rk30_adc_battery_data *bat)
1386 int new_capacity, old_capacity;
1389 new_capacity = bat ->bat_capacity;
1392 g_old_cap = g_old_cap + g_uboot_incre;
1395 old_capacity = g_old_cap; // rk30_adc_battery_load_capacity();
1396 if( old_capacity != -1 ){
1401 printk("func:%s; line:%d; old_capacity = %d; new_capacity = %d; g_uboot_incre = %d\n", __func__, __LINE__, old_capacity, new_capacity,g_uboot_incre);
1403 if ((old_capacity < 0) || (old_capacity > 100)){
1404 old_capacity = new_capacity;
1407 if (bat ->bat_status == POWER_SUPPLY_STATUS_FULL){
1408 if (new_capacity > 80){
1409 bat ->bat_capacity = 100;
1412 else if (bat ->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING){
1414 bat->bat_capacity = (old_capacity < 10) ? (old_capacity + 2) : old_capacity;
1416 bat ->bat_capacity = old_capacity;
1417 if(bat->bat_capacity == 100)
1418 bat->bat_capacity = 99;
1419 if(bat->bat_capacity == 0)
1420 bat->bat_capacity =1;
1422 DBG("oldcapacity %d,newcapacity %d,capacity %d\n", old_capacity
1423 , new_capacity, bat->bat_capacity);
1425 bat ->bat_change = 1;
1427 #if defined CONFIG_BATTERY_RK30_USB_CHARGE
1428 #define to_battery_usb_device_info(x) container_of((x), \
1429 struct rk30_adc_battery_data, usb);
1431 static int rk30_adc_battery_get_usb_property(struct power_supply *psy,
1432 enum power_supply_property psp,
1433 union power_supply_propval *val)
1435 struct rk30_adc_battery_data *bat= to_battery_usb_device_info(psy);
1438 case POWER_SUPPLY_PROP_ONLINE:
1439 if (psy->type == POWER_SUPPLY_TYPE_USB){
1440 val->intval = bat ->usb_charging;
1441 if (strstr(saved_command_line,"charger") == NULL){
1442 if( 1 == bat->charge_full_flag)
1456 static enum power_supply_property rk30_adc_battery_usb_props[] = {
1458 POWER_SUPPLY_PROP_ONLINE,
1461 static struct power_supply rk30_usb_supply =
1464 .type = POWER_SUPPLY_TYPE_USB,
1466 .get_property = rk30_adc_battery_get_usb_property,
1468 .properties = rk30_adc_battery_usb_props,
1469 .num_properties = ARRAY_SIZE(rk30_adc_battery_usb_props),
1472 static irqreturn_t rk30_adc_battery_dc_wakeup(int irq, void *dev_id)
1474 disable_irq_nosync(irq);
1475 queue_work(gBatteryData->wq, &gBatteryData->dcwakeup_work);
1479 #define to_battery_ac_device_info(x) container_of((x), \
1480 struct rk30_adc_battery_data, ac);
1482 static int rk30_adc_battery_get_ac_property(struct power_supply *psy,
1483 enum power_supply_property psp,
1484 union power_supply_propval *val)
1488 struct rk30_adc_battery_data *bat = to_battery_ac_device_info(psy);
1491 case POWER_SUPPLY_PROP_ONLINE:
1492 if (psy->type == POWER_SUPPLY_TYPE_MAINS){
1493 val->intval = bat ->ac_charging;
1494 if (strstr(saved_command_line,"charger") == NULL ){
1495 if( 1 == bat->charge_full_flag)
1509 static enum power_supply_property rk30_adc_battery_ac_props[] =
1511 POWER_SUPPLY_PROP_ONLINE,
1514 static struct power_supply rk30_ac_supply =
1517 .type = POWER_SUPPLY_TYPE_MAINS,
1519 .get_property = rk30_adc_battery_get_ac_property,
1521 .properties = rk30_adc_battery_ac_props,
1522 .num_properties = ARRAY_SIZE(rk30_adc_battery_ac_props),
1524 static void rk30_adc_battery_dcdet_delaywork(struct work_struct *work)
1528 struct rk30_adc_battery_platform_data *pdata;
1531 struct rk30_adc_battery_data *bat = container_of((work), \
1532 struct rk30_adc_battery_data, dcwakeup_work);
1535 irq = gpio_to_irq(pdata->dc_det_pin);
1536 free_irq(irq, NULL);
1538 irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1539 ret = request_irq(irq, rk30_adc_battery_dc_wakeup, irq_flag, "ac_charge_irq", NULL);// reinitialize the DC irq
1541 free_irq(irq, NULL);
1544 power_supply_changed(&bat ->ac);
1545 rk_send_wakeup_key();
1547 bat ->bat_status_cnt = 0; //the state of battery is change
1552 static int rk30_adc_battery_get_status(struct rk30_adc_battery_data *bat)
1554 return (bat->bat_status);
1557 static int rk30_adc_battery_get_health(struct rk30_adc_battery_data *bat)
1559 return POWER_SUPPLY_HEALTH_GOOD;
1562 static int rk30_adc_battery_get_present(struct rk30_adc_battery_data *bat)
1564 return (bat->bat_voltage < BATT_MAX_VOL_VALUE) ? 0 : 1;
1567 static int rk30_adc_battery_get_voltage(struct rk30_adc_battery_data *bat)
1569 return (bat->bat_voltage );
1572 static int rk30_adc_battery_get_capacity(struct rk30_adc_battery_data *bat)
1574 return (bat->bat_capacity);
1577 static int rk30_adc_battery_get_property(struct power_supply *psy,
1578 enum power_supply_property psp,
1579 union power_supply_propval *val)
1583 struct rk30_adc_battery_data *bat = container_of((psy), \
1584 struct rk30_adc_battery_data, bat);
1586 case POWER_SUPPLY_PROP_STATUS:
1587 val->intval = rk30_adc_battery_get_status(bat);
1588 DBG("gBatStatus=%d\n",val->intval);
1590 case POWER_SUPPLY_PROP_HEALTH:
1591 val->intval = rk30_adc_battery_get_health(bat);
1592 DBG("gBatHealth=%d\n",val->intval);
1594 case POWER_SUPPLY_PROP_PRESENT:
1595 val->intval = rk30_adc_battery_get_present(bat);
1596 DBG("gBatPresent=%d\n",val->intval);
1598 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1599 // val ->intval = rk30_adc_battery_get_voltage(bat);
1600 voltage = rk30_adc_battery_get_voltage(bat);
1601 val->intval = voltage*1000;
1602 DBG("gBatVoltage=%d\n",val->intval);
1604 case POWER_SUPPLY_PROP_CAPACITY:
1605 if(battery_test_flag == 2)
1608 val->intval = rk30_adc_battery_get_capacity(bat);
1609 DBG("gBatCapacity=%d%%\n",val->intval);
1611 case POWER_SUPPLY_PROP_TECHNOLOGY:
1612 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
1614 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
1615 val->intval = BATT_MAX_VOL_VALUE;
1617 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
1618 val->intval = BATT_ZERO_VOL_VALUE;
1628 static enum power_supply_property rk30_adc_battery_props[] = {
1630 POWER_SUPPLY_PROP_STATUS,
1631 POWER_SUPPLY_PROP_HEALTH,
1632 POWER_SUPPLY_PROP_PRESENT,
1633 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1634 POWER_SUPPLY_PROP_TECHNOLOGY,
1635 POWER_SUPPLY_PROP_CAPACITY,
1636 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
1637 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
1640 static struct power_supply rk30_battery_supply =
1643 .type = POWER_SUPPLY_TYPE_BATTERY,
1645 .get_property = rk30_adc_battery_get_property,
1647 .properties = rk30_adc_battery_props,
1648 .num_properties = ARRAY_SIZE(rk30_adc_battery_props),
1652 static void rk30_adc_battery_resume_check(struct rk30_adc_battery_data *bat)
1656 int new_capacity, old_capacity;
1657 // struct rk30_adc_battery_data *bat = gBatteryData;
1659 bat ->old_charge_level = -1;
1660 bat ->pSamples = bat->adc_samples;
1662 bat->adc_val = rk_adc_battery_iio_read(bat->pdata);
1664 level = oldlevel = rk_battery_get_status(bat);//rk30_adc_battery_status_samples(bat);//init charge status
1666 for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++) { //0.3 s
1669 rk30_adc_battery_voltage_samples(bat); //get voltage
1670 level = rk_battery_get_status(bat);// rk30_adc_battery_status_samples(bat); //check charge status
1671 if (oldlevel != level){
1672 oldlevel = level; //if charge status changed, reset sample
1676 new_capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
1677 old_capacity =bat-> suspend_capacity;
1679 //if (bat->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING){
1682 bat->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity;
1685 bat->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity; // aviod the value of capacity increase dicharge
1688 if (batt_gpio_is_valid(bat->pdata->batt_low_pin)) {
1689 if (gpio_get_value(bat ->pdata->batt_low_pin) == bat ->pdata->batt_low_level)
1690 bat->bat_capacity = 0;
1696 static int rk30_adc_battery_suspend(struct platform_device *dev, pm_message_t state)
1699 struct rk30_adc_battery_data *data = platform_get_drvdata(dev);
1701 data ->suspend_capacity = data->bat_capacity;
1702 data ->suspend_time = get_seconds();
1703 cancel_delayed_work(&data ->delay_work);
1705 if (batt_gpio_is_valid(data->pdata->batt_low_pin)) {
1707 irq = gpio_to_irq(data ->pdata->batt_low_pin);
1709 enable_irq_wake(irq);
1715 static int rk30_adc_battery_resume(struct platform_device *dev)
1718 struct rk30_adc_battery_data *data = platform_get_drvdata(dev);
1719 if( data->bat_capacity < 10 ){
1720 wake_lock_timeout(&batt_wake_lock_detect_lowpower,15*HZ);
1721 data->bat_change = 1;
1723 data ->resume_time = get_seconds();
1724 data ->resume = true;
1725 queue_delayed_work(data->wq, &data ->delay_work, msecs_to_jiffies(100));
1726 if (batt_gpio_is_valid(data->pdata->batt_low_pin)) {
1728 irq = gpio_to_irq(data ->pdata ->batt_low_pin);
1729 disable_irq_wake(irq);
1735 #define rk30_adc_battery_suspend NULL
1736 #define rk30_adc_battery_resume NULL
1740 unsigned long AdcTestCnt = 0;
1741 static void rk30_adc_battery_timer_work(struct work_struct *work)
1743 struct rk30_adc_battery_data *bat = container_of((work), struct
1744 rk30_adc_battery_data, delay_work.work);
1748 // if( (bat->resume_time - bat->suspend_time) >= 1800 )
1749 rk30_adc_battery_resume_check(bat);
1751 //bat->bat_capacity = bat->suspend_capacity;
1752 bat ->resume = false;
1753 bat ->bat_change =1;
1756 bat->stop_check = 1;
1757 if( 1 == bat ->lower_power_flag ){
1758 bat ->bat_capacity = 0;
1759 bat ->bat_change =1;
1761 if (bat ->poweron_check){
1762 bat ->poweron_check = 0;
1763 rk30_adc_battery_poweron_capacity_check(bat);
1766 bat ->charge_level = rk_battery_get_status(bat);
1767 DBG("bat ->charge_level =%d\n", bat ->charge_level);
1768 rk30_adc_battery_status_samples(bat);
1769 rk30_adc_battery_voltage_samples(bat);
1770 rk30_adc_battery_capacity_samples(bat);
1772 if( 0 == bat ->pdata ->charging_sleep){
1773 if( 1 == bat->charge_level){ // charge
1774 if(0 == bat->status_lock ){
1775 wake_lock(&batt_wake_lock); //lock
1776 bat ->status_lock = 1;
1780 if(1 == bat ->status_lock ){
1781 wake_unlock(&batt_wake_lock); //unlock
1782 bat ->status_lock = 0;
1788 /*update battery parameter after adc and capacity has been changed*/
1789 if(bat ->bat_change){
1790 bat ->bat_change= 0;
1791 if (strstr(saved_command_line,"charger") == NULL){ //when low charging-current,not in charging-displays
1792 if(0 == bat ->bat_capacity){
1793 bat ->ac_charging = 0;
1794 bat ->usb_charging = 0;
1798 // rk30_adc_battery_put_capacity(bat ->bat_capacity);
1799 power_supply_changed(&bat ->bat);
1800 power_supply_changed(&bat ->ac);
1801 #if defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1802 power_supply_changed(&bat ->usb);
1807 //if (rk30_battery_dbg_level){
1808 if (++AdcTestCnt >= 2)
1812 DBG("Status = %d, RealAdcVal = %d, RealVol = %d,gBatVol = %d, gBatCap = %d, RealCapacity = %d, batt_dischargecnt = %d\n, chargecnt = %d,ac_count = %d, usb_count =%d ,usb_dischargecount =%d\n",
1813 bat ->bat_status, bat ->adc_val, rk_adc_voltage(bat, bat ->adc_val),
1814 bat ->bat_voltage, bat ->bat_capacity, bat ->capacitytmp, bat ->gBatCapacityDisChargeCnt, bat ->gBatCapacityChargeCnt,
1815 bat ->gBatCapacityacChargeCnt, bat ->gBatCapacityusbChargeCnt, bat ->gBatCapacityusbdisChargeCnt);
1819 queue_delayed_work(bat ->wq, &bat ->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS));
1824 static int rk30_adc_battery_io_init(struct rk30_adc_battery_platform_data *pdata)
1828 if (batt_gpio_is_valid(pdata->dc_det_pin)) {
1829 ret = gpio_request(pdata->dc_det_pin, NULL);
1831 pr_info("failed to request dc_det gpio\n");
1835 ret = gpio_direction_input(pdata->dc_det_pin);
1837 pr_info("failed to set gpio dc_det input\n");
1843 if (batt_gpio_is_valid(pdata->charge_ok_pin)) {
1844 ret = gpio_request(pdata->charge_ok_pin, NULL);
1846 pr_err("failed to request charge_ok gpio\n");
1850 ret = gpio_direction_input(pdata->charge_ok_pin);
1852 pr_err("failed to set gpio charge_ok input\n");
1857 if (batt_gpio_is_valid(pdata->batt_low_pin)) {
1858 ret = gpio_request(pdata->batt_low_pin, NULL);
1860 pr_err("failed to request batt_low_pin gpio\n");
1864 ret = gpio_direction_input(pdata->batt_low_pin);
1866 pr_err("failed to set gpio batt_low_pin input\n");
1876 extern void kernel_power_off(void);
1877 int get_battery_status(void)
1879 return system_lowerpower;
1881 static int rk_adc_battery_poweron_status(struct rk30_adc_battery_data *bat)
1884 #if defined CONFIG_BATTERY_RK30_USB_CHARGE
1888 // struct rk30_adc_battery_platform_data *pdata = bat->pdata;
1890 if (get_ac_status(bat) ){
1891 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
1892 bat -> ac_charging = 1;
1893 if (is_charge_ok(bat) == 1){
1894 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
1895 bat->bat_capacity = 100;
1897 power_supply_changed(&bat ->ac);
1900 #if defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1901 otg_status = dwc_otg_check_dpdm();
1902 if( 0 != otg_status ){
1903 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
1904 if (is_charge_ok(bat) == 1){
1905 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
1906 bat->bat_capacity = 100;
1910 if(otg_status == 1){
1911 bat->usb_charging = 1;
1912 if(bat -> pdata ->control_usb_charging)
1913 bat -> pdata ->control_usb_charging(0);
1914 }else if(otg_status == 2){
1915 bat->usb_charging = 0;
1916 bat -> ac_charging = 1;
1917 if(bat -> pdata ->control_usb_charging)
1918 bat -> pdata ->control_usb_charging(1);
1920 bat->usb_charging = 0;
1922 printk("charge_status = %d\n",otg_status);
1924 power_supply_changed(&bat ->ac);
1925 #if defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1926 power_supply_changed(&bat ->usb);
1928 if((bat -> ac_charging == 1)||(bat->usb_charging == 1)){
1929 bat ->old_charge_level =1;
1930 bat->charge_level = 1;
1933 bat ->old_charge_level =0;
1934 bat->charge_level = 0;
1941 static void rk30_adc_battery_check(struct rk30_adc_battery_data *bat)
1945 // struct rk30_adc_battery_platform_data *pdata = bat->pdata;
1946 int check_data[NUM_VOLTAGE_SAMPLE];
1947 //bat ->old_charge_level
1948 // pSamples = bat->adc_samples;
1951 bat->adc_val = rk_adc_battery_iio_read(bat->pdata);
1953 DBG("first_adc_value is %d\n", bat->adc_val);
1954 level = oldlevel = rk_adc_battery_poweron_status(bat);// rk30_adc_battery_status_samples(bat);//init charge status
1956 for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++){ //0.3 s
1958 rk30_adc_battery_voltage_samples(bat); //get voltage
1959 //level = rk30_adc_battery_status_samples(bat); //check charge status
1961 level = rk_adc_battery_poweron_status(bat);
1963 if (oldlevel != level){
1964 oldlevel = level; //if charge status changed, reset sample
1969 for(i=0; i< NUM_VOLTAGE_SAMPLE; i++){
1971 check_data[i] = bat->adc_val;
1973 bat->adc_val = rk_adc_battery_iio_read(bat->pdata);
1974 bat->adc_value += check_data[i];
1976 bat->adc_value /= NUM_VOLTAGE_SAMPLE;
1978 bat->bat_capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage); //init bat_capacity
1979 bat->capacitytmp = bat->bat_capacity;
1980 level = rk_adc_battery_poweron_status(bat);
1981 if((1 == level)&&(0 == bat->start_voltage_status )){
1982 bat->charge_start_voltage = bat->bat_voltage;
1983 bat->start_voltage_status = 1;
1984 bat->charge_start_capacity = bat->bat_capacity;
1985 bat ->charge_up_proprotion = (100 - bat ->charge_start_capacity)/10+1;
1986 bat ->charge_down_proportion = bat ->charge_start_capacity/10+1;
1989 if (get_ac_status(bat) ){
1990 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
1991 bat -> ac_charging = 1;
1992 if (is_charge_ok(bat) == 1){
1993 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
1994 bat->bat_capacity = 100;
1997 #if defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1998 if( 0 != dwc_otg_check_dpdm() ){
1999 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
2000 if (is_charge_ok(bat) == 1){
2001 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
2002 bat->bat_capacity = 100;
2006 if(dwc_otg_check_dpdm() == 1){
2007 bat->usb_charging = 1;
2008 if(bat -> pdata ->control_usb_charging)
2009 bat -> pdata ->control_usb_charging(0);
2010 }else if(dwc_otg_check_dpdm() == 2){
2011 bat->usb_charging = 0;
2012 bat -> ac_charging = 1;
2013 if(bat -> pdata ->control_usb_charging)
2014 bat -> pdata ->control_usb_charging(1);
2016 bat->usb_charging = 0;
2019 power_supply_changed(&bat ->ac);
2020 #if defined (CONFIG_BATTERY_RK30_USB_CHARGE)
2021 power_supply_changed(&bat ->usb);
2023 if((bat -> ac_charging == 1)||(bat->usb_charging == 1)){
2024 bat ->old_charge_level =1;
2025 bat->charge_level = 1;
2030 if (bat->bat_capacity == 0) {
2031 bat->bat_capacity = 1;
2032 system_lowerpower = 1;
2036 if(0 !=bat ->pdata->low_voltage_protection ){
2037 if (bat->bat_voltage <= bat->pdata->low_voltage_protection) {
2038 system_lowerpower = 1;
2039 printk("protection lower power .....\n");
2042 if (bat->bat_voltage <= BATT_ZERO_VOL_VALUE) {
2043 system_lowerpower = 1;
2044 pr_info("lower power bat->bat_voltage = %d\n"
2045 , bat->bat_voltage);
2050 if ((bat->bat_voltage <= BATT_ZERO_VOL_VALUE)&&(bat->bat_status != POWER_SUPPLY_STATUS_CHARGING)){
2057 static void rk30_adc_battery_lowerpower_delaywork(struct work_struct *work)
2061 struct rk30_adc_battery_data *bat = container_of((work), \
2062 struct rk30_adc_battery_data, lowerpower_work);
2064 if (batt_gpio_is_valid(bat->pdata->batt_low_pin)) {
2065 irq = gpio_to_irq(bat ->pdata ->batt_low_pin);
2069 printk("lowerpower\n");
2074 static irqreturn_t rk30_adc_battery_low_wakeup(int irq,void *dev_id)
2076 queue_work(gBatteryData->wq, &gBatteryData->lowerpower_work);
2079 static void rk_lowerpower_check(struct rk30_adc_battery_data *bat)
2083 int check_data[NUM_VOLTAGE_SAMPLE];
2085 for(i=0; i< NUM_VOLTAGE_SAMPLE; i++){
2087 bat->adc_val = rk_adc_battery_iio_read(bat->pdata);
2088 check_data[i] = bat->adc_val;
2090 adc_val += check_data[i];
2092 adc_val /=NUM_VOLTAGE_SAMPLE;
2094 DBG(">>>>>>>>>>>one>>>%d, two<<<<<%d<<<<\n",bat->adc_value,adc_val);
2095 DBG(">>>>>>>>>>>firset-value>>>%d, second-value<<<<<%d<<<<\n",rk_adc_voltage(bat, bat->adc_value),rk_adc_voltage(bat, adc_val));
2097 if((adc_val >= bat->adc_value+5) &&(bat->bat_status == POWER_SUPPLY_STATUS_NOT_CHARGING ) )//
2099 printk("%d,%d\n",adc_val,bat->adc_value);
2100 printk("lower-power shutdown");
2105 static void rk_adc_battery_check_work(struct work_struct *work)
2107 struct rk30_adc_battery_data *bat =
2108 container_of((work), struct
2109 rk30_adc_battery_data, check_work.work);
2111 if(1 == get_ac_status(bat)){
2112 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
2113 bat -> ac_charging = 1;
2116 power_supply_changed(&bat ->ac);
2117 if(bat->stop_check != 1)
2118 queue_delayed_work(bat ->wq, &bat ->check_work, msecs_to_jiffies(TIMER_MS_COUNTS));
2121 static void poweron_lowerpoer_handle(struct rk30_adc_battery_data *bat)
2123 #ifdef CONFIG_LOGO_LOWERPOWER_WARNING
2124 if((1 == get_battery_status())&&(bat->bat_status == POWER_SUPPLY_STATUS_NOT_CHARGING )){
2131 static int battery_notifier_call(struct notifier_block *nb,
2132 unsigned long event, void *data)
2134 struct rk30_adc_battery_data *bat=
2135 container_of(nb, struct rk30_adc_battery_data, battery_nb);
2139 rk_lowerpower_check(bat);
2143 poweron_lowerpoer_handle(bat);
2152 static int rk31_adcbat_parse_dt(struct platform_device *pdev, struct
2153 rk30_adc_battery_platform_data *data)
2155 struct device_node *node = pdev->dev.of_node;
2156 enum of_gpio_flags flags;
2157 struct property *prop;
2164 struct iio_channel *channels;
2167 channels = iio_channel_get_all(&pdev->dev);
2168 if (IS_ERR(channels))
2169 pr_err("get adc channels fails\n");
2170 while (channels[num].indio_dev)
2172 data->chan = &channels[0];
2174 data->ref_voltage_chan = &channels[1];
2175 ret = of_property_read_u32(node, "auto_calibration", &value);
2177 pr_info("%s:unsupport auto_calibration\n", __func__);
2180 data->auto_calibration = value;
2182 ret = of_property_read_u32(node, "ref_voltage", &value);
2184 pr_info("%s:unsupport ref_voltage\n", __func__);
2187 data->reference_voltage = value;
2189 /* determine the number of config info */
2190 prop = of_find_property(node, "bat_table", &length);
2194 length /= sizeof(u32);
2197 size = (sizeof(*data->dts_batt_table)) * length;
2198 data->dts_batt_table =
2199 devm_kzalloc(&(pdev->dev), size, GFP_KERNEL);
2200 if (!data->dts_batt_table)
2203 ret = of_property_read_u32_array(node
2204 , "bat_table", data->dts_batt_table, length);
2209 for (i = 4; i < length; i++) {
2210 batt_table[i] = data->dts_batt_table[i];
2212 pr_info("data->dts_batt_table[ %d ] %d %d\n", i
2213 , data->dts_batt_table[i], batt_table[i]);
2215 data->dc_det_pin = of_get_named_gpio_flags(node
2216 , "dc_det_gpio", 0, &flags);
2217 if (data->dc_det_pin == -EPROBE_DEFER)
2218 pr_info("%s dc_det_gpio error\n", __func__);
2220 if (batt_gpio_is_valid(data->dc_det_pin))
2221 data->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW)
2222 ? RK30_GPIO_LOW : RK30_GPIO_HIGH;
2224 data->batt_low_pin = of_get_named_gpio_flags(node
2225 , "bat_low_gpio", 0, &flags);
2226 if (data->batt_low_pin == -EPROBE_DEFER)
2227 pr_info("%s bat_low_gpio error\n", __func__);
2229 if (batt_gpio_is_valid(data->batt_low_pin))
2230 data->batt_low_level = (flags & OF_GPIO_ACTIVE_LOW)
2231 ? RK30_GPIO_LOW : RK30_GPIO_HIGH;
2233 data->charge_ok_pin = of_get_named_gpio_flags(node
2234 , "chg_ok_gpio", 0, &flags);
2235 if (data->charge_ok_pin == -EPROBE_DEFER)
2236 pr_info("%s chg_ok_gpio error\n", __func__);
2238 if (batt_gpio_is_valid(data->charge_ok_pin))
2239 data->charge_ok_level = (flags & OF_GPIO_ACTIVE_LOW)
2240 ? RK30_GPIO_LOW : RK30_GPIO_HIGH;
2242 ret = of_property_read_u32(node, "is_dc_charge", &value);
2244 pr_info("%s:hardware unsupport dc charge\n", __func__);
2247 data->is_dc_charge = value;
2249 ret = of_property_read_u32(node, "is_usb_charge"
2252 pr_err("%s:hardware unsupport usb charge\n", __func__);
2255 data->is_usb_charge = value;
2257 pr_info("rk30 battery:support %s %s charger\n",
2258 data->is_dc_charge ? "DC" : ""
2259 , data->is_usb_charge ? "USB" : "");
2264 static int rk31_adcbat_parse_dt(struct platform_device
2265 *dev, struct rk30_adc_battery_platform_data *data)
2272 static int rk30_adc_battery_probe(struct platform_device *pdev)
2278 struct rk30_adc_battery_data *data;
2279 struct rk30_adc_battery_platform_data *pdata;
2280 #ifdef CONFIG_MACH_RK_FAC
2282 for(i=0;i<BATT_NUM;i++)
2284 batt_table[6+i]=pdata->chargeArray[i];
2285 batt_table[BATT_NUM+6+i]=pdata->chargeArray[i];
2288 gSecondsCnt = get_seconds();
2289 /*data = kzalloc(sizeof(*data), GFP_KERNEL);*/
2290 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
2293 goto err_data_alloc_failed;
2296 /*pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);*/
2297 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
2298 if (pdata == NULL) {
2300 goto err_pdata_alloc_failed;
2302 memset(data, 0, sizeof(struct rk30_adc_battery_data));
2303 gBatteryData = data;
2304 platform_set_drvdata(pdev, data);
2306 data->pdata = pdata;
2307 data->status_lock = 0;
2308 data->old_charge_level = -1;
2309 data->capacitytmp = 0;
2310 data->suspend_capacity = 0;
2311 data->ac_charging = 0;
2312 data->usb_charging = 0;
2313 data->full_times = 0;
2314 data->gBatCapacityDisChargeCnt =0;
2315 data->gBatCapacityChargeCnt=0;
2316 data->gBatCapacityusbdisChargeCnt=0 ;
2317 data->gBatCapacityusbChargeCnt =0;
2318 data->gBatCapacityacChargeCnt = 0;
2319 data->charge_source_now = 0;
2320 data->charge_soure_old = 0;
2321 data->start_voltage_status = 0;
2322 data->charge_full_flag =0;
2323 data->pSamples = data->adc_samples;
2324 data->lower_power_flag = 0;
2325 data->capacitytmp = 0;
2326 data->time_to_full = 0;
2327 data->stop_check = 0;
2328 data->voltage_to_local = 0;
2330 data->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
2331 wake_lock_init(&batt_wake_lock, WAKE_LOCK_SUSPEND, "batt_lock");
2332 wake_lock_init(&charge_display_lock, WAKE_LOCK_SUSPEND, "charge_display_lock"); //charge_display_lock
2333 wake_lock_init(&batt_wake_lock_detect_lowpower
2334 , WAKE_LOCK_SUSPEND, "lowpower_lock");
2336 ret = rk31_adcbat_parse_dt(pdev, data->pdata);
2337 /*ret = rk31_adcbat_parse_dt(pdev, pdata);*/
2339 pr_err("failed to find rk30 adc battery platform data\n");
2343 ret = rk30_adc_battery_io_init(data->pdata);
2349 memset(data->adc_samples, 0, sizeof(int)*(NUM_VOLTAGE_SAMPLE + 2));
2351 //register adc for battery sample
2352 data->wq = create_singlethread_workqueue("adc_battd");
2354 /*data->client = client;*/
2355 data->adc_val = rk_adc_battery_iio_read(data->pdata);
2357 data ->bat = rk30_battery_supply;
2358 ret = power_supply_register(&pdev->dev,&data ->bat);
2361 printk(KERN_INFO "fail to battery power_supply_register\n");
2362 goto err_battery_failed;
2364 #if defined (CONFIG_BATTERY_RK30_USB_CHARGE)
2365 data ->usb = rk30_usb_supply;
2366 ret = power_supply_register(&pdev->dev, &data ->usb);
2369 printk(KERN_INFO "fail to usb power_supply_register\n");
2370 goto err_usb_failed;
2373 data ->ac = rk30_ac_supply;
2374 ret = power_supply_register(&pdev->dev, &data ->ac);
2377 printk(KERN_INFO "fail to ac power_supply_register\n");
2381 //init dc dectet irq & delay work
2382 if (batt_gpio_is_valid(data->pdata->dc_det_pin)) {
2383 INIT_WORK(&data->dcwakeup_work, rk30_adc_battery_dcdet_delaywork);
2385 irq = gpio_to_irq(data->pdata->dc_det_pin);
2386 irq_flag = gpio_get_value(data->pdata->dc_det_pin)
2387 ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
2388 ret = request_irq(irq, rk30_adc_battery_dc_wakeup, irq_flag, "ac_charge_irq", NULL);
2391 printk("failed to request dc det irq\n");
2392 goto err_dcirq_failed;
2394 enable_irq_wake(irq);
2399 ret = device_create_file(&pdev->dev,&dev_attr_batparam);
2402 printk(KERN_ERR "failed to create bat param file\n");
2403 goto err_battery_failed;
2406 ret = create_sysfs_interfaces(&pdev->dev);
2411 "device rk30_adc_batterry sysfs register failed\n");
2415 //Power on Battery detect
2416 rk30_adc_battery_check(data);
2418 // data->wq = create_singlethread_workqueue("adc_battd");
2419 INIT_DELAYED_WORK(&data->delay_work, rk30_adc_battery_timer_work);
2421 //if (1 == data->pdata->save_capacity) {
2423 queue_delayed_work(data->wq, &data->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS*10));
2424 data ->poweron_check = 1;
2426 queue_delayed_work(data->wq, &data->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS));
2427 data ->poweron_check = 0;
2429 INIT_DELAYED_WORK(&data->check_work, rk_adc_battery_check_work);
2430 queue_delayed_work(data ->wq, &data ->check_work, msecs_to_jiffies(TIMER_MS_COUNTS));
2431 if (batt_gpio_is_valid(data->pdata->batt_low_pin)) {
2432 if (0 == gpio_get_value(data->pdata->batt_low_pin)) {
2434 if (gpio_get_value(data->pdata->batt_low_pin) == 0) {
2435 printk("lower power\n");
2440 INIT_WORK(&data->lowerpower_work, rk30_adc_battery_lowerpower_delaywork);
2441 irq = gpio_to_irq(data->pdata->batt_low_pin);
2442 ret = request_irq(irq, rk30_adc_battery_low_wakeup, IRQF_TRIGGER_LOW, "batt_low_irq", NULL);
2445 printk("failed to request batt_low_irq irq\n");
2446 goto err_lowpowerirq_failed;
2451 data->battery_nb.notifier_call = battery_notifier_call;
2452 register_adc_battery_notifier(&data->battery_nb);
2454 printk(KERN_INFO "rk30_adc_battery: driver initialized\n");
2458 power_supply_unregister(&data ->usb);
2460 power_supply_unregister(&data ->ac);
2463 power_supply_unregister(&data ->bat);
2466 if (batt_gpio_is_valid(data->pdata->dc_det_pin))
2467 free_irq(gpio_to_irq(data->pdata->dc_det_pin), data);
2469 err_lowpowerirq_failed:
2470 if (batt_gpio_is_valid(data->pdata->batt_low_pin))
2471 free_irq(gpio_to_irq(data->pdata->batt_low_pin), data);
2476 err_pdata_alloc_failed:
2478 err_data_alloc_failed:
2481 printk("rk30_adc_battery: error!\n");
2486 static int rk30_adc_battery_remove(struct platform_device *pdev)
2488 struct rk30_adc_battery_data *data = platform_get_drvdata(pdev);
2489 struct rk30_adc_battery_platform_data *pdata = data->pdata;
2491 cancel_delayed_work_sync(&data->delay_work);
2492 if (batt_gpio_is_valid(pdata->dc_det_pin))
2493 cancel_work_sync(&data->dcwakeup_work);
2494 cancel_delayed_work_sync(&data->check_work);
2496 if (batt_gpio_is_valid(pdata->batt_low_pin))
2497 cancel_work_sync(&data->lowerpower_work);
2498 #if defined (CONFIG_BATTERY_RK30_USB_CHARGE)
2499 power_supply_unregister(&data ->usb);
2501 power_supply_unregister(&data ->ac);
2502 power_supply_unregister(&data ->bat);
2503 if (batt_gpio_is_valid(pdata->dc_det_pin))
2504 free_irq(gpio_to_irq(pdata->dc_det_pin), data);
2512 static const struct of_device_id rk30_adc_battery_dt_match[] = {
2513 { .compatible = "rk30-adc-battery",},
2516 MODULE_DEVICE_TABLE(of, rk30_adc_battery_dt_match);
2520 static struct platform_driver rk30_adc_battery_driver = {
2521 .probe = rk30_adc_battery_probe,
2522 .remove = rk30_adc_battery_remove,
2523 .suspend = rk30_adc_battery_suspend,
2524 .resume = rk30_adc_battery_resume,
2526 .name = "rk30-adc-battery",
2527 .owner = THIS_MODULE,
2528 .of_match_table = of_match_ptr(rk30_adc_battery_dt_match),
2532 static int __init rk30_adc_battery_init(void)
2534 return platform_driver_register(&rk30_adc_battery_driver);
2537 static void __exit rk30_adc_battery_exit(void)
2539 platform_driver_unregister(&rk30_adc_battery_driver);
2541 //module_init(rk30_adc_battery_init);//module_init(rk30_adc_battery_init);//
2542 subsys_initcall(rk30_adc_battery_init);
2543 //fs_initcall(rk30_adc_battery_init);
2544 module_exit(rk30_adc_battery_exit);
2548 MODULE_DESCRIPTION("Battery detect driver for the rk30");
2549 MODULE_AUTHOR("luowei lw@rock-chips.com");
2550 MODULE_LICENSE("GPL");