drivers/power/rk30_factory_adc_battery.c

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