drivers/power/rk30_adc_battery.c

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