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 || cw_capacity > 100) {
 342                 dev_err(&cw_bat->client->dev,
 343                         "get cw_capacity error; cw_capacity = %d\n",
 344                         cw_capacity);
 345                 reset_loop++;
 346
 347                 if (reset_loop > 5) {
 348                         reset_val = MODE_SLEEP;
 349                         ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
 350                         if (ret < 0)
 351                                 return ret;
 352                         reset_val = MODE_NORMAL;
 353                         msleep(10);
 354                         ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
 355                         if (ret < 0)
 356                                 return ret;
 357                         dev_info(&cw_bat->client->dev,
 358                                  "report battery capacity error");
 359                         ret = cw_update_config_info(cw_bat);
 360                         if (ret)
 361                                 return ret;
 362                         reset_loop = 0;
 363                 }
 364
 365                 return cw_capacity;
 366         } else {
 367                 reset_loop = 0;
 368         }
 369
 370         ktime_get_ts(&ts);
 371         new_run_time = ts.tv_sec;
 372
 373         get_monotonic_boottime(&ts);
 374         new_sleep_time = ts.tv_sec - new_run_time;
 375
 376         /* modify battery level swing */
 377         if ((cw_bat->charger_mode > 0 &&
 378              cw_capacity <= (cw_bat->capacity - 1) &&
 379              cw_capacity > (cw_bat->capacity - 9)) ||
 380             (cw_bat->charger_mode == 0 &&
 381              cw_capacity == (cw_bat->capacity + 1))) {
 382                 if (!(cw_capacity == 0 && cw_bat->capacity <= 2))
 383                         cw_capacity = cw_bat->capacity;
 384         }
 385
 386         /* avoid no charge full */
 387         if (cw_bat->charger_mode > 0 &&
 388             cw_capacity >= 95 &&
 389             cw_capacity <= cw_bat->capacity) {
 390                 capacity_or_aconline_time =
 391                     (cw_bat->sleep_time_capacity_change >
 392                      cw_bat->sleep_time_charge_start) ? cw_bat->
 393                     sleep_time_capacity_change : cw_bat->
 394                     sleep_time_charge_start;
 395                 capacity_or_aconline_time +=
 396                     (cw_bat->run_time_capacity_change >
 397                      cw_bat->run_time_charge_start) ? cw_bat->
 398                     run_time_capacity_change : cw_bat->run_time_charge_start;
 399                 allow_change =
 400                     (new_sleep_time + new_run_time -
 401                      capacity_or_aconline_time) / BATTERY_UP_MAX_CHANGE;
 402                 if (allow_change > 0) {
 403                         allow_capacity = cw_bat->capacity + allow_change;
 404                         cw_capacity =
 405                             (allow_capacity <= 100) ? allow_capacity : 100;
 406                         jump_flag = 1;
 407                 } else if (cw_capacity <= cw_bat->capacity) {
 408                         cw_capacity = cw_bat->capacity;
 409                 }
 410         }
 411         /* avoid battery level jump to CW_BAT */
 412         else if (cw_bat->charger_mode == 0 &&
 413                  cw_capacity <= cw_bat->capacity &&
 414                  cw_capacity >= 90 && jump_flag == 1) {
 415                 capacity_or_aconline_time =
 416                     (cw_bat->sleep_time_capacity_change >
 417                      cw_bat->sleep_time_charge_start) ? cw_bat->
 418                     sleep_time_capacity_change : cw_bat->
 419                     sleep_time_charge_start;
 420                 capacity_or_aconline_time +=
 421                     (cw_bat->run_time_capacity_change >
 422                      cw_bat->run_time_charge_start) ? cw_bat->
 423                     run_time_capacity_change : cw_bat->run_time_charge_start;
 424                 allow_change =
 425                     (new_sleep_time + new_run_time -
 426                      capacity_or_aconline_time) / BATTERY_DOWN_CHANGE;
 427                 if (allow_change > 0) {
 428                         allow_capacity = cw_bat->capacity - allow_change;
 429                         if (cw_capacity >= allow_capacity) {
 430                                 jump_flag = 0;
 431                         } else {
 432                                 cw_capacity =
 433                                     (allow_capacity <=
 434                                      100) ? allow_capacity : 100;
 435                         }
 436                 } else if (cw_capacity <= cw_bat->capacity) {
 437                         cw_capacity = cw_bat->capacity;
 438                 }
 439         }
 440
 441         /* avoid battery level jump to 0% at a moment from more than 2% */
 442         if (cw_capacity == 0 && cw_bat->capacity > 1) {
 443                 allow_change =
 444                     ((new_run_time -
 445                       cw_bat->run_time_capacity_change) /
 446                      BATTERY_DOWN_MIN_CHANGE_RUN);
 447                 allow_change +=
 448                     ((new_sleep_time -
 449                       cw_bat->sleep_time_capacity_change) /
 450                      BATTERY_DOWN_MIN_CHANGE_SLEEP);
 451
 452                 allow_capacity = cw_bat->capacity - allow_change;
 453                 cw_capacity =
 454                     (allow_capacity >=
 455                      cw_capacity) ? allow_capacity : cw_capacity;
 456                 dev_info(&cw_bat->client->dev, "report GGIC POR happened");
 457                 reset_val = MODE_SLEEP;
 458                 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
 459                 if (ret < 0)
 460                         return ret;
 461                 reset_val = MODE_NORMAL;
 462                 msleep(10);
 463                 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
 464                 if (ret < 0)
 465                         return ret;
 466                 dev_info(&cw_bat->client->dev, "report battery capacity error");
 467                 ret = cw_update_config_info(cw_bat);
 468                 if (ret)
 469                         return ret;
 470                 dev_info(&cw_bat->client->dev,
 471                          "report battery capacity jump 0 ");
 472         }
 473 #if 1
 474         if (cw_bat->charger_mode > 0 && cw_capacity == 0) {
 475                 charge_time =
 476                     new_sleep_time + new_run_time -
 477                     cw_bat->sleep_time_charge_start -
 478                     cw_bat->run_time_charge_start;
 479                 if (charge_time > BATTERY_DOWN_MAX_CHANGE_RUN_AC_ONLINE &&
 480                     if_quickstart == 0) {
 481                         reset_val = MODE_SLEEP;
 482                         ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
 483                         if (ret < 0)
 484                                 return ret;
 485                         reset_val = MODE_NORMAL;
 486                         msleep(10);
 487                         ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
 488                         if (ret < 0)
 489                                 return ret;
 490                         dev_info(&cw_bat->client->dev,
 491                                  "report battery capacity error");
 492                         ret = cw_update_config_info(cw_bat);
 493                         if (ret)
 494                                 return ret;
 495                         dev_info(&cw_bat->client->dev,
 496                                  "report battery capacity still 0 if in changing");
 497                         if_quickstart = 1;
 498                 }
 499         } else if (if_quickstart == 1 && cw_bat->charger_mode == 0) {
 500                 if_quickstart = 0;
 501         }
 502 #endif
 503
 504 #ifdef SYSTEM_SHUTDOWN_VOLTAGE
 505         if (cw_bat->charger_mode == 0 && cw_capacity <= 10 &&
 506             cw_bat->voltage <= SYSTEM_SHUTDOWN_VOLTAGE) {
 507                 if (if_quickstart == 10) {
 508                         cw_quickstart(cw_bat);
 509                         if_quickstart = 12;
 510                         cw_capacity = 0;
 511                 } else if (if_quickstart <= 10) {
 512                         if_quickstart = if_quickstart + 2;
 513                 }
 514                 dev_info(&cw_bat->client->dev,
 515                          "voltage is less than shutdown voltage\n");
 516         } else if ((cw_bat->charger_mode > 0) && (if_quickstart <= 12)) {
 517                 if_quickstart = 0;
 518         }
 519 #endif
 520         return cw_capacity;
 521 }
 522
 523 static int cw_get_vol(struct cw_battery *cw_bat)
 524 {
 525         int ret;
 526         u8 reg_val[2];
 527         u16 value16, value16_1, value16_2, value16_3;
 528         int voltage;
 529
 530         ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
 531         if (ret < 0)
 532                 return ret;
 533         value16 = (reg_val[0] << 8) + reg_val[1];
 534
 535         ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
 536         if (ret < 0)
 537                 return ret;
 538         value16_1 = (reg_val[0] << 8) + reg_val[1];
 539
 540         ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
 541         if (ret < 0)
 542                 return ret;
 543         value16_2 = (reg_val[0] << 8) + reg_val[1];
 544
 545         if (value16 > value16_1) {
 546                 value16_3 = value16;
 547                 value16 = value16_1;
 548                 value16_1 = value16_3;
 549         }
 550
 551         if (value16_1 > value16_2) {
 552                 value16_3 = value16_1;
 553                 value16_1 = value16_2;
 554                 value16_2 = value16_3;
 555         }
 556
 557         if (value16 > value16_1) {
 558                 value16_3 = value16;
 559                 value16 = value16_1;
 560                 value16_1 = value16_3;
 561         }
 562
 563         voltage = value16_1 * 305;
 564
 565         dev_dbg(&cw_bat->client->dev, "the cw201x voltage=%d,reg_val=%x %x\n",
 566                 voltage, reg_val[0], reg_val[1]);
 567         return voltage;
 568 }
 569
 570 #ifdef BAT_LOW_INTERRUPT
 571 static int cw_get_alt(struct cw_battery *cw_bat)
 572 {
 573         int ret = 0;
 574         u8 reg_val;
 575         u8 value8 = 0;
 576         int alrt;
 577
 578         ret = cw_read(cw_bat->client, REG_RRT_ALERT, &reg_val);
 579         if (ret < 0)
 580                 return ret;
 581         value8 = reg_val;
 582         alrt = value8 >> 7;
 583
 584         value8 = value8 & 0x7f;
 585         reg_val = value8;
 586         ret = cw_write(cw_bat->client, REG_RRT_ALERT, &reg_val);
 587         if (ret < 0) {
 588                 dev_err(&cw_bat->client->dev, "Error clear ALRT\n");
 589                 return ret;
 590         }
 591
 592         return alrt;
 593 }
 594 #endif
 595
 596 static int cw_get_time_to_empty(struct cw_battery *cw_bat)
 597 {
 598         int ret;
 599         u8 reg_val;
 600         u16 value16;
 601
 602         ret = cw_read(cw_bat->client, REG_RRT_ALERT, &reg_val);
 603         if (ret < 0)
 604                 return ret;
 605
 606         value16 = reg_val;
 607
 608         ret = cw_read(cw_bat->client, REG_RRT_ALERT + 1, &reg_val);
 609         if (ret < 0)
 610                 return ret;
 611
 612         value16 = ((value16 << 8) + reg_val) & 0x1fff;
 613         return value16;
 614 }
 615
 616 static void rk_bat_update_capacity(struct cw_battery *cw_bat)
 617 {
 618         int cw_capacity;
 619
 620         cw_capacity = cw_get_capacity(cw_bat);
 621         if ((cw_capacity >= 0) && (cw_capacity <= 100) &&
 622             (cw_bat->capacity != cw_capacity)) {
 623                 cw_bat->capacity = cw_capacity;
 624                 cw_bat->bat_change = 1;
 625                 cw_update_time_member_capacity_change(cw_bat);
 626
 627                 if (cw_bat->capacity == 0)
 628                         dev_info(&cw_bat->client->dev,
 629                                  "report battery capacity 0 and will shutdown if no changing");
 630         }
 631 }
 632
 633 static void rk_bat_update_vol(struct cw_battery *cw_bat)
 634 {
 635         int ret;
 636
 637         ret = cw_get_vol(cw_bat);
 638         if ((ret >= 0) && (cw_bat->voltage != ret))
 639                 cw_bat->voltage = ret;
 640 }
 641
 642 static void rk_bat_update_status(struct cw_battery *cw_bat)
 643 {
 644         int status;
 645
 646         if (cw_bat->charger_mode > 0) {
 647                 if (cw_bat->capacity >= 100)
 648                         status = POWER_SUPPLY_STATUS_FULL;
 649                 else
 650                         status = POWER_SUPPLY_STATUS_CHARGING;
 651         } else {
 652                 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 653         }
 654
 655         if (cw_bat->status != status) {
 656                 cw_bat->status = status;
 657                 cw_bat->bat_change = 1;
 658         }
 659 }
 660
 661 static void rk_bat_update_time_to_empty(struct cw_battery *cw_bat)
 662 {
 663         int ret;
 664
 665         ret = cw_get_time_to_empty(cw_bat);
 666         if ((ret >= 0) && (cw_bat->time_to_empty != ret))
 667                 cw_bat->time_to_empty = ret;
 668 }
 669
 670 static int rk_ac_update_online(struct cw_battery *cw_bat)
 671 {
 672         int ret = 0;
 673
 674         if (!gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
 675                 cw_bat->dc_online = 0;
 676                 pr_info("%s dc charger without dc_det_pin\n", __func__);
 677                 return 0;
 678         }
 679
 680         if (gpio_get_value(cw_bat->plat_data.dc_det_pin) ==
 681             cw_bat->plat_data.dc_det_level) {
 682                 if (cw_bat->dc_online != 1) {
 683                         cw_update_time_member_charge_start(cw_bat);
 684                         cw_bat->dc_online = 1;
 685                         if (cw_bat->charger_mode != AC_CHARGER_MODE)
 686                                 cw_bat->charger_mode = AC_CHARGER_MODE;
 687
 688                         ret = 1;
 689                 }
 690         } else {
 691                 if (cw_bat->dc_online != 0) {
 692                         cw_update_time_member_charge_start(cw_bat);
 693                         cw_bat->dc_online = 0;
 694                         if (cw_bat->usb_online == 0)
 695                                 cw_bat->charger_mode = 0;
 696                         ret = 1;
 697                 }
 698         }
 699         return ret;
 700 }
 701
 702 static int get_usb_charge_state(struct cw_battery *cw_bat)
 703 {
 704         int charge_time;
 705         int time_from_boot;
 706         struct timespec ts;
 707
 708         int gadget_status = get_gadget_connect_flag();
 709         int usb_status = dwc_vbus_status();
 710
 711         get_monotonic_boottime(&ts);
 712         time_from_boot = ts.tv_sec;
 713
 714         if (cw_bat->charger_init_mode) {
 715                 if (usb_status == 1 || usb_status == 2) {
 716                         cw_bat->charger_init_mode = 0;
 717                 } else if (time_from_boot < 8) {
 718                         usb_status = cw_bat->charger_init_mode;
 719                 } else if (strstr(saved_command_line, "charger")) {
 720                         cw_bat->charger_init_mode = dwc_otg_check_dpdm();
 721                         usb_status = cw_bat->charger_init_mode;
 722                 }
 723         }
 724 #ifdef NO_STANDARD_AC_BIG_CHARGE_MODE
 725         if (cw_bat->usb_online == 1) {
 726                 charge_time =
 727                     time_from_boot - cw_bat->sleep_time_charge_start -
 728                     cw_bat->run_time_charge_start;
 729                 if (charge_time > 3) {
 730                         if (gadget_status == 0 && dwc_vbus_status() == 1)
 731                                 usb_status = 2;
 732                 }
 733         }
 734 #endif
 735
 736         dev_dbg(&cw_bat->client->dev,
 737                 "%s usb_status=[%d],cw_bat->charger_mode=[%d],cw_bat->gadget_status=[%d], cw_bat->charger_init_mode = [%d]\n",
 738                 __func__, usb_status, cw_bat->charger_mode, gadget_status,
 739                 cw_bat->charger_init_mode);
 740
 741         return usb_status;
 742 }
 743
 744 static int rk_usb_update_online(struct cw_battery *cw_bat)
 745 {
 746         int gpio;
 747         int value;
 748         int ret = 0;
 749         int usb_status = 0;
 750
 751         gpio = cw_bat->plat_data.chg_mode_sel_pin;
 752         value = cw_bat->plat_data.chg_mode_sel_level;
 753         usb_status = get_usb_charge_state(cw_bat);
 754         if (usb_status == 2) {
 755                 if (cw_bat->charger_mode != AC_CHARGER_MODE) {
 756                         cw_bat->charger_mode = AC_CHARGER_MODE;
 757                         ret = 1;
 758                 }
 759                 if (gpio_is_valid(gpio)) {
 760                         if (gpio_get_value(gpio) != value)
 761                                 gpio_direction_output(gpio, value);
 762                 }
 763
 764                 if (cw_bat->usb_online != 1) {
 765                         cw_bat->usb_online = 1;
 766                         cw_update_time_member_charge_start(cw_bat);
 767                 }
 768
 769         } else if (usb_status == 1) {
 770                 if (cw_bat->charger_mode != USB_CHARGER_MODE &&
 771                     cw_bat->dc_online == 0) {
 772                         cw_bat->charger_mode = USB_CHARGER_MODE;
 773                         ret = 1;
 774                 }
 775
 776                 if (gpio_is_valid(gpio)) {
 777                         if (gpio_get_value(gpio) == value)
 778                                 gpio_direction_output(gpio, !value);
 779                 }
 780                 if (cw_bat->usb_online != 1) {
 781                         cw_bat->usb_online = 1;
 782                         cw_update_time_member_charge_start(cw_bat);
 783                 }
 784
 785         } else if (usb_status == 0 && cw_bat->usb_online != 0) {
 786                 if (gpio_is_valid(gpio)) {
 787                         if (gpio_get_value(gpio) == value)
 788                                 gpio_direction_output(gpio, !value);
 789                 }
 790
 791                 if (cw_bat->dc_online == 0)
 792                         cw_bat->charger_mode = 0;
 793
 794                 cw_update_time_member_charge_start(cw_bat);
 795                 cw_bat->usb_online = 0;
 796                 ret = 1;
 797         }
 798
 799         return ret;
 800 }
 801
 802 static void cw_bat_work(struct work_struct *work)
 803 {
 804         struct delayed_work *delay_work;
 805         struct cw_battery *cw_bat;
 806         int ret;
 807
 808         delay_work = container_of(work, struct delayed_work, work);
 809         cw_bat =
 810             container_of(delay_work, struct cw_battery, battery_delay_work);
 811
 812         if (cw_bat->plat_data.is_dc_charge == 1) {
 813                 ret = rk_ac_update_online(cw_bat);
 814                 if (ret == 1)
 815                         power_supply_changed(&cw_bat->rk_ac);
 816         }
 817
 818         if (cw_bat->plat_data.is_usb_charge == 1) {
 819                 ret = rk_usb_update_online(cw_bat);
 820                 if (ret == 1) {
 821                         power_supply_changed(&cw_bat->rk_usb);
 822                         power_supply_changed(&cw_bat->rk_ac);
 823                 }
 824         }
 825
 826         rk_bat_update_status(cw_bat);
 827         rk_bat_update_capacity(cw_bat);
 828         rk_bat_update_vol(cw_bat);
 829         rk_bat_update_time_to_empty(cw_bat);
 830
 831         if (cw_bat->bat_change) {
 832                 power_supply_changed(&cw_bat->rk_bat);
 833                 cw_bat->bat_change = 0;
 834         }
 835
 836         queue_delayed_work(cw_bat->battery_workqueue,
 837                            &cw_bat->battery_delay_work, msecs_to_jiffies(1000));
 838
 839         dev_dbg(&cw_bat->client->dev,
 840                 "cw_bat->bat_change = %d, cw_bat->time_to_empty = %d, cw_bat->capacity = %d\n",
 841                 cw_bat->bat_change, cw_bat->time_to_empty, cw_bat->capacity);
 842
 843         dev_dbg(&cw_bat->client->dev,
 844                 "cw_bat->voltage = %d, cw_bat->dc_online = %d, cw_bat->usb_online = %d\n",
 845                 cw_bat->voltage, cw_bat->dc_online, cw_bat->usb_online);
 846 }
 847
 848 static int rk_usb_get_property(struct power_supply *psy,
 849                                enum power_supply_property psp,
 850                                union power_supply_propval *val)
 851 {
 852         int ret = 0;
 853         struct cw_battery *cw_bat;
 854
 855         cw_bat = container_of(psy, struct cw_battery, rk_usb);
 856         switch (psp) {
 857         case POWER_SUPPLY_PROP_ONLINE:
 858                 val->intval = (cw_bat->charger_mode == USB_CHARGER_MODE);
 859                 break;
 860         default:
 861                 break;
 862         }
 863         return ret;
 864 }
 865
 866 static enum power_supply_property rk_usb_properties[] = {
 867         POWER_SUPPLY_PROP_ONLINE,
 868 };
 869
 870 static int rk_ac_get_property(struct power_supply *psy,
 871                               enum power_supply_property psp,
 872                               union power_supply_propval *val)
 873 {
 874         int ret = 0;
 875         struct cw_battery *cw_bat;
 876
 877         cw_bat = container_of(psy, struct cw_battery, rk_ac);
 878         switch (psp) {
 879         case POWER_SUPPLY_PROP_ONLINE:
 880                 val->intval = (cw_bat->charger_mode == AC_CHARGER_MODE);
 881                 break;
 882         default:
 883                 break;
 884         }
 885         return ret;
 886 }
 887
 888 static enum power_supply_property rk_ac_properties[] = {
 889         POWER_SUPPLY_PROP_ONLINE,
 890 };
 891
 892 static int rk_battery_get_property(struct power_supply *psy,
 893                                    enum power_supply_property psp,
 894                                    union power_supply_propval *val)
 895 {
 896         int ret = 0;
 897         struct cw_battery *cw_bat;
 898
 899         cw_bat = container_of(psy, struct cw_battery, rk_bat);
 900         switch (psp) {
 901         case POWER_SUPPLY_PROP_CAPACITY:
 902                 val->intval = cw_bat->capacity;
 903                 break;
 904         case POWER_SUPPLY_PROP_STATUS:
 905                 val->intval = cw_bat->status;
 906                 break;
 907
 908         case POWER_SUPPLY_PROP_HEALTH:
 909                 val->intval = POWER_SUPPLY_HEALTH_GOOD;
 910                 break;
 911         case POWER_SUPPLY_PROP_PRESENT:
 912                 val->intval = cw_bat->voltage <= 0 ? 0 : 1;
 913                 break;
 914
 915         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 916                 val->intval = cw_bat->voltage;
 917                 break;
 918
 919         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
 920                 val->intval = cw_bat->time_to_empty;
 921                 break;
 922
 923         case POWER_SUPPLY_PROP_TECHNOLOGY:
 924                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 925                 break;
 926
 927         default:
 928                 break;
 929         }
 930         return ret;
 931 }
 932
 933 static enum power_supply_property rk_battery_properties[] = {
 934         POWER_SUPPLY_PROP_CAPACITY,
 935         POWER_SUPPLY_PROP_STATUS,
 936         POWER_SUPPLY_PROP_HEALTH,
 937         POWER_SUPPLY_PROP_PRESENT,
 938         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 939         POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
 940         POWER_SUPPLY_PROP_TECHNOLOGY,
 941 };
 942
 943 static int cw_bat_gpio_init(struct cw_battery *cw_bat)
 944 {
 945         int ret;
 946
 947         if (gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
 948                 ret = gpio_request(cw_bat->plat_data.dc_det_pin, NULL);
 949                 if (ret) {
 950                         dev_err(&cw_bat->client->dev,
 951                                 "failed to request dc_det_pin gpio\n");
 952                         goto request_dc_det_pin_fail;
 953                 }
 954                 ret = gpio_direction_input(cw_bat->plat_data.dc_det_pin);
 955                 if (ret) {
 956                         dev_err(&cw_bat->client->dev,
 957                                 "failed to set dc_det_pin input\n");
 958                         goto request_bat_low_pin_fail;
 959                 }
 960         }
 961         if (gpio_is_valid(cw_bat->plat_data.bat_low_pin)) {
 962                 ret = gpio_request(cw_bat->plat_data.bat_low_pin, NULL);
 963                 if (ret) {
 964                         dev_err(&cw_bat->client->dev,
 965                                 "failed to request bat_low_pin gpio\n");
 966                         goto request_bat_low_pin_fail;
 967                 }
 968
 969                 ret = gpio_direction_input(cw_bat->plat_data.bat_low_pin);
 970                 if (ret) {
 971                         dev_err(&cw_bat->client->dev,
 972                                 "failed to set bat_low_pin input\n");
 973                         goto request_bat_low_pin_fail;
 974                 }
 975         }
 976         if (gpio_is_valid(cw_bat->plat_data.chg_ok_pin)) {
 977                 ret = gpio_request(cw_bat->plat_data.chg_ok_pin, NULL);
 978                 if (ret) {
 979                         dev_err(&cw_bat->client->dev,
 980                                 "failed to request chg_ok_pin gpio\n");
 981                         goto request_chg_ok_pin_fail;
 982                 }
 983
 984                 ret = gpio_direction_input(cw_bat->plat_data.chg_ok_pin);
 985                 if (ret) {
 986                         dev_err(&cw_bat->client->dev,
 987                                 "failed to set chg_ok_pin input\n");
 988                         gpio_free(cw_bat->plat_data.chg_ok_pin);
 989                         goto request_chg_ok_pin_fail;
 990                 }
 991         }
 992
 993         if ((gpio_is_valid(cw_bat->plat_data.chg_mode_sel_pin))) {
 994                 ret = gpio_request(cw_bat->plat_data.chg_mode_sel_pin, NULL);
 995                 if (ret) {
 996                         dev_err(&cw_bat->client->dev,
 997                                 "failed to request chg_mode_sel_pin gpio\n");
 998                         goto request_chg_mode_sel_pin_fail;
 999                 }
1000                 ret =
1001                     gpio_direction_output(cw_bat->plat_data.chg_mode_sel_pin,
1002                                           (cw_bat->plat_data.
1003                                            chg_mode_sel_level ==
1004                                            CW2015_GPIO_LOW) ? CW2015_GPIO_HIGH :
1005                                           CW2015_GPIO_LOW);
1006                 if (ret) {
1007                         dev_err(&cw_bat->client->dev,
1008                                 "failed to set chg_mode_sel_pin output\n");
1009                         gpio_free(cw_bat->plat_data.chg_mode_sel_pin);
1010                         goto request_chg_mode_sel_pin_fail;
1011                 }
1012         }
1013
1014         return 0;
1015
1016 request_chg_mode_sel_pin_fail:
1017         gpio_free(cw_bat->plat_data.chg_mode_sel_pin);
1018 request_chg_ok_pin_fail:
1019         if (gpio_is_valid(cw_bat->plat_data.bat_low_pin))
1020                 gpio_free(cw_bat->plat_data.bat_low_pin);
1021 request_bat_low_pin_fail:
1022         if (gpio_is_valid(cw_bat->plat_data.dc_det_pin))
1023                 gpio_free(cw_bat->plat_data.dc_det_pin);
1024 request_dc_det_pin_fail:
1025
1026         return ret;
1027 }
1028
1029 static void dc_detect_do_wakeup(struct work_struct *work)
1030 {
1031         int ret;
1032         int irq;
1033         unsigned int type;
1034
1035         struct delayed_work *delay_work;
1036         struct cw_battery *cw_bat;
1037
1038         delay_work = container_of(work, struct delayed_work, work);
1039         cw_bat = container_of(delay_work, struct cw_battery, dc_wakeup_work);
1040
1041         rk_send_wakeup_key();
1042
1043         irq = gpio_to_irq(cw_bat->plat_data.dc_det_pin);
1044         type =
1045             gpio_get_value(cw_bat->plat_data.
1046                            dc_det_pin) ? IRQ_TYPE_EDGE_FALLING :
1047             IRQ_TYPE_EDGE_RISING;
1048         ret = irq_set_irq_type(irq, type);
1049         if (ret < 0) {
1050                 pr_err("%s: irq_set_irq_type(%d, %d) failed\n", __func__, irq,
1051                        type);
1052         }
1053         enable_irq(irq);
1054 }
1055
1056 static irqreturn_t dc_detect_irq_handler(int irq, void *dev_id)
1057 {
1058         struct cw_battery *cw_bat = dev_id;
1059
1060         /* for irq debounce */
1061         disable_irq_nosync(irq);
1062         queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->dc_wakeup_work,
1063                            msecs_to_jiffies(20));
1064         return IRQ_HANDLED;
1065 }
1066
1067 #ifdef BAT_LOW_INTERRUPT
1068
1069 #define WAKE_LOCK_TIMEOUT       (10 * HZ)
1070
1071 static void bat_low_detect_do_wakeup(struct work_struct *work)
1072 {
1073         struct delayed_work *delay_work;
1074         struct cw_battery *cw_bat;
1075
1076         delay_work = container_of(work, struct delayed_work, work);
1077         cw_bat =
1078             container_of(delay_work, struct cw_battery, bat_low_wakeup_work);
1079         dev_info(&cw_bat->client->dev, "func: %s-------\n", __func__);
1080         cw_get_alt(cw_bat);
1081 }
1082
1083 static irqreturn_t bat_low_detect_irq_handler(int irq, void *dev_id)
1084 {
1085         struct cw_battery *cw_bat = dev_id;
1086
1087         queue_delayed_work(cw_bat->battery_workqueue,
1088                            &cw_bat->bat_low_wakeup_work, msecs_to_jiffies(20));
1089         return IRQ_HANDLED;
1090 }
1091 #endif
1092
1093 #ifdef CONFIG_OF
1094 static int cw2015_parse_dt(struct device *dev,
1095                            struct cw_bat_platform_data *data)
1096 {
1097         struct device_node *node = dev->of_node;
1098         enum of_gpio_flags flags;
1099         struct property *prop;
1100         int length;
1101         u32 value;
1102         int ret;
1103
1104         if (!node)
1105                 return -ENODEV;
1106
1107         memset(data, 0, sizeof(*data));
1108
1109         /* determine the number of config info */
1110         prop = of_find_property(node, "bat_config_info", &length);
1111         if (!prop)
1112                 return -EINVAL;
1113
1114         length /= sizeof(u32);
1115
1116         if (length > 0) {
1117                 size_t size = sizeof(*data->cw_bat_config_info) * length;
1118
1119                 data->cw_bat_config_info = devm_kzalloc(dev, size, GFP_KERNEL);
1120                 if (!data->cw_bat_config_info)
1121                         return -ENOMEM;
1122
1123                 ret = of_property_read_u32_array(node, "bat_config_info",
1124                                                  data->cw_bat_config_info,
1125                                                  length);
1126                 if (ret < 0)
1127                         return ret;
1128         }
1129
1130         data->dc_det_pin = of_get_named_gpio_flags(node, "dc_det_gpio", 0,
1131                                                    &flags);
1132         if (data->dc_det_pin == -EPROBE_DEFER)
1133                 pr_info("%s  dc_det_gpio error\n", __func__);
1134
1135         if (gpio_is_valid(data->dc_det_pin))
1136                 data->dc_det_level =
1137                     (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1138                     CW2015_GPIO_HIGH;
1139
1140         data->bat_low_pin = of_get_named_gpio_flags(node, "bat_low_gpio", 0,
1141                                                     &flags);
1142         if (data->bat_low_pin == -EPROBE_DEFER)
1143                 pr_info("%s  bat_low_gpio error\n", __func__);
1144
1145         if (gpio_is_valid(data->bat_low_pin))
1146                 data->bat_low_level =
1147                     (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1148                     CW2015_GPIO_HIGH;
1149
1150         data->chg_ok_pin = of_get_named_gpio_flags(node, "chg_ok_gpio", 0,
1151                                                    &flags);
1152         if (data->chg_ok_pin == -EPROBE_DEFER)
1153                 pr_info("%s  chg_ok_gpio error\n", __func__);
1154
1155         if (gpio_is_valid(data->chg_ok_pin))
1156                 data->chg_ok_level =
1157                     (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1158                     CW2015_GPIO_HIGH;
1159
1160         data->chg_mode_sel_pin =
1161             of_get_named_gpio_flags(node, "chg_mode_sel_gpio", 0, &flags);
1162         if (data->chg_mode_sel_pin == -EPROBE_DEFER)
1163                 pr_info("%s  chg_mod_sel_gpio error\n", __func__);
1164
1165         if (gpio_is_valid(data->chg_mode_sel_pin))
1166                 data->chg_mode_sel_level =
1167                     (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1168                     CW2015_GPIO_HIGH;
1169
1170         ret = of_property_read_u32(node, "is_dc_charge", &value);
1171         if (ret < 0) {
1172                 pr_info("%s:hardware unsupport dc charge\n", __func__);
1173                 value = 0;
1174         }
1175         data->is_dc_charge = value;
1176
1177         ret = of_property_read_u32(node, "is_usb_charge", &value);
1178         if (ret < 0) {
1179                 pr_info("%s:hardware unsupport usb charge\n", __func__);
1180                 value = 0;
1181         }
1182         data->is_usb_charge = value;
1183
1184         pr_info("cw201x:support %s %s charger\n",
1185                 data->is_dc_charge ? "DC" : "",
1186                 data->is_usb_charge ? "USB" : "");
1187
1188         return 0;
1189 }
1190 #else
1191 static int cw2015_parse_dt(struct device *dev,
1192                            struct cw_bat_platform_data *data)
1193 {
1194         return -ENODEV;
1195 }
1196 #endif
1197
1198 static int cw_bat_probe(struct i2c_client *client,
1199                         const struct i2c_device_id *id)
1200 {
1201         struct cw_battery *cw_bat;
1202         struct cw_bat_platform_data *plat_data = client->dev.platform_data;
1203         int ret;
1204         int irq;
1205         int irq_flags;
1206         int level = 0;
1207
1208         cw_bat = devm_kzalloc(&client->dev, sizeof(*cw_bat), GFP_KERNEL);
1209         if (!cw_bat) {
1210                 dev_err(&cw_bat->client->dev,
1211                         "fail to allocate memory for cw2015\n");
1212                 return -ENOMEM;
1213         }
1214         i2c_set_clientdata(client, cw_bat);
1215
1216         if (!plat_data) {
1217                 ret = cw2015_parse_dt(&client->dev, &(cw_bat->plat_data));
1218                 if (ret < 0) {
1219                         dev_err(&client->dev,
1220                                 "failed to find cw2015 platform data\n");
1221                         goto pdate_fail;
1222                 }
1223         }
1224
1225         cw_bat->client = client;
1226         ret = cw_bat_gpio_init(cw_bat);
1227         if (ret) {
1228                 dev_err(&cw_bat->client->dev, "cw_bat_gpio_init error\n");
1229                 return ret;
1230         }
1231
1232         ret = cw_init(cw_bat);
1233         if (ret) {
1234                 pr_err("%s cw_init error\n", __func__);
1235                 return ret;
1236         }
1237
1238         cw_bat->rk_bat.name = "rk-bat";
1239         cw_bat->rk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
1240         cw_bat->rk_bat.properties = rk_battery_properties;
1241         cw_bat->rk_bat.num_properties = ARRAY_SIZE(rk_battery_properties);
1242         cw_bat->rk_bat.get_property = rk_battery_get_property;
1243         ret = power_supply_register(&client->dev, &cw_bat->rk_bat);
1244         if (ret < 0) {
1245                 dev_err(&cw_bat->client->dev,
1246                         "power supply register rk_bat error\n");
1247                 goto rk_bat_register_fail;
1248         }
1249
1250         cw_bat->rk_ac.name = "rk-ac";
1251         cw_bat->rk_ac.type = POWER_SUPPLY_TYPE_MAINS;
1252         cw_bat->rk_ac.properties = rk_ac_properties;
1253         cw_bat->rk_ac.num_properties = ARRAY_SIZE(rk_ac_properties);
1254         cw_bat->rk_ac.get_property = rk_ac_get_property;
1255         ret = power_supply_register(&client->dev, &cw_bat->rk_ac);
1256         if (ret < 0) {
1257                 dev_err(&cw_bat->client->dev,
1258                         "power supply register rk_ac error\n");
1259                 goto rk_ac_register_fail;
1260         }
1261
1262         if (cw_bat->plat_data.is_usb_charge == 1) {
1263                 cw_bat->rk_usb.name = "rk-usb";
1264                 cw_bat->rk_usb.type = POWER_SUPPLY_TYPE_USB;
1265                 cw_bat->rk_usb.properties = rk_usb_properties;
1266                 cw_bat->rk_usb.num_properties = ARRAY_SIZE(rk_usb_properties);
1267                 cw_bat->rk_usb.get_property = rk_usb_get_property;
1268                 ret = power_supply_register(&client->dev, &cw_bat->rk_usb);
1269                 if (ret < 0) {
1270                         dev_err(&cw_bat->client->dev,
1271                                 "power supply register rk_usb error\n");
1272                         goto rk_usb_register_fail;
1273                 }
1274                 cw_bat->charger_init_mode = dwc_otg_check_dpdm();
1275                 pr_info("%s cw2015 support charger by usb. usb_mode=%d\n",
1276                         __func__, cw_bat->charger_init_mode);
1277         }
1278
1279         cw_bat->dc_online = 0;
1280         cw_bat->usb_online = 0;
1281         cw_bat->charger_mode = 0;
1282         cw_bat->capacity = 1;
1283         cw_bat->voltage = 0;
1284         cw_bat->status = 0;
1285         cw_bat->time_to_empty = 0;
1286         cw_bat->bat_change = 0;
1287
1288         cw_update_time_member_capacity_change(cw_bat);
1289         cw_update_time_member_charge_start(cw_bat);
1290
1291         cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery");
1292         INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work);
1293         INIT_DELAYED_WORK(&cw_bat->dc_wakeup_work, dc_detect_do_wakeup);
1294         queue_delayed_work(cw_bat->battery_workqueue,
1295                            &cw_bat->battery_delay_work, msecs_to_jiffies(10));
1296
1297         if (gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
1298                 irq = gpio_to_irq(cw_bat->plat_data.dc_det_pin);
1299                 level = gpio_get_value(cw_bat->plat_data.dc_det_pin);
1300                 if (level == cw_bat->plat_data.dc_det_level) {
1301                         pr_info("%s booting up with dc plug\n", __func__);
1302                         cw_bat->status = POWER_SUPPLY_STATUS_CHARGING;
1303                 }
1304                 irq_flags = level ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1305                 ret =
1306                     request_irq(irq, dc_detect_irq_handler, irq_flags,
1307                                 "dc_detect", cw_bat);
1308                 if (ret < 0)
1309                         pr_err("%s: request_irq(%d) failed\n", __func__, irq);
1310                 enable_irq_wake(irq);
1311         }
1312
1313         if (gpio_is_valid(cw_bat->plat_data.bat_low_pin)) {
1314                 INIT_DELAYED_WORK(&cw_bat->bat_low_wakeup_work,
1315                                   bat_low_detect_do_wakeup);
1316                 level = gpio_get_value(cw_bat->plat_data.bat_low_pin);
1317                 if (level == cw_bat->plat_data.dc_det_level) {
1318                         pr_info("%s booting up with lower power\n", __func__);
1319                         cw_bat->capacity = 1;
1320                 }
1321                 irq = gpio_to_irq(cw_bat->plat_data.bat_low_pin);
1322                 ret =
1323                     request_irq(irq, bat_low_detect_irq_handler,
1324                                 IRQF_TRIGGER_RISING, "bat_low_detect", cw_bat);
1325                 if (ret < 0)
1326                         gpio_free(cw_bat->plat_data.bat_low_pin);
1327
1328                 enable_irq_wake(irq);
1329         }
1330
1331         dev_info(&cw_bat->client->dev,
1332                  "cw2015/cw2013 driver v1.2 probe sucess\n");
1333         return 0;
1334
1335 rk_usb_register_fail:
1336         power_supply_unregister(&cw_bat->rk_usb);
1337 rk_ac_register_fail:
1338         power_supply_unregister(&cw_bat->rk_ac);
1339 rk_bat_register_fail:
1340         power_supply_unregister(&cw_bat->rk_bat);
1341 pdate_fail:
1342         dev_info(&cw_bat->client->dev,
1343                  "cw2015/cw2013 driver v1.2 probe error!!!!\n");
1344         return ret;
1345 }
1346
1347 static int cw_bat_remove(struct i2c_client *client)
1348 {
1349         struct cw_battery *cw_bat = i2c_get_clientdata(client);
1350
1351         dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1352         cancel_delayed_work(&cw_bat->battery_delay_work);
1353         return 0;
1354 }
1355
1356 #ifdef CONFIG_PM
1357 static int cw_bat_suspend(struct device *dev)
1358 {
1359         struct i2c_client *client = to_i2c_client(dev);
1360         struct cw_battery *cw_bat = i2c_get_clientdata(client);
1361
1362         dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1363         cancel_delayed_work(&cw_bat->battery_delay_work);
1364         return 0;
1365 }
1366
1367 static int cw_bat_resume(struct device *dev)
1368 {
1369         struct i2c_client *client = to_i2c_client(dev);
1370         struct cw_battery *cw_bat = i2c_get_clientdata(client);
1371
1372         dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1373         queue_delayed_work(cw_bat->battery_workqueue,
1374                            &cw_bat->battery_delay_work, msecs_to_jiffies(100));
1375         return 0;
1376 }
1377
1378 static const struct i2c_device_id cw_id[] = {
1379         {"cw201x", 0},
1380         {}
1381 };
1382 MODULE_DEVICE_TABLE(i2c, cw_id);
1383
1384 static const struct dev_pm_ops cw_bat_pm_ops = {
1385         .suspend = cw_bat_suspend,
1386         .resume = cw_bat_resume,
1387 };
1388 #endif
1389
1390 static struct i2c_driver cw_bat_driver = {
1391         .driver = {
1392                    .name = "cw201x",
1393 #ifdef CONFIG_PM
1394                    .pm = &cw_bat_pm_ops,
1395 #endif
1396                    },
1397
1398         .probe = cw_bat_probe,
1399         .remove = cw_bat_remove,
1400         .id_table = cw_id,
1401 };
1402
1403 static int __init cw_bat_init(void)
1404 {
1405         return i2c_add_driver(&cw_bat_driver);
1406 }
1407
1408 static void __exit cw_bat_exit(void)
1409 {
1410         i2c_del_driver(&cw_bat_driver);
1411 }
1412
1413 fs_initcall(cw_bat_init);
1414 module_exit(cw_bat_exit);
1415
1416 MODULE_AUTHOR("xhc<xhc@rock-chips.com>");
1417 MODULE_DESCRIPTION("cw2015/cw2013 battery driver");
1418 MODULE_LICENSE("GPL");