drivers/power/rk30_factory_adc_battery.c

   1 /* drivers/power/rk30_adc_battery.c
   2  *
   3  * battery detect driver for the rk30
   4  *
   5  * This software is licensed under the terms of the GNU General Public
   6  * License version 2, as published by the Free Software Foundation, and
   7  * may be copied, distributed, and modified under those terms.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/err.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/power_supply.h>
  20 #include <linux/regulator/consumer.h>
  21 #include <linux/types.h>
  22 #include <linux/pci.h>
  23 #include <linux/interrupt.h>
  24 #include <asm/io.h>
  25 #include <asm/mach-types.h>
  26 #include <asm/mach/arch.h>
  27 #include <asm/mach/map.h>
  28 #include <mach/gpio.h>
  29 #include <linux/adc.h>
  30 #include <mach/iomux.h>
  31 #include <mach/board.h>
  32 #include <linux/delay.h>
  33 #include <linux/ktime.h>
  34 #include <linux/slab.h>
  35 #include <linux/syscalls.h>
  36 #include <linux/fs.h>
  37 #include <linux/wakelock.h>
  38
  39 #if 0
  40 #define DBG(x...)   printk(x)
  41 #else
  42 #define DBG(x...)
  43 #endif
  44
  45 static int rk30_battery_dbg_level = 0;
  46 module_param_named(dbg_level, rk30_battery_dbg_level, int, 0644);
  47 #define pr_bat( args...) \
  48         do { \
  49                 if (rk30_battery_dbg_level) { \
  50                         pr_info(args); \
  51                 } \
  52         } while (0)
  53
  54
  55 /*******************ÒÔÏÂ²ÎÊý¿ÉÒÔÐÞ¸Ä******************************/
  56 #define TIMER_MS_COUNTS          1000   //¶¨Ê±Æ÷µÄ³¤¶Èms
  57 //ÒÔÏÂ²ÎÊýÐèÒª¸ù¾ÝÊµ¼Ê²âÊÔµ÷Õû
  58 #define SLOPE_SECOND_COUNTS                    15       //Í³¼ÆµçÑ¹Ð±ÂÊµÄÊ±¼ä¼ä¸ôs
  59 #define DISCHARGE_MIN_SECOND                   45       //×î¿ì·Åµçµç1%Ê±¼ä
  60 #define CHARGE_MIN_SECOND                      45       //×î¿ì³äµçµç1%Ê±¼ä
  61 #define CHARGE_MID_SECOND                      90       //ÆÕÍ¨³äµçµç1%Ê±¼ä
  62 #define CHARGE_MAX_SECOND                      250      //×î³¤³äµçµç1%Ê±¼ä
  63 #define   CHARGE_FULL_DELAY_TIMES          10          //³äµçÂú¼ì²â·À¶¶Ê±¼ä
  64 #define   USBCHARGE_IDENTIFY_TIMES        5           //²åÈëUSB»ìÁ÷£¬pcÊ¶±ð¼ì²âÊ±¼ä
  65
  66 #define NUM_VOLTAGE_SAMPLE                             ((SLOPE_SECOND_COUNTS * 1000) / TIMER_MS_COUNTS)
  67 #define NUM_DISCHARGE_MIN_SAMPLE                 ((DISCHARGE_MIN_SECOND * 1000) / TIMER_MS_COUNTS)
  68 #define NUM_CHARGE_MIN_SAMPLE            ((CHARGE_MIN_SECOND * 1000) / TIMER_MS_COUNTS)
  69 #define NUM_CHARGE_MID_SAMPLE            ((CHARGE_MID_SECOND * 1000) / TIMER_MS_COUNTS)
  70 #define NUM_CHARGE_MAX_SAMPLE            ((CHARGE_MAX_SECOND * 1000) / TIMER_MS_COUNTS)
  71 #define   NUM_CHARGE_FULL_DELAY_TIMES         ((CHARGE_FULL_DELAY_TIMES * 1000) / TIMER_MS_COUNTS)      //³äµçÂú×´Ì¬³ÖÐøÊ±¼ä³¤¶È
  72 #define   NUM_USBCHARGE_IDENTIFY_TIMES      ((USBCHARGE_IDENTIFY_TIMES * 1000) / TIMER_MS_COUNTS)       //³äµçÂú×´Ì¬³ÖÐøÊ±¼ä³¤¶È
  73
  74 #define   CHARGE_IS_OK                    1
  75 #define   INVALID_CHARGE_CHECK               -1
  76 #if defined(CONFIG_ARCH_RK3066B)
  77 #define  BAT_DEFINE_VALUE                                            1800
  78 #elif defined(CONFIG_ARCH_RK2928)
  79 #define  BAT_DEFINE_VALUE                                         3300
  80 #else
  81 #define  BAT_DEFINE_VALUE                                            2500
  82 #endif
  83
  84
  85 #define BATT_FILENAME "/data/bat_last_capacity.dat"
  86
  87 static struct wake_lock batt_wake_lock;
  88
  89
  90 struct batt_vol_cal{
  91         u32 disp_cal;
  92         u32 dis_charge_vol;
  93         u32 charge_vol;
  94 };
  95 #if 0
  96
  97 #ifdef CONFIG_BATTERY_RK30_VOL3V8
  98
  99 #define BATT_MAX_VOL_VALUE                             4120                     //ÂúµçÊ±µÄµç³ØµçÑ¹
 100 #define BATT_ZERO_VOL_VALUE                            3400                     //¹Ø»úÊ±µÄµç³ØµçÑ¹
 101 #define BATT_NOMAL_VOL_VALUE                         3800
 102 //divider resistance
 103 #define BAT_PULL_UP_R                                         200
 104 #define BAT_PULL_DOWN_R                                    200
 105
 106 static struct batt_vol_cal  batt_table[] = {
 107         {0,3400,3520},{1,3420,3525},{2,3420,3575},{3,3475,3600},{5,3505,3620},{7,3525,3644},
 108         {9,3540,3662},{11,3557,3670},{13,3570,3684},{15,3580,3700},{17,3610,3715},
 109         {19,3630,3720},{21,3640,3748},{23,3652,3756},{25,3662,3775},{27,3672,3790},
 110         {29,3680,3810},{31,3687,3814},{33,3693,3818},{35,3699,3822},{37,3705,3825},
 111         {39,3710,3830},{41,3714,3832},{43,3718,3834},{45,3722,3836},{47,3726,3837},
 112         {49,3730,3839},{51,3734,3841},{53,3738,3842},{55,3742,3844},{57,3746,3844},
 113         {59,3750,3855},{61,3756,3860},{63,3764,3864},{65,3774,3871},{67,3786,3890},
 114         {69,3800,3910},{71,3808,3930},{73,3817,3977},{75,3827,3977},{77,3845,3997},
 115         {79,3950,4030},{81,3964,4047},{83,3982,4064},{85,4002,4080},{87,4026,4096},
 116         {89,4030,4132},{91,4034,4144},{93,4055,4150},{95,4085,4195},{97,4085,4195},{100,4120,4200},
 117 };
 118 #else
 119 #define BATT_MAX_VOL_VALUE                              8284                    //Full charge voltage
 120 #define BATT_ZERO_VOL_VALUE                             6800                    // power down voltage
 121 #define BATT_NOMAL_VOL_VALUE                          7600
 122
 123 //¶¨ÒåADC²ÉÑù·ÖÑ¹µç×è£¬ÒÔÊµ¼ÊÖµÎª×¼£¬µ¥Î»K
 124
 125 #define BAT_PULL_UP_R                                         300
 126 #define BAT_PULL_DOWN_R                                    100
 127
 128 static struct batt_vol_cal  batt_table[] = {
 129         {0,6800,7400},    {1,6840,7440},    {2,6880,7480},     {3,6950,7450},       {5,7010,7510},    {7,7050,7550},
 130         {9,7080,7580},    {11,7104,7604},   {13,7140,7640},   {15,7160,7660},      {17,7220,7720},
 131         {19,7260,7760},  {21,7280,7780},   {23,7304,7802},   {25,7324,7824},      {27,7344,7844},
 132         {29,7360,7860},  {31,7374,7874},   {33,7386,7886},   {35,7398,7898},      {37,7410,7910},//500
 133         {39,7420,7920},  {41,7424,7928},   {43,7436,7947},   {45,7444,7944},      {47,7450,7958}, //508
 134         {49,7460,7965},  {51,7468,7975},   {53, 7476,7990},  {55,7482,8000},      {57,7492,8005}, // 5 14
 135         {59,7500,8011},  {61,7510,8033},   {63,7528,8044},   {65,7548,8055},      {67,7560,8066},//506
 136         {69,7600,8070},  {71,7618,8075},   {73,7634,8080},   {75,7654,8085},      {77,7690,8100}, //400
 137         {79,7900,8180},  {81,7920,8210},   {83,7964,8211},   {85,8000,8214},      {87,8002,8218},//290
 138         {89,8012, 8220}, {91,8022,8235},   {93,8110,8260},   {95,8140,8290},       {97,8170,8300},  {100,8200 ,8310},//110
 139
 140 };
 141 #endif
 142
 143
 144
 145 #define BATT_NUM  ARRAY_SIZE(batt_table)
 146 #endif
 147
 148 #define BATTERY_APK
 149
 150 #ifdef  BATTERY_APK
 151
 152 #define BATT_NUM  11
 153 #include <linux/fs.h>
 154 int    battery_dbg_level = 0;
 155 int    battery_test_flag = 0;
 156 int gVoltageCnt = 3400;
 157 int gDoubleVoltageCnt = 6800;
 158 #ifdef CONFIG_BATTERY_RK30_VOL3V8
 159 #define BATT_MAX_VOL_VALUE                             4120                     //ÂúµçÊ±µÄµç³ØµçÑ¹
 160 #define BATT_ZERO_VOL_VALUE                            3400                     //¹Ø»úÊ±µÄµç³ØµçÑ¹
 161 #define BATT_NOMAL_VOL_VALUE                         3800
 162
 163 //int    pull_up_res  =100;
 164 //int    pull_down_res = 100;
 165
 166
 167 static int batt_table[2*BATT_NUM+6] =
 168 {
 169         0x4B434F52,0x7461625F,0x79726574,0,100,100,
 170         3496, 3548, 3599, 3626, 3655, 3697, 3751, 3812, 3877, 3949, 4030,  //discharge
 171         3540, 3785, 3842, 3861, 3915, 3980, 4041, 4135, 4169, 4175, 4185          //charge
 172 };
 173 #define adc_to_voltage(adc_val) ((adc_val * BAT_DEFINE_VALUE * (batt_table[4] +batt_table[5])) / (1024 *batt_table[5]))
 174 #else
 175 #define BATT_MAX_VOL_VALUE                              8284                    //Full charge voltage
 176 #define BATT_ZERO_VOL_VALUE                             6800                    // power down voltage
 177 #define BATT_NOMAL_VOL_VALUE                          7600
 178 //int    pull_up_res  =300;
 179 //int    pull_down_res = 100;
 180 //¶¨ÒåADC²ÉÑù·ÖÑ¹µç×è£¬ÒÔÊµ¼ÊÖµÎª×¼£¬µ¥Î»K
 181
 182 static int batt_table[2*BATT_NUM+6] =
 183 {
 184         0x4B434F52,0x7461625F,0x79726574,1,300,100,
 185         6800,7242,7332,7404,7470,7520,7610,7744,7848,8016,8284,
 186         7630, 7754, 7852, 7908, 7956, 8024, 8112, 8220, 8306, 8318, 8328
 187 };
 188 #define adc_to_voltage(adc_val) ((adc_val * BAT_DEFINE_VALUE * (batt_table[4] +batt_table[5])) / (1024 *batt_table[5]))
 189
 190
 191 #endif
 192 #else
 193 //#define adc_to_voltage(adc_val)                           ((adc_val * BAT_2V5_VALUE * (BAT_PULL_UP_R + BAT_PULL_DOWN_R)) / (1024 * BAT_PULL_DOWN_R))
 194 #endif
 195 int Cnt=0;
 196 unsigned long gSecondsCnt = 0;
 197
 198 char gDischargeFlag[3] = {"on "};
 199
 200
 201 /********************************************************************************/
 202
 203 extern int dwc_vbus_status(void);
 204 extern int get_msc_connect_flag(void);
 205
 206 struct rk30_adc_battery_data {
 207         int irq;
 208
 209         //struct timer_list       timer;
 210         struct workqueue_struct *wq;
 211         struct delayed_work         delay_work;
 212         struct work_struct          dcwakeup_work;
 213         struct work_struct                   lowerpower_work;
 214         bool                    resume;
 215
 216         struct rk30_adc_battery_platform_data *pdata;
 217
 218         int                     full_times;
 219
 220         struct adc_client       *client;
 221         int                     adc_val;
 222         int                     adc_samples[NUM_VOLTAGE_SAMPLE+2];
 223
 224         int                     bat_status;
 225         int                     bat_status_cnt;
 226         int                     bat_health;
 227         int                     bat_present;
 228         int                     bat_voltage;
 229         int                     bat_capacity;
 230         int                     bat_change;
 231
 232         int                     old_charge_level;
 233         int                    *pSamples;
 234         int                     gBatCapacityDisChargeCnt;
 235         int                     gBatCapacityChargeCnt;
 236         int               capacitytmp;
 237         int                     poweron_check;
 238         int                     suspend_capacity;
 239         int                     gBatUsbChargeCnt;
 240         int                     status_lock;
 241
 242         int                    usb_charging;
 243         int                    ac_charging;
 244
 245
 246 };
 247 static struct rk30_adc_battery_data *gBatteryData;
 248
 249
 250 #ifdef  BATTERY_APK
 251 #define BAT_ADC_TABLE_LEN               11
 252 static ssize_t bat_param_read(struct device *dev,struct device_attribute *attr, char *buf)
 253 {
 254 #if 1
 255         int i;
 256         for(i=0;i<BATT_NUM;i++)
 257                 printk("i=%d batt_table=%d\n",i+6,batt_table[i+6]);
 258
 259         for(i=0;i<BATT_NUM;i++)
 260                 printk("i=%d batt_table=%d\n",i+17,batt_table[i+17]);
 261 #endif
 262         return 0;
 263 }
 264 DEVICE_ATTR(batparam, 0664, bat_param_read,NULL);
 265
 266
 267 static ssize_t rkbatt_show_debug_attrs(struct device *dev,
 268                                               struct device_attribute *attr, char *buf)
 269 {
 270         return sprintf(buf, "%d\n", battery_dbg_level);
 271 }
 272
 273 static ssize_t rkbatt_restore_debug_attrs(struct device *dev,
 274                                                 struct device_attribute *attr,
 275                                                 const char *buf, size_t size)
 276 {
 277         int liTmp;
 278
 279         sscanf(buf, "%d", &liTmp);
 280
 281         if(liTmp != 0 && liTmp != 1)
 282         {
 283                 dev_err(dev, "rk29adc_restore_debug_attrs err\n");
 284         }
 285         else
 286         {
 287                 battery_dbg_level = liTmp;
 288         }
 289         return size;
 290 }
 291 static int  is_charge_ok(struct rk30_adc_battery_data *bat);
 292
 293 static ssize_t rkbatt_show_state_attrs(struct device *dev,
 294                                               struct device_attribute *attr,
 295                                               char *buf)
 296 {
 297 //      struct rk30_adc_battery_platform_data *pdata = gBatteryData->pdata;
 298         int charge_ok_value =0 ;
 299         charge_ok_value = is_charge_ok(gBatteryData) ;
 300
 301         return  sprintf(buf,
 302                 "gBatVol=%d,gBatCap=%d,charge_ok=%d,%s\n",
 303                 gBatteryData->bat_voltage,gBatteryData->bat_capacity,
 304                 charge_ok_value,gDischargeFlag);
 305 }
 306
 307 static ssize_t rkbatt_restore_state_attrs(struct device *dev,
 308                                                 struct device_attribute *attr,
 309                                                 const char *buf, size_t size)
 310 {
 311         return size;
 312 }
 313
 314 static ssize_t rkbatt_show_value_attrs(struct device *dev,
 315                                               struct device_attribute *attr, char *buf)
 316 {
 317         return sprintf(buf, "pull_up_res =%d,\npull_down_res=%d\n", batt_table[4],batt_table[5]);
 318 }
 319
 320 static ssize_t rkbatt_restore_value_attrs(struct device *dev,
 321                                                 struct device_attribute *attr,
 322                                                 const char *buf, size_t size)
 323 {
 324         int liUp        = 0;
 325         int liDown      = 0;
 326
 327         sscanf(buf, "%d,%d", &liUp,&liDown);
 328
 329         if(liUp != 0 && liDown != 0)
 330         {
 331                 batt_table[4] = liUp;
 332                 batt_table[5] = liDown;
 333         }
 334         else
 335         {
 336                 //nothing
 337         }
 338         return size;
 339 }
 340
 341 static ssize_t rkbatt_show_flag_attrs(struct device *dev,
 342                                               struct device_attribute *attr, char *buf)
 343 {
 344         return sprintf(buf, "rk29_battery_test_flag=%d\n", battery_test_flag);
 345 }
 346 static ssize_t rkbatt_restore_flag_attrs(struct device *dev,
 347                                                 struct device_attribute *attr,
 348                                                 const char *buf, size_t size)
 349 {
 350         int liFlag;
 351
 352         sscanf(buf, "%d", &liFlag);
 353
 354         if(liFlag != 0)
 355         {
 356                 battery_test_flag = liFlag;
 357         }
 358         return size;
 359 }
 360 static struct device_attribute rkbatt_attrs[] = {
 361         __ATTR(state, 0664, rkbatt_show_state_attrs, rkbatt_restore_state_attrs),
 362         __ATTR(debug, 0664, rkbatt_show_debug_attrs, rkbatt_restore_debug_attrs),
 363         __ATTR(value, 0666, rkbatt_show_value_attrs, rkbatt_restore_value_attrs),
 364         __ATTR(flag,  0666, rkbatt_show_flag_attrs,  rkbatt_restore_flag_attrs),
 365 };
 366
 367 static int create_sysfs_interfaces(struct device *dev)
 368 {
 369         int liTmep;
 370         for (liTmep = 0; liTmep < ARRAY_SIZE(rkbatt_attrs); liTmep++)
 371         {
 372                 if (device_create_file(dev, rkbatt_attrs + liTmep))
 373                 {
 374                         goto error;
 375                 }
 376         }
 377
 378         return 0;
 379
 380 error:
 381         for ( ; liTmep >= 0; liTmep--)
 382         {
 383                 device_remove_file(dev, rkbatt_attrs + liTmep);
 384         }
 385
 386         dev_err(dev, "%s:Unable to create sysfs interface\n", __func__);
 387         return -1;
 388 }
 389
 390 #endif
 391
 392
 393
 394 enum {
 395         BATTERY_STATUS          = 0,
 396         BATTERY_HEALTH          = 1,
 397         BATTERY_PRESENT         = 2,
 398         BATTERY_CAPACITY        = 3,
 399         BATTERY_AC_ONLINE       = 4,
 400         BATTERY_STATUS_CHANGED  = 5,
 401         AC_STATUS_CHANGED       = 6,
 402         BATTERY_INT_STATUS          = 7,
 403         BATTERY_INT_ENABLE          = 8,
 404 };
 405
 406 typedef enum {
 407         CHARGER_BATTERY = 0,
 408         CHARGER_USB,
 409         CHARGER_AC
 410 } charger_type_t;
 411
 412
 413
 414
 415
 416 static int rk30_adc_battery_load_capacity(void)
 417 {
 418         char value[4];
 419         int* p = (int *)value;
 420         long fd = sys_open(BATT_FILENAME,O_RDONLY,0);
 421
 422         if(fd < 0){
 423                 pr_bat("rk30_adc_battery_load_capacity: open file /data/bat_last_capacity.dat failed\n");
 424                 return -1;
 425         }
 426
 427         sys_read(fd,(char __user *)value,4);
 428         sys_close(fd);
 429
 430         return (*p);
 431 }
 432
 433 static void rk30_adc_battery_put_capacity(int loadcapacity)
 434 {
 435         char value[4];
 436         int* p = (int *)value;
 437         long fd = sys_open(BATT_FILENAME,O_CREAT | O_RDWR,0);
 438
 439         if(fd < 0){
 440                 pr_bat("rk30_adc_battery_put_capacity: open file /data/bat_last_capacity.dat failed\n");
 441                 return;
 442         }
 443
 444         *p = loadcapacity;
 445         sys_write(fd, (const char __user *)value, 4);
 446
 447         sys_close(fd);
 448 }
 449
 450 static void rk30_adc_battery_charge_enable(struct rk30_adc_battery_data *bat)
 451 {
 452         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 453
 454         if (pdata->charge_set_pin != INVALID_GPIO){
 455                 gpio_direction_output(pdata->charge_set_pin, pdata->charge_set_level);
 456         }
 457 }
 458
 459 static void rk30_adc_battery_charge_disable(struct rk30_adc_battery_data *bat)
 460 {
 461         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 462
 463         if (pdata->charge_set_pin != INVALID_GPIO){
 464                 gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
 465         }
 466 }
 467
 468 //extern int suspend_flag;
 469 static int rk30_adc_battery_get_charge_level(struct rk30_adc_battery_data *bat)
 470 {
 471         int charge_on = 0;
 472         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 473
 474 #if defined (CONFIG_BATTERY_RK30_AC_CHARGE)
 475         if (pdata->dc_det_pin != INVALID_GPIO){
 476                 if (gpio_get_value (pdata->dc_det_pin) == pdata->dc_det_level){
 477                         //charge_on = 1;
 478                         bat -> ac_charging = 1;
 479                 }
 480                 else{
 481                         bat -> ac_charging = 0;
 482
 483                 }
 484         }
 485         else{
 486                 if(pdata->is_dc_charging){
 487                         //charge_on =pdata->is_dc_charging();
 488                         bat ->ac_charging = pdata->is_dc_charging();;
 489                 }
 490         }
 491 #endif
 492         if(1 == pdata->spport_usb_charging){
 493                 if (charge_on == 0){
 494                         if (1 == dwc_vbus_status()) {
 495                                 if (0 == get_msc_connect_flag()){
 496                                         if (++bat->gBatUsbChargeCnt >= NUM_USBCHARGE_IDENTIFY_TIMES){
 497                                                 bat->gBatUsbChargeCnt = NUM_USBCHARGE_IDENTIFY_TIMES + 1;
 498                                                 //charge_on = 1;
 499                                                 bat->usb_charging =1;
 500                                                 if(bat -> pdata ->control_usb_charging)
 501                                                         bat -> pdata ->control_usb_charging(0);
 502
 503                                                 //printk("1 == dwc_vbus_status\n");
 504                                         }
 505                                 }
 506                         }else{
 507                                 bat->gBatUsbChargeCnt = 0;
 508                                 if (2 == dwc_vbus_status()) {
 509                                         //charge_on = 1;
 510                                         bat->usb_charging =1;
 511                                         if(bat -> pdata ->control_usb_charging)
 512                                                         bat -> pdata ->control_usb_charging(1);
 513                                         //printk("2 == dwc_vbus_status\n");
 514                                 }else{
 515                                         bat->usb_charging =0;
 516                                 }
 517                 }
 518                 }
 519         }
 520 #if 0
 521         if (pdata->spport_usb_charging)  //is usb charging
 522                 if(pdata->is_usb_charging)
 523                         charge_on = pdata->is_usb_charging();
 524
 525 #endif
 526         if((bat->usb_charging == 1)||(bat ->ac_charging ==1))
 527                 charge_on =1;
 528         return charge_on;
 529 }
 530 static int  is_charge_ok(struct rk30_adc_battery_data *bat)
 531 {
 532         int charge_is_ok = 0;
 533         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 534
 535         if(rk30_adc_battery_get_charge_level(bat) != 1)
 536                 return -1;
 537         if((pdata->charge_ok_pin == INVALID_GPIO)&& ( pdata->charging_ok == NULL))
 538                 return -1;
 539
 540         if (pdata->charge_ok_pin != INVALID_GPIO){
 541                 if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level)
 542                 {
 543                         charge_is_ok =1;
 544                 }
 545         }else if( pdata->charging_ok)
 546                 {
 547                 charge_is_ok = pdata->charging_ok();
 548                 }
 549         return charge_is_ok;
 550
 551
 552 }
 553
 554
 555 //int old_charge_level;
 556 static int rk30_adc_battery_status_samples(struct rk30_adc_battery_data *bat)
 557 {
 558         int charge_level;
 559
 560 //      struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 561
 562         charge_level = rk30_adc_battery_get_charge_level(bat);
 563
 564         //¼ì²â³äµç×´Ì¬±ä»¯Çé¿ö
 565         if (charge_level != bat->old_charge_level){
 566                 bat->old_charge_level = charge_level;
 567                 bat->bat_change  = 1;
 568
 569                 if(charge_level) {
 570                         rk30_adc_battery_charge_enable(bat);
 571                 }
 572                 else{
 573                         rk30_adc_battery_charge_disable(bat);
 574                 }
 575                 bat->bat_status_cnt = 0;        //×´Ì¬±ä»¯¿ªÊ¼¼ÆÊý
 576         }
 577
 578         if(charge_level == 0){
 579         //discharge
 580                 bat->full_times = 0;
 581                 bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 582         }
 583         else{
 584         //CHARGE
 585                 if( is_charge_ok(bat)  ==  INVALID_CHARGE_CHECK){
 586
 587                         if (bat->bat_capacity == 100){
 588                                 if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){
 589                                         bat->bat_status = POWER_SUPPLY_STATUS_FULL;
 590                                         bat->bat_change  = 1;
 591                                 }
 592                         }
 593                         else{
 594                                 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 595                         }
 596                 }
 597                 else{  // pin of charge_ok_pin
 598                         if (is_charge_ok(bat) != CHARGE_IS_OK ){
 599
 600                                 bat->full_times = 0;
 601                                 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 602                         }
 603                         else{
 604         //¼ì²âµ½³äµçÂúµçÆ½±êÖ¾
 605                                 bat->full_times++;
 606
 607                                 if (bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) {
 608                                         bat->full_times = NUM_CHARGE_FULL_DELAY_TIMES + 1;
 609                                 }
 610
 611                                 if ((bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) && (bat->bat_capacity >= 99)){
 612                                         if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){
 613                                                 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
 614                                                 bat->bat_capacity = 100;
 615                                                 bat->bat_change  = 1;
 616                                         }
 617                                 }
 618                                 else{
 619                                         bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 620                                 }
 621                         }
 622                 }
 623         }
 624
 625         return charge_level;
 626 }
 627 static int rk_adc_voltage(int value)
 628 {
 629         int voltage;
 630
 631         int ref_voltage; //reference_voltage
 632         int pullup_res;
 633         int pulldown_res;
 634
 635         ref_voltage = gBatteryData ->pdata->reference_voltage;
 636         pullup_res = gBatteryData ->pdata->pull_up_res;
 637         pulldown_res = gBatteryData ->pdata->pull_down_res;
 638
 639         if(ref_voltage && pullup_res && pulldown_res){
 640
 641                 voltage =  ((value * ref_voltage * (pullup_res + pulldown_res)) / (1024 * pulldown_res));
 642
 643         }else{
 644                 voltage = adc_to_voltage(value);
 645         }
 646
 647
 648         return voltage;
 649
 650 }
 651 static void rk_handle_ripple(struct rk30_adc_battery_data *bat, int status)
 652 {
 653
 654 #if  0
 655                 if(1 == status){
 656                         if(bat->bat_voltage >=  bat->pdata->charge_table[bat->pdata->table_size-1]+ 10)
 657                                 bat->bat_voltage = bat->pdata->charge_table[bat->pdata->table_size-1]  + 10;
 658                         else if(bat->bat_voltage <= bat->pdata->charge_table[0] - 10)
 659                                 bat->bat_voltage =   bat->pdata->charge_table[0] - 10;
 660                 }
 661                 else{
 662                         if(bat->bat_voltage >=  bat->pdata->discharge_table[bat->pdata->table_size-1]+ 10)
 663                                 bat->bat_voltage =  bat->pdata->discharge_table[ bat->pdata->table_size-1] + 10;
 664                         else if(bat->bat_voltage <=   bat->pdata->discharge_table[ 0]  - 10)
 665                                 bat->bat_voltage =   bat->pdata->discharge_table[ 0] - 10;
 666
 667                 }
 668 #endif
 669         int *p_table;
 670
 671         if (bat->pdata->use_board_table){
 672                 p_table = bat->pdata->board_batt_table;
 673
 674                 if(1 == status){
 675                         if(bat->bat_voltage >= p_table[2*BATT_NUM +5]+ 10)
 676                                 bat->bat_voltage = p_table[2*BATT_NUM +5]  + 10;
 677                         else if(bat->bat_voltage <= p_table[BATT_NUM +6]  - 10)
 678                                 bat->bat_voltage =  p_table[BATT_NUM +6] - 10;
 679                 }
 680                 else{
 681                         if(bat->bat_voltage >= p_table[BATT_NUM +5]+ 10)
 682                                 bat->bat_voltage = p_table[BATT_NUM +5]  + 10;
 683                         else if(bat->bat_voltage <= p_table[6]  - 10)
 684                                 bat->bat_voltage =  p_table[6] - 10;
 685                 }
 686         }
 687
 688 }
 689
 690 static int *pSamples;
 691 static void rk30_adc_battery_voltage_samples(struct rk30_adc_battery_data *bat)
 692 {
 693         int value;
 694         int i,*pStart = bat->adc_samples, num = 0;
 695         int level = rk30_adc_battery_get_charge_level(bat);
 696
 697
 698         value = bat->adc_val;
 699         adc_async_read(bat->client);
 700
 701         *pSamples++ = rk_adc_voltage(value);
 702
 703         bat->bat_status_cnt++;
 704         if (bat->bat_status_cnt > NUM_VOLTAGE_SAMPLE)  bat->bat_status_cnt = NUM_VOLTAGE_SAMPLE + 1;
 705
 706         num = pSamples - pStart;
 707
 708         if (num >= NUM_VOLTAGE_SAMPLE){
 709                 pSamples = pStart;
 710                 num = NUM_VOLTAGE_SAMPLE;
 711
 712         }
 713
 714         value = 0;
 715         for (i = 0; i < num; i++){
 716                 value += bat->adc_samples[i];
 717         }
 718         bat->bat_voltage = value / num;
 719
 720         /*Ïû³ýÃ«´ÌµçÑ¹*/
 721         if(battery_test_flag == 0)
 722         {
 723                 if(0 == bat->pdata->use_board_table){
 724                         if(1 == level){
 725                                 if(bat->bat_voltage >= batt_table[2*BATT_NUM +5]+ 10)
 726                                         bat->bat_voltage = batt_table[2*BATT_NUM +5]  + 10;
 727                                 else if(bat->bat_voltage <= batt_table[BATT_NUM +6]  - 10)
 728                                         bat->bat_voltage =  batt_table[BATT_NUM +6] - 10;
 729                         }
 730                         else{
 731                                 if(bat->bat_voltage >= batt_table[BATT_NUM +5]+ 10)
 732                                         bat->bat_voltage = batt_table[BATT_NUM +5]  + 10;
 733                                 else if(bat->bat_voltage <= batt_table[6]  - 10)
 734                                         bat->bat_voltage =  batt_table[6] - 10;
 735                         }
 736                 }else{
 737                         rk_handle_ripple(bat, level);
 738                 }
 739
 740         }else if(battery_test_flag == 2){
 741
 742                 if(batt_table[3] == 0){
 743                         if(bat->bat_voltage < 3400){
 744                                 //printk("gSecondsCnt=%ld,get_seconds()=%ld,(get_seconds() - gSecondsCnt)=%ld-------------------1\n",gSecondsCnt,get_seconds(),(get_seconds() - gSecondsCnt));
 745                                 if((get_seconds() - gSecondsCnt) > 30){
 746                                         gSecondsCnt = get_seconds();
 747                                         //printk("gSecondsCnt=%ld,gVoltageCnt=%d,(gVoltageCnt - bat->bat_voltage)=%d,bat->bat_voltage=%d-------------------2\n",gSecondsCnt,gVoltageCnt,(gVoltageCnt - bat->bat_voltage),bat->bat_voltage);
 748                                         if((gVoltageCnt - bat->bat_voltage) > 15){
 749                                                 //gVoltageCnt = bat->bat_voltage;
 750                                                 //printk("gVoltageCnt=%d-------------------3\n",gVoltageCnt);
 751                                                 strncpy(gDischargeFlag, "off" ,3);
 752                                         }
 753                                         gVoltageCnt = bat->bat_voltage;
 754
 755                                 }
 756                         }
 757
 758                         if(bat->bat_voltage < 3400){
 759                                 bat->bat_voltage = 3400;
 760                         }
 761                 }
 762                 else{
 763                         if(bat->bat_voltage < 6800){
 764                                 //printk("gSecondsCnt=%ld,get_seconds()=%ld,(get_seconds() - gSecondsCnt)=%ld-------------------1\n",gSecondsCnt,get_seconds(),(get_seconds() - gSecondsCnt));
 765                                 if((get_seconds() - gSecondsCnt) > 30){
 766                                         gSecondsCnt = get_seconds();
 767                                         //printk("gSecondsCnt=%ld,gVoltageCnt=%d,(gVoltageCnt - bat->bat_voltage)=%d,bat->bat_voltage=%d-------------------2\n",gSecondsCnt,gVoltageCnt,(gVoltageCnt - bat->bat_voltage),bat->bat_voltage);
 768                                         if((gDoubleVoltageCnt - bat->bat_voltage) > 30){
 769                                                 //gVoltageCnt = bat->bat_voltage;
 770                                                 //printk("gVoltageCnt=%d-------------------3\n",gVoltageCnt);
 771                                                 strncpy(gDischargeFlag, "off" ,3);
 772                                         }
 773                                         gDoubleVoltageCnt =bat->bat_voltage;
 774                                 }
 775                         }
 776                         if(bat->bat_voltage < 6800){
 777                                 bat->bat_voltage = 6800;
 778                         }
 779                 }
 780         }
 781 /****************************************************/
 782 }
 783 #if 0
 784 static int rk_voltage_capacity(struct rk30_adc_battery_data *bat, int BatVoltage)
 785 {
 786
 787         int i = 0;
 788         int capacity = 0;
 789         int size =bat->pdata->table_size;
 790         int *p;
 791         int *p_capacity = bat->pdata->property_tabel;
 792
 793         if (rk30_adc_battery_get_charge_level(bat)){  //charge
 794                 p =  bat->pdata->charge_table;
 795                 if(BatVoltage >= (p[size - 1])){
 796                         capacity = 99;
 797                 }
 798                 else{
 799                         if(BatVoltage <= (p[0])){
 800                                 capacity = 0;
 801                         }
 802                         else{
 803                                 for(i = 0; i < size - 1; i++){
 804
 805                                         if(((p[i]) <= BatVoltage) && (BatVoltage < (p[i+1]))){
 806                                                 capacity = p_capacity[i] + ((BatVoltage - p[i]) *  (p_capacity[i+1] -p_capacity[i]))/ (p[i+1]- p[i]);
 807                                                 break;
 808                                         }
 809                                 }
 810                         }
 811                 }
 812
 813         }
 814         else{  //discharge
 815                 p =  bat->pdata->discharge_table;
 816                 if(BatVoltage >= (p[size - 1])){
 817                         capacity = 100;
 818                 }
 819                 else{
 820                         if(BatVoltage <= p[0]){
 821                                 capacity = 0;
 822                         }
 823                         else{
 824                                 for(i = 0; i < size - 1; i++){
 825                                         if((p[i] <= BatVoltage) &&( BatVoltage < p[i+1])){
 826                                                 capacity =  p_capacity[i]+ ((BatVoltage - p[i]) * (p_capacity[i+1] -p_capacity[i] ) )/ (p[i+1]- p[i]) ;
 827                                                 break;
 828                                         }
 829                                 }
 830                         }
 831
 832                 }
 833
 834
 835         }
 836             return capacity;
 837
 838
 839 }
 840
 841 #endif
 842 static int rk30_adc_battery_voltage_to_capacity(struct rk30_adc_battery_data *bat, int BatVoltage)
 843 {
 844         int i = 0;
 845         int capacity = 0;
 846
 847         int  *p;
 848         if (bat->pdata->use_board_table)
 849                 p = bat->pdata->board_batt_table;
 850         else
 851                 p = batt_table;
 852
 853 //      rk30_battery_table_info_dump(p);
 854
 855         if (rk30_adc_battery_get_charge_level(bat)){  //charge
 856                         if(BatVoltage >= (p[2*BATT_NUM +5])){
 857                                 capacity = 100;
 858                         }
 859                         else{
 860                                 if(BatVoltage <= (p[BATT_NUM +6])){
 861                                         capacity = 0;
 862                                 }
 863                                 else{
 864                                         for(i = BATT_NUM +6; i <2*BATT_NUM +6; i++){
 865
 866                                                 if(((p[i]) <= BatVoltage) && (BatVoltage < (p[i+1]))){
 867                                                         capacity = (i-(BATT_NUM +6))*10 + ((BatVoltage - p[i]) *  10)/ (p[i+1]- p[i]);
 868                                                         break;
 869                                                 }
 870                                         }
 871                                 }
 872                         }
 873
 874                 }else{  //discharge
 875                         if(BatVoltage >= (p[BATT_NUM +5])){
 876                                 capacity = 100;
 877                         }
 878                         else{
 879                                 if(BatVoltage <= (p[6])){
 880                                         capacity = 0;
 881                                 }
 882                                 else{
 883                                         for(i = 6; i < BATT_NUM +6; i++){
 884                                                 if(((p[i]) <= BatVoltage) && (BatVoltage < (p[i+1]))){
 885                                                         capacity = (i-6)*10+ ((BatVoltage - p[i]) *10 )/ (p[i+1]- p[i]) ;
 886                                                         break;
 887                                                 }
 888                                         }
 889                                 }
 890
 891                         }
 892
 893
 894                 }
 895
 896 //      }
 897     return capacity;
 898 }
 899
 900 static void rk30_adc_battery_capacity_samples(struct rk30_adc_battery_data *bat)
 901 {
 902         int capacity = 0;
 903 //      struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 904         int timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE;
 905         int timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE;
 906
 907         //³ä·Åµç×´Ì¬±ä»¯ºó£¬BufferÌîÂúÖ®Ç°£¬²»¸üÐÂ
 908         if (bat->bat_status_cnt < NUM_VOLTAGE_SAMPLE)  {
 909                 bat->gBatCapacityDisChargeCnt = 0;
 910                 bat->gBatCapacityChargeCnt    = 0;
 911                 return;
 912         }
 913
 914         capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
 915
 916         if (rk30_adc_battery_get_charge_level(bat)){
 917                 if (capacity > bat->bat_capacity){
 918                         if(capacity > bat->bat_capacity + 10 )
 919                                 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -10;  //5s
 920                         else if(capacity > bat->bat_capacity + 7 )
 921                                 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -5; //10s
 922                                 else if(capacity > bat->bat_capacity + 3 )
 923                                         timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE - 2; // 13
 924                         //Êµ¼Ê²ÉÑùµ½µÄÈÝÁ¿±ÈÏÔÊ¾µÄÈÝÁ¿´ó£¬Öð¼¶ÉÏÉý
 925                         if (++(bat->gBatCapacityDisChargeCnt) >= timer_of_charge_sample){
 926                                 bat->gBatCapacityDisChargeCnt  = 0;
 927                                 if (bat->bat_capacity < 99){
 928                                         bat->bat_capacity++;
 929                                         bat->bat_change  = 1;
 930                                 }
 931                         }
 932                         bat->gBatCapacityChargeCnt = 0;
 933                 }
 934                 else{  //   Êµ¼ÊµÄÈÝÁ¿±È²ÉÑù±È ÏÔÊ¾µÄÈÝÁ¿Ð¡
 935                             bat->gBatCapacityDisChargeCnt = 0;
 936                             (bat->gBatCapacityChargeCnt)++;
 937                                 if( is_charge_ok(bat) != INVALID_CHARGE_CHECK){
 938                         //if (pdata->charge_ok_pin != INVALID_GPIO){
 939                                 //if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level){
 940                                 if( is_charge_ok(bat) == CHARGE_IS_OK){
 941                                         if(capacity > bat->bat_capacity + 10 )
 942                                                 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -13;  //  2s
 943                                         else if(capacity > bat->bat_capacity + 7 )
 944                                                 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -10; //10s
 945                                         else if(capacity > bat->bat_capacity + 2 )
 946                                                 timer_of_charge_sample = NUM_CHARGE_MIN_SAMPLE -8; //7s
 947                                 //¼ì²âµ½µç³Ø³äÂú±êÖ¾£¬Í¬Ê±³¤Ê±¼äÄÚ³äµçµçÑ¹ÎÞ±ä»¯£¬¿ªÊ¼Æô¶¯¼ÆÊ±³äµç£¬¿ìËÙÉÏÉýÈÝÁ¿
 948                                         if (bat->gBatCapacityChargeCnt >= timer_of_charge_sample){
 949                                                 bat->gBatCapacityChargeCnt = 0;
 950                                                 if (bat->bat_capacity < 99){
 951                                                         bat->bat_capacity++;
 952                                                         bat->bat_change  = 1;
 953                                                 }
 954                                         }
 955                                 }
 956                                 else{
 957 #if 0
 958                                         if (capacity > capacitytmp){
 959                                         //¹ý³ÌÖÐÈç¹ûµçÑ¹ÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±ÈÊµ¼Ê³äµç¿ì
 960                                                 gBatCapacityChargeCnt = 0;
 961                                         }
 962                                         else if (/*bat->bat_capacity >= 85) &&*/ (gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)){
 963                                                 gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
 964
 965                                                 if (bat->bat_capacity < 99){
 966                                                 bat->bat_capacity++;
 967                                                 bat->bat_change  = 1;
 968                                                 }
 969                                         }
 970                                 }
 971 #else                   //  ·ÀÖ¹µç³ØÀÏ»¯ºó³öÏÖ³å²»ÂúµÄÇé¿ö£¬
 972                                         if (capacity > bat->capacitytmp){
 973                                         //¹ý³ÌÖÐÈç¹ûµçÑ¹ÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±ÈÊµ¼Ê³äµç¿ì
 974                                                 bat->gBatCapacityChargeCnt = 0;
 975                                         }
 976                                         else{
 977
 978                                                 if ((bat->bat_capacity >= 85) &&((bat->gBatCapacityChargeCnt) > NUM_CHARGE_MAX_SAMPLE)){
 979                                                         bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
 980
 981                                                         if (bat->bat_capacity < 99){
 982                                                                 bat->bat_capacity++;
 983                                                                 bat->bat_change  = 1;
 984                                                         }
 985                                                 }
 986                                         }
 987                                 }
 988 #endif
 989
 990                         }
 991                         else{
 992                         //Ã»ÓÐ³äµçÂú¼ì²â½Å£¬³¤Ê±¼äÄÚµçÑ¹ÎÞ±ä»¯£¬¶¨Ê±Æ÷Ä£Äâ³äµç
 993                                 if (capacity > bat->capacitytmp){
 994                                 //¹ý³ÌÖÐÈç¹ûµçÑ¹ÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±ÈÊµ¼Ê³äµç¿ì
 995                                         bat->gBatCapacityChargeCnt = 0;
 996                                 }
 997                                 else{
 998
 999                                         if ((bat->bat_capacity >= 85) &&(bat->gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)){
1000                                                 bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
1001
1002                                                 if (bat->bat_capacity < 99){
1003                                                         bat->bat_capacity++;
1004                                                         bat->bat_change  = 1;
1005                                                 }
1006                                         }
1007                                 }
1008
1009
1010                         }
1011                 }
1012         }
1013         else{
1014         //·ÅµçÊ±,Ö»ÔÊÐíµçÑ¹ÏÂ½µ
1015                 if (capacity < bat->bat_capacity){
1016                         if(capacity + 10 > bat->bat_capacity  )
1017                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -10;  //5s
1018                         else if(capacity  + 7 > bat->bat_capacity )
1019                                 timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE -5; //10s
1020                                 else if(capacity  + 3> bat->bat_capacity )
1021                                         timer_of_discharge_sample = NUM_CHARGE_MIN_SAMPLE - 2; // 13
1022
1023                         if (++(bat->gBatCapacityDisChargeCnt) >= timer_of_discharge_sample){
1024                                 bat->gBatCapacityDisChargeCnt = 0;
1025                                 if (bat->bat_capacity > 0){
1026                                         bat->bat_capacity-- ;
1027                                         bat->bat_change  = 1;
1028                                 }
1029                         }
1030                 }
1031                 else{
1032                         bat->gBatCapacityDisChargeCnt = 0;
1033                 }
1034                 bat->gBatCapacityChargeCnt = 0;
1035         }
1036                 bat->capacitytmp = capacity;
1037 }
1038
1039 //static int poweron_check = 0;
1040 static void rk30_adc_battery_poweron_capacity_check(void)
1041 {
1042
1043         int new_capacity, old_capacity;
1044          int cnt = 50 ;
1045
1046         new_capacity = gBatteryData->bat_capacity;
1047
1048         while( cnt -- ){
1049             old_capacity = rk30_adc_battery_load_capacity();
1050            // printk("------------------->> : %d \n",old_capacity);
1051             if( old_capacity >= 0 ){
1052                 break ;
1053             }
1054             msleep(100);
1055         }
1056 //      printk("---------------------------------------------------------->> : %d \n",old_capacity);
1057         if ((old_capacity < 0) || (old_capacity > 100)){
1058                 old_capacity = new_capacity;
1059         }
1060
1061         if (gBatteryData->bat_status == POWER_SUPPLY_STATUS_FULL){
1062                 if (new_capacity > 80){
1063                         gBatteryData->bat_capacity = 100;
1064                 }
1065         }
1066         else if (gBatteryData->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING){
1067         //chargeing state
1068         //ÎÊÌâ£º
1069 //      //1£©³¤Ê±¼ä¹Ø»ú·ÅÖÃºó£¬¿ª»úºó¶ÁÈ¡µÄÈÝÁ¿Ô¶Ô¶´óÓÚÊµ¼ÊÈÝÁ¿ÔõÃ´°ì£¿
1070 //      //2£©Èç¹û²»ÕâÑù×ö£¬¶ÌÊ±¼ä¹Ø»úÔÙ¿ª»ú£¬Ç°ºóÈÝÁ¿²»Ò»ÖÂÓÖ¸ÃÔõÃ´°ì£¿
1071 //      //3£©Ò»ÏÂÄÇÖÖ·½Ê½ºÏÊÊ£¿
1072         //gBatteryData->bat_capacity = new_capacity;
1073         //      gBatteryData->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
1074                 if( gBatteryData ->pdata->is_reboot_charging == 1)
1075                         gBatteryData->bat_capacity = old_capacity;
1076                 else
1077                         gBatteryData->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
1078
1079         }else{
1080
1081                 if(new_capacity > old_capacity + 50 )
1082                         gBatteryData->bat_capacity = new_capacity;
1083                 else
1084                         gBatteryData->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity;  //avoid the value of capacity increase
1085         }
1086
1087
1088         printk("capacity = %d, new_capacity = %d, old_capacity = %d\n",gBatteryData->bat_capacity, new_capacity, old_capacity);
1089
1090         gBatteryData->bat_change = 1;
1091 }
1092
1093 static int rk30_adc_battery_get_usb_property(struct power_supply *psy,
1094                                     enum power_supply_property psp,
1095                                     union power_supply_propval *val)
1096 {
1097         charger_type_t charger;
1098         charger =  CHARGER_USB;
1099
1100         switch (psp) {
1101         case POWER_SUPPLY_PROP_ONLINE:
1102                 if (psy->type == POWER_SUPPLY_TYPE_USB)
1103                         val->intval = gBatteryData ->usb_charging;
1104                 //printk("%s:%d\n",__FUNCTION__,val->intval);
1105                 break;
1106
1107         default:
1108                 return -EINVAL;
1109         }
1110
1111         return 0;
1112
1113 }
1114
1115 static enum power_supply_property rk30_adc_battery_usb_props[] = {
1116
1117         POWER_SUPPLY_PROP_ONLINE,
1118 };
1119
1120 static struct power_supply rk30_usb_supply =
1121 {
1122         .name = "usb",
1123         .type = POWER_SUPPLY_TYPE_USB,
1124
1125         .get_property   = rk30_adc_battery_get_usb_property,
1126
1127         .properties     = rk30_adc_battery_usb_props,
1128         .num_properties = ARRAY_SIZE(rk30_adc_battery_usb_props),
1129 };
1130
1131 #if defined(CONFIG_BATTERY_RK30_AC_CHARGE)
1132 static irqreturn_t rk30_adc_battery_dc_wakeup(int irq, void *dev_id)
1133 {
1134         queue_work(gBatteryData->wq, &gBatteryData->dcwakeup_work);
1135         return IRQ_HANDLED;
1136 }
1137
1138
1139 static int rk30_adc_battery_get_ac_property(struct power_supply *psy,
1140                         enum power_supply_property psp,
1141                         union power_supply_propval *val)
1142 {
1143         int ret = 0;
1144         charger_type_t charger;
1145         charger =  CHARGER_USB;
1146         switch (psp) {
1147         case POWER_SUPPLY_PROP_ONLINE:
1148                 if (psy->type == POWER_SUPPLY_TYPE_MAINS)
1149                 {
1150                         rk30_adc_battery_get_charge_level(gBatteryData);
1151                         val->intval = gBatteryData ->ac_charging;
1152                 }
1153                 DBG("%s:%d\n",__FUNCTION__,val->intval);
1154                 break;
1155
1156         default:
1157                 ret = -EINVAL;
1158                 break;
1159         }
1160
1161         return ret;
1162 }
1163
1164 static enum power_supply_property rk30_adc_battery_ac_props[] =
1165 {
1166         POWER_SUPPLY_PROP_ONLINE,
1167 };
1168
1169 static struct power_supply rk30_ac_supply =
1170 {
1171         .name = "ac",
1172         .type = POWER_SUPPLY_TYPE_MAINS,
1173
1174         .get_property   = rk30_adc_battery_get_ac_property,
1175
1176         .properties     = rk30_adc_battery_ac_props,
1177         .num_properties = ARRAY_SIZE(rk30_adc_battery_ac_props),
1178 };
1179
1180 static void rk30_adc_battery_dcdet_delaywork(struct work_struct *work)
1181 {
1182         int ret;
1183         struct rk30_adc_battery_platform_data *pdata;
1184         int irq;
1185         int irq_flag;
1186
1187         pdata    = gBatteryData->pdata;
1188         irq        = gpio_to_irq(pdata->dc_det_pin);
1189         irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1190
1191         rk28_send_wakeup_key(); // wake up the system
1192
1193         free_irq(irq, NULL);
1194         ret = request_irq(irq, rk30_adc_battery_dc_wakeup, irq_flag, "ac_charge_irq", NULL);// reinitialize the DC irq
1195         if (ret) {
1196                 free_irq(irq, NULL);
1197         }
1198
1199         power_supply_changed(&rk30_ac_supply);
1200
1201         gBatteryData->bat_status_cnt = 0;        //the state of battery is change
1202
1203 }
1204
1205
1206 #endif
1207
1208 static int rk30_adc_battery_get_status(struct rk30_adc_battery_data *bat)
1209 {
1210         return (bat->bat_status);
1211 }
1212
1213 static int rk30_adc_battery_get_health(struct rk30_adc_battery_data *bat)
1214 {
1215         return POWER_SUPPLY_HEALTH_GOOD;
1216 }
1217
1218 static int rk30_adc_battery_get_present(struct rk30_adc_battery_data *bat)
1219 {
1220         return (bat->bat_voltage < BATT_MAX_VOL_VALUE) ? 0 : 1;
1221 }
1222
1223 static int rk30_adc_battery_get_voltage(struct rk30_adc_battery_data *bat)
1224 {
1225         return (bat->bat_voltage );
1226 }
1227
1228 static int rk30_adc_battery_get_capacity(struct rk30_adc_battery_data *bat)
1229 {
1230         return (bat->bat_capacity);
1231 }
1232
1233 static int rk30_adc_battery_get_property(struct power_supply *psy,
1234                                  enum power_supply_property psp,
1235                                  union power_supply_propval *val)
1236 {
1237         int ret = 0;
1238
1239         switch (psp) {
1240                 case POWER_SUPPLY_PROP_STATUS:
1241                         val->intval = rk30_adc_battery_get_status(gBatteryData);
1242                         DBG("gBatStatus=%d\n",val->intval);
1243                         break;
1244                 case POWER_SUPPLY_PROP_HEALTH:
1245                         val->intval = rk30_adc_battery_get_health(gBatteryData);
1246                         DBG("gBatHealth=%d\n",val->intval);
1247                         break;
1248                 case POWER_SUPPLY_PROP_PRESENT:
1249                         val->intval = rk30_adc_battery_get_present(gBatteryData);
1250                         DBG("gBatPresent=%d\n",val->intval);
1251                         break;
1252                 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1253                         val ->intval = rk30_adc_battery_get_voltage(gBatteryData);
1254                         DBG("gBatVoltage=%d\n",val->intval);
1255                         break;
1256                 //      case POWER_SUPPLY_PROP_CURRENT_NOW:
1257                 //              val->intval = 1100;
1258                 //              break;
1259                 case POWER_SUPPLY_PROP_CAPACITY:
1260                         if(battery_test_flag == 2)
1261                                 val->intval = 50;
1262                         else
1263                                 val->intval = rk30_adc_battery_get_capacity(gBatteryData);
1264                         DBG("gBatCapacity=%d%%\n",val->intval);
1265                         break;
1266                 case POWER_SUPPLY_PROP_TECHNOLOGY:
1267                         val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
1268                         break;
1269                 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
1270                         val->intval = BATT_MAX_VOL_VALUE;
1271                         break;
1272                 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
1273                         val->intval = BATT_ZERO_VOL_VALUE;
1274                         break;
1275                 default:
1276                         ret = -EINVAL;
1277                         break;
1278         }
1279
1280         return ret;
1281 }
1282
1283 static enum power_supply_property rk30_adc_battery_props[] = {
1284
1285         POWER_SUPPLY_PROP_STATUS,
1286         POWER_SUPPLY_PROP_HEALTH,
1287         POWER_SUPPLY_PROP_PRESENT,
1288         POWER_SUPPLY_PROP_VOLTAGE_NOW,
1289 //      POWER_SUPPLY_PROP_CURRENT_NOW,
1290         POWER_SUPPLY_PROP_TECHNOLOGY,
1291         POWER_SUPPLY_PROP_CAPACITY,
1292         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
1293         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
1294 };
1295
1296 static struct power_supply rk30_battery_supply =
1297 {
1298         .name = "battery",
1299         .type = POWER_SUPPLY_TYPE_BATTERY,
1300
1301         .get_property   = rk30_adc_battery_get_property,
1302
1303         .properties     = rk30_adc_battery_props,
1304         .num_properties = ARRAY_SIZE(rk30_adc_battery_props),
1305 };
1306
1307 #ifdef CONFIG_PM
1308 static void rk30_adc_battery_resume_check(void)
1309 {
1310         int i;
1311         int level,oldlevel;
1312         int new_capacity, old_capacity;
1313         struct rk30_adc_battery_data *bat = gBatteryData;
1314
1315         bat->old_charge_level = -1;
1316         pSamples = bat->adc_samples;
1317
1318         adc_sync_read(bat->client);                             //start adc sample
1319         level = oldlevel = rk30_adc_battery_status_samples(bat);//init charge status
1320
1321         for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++) {               //0.3 s
1322
1323                 mdelay(1);
1324                 rk30_adc_battery_voltage_samples(bat);              //get voltage
1325                 level = rk30_adc_battery_status_samples(bat);       //check charge status
1326                 if (oldlevel != level){
1327                     oldlevel = level;                               //if charge status changed, reset sample
1328                     i = 0;
1329                 }
1330         }
1331         new_capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
1332         old_capacity =gBatteryData-> suspend_capacity;
1333
1334         if (bat->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING){
1335         //chargeing state
1336                 bat->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
1337         }
1338         else{
1339                 bat->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity;  // aviod the value of capacity increase    dicharge
1340         }
1341
1342 }
1343
1344 static int rk30_adc_battery_suspend(struct platform_device *dev, pm_message_t state)
1345 {
1346         int irq;
1347         gBatteryData->suspend_capacity = gBatteryData->bat_capacity;
1348         cancel_delayed_work(&gBatteryData->delay_work);
1349
1350         if( gBatteryData->pdata->batt_low_pin != INVALID_GPIO){
1351
1352                 irq = gpio_to_irq(gBatteryData->pdata->batt_low_pin);
1353                 enable_irq(irq);
1354                 enable_irq_wake(irq);
1355         }
1356
1357         return 0;
1358 }
1359
1360 static int rk30_adc_battery_resume(struct platform_device *dev)
1361 {
1362         int irq;
1363         gBatteryData->resume = true;
1364         queue_delayed_work(gBatteryData->wq, &gBatteryData->delay_work, msecs_to_jiffies(100));
1365         if( gBatteryData->pdata->batt_low_pin != INVALID_GPIO){
1366
1367                 irq = gpio_to_irq(gBatteryData->pdata->batt_low_pin);
1368                 disable_irq_wake(irq);
1369                 disable_irq(irq);
1370         }
1371         return 0;
1372 }
1373 #else
1374 #define rk30_adc_battery_suspend NULL
1375 #define rk30_adc_battery_resume NULL
1376 #endif
1377
1378
1379 unsigned long AdcTestCnt = 0;
1380 static void rk30_adc_battery_timer_work(struct work_struct *work)
1381 {
1382 #ifdef CONFIG_PM
1383         if (gBatteryData->resume) {
1384                 rk30_adc_battery_resume_check();
1385                 gBatteryData->resume = false;
1386         }
1387 #endif
1388
1389
1390         rk30_adc_battery_status_samples(gBatteryData);
1391
1392         if (gBatteryData->poweron_check){
1393                 gBatteryData->poweron_check = 0;
1394                 rk30_adc_battery_poweron_capacity_check();
1395         }
1396
1397         rk30_adc_battery_voltage_samples(gBatteryData);
1398         rk30_adc_battery_capacity_samples(gBatteryData);
1399
1400         if( 0 == gBatteryData ->pdata ->charging_sleep){
1401                 if( 1 == rk30_adc_battery_get_charge_level(gBatteryData)){  // charge
1402                         if(0 == gBatteryData->status_lock ){
1403                                 wake_lock(&batt_wake_lock);  //lock
1404                                 gBatteryData->status_lock = 1;
1405                         }
1406                 }
1407                 else{
1408                         if(1 == gBatteryData->status_lock ){
1409                                 wake_unlock(&batt_wake_lock);  //unlock
1410                                 gBatteryData->status_lock = 0;
1411                         }
1412
1413                 }
1414         }
1415
1416
1417         /*update battery parameter after adc and capacity has been changed*/
1418         if(gBatteryData->bat_change){
1419                 gBatteryData->bat_change = 0;
1420                 rk30_adc_battery_put_capacity(gBatteryData->bat_capacity);
1421                 power_supply_changed(&rk30_battery_supply);
1422 #if  defined (CONFIG_BATTERY_RK30_AC_CHARGE)
1423         //      if (gBatteryData->pdata->dc_det_pin == INVALID_GPIO){
1424                         power_supply_changed(&rk30_ac_supply);
1425         //      }
1426
1427 #endif
1428                  if(1 == gBatteryData->pdata->spport_usb_charging){
1429                         power_supply_changed(&rk30_usb_supply);
1430                  }
1431
1432
1433         }
1434
1435         if (rk30_battery_dbg_level){
1436                 if (++AdcTestCnt >= 2)
1437                         {
1438                         AdcTestCnt = 0;
1439
1440                         pr_bat("Status = %d, RealAdcVal = %d, RealVol = %d,gBatVol = %d, gBatCap = %d, RealCapacity = %d, dischargecnt = %d, chargecnt = %d\n",
1441                         gBatteryData->bat_status, gBatteryData->adc_val, rk_adc_voltage(gBatteryData->adc_val),
1442                         gBatteryData->bat_voltage, gBatteryData->bat_capacity, gBatteryData->capacitytmp, gBatteryData->gBatCapacityDisChargeCnt,gBatteryData-> gBatCapacityChargeCnt);
1443
1444                 }
1445         }
1446         queue_delayed_work(gBatteryData->wq, &gBatteryData->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS));
1447
1448 }
1449
1450
1451 static int rk30_adc_battery_io_init(struct rk30_adc_battery_platform_data *pdata)
1452 {
1453         int ret = 0;
1454
1455         if (pdata->io_init) {
1456                 pdata->io_init();
1457                 return 0;
1458         }
1459
1460         //charge control pin
1461         if (pdata->charge_set_pin != INVALID_GPIO){
1462                 ret = gpio_request(pdata->charge_set_pin, NULL);
1463                 if (ret) {
1464                         printk("failed to request dc_det gpio\n");
1465                         goto error;
1466                         }
1467                 gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
1468         }
1469
1470         //dc charge detect pin
1471         if (pdata->dc_det_pin != INVALID_GPIO){
1472                 ret = gpio_request(pdata->dc_det_pin, NULL);
1473                 if (ret) {
1474                         printk("failed to request dc_det gpio\n");
1475                         goto error;
1476                 }
1477
1478                 gpio_pull_updown(pdata->dc_det_pin, GPIOPullUp);//important
1479                 ret = gpio_direction_input(pdata->dc_det_pin);
1480                 if (ret) {
1481                         printk("failed to set gpio dc_det input\n");
1482                         goto error;
1483                 }
1484         }
1485
1486         //charge ok detect
1487         if (pdata->charge_ok_pin != INVALID_GPIO){
1488                 ret = gpio_request(pdata->charge_ok_pin, NULL);
1489                 if (ret) {
1490                         printk("failed to request charge_ok gpio\n");
1491                         goto error;
1492                 }
1493
1494                 gpio_pull_updown(pdata->charge_ok_pin, GPIOPullUp);//important
1495                 ret = gpio_direction_input(pdata->charge_ok_pin);
1496                 if (ret) {
1497                         printk("failed to set gpio charge_ok input\n");
1498                         goto error;
1499                 }
1500         }
1501         //batt low pin
1502         if( pdata->batt_low_pin != INVALID_GPIO){
1503                 ret = gpio_request(pdata->batt_low_pin, NULL);
1504                 if (ret) {
1505                         printk("failed to request batt_low_pin gpio\n");
1506                         goto error;
1507                 }
1508
1509                 gpio_pull_updown(pdata->batt_low_pin, GPIOPullUp);
1510                 ret = gpio_direction_input(pdata->batt_low_pin);
1511                 if (ret) {
1512                         printk("failed to set gpio batt_low_pin input\n");
1513                         goto error;
1514                 }
1515         }
1516
1517         return 0;
1518 error:
1519         return -1;
1520 }
1521
1522 extern void kernel_power_off(void);
1523 static void rk30_adc_battery_check(struct rk30_adc_battery_data *bat)
1524 {
1525         int i;
1526         int level,oldlevel;
1527         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
1528         //printk("%s--%d:\n",__FUNCTION__,__LINE__);
1529
1530         bat->old_charge_level = -1;
1531         bat->capacitytmp = 0;
1532         bat->suspend_capacity = 0;
1533
1534         pSamples = bat->adc_samples;
1535
1536         adc_sync_read(bat->client);                             //start adc sample
1537         level = oldlevel = rk30_adc_battery_status_samples(bat);//init charge status
1538
1539         bat->full_times = 0;
1540         for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++){                //0.3 s
1541                 mdelay(1);
1542                 rk30_adc_battery_voltage_samples(bat);              //get voltage
1543                 //level = rk30_adc_battery_status_samples(bat);       //check charge status
1544                 level = rk30_adc_battery_get_charge_level(bat);
1545
1546                 if (oldlevel != level){
1547                         oldlevel = level;                               //if charge status changed, reset sample
1548                         i = 0;
1549                 }
1550         }
1551
1552         bat->bat_capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);  //init bat_capacity
1553
1554
1555         bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1556         if (rk30_adc_battery_get_charge_level(bat)){
1557                 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
1558
1559                 if (pdata->charge_ok_pin != INVALID_GPIO){
1560                         if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level){
1561                                 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
1562                                 bat->bat_capacity = 100;
1563                         }
1564                 }
1565         }
1566
1567
1568
1569 #if 0
1570 #if 1
1571         rk30_adc_battery_poweron_capacity_check();
1572 #else
1573         gBatteryData->poweron_check = 1;
1574 #endif
1575         gBatteryData->poweron_check = 0;
1576 #endif
1577 /*******************************************
1578 //¿ª»ú²ÉÑùµ½µÄµçÑ¹ºÍÉÏ´Î¹Ø»ú±£´æµçÑ¹Ïà²î½Ï´ó£¬ÔõÃ´´¦Àí£¿
1579 if (bat->bat_capacity > old_capacity)
1580 {
1581 if ((bat->bat_capacity - old_capacity) > 20)
1582 {
1583
1584 }
1585 }
1586 else if (bat->bat_capacity < old_capacity)
1587 {
1588 if ((old_capacity > bat->bat_capacity) > 20)
1589 {
1590
1591 }
1592 }
1593 *********************************************/
1594         if (bat->bat_capacity == 0) bat->bat_capacity = 1;
1595
1596
1597         if(1==gBatteryData -> pdata->low_voltage_protection)
1598                 if ((bat->bat_voltage <= BATT_ZERO_VOL_VALUE)&&(bat->bat_status != POWER_SUPPLY_STATUS_CHARGING)){
1599                         kernel_power_off();
1600                 }
1601
1602 }
1603
1604 static void rk30_adc_battery_callback(struct adc_client *client, void *param, int result)
1605 {
1606 #if 0
1607         struct rk30_adc_battery_data  *info = container_of(client, struct rk30_adc_battery_data,
1608                 client);
1609         info->adc_val = result;
1610 #endif
1611         if (result < 0){
1612                 pr_bat("adc_battery_callback    resule < 0 , the value ");
1613                 return;
1614         }
1615         else{
1616                 gBatteryData->adc_val = result;
1617                 pr_bat("result = %d, gBatteryData->adc_val = %d\n", result, gBatteryData->adc_val );
1618         }
1619         return;
1620 }
1621
1622 #if 1
1623 static void rk30_adc_battery_lowerpower_delaywork(struct work_struct *work)
1624 {
1625         int irq;
1626         if( gBatteryData->pdata->batt_low_pin != INVALID_GPIO){
1627                 irq = gpio_to_irq(gBatteryData->pdata->batt_low_pin);
1628                 disable_irq(irq);
1629         }
1630
1631         printk("lowerpower\n");
1632         rk28_send_wakeup_key(); // wake up the system
1633         return;
1634 }
1635
1636
1637 static irqreturn_t rk30_adc_battery_low_wakeup(int irq,void *dev_id)
1638 {
1639         queue_work(gBatteryData->wq, &gBatteryData->lowerpower_work);
1640         return IRQ_HANDLED;
1641 }
1642
1643 #endif
1644
1645 static int rk30_adc_battery_probe(struct platform_device *pdev)
1646 {
1647         int    ret;
1648         int    irq;
1649         int    irq_flag;
1650         struct adc_client                   *client;
1651         struct rk30_adc_battery_data          *data;
1652         struct rk30_adc_battery_platform_data *pdata = pdev->dev.platform_data;
1653         gSecondsCnt = get_seconds();
1654         data = kzalloc(sizeof(*data), GFP_KERNEL);
1655         if (data == NULL) {
1656                 ret = -ENOMEM;
1657                 goto err_data_alloc_failed;
1658         }
1659         memset(data, 0, sizeof(struct rk30_adc_battery_data));
1660         gBatteryData = data;
1661
1662         platform_set_drvdata(pdev, data);
1663
1664         data->pdata = pdata;
1665         data->status_lock = 0;
1666         ret = rk30_adc_battery_io_init(pdata);
1667          if (ret) {
1668                 ret = -EINVAL;
1669                 goto err_io_init;
1670         }
1671
1672         memset(data->adc_samples, 0, sizeof(int)*(NUM_VOLTAGE_SAMPLE + 2));
1673
1674          //register adc for battery sample
1675          if(0 == pdata->adc_channel)
1676                 client = adc_register(0, rk30_adc_battery_callback, NULL);  //pdata->adc_channel = ani0
1677         else
1678                 client = adc_register(pdata->adc_channel, rk30_adc_battery_callback, NULL);
1679         if(!client){
1680                 ret = -EINVAL;
1681                 goto err_adc_register_failed;
1682         }
1683
1684          //variable init
1685         data->client  = client;
1686         data->adc_val = adc_sync_read(client);
1687
1688         ret = power_supply_register(&pdev->dev, &rk30_battery_supply);
1689         if (ret){
1690                 ret = -EINVAL;
1691                 printk(KERN_INFO "fail to battery power_supply_register\n");
1692                 goto err_battery_failed;
1693         }
1694 #ifdef BATTERY_APK
1695         ret = device_create_file(&pdev->dev,&dev_attr_batparam);
1696         if(ret){
1697                 ret = -EINVAL;
1698                 printk(KERN_ERR "failed to create bat param file\n");
1699                 goto err_battery_failed;
1700         }
1701
1702 #endif
1703          if(1 == pdata->spport_usb_charging){
1704                 ret = power_supply_register(&pdev->dev, &rk30_usb_supply);
1705                 if (ret){
1706                         ret = -EINVAL;
1707                         printk(KERN_INFO "fail to usb power_supply_register\n");
1708                         goto err_usb_failed;
1709                 }
1710         }
1711         wake_lock_init(&batt_wake_lock, WAKE_LOCK_SUSPEND, "batt_lock");
1712
1713         data->wq = create_singlethread_workqueue("adc_battd");
1714         INIT_DELAYED_WORK(&data->delay_work, rk30_adc_battery_timer_work);
1715         //Power on Battery detect
1716         rk30_adc_battery_check(data);
1717         if(1 == pdata->save_capacity ){
1718                 queue_delayed_work(data->wq, &data->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS*10));
1719                 gBatteryData->poweron_check = 1;
1720         }else{
1721                 queue_delayed_work(data->wq, &data->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS));
1722                 gBatteryData->poweron_check = 0;
1723         }
1724
1725 #if  defined (CONFIG_BATTERY_RK30_AC_CHARGE)
1726         ret = power_supply_register(&pdev->dev, &rk30_ac_supply);
1727         if (ret) {
1728                 ret = -EINVAL;
1729                 printk(KERN_INFO "fail to ac power_supply_register\n");
1730                 goto err_ac_failed;
1731         }
1732         //init dc dectet irq & delay work
1733         if (pdata->dc_det_pin != INVALID_GPIO){
1734                 INIT_WORK(&data->dcwakeup_work, rk30_adc_battery_dcdet_delaywork);
1735
1736                 irq = gpio_to_irq(pdata->dc_det_pin);
1737                 irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1738                 ret = request_irq(irq, rk30_adc_battery_dc_wakeup, irq_flag, "ac_charge_irq", NULL);
1739                 if (ret) {
1740                         ret = -EINVAL;
1741                         printk("failed to request dc det irq\n");
1742                         goto err_dcirq_failed;
1743                 }
1744                 enable_irq_wake(irq);
1745
1746         }
1747 #endif
1748
1749 #if 1
1750         // batt low irq lowerpower_work
1751         if( pdata->batt_low_pin != INVALID_GPIO){
1752                 INIT_WORK(&data->lowerpower_work, rk30_adc_battery_lowerpower_delaywork);
1753
1754                 irq = gpio_to_irq(pdata->batt_low_pin);
1755                 ret = request_irq(irq, rk30_adc_battery_low_wakeup, IRQF_TRIGGER_LOW, "batt_low_irq", NULL);
1756
1757                 if (ret) {
1758                         ret = -EINVAL;
1759                         printk("failed to request batt_low_irq irq\n");
1760                         goto err_lowpowerirq_failed;
1761                 }
1762                 disable_irq(irq);
1763
1764         }
1765 #endif
1766
1767 #ifdef  BATTERY_APK
1768         ret = create_sysfs_interfaces(&pdev->dev);
1769         if (ret < 0)
1770         {
1771                 ret = -EINVAL;
1772                 dev_err(&pdev->dev,
1773                         "device rk30_adc_batterry sysfs register failed\n");
1774                 goto err_sysfs;
1775         }
1776
1777 #endif
1778         printk(KERN_INFO "rk30_adc_battery: driver initialized\n");
1779
1780         return 0;
1781 err_sysfs:
1782 err_usb_failed:
1783         power_supply_unregister(&rk30_usb_supply);
1784
1785 err_ac_failed:
1786 #if defined (CONFIG_BATTERY_RK30_AC_CHARGE)
1787         power_supply_unregister(&rk30_ac_supply);
1788 #endif
1789
1790 err_battery_failed:
1791         power_supply_unregister(&rk30_battery_supply);
1792
1793 err_dcirq_failed:
1794         free_irq(gpio_to_irq(pdata->dc_det_pin), data);
1795 #if 1
1796  err_lowpowerirq_failed:
1797         free_irq(gpio_to_irq(pdata->batt_low_pin), data);
1798 #endif
1799 err_adc_register_failed:
1800 err_io_init:
1801 err_data_alloc_failed:
1802         kfree(data);
1803
1804         printk("rk30_adc_battery: error!\n");
1805
1806         return ret;
1807 }
1808
1809 static int rk30_adc_battery_remove(struct platform_device *pdev)
1810 {
1811         struct rk30_adc_battery_data *data = platform_get_drvdata(pdev);
1812         struct rk30_adc_battery_platform_data *pdata = pdev->dev.platform_data;
1813
1814         cancel_delayed_work(&gBatteryData->delay_work);
1815          if(1 == pdata->spport_usb_charging){
1816         power_supply_unregister(&rk30_usb_supply);
1817          }
1818 #if defined(CONFIG_BATTERY_RK30_AC_CHARGE)
1819         power_supply_unregister(&rk30_ac_supply);
1820 #endif
1821         power_supply_unregister(&rk30_battery_supply);
1822
1823         free_irq(gpio_to_irq(pdata->dc_det_pin), data);
1824
1825         kfree(data);
1826
1827         return 0;
1828 }
1829
1830 static struct platform_driver rk30_adc_battery_driver = {
1831         .probe          = rk30_adc_battery_probe,
1832         .remove         = rk30_adc_battery_remove,
1833         .suspend                = rk30_adc_battery_suspend,
1834         .resume         = rk30_adc_battery_resume,
1835         .driver = {
1836                 .name = "rk30-battery",
1837                 .owner  = THIS_MODULE,
1838         }
1839 };
1840
1841 static int __init rk30_adc_battery_init(void)
1842 {
1843         return platform_driver_register(&rk30_adc_battery_driver);
1844 }
1845
1846 static void __exit rk30_adc_battery_exit(void)
1847 {
1848         platform_driver_unregister(&rk30_adc_battery_driver);
1849 }
1850
1851 module_init(rk30_adc_battery_init);//module_init(rk30_adc_battery_init);//subsys_initcall(rk30_adc_battery_init);
1852 module_exit(rk30_adc_battery_exit);
1853
1854 MODULE_DESCRIPTION("Battery detect driver for the rk30");
1855 MODULE_AUTHOR("luowei lw@rock-chips.com");
1856 MODULE_LICENSE("GPL");