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