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