drivers/power/rk30_factory_adc_battery.c

   1 /* drivers/power/rk30_adc_battery.c
   2  *
   3  * battery detect driver for the rk30
   4  *
   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.
   8  *
   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.
  13  *
  14  */
  15
  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>
  24 #include <asm/io.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>
  36 #include <linux/fs.h>
  37 #include <linux/wakelock.h>
  38 #include <linux/fs.h>
  39 #include <linux/string.h>
  40 #include <linux/init.h>
  41 #include <linux/earlysuspend.h>
  42 #include <linux/suspend.h>
  43 #ifdef CONFIG_EARLYSUSPEND
  44 /* kernel/power/earlysuspend.c */
  45 extern suspend_state_t get_suspend_state(void);
  46 #endif
  47
  48 static int rk30_battery_dbg_level = 0;
  49 module_param_named(dbg_level, rk30_battery_dbg_level, int, 0644);
  50 #define DBG( args...) \
  51         do { \
  52                 if (rk30_battery_dbg_level) { \
  53                         pr_info(args); \
  54                 } \
  55         } while (0)
  56
  57 #define TIMER_MS_COUNTS          1000
  58 #define SLOPE_SECOND_COUNTS                    15
  59 #define DISCHARGE_MIN_SECOND                   45
  60 #define CHARGE_MIN_SECOND                      45
  61 #define CHARGE_MID_SECOND                      90
  62 #define CHARGE_MAX_SECOND                      250
  63 #define   CHARGE_FULL_DELAY_TIMES          10
  64 #define   USBCHARGE_IDENTIFY_TIMES        5
  65
  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)
  73
  74 #define   CHARGE_IS_OK                                 1
  75 #define   INVALID_CHARGE_CHECK               -1
  76
  77 #if defined(CONFIG_ARCH_RK3066B)
  78 #define  BAT_DEFINE_VALUE                                            1800
  79 #elif defined(CONFIG_ARCH_RK2928)
  80 #define  BAT_DEFINE_VALUE                                         3300
  81 #else
  82 #define  BAT_DEFINE_VALUE                                            2500
  83 #endif
  84
  85
  86 #define BATT_FILENAME "/data/bat_last_capacity.dat"
  87
  88
  89 #define BATTERY_APK
  90 #ifdef  BATTERY_APK
  91 #define BATT_NUM  11
  92 int    battery_dbg_level = 0;
  93 int    battery_test_flag = 0;
  94 int    gVoltageCnt = 3400;
  95 int    gDoubleVoltageCnt = 6800;
  96 unsigned long gSecondsCnt = 0;
  97 char gDischargeFlag[3] = {"on "};
  98
  99
 100 #ifdef CONFIG_BATTERY_RK30_VOL3V8
 101 #define BATT_MAX_VOL_VALUE                             4120                     //Full  charge volate
 102 #define BATT_ZERO_VOL_VALUE                            3500                     //power down voltage
 103 #define BATT_NOMAL_VOL_VALUE                         3800
 104
 105 static int batt_table[2*BATT_NUM+6] =
 106 {
 107         0x4B434F52,0x7461625F,0x79726574,0,100,100,
 108         3496, 3548, 3599, 3626, 3655, 3697, 3751, 3812, 3877, 3949, 4030,  //discharge
 109         3540, 3785, 3842, 3861, 3915, 3980, 4041, 4135, 4169, 4175, 4185          //charge
 110 };
 111 #define adc_to_voltage(adc_val) ((adc_val * BAT_DEFINE_VALUE * (batt_table[4] +batt_table[5])) / (1024 *batt_table[5]))
 112 #else
 113 #define BATT_MAX_VOL_VALUE                              8284                    //Full charge voltage
 114 #define BATT_ZERO_VOL_VALUE                             6800                    // power down voltage
 115 #define BATT_NOMAL_VOL_VALUE                          7600
 116
 117
 118 static int batt_table[2*BATT_NUM+6] =
 119 {
 120         0x4B434F52,0x7461625F,0x79726574,1,300,100,
 121         6800, 7242, 7332, 7404, 7470, 7520, 7610, 7744, 7848, 8016, 8284,//discharge
 122         7630, 7754, 7852, 7908, 7956, 8024, 8112, 8220, 8306, 8318, 8328//charge
 123 };
 124 #define adc_to_voltage(adc_val) ((adc_val * BAT_DEFINE_VALUE * (batt_table[4] +batt_table[5])) / (1024 *batt_table[5]))
 125 #endif
 126
 127 #endif
 128
 129
 130
 131 /********************************************************************************/
 132
 133
 134 enum {
 135         BATTERY_STATUS                  = 0,
 136         BATTERY_HEALTH                  = 1,
 137         BATTERY_PRESENT                 = 2,
 138         BATTERY_CAPACITY                        = 3,
 139         BATTERY_AC_ONLINE                       = 4,
 140         BATTERY_STATUS_CHANGED  = 5,
 141         AC_STATUS_CHANGED               = 6,
 142         BATTERY_INT_STATUS              = 7,
 143         BATTERY_INT_ENABLE              = 8,
 144 };
 145
 146 typedef enum {
 147         CHARGER_BATTERY = 0,
 148         CHARGER_USB,
 149         CHARGER_AC
 150 } charger_type_t;
 151
 152
 153
 154 struct rk30_adc_battery_data {
 155         int irq;
 156
 157         //struct timer_list       timer;
 158         struct workqueue_struct *wq;
 159         struct delayed_work         delay_work;
 160         struct work_struct          dcwakeup_work;
 161         struct work_struct                   lowerpower_work;
 162         bool                    resume;
 163
 164         struct rk30_adc_battery_platform_data *pdata;
 165
 166         struct adc_client       *client;
 167         int                     adc_val;
 168         int                     adc_samples[NUM_VOLTAGE_SAMPLE+2];
 169
 170         int                     bat_status;
 171         int                     bat_status_cnt;
 172         int                     bat_health;
 173         int                     bat_present;
 174         int                     bat_voltage;
 175         int                     bat_capacity;
 176         int                     bat_change;
 177
 178         int                     old_charge_level;
 179         int                    *pSamples;
 180         int                     gBatCapacityDisChargeCnt;
 181         int                     gBatCapacityChargeCnt;
 182         int                     gBatCapacityacChargeCnt;
 183         int                     gBatCapacityusbChargeCnt ;
 184         int                       gBatCapacityusbdisChargeCnt;
 185         int                       capacitytmp;
 186         int                     suspend_capacity;
 187         int                     gBatUsbChargeCnt;
 188         int                     status_lock;
 189
 190         struct power_supply     bat;
 191         struct power_supply     usb;
 192         struct power_supply     ac;
 193         struct power_supply     bk_bat;
 194
 195         int                     poweron_check;
 196         int                     usb_charging;
 197         int                     ac_charging;
 198         int                      charge_check;
 199         int                        charge_level;
 200
 201         int                     charge_source_now;
 202         int                     charge_soure_old;
 203         int                     charge_start_capacity;
 204         int                     charge_start_voltage;
 205         int                     start_voltage_status;
 206         int                     charge_up_proprotion;
 207         int                     charge_down_proportion;
 208         unsigned long          suspend_time;
 209         unsigned long           resume_time;
 210
 211         int                     full_times;
 212         int                         charge_full_flag;
 213
 214
 215 };
 216 static struct rk30_adc_battery_data *gBatteryData;
 217 static struct wake_lock batt_wake_lock;
 218 static struct wake_lock charge_display_lock;
 219 int system_lowerpower = 0;
 220
 221 extern int dwc_vbus_status(void);
 222 extern int get_gadget_connect_flag(void);
 223 extern int dwc_otg_check_dpdm(void);
 224 static int  is_charge_ok(struct rk30_adc_battery_data *bat);
 225 static void rk30_adc_battery_voltage_samples(struct rk30_adc_battery_data *bat);
 226
 227
 228 #ifdef  BATTERY_APK
 229 //#define BAT_ADC_TABLE_LEN               11
 230 static ssize_t bat_param_read(struct device *dev,struct device_attribute *attr, char *buf)
 231 {
 232         int i;
 233         for(i=0;i<BATT_NUM;i++)
 234                 printk("i=%d batt_table=%d\n",i+6,batt_table[i+6]);
 235
 236         for(i=0;i<BATT_NUM;i++)
 237                 printk("i=%d batt_table=%d\n",i+17,batt_table[i+17]);
 238         return 0;
 239 }
 240 DEVICE_ATTR(batparam, 0664, bat_param_read,NULL);
 241
 242
 243 static ssize_t rkbatt_show_debug_attrs(struct device *dev,
 244                                                                               struct device_attribute *attr, char *buf)
 245 {
 246         return sprintf(buf, "%d\n", battery_dbg_level);
 247 }
 248
 249 static ssize_t rkbatt_restore_debug_attrs(struct device *dev,
 250                                                                                   struct device_attribute *attr, const char *buf, size_t size)
 251 {
 252         int liTmp;
 253
 254         sscanf(buf, "%d", &liTmp);
 255
 256         if(liTmp != 0 && liTmp != 1)
 257         {
 258                 dev_err(dev, "rk29adc_restore_debug_attrs err\n");
 259         }
 260         else
 261         {
 262                 battery_dbg_level = liTmp;
 263         }
 264         return size;
 265 }
 266
 267 static ssize_t rkbatt_show_state_attrs(struct device *dev,
 268                                                                                 struct device_attribute *attr, char *buf)
 269 {
 270 //      struct rk30_adc_battery_platform_data *pdata = gBatteryData->pdata;
 271         int charge_ok_value =0 ;
 272         charge_ok_value = is_charge_ok(gBatteryData) ;
 273
 274         return  sprintf(buf,
 275                 "gBatVol=%d,gBatCap=%d,charge_ok=%d,%s\n",
 276                 gBatteryData->bat_voltage,gBatteryData->bat_capacity,
 277                 charge_ok_value,gDischargeFlag);
 278 }
 279
 280 static ssize_t rkbatt_restore_state_attrs(struct device *dev,
 281                                                                                 struct device_attribute *attr, const char *buf, size_t size)
 282 {
 283         return size;
 284 }
 285
 286 static ssize_t rkbatt_show_value_attrs(struct device *dev,
 287                                                                             struct device_attribute *attr, char *buf)
 288 {
 289         return sprintf(buf, "pull_up_res =%d,\npull_down_res=%d\n", batt_table[4],batt_table[5]);
 290 }
 291
 292 static ssize_t rkbatt_restore_value_attrs(struct device *dev,
 293                                                                                 struct device_attribute *attr, const char *buf, size_t size)
 294 {
 295         int liUp        = 0;
 296         int liDown      = 0;
 297
 298         sscanf(buf, "%d,%d", &liUp,&liDown);
 299
 300         if(liUp != 0 && liDown != 0)
 301         {
 302                 batt_table[4] = liUp;
 303                 batt_table[5] = liDown;
 304         }
 305         return size;
 306 }
 307
 308 static ssize_t rkbatt_show_flag_attrs(struct device *dev,
 309                                                                          struct device_attribute *attr, char *buf)
 310 {
 311         return sprintf(buf, "rk29_battery_test_flag=%d\n", battery_test_flag);
 312 }
 313 static ssize_t rkbatt_restore_flag_attrs(struct device *dev,
 314                                                                             struct device_attribute *attr, const char *buf, size_t size)
 315 {
 316         int liFlag;
 317
 318         sscanf(buf, "%d", &liFlag);
 319
 320         if(liFlag != 0)
 321         {
 322                 battery_test_flag = liFlag;
 323         }
 324         return size;
 325 }
 326 static struct device_attribute rkbatt_attrs[] = {
 327         __ATTR(state, 0664, rkbatt_show_state_attrs, rkbatt_restore_state_attrs),
 328         __ATTR(debug, 0664, rkbatt_show_debug_attrs, rkbatt_restore_debug_attrs),
 329         __ATTR(value, 0666, rkbatt_show_value_attrs, rkbatt_restore_value_attrs),
 330         __ATTR(flag,  0666, rkbatt_show_flag_attrs,  rkbatt_restore_flag_attrs),
 331 };
 332
 333 static int create_sysfs_interfaces(struct device *dev)
 334 {
 335         int liTmep;
 336         for (liTmep = 0; liTmep < ARRAY_SIZE(rkbatt_attrs); liTmep++)   {
 337
 338                 if (device_create_file(dev, rkbatt_attrs + liTmep)){
 339                         goto error;
 340                 }
 341         }
 342
 343         return 0;
 344
 345 error:
 346         for ( ; liTmep >= 0; liTmep--){
 347                 device_remove_file(dev, rkbatt_attrs + liTmep);
 348         }
 349
 350         dev_err(dev, "%s:Unable to create sysfs interface\n", __func__);
 351         return -1;
 352 }
 353
 354 #endif
 355
 356
 357 static int rk30_adc_battery_load_capacity(void)
 358 {
 359         char value[4];
 360         int* p = (int *)value;
 361         long fd = sys_open(BATT_FILENAME,O_RDONLY,0);
 362
 363         if(fd < 0){
 364                 DBG("rk30_adc_battery_load_capacity: open file /data/bat_last_capacity.dat failed\n");
 365                 return -1;
 366         }
 367
 368         sys_read(fd,(char __user *)value,4);
 369         sys_close(fd);
 370
 371         return (*p);
 372 }
 373
 374 static void rk30_adc_battery_put_capacity(int loadcapacity)
 375 {
 376         char value[4];
 377         int* p = (int *)value;
 378         long fd = sys_open(BATT_FILENAME,O_CREAT | O_RDWR,0);
 379
 380         if(fd < 0){
 381                 DBG("rk30_adc_battery_put_capacity: open file /data/bat_last_capacity.dat failed\n");
 382                 return;
 383         }
 384
 385         *p = loadcapacity;
 386         sys_write(fd, (const char __user *)value, 4);
 387         sys_close(fd);
 388 }
 389
 390 static void rk_start_charge(struct rk30_adc_battery_data *bat)
 391 {
 392         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 393
 394         if (pdata->charge_set_pin != INVALID_GPIO){
 395                 gpio_direction_output(pdata->charge_set_pin, pdata->charge_set_level);
 396         }
 397 }
 398
 399 static void rk_stop_charge(struct rk30_adc_battery_data *bat)
 400 {
 401         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 402
 403         if (pdata->charge_set_pin != INVALID_GPIO){
 404                 gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
 405         }
 406 }
 407
 408 static int  get_ac_status(struct rk30_adc_battery_data *bat){
 409
 410         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 411         int status = 0;
 412         if (pdata->dc_det_pin != INVALID_GPIO){
 413                 if (gpio_get_value (pdata->dc_det_pin) == pdata->dc_det_level){
 414                                 status = 1;
 415                         }else{
 416                                 status = 0;
 417                         }
 418         }else{
 419                 if(pdata->is_dc_charging){
 420                         status = pdata->is_dc_charging();
 421                 }
 422         }
 423
 424         return status;
 425 }
 426 // state of charge  --- charge-display
 427 static int  get_usb_status1(struct rk30_adc_battery_data *bat){
 428
 429 }
 430 //state of charge ----running
 431 static int  get_usb_status2(struct rk30_adc_battery_data *bat){
 432
 433 //      struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 434         int usb_status = 0; // 0--dischage ,1 ---usb charge, 2 ---ac charge
 435
 436         if (1 == dwc_vbus_status()) {
 437                 if (0 == get_gadget_connect_flag()){
 438                         if (++bat->gBatUsbChargeCnt >= NUM_USBCHARGE_IDENTIFY_TIMES){
 439                                 bat->gBatUsbChargeCnt = NUM_USBCHARGE_IDENTIFY_TIMES + 1;
 440                                 usb_status = 2; // non-standard AC charger
 441                                 if(bat ->pdata ->control_usb_charging)
 442                                         bat ->pdata ->control_usb_charging(1);
 443                         }
 444                 }else{
 445
 446                                 usb_status = 1; // connect to pc
 447                                 if(bat ->pdata ->control_usb_charging)
 448                                         bat ->pdata ->control_usb_charging(0);
 449
 450                 }
 451
 452         }else{
 453                 bat->gBatUsbChargeCnt = 0;
 454                 if (2 == dwc_vbus_status()) {
 455                         usb_status = 2; //standard AC charger
 456
 457                         if(bat ->pdata ->control_usb_charging)
 458                                         bat ->pdata ->control_usb_charging(1);
 459                 }else{
 460                         usb_status = 0;
 461                 }
 462
 463
 464         }
 465         return usb_status;
 466
 467 }
 468
 469 static int rk_battery_get_status(struct rk30_adc_battery_data *bat)
 470 {
 471         int charge_on = 0;
 472         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 473         int ac_ac_charging = 0, usb_ac_charging = 0;
 474         int i=0;
 475
 476 #if defined (CONFIG_BATTERY_RK30_AC_CHARGE)
 477         ac_ac_charging = get_ac_status(bat);
 478         if(1 == ac_ac_charging)
 479                 charge_on = 1;
 480 #endif
 481
 482 #if  defined (CONFIG_BATTERY_RK30_USB_CHARGE)
 483                 if (strstr(saved_command_line,"charger")){
 484                         wake_lock(&charge_display_lock);  //lock
 485                         if( bat->pdata->usb_det_pin  != INVALID_GPIO ){
 486                                 if( gpio_get_value(bat->pdata->usb_det_pin)== bat->pdata->usb_det_level){
 487                                         if(( 1 == usb_ac_charging )||( 1 == ac_ac_charging ))
 488                                                 bat -> ac_charging = 1;
 489                                         if(( 1 == bat->usb_charging)||(1 == bat ->ac_charging))
 490                                                 charge_on =1;
 491                                         return charge_on;
 492                                 }else{
 493                                         if(( 0 == usb_ac_charging )&&( 0 == ac_ac_charging ))
 494                                                 bat -> ac_charging = 0;
 495                                         else
 496                                                 bat->ac_charging = 1;
 497
 498                                         bat->usb_charging = 0;
 499                                         if(1 == bat->ac_charging)
 500                                                 charge_on=1;
 501                                         else
 502                                                 charge_on = 0;
 503                                         return charge_on;
 504                                 }
 505                         }else{
 506
 507                                 if(dwc_otg_check_dpdm() == 0){
 508                                         bat->usb_charging = 0;
 509                                         usb_ac_charging = 0;
 510                                 }else if(dwc_otg_check_dpdm() == 1){
 511                                         bat->usb_charging = 1;
 512                                         if(bat -> pdata ->control_usb_charging)
 513                                                 bat -> pdata ->control_usb_charging(0);
 514                                 }else if(dwc_otg_check_dpdm() == 2){
 515                                         bat->usb_charging = 0;
 516                                         usb_ac_charging = 1;
 517                                         if(bat -> pdata ->control_usb_charging)
 518                                                 bat -> pdata ->control_usb_charging(1);
 519                                 }
 520                                 if((1 == usb_ac_charging)||(1 == ac_ac_charging))
 521                                         bat ->ac_charging = 1;
 522                                 else
 523                                         bat ->ac_charging = 0;
 524
 525                                 if(( 0 == bat ->ac_charging )&&(0 == bat->usb_charging  )){
 526                                         charge_on = 0;
 527                                         bat->bat_change = 1;
 528                                 }
 529
 530                                 return charge_on;
 531
 532                         }
 533                 }
 534
 535                 if (charge_on == 0){
 536                         usb_ac_charging = get_usb_status2(bat); //0 --discharge, 1---usb charging,2----AC charging;
 537                         if(1 == usb_ac_charging)
 538                                 bat->usb_charging = 1;
 539                         else
 540                                 bat->usb_charging = 0;
 541                 }
 542 #endif
 543         if((usb_ac_charging == 2)||(ac_ac_charging == 1))
 544                 bat -> ac_charging = 1;
 545         else
 546                 bat -> ac_charging = 0;
 547
 548         if((bat->usb_charging == 1)||(bat ->ac_charging ==1))
 549                 charge_on =1;
 550
 551         if(1 == bat->ac_charging )
 552                         bat->charge_source_now = 1; //ac charge
 553         else if( 1 == bat->usb_charging){
 554                         bat->charge_source_now = 2; //ac charge
 555         }else{
 556                 bat->charge_soure_old =0;
 557                 bat->charge_source_now=0;
 558         }
 559         if(bat->charge_source_now != bat->charge_soure_old){
 560
 561                 for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++){                //0.3 s
 562                         msleep(1); //mdelay --- > msleep
 563                         rk30_adc_battery_voltage_samples(bat);              //get new voltage
 564                 }
 565
 566                         bat->charge_soure_old = bat->charge_source_now;
 567                         bat->bat_change = 1;
 568         }
 569         DBG("ac_status=%d,usb_status=%d bat->bat_change = %d\n",bat -> ac_charging, bat->usb_charging ,bat->bat_change );
 570
 571         return charge_on;
 572 }
 573
 574 static int  is_charge_ok(struct rk30_adc_battery_data *bat)
 575 {
 576         int charge_is_ok = 0;
 577         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 578
 579         if( 1 != bat->charge_level)
 580                 return -1;
 581
 582         if((pdata->charge_ok_pin == INVALID_GPIO)&& ( pdata->charging_ok == NULL))
 583                 return -1;
 584
 585         if (pdata->charge_ok_pin != INVALID_GPIO){
 586                 if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level){
 587                         charge_is_ok =1;
 588                 }
 589         }else if( pdata->charging_ok){
 590
 591                 charge_is_ok = pdata->charging_ok();
 592                 }
 593
 594         return charge_is_ok;
 595
 596
 597 }
 598
 599
 600 static int rk30_adc_battery_status_samples(struct rk30_adc_battery_data *bat)
 601 {
 602         int charge_level;
 603
 604         charge_level = bat ->charge_level;//rk_battery_get_status(bat);
 605
 606         if (charge_level != bat->old_charge_level){
 607                 bat->old_charge_level = charge_level;
 608                 bat->bat_change  = 1;
 609 #if 0
 610                 if(charge_level) {
 611                         rk_start_charge(bat);
 612                 }
 613                 else{
 614                         rk_stop_charge(bat);
 615                 }
 616 #endif
 617                 bat->bat_status_cnt = 0;
 618         }
 619         if(( 1 == charge_level )&&(1 == bat->charge_full_flag) && (bat->bat_capacity < 90)){
 620                 rk_start_charge(bat);  //recharge
 621                 if(bat->pdata->ctrl_charge_led != NULL)
 622                         bat->pdata->ctrl_charge_led(0);
 623
 624         }else if (charge_level) {
 625                 rk_start_charge(bat);
 626                 }else{
 627                         rk_stop_charge(bat);
 628
 629                 }
 630
 631
 632         if(charge_level == 0){
 633         //discharge
 634                 bat->charge_full_flag = 0;
 635                 bat->full_times = 0;
 636                 bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 637         }else{
 638         //charging
 639                 if( is_charge_ok(bat)  ==  INVALID_CHARGE_CHECK){
 640                         if (bat->bat_capacity == 100){
 641                                 if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){
 642                                         bat->bat_status = POWER_SUPPLY_STATUS_FULL;
 643                                         bat->bat_change  = 1;
 644                                         bat->charge_full_flag = 1;
 645                                         if(bat->pdata->ctrl_charge_led != NULL)
 646                                                 bat->pdata->ctrl_charge_led(1);
 647                                         rk_stop_charge(bat);
 648
 649                                 }
 650                         }else{
 651                                 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 652                                 if(bat->pdata->ctrl_charge_led != NULL)
 653                                                 bat->pdata->ctrl_charge_led(0);
 654                         }
 655                 }else{  // pin of charge_ok_pin
 656                         if (is_charge_ok(bat) != CHARGE_IS_OK ){
 657
 658                                 bat->full_times = 0;
 659                                 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 660                         }else{
 661                                 bat->full_times++;
 662
 663                                 if (bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) {
 664                                         bat->full_times = NUM_CHARGE_FULL_DELAY_TIMES + 1;
 665                                 }
 666
 667                                 if ((bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) && (bat->bat_capacity >= 99)){
 668                                         if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){
 669                                                 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
 670                                                 rk_stop_charge(bat);
 671                                                 bat->bat_capacity = 100;
 672                                                 bat->bat_change  = 1;
 673                                         }
 674                                 }
 675                                 else{
 676                                         bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 677                                 }
 678                         }
 679                 }
 680         }
 681
 682         return charge_level;
 683 }
 684 static int rk_adc_voltage(struct rk30_adc_battery_data *bat, int value)
 685 {
 686         int voltage;
 687
 688         int ref_voltage; //reference_voltage
 689         int pullup_res;
 690         int pulldown_res;
 691
 692         ref_voltage = bat ->pdata->reference_voltage;
 693         pullup_res = bat ->pdata->pull_up_res;
 694         pulldown_res = bat ->pdata->pull_down_res;
 695
 696         if(ref_voltage && pullup_res && pulldown_res){
 697
 698                 voltage =  ((value * ref_voltage * (pullup_res + pulldown_res)) / (1024 * pulldown_res));
 699
 700         }else{
 701                 voltage = adc_to_voltage(value);
 702         }
 703
 704
 705         return voltage;
 706
 707 }
 708 static void rk_handle_ripple(struct rk30_adc_battery_data *bat, int status)
 709 {
 710
 711         int *p_table;
 712
 713         if (bat->pdata->use_board_table){
 714                 p_table = bat->pdata->board_batt_table;
 715
 716                 if(1 == status){
 717                         if(bat->bat_voltage >= p_table[2*BATT_NUM +5]+ 10)
 718                                 bat->bat_voltage = p_table[2*BATT_NUM +5]  + 10;
 719                         else if(bat->bat_voltage <= p_table[BATT_NUM +6]  - 10)
 720                                 bat->bat_voltage =  p_table[BATT_NUM +6] - 10;
 721                 }
 722                 else{
 723                         if(bat->bat_voltage >= p_table[BATT_NUM +5]+ 10)
 724                                 bat->bat_voltage = p_table[BATT_NUM +5]  + 10;
 725                         else if(bat->bat_voltage <= p_table[6]  - 10)
 726                                 bat->bat_voltage =  p_table[6] - 10;
 727                 }
 728         }
 729
 730 }
 731
 732 //static int *pSamples;
 733 static void rk30_adc_battery_voltage_samples(struct rk30_adc_battery_data *bat)
 734 {
 735         int value;
 736         int i,*pStart = bat->adc_samples, num = 0;
 737         int level = bat->charge_level;
 738
 739
 740         value = bat->adc_val;
 741         adc_async_read(bat->client);
 742
 743         *(bat->pSamples++) = rk_adc_voltage(bat,value);
 744
 745         bat->bat_status_cnt++;
 746         if (bat->bat_status_cnt > NUM_VOLTAGE_SAMPLE)  bat->bat_status_cnt = NUM_VOLTAGE_SAMPLE + 1;
 747
 748         num = bat->pSamples - pStart;
 749
 750         if (num >= NUM_VOLTAGE_SAMPLE){
 751                 bat ->pSamples = pStart;
 752                 num = NUM_VOLTAGE_SAMPLE;
 753
 754         }
 755
 756         value = 0;
 757         for (i = 0; i < num; i++){
 758                 value += bat->adc_samples[i];
 759         }
 760         bat->bat_voltage = value / num;
 761
 762         /*handle  ripple */
 763         if(battery_test_flag == 0)
 764         {
 765                 if(0 == bat->pdata->use_board_table){
 766                         if(1 == level){
 767                                 if(bat->bat_voltage >= batt_table[2*BATT_NUM +5]+ 10)
 768                                         bat->bat_voltage = batt_table[2*BATT_NUM +5]  + 10;
 769                                 else if(bat->bat_voltage <= batt_table[BATT_NUM +6]  - 10)
 770                                         bat->bat_voltage =  batt_table[BATT_NUM +6] - 10;
 771                         }
 772                         else{
 773                                 if(bat->bat_voltage >= batt_table[BATT_NUM +5]+ 10)
 774                                         bat->bat_voltage = batt_table[BATT_NUM +5]  + 10;
 775                                 else if(bat->bat_voltage <= batt_table[6]  - 10)
 776                                         bat->bat_voltage =  batt_table[6] - 10;
 777                         }
 778                 }else{
 779                         rk_handle_ripple(bat, level);
 780                 }
 781
 782         }else if(battery_test_flag == 2){
 783
 784                 if(batt_table[3] == 0){
 785                         if(bat->bat_voltage < 3400){
 786                                 if((get_seconds() - gSecondsCnt) > 30){
 787                                         gSecondsCnt = get_seconds();
 788                                         if((gVoltageCnt - bat->bat_voltage) > 15){
 789                                                 strncpy(gDischargeFlag, "off" ,3);
 790                                         }
 791                                         gVoltageCnt = bat->bat_voltage;
 792
 793                                 }
 794                         }
 795
 796                         if(bat->bat_voltage < 3400){
 797                                 bat->bat_voltage = 3400;
 798                         }
 799                 }
 800                 else{
 801                         if(bat->bat_voltage < 6800){
 802                                 if((get_seconds() - gSecondsCnt) > 30){
 803                                         gSecondsCnt = get_seconds();
 804                                         if((gDoubleVoltageCnt - bat->bat_voltage) > 30){
 805                                                 strncpy(gDischargeFlag, "off" ,3);
 806                                         }
 807                                         gDoubleVoltageCnt =bat->bat_voltage;
 808                                 }
 809                         }
 810                         if(bat->bat_voltage < 6800){
 811                                 bat->bat_voltage = 6800;
 812                         }
 813                 }
 814         }
 815 }
 816
 817 static int rk30_adc_battery_voltage_to_capacity(struct rk30_adc_battery_data *bat, int BatVoltage)
 818 {
 819         int i = 0;
 820         int capacity = 0;
 821
 822         int  *p;
 823         if (bat->pdata->use_board_table)
 824                 p = bat->pdata->board_batt_table;
 825         else
 826                 p = batt_table;
 827
 828         if (1 == bat->charge_level){  //charge
 829                 if(0 == bat->start_voltage_status ){
 830                         if(BatVoltage >= (p[2*BATT_NUM +5])){
 831                                 capacity = 100;
 832                         }
 833                         else{
 834                                 if(BatVoltage <= (p[BATT_NUM +6])){
 835                                         capacity = 0;
 836                                 }
 837                                 else{
 838                                         for(i = BATT_NUM +6; i <2*BATT_NUM +5; i++){
 839
 840                                                 if(((p[i]) <= BatVoltage) && (BatVoltage <  (p[i+1]))){
 841
 842                                                                 capacity = (i-(BATT_NUM +6))*10 + ((BatVoltage - p[i]) *  10)/ (p[i+1]- p[i]);
 843                                                         break;
 844                                                 }
 845                                         }
 846                                 }
 847                         }
 848                 }
 849                 else{
 850
 851                         DBG("start_voltage=%d,start_capacity =%d\n", bat->charge_start_voltage, bat->charge_start_capacity);
 852                         DBG("charge_down_proportion =%d,charge_up_proprotion=%d\n",bat ->charge_down_proportion,bat ->charge_up_proprotion);
 853                                 if(BatVoltage >= (p[2*BATT_NUM +5])){
 854                                         capacity = 100;
 855                                 }else{
 856
 857                                         if(BatVoltage <= (p[BATT_NUM +6])){
 858                                                 capacity = 0;
 859                                                 }else{
 860
 861                                                         if(BatVoltage <bat->charge_start_voltage){
 862                                                                 for(i = BATT_NUM +6; i <2*BATT_NUM +5; i++)
 863                                                                         if(((p[i]) <= BatVoltage) && (BatVoltage <  (p[i+1]))){
 864                                                                                 if( p[i+1] < bat->charge_start_voltage ){
 865                                                                                         capacity =(i-(BATT_NUM +6))*(bat ->charge_down_proportion) + ((BatVoltage - p[i]) *  bat ->charge_down_proportion)/ (p[i+1]- p[i]);
 866                                                                                 }
 867                                                                                 else {
 868                                                                                         capacity = (i-(BATT_NUM +6))*(bat ->charge_down_proportion) + ((BatVoltage - p[i]) *  bat ->charge_down_proportion)/ (bat->charge_start_voltage - p[i]);
 869                                                                                 }
 870                                                                                 break;
 871                                                                         }
 872
 873
 874                                                         }else{
 875
 876                                                                         if(BatVoltage > bat->charge_start_voltage){
 877                                                                                 for(i = BATT_NUM +6; i <2*BATT_NUM +5; i++)
 878                                                                                         if(((p[i]) <= BatVoltage) && (BatVoltage <  (p[i+1]))){
 879                                                                                                 if( p[i] > bat->charge_start_voltage ){
 880                                                                                                         capacity = bat->charge_start_capacity + (i - (BATT_NUM +6)-bat->charge_start_capacity/10)*(bat ->charge_up_proprotion) + ((BatVoltage - p[i]) *  bat ->charge_up_proprotion)/ (p[i+1]- p[i]);
 881                                                                                                 }
 882                                                                                                 else {
 883                                                                                                        capacity = bat->charge_start_capacity + (i - (BATT_NUM +6)-bat->charge_start_capacity/10)*(bat ->charge_up_proprotion) + ((BatVoltage - p[i]) *  bat ->charge_up_proprotion)/ (p[i+1] - bat->charge_start_voltage );
 884                                                                                                         }
 885                                                                                                 break;
 886                                                                                         }
 887
 888                                                                         }else{
 889
 890                                                                                 if(BatVoltage  ==  bat->charge_start_voltage)
 891                                                                                         capacity = bat ->charge_start_capacity;
 892                                                                                 }
 893                                                                 }
 894                                                         }
 895                                         }
 896
 897                         }
 898
 899                 }
 900                 else{  //discharge
 901                         if(BatVoltage >= (p[BATT_NUM +5])){
 902                                 capacity = 100;
 903                         }
 904                         else{
 905                                 if(BatVoltage <= (p[6])){
 906                                         capacity = 0;
 907                                 }
 908                                 else{
 909                                         for(i = 6; i < BATT_NUM +5; i++){
 910                                                 if(((p[i]) <= BatVoltage) && (BatVoltage < (p[i+1]))){
 911                                                         capacity = (i-6)*10+ ((BatVoltage - p[i]) *10 )/ (p[i+1]- p[i]) ;
 912                                                         break;
 913                                                 }
 914                                         }
 915                                 }
 916
 917                         }
 918
 919
 920                 }
 921
 922         DBG("real_voltage_to_capacity =%d\n" ,capacity);
 923     return capacity;
 924 }
 925
 926 static void rk_usb_charger(struct rk30_adc_battery_data *bat)
 927 {
 928
 929         int capacity = 0;
 930 //      struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 931         int timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE;
 932         int timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE;
 933
 934         if((1 == bat ->charge_level)&&( 0 == bat ->start_voltage_status)){
 935                         bat ->charge_start_voltage = bat ->bat_voltage;
 936                         bat ->start_voltage_status = 1;
 937                         bat ->charge_start_capacity = bat ->bat_capacity;
 938                         bat ->charge_up_proprotion = (100 - bat ->charge_start_capacity)/10+1;
 939                         bat ->charge_down_proportion = bat ->charge_start_capacity/10+1;
 940         }
 941
 942         capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
 943
 944                 if (capacity > bat->bat_capacity){
 945                         if(capacity > bat->bat_capacity + 10 )
 946                                 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -10;  //5s
 947                         else if(capacity > bat->bat_capacity + 7 )
 948                                 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -5; //10s
 949                                 else if(capacity > bat->bat_capacity + 3 )
 950                                         timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE - 2; // 13
 951                         if (++(bat->gBatCapacityusbChargeCnt) >= timer_of_charge_sample){
 952                                 bat->gBatCapacityusbChargeCnt  = 0;
 953                                 if (bat->bat_capacity <= 99){
 954                                         bat->bat_capacity++;
 955                                         bat->bat_change  = 1;
 956                                 }
 957                         }
 958                         bat->gBatCapacityChargeCnt = 0;
 959                         bat ->gBatCapacityusbdisChargeCnt = 0;//get_suspend_state(void)
 960                 }else //if(( get_suspend_state() != PM_SUSPEND_MEM)&&(capacity < bat->bat_capacity)){
 961                 // if((gpio_get_value (bat->pdata->back_light_pin) == 1)&&(capacity < bat->bat_capacity)){
 962                 if((capacity < bat->bat_capacity)){
 963                                 DBG("USB CHARGE DOWN\n");
 964
 965                 //      if (capacity < bat->bat_capacity){
 966                                 if(capacity <10){
 967                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 40; // 13
 968                                 }else if(capacity < 20){
 969                                         if(capacity + 3 > bat->bat_capacity  )
 970                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -5;  //5s
 971                                         else if(capacity  + 7 > bat->bat_capacity )
 972                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -10; //10s
 973                                         else if(capacity  + 10> bat->bat_capacity )
 974                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -25; // 13
 975                                         else
 976                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 35; // 13
 977                                 }else{
 978                                         if(capacity + 3 > bat->bat_capacity  )
 979                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -5;  //5s
 980                                         else if(capacity  + 7 > bat->bat_capacity )
 981                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -10; //10s
 982                                         else if(capacity  + 10> bat->bat_capacity )
 983                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 15; // 13
 984                                         else
 985                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 20; // 13
 986                         }
 987
 988                                 if (++(bat->gBatCapacityusbdisChargeCnt) >= timer_of_discharge_sample){
 989                                         bat->gBatCapacityusbdisChargeCnt = 0;
 990                                         if (bat->bat_capacity > 0){
 991                                                 bat->bat_capacity-- ;
 992                                                 bat->bat_change  = 1;
 993                                         }
 994                                 }
 995
 996                         //}
 997                         bat->gBatCapacityusbChargeCnt  = 0;
 998
 999                 }
1000                 else //if(get_suspend_state() == PM_SUSPEND_MEM){
1001                         //if(gpio_get_value (bat->pdata->back_light_pin) == 0){
1002                         {
1003
1004
1005                         bat->gBatCapacityusbdisChargeCnt = 0;
1006                         // (bat->gBatCapacityusbChargeCnt)++;
1007                         if( is_charge_ok(bat) != INVALID_CHARGE_CHECK){
1008                                 if( is_charge_ok(bat) == CHARGE_IS_OK){
1009
1010                                         if (++bat->gBatCapacityusbChargeCnt >= timer_of_charge_sample-30){
1011                                                 bat->gBatCapacityusbChargeCnt = 0;
1012                                                         if (bat->bat_capacity <= 99){
1013                                                                 bat->bat_capacity++;
1014                                                                 bat->bat_change  = 1;
1015                                                         }
1016                                         }
1017                                 }else{
1018                                                 if (capacity > bat->capacitytmp){
1019                                                         bat->gBatCapacityChargeCnt = 0;
1020                                                 }else{
1021
1022                                                         if ((bat->bat_capacity >= 85) &&((bat->gBatCapacityChargeCnt) > NUM_CHARGE_MAX_SAMPLE)){
1023                                                                 bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
1024
1025                                                                 if (bat->bat_capacity < 99){
1026                                                                         bat->bat_capacity++;
1027                                                                         bat->bat_change  = 1;
1028                                                                 }
1029                                                         }
1030                                                 }
1031                                         }
1032
1033                                 }
1034                                 else{
1035                                         if (capacity > bat->capacitytmp){
1036                                                         bat->gBatCapacityChargeCnt = 0;
1037                                         }else{
1038                                                 if ((bat->bat_capacity >= 85) &&(bat->gBatCapacityusbChargeCnt > NUM_CHARGE_MAX_SAMPLE)){
1039                                                         bat->gBatCapacityusbChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
1040                                                                 if (bat->bat_capacity <= 99){
1041                                                                         bat->bat_capacity++;
1042                                                                         bat->bat_change  = 1;
1043                                                         }
1044                                                 }
1045                                         }
1046                         }
1047
1048                 }
1049                 bat->capacitytmp = capacity;
1050
1051 }
1052 static void rk_ac_charger(struct rk30_adc_battery_data *bat)
1053 {
1054         int capacity = 0;
1055         int timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE;
1056
1057         if((1 == bat->charge_level)&&( 0 == bat->start_voltage_status)){
1058                 bat->charge_start_voltage = bat->bat_voltage;
1059                 bat->start_voltage_status = 1;
1060                 bat->charge_start_capacity = bat->bat_capacity;
1061                 bat ->charge_up_proprotion = (100 - bat ->charge_start_capacity)/10+1;
1062                 bat ->charge_down_proportion = bat ->charge_start_capacity/10+1;
1063         }
1064         capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
1065                 if (capacity > bat->bat_capacity){
1066                         if(capacity > bat->bat_capacity + 10 )
1067                                 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -10;  //5s
1068                         else if(capacity > bat->bat_capacity + 7 )
1069                                 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -5; //10s
1070                                 else if(capacity > bat->bat_capacity + 3 )
1071                                         timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE - 2; // 13
1072                         if (++(bat->gBatCapacityacChargeCnt) >= timer_of_charge_sample){
1073                                 bat->gBatCapacityacChargeCnt  = 0;
1074                                 if (bat->bat_capacity <= 99){
1075                                         bat->bat_capacity++;
1076                                         bat->bat_change  = 1;
1077                                 }
1078                         }
1079                         bat->gBatCapacityChargeCnt = 0;
1080                 }
1081                 else{
1082                             bat->gBatCapacityacChargeCnt = 0;
1083                             (bat->gBatCapacityChargeCnt)++;
1084                                 if( is_charge_ok(bat) != INVALID_CHARGE_CHECK){
1085                                         if( is_charge_ok(bat) == CHARGE_IS_OK){
1086                                                 if (bat->gBatCapacityChargeCnt >= timer_of_charge_sample){
1087                                                         bat->gBatCapacityChargeCnt = 0;
1088                                                         if (bat->bat_capacity < 99){
1089                                                                 bat->bat_capacity++;
1090                                                                 bat->bat_change  = 1;
1091                                                         }
1092                                                 }
1093                                         }else{
1094                                                 if (capacity > bat->capacitytmp){
1095                                                         bat->gBatCapacityChargeCnt = 0;
1096                                                 }
1097                                                 else{
1098
1099                                                         if ((bat->bat_capacity >= 85) &&((bat->gBatCapacityChargeCnt) > NUM_CHARGE_MAX_SAMPLE)){
1100                                                                 bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
1101
1102                                                                 if (bat->bat_capacity < 99){
1103                                                                         bat->bat_capacity++;
1104                                                                         bat->bat_change  = 1;
1105                                                                 }
1106                                                         }
1107                                                 }
1108                                         }
1109
1110                         }else{
1111                                 if (capacity > bat->capacitytmp){
1112                                         bat->gBatCapacityChargeCnt = 0;
1113                                 }
1114                                 else{
1115
1116                                         if ((bat->bat_capacity >= 85) &&(bat->gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)){
1117                                                 bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
1118
1119                                                 if (bat->bat_capacity <= 99){
1120                                                         bat->bat_capacity++;
1121                                                         bat->bat_change  = 1;
1122                                                 }
1123                                         }
1124                                 }
1125
1126
1127                         }
1128                 }
1129                 bat->capacitytmp = capacity;
1130 }
1131 static void rk_battery_charger(struct rk30_adc_battery_data *bat)
1132 {
1133
1134         int capacity = 0;
1135         int timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE;
1136
1137         capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
1138
1139                 if (capacity < bat->bat_capacity){
1140                                 if(capacity <10){
1141                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 40; // 13
1142                                 }else if(capacity < 20){
1143                                         if(capacity + 3 > bat->bat_capacity  )
1144                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -5;  //5s
1145                                         else if(capacity  + 7 > bat->bat_capacity )
1146                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -10; //10s
1147                                         else if(capacity  + 10> bat->bat_capacity )
1148                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -25; // 13
1149                                         else
1150                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 35; // 13
1151                                 }else{
1152                                         if(capacity + 3 > bat->bat_capacity  )
1153                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -5;  //5s
1154                                         else if(capacity  + 7 > bat->bat_capacity )
1155                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -10; //10s
1156                                         else if(capacity  + 10> bat->bat_capacity )
1157                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 15; // 13
1158                                         else
1159                                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 20; // 13
1160
1161                         }
1162                         if (++(bat->gBatCapacityDisChargeCnt) >= timer_of_discharge_sample){
1163                                 bat->gBatCapacityDisChargeCnt = 0;
1164                                 if (bat->bat_capacity > 0){
1165                                         bat->bat_capacity-- ;
1166                                         bat->bat_change  = 1;
1167                                 }
1168                         }
1169                 }
1170                 else{
1171                         bat->gBatCapacityDisChargeCnt = 0;
1172                 }
1173                 bat->gBatCapacityChargeCnt = 0;
1174                 bat->gBatCapacityusbdisChargeCnt=0 ;
1175                 bat->gBatCapacityusbChargeCnt =0;
1176                 bat->gBatCapacityacChargeCnt = 0;
1177                 bat->start_voltage_status = 0;
1178
1179                 bat->capacitytmp = capacity;
1180
1181
1182
1183 }
1184
1185 static void rk30_adc_battery_capacity_samples(struct rk30_adc_battery_data *bat)
1186 {
1187 //      int capacity = 0;
1188 //      int timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE;
1189         int timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE;
1190
1191         if (bat->bat_status_cnt < NUM_VOLTAGE_SAMPLE)  {
1192                 bat->gBatCapacityDisChargeCnt = 0;
1193                 bat->gBatCapacityChargeCnt    = 0;
1194                 bat->gBatCapacityacChargeCnt = 0;
1195                 return;
1196         }
1197
1198         if(1 == bat->charge_level){
1199 #if  defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1200                 if(1 == bat->usb_charging)
1201                         rk_usb_charger(bat);
1202                 else
1203                         rk_ac_charger(bat);
1204 #else
1205                 rk_ac_charger(bat);
1206 #endif
1207         }else{
1208                 rk_battery_charger(bat);
1209
1210         }
1211
1212 }
1213
1214 //static int poweron_check = 0;
1215 static void rk30_adc_battery_poweron_capacity_check(struct rk30_adc_battery_data *bat)
1216 {
1217
1218         int new_capacity, old_capacity;
1219          int cnt = 50 ;
1220
1221         new_capacity = bat ->bat_capacity;
1222 //#if  defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1223 //      if(dwc_vbus_status() != 0)
1224 //              bat ->bat_status = POWER_SUPPLY_STATUS_CHARGING; // add for charging.
1225 //#endif
1226
1227         while( cnt -- ){
1228             old_capacity = rk30_adc_battery_load_capacity();
1229             if( old_capacity >= 0 ){
1230                 break ;
1231             }
1232             msleep(100);
1233         }
1234
1235         if ((old_capacity < 0) || (old_capacity > 100)){
1236                 old_capacity = new_capacity;
1237         }
1238
1239         if (bat ->bat_status == POWER_SUPPLY_STATUS_FULL){
1240                 if (new_capacity > 80){
1241                         bat ->bat_capacity = 100;
1242                 }
1243         }
1244         else if (bat ->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING){
1245         //chargeing state
1246
1247                 if( bat  ->pdata->is_reboot_charging == 1)
1248                         bat ->bat_capacity = (old_capacity < 10) ?(old_capacity+2):old_capacity;
1249                 else
1250                         bat ->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
1251         }else{
1252                 if(new_capacity > old_capacity + 50 )
1253                         bat ->bat_capacity = new_capacity;
1254                 else
1255                         bat ->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity;  //avoid the value of capacity increase
1256         }
1257
1258
1259         bat ->bat_change = 1;
1260 }
1261 #define to_battery_usb_device_info(x) container_of((x), \
1262                 struct rk30_adc_battery_data, usb);
1263
1264 static int rk30_adc_battery_get_usb_property(struct power_supply *psy,
1265                                     enum power_supply_property psp,
1266                                     union power_supply_propval *val)
1267 {
1268         struct rk30_adc_battery_data *bat=  to_battery_usb_device_info(psy);
1269
1270         switch (psp) {
1271                 case POWER_SUPPLY_PROP_ONLINE:
1272                         if (psy->type == POWER_SUPPLY_TYPE_USB){
1273                                 val->intval = bat ->usb_charging;
1274                                 if( 1 == bat->charge_full_flag)
1275                                         val->intval = 0;
1276
1277                         }
1278                         break;
1279
1280                 default:
1281                         return -EINVAL;
1282         }
1283
1284         return 0;
1285
1286 }
1287
1288 static enum power_supply_property rk30_adc_battery_usb_props[] = {
1289
1290         POWER_SUPPLY_PROP_ONLINE,
1291 };
1292
1293 static struct power_supply rk30_usb_supply =
1294 {
1295         .name = "usb",
1296         .type = POWER_SUPPLY_TYPE_USB,
1297
1298         .get_property   = rk30_adc_battery_get_usb_property,
1299
1300         .properties     = rk30_adc_battery_usb_props,
1301         .num_properties = ARRAY_SIZE(rk30_adc_battery_usb_props),
1302 };
1303
1304 static irqreturn_t rk30_adc_battery_dc_wakeup(int irq, void *dev_id)
1305 {
1306         disable_irq_nosync(irq);
1307         queue_work(gBatteryData->wq, &gBatteryData->dcwakeup_work);
1308         return IRQ_HANDLED;
1309 }
1310
1311 #define to_battery_ac_device_info(x) container_of((x), \
1312                 struct rk30_adc_battery_data, ac);
1313
1314 static int rk30_adc_battery_get_ac_property(struct power_supply *psy,
1315                         enum power_supply_property psp,
1316                         union power_supply_propval *val)
1317 {
1318         int ret;
1319
1320         struct rk30_adc_battery_data *bat = to_battery_ac_device_info(psy);
1321
1322         switch (psp) {
1323         case POWER_SUPPLY_PROP_ONLINE:
1324                 if (psy->type == POWER_SUPPLY_TYPE_MAINS){
1325                         val->intval = bat ->ac_charging;
1326                         if (strstr(saved_command_line,"charger")  == NULL ){
1327                                 if( 1 == bat->charge_full_flag)
1328                                         val->intval = 0;
1329                         }
1330                 }
1331                 break;
1332
1333         default:
1334                 ret = -EINVAL;
1335                 break;
1336         }
1337
1338         return 0;
1339 }
1340
1341 static enum power_supply_property rk30_adc_battery_ac_props[] =
1342 {
1343         POWER_SUPPLY_PROP_ONLINE,
1344 };
1345
1346 static struct power_supply rk30_ac_supply =
1347 {
1348         .name = "ac",
1349         .type = POWER_SUPPLY_TYPE_MAINS,
1350
1351         .get_property   = rk30_adc_battery_get_ac_property,
1352
1353         .properties     = rk30_adc_battery_ac_props,
1354         .num_properties = ARRAY_SIZE(rk30_adc_battery_ac_props),
1355 };
1356 static void rk30_adc_battery_dcdet_delaywork(struct work_struct *work)
1357 {
1358
1359         int ret;
1360         struct rk30_adc_battery_platform_data *pdata;
1361         int irq;
1362         int irq_flag;
1363         struct rk30_adc_battery_data  *bat = container_of((work), \
1364                 struct rk30_adc_battery_data, dcwakeup_work);
1365
1366         rk28_send_wakeup_key(); // wake up the system
1367
1368
1369         pdata    = bat->pdata;
1370         irq        = gpio_to_irq(pdata->dc_det_pin);
1371         free_irq(irq, NULL);
1372         msleep(10);
1373         irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1374         ret = request_irq(irq, rk30_adc_battery_dc_wakeup, irq_flag, "ac_charge_irq", NULL);// reinitialize the DC irq
1375         if (ret) {
1376                 free_irq(irq, NULL);
1377         }
1378
1379         power_supply_changed(&bat ->ac);
1380
1381         bat ->bat_status_cnt = 0;        //the state of battery is change
1382
1383 }
1384
1385
1386 static int rk30_adc_battery_get_status(struct rk30_adc_battery_data *bat)
1387 {
1388         return (bat->bat_status);
1389 }
1390
1391 static int rk30_adc_battery_get_health(struct rk30_adc_battery_data *bat)
1392 {
1393         return POWER_SUPPLY_HEALTH_GOOD;
1394 }
1395
1396 static int rk30_adc_battery_get_present(struct rk30_adc_battery_data *bat)
1397 {
1398         return (bat->bat_voltage < BATT_MAX_VOL_VALUE) ? 0 : 1;
1399 }
1400
1401 static int rk30_adc_battery_get_voltage(struct rk30_adc_battery_data *bat)
1402 {
1403         return (bat->bat_voltage );
1404 }
1405
1406 static int rk30_adc_battery_get_capacity(struct rk30_adc_battery_data *bat)
1407 {
1408         return (bat->bat_capacity);
1409 }
1410
1411 static int rk30_adc_battery_get_property(struct power_supply *psy,
1412                                  enum power_supply_property psp,
1413                                  union power_supply_propval *val)
1414 {
1415         int ret = 0;
1416         struct rk30_adc_battery_data  *bat = container_of((psy), \
1417                         struct rk30_adc_battery_data, bat);
1418         switch (psp) {
1419                 case POWER_SUPPLY_PROP_STATUS:
1420                         val->intval = rk30_adc_battery_get_status(bat);
1421                         DBG("gBatStatus=%d\n",val->intval);
1422                         break;
1423                 case POWER_SUPPLY_PROP_HEALTH:
1424                         val->intval = rk30_adc_battery_get_health(bat);
1425                         DBG("gBatHealth=%d\n",val->intval);
1426                         break;
1427                 case POWER_SUPPLY_PROP_PRESENT:
1428                         val->intval = rk30_adc_battery_get_present(bat);
1429                         DBG("gBatPresent=%d\n",val->intval);
1430                         break;
1431                 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1432                         val ->intval = rk30_adc_battery_get_voltage(bat);
1433                         DBG("gBatVoltage=%d\n",val->intval);
1434                         break;
1435                 case POWER_SUPPLY_PROP_CAPACITY:
1436                         if(battery_test_flag == 2)
1437                                 val->intval = 50;
1438                         else
1439                                 val->intval = rk30_adc_battery_get_capacity(bat);
1440                         DBG("gBatCapacity=%d%%\n",val->intval);
1441                         break;
1442                 case POWER_SUPPLY_PROP_TECHNOLOGY:
1443                         val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
1444                         break;
1445                 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
1446                         val->intval = BATT_MAX_VOL_VALUE;
1447                         break;
1448                 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
1449                         val->intval = BATT_ZERO_VOL_VALUE;
1450                         break;
1451                 default:
1452                         ret = -EINVAL;
1453                         break;
1454         }
1455
1456         return ret;
1457 }
1458
1459 static enum power_supply_property rk30_adc_battery_props[] = {
1460
1461         POWER_SUPPLY_PROP_STATUS,
1462         POWER_SUPPLY_PROP_HEALTH,
1463         POWER_SUPPLY_PROP_PRESENT,
1464         POWER_SUPPLY_PROP_VOLTAGE_NOW,
1465         POWER_SUPPLY_PROP_TECHNOLOGY,
1466         POWER_SUPPLY_PROP_CAPACITY,
1467         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
1468         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
1469 };
1470
1471 static struct power_supply rk30_battery_supply =
1472 {
1473         .name = "battery",
1474         .type = POWER_SUPPLY_TYPE_BATTERY,
1475
1476         .get_property   = rk30_adc_battery_get_property,
1477
1478         .properties     = rk30_adc_battery_props,
1479         .num_properties = ARRAY_SIZE(rk30_adc_battery_props),
1480 };
1481
1482 #ifdef CONFIG_PM
1483 static void rk30_adc_battery_resume_check(struct rk30_adc_battery_data *bat)
1484 {
1485         int i;
1486         int level,oldlevel;
1487         int new_capacity, old_capacity;
1488 //      struct rk30_adc_battery_data *bat = gBatteryData;
1489
1490         bat ->old_charge_level = -1;
1491         bat ->pSamples = bat->adc_samples;
1492
1493         adc_sync_read(bat->client);                             //start adc sample
1494         level = oldlevel =  rk_battery_get_status(bat);//rk30_adc_battery_status_samples(bat);//init charge status
1495
1496         for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++) {               //0.3 s
1497
1498                 mdelay(1);
1499                 rk30_adc_battery_voltage_samples(bat);              //get voltage
1500                 level =          rk_battery_get_status(bat);// rk30_adc_battery_status_samples(bat);       //check charge status
1501                 if (oldlevel != level){
1502                     oldlevel = level;                               //if charge status changed, reset sample
1503                     i = 0;
1504                 }
1505         }
1506         new_capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
1507         old_capacity =bat-> suspend_capacity;
1508
1509         //if (bat->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING){
1510         if( 1 == level ){
1511         //chargeing state
1512                 bat->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
1513         }
1514         else{
1515                 bat->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity;  // aviod the value of capacity increase    dicharge
1516         }
1517
1518 }
1519
1520 static int rk30_adc_battery_suspend(struct platform_device *dev, pm_message_t state)
1521 {
1522         int irq;
1523         struct rk30_adc_battery_data *data = platform_get_drvdata(dev);
1524
1525         data ->suspend_capacity = data->bat_capacity;
1526         data ->suspend_time = get_seconds();
1527         cancel_delayed_work(&data ->delay_work);
1528
1529         if( data ->pdata->batt_low_pin != INVALID_GPIO){
1530
1531                 irq = gpio_to_irq(data ->pdata->batt_low_pin);
1532                 enable_irq(irq);
1533                 enable_irq_wake(irq);
1534         }
1535
1536         return 0;
1537 }
1538
1539 static int rk30_adc_battery_resume(struct platform_device *dev)
1540 {
1541         int irq;
1542         struct rk30_adc_battery_data *data = platform_get_drvdata(dev);
1543         data ->resume_time = get_seconds();
1544         data ->resume = true;
1545         queue_delayed_work(data->wq, &data ->delay_work, msecs_to_jiffies(100));
1546         if( data ->pdata->batt_low_pin != INVALID_GPIO){
1547
1548                 irq = gpio_to_irq(data ->pdata ->batt_low_pin);
1549                 disable_irq_wake(irq);
1550                 disable_irq(irq);
1551         }
1552         return 0;
1553 }
1554 #else
1555 #define rk30_adc_battery_suspend NULL
1556 #define rk30_adc_battery_resume NULL
1557 #endif
1558
1559
1560 unsigned long AdcTestCnt = 0;
1561 static void rk30_adc_battery_timer_work(struct work_struct *work)
1562 {
1563 struct rk30_adc_battery_data  *bat = container_of((work), \
1564                 struct rk30_adc_battery_data, delay_work);
1565
1566 #ifdef CONFIG_PM
1567         if (bat ->resume) {
1568                 if( (bat->resume_time - bat->suspend_time) >= 1800 )
1569                         rk30_adc_battery_resume_check(bat);
1570                 else
1571                         bat->bat_capacity = bat->suspend_capacity;
1572                 bat ->resume = false;
1573                 bat ->bat_change =1;
1574         }
1575 #endif
1576
1577         if (bat ->poweron_check){
1578                 bat ->poweron_check = 0;
1579                 rk30_adc_battery_poweron_capacity_check(bat);
1580         }
1581
1582         bat ->charge_level = rk_battery_get_status(bat);
1583         rk30_adc_battery_status_samples(bat);
1584         rk30_adc_battery_voltage_samples(bat);
1585         rk30_adc_battery_capacity_samples(bat);
1586
1587         if( 0 == bat ->pdata ->charging_sleep){
1588                 if( 1 == bat->charge_level){  // charge
1589                         if(0 == bat->status_lock ){
1590                                 wake_lock(&batt_wake_lock);  //lock
1591                                 bat ->status_lock = 1;
1592                         }
1593                 }
1594                 else{
1595                         if(1 == bat ->status_lock ){
1596                                 wake_unlock(&batt_wake_lock);  //unlock
1597                                 bat ->status_lock = 0;
1598                         }
1599
1600                 }
1601         }
1602
1603         /*update battery parameter after adc and capacity has been changed*/
1604         if(bat ->bat_change){
1605                 bat ->bat_change= 0;
1606                 if(0 == bat ->bat_capacity){
1607                         bat ->ac_charging = 0;
1608                         bat ->usb_charging = 0;
1609
1610                 }
1611                 rk30_adc_battery_put_capacity(bat ->bat_capacity);
1612                 power_supply_changed(&bat ->bat);
1613                 power_supply_changed(&bat ->ac);
1614 #if  defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1615                 power_supply_changed(&bat ->usb);
1616 #endif
1617
1618         }
1619
1620         //if (rk30_battery_dbg_level){
1621                 if (++AdcTestCnt >= 2)
1622                         {
1623                         AdcTestCnt = 0;
1624
1625                         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",
1626                         bat ->bat_status, bat ->adc_val, rk_adc_voltage(bat, bat ->adc_val),
1627                         bat ->bat_voltage, bat ->bat_capacity, bat ->capacitytmp, bat ->gBatCapacityDisChargeCnt, bat ->gBatCapacityChargeCnt,
1628                         bat ->gBatCapacityacChargeCnt, bat ->gBatCapacityusbChargeCnt, bat ->gBatCapacityusbdisChargeCnt);
1629
1630                 }
1631         //}
1632         queue_delayed_work(bat ->wq, &bat ->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS));
1633
1634 }
1635
1636
1637 static int rk30_adc_battery_io_init(struct rk30_adc_battery_platform_data *pdata)
1638 {
1639         int ret = 0;
1640
1641         if (pdata->io_init) {
1642                 pdata->io_init();
1643                 return 0;
1644         }
1645
1646         //charge control pin
1647         if (pdata->charge_set_pin != INVALID_GPIO){
1648                 ret = gpio_request(pdata->charge_set_pin, NULL);
1649                 if (ret) {
1650                         printk("failed to request dc_det gpio\n");
1651                         goto error;
1652                         }
1653                 gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
1654         }
1655
1656         //dc charge detect pin
1657         if (pdata->dc_det_pin != INVALID_GPIO){
1658                 ret = gpio_request(pdata->dc_det_pin, NULL);
1659                 if (ret) {
1660                         printk("failed to request dc_det gpio\n");
1661                         goto error;
1662                 }
1663
1664                 gpio_pull_updown(pdata->dc_det_pin, GPIOPullUp);//important
1665                 ret = gpio_direction_input(pdata->dc_det_pin);
1666                 if (ret) {
1667                         printk("failed to set gpio dc_det input\n");
1668                         goto error;
1669                 }
1670         }
1671
1672         //charge ok detect
1673         if (pdata->charge_ok_pin != INVALID_GPIO){
1674                 ret = gpio_request(pdata->charge_ok_pin, NULL);
1675                 if (ret) {
1676                         printk("failed to request charge_ok gpio\n");
1677                         goto error;
1678                 }
1679
1680                 gpio_pull_updown(pdata->charge_ok_pin, GPIOPullUp);//important
1681                 ret = gpio_direction_input(pdata->charge_ok_pin);
1682                 if (ret) {
1683                         printk("failed to set gpio charge_ok input\n");
1684                         goto error;
1685                 }
1686         }
1687         //batt low pin
1688         if( pdata->batt_low_pin != INVALID_GPIO){
1689                 ret = gpio_request(pdata->batt_low_pin, NULL);
1690                 if (ret) {
1691                         printk("failed to request batt_low_pin gpio\n");
1692                         goto error;
1693                 }
1694
1695                 gpio_pull_updown(pdata->batt_low_pin, GPIOPullUp);
1696                 ret = gpio_direction_input(pdata->batt_low_pin);
1697                 if (ret) {
1698                         printk("failed to set gpio batt_low_pin input\n");
1699                         goto error;
1700                 }
1701         }
1702
1703         return 0;
1704 error:
1705         return -1;
1706 }
1707
1708 extern void kernel_power_off(void);
1709 int get_battery_status(void)
1710 {
1711         return system_lowerpower;
1712 }
1713 static void rk30_adc_battery_check(struct rk30_adc_battery_data *bat)
1714 {
1715         int i;
1716         int level,oldlevel;
1717         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
1718
1719 //      pSamples = bat->adc_samples;
1720
1721         adc_sync_read(bat->client);                             //start adc sample
1722         level = oldlevel =       rk_battery_get_status(bat);// rk30_adc_battery_status_samples(bat);//init charge status
1723
1724         for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++){                //0.3 s
1725                 mdelay(1);
1726                 rk30_adc_battery_voltage_samples(bat);              //get voltage
1727                 //level = rk30_adc_battery_status_samples(bat);       //check charge status
1728                 level = rk_battery_get_status(bat);
1729
1730                 if (oldlevel != level){
1731                         oldlevel = level;                               //if charge status changed, reset sample
1732                         i = 0;
1733                 }
1734                 bat->charge_level = level;
1735         }
1736
1737
1738         bat->bat_capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);  //init bat_capacity
1739
1740         if((1 == level)&&(0 == bat->start_voltage_status )){
1741                         bat->charge_start_voltage = bat->bat_voltage;
1742                         bat->start_voltage_status = 1;
1743                         bat->charge_start_capacity = bat->bat_capacity;
1744                         bat ->charge_up_proprotion = (100 - bat ->charge_start_capacity)/10+1;
1745                         bat ->charge_down_proportion = bat ->charge_start_capacity/10+1;
1746         }
1747
1748         if (get_ac_status(bat) || dwc_otg_check_dpdm() ){
1749                 if (is_charge_ok(bat)  == 1){
1750                         bat->bat_status = POWER_SUPPLY_STATUS_FULL;
1751                         bat->bat_capacity = 100;
1752                 }
1753 #if  defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1754                 if( 0 != dwc_otg_check_dpdm() )
1755                         bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
1756                 if(dwc_otg_check_dpdm() == 0){
1757                         bat->usb_charging = 0;
1758                 }else if(dwc_otg_check_dpdm() == 1){
1759                         bat->usb_charging = 1;
1760                         if(bat -> pdata ->control_usb_charging)
1761                                 bat -> pdata ->control_usb_charging(0);
1762                 }else if(dwc_otg_check_dpdm() == 2){
1763                         bat->usb_charging = 0;
1764                         bat -> ac_charging = 1;
1765                         if(bat -> pdata ->control_usb_charging)
1766                                 bat -> pdata ->control_usb_charging(1);
1767                 }
1768 #endif
1769                 if(1 == get_ac_status(bat)){
1770                         bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
1771                         bat -> ac_charging = 1;
1772                 }
1773                 power_supply_changed(&bat ->ac);
1774 #if  defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1775                 power_supply_changed(&bat ->usb);
1776 #endif
1777
1778         }
1779 #if 0
1780         if (bat->bat_capacity == 0) {
1781                 bat->bat_capacity = 1;
1782                 system_lowerpower = 1;
1783         }
1784 #endif
1785         if(0 !=bat ->pdata->low_voltage_protection ){
1786                 if((bat->bat_voltage <=  bat ->pdata->low_voltage_protection)&&(bat->bat_status != POWER_SUPPLY_STATUS_CHARGING))
1787                         system_lowerpower = 1;
1788         }else{
1789                 if((bat->bat_voltage <= BATT_ZERO_VOL_VALUE)&&(bat->bat_status != POWER_SUPPLY_STATUS_CHARGING))
1790                         system_lowerpower = 1;
1791
1792         }
1793 #if 1
1794                 if ((bat->bat_voltage <= BATT_ZERO_VOL_VALUE)&&(bat->bat_status != POWER_SUPPLY_STATUS_CHARGING)){
1795                         kernel_power_off();
1796                 }
1797 #endif
1798
1799 }
1800
1801 static void rk30_adc_battery_callback(struct adc_client *client, void *param, int result)
1802 {
1803         struct rk30_adc_battery_data  *bat = container_of((client), \
1804                                 struct rk30_adc_battery_data, client);
1805
1806         if (result < 0){
1807                 DBG("adc_battery_callback    resule < 0 , the value ");
1808                 return;
1809         }else{
1810                 gBatteryData->adc_val = result;
1811                 DBG("result = %d, gBatteryData->adc_val = %d\n", result, gBatteryData->adc_val );
1812         }
1813         return;
1814 }
1815
1816 static void rk30_adc_battery_lowerpower_delaywork(struct work_struct *work)
1817 {
1818         int irq;
1819
1820         struct rk30_adc_battery_data  *bat = container_of((work), \
1821                         struct rk30_adc_battery_data, lowerpower_work);
1822
1823         if( bat->pdata->batt_low_pin != INVALID_GPIO){
1824                 irq = gpio_to_irq(bat ->pdata ->batt_low_pin);
1825                 disable_irq(irq);
1826         }
1827
1828         printk("lowerpower\n");
1829         rk28_send_wakeup_key(); // wake up the system
1830         return;
1831 }
1832
1833
1834 static irqreturn_t rk30_adc_battery_low_wakeup(int irq,void *dev_id)
1835 {
1836         queue_work(gBatteryData->wq, &gBatteryData->lowerpower_work);
1837         return IRQ_HANDLED;
1838 }
1839
1840 static int rk30_adc_battery_probe(struct platform_device *pdev)
1841 {
1842         int    ret;
1843         int    irq;
1844         int    irq_flag;
1845         struct adc_client                   *client;
1846         struct rk30_adc_battery_data          *data;
1847         struct rk30_adc_battery_platform_data *pdata = pdev->dev.platform_data;
1848         gSecondsCnt = get_seconds();
1849         data = kzalloc(sizeof(*data), GFP_KERNEL);
1850         if (data == NULL) {
1851                 ret = -ENOMEM;
1852                 goto err_data_alloc_failed;
1853         }
1854         memset(data, 0, sizeof(struct rk30_adc_battery_data));
1855         gBatteryData = data;
1856
1857         platform_set_drvdata(pdev, data);
1858
1859         data->pdata = pdata;
1860         data->status_lock = 0;
1861         data->old_charge_level = -1;
1862         data->capacitytmp = 0;
1863         data->suspend_capacity = 0;
1864         data->ac_charging = 0;
1865         data->usb_charging = 0;
1866         data->full_times = 0;
1867         data->gBatCapacityDisChargeCnt =0;
1868         data->gBatCapacityChargeCnt=0;
1869         data->gBatCapacityusbdisChargeCnt=0 ;
1870         data->gBatCapacityusbChargeCnt =0;
1871         data->gBatCapacityacChargeCnt = 0;
1872         data->charge_source_now = 0;
1873         data->charge_soure_old = 0;
1874         data->start_voltage_status = 0;
1875         data->charge_full_flag =0;
1876         data->pSamples = data->adc_samples;
1877
1878         data->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1879         wake_lock_init(&batt_wake_lock, WAKE_LOCK_SUSPEND, "batt_lock");
1880         wake_lock_init(&charge_display_lock, WAKE_LOCK_SUSPEND, "charge_display_lock"); //charge_display_lock
1881
1882         ret = rk30_adc_battery_io_init(pdata);
1883          if (ret) {
1884                 ret = -EINVAL;
1885                 goto err_io_init;
1886         }
1887
1888         memset(data->adc_samples, 0, sizeof(int)*(NUM_VOLTAGE_SAMPLE + 2));
1889
1890          //register adc for battery sample
1891          if(0 == pdata->adc_channel)
1892                 client = adc_register(0, rk30_adc_battery_callback, NULL);  //pdata->adc_channel = ani0
1893         else
1894                 client = adc_register(pdata->adc_channel, rk30_adc_battery_callback, NULL);
1895         if(!client){
1896                 ret = -EINVAL;
1897                 goto err_adc_register_failed;
1898         }
1899
1900          //variable init
1901         data->client  = client;
1902         data->adc_val = adc_sync_read(client);
1903
1904         data ->bat = rk30_battery_supply;
1905         ret = power_supply_register(&pdev->dev,&data ->bat);
1906         if (ret){
1907                 ret = -EINVAL;
1908                 printk(KERN_INFO "fail to battery power_supply_register\n");
1909                 goto err_battery_failed;
1910         }
1911 #if  defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1912         data ->usb = rk30_usb_supply;
1913         ret = power_supply_register(&pdev->dev, &data ->usb);
1914         if (ret){
1915                 ret = -EINVAL;
1916                 printk(KERN_INFO "fail to usb power_supply_register\n");
1917                 goto err_usb_failed;
1918         }
1919 #endif
1920         data ->ac = rk30_ac_supply;
1921         ret = power_supply_register(&pdev->dev, &data ->ac);
1922         if (ret) {
1923                 ret = -EINVAL;
1924                 printk(KERN_INFO "fail to ac power_supply_register\n");
1925                 goto err_ac_failed;
1926         }
1927
1928 #if  defined (CONFIG_BATTERY_RK30_AC_CHARGE)
1929         //init dc dectet irq & delay work
1930         if (pdata->dc_det_pin != INVALID_GPIO){
1931                 INIT_WORK(&data->dcwakeup_work, rk30_adc_battery_dcdet_delaywork);
1932
1933                 irq = gpio_to_irq(pdata->dc_det_pin);
1934                 irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1935                 ret = request_irq(irq, rk30_adc_battery_dc_wakeup, irq_flag, "ac_charge_irq", NULL);
1936                 if (ret) {
1937                         ret = -EINVAL;
1938                         printk("failed to request dc det irq\n");
1939                         goto err_dcirq_failed;
1940                 }
1941                 enable_irq_wake(irq);
1942
1943         }
1944 #endif
1945
1946 #ifdef BATTERY_APK
1947         ret = device_create_file(&pdev->dev,&dev_attr_batparam);
1948         if(ret){
1949                 ret = -EINVAL;
1950                 printk(KERN_ERR "failed to create bat param file\n");
1951                 goto err_battery_failed;
1952         }
1953
1954         ret = create_sysfs_interfaces(&pdev->dev);
1955         if (ret < 0)
1956         {
1957                 ret = -EINVAL;
1958                 dev_err(&pdev->dev,
1959                         "device rk30_adc_batterry sysfs register failed\n");
1960                 goto err_sysfs;
1961         }
1962 #endif
1963         //Power on Battery detect
1964         rk30_adc_battery_check(data);
1965
1966         data->wq = create_singlethread_workqueue("adc_battd");
1967         INIT_DELAYED_WORK(&data->delay_work, rk30_adc_battery_timer_work);
1968
1969         if(1 == pdata->save_capacity ){
1970                 queue_delayed_work(data->wq, &data->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS*10));
1971                 data ->poweron_check = 1;
1972         }else{
1973                 queue_delayed_work(data->wq, &data->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS));
1974                 data ->poweron_check = 0;
1975         }
1976         if( pdata->batt_low_pin != INVALID_GPIO){
1977
1978                 if (gpio_get_value(pdata->batt_low_pin) ==0){
1979                        mdelay(20);
1980                        if (gpio_get_value(pdata->batt_low_pin) ==0){
1981                          printk("lower power\n");
1982                                kernel_power_off();
1983                        }
1984                 }
1985
1986                 INIT_WORK(&data->lowerpower_work, rk30_adc_battery_lowerpower_delaywork);
1987                 irq = gpio_to_irq(pdata->batt_low_pin);
1988                 ret = request_irq(irq, rk30_adc_battery_low_wakeup, IRQF_TRIGGER_LOW, "batt_low_irq", NULL);
1989                 if (ret) {
1990                         ret = -EINVAL;
1991                         printk("failed to request batt_low_irq irq\n");
1992                         goto err_lowpowerirq_failed;
1993                 }
1994                 disable_irq(irq);
1995
1996         }
1997
1998         printk(KERN_INFO "rk30_adc_battery: driver initialized\n");
1999
2000         return 0;
2001 err_sysfs:
2002 err_usb_failed:
2003         power_supply_unregister(&data ->usb);
2004 err_ac_failed:
2005         power_supply_unregister(&data ->ac);
2006
2007 err_battery_failed:
2008         power_supply_unregister(&data ->bat);
2009
2010 err_dcirq_failed:
2011         free_irq(gpio_to_irq(pdata->dc_det_pin), data);
2012 #if 1
2013  err_lowpowerirq_failed:
2014         free_irq(gpio_to_irq(pdata->batt_low_pin), data);
2015 #endif
2016 err_adc_register_failed:
2017 err_io_init:
2018 err_data_alloc_failed:
2019         kfree(data);
2020
2021         printk("rk30_adc_battery: error!\n");
2022
2023         return ret;
2024 }
2025
2026 static int rk30_adc_battery_remove(struct platform_device *pdev)
2027 {
2028         struct rk30_adc_battery_data *data = platform_get_drvdata(pdev);
2029         struct rk30_adc_battery_platform_data *pdata = pdev->dev.platform_data;
2030
2031         cancel_delayed_work(&data->delay_work);
2032 #if  defined (CONFIG_BATTERY_RK30_AC_CHARGE)
2033     if (pdata->dc_det_pin != INVALID_GPIO)
2034         cancel_delayed_work_sync(&data->dcwakeup_work);
2035 #endif
2036
2037     if( pdata->batt_low_pin != INVALID_GPIO)
2038         cancel_delayed_work_sync(&data->lowerpower_work);
2039 #if  defined (CONFIG_BATTERY_RK30_USB_CHARGE)
2040                 power_supply_unregister(&data ->usb);
2041 #endif
2042         power_supply_unregister(&data ->ac);
2043         power_supply_unregister(&data ->bat);
2044
2045         free_irq(gpio_to_irq(pdata->dc_det_pin), data);
2046
2047         kfree(data);
2048
2049         return 0;
2050 }
2051
2052 static struct platform_driver rk30_adc_battery_driver = {
2053         .probe          = rk30_adc_battery_probe,
2054         .remove         = rk30_adc_battery_remove,
2055         .suspend                = rk30_adc_battery_suspend,
2056         .resume         = rk30_adc_battery_resume,
2057         .driver = {
2058                 .name = "rk30-battery",
2059                 .owner  = THIS_MODULE,
2060         }
2061 };
2062
2063 static int __init rk30_adc_battery_init(void)
2064 {
2065         return platform_driver_register(&rk30_adc_battery_driver);
2066 }
2067
2068 static void __exit rk30_adc_battery_exit(void)
2069 {
2070         platform_driver_unregister(&rk30_adc_battery_driver);
2071 }
2072 module_init(rk30_adc_battery_init);//module_init(rk30_adc_battery_init);//
2073 //subsys_initcall(rk30_adc_battery_init);
2074 //fs_initcall(rk30_adc_battery_init);
2075 module_exit(rk30_adc_battery_exit);
2076
2077 MODULE_DESCRIPTION("Battery detect driver for the rk30");
2078 MODULE_AUTHOR("luowei lw@rock-chips.com");
2079 MODULE_LICENSE("GPL");