drivers/power/cw2015_battery.c

   1 /*
   2  * RockChip ADC Battery Driver
   3  * Copyright (C) 2012, RockChip
   4  *
   5  * Authors: xuhuicong <xhc@rock-chips.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  */
  12
  13 // #define DEBUG    1
  14
  15 #include <linux/platform_device.h>
  16 #include <linux/power_supply.h>
  17 #include <linux/workqueue.h>
  18 #include <linux/kernel.h>
  19 #include <linux/i2c.h>
  20 #include <mach/gpio.h>
  21 #include <linux/delay.h>
  22 #include <linux/power/cw2015_battery.h>
  23 #include <linux/time.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/irq.h>
  26 #include <mach/board.h>
  27
  28 #define REG_VERSION             0x0
  29 #define REG_VCELL               0x2
  30 #define REG_SOC                 0x4
  31 #define REG_RRT_ALERT           0x6
  32 #define REG_CONFIG              0x8
  33 #define REG_MODE                0xA
  34 #define REG_BATINFO             0x10
  35
  36 #define MODE_SLEEP_MASK         (0x3<<6)
  37 #define MODE_SLEEP              (0x3<<6)
  38 #define MODE_NORMAL             (0x0<<6)
  39 #define MODE_QUICK_START        (0x3<<4)
  40 #define MODE_RESTART            (0xf<<0)
  41
  42 #define CONFIG_UPDATE_FLG       (0x1<<1)
  43 #define ATHD                    (0x0<<3)        //ATHD = 0%
  44
  45 #define CW_I2C_SPEED            100000          // default i2c speed set 100khz
  46 #define BATTERY_UP_MAX_CHANGE   420             // the max time allow battery change quantity
  47 #define BATTERY_DOWN_CHANGE   60                // the max time allow battery change quantity
  48 #define BATTERY_DOWN_MIN_CHANGE_RUN 30          // the min time allow battery change quantity when run
  49 #define BATTERY_DOWN_MIN_CHANGE_SLEEP 1800      // the min time allow battery change quantity when run 30min
  50
  51 #define BATTERY_DOWN_MAX_CHANGE_RUN_AC_ONLINE 3600
  52
  53 #define NO_STANDARD_AC_BIG_CHARGE_MODE 1
  54 // #define SYSTEM_SHUTDOWN_VOLTAGE  3400000        //set system shutdown voltage related in battery info.
  55 #define BAT_LOW_INTERRUPT    1
  56
  57 #define USB_CHARGER_MODE        1
  58 #define AC_CHARGER_MODE         2
  59
  60 extern int dwc_otg_check_dpdm(void);
  61 extern int get_gadget_connect_flag(void);
  62 extern int dwc_vbus_status( void );
  63
  64 struct cw_battery {
  65         struct i2c_client *client;
  66         struct workqueue_struct *battery_workqueue;
  67         struct delayed_work battery_delay_work;
  68         struct delayed_work dc_wakeup_work;
  69         struct delayed_work bat_low_wakeup_work;
  70         const struct cw_bat_platform_data *plat_data;
  71
  72         struct power_supply rk_bat;
  73         struct power_supply rk_ac;
  74         struct power_supply rk_usb;
  75
  76         long sleep_time_capacity_change;      // the sleep time from capacity change to present, it will set 0 when capacity change
  77         long run_time_capacity_change;
  78
  79         long sleep_time_charge_start;      // the sleep time from insert ac to present, it will set 0 when insert ac
  80         long run_time_charge_start;
  81
  82         int dc_online;
  83         int usb_online;
  84         int charger_mode;
  85         int charger_init_mode;
  86         int capacity;
  87         int voltage;
  88         int status;
  89         int time_to_empty;
  90         int alt;
  91
  92         int bat_change;
  93 };
  94
  95 static int cw_read(struct i2c_client *client, u8 reg, u8 buf[])
  96 {
  97         int ret;
  98         ret = i2c_master_reg8_recv(client, reg, buf, 1, CW_I2C_SPEED);
  99         return ret;
 100 }
 101
 102 static int cw_write(struct i2c_client *client, u8 reg, u8 const buf[])
 103 {
 104         int ret;
 105         ret = i2c_master_reg8_send(client, reg, buf, 1, CW_I2C_SPEED);
 106         return ret;
 107 }
 108
 109 static int cw_read_word(struct i2c_client *client, u8 reg, u8 buf[])
 110 {
 111         int ret;
 112         ret = i2c_master_reg8_recv(client, reg, buf, 2, CW_I2C_SPEED);
 113         return ret;
 114 }
 115
 116 #if 0
 117 static int cw_write_word(struct i2c_client *client, u8 reg, u8 const buf[])
 118 {
 119         int ret;
 120         ret = i2c_master_reg8_send(client, reg, buf, 2, CW_I2C_SPEED);
 121         return ret;
 122 }
 123 #endif
 124
 125
 126
 127 static int cw_update_config_info(struct cw_battery *cw_bat)
 128 {
 129         int ret;
 130         u8 reg_val;
 131         int i;
 132         u8 reset_val;
 133
 134         dev_info(&cw_bat->client->dev, "func: %s-------\n", __func__);
 135
 136         /* make sure no in sleep mode */
 137         ret = cw_read(cw_bat->client, REG_MODE, &reg_val);
 138         if (ret < 0)
 139                 return ret;
 140
 141         reset_val = reg_val;
 142         if((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
 143                 dev_err(&cw_bat->client->dev, "Error, device in sleep mode, cannot update battery info\n");
 144                 return -1;
 145         }
 146
 147         /* update new battery info */
 148         for (i = 0; i < SIZE_BATINFO; i++) {
 149                 dev_info(&cw_bat->client->dev, "cw_bat->plat_data->cw_bat_config_info[%d] = 0x%x\n", i, \
 150                                 cw_bat->plat_data->cw_bat_config_info[i]);
 151                 ret = cw_write(cw_bat->client, REG_BATINFO + i, &cw_bat->plat_data->cw_bat_config_info[i]);
 152
 153                 if (ret < 0)
 154                         return ret;
 155         }
 156
 157         /* readback & check */
 158         for (i = 0; i < SIZE_BATINFO; i++) {
 159                 ret = cw_read(cw_bat->client, REG_BATINFO + i, &reg_val);
 160                 if (reg_val != cw_bat->plat_data->cw_bat_config_info[i])
 161                         return -1;
 162         }
 163
 164         /* set cw2015/cw2013 to use new battery info */
 165         ret = cw_read(cw_bat->client, REG_CONFIG, &reg_val);
 166         if (ret < 0)
 167                 return ret;
 168
 169         reg_val |= CONFIG_UPDATE_FLG;   /* set UPDATE_FLAG */
 170         reg_val &= 0x07;                /* clear ATHD */
 171         reg_val |= ATHD;                /* set ATHD */
 172         ret = cw_write(cw_bat->client, REG_CONFIG, &reg_val);
 173         if (ret < 0)
 174                 return ret;
 175
 176         /* check 2015/cw2013 for ATHD & update_flag */
 177         ret = cw_read(cw_bat->client, REG_CONFIG, &reg_val);
 178         if (ret < 0)
 179                 return ret;
 180
 181         if (!(reg_val & CONFIG_UPDATE_FLG)) {
 182                 dev_info(&cw_bat->client->dev, "update flag for new battery info have not set..\n");
 183         }
 184
 185         if ((reg_val & 0xf8) != ATHD) {
 186                 dev_info(&cw_bat->client->dev, "the new ATHD have not set..\n");
 187         }
 188
 189         /* reset */
 190         reset_val &= ~(MODE_RESTART);
 191         reg_val = reset_val | MODE_RESTART;
 192         ret = cw_write(cw_bat->client, REG_MODE, &reg_val);
 193         if (ret < 0)
 194                 return ret;
 195
 196         msleep(10);
 197         ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
 198         if (ret < 0)
 199                 return ret;
 200
 201         return 0;
 202 }
 203
 204 static int cw_init(struct cw_battery *cw_bat)
 205 {
 206         int ret;
 207         int i;
 208         u8 reg_val = MODE_SLEEP;
 209 #if 0
 210         ret = cw_read(cw_bat->client, REG_MODE, &reg_val);
 211         if (ret < 0)
 212                 return ret;
 213 #endif
 214         if ((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
 215                 reg_val = MODE_NORMAL;
 216                 ret = cw_write(cw_bat->client, REG_MODE, &reg_val);
 217                 if (ret < 0)
 218                         return ret;
 219         }
 220
 221         ret = cw_read(cw_bat->client, REG_CONFIG, &reg_val);
 222         if (ret < 0)
 223                 return ret;
 224
 225         if ((reg_val & 0xf8) != ATHD) {
 226                 dev_info(&cw_bat->client->dev, "the new ATHD have not set\n");
 227                 reg_val &= 0x07;    /* clear ATHD */
 228                 reg_val |= ATHD;    /* set ATHD */
 229                 ret = cw_write(cw_bat->client, REG_CONFIG, &reg_val);
 230                 if (ret < 0)
 231                         return ret;
 232         }
 233
 234         ret = cw_read(cw_bat->client, REG_CONFIG, &reg_val);
 235         if (ret < 0)
 236                 return ret;
 237
 238         if (!(reg_val & CONFIG_UPDATE_FLG)) {
 239                 dev_info(&cw_bat->client->dev, "update flag for new battery info have not set\n");
 240                 ret = cw_update_config_info(cw_bat);
 241                 if (ret < 0)
 242                         return ret;
 243         } else {
 244                 for(i = 0; i < SIZE_BATINFO; i++) {
 245                         ret = cw_read(cw_bat->client, (REG_BATINFO + i), &reg_val);
 246                         if (ret < 0)
 247                                 return ret;
 248
 249                         if (cw_bat->plat_data->cw_bat_config_info[i] != reg_val)
 250                                 break;
 251                 }
 252
 253                 if (i != SIZE_BATINFO) {
 254                         dev_info(&cw_bat->client->dev, "update flag for new battery info have not set\n");
 255                         ret = cw_update_config_info(cw_bat);
 256                         if (ret < 0)
 257                                 return ret;
 258                 }
 259         }
 260
 261         for (i = 0; i < 30; i++) {
 262                 ret = cw_read(cw_bat->client, REG_SOC, &reg_val);
 263                 if (ret < 0)
 264                         return ret;
 265                 else if (ret != 0xff)
 266                         break;
 267
 268                 msleep(100);
 269                 if (i > 25)
 270                         dev_err(&cw_bat->client->dev, "cw2015/cw2013 input unvalid power error\n");
 271
 272         }
 273
 274         return 0;
 275 }
 276
 277 static void cw_update_time_member_charge_start(struct cw_battery *cw_bat)
 278 {
 279         struct timespec ts;
 280         int new_run_time;
 281         int new_sleep_time;
 282
 283         ktime_get_ts(&ts);
 284         new_run_time = ts.tv_sec;
 285
 286         get_monotonic_boottime(&ts);
 287         new_sleep_time = ts.tv_sec - new_run_time;
 288
 289         cw_bat->run_time_charge_start = new_run_time;
 290         cw_bat->sleep_time_charge_start = new_sleep_time;
 291 }
 292
 293 static void cw_update_time_member_capacity_change(struct cw_battery *cw_bat)
 294 {
 295         struct timespec ts;
 296         int new_run_time;
 297         int new_sleep_time;
 298
 299         ktime_get_ts(&ts);
 300         new_run_time = ts.tv_sec;
 301
 302         get_monotonic_boottime(&ts);
 303         new_sleep_time = ts.tv_sec - new_run_time;
 304
 305         cw_bat->run_time_capacity_change = new_run_time;
 306         cw_bat->sleep_time_capacity_change = new_sleep_time;
 307 }
 308
 309 static int cw_quickstart(struct cw_battery *cw_bat)
 310 {
 311         int ret = 0;
 312         u8 reg_val = MODE_QUICK_START;
 313
 314         ret = cw_write(cw_bat->client, REG_MODE, &reg_val);     //(MODE_QUICK_START | MODE_NORMAL));  // 0x30
 315         if(ret < 0) {
 316                 dev_err(&cw_bat->client->dev, "Error quick start1\n");
 317                 return ret;
 318         }
 319
 320         reg_val = MODE_NORMAL;
 321         ret = cw_write(cw_bat->client, REG_MODE, &reg_val);
 322         if(ret < 0) {
 323                 dev_err(&cw_bat->client->dev, "Error quick start2\n");
 324                 return ret;
 325         }
 326         return 1;
 327 }
 328
 329 static int cw_get_capacity(struct cw_battery *cw_bat)
 330 {
 331         int cw_capacity;
 332         int ret;
 333         u8 reg_val[2];
 334
 335         struct timespec ts;
 336         long new_run_time;
 337         long new_sleep_time;
 338         long capacity_or_aconline_time;
 339         int allow_change;
 340         int allow_capacity;
 341         static int if_quickstart = 0;
 342         static int jump_flag =0;
 343         int charge_time;
 344
 345
 346         // ret = cw_read(cw_bat->client, REG_SOC, &reg_val);
 347         ret = cw_read_word(cw_bat->client, REG_SOC, reg_val);
 348         if (ret < 0)
 349                 return ret;
 350
 351         cw_capacity = reg_val[0];
 352         if ((cw_capacity < 0) || (cw_capacity > 100)) {
 353                 dev_err(&cw_bat->client->dev, "get cw_capacity error; cw_capacity = %d\n", cw_capacity);
 354                 return cw_capacity;
 355         }
 356
 357         if (cw_capacity == 0)
 358                 dev_dbg(&cw_bat->client->dev, "the cw201x capacity is 0 !!!!!!!, funciton: %s, line: %d\n", __func__, __LINE__);
 359         else
 360                 dev_dbg(&cw_bat->client->dev, "the cw201x capacity is %d, funciton: %s\n", cw_capacity, __func__);
 361
 362         // ret = cw_read(cw_bat->client, REG_SOC + 1, &reg_val);
 363
 364         ktime_get_ts(&ts);
 365         new_run_time = ts.tv_sec;
 366
 367         get_monotonic_boottime(&ts);
 368         new_sleep_time = ts.tv_sec - new_run_time;
 369
 370         if ((cw_bat->charger_mode > 0) && (cw_capacity >= 95) && (cw_capacity <= cw_bat->capacity)) {     // avoid no charge full
 371
 372                 capacity_or_aconline_time = (cw_bat->sleep_time_capacity_change > cw_bat->sleep_time_charge_start) ? cw_bat->sleep_time_capacity_change : cw_bat->sleep_time_charge_start;
 373                 capacity_or_aconline_time += (cw_bat->run_time_capacity_change > cw_bat->run_time_charge_start) ? cw_bat->run_time_capacity_change : cw_bat->run_time_charge_start;
 374                 allow_change = (new_sleep_time + new_run_time - capacity_or_aconline_time) / BATTERY_UP_MAX_CHANGE;
 375                 if (allow_change > 0) {
 376                         allow_capacity = cw_bat->capacity + allow_change;
 377                         cw_capacity = (allow_capacity <= 100) ? allow_capacity : 100;
 378                         jump_flag =1;
 379                 } else if (cw_capacity <= cw_bat->capacity) {
 380                         cw_capacity = cw_bat->capacity;
 381                 }
 382
 383         } else if (((cw_bat->charger_mode > 0) && (cw_capacity == (cw_bat->capacity - 1)))
 384                         || ((cw_bat->charger_mode == 0) && (cw_capacity == (cw_bat->capacity + 1)))) {             // modify battery level swing
 385
 386                 if (!(cw_capacity == 0 && cw_bat->capacity == 1)) {
 387                         cw_capacity = cw_bat->capacity;
 388                 }
 389
 390
 391         } else if ((cw_capacity == 0) && (cw_bat->capacity > 1)) {              // avoid battery level jump to 0% at a moment from more than 2%
 392                 allow_change = ((new_run_time - cw_bat->run_time_capacity_change) / BATTERY_DOWN_MIN_CHANGE_RUN);
 393                 allow_change += ((new_sleep_time - cw_bat->sleep_time_capacity_change) / BATTERY_DOWN_MIN_CHANGE_SLEEP);
 394
 395                 allow_capacity = cw_bat->capacity - allow_change;
 396                 cw_capacity = (allow_capacity >= cw_capacity) ? allow_capacity: cw_capacity;
 397                 reg_val[0] = MODE_NORMAL;
 398                 ret = cw_write(cw_bat->client, REG_MODE, reg_val);
 399                 if (ret < 0)
 400                         return ret;
 401
 402         } else if ((cw_bat->charger_mode == 0) && (cw_capacity <= cw_bat->capacity ) && (cw_capacity >= 90) && (jump_flag == 1)) {     // avoid battery level jump to CW_BAT
 403                 capacity_or_aconline_time = (cw_bat->sleep_time_capacity_change > cw_bat->sleep_time_charge_start) ? cw_bat->sleep_time_capacity_change : cw_bat->sleep_time_charge_start;
 404                 capacity_or_aconline_time += (cw_bat->run_time_capacity_change > cw_bat->run_time_charge_start) ? cw_bat->run_time_capacity_change : cw_bat->run_time_charge_start;
 405                 allow_change = (new_sleep_time + new_run_time - capacity_or_aconline_time) / BATTERY_DOWN_CHANGE;
 406                 if (allow_change > 0) {
 407                         allow_capacity = cw_bat->capacity - allow_change;
 408                         if (cw_capacity >= allow_capacity){
 409                                 jump_flag =0;
 410                         }
 411                         else{
 412                                 cw_capacity = (allow_capacity <= 100) ? allow_capacity : 100;
 413                         }
 414                 } else if (cw_capacity <= cw_bat->capacity) {
 415                         cw_capacity = cw_bat->capacity;
 416                 }
 417         }
 418
 419 #if 1
 420         if((cw_bat->charger_mode > 0) &&(cw_capacity == 0))
 421         {
 422                 charge_time = new_sleep_time + new_run_time - cw_bat->sleep_time_charge_start - cw_bat->run_time_charge_start;
 423                 if ((charge_time > BATTERY_DOWN_MAX_CHANGE_RUN_AC_ONLINE) && (if_quickstart == 0)) {
 424                         cw_quickstart(cw_bat);      // if the cw_capacity = 0 the cw2015 will qstrt
 425                         if_quickstart = 1;
 426                 }
 427         } else if ((if_quickstart == 1)&&(cw_bat->charger_mode == 0)) {
 428                 if_quickstart = 0;
 429         }
 430
 431 #endif
 432
 433 #if 0
 434         if (cw_bat->plat_data->chg_ok_pin != INVALID_GPIO) {
 435                 if(gpio_get_value(cw_bat->plat_data->chg_ok_pin) != cw_bat->plat_data->chg_ok_level) {
 436                         if (cw_capacity == 100) {
 437                                 cw_capacity = 99;
 438                         }
 439                 } else {
 440                         if (cw_bat->charger_mode > 0) {
 441                                 cw_capacity = 100;
 442                         }
 443                 }
 444         }
 445 #endif
 446
 447 #ifdef SYSTEM_SHUTDOWN_VOLTAGE
 448         if ((cw_bat->charger_mode == 0) && (cw_capacity <= 10) && (cw_bat->voltage <= SYSTEM_SHUTDOWN_VOLTAGE)){
 449                 if (if_quickstart == 10){
 450                         cw_quickstart(cw_bat);
 451                         if_quickstart = 12;
 452                         cw_capacity = 0;
 453                 } else if (if_quickstart <= 10)
 454                         if_quickstart =if_quickstart+2;
 455                 dev_info(&cw_bat->client->dev, "the cw201x voltage is less than SYSTEM_SHUTDOWN_VOLTAGE !!!!!!!, funciton: %s, line: %d\n", __func__, __LINE__);
 456         } else if ((cw_bat->charger_mode > 0)&& (if_quickstart <= 12)) {
 457                 if_quickstart = 0;
 458         }
 459 #endif
 460         return cw_capacity;
 461 }
 462
 463 static int cw_get_vol(struct cw_battery *cw_bat)
 464 {
 465         int ret;
 466         u8 reg_val[2];
 467         u16 value16, value16_1, value16_2, value16_3;
 468         int voltage;
 469
 470         ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
 471         if (ret < 0)
 472                 return ret;
 473         value16 = (reg_val[0] << 8) + reg_val[1];
 474
 475         ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
 476         if (ret < 0)
 477                 return ret;
 478         value16_1 = (reg_val[0] << 8) + reg_val[1];
 479
 480         ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
 481         if (ret < 0)
 482                 return ret;
 483         value16_2 = (reg_val[0] << 8) + reg_val[1];
 484
 485
 486         if(value16 > value16_1)
 487             {
 488                 value16_3 = value16;
 489                     value16 = value16_1;
 490                     value16_1 = value16_3;
 491         }
 492
 493         if(value16_1 > value16_2)
 494             {
 495                 value16_3 =value16_1;
 496                         value16_1 =value16_2;
 497                         value16_2 =value16_3;
 498             }
 499
 500         if(value16 >value16_1)
 501             {
 502                 value16_3 =value16;
 503                         value16 =value16_1;
 504                         value16_1 =value16_3;
 505         }
 506
 507         voltage = value16_1 * 312 / 1024;
 508         voltage = voltage * 1000;
 509
 510         return voltage;
 511 }
 512
 513 #ifdef BAT_LOW_INTERRUPT
 514 static int cw_get_alt(struct cw_battery *cw_bat)
 515 {
 516         int ret = 0;
 517         u8 reg_val;
 518         u8 value8 = 0;
 519         int alrt;
 520
 521         ret = cw_read(cw_bat->client, REG_RRT_ALERT, &reg_val);
 522         if (ret < 0)
 523                 return ret;
 524         value8 = reg_val;
 525         alrt = value8 >>7;
 526
 527         //dev_info(&cw_bat->client->dev, "read RRT %d%%. value16 0x%x\n", alrt, value16);
 528         value8 = value8&0x7f;
 529         reg_val = value8;
 530         ret = cw_write(cw_bat->client, REG_RRT_ALERT, &reg_val);
 531         if(ret < 0) {
 532                 dev_err(&cw_bat->client->dev, "Error clear ALRT\n");
 533                 return ret;
 534         }
 535
 536         return alrt;
 537 }
 538 #endif
 539
 540
 541 static int cw_get_time_to_empty(struct cw_battery *cw_bat)
 542 {
 543         int ret;
 544         u8 reg_val;
 545         u16 value16;
 546
 547         ret = cw_read(cw_bat->client, REG_RRT_ALERT, &reg_val);
 548         if (ret < 0)
 549                 return ret;
 550
 551         value16 = reg_val;
 552
 553         ret = cw_read(cw_bat->client, REG_RRT_ALERT + 1, &reg_val);
 554         if (ret < 0)
 555                 return ret;
 556
 557         value16 = ((value16 << 8) + reg_val) & 0x1fff;
 558         return value16;
 559 }
 560
 561 static void rk_bat_update_capacity(struct cw_battery *cw_bat)
 562 {
 563         int cw_capacity;
 564
 565         cw_capacity = cw_get_capacity(cw_bat);
 566         if ((cw_capacity >= 0) && (cw_capacity <= 100) && (cw_bat->capacity != cw_capacity)) {
 567                 cw_bat->capacity = cw_capacity;
 568                 cw_bat->bat_change = 1;
 569                 cw_update_time_member_capacity_change(cw_bat);
 570
 571                 if (cw_bat->capacity == 0)
 572                         dev_info(&cw_bat->client->dev, "report battery capacity 0 and will shutdown if no changing");
 573
 574         }
 575 }
 576
 577
 578
 579 static void rk_bat_update_vol(struct cw_battery *cw_bat)
 580 {
 581         int ret;
 582         ret = cw_get_vol(cw_bat);
 583         if ((ret >= 0) && (cw_bat->voltage != ret)) {
 584                 cw_bat->voltage = ret;
 585                 cw_bat->bat_change = 1;
 586         }
 587 }
 588
 589 static void rk_bat_update_status(struct cw_battery *cw_bat)
 590 {
 591         int status;
 592
 593
 594         if (cw_bat->charger_mode > 0) {
 595                 if (cw_bat->capacity >= 100)
 596                         status=POWER_SUPPLY_STATUS_FULL;
 597                 else
 598                         status=POWER_SUPPLY_STATUS_CHARGING;
 599         } else {
 600                 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 601         }
 602
 603         if (cw_bat->status != status) {
 604                 cw_bat->status = status;
 605                 cw_bat->bat_change = 1;
 606
 607         }
 608 }
 609
 610 static void rk_bat_update_time_to_empty(struct cw_battery *cw_bat)
 611 {
 612         int ret;
 613         ret = cw_get_time_to_empty(cw_bat);
 614         if ((ret >= 0) && (cw_bat->time_to_empty != ret)) {
 615                 cw_bat->time_to_empty = ret;
 616                 cw_bat->bat_change = 1;
 617         }
 618
 619 }
 620
 621 static int rk_ac_update_online(struct cw_battery *cw_bat)
 622 {
 623         int ret = 0;
 624
 625         if(cw_bat->plat_data->dc_det_pin == INVALID_GPIO) {
 626                 cw_bat->dc_online = 0;
 627                 return 0;
 628         }
 629 #if 0
 630         if (cw_bat->plat_data->is_dc_charge == 0) {
 631                 cw_bat->dc_online = 0;
 632                 return 0;
 633         }
 634 #endif
 635
 636         if (gpio_get_value(cw_bat->plat_data->dc_det_pin) == cw_bat->plat_data->dc_det_level) {
 637                 if (cw_bat->dc_online != 1) {
 638                         cw_update_time_member_charge_start(cw_bat);
 639                         cw_bat->dc_online = 1;
 640                         if (cw_bat->charger_mode != AC_CHARGER_MODE)
 641                                 cw_bat->charger_mode = AC_CHARGER_MODE;
 642
 643                         ret = 1;
 644                 }
 645         } else {
 646                 if (cw_bat->dc_online != 0) {
 647                         cw_update_time_member_charge_start(cw_bat);
 648                         cw_bat->dc_online = 0;
 649                         if (cw_bat->usb_online == 0)
 650                                 cw_bat->charger_mode = 0;
 651                         ret = 1;
 652                 }
 653         }
 654         return ret;
 655 }
 656
 657 static int get_usb_charge_state(struct cw_battery *cw_bat)
 658 {
 659         int charge_time;
 660         int time_from_boot;
 661         struct timespec ts;
 662
 663         int gadget_status = get_gadget_connect_flag();
 664         int usb_status = dwc_vbus_status();
 665
 666         get_monotonic_boottime(&ts);
 667         time_from_boot = ts.tv_sec;
 668
 669         if (cw_bat->charger_init_mode) {
 670
 671                 if (usb_status == 1 || usb_status == 2) {
 672                         cw_bat->charger_init_mode = 0;
 673                 } else if (time_from_boot < 8) {
 674                         usb_status = cw_bat->charger_init_mode;
 675                 } else if (strstr(saved_command_line,"charger")) {
 676                         cw_bat->charger_init_mode = dwc_otg_check_dpdm();
 677                         usb_status = cw_bat->charger_init_mode;
 678                 }
 679         }
 680 #ifdef NO_STANDARD_AC_BIG_CHARGE_MODE
 681         if (cw_bat->usb_online == 1) {
 682
 683                 charge_time = time_from_boot - cw_bat->sleep_time_charge_start - cw_bat->run_time_charge_start;
 684                 if (charge_time > 3) {
 685                         if (gadget_status == 0 && dwc_vbus_status() == 1) {
 686                                 usb_status = 2;
 687                         }
 688                 }
 689         }
 690 #endif
 691         return usb_status;
 692
 693         dev_dbg(&cw_bat->client->dev, "%s usb_status=[%d],cw_bat->charger_mode=[%d],cw_bat->gadget_status=[%d], cw_bat->charger_init_mode = [%d]\n",__func__,usb_status,cw_bat->charger_mode,gadget_status, cw_bat->charger_init_mode);
 694
 695
 696
 697 }
 698
 699 static int rk_usb_update_online(struct cw_battery *cw_bat)
 700 {
 701         int ret = 0;
 702         int usb_status = 0;
 703
 704         if (cw_bat->plat_data->is_usb_charge == 0) {
 705                 cw_bat->usb_online = 0;
 706                 return 0;
 707
 708         }
 709
 710         usb_status = get_usb_charge_state(cw_bat);
 711         if (usb_status == 2) {
 712                 if (cw_bat->charger_mode != AC_CHARGER_MODE) {
 713                         cw_bat->charger_mode = AC_CHARGER_MODE;
 714                         ret = 1;
 715                 }
 716                 if (cw_bat->plat_data->chg_mode_sel_pin != INVALID_GPIO) {
 717                         if (gpio_get_value (cw_bat->plat_data->chg_mode_sel_pin) != cw_bat->plat_data->chg_mode_sel_level)
 718                                 gpio_direction_output(cw_bat->plat_data->chg_mode_sel_pin, (cw_bat->plat_data->chg_mode_sel_level==GPIO_HIGH) ? GPIO_HIGH : GPIO_LOW);
 719                 }
 720
 721                 if (cw_bat->usb_online != 1) {
 722                         cw_bat->usb_online = 1;
 723                         cw_update_time_member_charge_start(cw_bat);
 724                 }
 725
 726         } else if (usb_status == 1) {
 727                 if ((cw_bat->charger_mode != USB_CHARGER_MODE) && (cw_bat->dc_online == 0)) {
 728                         cw_bat->charger_mode = USB_CHARGER_MODE;
 729                         ret = 1;
 730                 }
 731
 732                 if (cw_bat->plat_data->chg_mode_sel_pin != INVALID_GPIO) {
 733                         if (gpio_get_value (cw_bat->plat_data->chg_mode_sel_pin) == cw_bat->plat_data->chg_mode_sel_level)
 734                                 gpio_direction_output(cw_bat->plat_data->chg_mode_sel_pin, (cw_bat->plat_data->chg_mode_sel_level==GPIO_HIGH) ? GPIO_LOW : GPIO_HIGH);
 735                 }
 736                 if (cw_bat->usb_online != 1){
 737                         cw_bat->usb_online = 1;
 738                         cw_update_time_member_charge_start(cw_bat);
 739                 }
 740
 741         } else if (usb_status == 0 && cw_bat->usb_online != 0) {
 742
 743                 if (cw_bat->plat_data->chg_mode_sel_pin != INVALID_GPIO) {
 744                         if (gpio_get_value (cw_bat->plat_data->chg_mode_sel_pin == cw_bat->plat_data->chg_mode_sel_level))
 745                                 gpio_direction_output(cw_bat->plat_data->chg_mode_sel_pin, (cw_bat->plat_data->chg_mode_sel_level==GPIO_HIGH) ? GPIO_LOW : GPIO_HIGH);
 746                 }
 747
 748                 if (cw_bat->dc_online == 0)
 749                         cw_bat->charger_mode = 0;
 750
 751                 cw_update_time_member_charge_start(cw_bat);
 752                 cw_bat->usb_online = 0;
 753                 ret = 1;
 754         }
 755
 756         return ret;
 757 }
 758
 759 static void cw_bat_work(struct work_struct *work)
 760 {
 761         struct delayed_work *delay_work;
 762         struct cw_battery *cw_bat;
 763         int ret;
 764
 765         delay_work = container_of(work, struct delayed_work, work);
 766         cw_bat = container_of(delay_work, struct cw_battery, battery_delay_work);
 767
 768
 769         ret = rk_ac_update_online(cw_bat);
 770         if (ret == 1) {
 771                 power_supply_changed(&cw_bat->rk_ac);
 772         }
 773
 774         if (cw_bat->plat_data->is_usb_charge == 1) {
 775                 ret = rk_usb_update_online(cw_bat);
 776                 if (ret == 1) {
 777                         power_supply_changed(&cw_bat->rk_usb);
 778                         power_supply_changed(&cw_bat->rk_ac);
 779                 }
 780         }
 781
 782
 783         rk_bat_update_status(cw_bat);
 784         rk_bat_update_capacity(cw_bat);
 785         rk_bat_update_vol(cw_bat);
 786         rk_bat_update_time_to_empty(cw_bat);
 787
 788         if (cw_bat->bat_change) {
 789                 power_supply_changed(&cw_bat->rk_bat);
 790                 cw_bat->bat_change = 0;
 791         }
 792
 793         queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(1000));
 794
 795         dev_dbg(&cw_bat->client->dev, "cw_bat->bat_change = %d, cw_bat->time_to_empty = %d, cw_bat->capacity = %d, cw_bat->voltage = %d, cw_bat->dc_online = %d, cw_bat->usb_online = %d\n",\
 796                         cw_bat->bat_change, cw_bat->time_to_empty, cw_bat->capacity, cw_bat->voltage, cw_bat->dc_online, cw_bat->usb_online);
 797 }
 798
 799 static int rk_usb_get_property (struct power_supply *psy,
 800                 enum power_supply_property psp,
 801                 union power_supply_propval *val)
 802 {
 803         int ret = 0;
 804         struct cw_battery *cw_bat;
 805
 806         cw_bat = container_of(psy, struct cw_battery, rk_usb);
 807         switch (psp) {
 808         case POWER_SUPPLY_PROP_ONLINE:
 809                 // val->intval = cw_bat->usb_online;
 810                 val->intval = (cw_bat->charger_mode == USB_CHARGER_MODE);
 811                 break;
 812         default:
 813                 break;
 814         }
 815         return ret;
 816 }
 817
 818 static enum power_supply_property rk_usb_properties[] = {
 819         POWER_SUPPLY_PROP_ONLINE,
 820 };
 821
 822
 823 static int rk_ac_get_property (struct power_supply *psy,
 824                 enum power_supply_property psp,
 825                 union power_supply_propval *val)
 826 {
 827         int ret = 0;
 828         struct cw_battery *cw_bat;
 829
 830         cw_bat = container_of(psy, struct cw_battery, rk_ac);
 831         switch (psp) {
 832         case POWER_SUPPLY_PROP_ONLINE:
 833                 // val->intval = cw_bat->dc_online;
 834                 val->intval = (cw_bat->charger_mode == AC_CHARGER_MODE);
 835                 break;
 836         default:
 837                 break;
 838         }
 839         return ret;
 840 }
 841
 842 static enum power_supply_property rk_ac_properties[] = {
 843         POWER_SUPPLY_PROP_ONLINE,
 844 };
 845
 846 static int rk_battery_get_property(struct power_supply *psy,
 847                 enum power_supply_property psp,
 848                 union power_supply_propval *val)
 849 {
 850         int ret = 0;
 851         struct cw_battery *cw_bat;
 852
 853         cw_bat = container_of(psy, struct cw_battery, rk_bat);
 854         switch (psp) {
 855         case POWER_SUPPLY_PROP_CAPACITY:
 856                 val->intval = cw_bat->capacity;
 857                 break;
 858         case POWER_SUPPLY_PROP_STATUS:
 859                 val->intval = cw_bat->status;
 860                 break;
 861
 862         case POWER_SUPPLY_PROP_HEALTH:
 863                 val->intval= POWER_SUPPLY_HEALTH_GOOD;
 864                 break;
 865         case POWER_SUPPLY_PROP_PRESENT:
 866                 val->intval = cw_bat->voltage <= 0 ? 0 : 1;
 867                 break;
 868
 869         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 870                 val->intval = cw_bat->voltage;
 871                 break;
 872
 873         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
 874                 val->intval = cw_bat->time_to_empty;
 875                 break;
 876
 877         case POWER_SUPPLY_PROP_TECHNOLOGY:
 878                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 879                 break;
 880
 881         default:
 882                 break;
 883         }
 884         return ret;
 885 }
 886
 887 static enum power_supply_property rk_battery_properties[] = {
 888         POWER_SUPPLY_PROP_CAPACITY,
 889         POWER_SUPPLY_PROP_STATUS,
 890         POWER_SUPPLY_PROP_HEALTH,
 891         POWER_SUPPLY_PROP_PRESENT,
 892         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 893         POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
 894         POWER_SUPPLY_PROP_TECHNOLOGY,
 895 };
 896
 897 static int cw_bat_gpio_init(struct cw_battery *cw_bat)
 898 {
 899
 900         int ret;
 901         gpio_free(cw_bat->plat_data->dc_det_pin);
 902         if (cw_bat->plat_data->dc_det_pin != INVALID_GPIO) {
 903                 ret = gpio_request(cw_bat->plat_data->dc_det_pin, NULL);
 904                 if (ret) {
 905                         dev_err(&cw_bat->client->dev, "failed to request dc_det_pin gpio\n");
 906                         goto request_dc_det_pin_fail;
 907                 }
 908
 909                 gpio_pull_updown(cw_bat->plat_data->dc_det_pin, GPIOPullUp);
 910                 ret = gpio_direction_input(cw_bat->plat_data->dc_det_pin);
 911                 if (ret) {
 912                         dev_err(&cw_bat->client->dev, "failed to set dc_det_pin input\n");
 913                         goto request_bat_low_pin_fail;
 914                 }
 915         }
 916         if (cw_bat->plat_data->bat_low_pin != INVALID_GPIO) {
 917                 ret = gpio_request(cw_bat->plat_data->bat_low_pin, NULL);
 918                 if (ret) {
 919                         dev_err(&cw_bat->client->dev, "failed to request bat_low_pin gpio\n");
 920                         goto request_bat_low_pin_fail;
 921                 }
 922
 923                 gpio_pull_updown(cw_bat->plat_data->bat_low_pin, GPIOPullUp);
 924                 ret = gpio_direction_input(cw_bat->plat_data->bat_low_pin);
 925                 if (ret) {
 926                         dev_err(&cw_bat->client->dev, "failed to set bat_low_pin input\n");
 927                         goto request_chg_ok_pin_fail;
 928                 }
 929         }
 930         if (cw_bat->plat_data->chg_ok_pin != INVALID_GPIO) {
 931                 ret = gpio_request(cw_bat->plat_data->chg_ok_pin, NULL);
 932                 if (ret) {
 933                         dev_err(&cw_bat->client->dev, "failed to request chg_ok_pin gpio\n");
 934                         goto request_chg_ok_pin_fail;
 935                 }
 936
 937                 gpio_pull_updown(cw_bat->plat_data->chg_ok_pin, GPIOPullUp);
 938                 ret = gpio_direction_input(cw_bat->plat_data->chg_ok_pin);
 939                 if (ret) {
 940                         dev_err(&cw_bat->client->dev, "failed to set chg_ok_pin input\n");
 941                         gpio_free(cw_bat->plat_data->chg_ok_pin);
 942                         goto request_chg_ok_pin_fail;
 943                 }
 944         }
 945
 946         if ((cw_bat->plat_data->is_usb_charge == 1) && (cw_bat->plat_data->chg_mode_sel_pin!= INVALID_GPIO)) {
 947                 ret = gpio_request(cw_bat->plat_data->chg_mode_sel_pin, NULL);
 948                 if (ret) {
 949                         dev_err(&cw_bat->client->dev, "failed to request chg_mode_sel_pin gpio\n");
 950                         goto request_chg_ok_pin_fail;
 951                 }
 952                 ret = gpio_direction_output(cw_bat->plat_data->chg_mode_sel_pin, (cw_bat->plat_data->chg_mode_sel_level==GPIO_HIGH) ? GPIO_LOW : GPIO_HIGH);
 953                 if (ret) {
 954                         dev_err(&cw_bat->client->dev, "failed to set chg_mode_sel_pin input\n");
 955                         gpio_free(cw_bat->plat_data->chg_mode_sel_pin);
 956                         goto request_chg_ok_pin_fail;
 957                 }
 958         }
 959
 960         return 0;
 961
 962
 963 request_chg_ok_pin_fail:
 964         if (cw_bat->plat_data->bat_low_pin != INVALID_GPIO)
 965                 gpio_free(cw_bat->plat_data->bat_low_pin);
 966
 967 request_bat_low_pin_fail:
 968         if (cw_bat->plat_data->dc_det_pin != INVALID_GPIO)
 969                 gpio_free(cw_bat->plat_data->dc_det_pin);
 970
 971 request_dc_det_pin_fail:
 972         return ret;
 973
 974 }
 975
 976
 977 static void dc_detect_do_wakeup(struct work_struct *work)
 978 {
 979         int ret;
 980         int irq;
 981         unsigned int type;
 982
 983         struct delayed_work *delay_work;
 984         struct cw_battery *cw_bat;
 985
 986         delay_work = container_of(work, struct delayed_work, work);
 987         cw_bat = container_of(delay_work, struct cw_battery, dc_wakeup_work);
 988
 989         rk28_send_wakeup_key();
 990
 991         /* this assume if usb insert or extract dc_det pin is change */
 992 #if 0
 993         if(cw_bat->charger_init_mode)
 994                 cw_bat->charger_init_mode=0;
 995 #endif
 996
 997         irq = gpio_to_irq(cw_bat->plat_data->dc_det_pin);
 998         type = gpio_get_value(cw_bat->plat_data->dc_det_pin) ? IRQ_TYPE_EDGE_FALLING : IRQ_TYPE_EDGE_RISING;
 999         ret = irq_set_irq_type(irq, type);
1000         if (ret < 0) {
1001                 pr_err("%s: irq_set_irq_type(%d, %d) failed\n", __func__, irq, type);
1002         }
1003         enable_irq(irq);
1004 }
1005
1006 static irqreturn_t dc_detect_irq_handler(int irq, void *dev_id)
1007 {
1008         struct cw_battery *cw_bat = dev_id;
1009         disable_irq_nosync(irq); // for irq debounce
1010         queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->dc_wakeup_work, msecs_to_jiffies(20));
1011         return IRQ_HANDLED;
1012 }
1013
1014 #ifdef BAT_LOW_INTERRUPT
1015
1016 #define WAKE_LOCK_TIMEOUT       (10 * HZ)
1017 static struct wake_lock bat_low_wakelock;
1018
1019 static void bat_low_detect_do_wakeup(struct work_struct *work)
1020 {
1021         struct delayed_work *delay_work;
1022         struct cw_battery *cw_bat;
1023
1024         delay_work = container_of(work, struct delayed_work, work);
1025         cw_bat = container_of(delay_work, struct cw_battery, bat_low_wakeup_work);
1026         dev_info(&cw_bat->client->dev, "func: %s-------\n", __func__);
1027         cw_get_alt(cw_bat);
1028         //enable_irq(irq);
1029 }
1030
1031 static irqreturn_t bat_low_detect_irq_handler(int irq, void *dev_id)
1032 {
1033         struct cw_battery *cw_bat = dev_id;
1034         // disable_irq_nosync(irq); // for irq debounce
1035         wake_lock_timeout(&bat_low_wakelock, WAKE_LOCK_TIMEOUT);
1036         queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->bat_low_wakeup_work, msecs_to_jiffies(20));
1037         return IRQ_HANDLED;
1038 }
1039 #endif
1040
1041 static int cw_bat_probe(struct i2c_client *client, const struct i2c_device_id *id)
1042 {
1043         struct cw_battery *cw_bat;
1044         int ret;
1045         int irq;
1046         int irq_flags;
1047         int loop = 0;
1048
1049         cw_bat = devm_kzalloc(&client->dev, sizeof(*cw_bat), GFP_KERNEL);
1050         if (!cw_bat) {
1051                 dev_err(&cw_bat->client->dev, "fail to allocate memory\n");
1052                 return -ENOMEM;
1053         }
1054
1055         i2c_set_clientdata(client, cw_bat);
1056         cw_bat->plat_data = client->dev.platform_data;
1057         ret = cw_bat_gpio_init(cw_bat);
1058         if (ret) {
1059                 dev_err(&cw_bat->client->dev, "cw_bat_gpio_init error\n");
1060                 return ret;
1061         }
1062
1063         cw_bat->client = client;
1064
1065         ret = cw_init(cw_bat);
1066         while ((loop++ < 200) && (ret != 0)) {
1067                 ret = cw_init(cw_bat);
1068         }
1069
1070         if (ret)
1071                 return ret;
1072
1073         cw_bat->rk_bat.name = "rk-bat";
1074         cw_bat->rk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
1075         cw_bat->rk_bat.properties = rk_battery_properties;
1076         cw_bat->rk_bat.num_properties = ARRAY_SIZE(rk_battery_properties);
1077         cw_bat->rk_bat.get_property = rk_battery_get_property;
1078         ret = power_supply_register(&client->dev, &cw_bat->rk_bat);
1079         if(ret < 0) {
1080                 dev_err(&cw_bat->client->dev, "power supply register rk_bat error\n");
1081                 goto rk_bat_register_fail;
1082         }
1083
1084         cw_bat->rk_ac.name = "rk-ac";
1085         cw_bat->rk_ac.type = POWER_SUPPLY_TYPE_MAINS;
1086         cw_bat->rk_ac.properties = rk_ac_properties;
1087         cw_bat->rk_ac.num_properties = ARRAY_SIZE(rk_ac_properties);
1088         cw_bat->rk_ac.get_property = rk_ac_get_property;
1089         ret = power_supply_register(&client->dev, &cw_bat->rk_ac);
1090         if(ret < 0) {
1091                 dev_err(&cw_bat->client->dev, "power supply register rk_ac error\n");
1092                 goto rk_ac_register_fail;
1093         }
1094
1095         cw_bat->rk_usb.name = "rk-usb";
1096         cw_bat->rk_usb.type = POWER_SUPPLY_TYPE_USB;
1097         cw_bat->rk_usb.properties = rk_usb_properties;
1098         cw_bat->rk_usb.num_properties = ARRAY_SIZE(rk_usb_properties);
1099         cw_bat->rk_usb.get_property = rk_usb_get_property;
1100         ret = power_supply_register(&client->dev, &cw_bat->rk_usb);
1101         if(ret < 0) {
1102                 dev_err(&cw_bat->client->dev, "power supply register rk_ac error\n");
1103                 goto rk_usb_register_fail;
1104         }
1105
1106         cw_bat->charger_init_mode = dwc_otg_check_dpdm();
1107
1108         cw_bat->dc_online = 0;
1109         cw_bat->usb_online = 0;
1110         cw_bat->charger_mode = 0;
1111         cw_bat->capacity = 2;
1112         cw_bat->voltage = 0;
1113         cw_bat->status = 0;
1114         cw_bat->time_to_empty = 0;
1115         cw_bat->bat_change = 0;
1116
1117         cw_update_time_member_capacity_change(cw_bat);
1118         cw_update_time_member_charge_start(cw_bat);
1119
1120         cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery");
1121         INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work);
1122         INIT_DELAYED_WORK(&cw_bat->dc_wakeup_work, dc_detect_do_wakeup);
1123         queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(10));
1124
1125         if (cw_bat->plat_data->dc_det_pin != INVALID_GPIO) {
1126                 irq = gpio_to_irq(cw_bat->plat_data->dc_det_pin);
1127                 irq_flags = gpio_get_value(cw_bat->plat_data->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1128                 ret = request_irq(irq, dc_detect_irq_handler, irq_flags, "usb_detect", cw_bat);
1129                 if (ret < 0) {
1130                         pr_err("%s: request_irq(%d) failed\n", __func__, irq);
1131                 }
1132                 enable_irq_wake(irq);
1133         }
1134
1135 #ifdef BAT_LOW_INTERRUPT
1136         INIT_DELAYED_WORK(&cw_bat->bat_low_wakeup_work, bat_low_detect_do_wakeup);
1137         wake_lock_init(&bat_low_wakelock, WAKE_LOCK_SUSPEND, "bat_low_detect");
1138         if (cw_bat->plat_data->bat_low_pin != INVALID_GPIO) {
1139                 irq = gpio_to_irq(cw_bat->plat_data->bat_low_pin);
1140                 ret = request_irq(irq, bat_low_detect_irq_handler, IRQF_TRIGGER_RISING, "bat_low_detect", cw_bat);
1141                 if (ret < 0) {
1142                         gpio_free(cw_bat->plat_data->bat_low_pin);
1143                 }
1144                 enable_irq_wake(irq);
1145         }
1146 #endif
1147
1148         dev_info(&cw_bat->client->dev, "cw2015/cw2013 driver v1.2 probe sucess\n");
1149         return 0;
1150
1151 rk_usb_register_fail:
1152         power_supply_unregister(&cw_bat->rk_bat);
1153 rk_ac_register_fail:
1154         power_supply_unregister(&cw_bat->rk_ac);
1155 rk_bat_register_fail:
1156         dev_info(&cw_bat->client->dev, "cw2015/cw2013 driver v1.2 probe error!!!!\n");
1157         return ret;
1158 }
1159
1160 static int cw_bat_remove(struct i2c_client *client)
1161 {
1162         struct cw_battery *cw_bat = i2c_get_clientdata(client);
1163         dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1164         cancel_delayed_work(&cw_bat->battery_delay_work);
1165         return 0;
1166 }
1167
1168 #ifdef CONFIG_PM
1169 static int cw_bat_suspend(struct device *dev)
1170 {
1171         struct i2c_client *client = to_i2c_client(dev);
1172         struct cw_battery *cw_bat = i2c_get_clientdata(client);
1173         dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1174         cancel_delayed_work(&cw_bat->battery_delay_work);
1175         return 0;
1176 }
1177
1178 static int cw_bat_resume(struct device *dev)
1179 {
1180         struct i2c_client *client = to_i2c_client(dev);
1181         struct cw_battery *cw_bat = i2c_get_clientdata(client);
1182         dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1183         queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(100));
1184         return 0;
1185 }
1186
1187 static const struct i2c_device_id cw_id[] = {
1188         { "cw201x", 0 },
1189 };
1190 MODULE_DEVICE_TABLE(i2c, cw_id);
1191
1192 static const struct dev_pm_ops cw_bat_pm_ops = {
1193         .suspend  = cw_bat_suspend,
1194         .resume   = cw_bat_resume,
1195 };
1196 #endif
1197
1198 static struct i2c_driver cw_bat_driver = {
1199         .driver         = {
1200                 .name   = "cw201x",
1201 #ifdef CONFIG_PM
1202                 .pm     = &cw_bat_pm_ops,
1203 #endif
1204         },
1205
1206         .probe          = cw_bat_probe,
1207         .remove         = cw_bat_remove,
1208         .id_table       = cw_id,
1209 };
1210
1211 static int __init cw_bat_init(void)
1212 {
1213         return i2c_add_driver(&cw_bat_driver);
1214 }
1215
1216 static void __exit cw_bat_exit(void)
1217 {
1218         i2c_del_driver(&cw_bat_driver);
1219 }
1220
1221 fs_initcall(cw_bat_init);
1222 module_exit(cw_bat_exit);
1223
1224 MODULE_AUTHOR("xhc<xhc@rock-chips.com>");
1225 MODULE_DESCRIPTION("cw2015/cw2013 battery driver");
1226 MODULE_LICENSE("GPL");
1227