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