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