drivers/power/cw2015_battery.c

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