drivers/power/rk30_factory_adc_battery.c

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