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