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