drivers/power/rk30_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
  76 #define  BAT_DEFINE_VALUE                                            1800
  77 #else
  78 #define  BAT_DEFINE_VALUE                                            2500
  79
  80
  81 #endif
  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
  94 #ifdef CONFIG_BATTERY_RK30_VOL3V8
  95
  96 #define BATT_MAX_VOL_VALUE                             4120                     //ÂúµçÊ±µÄµç³ØµçÑ¹
  97 #define BATT_ZERO_VOL_VALUE                            3400                     //¹Ø»úÊ±µÄµç³ØµçÑ¹
  98 #define BATT_NOMAL_VOL_VALUE                         3800
  99 //divider resistance
 100 #define BAT_PULL_UP_R                                         200
 101 #if defined(CONFIG_ARCH_RK3066B)
 102 #define BAT_PULL_DOWN_R                                    100
 103 #else
 104 #define BAT_PULL_DOWN_R                                    200
 105 #endif
 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 #define BATT_NUM  ARRAY_SIZE(batt_table)
 145
 146 #define adc_to_voltage(adc_val)                           ((adc_val * BAT_DEFINE_VALUE * (BAT_PULL_UP_R + BAT_PULL_DOWN_R)) / (1024 * BAT_PULL_DOWN_R))
 147
 148 /********************************************************************************/
 149
 150 extern int dwc_vbus_status(void);
 151 extern int get_msc_connect_flag(void);
 152
 153 struct rk30_adc_battery_data {
 154         int irq;
 155
 156         //struct timer_list       timer;
 157         struct workqueue_struct *wq;
 158         struct delayed_work         delay_work;
 159         struct work_struct          dcwakeup_work;
 160         struct work_struct                   lowerpower_work;
 161         bool                    resume;
 162
 163         struct rk30_adc_battery_platform_data *pdata;
 164
 165         int                     full_times;
 166
 167         struct adc_client       *client;
 168         int                     adc_val;
 169         int                     adc_samples[NUM_VOLTAGE_SAMPLE+2];
 170
 171         int                     bat_status;
 172         int                     bat_status_cnt;
 173         int                     bat_health;
 174         int                     bat_present;
 175         int                     bat_voltage;
 176         int                     bat_capacity;
 177         int                     bat_change;
 178
 179         int                     old_charge_level;
 180         int                    *pSamples;
 181         int                     gBatCapacityDisChargeCnt;
 182         int                     gBatCapacityChargeCnt;
 183         int               capacitytmp;
 184         int                     poweron_check;
 185         int                     suspend_capacity;
 186
 187         int                     status_lock;
 188
 189 };
 190 static struct rk30_adc_battery_data *gBatteryData;
 191
 192 enum {
 193         BATTERY_STATUS          = 0,
 194         BATTERY_HEALTH          = 1,
 195         BATTERY_PRESENT         = 2,
 196         BATTERY_CAPACITY        = 3,
 197         BATTERY_AC_ONLINE       = 4,
 198         BATTERY_STATUS_CHANGED  = 5,
 199         AC_STATUS_CHANGED       = 6,
 200         BATTERY_INT_STATUS          = 7,
 201         BATTERY_INT_ENABLE          = 8,
 202 };
 203
 204 typedef enum {
 205         CHARGER_BATTERY = 0,
 206         CHARGER_USB,
 207         CHARGER_AC
 208 } charger_type_t;
 209
 210
 211
 212
 213
 214 static int rk30_adc_battery_load_capacity(void)
 215 {
 216         char value[4];
 217         int* p = (int *)value;
 218         long fd = sys_open(BATT_FILENAME,O_RDONLY,0);
 219
 220         if(fd < 0){
 221                 pr_bat("rk30_adc_battery_load_capacity: open file /data/bat_last_capacity.dat failed\n");
 222                 return -1;
 223         }
 224
 225         sys_read(fd,(char __user *)value,4);
 226         sys_close(fd);
 227
 228         return (*p);
 229 }
 230
 231 static void rk30_adc_battery_put_capacity(int loadcapacity)
 232 {
 233         char value[4];
 234         int* p = (int *)value;
 235         long fd = sys_open(BATT_FILENAME,O_CREAT | O_RDWR,0);
 236
 237         if(fd < 0){
 238                 pr_bat("rk30_adc_battery_put_capacity: open file /data/bat_last_capacity.dat failed\n");
 239                 return;
 240         }
 241
 242         *p = loadcapacity;
 243         sys_write(fd, (const char __user *)value, 4);
 244
 245         sys_close(fd);
 246 }
 247
 248 static void rk30_adc_battery_charge_enable(struct rk30_adc_battery_data *bat)
 249 {
 250         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 251
 252         if (pdata->charge_set_pin != INVALID_GPIO){
 253                 gpio_direction_output(pdata->charge_set_pin, pdata->charge_set_level);
 254         }
 255 }
 256
 257 static void rk30_adc_battery_charge_disable(struct rk30_adc_battery_data *bat)
 258 {
 259         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 260
 261         if (pdata->charge_set_pin != INVALID_GPIO){
 262                 gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
 263         }
 264 }
 265
 266 //extern int suspend_flag;
 267 static int rk30_adc_battery_get_charge_level(struct rk30_adc_battery_data *bat)
 268 {
 269         int charge_on = 0;
 270         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 271
 272 #if defined (CONFIG_BATTERY_RK30_AC_CHARGE)
 273         if (pdata->dc_det_pin != INVALID_GPIO){
 274                 if (gpio_get_value (pdata->dc_det_pin) == pdata->dc_det_level){
 275                         charge_on = 1;
 276                 }
 277         }
 278 #endif
 279
 280 #if defined  (CONFIG_BATTERY_RK30_USB_CHARGE)
 281         if (charge_on == 0){
 282                 if (suspend_flag)
 283                         return;
 284                 if (1 == dwc_vbus_status()) {          //¼ì²âµ½USB²åÈë£¬µ«ÊÇÎÞ·¨Ê¶±ðÊÇ·ñÊÇ³äµçÆ÷
 285                                                  //Í¨¹ýÑÓÊ±¼ì²âPCÊ¶±ð±êÖ¾£¬Èç¹û³¬Ê±¼ì²â²»µ½£¬ËµÃ÷ÊÇ³äµç
 286                         if (0 == get_msc_connect_flag()){                               //²åÈë³äµçÆ÷Ê±¼ä´óÓÚÒ»¶¨Ê±¼äÖ®ºó£¬¿ªÊ¼½øÈë³äµç×´Ì¬
 287                                 if (++gBatUsbChargeCnt >= NUM_USBCHARGE_IDENTIFY_TIMES){
 288                                         gBatUsbChargeCnt = NUM_USBCHARGE_IDENTIFY_TIMES + 1;
 289                                         charge_on = 1;
 290                                 }
 291                         }                               //·ñÔò£¬²»½øÈë³äµçÄ£Ê½
 292                 }
 293                 else{
 294                         gBatUsbChargeCnt = 0;
 295                         if (2 == dwc_vbus_status()) {
 296                                 charge_on = 1;
 297                         }
 298                 }
 299         }
 300 #endif
 301         return charge_on;
 302 }
 303
 304 //int old_charge_level;
 305 static int rk30_adc_battery_status_samples(struct rk30_adc_battery_data *bat)
 306 {
 307         int charge_level;
 308
 309         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 310
 311         charge_level = rk30_adc_battery_get_charge_level(bat);
 312
 313         //¼ì²â³äµç×´Ì¬±ä»¯Çé¿ö
 314         if (charge_level != bat->old_charge_level){
 315                 bat->old_charge_level = charge_level;
 316                 bat->bat_change  = 1;
 317
 318                 if(charge_level) {
 319                         rk30_adc_battery_charge_enable(bat);
 320                 }
 321                 else{
 322                         rk30_adc_battery_charge_disable(bat);
 323                 }
 324                 bat->bat_status_cnt = 0;        //×´Ì¬±ä»¯¿ªÊ¼¼ÆÊý
 325         }
 326
 327         if(charge_level == 0){
 328         //discharge
 329                 bat->full_times = 0;
 330                 bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 331         }
 332         else{
 333         //CHARGE
 334                 if (pdata->charge_ok_pin == INVALID_GPIO){  //no charge_ok_pin
 335
 336                         if (bat->bat_capacity == 100){
 337                                 if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){
 338                                         bat->bat_status = POWER_SUPPLY_STATUS_FULL;
 339                                         bat->bat_change  = 1;
 340                                 }
 341                         }
 342                         else{
 343                                 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 344                         }
 345                 }
 346                 else{  // pin of charge_ok_pin
 347                         if (gpio_get_value(pdata->charge_ok_pin) != pdata->charge_ok_level){
 348
 349                                 bat->full_times = 0;
 350                                 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 351                         }
 352                         else{
 353         //¼ì²âµ½³äµçÂúµçÆ½±êÖ¾
 354                                 bat->full_times++;
 355
 356                                 if (bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) {
 357                                         bat->full_times = NUM_CHARGE_FULL_DELAY_TIMES + 1;
 358                                 }
 359
 360                                 if ((bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) && (bat->bat_capacity >= 99)){
 361                                         if (bat->bat_status != POWER_SUPPLY_STATUS_FULL){
 362                                                 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
 363                                                 bat->bat_capacity = 100;
 364                                                 bat->bat_change  = 1;
 365                                         }
 366                                 }
 367                                 else{
 368                                         bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 369                                 }
 370                         }
 371                 }
 372         }
 373
 374         return charge_level;
 375 }
 376
 377 static int *pSamples;
 378 static void rk30_adc_battery_voltage_samples(struct rk30_adc_battery_data *bat)
 379 {
 380         int value;
 381         int i,*pStart = bat->adc_samples, num = 0;
 382         int level = rk30_adc_battery_get_charge_level(bat);
 383
 384
 385         value = bat->adc_val;
 386         adc_async_read(bat->client);
 387
 388         *pSamples++ = adc_to_voltage(value);
 389
 390         bat->bat_status_cnt++;
 391         if (bat->bat_status_cnt > NUM_VOLTAGE_SAMPLE)  bat->bat_status_cnt = NUM_VOLTAGE_SAMPLE + 1;
 392
 393         num = pSamples - pStart;
 394
 395         if (num >= NUM_VOLTAGE_SAMPLE){
 396                 pSamples = pStart;
 397                 num = NUM_VOLTAGE_SAMPLE;
 398
 399         }
 400
 401         value = 0;
 402         for (i = 0; i < num; i++){
 403                 value += bat->adc_samples[i];
 404         }
 405         bat->bat_voltage = value / num;
 406
 407         /*Ïû³ýÃ«´ÌµçÑ¹*/
 408         if(1 == level){
 409                 if(bat->bat_voltage >= batt_table[BATT_NUM-1].charge_vol+ 10)
 410                         bat->bat_voltage = batt_table[BATT_NUM-1].charge_vol  + 10;
 411                 else if(bat->bat_voltage <= batt_table[0].charge_vol  - 10)
 412                         bat->bat_voltage =  batt_table[0].charge_vol - 10;
 413         }
 414         else{
 415                 if(bat->bat_voltage >= batt_table[BATT_NUM-1].dis_charge_vol+ 10)
 416                         bat->bat_voltage = batt_table[BATT_NUM-1].dis_charge_vol  + 10;
 417                 else if(bat->bat_voltage <= batt_table[0].dis_charge_vol  - 10)
 418                         bat->bat_voltage =  batt_table[0].dis_charge_vol - 10;
 419
 420         }
 421
 422 }
 423 static int rk30_adc_battery_voltage_to_capacity(struct rk30_adc_battery_data *bat, int BatVoltage)
 424 {
 425         int i = 0;
 426         int capacity = 0;
 427
 428         struct batt_vol_cal *p;
 429         p = batt_table;
 430
 431         if (rk30_adc_battery_get_charge_level(bat)){  //charge
 432                 if(BatVoltage >= (p[BATT_NUM - 1].charge_vol)){
 433                         capacity = 100;
 434                 }
 435                 else{
 436                         if(BatVoltage <= (p[0].charge_vol)){
 437                                 capacity = 0;
 438                         }
 439                         else{
 440                                 for(i = 0; i < BATT_NUM - 1; i++){
 441
 442                                         if(((p[i].charge_vol) <= BatVoltage) && (BatVoltage < (p[i+1].charge_vol))){
 443                                                 capacity = p[i].disp_cal + ((BatVoltage - p[i].charge_vol) *  (p[i+1].disp_cal -p[i].disp_cal ))/ (p[i+1].charge_vol- p[i].charge_vol);
 444                                                 break;
 445                                         }
 446                                 }
 447                         }
 448                 }
 449
 450         }
 451         else{  //discharge
 452                 if(BatVoltage >= (p[BATT_NUM - 1].dis_charge_vol)){
 453                         capacity = 100;
 454                 }
 455                 else{
 456                         if(BatVoltage <= (p[0].dis_charge_vol)){
 457                                 capacity = 0;
 458                         }
 459                         else{
 460                                 for(i = 0; i < BATT_NUM - 1; i++){
 461                                         if(((p[i].dis_charge_vol) <= BatVoltage) && (BatVoltage < (p[i+1].dis_charge_vol))){
 462                                                 capacity =  p[i].disp_cal+ ((BatVoltage - p[i].dis_charge_vol) * (p[i+1].disp_cal -p[i].disp_cal ) )/ (p[i+1].dis_charge_vol- p[i].dis_charge_vol) ;
 463                                                 break;
 464                                         }
 465                                 }
 466                         }
 467
 468                 }
 469
 470
 471         }
 472     return capacity;
 473 }
 474
 475 static void rk30_adc_battery_capacity_samples(struct rk30_adc_battery_data *bat)
 476 {
 477         int capacity = 0;
 478         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
 479
 480         //³ä·Åµç×´Ì¬±ä»¯ºó£¬BufferÌîÂúÖ®Ç°£¬²»¸üÐÂ
 481         if (bat->bat_status_cnt < NUM_VOLTAGE_SAMPLE)  {
 482                 bat->gBatCapacityDisChargeCnt = 0;
 483                 bat->gBatCapacityChargeCnt    = 0;
 484                 return;
 485         }
 486
 487         capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
 488
 489         if (rk30_adc_battery_get_charge_level(bat)){
 490                 if (capacity > bat->bat_capacity){
 491                         //Êµ¼Ê²ÉÑùµ½µÄÈÝÁ¿±ÈÏÔÊ¾µÄÈÝÁ¿´ó£¬Öð¼¶ÉÏÉý
 492                         if (++(bat->gBatCapacityDisChargeCnt) >= NUM_CHARGE_MIN_SAMPLE){
 493                                 bat->gBatCapacityDisChargeCnt  = 0;
 494                                 if (bat->bat_capacity < 99){
 495                                         bat->bat_capacity++;
 496                                         bat->bat_change  = 1;
 497                                 }
 498                         }
 499                         bat->gBatCapacityChargeCnt = 0;
 500                 }
 501                 else{  //   Êµ¼ÊµÄÈÝÁ¿±È²ÉÑù±È ÏÔÊ¾µÄÈÝÁ¿Ð¡
 502                             bat->gBatCapacityDisChargeCnt = 0;
 503                             (bat->gBatCapacityChargeCnt)++;
 504
 505                         if (pdata->charge_ok_pin != INVALID_GPIO){
 506                                 if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level){
 507                                 //¼ì²âµ½µç³Ø³äÂú±êÖ¾£¬Í¬Ê±³¤Ê±¼äÄÚ³äµçµçÑ¹ÎÞ±ä»¯£¬¿ªÊ¼Æô¶¯¼ÆÊ±³äµç£¬¿ìËÙÉÏÉýÈÝÁ¿
 508                                         if (bat->gBatCapacityChargeCnt >= NUM_CHARGE_MIN_SAMPLE){
 509                                                 bat->gBatCapacityChargeCnt = 0;
 510                                                 if (bat->bat_capacity < 99){
 511                                                         bat->bat_capacity++;
 512                                                         bat->bat_change  = 1;
 513                                                 }
 514                                         }
 515                                 }
 516                                 else{
 517 #if 0
 518                                         if (capacity > capacitytmp){
 519                                         //¹ý³ÌÖÐÈç¹ûµçÑ¹ÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±ÈÊµ¼Ê³äµç¿ì
 520                                                 gBatCapacityChargeCnt = 0;
 521                                         }
 522                                         else if (/*bat->bat_capacity >= 85) &&*/ (gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)){
 523                                                 gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
 524
 525                                                 if (bat->bat_capacity < 99){
 526                                                 bat->bat_capacity++;
 527                                                 bat->bat_change  = 1;
 528                                                 }
 529                                         }
 530                                 }
 531 #else                   //  ·ÀÖ¹µç³ØÀÏ»¯ºó³öÏÖ³å²»ÂúµÄÇé¿ö£¬
 532                                         if (capacity > bat->capacitytmp){
 533                                         //¹ý³ÌÖÐÈç¹ûµçÑ¹ÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±ÈÊµ¼Ê³äµç¿ì
 534                                                 bat->gBatCapacityChargeCnt = 0;
 535                                         }
 536                                         else{
 537
 538                                                 if ((bat->bat_capacity >= 85) &&((bat->gBatCapacityChargeCnt) > NUM_CHARGE_MAX_SAMPLE)){
 539                                                         bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
 540
 541                                                         if (bat->bat_capacity < 99){
 542                                                                 bat->bat_capacity++;
 543                                                                 bat->bat_change  = 1;
 544                                                         }
 545                                                 }
 546                                         }
 547                                 }
 548 #endif
 549
 550                         }
 551                         else{
 552                         //Ã»ÓÐ³äµçÂú¼ì²â½Å£¬³¤Ê±¼äÄÚµçÑ¹ÎÞ±ä»¯£¬¶¨Ê±Æ÷Ä£Äâ³äµç
 553                                 if (capacity > bat->capacitytmp){
 554                                 //¹ý³ÌÖÐÈç¹ûµçÑ¹ÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±ÈÊµ¼Ê³äµç¿ì
 555                                         bat->gBatCapacityChargeCnt = 0;
 556                                 }
 557                                 else{
 558
 559                                         if ((bat->bat_capacity >= 85) &&(bat->gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)){
 560                                                 bat->gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
 561
 562                                                 if (bat->bat_capacity < 99){
 563                                                         bat->bat_capacity++;
 564                                                         bat->bat_change  = 1;
 565                                                 }
 566                                         }
 567                                 }
 568
 569
 570                         }
 571                 }
 572         }
 573         else{
 574         //·ÅµçÊ±,Ö»ÔÊÐíµçÑ¹ÏÂ½µ
 575                 if (capacity < bat->bat_capacity){
 576                         if (++(bat->gBatCapacityDisChargeCnt) >= NUM_DISCHARGE_MIN_SAMPLE){
 577                                 bat->gBatCapacityDisChargeCnt = 0;
 578                                 if (bat->bat_capacity > 0){
 579                                         bat->bat_capacity-- ;
 580                                         bat->bat_change  = 1;
 581                                 }
 582                         }
 583                 }
 584                 else{
 585                         bat->gBatCapacityDisChargeCnt = 0;
 586                 }
 587                 bat->gBatCapacityChargeCnt = 0;
 588         }
 589                 bat->capacitytmp = capacity;
 590 }
 591
 592 //static int poweron_check = 0;
 593 static void rk30_adc_battery_poweron_capacity_check(void)
 594 {
 595
 596         int new_capacity, old_capacity;
 597
 598         new_capacity = gBatteryData->bat_capacity;
 599         old_capacity = rk30_adc_battery_load_capacity();
 600         if ((old_capacity <= 0) || (old_capacity >= 100)){
 601                 old_capacity = new_capacity;
 602         }
 603
 604         if (gBatteryData->bat_status == POWER_SUPPLY_STATUS_FULL){
 605                 if (new_capacity > 80){
 606                         gBatteryData->bat_capacity = 100;
 607                 }
 608         }
 609         else if (gBatteryData->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING){
 610         //chargeing state
 611         //ÎÊÌâ£º
 612 //      //1£©³¤Ê±¼ä¹Ø»ú·ÅÖÃºó£¬¿ª»úºó¶ÁÈ¡µÄÈÝÁ¿Ô¶Ô¶´óÓÚÊµ¼ÊÈÝÁ¿ÔõÃ´°ì£¿
 613 //      //2£©Èç¹û²»ÕâÑù×ö£¬¶ÌÊ±¼ä¹Ø»úÔÙ¿ª»ú£¬Ç°ºóÈÝÁ¿²»Ò»ÖÂÓÖ¸ÃÔõÃ´°ì£¿
 614 //      //3£©Ò»ÏÂÄÇÖÖ·½Ê½ºÏÊÊ£¿
 615         //gBatteryData->bat_capacity = new_capacity;
 616                 gBatteryData->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
 617         }else{
 618
 619                 if(new_capacity > old_capacity + 50 )
 620                         gBatteryData->bat_capacity = new_capacity;
 621                 else
 622                         gBatteryData->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity;  //avoid the value of capacity increase
 623         }
 624
 625
 626         //printk("capacity = %d, new_capacity = %d, old_capacity = %d\n",gBatteryData->bat_capacity, new_capacity, old_capacity);
 627
 628         gBatteryData->bat_change = 1;
 629 }
 630
 631 #if defined(CONFIG_BATTERY_RK30_USB_CHARGE)
 632 static int rk30_adc_battery_get_usb_property(struct power_supply *psy,
 633                                     enum power_supply_property psp,
 634                                     union power_supply_propval *val)
 635 {
 636         charger_type_t charger;
 637         charger =  CHARGER_USB;
 638
 639         switch (psp) {
 640         case POWER_SUPPLY_PROP_ONLINE:
 641                 if (psy->type == POWER_SUPPLY_TYPE_USB)
 642                         val->intval = get_msc_connect_flag();
 643                 printk("%s:%d\n",__FUNCTION__,val->intval);
 644                 break;
 645
 646         default:
 647                 return -EINVAL;
 648         }
 649
 650         return 0;
 651
 652 }
 653
 654 static enum power_supply_property rk30_adc_battery_usb_props[] = {
 655
 656         POWER_SUPPLY_PROP_ONLINE,
 657 };
 658
 659 static struct power_supply rk30_usb_supply =
 660 {
 661         .name = "usb",
 662         .type = POWER_SUPPLY_TYPE_USB,
 663
 664         .get_property   = rk30_adc_battery_get_usb_property,
 665
 666         .properties     = rk30_adc_battery_usb_props,
 667         .num_properties = ARRAY_SIZE(rk30_adc_battery_usb_props),
 668 };
 669 #endif
 670
 671 #if defined(CONFIG_BATTERY_RK30_AC_CHARGE)
 672 static irqreturn_t rk30_adc_battery_dc_wakeup(int irq, void *dev_id)
 673 {
 674         queue_work(gBatteryData->wq, &gBatteryData->dcwakeup_work);
 675         return IRQ_HANDLED;
 676 }
 677
 678
 679 static int rk30_adc_battery_get_ac_property(struct power_supply *psy,
 680                         enum power_supply_property psp,
 681                         union power_supply_propval *val)
 682 {
 683         int ret = 0;
 684         charger_type_t charger;
 685         charger =  CHARGER_USB;
 686         switch (psp) {
 687         case POWER_SUPPLY_PROP_ONLINE:
 688                 if (psy->type == POWER_SUPPLY_TYPE_MAINS)
 689                 {
 690                         if (rk30_adc_battery_get_charge_level(gBatteryData))
 691                         {
 692                                 val->intval = 1;
 693                                 }
 694                         else
 695                                 {
 696                                 val->intval = 0;
 697                                 }
 698                 }
 699                 DBG("%s:%d\n",__FUNCTION__,val->intval);
 700                 break;
 701
 702         default:
 703                 ret = -EINVAL;
 704                 break;
 705         }
 706
 707         return ret;
 708 }
 709
 710 static enum power_supply_property rk30_adc_battery_ac_props[] =
 711 {
 712         POWER_SUPPLY_PROP_ONLINE,
 713 };
 714
 715 static struct power_supply rk30_ac_supply =
 716 {
 717         .name = "ac",
 718         .type = POWER_SUPPLY_TYPE_MAINS,
 719
 720         .get_property   = rk30_adc_battery_get_ac_property,
 721
 722         .properties     = rk30_adc_battery_ac_props,
 723         .num_properties = ARRAY_SIZE(rk30_adc_battery_ac_props),
 724 };
 725
 726 static void rk30_adc_battery_dcdet_delaywork(struct work_struct *work)
 727 {
 728         int ret;
 729         struct rk30_adc_battery_platform_data *pdata;
 730         int irq;
 731         int irq_flag;
 732
 733         pdata    = gBatteryData->pdata;
 734         irq        = gpio_to_irq(pdata->dc_det_pin);
 735         irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
 736
 737         rk28_send_wakeup_key(); // wake up the system
 738
 739         free_irq(irq, NULL);
 740         ret = request_irq(irq, rk30_adc_battery_dc_wakeup, irq_flag, "ac_charge_irq", NULL);// reinitialize the DC irq
 741         if (ret) {
 742                 free_irq(irq, NULL);
 743         }
 744
 745         power_supply_changed(&rk30_ac_supply);
 746
 747         gBatteryData->bat_status_cnt = 0;        //the state of battery is change
 748
 749 }
 750
 751
 752 #endif
 753
 754 static int rk30_adc_battery_get_status(struct rk30_adc_battery_data *bat)
 755 {
 756         return (bat->bat_status);
 757 }
 758
 759 static int rk30_adc_battery_get_health(struct rk30_adc_battery_data *bat)
 760 {
 761         return POWER_SUPPLY_HEALTH_GOOD;
 762 }
 763
 764 static int rk30_adc_battery_get_present(struct rk30_adc_battery_data *bat)
 765 {
 766         return (bat->bat_voltage < BATT_MAX_VOL_VALUE) ? 0 : 1;
 767 }
 768
 769 static int rk30_adc_battery_get_voltage(struct rk30_adc_battery_data *bat)
 770 {
 771         return (bat->bat_voltage );
 772 }
 773
 774 static int rk30_adc_battery_get_capacity(struct rk30_adc_battery_data *bat)
 775 {
 776         return (bat->bat_capacity);
 777 }
 778
 779 static int rk30_adc_battery_get_property(struct power_supply *psy,
 780                                  enum power_supply_property psp,
 781                                  union power_supply_propval *val)
 782 {
 783         int ret = 0;
 784
 785         switch (psp) {
 786                 case POWER_SUPPLY_PROP_STATUS:
 787                         val->intval = rk30_adc_battery_get_status(gBatteryData);
 788                         DBG("gBatStatus=%d\n",val->intval);
 789                         break;
 790                 case POWER_SUPPLY_PROP_HEALTH:
 791                         val->intval = rk30_adc_battery_get_health(gBatteryData);
 792                         DBG("gBatHealth=%d\n",val->intval);
 793                         break;
 794                 case POWER_SUPPLY_PROP_PRESENT:
 795                         val->intval = rk30_adc_battery_get_present(gBatteryData);
 796                         DBG("gBatPresent=%d\n",val->intval);
 797                         break;
 798                 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 799                         val ->intval = rk30_adc_battery_get_voltage(gBatteryData);
 800                         DBG("gBatVoltage=%d\n",val->intval);
 801                         break;
 802                 //      case POWER_SUPPLY_PROP_CURRENT_NOW:
 803                 //              val->intval = 1100;
 804                 //              break;
 805                 case POWER_SUPPLY_PROP_CAPACITY:
 806                         val->intval = rk30_adc_battery_get_capacity(gBatteryData);
 807                         DBG("gBatCapacity=%d%%\n",val->intval);
 808                         break;
 809                 case POWER_SUPPLY_PROP_TECHNOLOGY:
 810                         val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 811                         break;
 812                 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 813                         val->intval = BATT_MAX_VOL_VALUE;
 814                         break;
 815                 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 816                         val->intval = BATT_ZERO_VOL_VALUE;
 817                         break;
 818                 default:
 819                         ret = -EINVAL;
 820                         break;
 821         }
 822
 823         return ret;
 824 }
 825
 826 static enum power_supply_property rk30_adc_battery_props[] = {
 827
 828         POWER_SUPPLY_PROP_STATUS,
 829         POWER_SUPPLY_PROP_HEALTH,
 830         POWER_SUPPLY_PROP_PRESENT,
 831         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 832 //      POWER_SUPPLY_PROP_CURRENT_NOW,
 833         POWER_SUPPLY_PROP_TECHNOLOGY,
 834         POWER_SUPPLY_PROP_CAPACITY,
 835         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
 836         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 837 };
 838
 839 static struct power_supply rk30_battery_supply =
 840 {
 841         .name = "battery",
 842         .type = POWER_SUPPLY_TYPE_BATTERY,
 843
 844         .get_property   = rk30_adc_battery_get_property,
 845
 846         .properties     = rk30_adc_battery_props,
 847         .num_properties = ARRAY_SIZE(rk30_adc_battery_props),
 848 };
 849
 850 #ifdef CONFIG_PM
 851 static void rk30_adc_battery_resume_check(void)
 852 {
 853         int i;
 854         int level,oldlevel;
 855         int new_capacity, old_capacity;
 856         struct rk30_adc_battery_data *bat = gBatteryData;
 857
 858         bat->old_charge_level = -1;
 859         pSamples = bat->adc_samples;
 860
 861         adc_sync_read(bat->client);                             //start adc sample
 862         level = oldlevel = rk30_adc_battery_status_samples(bat);//init charge status
 863
 864         for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++) {               //0.3 s
 865
 866                 mdelay(1);
 867                 rk30_adc_battery_voltage_samples(bat);              //get voltage
 868                 level = rk30_adc_battery_status_samples(bat);       //check charge status
 869                 if (oldlevel != level){
 870                     oldlevel = level;                               //if charge status changed, reset sample
 871                     i = 0;
 872                 }
 873         }
 874         new_capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
 875         old_capacity =gBatteryData-> suspend_capacity;
 876
 877         if (bat->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING){
 878         //chargeing state
 879                 bat->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
 880         }
 881         else{
 882                 bat->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity;  // aviod the value of capacity increase    dicharge
 883         }
 884
 885 }
 886
 887 static int rk30_adc_battery_suspend(struct platform_device *dev, pm_message_t state)
 888 {
 889         int irq;
 890         gBatteryData->suspend_capacity = gBatteryData->bat_capacity;
 891         cancel_delayed_work(&gBatteryData->delay_work);
 892
 893         if( gBatteryData->pdata->batt_low_pin != INVALID_GPIO){
 894
 895                 irq = gpio_to_irq(gBatteryData->pdata->batt_low_pin);
 896                 enable_irq(irq);
 897                 enable_irq_wake(irq);
 898         }
 899
 900         return 0;
 901 }
 902
 903 static int rk30_adc_battery_resume(struct platform_device *dev)
 904 {
 905         int irq;
 906         gBatteryData->resume = true;
 907         queue_delayed_work(gBatteryData->wq, &gBatteryData->delay_work, msecs_to_jiffies(100));
 908         if( gBatteryData->pdata->batt_low_pin != INVALID_GPIO){
 909
 910                 irq = gpio_to_irq(gBatteryData->pdata->batt_low_pin);
 911                 disable_irq_wake(irq);
 912                 disable_irq(irq);
 913         }
 914         return 0;
 915 }
 916 #else
 917 #define rk30_adc_battery_suspend NULL
 918 #define rk30_adc_battery_resume NULL
 919 #endif
 920
 921
 922 unsigned long AdcTestCnt = 0;
 923 static void rk30_adc_battery_timer_work(struct work_struct *work)
 924 {
 925 #ifdef CONFIG_PM
 926         if (gBatteryData->resume) {
 927                 rk30_adc_battery_resume_check();
 928                 gBatteryData->resume = false;
 929         }
 930 #endif
 931
 932
 933         rk30_adc_battery_status_samples(gBatteryData);
 934
 935         if (gBatteryData->poweron_check){
 936                 gBatteryData->poweron_check = 0;
 937                 rk30_adc_battery_poweron_capacity_check();
 938         }
 939
 940         rk30_adc_battery_voltage_samples(gBatteryData);
 941         rk30_adc_battery_capacity_samples(gBatteryData);
 942
 943         if( 1 == rk30_adc_battery_get_charge_level(gBatteryData)){  // charge
 944                 if(0 == gBatteryData->status_lock ){
 945                         wake_lock(&batt_wake_lock);  //lock
 946                         gBatteryData->status_lock = 1;
 947                 }
 948         }
 949         else{
 950                 if(1 == gBatteryData->status_lock ){
 951                         wake_unlock(&batt_wake_lock);  //unlock
 952                         gBatteryData->status_lock = 0;
 953                 }
 954
 955         }
 956
 957
 958         /*update battery parameter after adc and capacity has been changed*/
 959         if(gBatteryData->bat_change){
 960                 gBatteryData->bat_change = 0;
 961                 rk30_adc_battery_put_capacity(gBatteryData->bat_capacity);
 962                 power_supply_changed(&rk30_battery_supply);
 963         }
 964
 965         if (rk30_battery_dbg_level){
 966                 if (++AdcTestCnt >= 2)
 967                         {
 968                         AdcTestCnt = 0;
 969
 970                         printk("Status = %d, RealAdcVal = %d, RealVol = %d,gBatVol = %d, gBatCap = %d, RealCapacity = %d, dischargecnt = %d, chargecnt = %d\n",
 971                         gBatteryData->bat_status, gBatteryData->adc_val, adc_to_voltage(gBatteryData->adc_val),
 972                         gBatteryData->bat_voltage, gBatteryData->bat_capacity, gBatteryData->capacitytmp, gBatteryData->gBatCapacityDisChargeCnt,gBatteryData-> gBatCapacityChargeCnt);
 973
 974                 }
 975         }
 976         queue_delayed_work(gBatteryData->wq, &gBatteryData->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS));
 977
 978 }
 979
 980
 981 static int rk30_adc_battery_io_init(struct rk30_adc_battery_platform_data *pdata)
 982 {
 983         int ret = 0;
 984
 985         if (pdata->io_init) {
 986                 pdata->io_init();
 987         }
 988
 989         //charge control pin
 990         if (pdata->charge_set_pin != INVALID_GPIO){
 991                 ret = gpio_request(pdata->charge_set_pin, NULL);
 992                 if (ret) {
 993                         printk("failed to request dc_det gpio\n");
 994                         goto error;
 995                         }
 996                 gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
 997         }
 998
 999         //dc charge detect pin
1000         if (pdata->dc_det_pin != INVALID_GPIO){
1001                 ret = gpio_request(pdata->dc_det_pin, NULL);
1002                 if (ret) {
1003                         printk("failed to request dc_det gpio\n");
1004                         goto error;
1005                 }
1006
1007                 gpio_pull_updown(pdata->dc_det_pin, GPIOPullUp);//important
1008                 ret = gpio_direction_input(pdata->dc_det_pin);
1009                 if (ret) {
1010                         printk("failed to set gpio dc_det input\n");
1011                         goto error;
1012                 }
1013         }
1014
1015         //charge ok detect
1016         if (pdata->charge_ok_pin != INVALID_GPIO){
1017                 ret = gpio_request(pdata->charge_ok_pin, NULL);
1018                 if (ret) {
1019                         printk("failed to request charge_ok gpio\n");
1020                         goto error;
1021                 }
1022
1023                 gpio_pull_updown(pdata->charge_ok_pin, GPIOPullUp);//important
1024                 ret = gpio_direction_input(pdata->charge_ok_pin);
1025                 if (ret) {
1026                         printk("failed to set gpio charge_ok input\n");
1027                         goto error;
1028                 }
1029         }
1030         //batt low pin
1031         if( pdata->batt_low_pin != INVALID_GPIO){
1032                 ret = gpio_request(pdata->batt_low_pin, NULL);
1033                 if (ret) {
1034                         printk("failed to request batt_low_pin gpio\n");
1035                         goto error;
1036                 }
1037
1038                 gpio_pull_updown(pdata->batt_low_pin, GPIOPullUp);
1039                 ret = gpio_direction_input(pdata->batt_low_pin);
1040                 if (ret) {
1041                         printk("failed to set gpio batt_low_pin input\n");
1042                         goto error;
1043                 }
1044         }
1045
1046         return 0;
1047 error:
1048         return -1;
1049 }
1050
1051 //extern void kernel_power_off(void);
1052 static void rk30_adc_battery_check(struct rk30_adc_battery_data *bat)
1053 {
1054         int i;
1055         int level,oldlevel;
1056         struct rk30_adc_battery_platform_data *pdata = bat->pdata;
1057         //printk("%s--%d:\n",__FUNCTION__,__LINE__);
1058
1059         bat->old_charge_level = -1;
1060         bat->capacitytmp = 0;
1061         bat->suspend_capacity = 0;
1062
1063         pSamples = bat->adc_samples;
1064
1065         adc_sync_read(bat->client);                             //start adc sample
1066         level = oldlevel = rk30_adc_battery_status_samples(bat);//init charge status
1067
1068         bat->full_times = 0;
1069         for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++){                //0.3 s
1070                 mdelay(1);
1071                 rk30_adc_battery_voltage_samples(bat);              //get voltage
1072                 //level = rk30_adc_battery_status_samples(bat);       //check charge status
1073                 level = rk30_adc_battery_get_charge_level(bat);
1074
1075                 if (oldlevel != level){
1076                         oldlevel = level;                               //if charge status changed, reset sample
1077                         i = 0;
1078                 }
1079         }
1080
1081         bat->bat_capacity = rk30_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);  //init bat_capacity
1082
1083
1084         bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1085         if (rk30_adc_battery_get_charge_level(bat)){
1086                 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
1087
1088                 if (pdata->charge_ok_pin != INVALID_GPIO){
1089                         if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level){
1090                                 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
1091                                 bat->bat_capacity = 100;
1092                         }
1093                 }
1094         }
1095
1096
1097
1098 #if 1
1099         rk30_adc_battery_poweron_capacity_check();
1100 #else
1101         gBatteryData->poweron_check = 1;
1102 #endif
1103         gBatteryData->poweron_check = 0;
1104
1105 /*******************************************
1106 //¿ª»ú²ÉÑùµ½µÄµçÑ¹ºÍÉÏ´Î¹Ø»ú±£´æµçÑ¹Ïà²î½Ï´ó£¬ÔõÃ´´¦Àí£¿
1107 if (bat->bat_capacity > old_capacity)
1108 {
1109 if ((bat->bat_capacity - old_capacity) > 20)
1110 {
1111
1112 }
1113 }
1114 else if (bat->bat_capacity < old_capacity)
1115 {
1116 if ((old_capacity > bat->bat_capacity) > 20)
1117 {
1118
1119 }
1120 }
1121 *********************************************/
1122         if (bat->bat_capacity == 0) bat->bat_capacity = 1;
1123
1124
1125 #if 0
1126         if ((bat->bat_voltage <= batt_table[0].dis_charge_vol+ 50)&&(bat->bat_status != POWER_SUPPLY_STATUS_CHARGING)){
1127                 kernel_power_off();
1128         }
1129 #endif
1130 }
1131
1132 static void rk30_adc_battery_callback(struct adc_client *client, void *param, int result)
1133 {
1134 #if 0
1135         struct rk30_adc_battery_data  *info = container_of(client, struct rk30_adc_battery_data,
1136                 client);
1137         info->adc_val = result;
1138 #endif
1139         if (result < 0){
1140                 pr_bat("adc_battery_callback    resule < 0 , the value ");
1141                 return;
1142         }
1143         else{
1144                 gBatteryData->adc_val = result;
1145                 pr_bat("result = %d, gBatteryData->adc_val = %d\n", result, gBatteryData->adc_val );
1146         }
1147         return;
1148 }
1149
1150 #if 1
1151 static void rk30_adc_battery_lowerpower_delaywork(struct work_struct *work)
1152 {
1153         int irq;
1154         if( gBatteryData->pdata->batt_low_pin != INVALID_GPIO){
1155                 irq = gpio_to_irq(gBatteryData->pdata->batt_low_pin);
1156                 disable_irq(irq);
1157         }
1158
1159         printk("lowerpower\n");
1160         rk28_send_wakeup_key(); // wake up the system
1161         return;
1162 }
1163
1164
1165 static irqreturn_t rk30_adc_battery_low_wakeup(int irq,void *dev_id)
1166 {
1167         queue_work(gBatteryData->wq, &gBatteryData->lowerpower_work);
1168         return IRQ_HANDLED;
1169 }
1170
1171 #endif
1172
1173 static int rk30_adc_battery_probe(struct platform_device *pdev)
1174 {
1175         int    ret;
1176         int    irq;
1177         int    irq_flag;
1178         struct adc_client                   *client;
1179         struct rk30_adc_battery_data          *data;
1180         struct rk30_adc_battery_platform_data *pdata = pdev->dev.platform_data;
1181
1182         data = kzalloc(sizeof(*data), GFP_KERNEL);
1183         if (data == NULL) {
1184                 ret = -ENOMEM;
1185                 goto err_data_alloc_failed;
1186         }
1187         gBatteryData = data;
1188
1189         platform_set_drvdata(pdev, data);
1190
1191         data->pdata = pdata;
1192         data->status_lock = 0;
1193         ret = rk30_adc_battery_io_init(pdata);
1194          if (ret) {
1195                 goto err_io_init;
1196         }
1197
1198         memset(data->adc_samples, 0, sizeof(int)*(NUM_VOLTAGE_SAMPLE + 2));
1199
1200          //register adc for battery sample
1201         client = adc_register(0, rk30_adc_battery_callback, NULL);  //pdata->adc_channel = ani0
1202         if(!client)
1203                 goto err_adc_register_failed;
1204
1205          //variable init
1206         data->client  = client;
1207         data->adc_val = adc_sync_read(client);
1208
1209         ret = power_supply_register(&pdev->dev, &rk30_battery_supply);
1210         if (ret){
1211                 printk(KERN_INFO "fail to battery power_supply_register\n");
1212                 goto err_battery_failed;
1213         }
1214
1215
1216 #if defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1217         ret = power_supply_register(&pdev->dev, &rk30_usb_supply);
1218         if (ret){
1219                 printk(KERN_INFO "fail to usb power_supply_register\n");
1220                 goto err_usb_failed;
1221         }
1222 #endif
1223         wake_lock_init(&batt_wake_lock, WAKE_LOCK_SUSPEND, "batt_lock");
1224
1225         data->wq = create_singlethread_workqueue("adc_battd");
1226         INIT_DELAYED_WORK(&data->delay_work, rk30_adc_battery_timer_work);
1227         //Power on Battery detect
1228         rk30_adc_battery_check(data);
1229         queue_delayed_work(data->wq, &data->delay_work, msecs_to_jiffies(TIMER_MS_COUNTS));
1230
1231 #if  defined (CONFIG_BATTERY_RK30_AC_CHARGE)
1232         ret = power_supply_register(&pdev->dev, &rk30_ac_supply);
1233         if (ret) {
1234                 printk(KERN_INFO "fail to ac power_supply_register\n");
1235                 goto err_ac_failed;
1236         }
1237         //init dc dectet irq & delay work
1238         if (pdata->dc_det_pin != INVALID_GPIO){
1239                 INIT_WORK(&data->dcwakeup_work, rk30_adc_battery_dcdet_delaywork);
1240
1241                 irq = gpio_to_irq(pdata->dc_det_pin);
1242                 irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1243                 ret = request_irq(irq, rk30_adc_battery_dc_wakeup, irq_flag, "ac_charge_irq", NULL);
1244                 if (ret) {
1245                         printk("failed to request dc det irq\n");
1246                         goto err_dcirq_failed;
1247                 }
1248                 enable_irq_wake(irq);
1249
1250         }
1251 #endif
1252
1253 #if 1
1254         // batt low irq lowerpower_work
1255         if( pdata->batt_low_pin != INVALID_GPIO){
1256                 INIT_WORK(&data->lowerpower_work, rk30_adc_battery_lowerpower_delaywork);
1257
1258                 irq = gpio_to_irq(pdata->batt_low_pin);
1259                 ret = request_irq(irq, rk30_adc_battery_low_wakeup, IRQF_TRIGGER_LOW, "batt_low_irq", NULL);
1260
1261                 if (ret) {
1262                         printk("failed to request batt_low_irq irq\n");
1263                         goto err_lowpowerirq_failed;
1264                 }
1265                 disable_irq(irq);
1266
1267         }
1268 #endif
1269
1270         printk(KERN_INFO "rk30_adc_battery: driver initialized\n");
1271
1272         return 0;
1273
1274 #if defined (CONFIG_BATTERY_RK30_USB_CHARGE)
1275 err_usb_failed:
1276         power_supply_unregister(&rk30_usb_supply);
1277 #endif
1278
1279 err_ac_failed:
1280 #if defined (CONFIG_BATTERY_RK30_AC_CHARGE)
1281         power_supply_unregister(&rk30_ac_supply);
1282 #endif
1283
1284 err_battery_failed:
1285         power_supply_unregister(&rk30_battery_supply);
1286
1287 err_dcirq_failed:
1288         free_irq(gpio_to_irq(pdata->dc_det_pin), data);
1289 #if 1
1290  err_lowpowerirq_failed:
1291         free_irq(gpio_to_irq(pdata->batt_low_pin), data);
1292 #endif
1293 err_adc_register_failed:
1294 err_io_init:
1295 err_data_alloc_failed:
1296         kfree(data);
1297
1298         printk("rk30_adc_battery: error!\n");
1299
1300         return ret;
1301 }
1302
1303 static int rk30_adc_battery_remove(struct platform_device *pdev)
1304 {
1305         struct rk30_adc_battery_data *data = platform_get_drvdata(pdev);
1306         struct rk30_adc_battery_platform_data *pdata = pdev->dev.platform_data;
1307
1308         cancel_delayed_work(&gBatteryData->delay_work);
1309 #if defined(CONFIG_BATTERY_RK30_USB_CHARGE)
1310         power_supply_unregister(&rk30_usb_supply);
1311 #endif
1312 #if defined(CONFIG_BATTERY_RK30_AC_CHARGE)
1313         power_supply_unregister(&rk30_ac_supply);
1314 #endif
1315         power_supply_unregister(&rk30_battery_supply);
1316
1317         free_irq(gpio_to_irq(pdata->dc_det_pin), data);
1318
1319         kfree(data);
1320
1321         return 0;
1322 }
1323
1324 static struct platform_driver rk30_adc_battery_driver = {
1325         .probe          = rk30_adc_battery_probe,
1326         .remove         = rk30_adc_battery_remove,
1327         .suspend                = rk30_adc_battery_suspend,
1328         .resume         = rk30_adc_battery_resume,
1329         .driver = {
1330                 .name = "rk30-battery",
1331                 .owner  = THIS_MODULE,
1332         }
1333 };
1334
1335 static int __init rk30_adc_battery_init(void)
1336 {
1337         return platform_driver_register(&rk30_adc_battery_driver);
1338 }
1339
1340 static void __exit rk30_adc_battery_exit(void)
1341 {
1342         platform_driver_unregister(&rk30_adc_battery_driver);
1343 }
1344
1345 subsys_initcall(rk30_adc_battery_init);//subsys_initcall(rk30_adc_battery_init);
1346 module_exit(rk30_adc_battery_exit);
1347
1348 MODULE_DESCRIPTION("Battery detect driver for the rk30");
1349 MODULE_AUTHOR("luowei lw@rock-chips.com");
1350 MODULE_LICENSE("GPL");