drivers/power/cw2015_battery.c

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