drivers/power/rk29_adc_battery.c

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