drivers/power/rk29_adc_battery.c

   1 /* drivers/power/rk29_adc_battery.c
   2  *
   3  * battery detect driver for the rk2918
   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
  37 #include <linux/wakelock.h>
  38
  39 static struct wake_lock batt_wake_lock;
  40
  41 #if 0
  42 #define DBG(x...)   printk(x)
  43 #else
  44 #define DBG(x...)
  45 #endif
  46
  47 int rk29_battery_dbg_level = 0;
  48 module_param_named(dbg_level, rk29_battery_dbg_level, int, 0644);
  49
  50 /*******************ÒÔÏÂ²ÎÊý¿ÉÒÔÐÞ¸Ä******************************/
  51 #define TIMER_MS_COUNTS                     50  //¶¨Ê±Æ÷µÄ³¤¶Èms
  52 //ÒÔÏÂ²ÎÊýÐèÒª¸ù¾ÝÊµ¼Ê²âÊÔµ÷Õû
  53 #define SLOPE_SECOND_COUNTS                 15  //Í³¼ÆµçÑ¹Ð±ÂÊµÄÊ±¼ä¼ä¸ôs
  54 #define DISCHARGE_MIN_SECOND            45      //×î¿ì·Åµçµç1%Ê±¼ä
  55 #define CHARGE_MIN_SECOND                   45  //×î¿ì³äµçµç1%Ê±¼ä
  56 #define CHARGE_MID_SECOND                   90  //ÆÕÍ¨³äµçµç1%Ê±¼ä
  57 #define CHARGE_MAX_SECOND                   250 //×î³¤³äµçµç1%Ê±¼ä
  58 #define CHARGE_FULL_DELAY_TIMES         10  //³äµçÂú¼ì²â·À¶¶Ê±¼ä
  59 #define USBCHARGE_IDENTIFY_TIMES        5   //²åÈëUSB»ìÁ÷£¬pcÊ¶±ð¼ì²âÊ±¼ä
  60
  61 #define NUM_VOLTAGE_SAMPLE                  ((SLOPE_SECOND_COUNTS * 1000) / TIMER_MS_COUNTS)    //´æ´¢µÄ²ÉÑùµã¸öÊý
  62 #define NUM_DISCHARGE_MIN_SAMPLE            ((DISCHARGE_MIN_SECOND * 1000) / TIMER_MS_COUNTS)   //´æ´¢µÄ²ÉÑùµã¸öÊý
  63 #define NUM_CHARGE_MIN_SAMPLE           ((CHARGE_MIN_SECOND * 1000) / TIMER_MS_COUNTS)      //´æ´¢µÄ²ÉÑùµã¸öÊý
  64 #define NUM_CHARGE_MID_SAMPLE           ((CHARGE_MID_SECOND * 1000) / TIMER_MS_COUNTS)      //´æ´¢µÄ²ÉÑùµã¸öÊý
  65 #define NUM_CHARGE_MAX_SAMPLE           ((CHARGE_MAX_SECOND * 1000) / TIMER_MS_COUNTS)      //´æ´¢µÄ²ÉÑùµã¸öÊý
  66 #define NUM_CHARGE_FULL_DELAY_TIMES     ((CHARGE_FULL_DELAY_TIMES * 1000) / TIMER_MS_COUNTS)    //³äµçÂú×´Ì¬³ÖÐøÊ±¼ä³¤¶È
  67 #define NUM_USBCHARGE_IDENTIFY_TIMES    ((USBCHARGE_IDENTIFY_TIMES * 1000) / TIMER_MS_COUNTS)   //³äµçÂú×´Ì¬³ÖÐøÊ±¼ä³¤¶È
  68
  69 #define BAT_2V5_VALUE                   2500
  70 #define BATT_MAX_VOL_VALUE               8284 //   4180                 //ÂúµçÊ±µÄµç³ØµçÑ¹       FOR A7
  71 #define BATT_ZERO_VOL_VALUE            6800 //    3500                  //¹Ø»úÊ±µÄµç³ØµçÑ¹
  72 #define BATT_NOMAL_VOL_VALUE             7600 //  3800
  73
  74 //¶¨ÒåADC²ÉÑù·ÖÑ¹µç×è£¬ÒÔÊµ¼ÊÖµÎª×¼£¬µ¥Î»K
  75 #define BAT_PULL_UP_R                  300  ////200
  76
  77 #define BAT_PULL_DOWN_R                100// 200
  78 #define BAT_ADC_TABLE_LEN               11
  79 #define adc_to_voltage(adc_val) ((adc_val * BAT_2V5_VALUE * (BAT_PULL_UP_R + BAT_PULL_DOWN_R)) / (1024 * BAT_PULL_DOWN_R))
  80
  81 static int adc_raw_table_bat[BAT_ADC_TABLE_LEN] =
  82 {
  83 //    3490, 3597, 3628, 3641, 3660, 3697, 3747, 3809, 3879, 3945, 4165
  84  6800,7242,7332,7404,7470,7520,7610,7744,7848,8016,8284
  85
  86 };
  87
  88 static int adc_raw_table_ac[BAT_ADC_TABLE_LEN] =
  89 {
  90  //   3600, 3760, 3800, 3827, 3845, 3885, 3950, 4007, 4078, 4140, 4200
  91  7630, 7754, 7852, 7908, 7956, 8024, 8112, 8220, 8306, 8318, 8328
  92
  93 };
  94
  95 extern int dwc_vbus_status(void);
  96 extern int get_msc_connect_flag(void);
  97
  98 struct rk29_adc_battery_data {
  99         int irq;
 100
 101         struct timer_list       timer;
 102         struct work_struct          timer_work;
 103         struct work_struct          dcwakeup_work;
 104         struct work_struct          resume_work;
 105
 106         struct rk29_adc_battery_platform_data *pdata;
 107
 108         int                     full_times;
 109
 110         struct adc_client       *client;
 111         int                     adc_val;
 112         int                     adc_samples[NUM_VOLTAGE_SAMPLE+2];
 113
 114         int                     bat_status;
 115         int                     bat_status_cnt;
 116         int                     bat_health;
 117         int                     bat_present;
 118         int                     bat_voltage;
 119         int                     bat_capacity;
 120         int                     bat_change;
 121 };
 122 static struct rk29_adc_battery_data *gBatteryData;
 123
 124 enum {
 125         BATTERY_STATUS          = 0,
 126         BATTERY_HEALTH          = 1,
 127         BATTERY_PRESENT         = 2,
 128         BATTERY_CAPACITY        = 3,
 129         BATTERY_AC_ONLINE       = 4,
 130         BATTERY_STATUS_CHANGED  = 5,
 131         AC_STATUS_CHANGED       = 6,
 132         BATTERY_INT_STATUS          = 7,
 133         BATTERY_INT_ENABLE          = 8,
 134 };
 135
 136 typedef enum {
 137         CHARGER_BATTERY = 0,
 138         CHARGER_USB,
 139         CHARGER_AC
 140 } charger_type_t;
 141
 142
 143 #define BATT_FILENAME "/data/bat_last_capacity.dat"
 144 #include <linux/fs.h>
 145
 146 static void rk29_adc_battery_capacity_samples(struct rk29_adc_battery_data *bat);
 147 static int rk29_adc_battery_voltage_to_capacity(struct rk29_adc_battery_data *bat, int BatVoltage);
 148 static struct power_supply rk29_battery_supply;
 149
 150 static int rk29_adc_battery_load_capacity(void)
 151 {
 152     char value[4];
 153         int* p = (int *)value;
 154     long fd = sys_open(BATT_FILENAME,O_RDONLY,0);
 155
 156         if(fd < 0)
 157     {
 158                 printk("rk29_adc_battery_load_capacity: open file /data/bat_last_capacity.dat failed\n");
 159                 return -1;
 160         }
 161
 162         sys_read(fd,(char __user *)value,4);
 163
 164     sys_close(fd);
 165
 166         return (*p);
 167 }
 168
 169 static void rk29_adc_battery_put_capacity(int loadcapacity)
 170 {
 171     char value[4];
 172         int* p = (int *)value;
 173     long fd = sys_open(BATT_FILENAME,O_CREAT | O_RDWR,0);
 174
 175         if(fd < 0)
 176     {
 177                 printk("rk29_adc_battery_put_capacity: open file /data/bat_last_capacity.dat failed\n");
 178                 return;
 179         }
 180     *p = loadcapacity;
 181         sys_write(fd, (const char __user *)value, 4);
 182
 183     sys_close(fd);
 184 }
 185
 186 static void rk29_adc_battery_charge_enable(struct rk29_adc_battery_data *bat)
 187 {
 188     struct rk29_adc_battery_platform_data *pdata = bat->pdata;
 189
 190     if (pdata->charge_set_pin != INVALID_GPIO)
 191     {
 192         gpio_direction_output(pdata->charge_set_pin, pdata->charge_set_level);
 193     }
 194 }
 195
 196 static void rk29_adc_battery_charge_disable(struct rk29_adc_battery_data *bat)
 197 {
 198     struct rk29_adc_battery_platform_data *pdata = bat->pdata;
 199
 200     if (pdata->charge_set_pin != INVALID_GPIO)
 201     {
 202         gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
 203     }
 204 }
 205
 206 extern int suspend_flag;
 207 static int rk29_adc_battery_get_charge_level(struct rk29_adc_battery_data *bat)
 208 {
 209     int charge_on = 0;
 210     struct rk29_adc_battery_platform_data *pdata = bat->pdata;
 211
 212 #if defined(CONFIG_BATTERY_RK29_AC_CHARGE)
 213     if (pdata->dc_det_pin != INVALID_GPIO)
 214     {
 215         if (gpio_get_value (pdata->dc_det_pin) == pdata->dc_det_level)
 216         {
 217             charge_on = 1;
 218         }
 219     }
 220 #endif
 221
 222 #if defined(CONFIG_BATTERY_RK29_USB_CHARGE)
 223     if (charge_on == 0)
 224     {
 225         if (suspend_flag) return;
 226
 227         if (1 == dwc_vbus_status())         //¼ì²âµ½USB²åÈë£¬µ«ÊÇÎÞ·¨Ê¶±ðÊÇ·ñÊÇ³äµçÆ÷
 228         {                                   //Í¨¹ýÑÓÊ±¼ì²âPCÊ¶±ð±êÖ¾£¬Èç¹û³¬Ê±¼ì²â²»µ½£¬ËµÃ÷ÊÇ³äµç
 229             if (0 == get_msc_connect_flag())
 230             {                               //²åÈë³äµçÆ÷Ê±¼ä´óÓÚÒ»¶¨Ê±¼äÖ®ºó£¬¿ªÊ¼½øÈë³äµç×´Ì¬
 231                 if (++gBatUsbChargeCnt >= NUM_USBCHARGE_IDENTIFY_TIMES)
 232                 {
 233                     gBatUsbChargeCnt = NUM_USBCHARGE_IDENTIFY_TIMES + 1;
 234                     charge_on = 1;
 235                 }
 236             }                               //·ñÔò£¬²»½øÈë³äµçÄ£Ê½
 237         }
 238         else
 239         {
 240             gBatUsbChargeCnt = 0;
 241             if (2 == dwc_vbus_status())
 242             {
 243                 charge_on = 1;
 244             }
 245         }
 246     }
 247 #endif
 248
 249     return charge_on;
 250 }
 251
 252 int old_charge_level;
 253 static int rk29_adc_battery_status_samples(struct rk29_adc_battery_data *bat)
 254 {
 255     int charge_level;
 256     struct rk29_adc_battery_platform_data *pdata = bat->pdata;
 257
 258     charge_level = rk29_adc_battery_get_charge_level(bat);
 259
 260     //¼ì²â³äµç×´Ì¬±ä»¯Çé¿ö
 261     if (charge_level != old_charge_level)
 262     {
 263         old_charge_level = charge_level;
 264         bat->bat_change  = 1;
 265         if(charge_level)
 266         {
 267             rk29_adc_battery_charge_enable(bat);
 268         }
 269         else
 270         {
 271             rk29_adc_battery_charge_disable(bat);
 272         }
 273         bat->bat_status_cnt = 0;        //×´Ì¬±ä»¯¿ªÊ¼¼ÆÊý
 274     }
 275
 276     //»ñÈ¡ÎÈ¶¨µÄ³äµç×´Ì¬
 277         if(charge_level == 0)
 278         {
 279             //Î´³äµç
 280             bat->full_times = 0;
 281         bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 282         }
 283         else
 284         {
 285             //³äµç
 286         if (pdata->charge_ok_pin == INVALID_GPIO)
 287         {
 288             //Ã»ÓÐcharge_ok_pin£¬¼ì²âÈÝÁ¿
 289             if (bat->bat_capacity == 100)
 290             {
 291                 if (bat->bat_status != POWER_SUPPLY_STATUS_FULL)
 292                 {
 293                     bat->bat_status = POWER_SUPPLY_STATUS_FULL;
 294                     bat->bat_change  = 1;
 295                 }
 296             }
 297             else
 298             {
 299                 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 300             }
 301         }
 302         else
 303         {
 304             //ÓÐ³äµç¼ì²â½Ì
 305             if (gpio_get_value(pdata->charge_ok_pin) != pdata->charge_ok_level)
 306             {
 307                 //Ã»ÓÐ¼ì²âµ½³äµçÂúµçÆ½±êÖ¾
 308                 bat->full_times = 0;
 309                 bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 310             }
 311             else
 312             {
 313                 //¼ì²âµ½³äµçÂúµçÆ½±êÖ¾
 314                 bat->full_times++;
 315                 if (bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES)
 316                 {
 317                     bat->full_times = NUM_CHARGE_FULL_DELAY_TIMES + 1;
 318                 }
 319
 320                 if ((bat->full_times >= NUM_CHARGE_FULL_DELAY_TIMES) && (bat->bat_capacity >= 99))
 321                     {
 322                         if (bat->bat_status != POWER_SUPPLY_STATUS_FULL)
 323                     {
 324                         bat->bat_status = POWER_SUPPLY_STATUS_FULL;
 325                         bat->bat_capacity = 100;
 326                         bat->bat_change  = 1;
 327                     }
 328                     }
 329                     else
 330                     {
 331                         bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
 332                     }
 333             }
 334         }
 335     }
 336
 337         return charge_level;
 338 }
 339
 340 int AdcTestvalue = 0;
 341 static int gFlagLoop = 0;
 342 static int *pSamples;
 343 static void rk29_adc_battery_voltage_samples(struct rk29_adc_battery_data *bat)
 344 {
 345         int value;
 346         int i,*pStart = bat->adc_samples, num = 0;
 347
 348         value = bat->adc_val;
 349         AdcTestvalue = value;
 350     adc_async_read(bat->client);
 351
 352         *pSamples++ = adc_to_voltage(value);
 353
 354         bat->bat_status_cnt++;
 355         if (bat->bat_status_cnt > NUM_VOLTAGE_SAMPLE)  bat->bat_status_cnt = NUM_VOLTAGE_SAMPLE + 1;
 356
 357         num = pSamples - pStart;
 358         if (num >= NUM_VOLTAGE_SAMPLE)
 359         {
 360             pSamples = pStart;
 361             gFlagLoop = 1;
 362         }
 363         if (gFlagLoop == 1)
 364         {
 365             num = NUM_VOLTAGE_SAMPLE;
 366         }
 367         value = 0;
 368         for (i = 0; i < num; i++)
 369         {
 370             value += bat->adc_samples[i];
 371         }
 372         bat->bat_voltage = value / num;
 373
 374         /*Ïû³ýÃ«´ÌµçÑ¹*/
 375         if(bat->bat_voltage >= BATT_MAX_VOL_VALUE + 10)
 376                 bat->bat_voltage = BATT_MAX_VOL_VALUE + 10;
 377         else if(bat->bat_voltage <= BATT_ZERO_VOL_VALUE - 10)
 378                 bat->bat_voltage = BATT_ZERO_VOL_VALUE - 10;
 379 }
 380
 381 int capacitytmp = 0;
 382 static int rk29_adc_battery_voltage_to_capacity(struct rk29_adc_battery_data *bat, int BatVoltage)
 383 {
 384     int i = 0;
 385         int capacity = 0;
 386         int *p = adc_raw_table_bat;
 387
 388     if (rk29_adc_battery_get_charge_level(bat))
 389     {
 390         p = adc_raw_table_ac;
 391     }
 392
 393         if(BatVoltage >= p[BAT_ADC_TABLE_LEN - 1])
 394         {
 395             //µ±µçÑ¹³¬¹ý×î´óÖµ
 396             capacity = 100;
 397         }
 398         else if(BatVoltage <= p[0])
 399         {
 400             //µ±µçÑ¹µÍÓÚ×îÐ¡Öµ
 401             capacity = 0;
 402         }
 403         else
 404         {
 405         //¼ÆËãÈÝÁ¿
 406         for(i = 0; i < BAT_ADC_TABLE_LEN - 1; i++)
 407         {
 408
 409                 if((p[i] <= BatVoltage) && (BatVoltage < p[i+1]))
 410                 {
 411                         capacity = i * 10 + ((BatVoltage - p[i]) * 10) / (p[i+1] - p[i]);
 412                         break;
 413                 }
 414         }
 415     }
 416     return capacity;
 417 }
 418
 419 static int gBatCapacityDisChargeCnt = 0;
 420 static int gBatCapacityChargeCnt    = 0;
 421 //static int rk29_adc_battery_get_capacity_ext(int BatVoltage)
 422 static void rk29_adc_battery_capacity_samples(struct rk29_adc_battery_data *bat)
 423 {
 424         int capacity = 0;
 425         struct rk29_adc_battery_platform_data *pdata = bat->pdata;
 426
 427     //³ä·Åµç×´Ì¬±ä»¯ºó£¬BufferÌîÂúÖ®Ç°£¬²»¸üÐÂ
 428         if (bat->bat_status_cnt < NUM_VOLTAGE_SAMPLE)
 429         {
 430             gBatCapacityDisChargeCnt = 0;
 431             gBatCapacityChargeCnt    = 0;
 432             return;
 433         }
 434
 435     capacity = rk29_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
 436
 437     if (rk29_adc_battery_get_charge_level(bat))
 438     {
 439         if (capacity > bat->bat_capacity)
 440         {
 441             //Êµ¼Ê²ÉÑùµ½µÄµçÑ¹±ÈÏÔÊ¾µÄµçÑ¹´ó£¬Öð¼¶ÉÏÉý
 442             if (++gBatCapacityDisChargeCnt >= NUM_CHARGE_MIN_SAMPLE)
 443             {
 444                 gBatCapacityDisChargeCnt = 0;
 445                 if (bat->bat_capacity < 99)
 446                 {
 447                     bat->bat_capacity++;
 448                     bat->bat_change  = 1;
 449                 }
 450             }
 451             gBatCapacityChargeCnt = 0;
 452         }
 453         else
 454         {
 455             gBatCapacityDisChargeCnt = 0;
 456             gBatCapacityChargeCnt++;
 457
 458             if (pdata->charge_ok_pin != INVALID_GPIO)
 459             {
 460                 if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level)
 461                 {
 462                     //¼ì²âµ½µç³Ø³äÂú±êÖ¾£¬Í¬Ê±³¤Ê±¼äÄÚ³äµçµçÑ¹ÎÞ±ä»¯£¬¿ªÊ¼Æô¶¯¼ÆÊ±³äµç£¬¿ìËÙÉÏÉýÈÝÁ¿
 463                     if (gBatCapacityChargeCnt >= NUM_CHARGE_MIN_SAMPLE)
 464                     {
 465                         gBatCapacityChargeCnt = 0;
 466                         if (bat->bat_capacity < 99)
 467                         {
 468                             bat->bat_capacity++;
 469                             bat->bat_change  = 1;
 470                         }
 471                     }
 472                 }
 473                 else
 474                 {
 475                     if (capacity > capacitytmp)
 476                     {
 477                         //¹ý³ÌÖÐÈç¹ûµçÑ¹ÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±ÈÊµ¼Ê³äµç¿ì
 478                         gBatCapacityChargeCnt = 0;
 479                     }
 480                     if (/*(bat->bat_capacity >= 80) && */(gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE))
 481                     {
 482                         gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
 483                         if (bat->bat_capacity < 99)
 484                         {
 485                             bat->bat_capacity++;
 486                             bat->bat_change  = 1;
 487                         }
 488                     }
 489                 }
 490             }
 491             else
 492             {
 493                 //Ã»ÓÐ³äµçÂú¼ì²â½Å£¬³¤Ê±¼äÄÚµçÑ¹ÎÞ±ä»¯£¬¶¨Ê±Æ÷Ä£Äâ³äµç
 494                 if (capacity > capacitytmp)
 495                 {
 496                     //¹ý³ÌÖÐÈç¹ûµçÑ¹ÓÐÔö³¤£¬¶¨Ê±Æ÷¸´Î»£¬·ÀÖ¹¶¨Ê±Æ÷Ä£Äâ³äµç±ÈÊµ¼Ê³äµç¿ì
 497                     gBatCapacityChargeCnt = 0;
 498                 }
 499                 if (gBatCapacityChargeCnt > NUM_CHARGE_MAX_SAMPLE)
 500                 {
 501                     gBatCapacityChargeCnt = (NUM_CHARGE_MAX_SAMPLE - NUM_CHARGE_MID_SAMPLE);
 502                     if (bat->bat_capacity < 100)
 503                     {
 504                         bat->bat_capacity++;
 505                         bat->bat_change  = 1;
 506                     }
 507                 }
 508             }
 509         }
 510     }
 511     else
 512     {
 513         //·ÅµçÊ±,Ö»ÔÊÐíµçÑ¹ÏÂ½µ
 514         if (capacity < bat->bat_capacity)
 515         {
 516             if (++gBatCapacityDisChargeCnt >= NUM_DISCHARGE_MIN_SAMPLE)
 517             {
 518                 gBatCapacityDisChargeCnt = 0;
 519                 if (bat->bat_capacity > 0)
 520                 {
 521                     bat->bat_capacity-- ;
 522                     bat->bat_change  = 1;
 523                 }
 524             }
 525         }
 526         else
 527         {
 528             gBatCapacityDisChargeCnt = 0;
 529         }
 530
 531         gBatCapacityChargeCnt = 0;
 532     }
 533         capacitytmp = capacity;
 534 }
 535
 536 static int poweron_check = 0;
 537 static void rk29_adc_battery_poweron_capacity_check(void)
 538 {
 539     int new_capacity, old_capacity;
 540
 541     new_capacity = gBatteryData->bat_capacity;
 542     old_capacity = rk29_adc_battery_load_capacity();
 543     if ((old_capacity <= 0) || (old_capacity >= 100))
 544     {
 545         old_capacity = new_capacity;
 546     }
 547
 548     if (gBatteryData->bat_status == POWER_SUPPLY_STATUS_FULL)
 549     {
 550         if (new_capacity > 80)
 551         {
 552             gBatteryData->bat_capacity = 100;
 553         }
 554     }
 555     else if (gBatteryData->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING)
 556     {
 557         //chargeing state
 558         //ÎÊÌâ£º
 559         //1£©³¤Ê±¼ä¹Ø»ú·ÅÖÃºó£¬¿ª»úºó¶ÁÈ¡µÄÈÝÁ¿Ô¶Ô¶´óÓÚÊµ¼ÊÈÝÁ¿ÔõÃ´°ì£¿
 560         //2£©Èç¹û²»ÕâÑù×ö£¬¶ÌÊ±¼ä¹Ø»úÔÙ¿ª»ú£¬Ç°ºóÈÝÁ¿²»Ò»ÖÂÓÖ¸ÃÔõÃ´°ì£¿
 561         //3£©Ò»ÏÂÄÇÖÖ·½Ê½ºÏÊÊ£¿
 562         //gBatteryData->bat_capacity = new_capacity;
 563         gBatteryData->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
 564     }
 565     else
 566     {
 567         gBatteryData->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity;
 568     }
 569
 570
 571     printk("capacity = %d, new_capacity = %d, old_capacity = %d\n",gBatteryData->bat_capacity, new_capacity, old_capacity);
 572
 573     gBatteryData->bat_change = 1;
 574 }
 575
 576 unsigned long AdcTestCnt = 0;
 577 static void rk29_adc_battery_timer_work(struct work_struct *work)
 578 {
 579         rk29_adc_battery_status_samples(gBatteryData);
 580
 581         if (poweron_check)
 582         {
 583         poweron_check = 0;
 584         rk29_adc_battery_poweron_capacity_check();
 585         }
 586
 587         rk29_adc_battery_voltage_samples(gBatteryData);
 588         rk29_adc_battery_capacity_samples(gBatteryData);
 589
 590         /*update battery parameter after adc and capacity has been changed*/
 591         if(gBatteryData->bat_change)
 592         {
 593             gBatteryData->bat_change = 0;
 594             rk29_adc_battery_put_capacity(gBatteryData->bat_capacity);
 595                 power_supply_changed(&rk29_battery_supply);
 596         }
 597
 598         if (rk29_battery_dbg_level)
 599         {
 600         if (++AdcTestCnt >= 20)
 601         {
 602             AdcTestCnt = 0;
 603             printk("Status = %d, RealAdcVal = %d, RealVol = %d,gBatVol = %d, gBatCap = %d, RealCapacity = %d, dischargecnt = %d, chargecnt = %d\n",
 604                     gBatteryData->bat_status, AdcTestvalue, adc_to_voltage(AdcTestvalue),
 605                     gBatteryData->bat_voltage, gBatteryData->bat_capacity, capacitytmp, gBatCapacityDisChargeCnt, gBatCapacityChargeCnt);
 606         }
 607     }
 608
 609
 610
 611 }
 612
 613 static void rk29_adc_battery_scan_timer(unsigned long data)
 614 {
 615     gBatteryData->timer.expires  = jiffies + msecs_to_jiffies(TIMER_MS_COUNTS);
 616         add_timer(&gBatteryData->timer);
 617
 618         schedule_work(&gBatteryData->timer_work);
 619 }
 620
 621 #if defined(CONFIG_BATTERY_RK29_USB_CHARGE)
 622 static int rk29_adc_battery_get_usb_property(struct power_supply *psy,
 623                                     enum power_supply_property psp,
 624                                     union power_supply_propval *val)
 625 {
 626         charger_type_t charger;
 627         charger =  CHARGER_USB;
 628
 629         switch (psp) {
 630         case POWER_SUPPLY_PROP_ONLINE:
 631                 if (psy->type == POWER_SUPPLY_TYPE_USB)
 632                         val->intval = get_msc_connect_flag();
 633                 printk("%s:%d\n",__FUNCTION__,val->intval);
 634                 break;
 635
 636         default:
 637                 return -EINVAL;
 638         }
 639
 640         return 0;
 641
 642 }
 643
 644 static enum power_supply_property rk29_adc_battery_usb_props[] = {
 645
 646         POWER_SUPPLY_PROP_ONLINE,
 647 };
 648
 649 static struct power_supply rk29_usb_supply =
 650 {
 651         .name = "usb",
 652         .type = POWER_SUPPLY_TYPE_USB,
 653
 654         .get_property   = rk29_adc_battery_get_usb_property,
 655
 656     .properties     = rk29_adc_battery_usb_props,
 657         .num_properties = ARRAY_SIZE(rk29_adc_battery_usb_props),
 658 };
 659 #endif
 660
 661 #if defined(CONFIG_BATTERY_RK29_AC_CHARGE)
 662 static irqreturn_t rk29_adc_battery_dc_wakeup(int irq, void *dev_id)
 663 {
 664     schedule_work(&gBatteryData->dcwakeup_work);
 665     return IRQ_HANDLED;
 666 }
 667
 668
 669 static int rk29_adc_battery_get_ac_property(struct power_supply *psy,
 670                         enum power_supply_property psp,
 671                         union power_supply_propval *val)
 672 {
 673         int ret = 0;
 674         charger_type_t charger;
 675         charger =  CHARGER_USB;
 676         switch (psp) {
 677         case POWER_SUPPLY_PROP_ONLINE:
 678                 if (psy->type == POWER_SUPPLY_TYPE_MAINS)
 679                 {
 680                         printk("POWER_SUPPLY_TYPE_MAINS\n");
 681                         if (rk29_adc_battery_get_charge_level(gBatteryData))
 682                         {
 683                                 val->intval = 1;
 684                                 }
 685                         else
 686                                 {
 687                                 val->intval = 0;
 688                                 }
 689                 }
 690                 DBG("%s:%d\n",__FUNCTION__,val->intval);
 691                 break;
 692
 693         default:
 694                 ret = -EINVAL;
 695                 break;
 696         }
 697
 698         return ret;
 699 }
 700
 701 static enum power_supply_property rk29_adc_battery_ac_props[] =
 702 {
 703         POWER_SUPPLY_PROP_ONLINE,
 704 };
 705
 706 static struct power_supply rk29_ac_supply =
 707 {
 708         .name = "ac",
 709         .type = POWER_SUPPLY_TYPE_MAINS,
 710
 711         .get_property   = rk29_adc_battery_get_ac_property,
 712
 713     .properties     = rk29_adc_battery_ac_props,
 714         .num_properties = ARRAY_SIZE(rk29_adc_battery_ac_props),
 715 };
 716
 717 static void rk29_adc_battery_dcdet_delaywork(struct work_struct *work)
 718 {
 719     int ret;
 720     struct rk29_adc_battery_platform_data *pdata = gBatteryData->pdata;
 721     int irq      = gpio_to_irq(pdata->dc_det_pin);
 722     int irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
 723
 724     rk28_send_wakeup_key();
 725
 726     free_irq(irq, NULL);
 727     ret = request_irq(irq, rk29_adc_battery_dc_wakeup, irq_flag, "rk29_adc_battery", NULL);
 728         if (ret) {
 729                 free_irq(irq, NULL);
 730         }
 731
 732         power_supply_changed(&rk29_ac_supply);
 733
 734     gBatteryData->bat_status_cnt = 0;        //×´Ì¬±ä»¯¿ªÊ¼¼ÆÊý
 735
 736                 wake_lock_timeout(&batt_wake_lock, 30 * HZ);
 737
 738 }
 739
 740
 741 #endif
 742
 743 static int rk29_adc_battery_get_status(struct rk29_adc_battery_data *bat)
 744 {
 745         return (bat->bat_status);
 746 }
 747
 748 static int rk29_adc_battery_get_health(struct rk29_adc_battery_data *bat)
 749 {
 750         return POWER_SUPPLY_HEALTH_GOOD;
 751 }
 752
 753 static int rk29_adc_battery_get_present(struct rk29_adc_battery_data *bat)
 754 {
 755         return (bat->bat_voltage < BATT_MAX_VOL_VALUE) ? 0 : 1;
 756 }
 757
 758 static int rk29_adc_battery_get_voltage(struct rk29_adc_battery_data *bat)
 759 {
 760         return (bat->bat_voltage );
 761 }
 762
 763 static int rk29_adc_battery_get_capacity(struct rk29_adc_battery_data *bat)
 764 {
 765         return (bat->bat_capacity);
 766 }
 767
 768 static int rk29_adc_battery_get_property(struct power_supply *psy,
 769                                  enum power_supply_property psp,
 770                                  union power_supply_propval *val)
 771 {
 772         int ret = 0;
 773
 774         switch (psp) {
 775         case POWER_SUPPLY_PROP_STATUS:
 776                 val->intval = rk29_adc_battery_get_status(gBatteryData);
 777                 DBG("gBatStatus=%d\n",val->intval);
 778                 break;
 779         case POWER_SUPPLY_PROP_HEALTH:
 780                 val->intval = rk29_adc_battery_get_health(gBatteryData);
 781                 DBG("gBatHealth=%d\n",val->intval);
 782                 break;
 783         case POWER_SUPPLY_PROP_PRESENT:
 784                 val->intval = rk29_adc_battery_get_present(gBatteryData);
 785                 DBG("gBatPresent=%d\n",val->intval);
 786                 break;
 787         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 788                 val ->intval = rk29_adc_battery_get_voltage(gBatteryData);
 789                 DBG("gBatVoltage=%d\n",val->intval);
 790                 break;
 791 //      case POWER_SUPPLY_PROP_CURRENT_NOW:
 792 //              val->intval = 1100;
 793 //              break;
 794         case POWER_SUPPLY_PROP_CAPACITY:
 795                 val->intval = rk29_adc_battery_get_capacity(gBatteryData);
 796                 DBG("gBatCapacity=%d%%\n",val->intval);
 797                 break;
 798         case POWER_SUPPLY_PROP_TECHNOLOGY:
 799                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 800                 break;
 801         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 802                 val->intval = BATT_MAX_VOL_VALUE;
 803                 break;
 804         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 805                 val->intval = BATT_ZERO_VOL_VALUE;
 806                 break;
 807         default:
 808                 ret = -EINVAL;
 809                 break;
 810         }
 811
 812         return ret;
 813 }
 814
 815 static enum power_supply_property rk29_adc_battery_props[] = {
 816
 817         POWER_SUPPLY_PROP_STATUS,
 818         POWER_SUPPLY_PROP_HEALTH,
 819         POWER_SUPPLY_PROP_PRESENT,
 820         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 821 //      POWER_SUPPLY_PROP_CURRENT_NOW,
 822         POWER_SUPPLY_PROP_TECHNOLOGY,
 823         POWER_SUPPLY_PROP_CAPACITY,
 824         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
 825         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 826 };
 827
 828 static struct power_supply rk29_battery_supply =
 829 {
 830         .name = "battery",
 831         .type = POWER_SUPPLY_TYPE_BATTERY,
 832
 833         .get_property   = rk29_adc_battery_get_property,
 834
 835     .properties     = rk29_adc_battery_props,
 836         .num_properties = ARRAY_SIZE(rk29_adc_battery_props),
 837 };
 838
 839
 840 #ifdef CONFIG_PM
 841 int suspend_capacity = 0;
 842 static void rk29_adc_battery_resume_check(struct work_struct *work)
 843 {
 844     int i;
 845     int level,oldlevel;
 846     int new_capacity, old_capacity;
 847     struct rk29_adc_battery_data *bat = gBatteryData;
 848
 849     old_charge_level = -1;
 850     pSamples = bat->adc_samples;
 851
 852     adc_sync_read(bat->client);                             //start adc sample
 853     level = oldlevel = rk29_adc_battery_status_samples(bat);//init charge status
 854
 855     for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++)                //0.3 s
 856     {
 857         mdelay(1);
 858         rk29_adc_battery_voltage_samples(bat);              //get voltage
 859         level = rk29_adc_battery_status_samples(bat);       //check charge status
 860         if (oldlevel != level)
 861         {
 862             oldlevel = level;                               //if charge status changed, reset sample
 863             i = 0;
 864         }
 865     }
 866     new_capacity = rk29_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
 867     old_capacity = suspend_capacity;
 868
 869     if (bat->bat_status != POWER_SUPPLY_STATUS_NOT_CHARGING)
 870     {
 871         //chargeing state
 872         bat->bat_capacity = (new_capacity > old_capacity) ? new_capacity : old_capacity;
 873     }
 874     else
 875     {
 876         bat->bat_capacity = (new_capacity < old_capacity) ? new_capacity : old_capacity;
 877     }
 878
 879     printk("rk29_adc_battery_resume: status = %d, voltage = %d, capacity = %d, new_capacity = %d, old_capacity = %d\n",
 880                                      bat->bat_status, bat->bat_voltage, bat->bat_capacity, new_capacity, old_capacity);
 881
 882     //start timer scan
 883         schedule_work(&bat->timer_work);
 884     bat->timer.expires  = jiffies + 10;
 885         add_timer(&bat->timer);
 886 }
 887
 888 static int rk29_adc_battery_suspend(struct platform_device *dev, pm_message_t state)
 889 {
 890         /* flush all pending status updates */
 891         suspend_capacity = gBatteryData->bat_capacity;
 892         del_timer(&gBatteryData->timer);
 893         //flush_scheduled_work();
 894         return 0;
 895 }
 896
 897 static int rk29_adc_battery_resume(struct platform_device *dev)
 898 {
 899         /* things may have changed while we were away */
 900         schedule_work(&gBatteryData->resume_work);
 901         return 0;
 902 }
 903 #else
 904 #define rk29_adc_battery_suspend NULL
 905 #define rk29_adc_battery_resume NULL
 906 #endif
 907
 908
 909 static int rk29_adc_battery_io_init(struct rk29_adc_battery_data *data, struct rk29_adc_battery_platform_data *pdata)
 910 {
 911     int ret = 0;
 912
 913     data->pdata = pdata;
 914
 915         if (pdata->io_init)
 916         {
 917                 pdata->io_init();
 918         }
 919
 920         //charge control pin
 921         if (pdata->charge_set_pin != INVALID_GPIO)
 922         {
 923         ret = gpio_request(pdata->charge_set_pin, NULL);
 924         if (ret) {
 925                 printk("failed to request dc_det gpio\n");
 926                 goto error;
 927         }
 928         gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level);
 929     }
 930
 931         //dc charge detect pin
 932         if (pdata->dc_det_pin != INVALID_GPIO)
 933         {
 934         ret = gpio_request(pdata->dc_det_pin, NULL);
 935         if (ret) {
 936                 printk("failed to request dc_det gpio\n");
 937                 goto error;
 938         }
 939
 940         gpio_pull_updown(pdata->dc_det_pin, GPIOPullUp);//important
 941         ret = gpio_direction_input(pdata->dc_det_pin);
 942         if (ret) {
 943                 printk("failed to set gpio dc_det input\n");
 944                 goto error;
 945         }
 946     }
 947
 948         //charge ok detect
 949         if (pdata->charge_ok_pin != INVALID_GPIO)
 950         {
 951         ret = gpio_request(pdata->charge_ok_pin, NULL);
 952         if (ret) {
 953                 printk("failed to request charge_ok gpio\n");
 954                 goto error;
 955         }
 956
 957         gpio_pull_updown(pdata->charge_ok_pin, GPIOPullUp);//important
 958         ret = gpio_direction_input(pdata->charge_ok_pin);
 959         if (ret) {
 960                 printk("failed to set gpio charge_ok input\n");
 961                 goto error;
 962         }
 963     }
 964
 965     return 0;
 966 error:
 967     return -1;
 968 }
 969
 970 #define POWER_ON_PIN    RK29_PIN4_PA4
 971 static void rk29_adc_battery_lowpower_check(struct rk29_adc_battery_data *bat)
 972 {
 973     int i;
 974     int tmp = 0;
 975     int level,oldlevel;
 976     struct rk29_adc_battery_platform_data *pdata = bat->pdata;
 977
 978     printk("%s--%d:\n",__FUNCTION__,__LINE__);
 979
 980     old_charge_level = -1;
 981     pSamples = bat->adc_samples;
 982
 983     adc_sync_read(bat->client);                             //start adc sample
 984     level = oldlevel = rk29_adc_battery_status_samples(bat);//init charge status
 985
 986     bat->full_times = 0;
 987     for (i = 0; i < NUM_VOLTAGE_SAMPLE; i++)                //0.3 s
 988     {
 989         mdelay(1);
 990         rk29_adc_battery_voltage_samples(bat);              //get voltage
 991         //level = rk29_adc_battery_status_samples(bat);       //check charge status
 992         level = rk29_adc_battery_get_charge_level(bat);
 993         if (oldlevel != level)
 994         {
 995             oldlevel = level;                               //if charge status changed, reset sample
 996             i = 0;
 997         }
 998     }
 999
1000     bat->bat_capacity = rk29_adc_battery_voltage_to_capacity(bat, bat->bat_voltage);
1001     bat->bat_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1002     if (rk29_adc_battery_get_charge_level(bat))
1003     {
1004         bat->bat_status = POWER_SUPPLY_STATUS_CHARGING;
1005         if (pdata->charge_ok_pin != INVALID_GPIO)
1006         {
1007             if (gpio_get_value(pdata->charge_ok_pin) == pdata->charge_ok_level)
1008             {
1009                 bat->bat_status = POWER_SUPPLY_STATUS_FULL;
1010                 bat->bat_capacity = 100;
1011             }
1012         }
1013     }
1014
1015 #if 0
1016     rk29_adc_battery_poweron_capacity_check();
1017 #else
1018     poweron_check = 1;
1019 #endif
1020
1021
1022     /*******************************************
1023     //¿ª»ú²ÉÑùµ½µÄµçÑ¹ºÍÉÏ´Î¹Ø»ú±£´æµçÑ¹Ïà²î½Ï´ó£¬ÔõÃ´´¦Àí£¿
1024     if (bat->bat_capacity > old_capacity)
1025     {
1026         if ((bat->bat_capacity - old_capacity) > 20)
1027         {
1028
1029         }
1030     }
1031     else if (bat->bat_capacity < old_capacity)
1032     {
1033         if ((old_capacity > bat->bat_capacity) > 20)
1034         {
1035
1036         }
1037     }
1038     *********************************************/
1039     if (bat->bat_capacity == 0) bat->bat_capacity = 1;
1040
1041     if (bat->bat_voltage <= BATT_ZERO_VOL_VALUE + 50)
1042     {
1043         printk("low battery: powerdown\n");
1044         gpio_direction_output(POWER_ON_PIN, GPIO_LOW);
1045         tmp = 0;
1046         while(1)
1047         {
1048             if(gpio_get_value(POWER_ON_PIN) == GPIO_HIGH)
1049                     {
1050                             gpio_set_value(POWER_ON_PIN,GPIO_LOW);
1051                     }
1052                     mdelay(5);
1053                     if (++tmp > 50) break;
1054                 }
1055     }
1056     gpio_direction_output(POWER_ON_PIN, GPIO_HIGH);
1057 }
1058
1059 static void rk29_adc_battery_callback(struct adc_client *client, void *param, int result)
1060 {
1061     gBatteryData->adc_val = result;
1062         return;
1063 }
1064
1065 static int rk29_adc_battery_probe(struct platform_device *pdev)
1066 {
1067         int    ret;
1068         int    irq;
1069         int    irq_flag;
1070         struct adc_client                   *client;
1071         struct rk29_adc_battery_data          *data;
1072         struct rk29_adc_battery_platform_data *pdata = pdev->dev.platform_data;
1073
1074         printk("%s--%d:\n",__FUNCTION__,__LINE__);
1075
1076         data = kzalloc(sizeof(*data), GFP_KERNEL);
1077         if (data == NULL) {
1078                 ret = -ENOMEM;
1079                 goto err_data_alloc_failed;
1080         }
1081         gBatteryData = data;
1082         platform_set_drvdata(pdev, data);
1083
1084         ret = rk29_adc_battery_io_init(data, pdata);
1085     if (ret)
1086     {
1087         goto err_io_init;
1088     }
1089
1090     //register adc for battery sample
1091         memset(data->adc_samples, 0, sizeof(int)*(NUM_VOLTAGE_SAMPLE + 2));
1092     client = adc_register(0, rk29_adc_battery_callback, NULL);
1093     if(!client)
1094                 goto err_adc_register_failed;
1095
1096     //variable init
1097         data->client  = client;
1098         data->adc_val = adc_sync_read(client);
1099
1100         //init a timer for adc sample
1101         //init a delay work for adc timer work
1102     setup_timer(&data->timer, rk29_adc_battery_scan_timer, (unsigned long)data);
1103         data->timer.expires  = jiffies + 2000;
1104         add_timer(&data->timer);
1105
1106         INIT_WORK(&data->timer_work, rk29_adc_battery_timer_work);
1107         INIT_WORK(&data->resume_work, rk29_adc_battery_resume_check);
1108
1109 #if defined(CONFIG_BATTERY_RK29_AC_CHARGE)
1110         //init dc dectet irq & delay work
1111     if (pdata->dc_det_pin != INVALID_GPIO)
1112     {
1113         irq = gpio_to_irq(pdata->dc_det_pin);
1114
1115         irq_flag = gpio_get_value (pdata->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1116         ret = request_irq(irq, rk29_adc_battery_dc_wakeup, irq_flag, "rk29_adc_battery", NULL);
1117         if (ret) {
1118                 printk("failed to request dc det irq\n");
1119                 goto err_dcirq_failed;
1120         }
1121         enable_irq_wake(irq);
1122
1123         INIT_WORK(&data->dcwakeup_work, rk29_adc_battery_dcdet_delaywork);
1124     }
1125 #endif
1126
1127     //Power on Battery detect
1128         rk29_adc_battery_lowpower_check(data);
1129
1130     //power supply register
1131     wake_lock_init(&batt_wake_lock, WAKE_LOCK_SUSPEND, "batt_lock");
1132
1133         ret = power_supply_register(&pdev->dev, &rk29_battery_supply);
1134         if (ret)
1135         {
1136                 printk(KERN_INFO "fail to battery power_supply_register\n");
1137                 goto err_battery_failed;
1138         }
1139
1140 #if defined(CONFIG_BATTERY_RK29_AC_CHARGE)
1141         ret = power_supply_register(&pdev->dev, &rk29_ac_supply);
1142         if (ret)
1143         {
1144                 printk(KERN_INFO "fail to ac power_supply_register\n");
1145                 goto err_ac_failed;
1146         }
1147 #endif
1148
1149 #if defined(CONFIG_BATTERY_RK29_USB_CHARGE)
1150         ret = power_supply_register(&pdev->dev, &rk29_usb_supply);
1151         if (ret)
1152         {
1153                 printk(KERN_INFO "fail to usb power_supply_register\n");
1154                 goto err_usb_failed;
1155         }
1156 #endif
1157
1158         printk(KERN_INFO "rk29_adc_battery: driver initialized\n");
1159
1160         return 0;
1161
1162 #if defined(CONFIG_BATTERY_RK29_USB_CHARGE)
1163 err_usb_failed:
1164         power_supply_unregister(&rk29_usb_supply);
1165 #endif
1166
1167 err_ac_failed:
1168 #if defined(CONFIG_BATTERY_RK29_AC_CHARGE)
1169         power_supply_unregister(&rk29_ac_supply);
1170 #endif
1171
1172 err_battery_failed:
1173         power_supply_unregister(&rk29_battery_supply);
1174
1175 err_dcirq_failed:
1176     free_irq(gpio_to_irq(pdata->dc_det_pin), data);
1177
1178 err_adc_register_failed:
1179 err_io_init:
1180 err_data_alloc_failed:
1181         kfree(data);
1182
1183     printk("rk29_adc_battery: error!\n");
1184
1185         return ret;
1186 }
1187
1188 static int rk29_adc_battery_remove(struct platform_device *pdev)
1189 {
1190         struct rk29_adc_battery_data *data = platform_get_drvdata(pdev);
1191         struct rk29_adc_battery_platform_data *pdata = pdev->dev.platform_data;
1192
1193 #if defined(CONFIG_BATTERY_RK29_USB_CHARGE)
1194         power_supply_unregister(&rk29_usb_supply);
1195 #endif
1196 #if defined(CONFIG_BATTERY_RK29_AC_CHARGE)
1197         power_supply_unregister(&rk29_ac_supply);
1198 #endif
1199         power_supply_unregister(&rk29_battery_supply);
1200
1201         free_irq(gpio_to_irq(pdata->dc_det_pin), data);
1202
1203         kfree(data);
1204
1205         return 0;
1206 }
1207
1208 static struct platform_driver rk29_adc_battery_driver = {
1209         .probe          = rk29_adc_battery_probe,
1210         .remove         = rk29_adc_battery_remove,
1211         .suspend        = rk29_adc_battery_suspend,
1212         .resume         = rk29_adc_battery_resume,
1213         .driver = {
1214                 .name = "rk2918-battery",
1215                 .owner  = THIS_MODULE,
1216         }
1217 };
1218
1219 static int __init rk29_adc_battery_init(void)
1220 {
1221         return platform_driver_register(&rk29_adc_battery_driver);
1222 }
1223
1224 static void __exit rk29_adc_battery_exit(void)
1225 {
1226         platform_driver_unregister(&rk29_adc_battery_driver);
1227 }
1228
1229 subsys_initcall(rk29_adc_battery_init);
1230 module_exit(rk29_adc_battery_exit);
1231
1232 MODULE_DESCRIPTION("Battery detect driver for the rk2918");
1233 MODULE_AUTHOR("luowei lw@rock-chips.com");
1234 MODULE_LICENSE("GPL");