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