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