drivers/power/twl6030_bci_battery.c

   1 /*
   2  * linux/drivers/power/twl6030_bci_battery.c
   3  *
   4  * OMAP4:TWL6030 battery driver for Linux
   5  *
   6  * Copyright (C) 2008-2009 Texas Instruments, Inc.
   7  * Author: Texas Instruments, Inc.
   8  *
   9  * This package is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  *
  13  * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  15  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  16  */
  17
  18 #include <linux/init.h>
  19 #include <linux/module.h>
  20 #include <linux/device.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/delay.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/slab.h>
  25 #include <linux/i2c/twl.h>
  26 #include <linux/power_supply.h>
  27 #include <linux/i2c/twl6030-gpadc.h>
  28 #include <linux/i2c/bq2415x.h>
  29 #include <linux/wakelock.h>
  30 #include <linux/usb/otg.h>
  31
  32 #include <mach/gpio.h>
  33
  34 #define CONTROLLER_INT_MASK     0x00
  35 #define CONTROLLER_CTRL1        0x01
  36 #define CONTROLLER_WDG          0x02
  37 #define CONTROLLER_STAT1        0x03
  38 #define CHARGERUSB_INT_STATUS   0x04
  39 #define CHARGERUSB_INT_MASK     0x05
  40 #define CHARGERUSB_STATUS_INT1  0x06
  41 #define CHARGERUSB_STATUS_INT2  0x07
  42 #define CHARGERUSB_CTRL1        0x08
  43 #define CHARGERUSB_CTRL2        0x09
  44 #define CHARGERUSB_CTRL3        0x0A
  45 #define CHARGERUSB_STAT1        0x0B
  46 #define CHARGERUSB_VOREG        0x0C
  47 #define CHARGERUSB_VICHRG       0x0D
  48 #define CHARGERUSB_CINLIMIT     0x0E
  49 #define CHARGERUSB_CTRLLIMIT1   0x0F
  50 #define CHARGERUSB_CTRLLIMIT2   0x10
  51 #define ANTICOLLAPSE_CTRL1      0x11
  52 #define ANTICOLLAPSE_CTRL2      0x12
  53
  54 /* TWL6032 registers 0xDA to 0xDE - TWL6032_MODULE_CHARGER */
  55 #define CONTROLLER_CTRL2        0x00
  56 #define CONTROLLER_VSEL_COMP    0x01
  57 #define CHARGERUSB_VSYSREG      0x02
  58 #define CHARGERUSB_VICHRG_PC    0x03
  59 #define LINEAR_CHRG_STS         0x04
  60
  61 /* TWL6032 Charger Mode Register */
  62 #define CHARGER_MODE_REG        0xD4
  63 #define CHARGER_MODE_POWERPATH  BIT(3)
  64 #define CHARGER_MODE_AUTOCHARGE BIT(6)
  65
  66 #define LINEAR_CHRG_STS_CRYSTL_OSC_OK   0x40
  67 #define LINEAR_CHRG_STS_END_OF_CHARGE   0x20
  68 #define LINEAR_CHRG_STS_VBATOV          0x10
  69 #define LINEAR_CHRG_STS_VSYSOV          0x08
  70 #define LINEAR_CHRG_STS_DPPM_STS        0x04
  71 #define LINEAR_CHRG_STS_CV_STS          0x02
  72 #define LINEAR_CHRG_STS_CC_STS          0x01
  73
  74 #define FG_REG_00       0x00
  75 #define FG_REG_01       0x01
  76 #define FG_REG_02       0x02
  77 #define FG_REG_03       0x03
  78 #define FG_REG_04       0x04
  79 #define FG_REG_05       0x05
  80 #define FG_REG_06       0x06
  81 #define FG_REG_07       0x07
  82 #define FG_REG_08       0x08
  83 #define FG_REG_09       0x09
  84 #define FG_REG_10       0x0A
  85 #define FG_REG_11       0x0B
  86
  87 /* CONTROLLER_INT_MASK */
  88 #define MVAC_FAULT              (1 << 7)
  89 #define MAC_EOC                 (1 << 6)
  90 #define LINCH_GATED             (1 << 5)
  91 #define MBAT_REMOVED            (1 << 4)
  92 #define MFAULT_WDG              (1 << 3)
  93 #define MBAT_TEMP               (1 << 2)
  94 #define MVBUS_DET               (1 << 1)
  95 #define MVAC_DET                (1 << 0)
  96
  97 /* CONTROLLER_CTRL1 */
  98 #define CONTROLLER_CTRL1_EN_LINCH       (1 << 5)
  99 #define CONTROLLER_CTRL1_EN_CHARGER     (1 << 4)
 100 #define CONTROLLER_CTRL1_SEL_CHARGER    (1 << 3)
 101
 102 /* CONTROLLER_STAT1 */
 103 #define CONTROLLER_STAT1_EXTCHRG_STATZ  (1 << 7)
 104 #define CONTROLLER_STAT1_LINCH_GATED    (1 << 6)
 105 #define CONTROLLER_STAT1_CHRG_DET_N     (1 << 5)
 106 #define CONTROLLER_STAT1_FAULT_WDG      (1 << 4)
 107 #define CONTROLLER_STAT1_VAC_DET        (1 << 3)
 108 #define VAC_DET (1 << 3)
 109 #define CONTROLLER_STAT1_VBUS_DET       (1 << 2)
 110 #define VBUS_DET        (1 << 2)
 111 #define CONTROLLER_STAT1_BAT_REMOVED    (1 << 1)
 112 #define CONTROLLER_STAT1_BAT_TEMP_OVRANGE (1 << 0)
 113
 114 /* CHARGERUSB_INT_STATUS */
 115 #define EN_LINCH                (1 << 4)
 116 #define CURRENT_TERM_INT        (1 << 3)
 117 #define CHARGERUSB_STAT         (1 << 2)
 118 #define CHARGERUSB_THMREG       (1 << 1)
 119 #define CHARGERUSB_FAULT        (1 << 0)
 120
 121 /* CHARGERUSB_INT_MASK */
 122 #define MASK_MCURRENT_TERM              (1 << 3)
 123 #define MASK_MCHARGERUSB_STAT           (1 << 2)
 124 #define MASK_MCHARGERUSB_THMREG         (1 << 1)
 125 #define MASK_MCHARGERUSB_FAULT          (1 << 0)
 126
 127 /* CHARGERUSB_STATUS_INT1 */
 128 #define CHARGERUSB_STATUS_INT1_TMREG    (1 << 7)
 129 #define CHARGERUSB_STATUS_INT1_NO_BAT   (1 << 6)
 130 #define CHARGERUSB_STATUS_INT1_BST_OCP  (1 << 5)
 131 #define CHARGERUSB_STATUS_INT1_TH_SHUTD (1 << 4)
 132 #define CHARGERUSB_STATUS_INT1_BAT_OVP  (1 << 3)
 133 #define CHARGERUSB_STATUS_INT1_POOR_SRC (1 << 2)
 134 #define CHARGERUSB_STATUS_INT1_SLP_MODE (1 << 1)
 135 #define CHARGERUSB_STATUS_INT1_VBUS_OVP (1 << 0)
 136
 137 /* CHARGERUSB_STATUS_INT2 */
 138 #define ICCLOOP         (1 << 3)
 139 #define CURRENT_TERM    (1 << 2)
 140 #define CHARGE_DONE     (1 << 1)
 141 #define ANTICOLLAPSE    (1 << 0)
 142
 143 /* CHARGERUSB_CTRL1 */
 144 #define SUSPEND_BOOT    (1 << 7)
 145 #define OPA_MODE        (1 << 6)
 146 #define HZ_MODE         (1 << 5)
 147 #define TERM            (1 << 4)
 148
 149 /* CHARGERUSB_CTRL2 */
 150 #define CHARGERUSB_CTRL2_VITERM_50      (0 << 5)
 151 #define CHARGERUSB_CTRL2_VITERM_100     (1 << 5)
 152 #define CHARGERUSB_CTRL2_VITERM_150     (2 << 5)
 153 #define CHARGERUSB_CTRL2_VITERM_400     (7 << 5)
 154
 155 /* CHARGERUSB_CTRL3 */
 156 #define VBUSCHRG_LDO_OVRD       (1 << 7)
 157 #define CHARGE_ONCE             (1 << 6)
 158 #define BST_HW_PR_DIS           (1 << 5)
 159 #define AUTOSUPPLY              (1 << 3)
 160 #define BUCK_HSILIM             (1 << 0)
 161
 162 /* CHARGERUSB_VOREG */
 163 #define CHARGERUSB_VOREG_3P52           0x01
 164 #define CHARGERUSB_VOREG_4P0            0x19
 165 #define CHARGERUSB_VOREG_4P2            0x23
 166 #define CHARGERUSB_VOREG_4P76           0x3F
 167
 168 /* CHARGERUSB_VICHRG */
 169 #define CHARGERUSB_VICHRG_300           0x0
 170 #define CHARGERUSB_VICHRG_500           0x4
 171 #define CHARGERUSB_VICHRG_1500          0xE
 172
 173 /* CHARGERUSB_CINLIMIT */
 174 #define CHARGERUSB_CIN_LIMIT_100        0x1
 175 #define CHARGERUSB_CIN_LIMIT_300        0x5
 176 #define CHARGERUSB_CIN_LIMIT_500        0x9
 177 #define CHARGERUSB_CIN_LIMIT_NONE       0xF
 178
 179 /* CHARGERUSB_CTRLLIMIT1 */
 180 #define VOREGL_4P16                     0x21
 181 #define VOREGL_4P56                     0x35
 182
 183 /* CHARGERUSB_CTRLLIMIT2 */
 184 #define CHARGERUSB_CTRLLIMIT2_1500      0x0E
 185 #define         LOCK_LIMIT              (1 << 4)
 186
 187 /* ANTICOLLAPSE_CTRL2 */
 188 #define BUCK_VTH_SHIFT                  5
 189
 190 /* FG_REG_00 */
 191 #define CC_ACTIVE_MODE_SHIFT    6
 192 #define CC_AUTOCLEAR            (1 << 2)
 193 #define CC_CAL_EN               (1 << 1)
 194 #define CC_PAUSE                (1 << 0)
 195
 196 #define REG_TOGGLE1             0x90
 197 #define FGDITHS                 (1 << 7)
 198 #define FGDITHR                 (1 << 6)
 199 #define FGS                     (1 << 5)
 200 #define FGR                     (1 << 4)
 201
 202 /* TWL6030_GPADC_CTRL */
 203 #define GPADC_CTRL_TEMP1_EN     (1 << 0)    /* input ch 1 */
 204 #define GPADC_CTRL_TEMP2_EN     (1 << 1)    /* input ch 4 */
 205 #define GPADC_CTRL_SCALER_EN    (1 << 2)    /* input ch 2 */
 206 #define GPADC_CTRL_SCALER_DIV4  (1 << 3)
 207 #define GPADC_CTRL_SCALER_EN_CH11       (1 << 4)    /* input ch 11 */
 208 #define GPADC_CTRL_TEMP1_EN_MONITOR     (1 << 5)
 209 #define GPADC_CTRL_TEMP2_EN_MONITOR     (1 << 6)
 210 #define GPADC_CTRL_ISOURCE_EN           (1 << 7)
 211
 212 #define GPADC_ISOURCE_22uA              22
 213 #define GPADC_ISOURCE_7uA               7
 214
 215 /* TWL6030/6032 BATTERY VOLTAGE GPADC CHANNELS */
 216
 217 #define TWL6030_GPADC_VBAT_CHNL 0x07
 218 #define TWL6032_GPADC_VBAT_CHNL 0x12
 219
 220 /* TWL6030_GPADC_CTRL2 */
 221 #define GPADC_CTRL2_CH18_SCALER_EN      BIT(2)
 222
 223 #define ENABLE_ISOURCE          0x80
 224
 225 #define REG_MISC1               0xE4
 226 #define VAC_MEAS                0x04
 227 #define VBAT_MEAS               0x02
 228 #define BB_MEAS                 0x01
 229
 230 #define REG_USB_VBUS_CTRL_SET   0x04
 231 #define VBUS_MEAS               0x01
 232 #define REG_USB_ID_CTRL_SET     0x06
 233 #define ID_MEAS                 0x01
 234
 235 #define BBSPOR_CFG              0xE6
 236 #define BB_CHG_EN               (1 << 3)
 237
 238 #define STS_HW_CONDITIONS       0x21
 239 #define STS_USB_ID              (1 << 2)        /* Level status of USB ID */
 240
 241 #define BATTERY_RESISTOR        10000
 242 #define SIMULATOR_RESISTOR      5000
 243 #define BATTERY_DETECT_THRESHOLD        ((BATTERY_RESISTOR + SIMULATOR_RESISTOR) / 2)   //battery voltage threshold divided by 22uA
 244 #define CHARGING_CAPACITY_UPDATE_PERIOD (1000 * 60 * 1)
 245
 246
 247
 248 /************************************************************/
 249 #define TIMER_MS_COUNTS     1000
 250 #define  NUM_DISCHARGE_MIN_SAMPLE   30
 251 #define NUM_CHARGE_MIN_SAMPLE   30
 252 /**************************************************************/
 253
 254 /* To get VBUS input limit from twl6030_usb */
 255 #if CONFIG_TWL6030_USB
 256 extern unsigned int twl6030_get_usb_max_power(struct otg_transceiver *x);
 257 #else
 258 static inline unsigned int twl6030_get_usb_max_power(struct otg_transceiver *x)
 259 {
 260         return 0;
 261 };
 262 #endif
 263
 264 /* Ptr to thermistor table */
 265 static const unsigned int fuelgauge_rate[4] = {1, 4, 16, 64};
 266 static struct wake_lock chrg_lock;
 267
 268
 269 struct twl6030_bci_device_info {
 270         struct device           *dev;
 271
 272         int                     voltage_mV;
 273         int                     bk_voltage_mV;
 274         int                     current_uA;
 275         int                     current_avg_uA;
 276         int                     temp_C;
 277         int                     charge_status;
 278         int                     vac_priority;
 279         int                     bat_health;
 280         int                     charger_source;
 281
 282         int                     fuelgauge_mode;
 283         int                     timer_n2;
 284         int                     timer_n1;
 285         s32                     charge_n1;
 286         s32                     charge_n2;
 287         s16                     cc_offset;
 288         u8                      usb_online;
 289         u8                      ac_online;
 290         u8                      stat1;
 291         u8                      linear_stat;
 292         u8                      status_int1;
 293         u8                      status_int2;
 294
 295         u8                      gpadc_vbat_chnl;
 296         u8                      watchdog_duration;
 297         u16                     current_avg_interval;
 298         u16                     monitoring_interval;
 299         unsigned int            min_vbus;
 300
 301         struct                  twl4030_bci_platform_data *platform_data;
 302
 303         unsigned int            charger_incurrentmA;
 304         unsigned int            charger_outcurrentmA;
 305         unsigned long           usb_max_power;
 306         unsigned long           event;
 307
 308         unsigned int            capacity;
 309         unsigned int            capacity_debounce_count;
 310         unsigned long           ac_next_refresh;
 311         unsigned int            prev_capacity;
 312         unsigned int            wakelock_enabled;
 313
 314         struct power_supply     bat;
 315         struct power_supply     usb;
 316         struct power_supply     ac;
 317         struct power_supply     bk_bat;
 318
 319         struct otg_transceiver  *otg;
 320         struct notifier_block   nb;
 321         struct work_struct      usb_work;
 322
 323         struct workqueue_struct *freezable_work;
 324
 325         struct delayed_work     twl6030_bci_monitor_work;
 326         struct delayed_work     twl6030_current_avg_work;
 327
 328         unsigned long           features;
 329
 330         int                     use_hw_charger;
 331         int                     use_power_path;
 332
 333         /* max scale current based on sense resitor */
 334         int                     current_max_scale;
 335         struct delayed_work work;
 336         unsigned int interval;
 337
 338         int     gBatCapacityDisChargeCnt;
 339         int           capacitytmp;
 340         int           usb_status;
 341         int           usb_old_satus;
 342         int     gBatCapacityChargeCnt;
 343 };
 344
 345 static BLOCKING_NOTIFIER_HEAD(notifier_list);
 346 extern u32 wakeup_timer_seconds;
 347
 348 static void twl6030_config_min_vbus_reg(struct twl6030_bci_device_info *di,
 349                                                 unsigned int value)
 350 {
 351         u8 rd_reg = 0;
 352         int ret;
 353
 354         /* not required on TWL6032 */
 355         if (di->features & TWL6032_SUBCLASS)
 356                 return;
 357
 358         if (value > 4760 || value < 4200) {
 359                 dev_err(di->dev, "invalid min vbus\n");
 360                 return;
 361         }
 362
 363         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &rd_reg,
 364                                         ANTICOLLAPSE_CTRL2);
 365         if (ret)
 366                 goto err;
 367         rd_reg = rd_reg & 0x1F;
 368         rd_reg = rd_reg | (((value - 4200)/80) << BUCK_VTH_SHIFT);
 369         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, rd_reg,
 370                                         ANTICOLLAPSE_CTRL2);
 371
 372         if (!ret)
 373                 return;
 374 err:
 375         pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 376 }
 377
 378 static void twl6030_config_iterm_reg(struct twl6030_bci_device_info *di,
 379                                                 unsigned int term_currentmA)
 380 {
 381         int ret;
 382
 383         if ((term_currentmA > 400) || (term_currentmA < 50)) {
 384                 dev_err(di->dev, "invalid termination current\n");
 385                 return;
 386         }
 387
 388         term_currentmA = ((term_currentmA - 50)/50) << 5;
 389         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, term_currentmA,
 390                                                 CHARGERUSB_CTRL2);
 391         if (ret)
 392                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 393 }
 394
 395 static unsigned int twl6030_get_iterm_reg(struct twl6030_bci_device_info *di)
 396 {
 397         int ret;
 398         unsigned int currentmA;
 399         u8 val = 0;
 400
 401         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val, CHARGERUSB_CTRL2);
 402         if (ret) {
 403                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 404                 currentmA = 0;
 405         } else
 406                 currentmA = 50 + (val >> 5) * 50;
 407
 408         return currentmA;
 409 }
 410
 411 static void twl6030_config_voreg_reg(struct twl6030_bci_device_info *di,
 412                                                         unsigned int voltagemV)
 413 {
 414         int ret;
 415
 416         if ((voltagemV < 3500) || (voltagemV > 4760)) {
 417                 dev_err(di->dev, "invalid charger_voltagemV\n");
 418                 return;
 419         }
 420
 421         voltagemV = (voltagemV - 3500) / 20;
 422         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, voltagemV,
 423                                                 CHARGERUSB_VOREG);
 424         if (ret)
 425                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 426 }
 427
 428 static unsigned int twl6030_get_voreg_reg(struct twl6030_bci_device_info *di)
 429 {
 430         int ret;
 431         unsigned int voltagemV;
 432         u8 val = 0;
 433
 434         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val, CHARGERUSB_VOREG);
 435         if (ret) {
 436                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 437                 voltagemV = 0;
 438         } else
 439                 voltagemV = 3500 + (val * 20);
 440
 441         return voltagemV;
 442 }
 443
 444 static void twl6030_config_vichrg_reg(struct twl6030_bci_device_info *di,
 445                                                         unsigned int currentmA)
 446 {
 447         int ret;
 448
 449         if ((currentmA >= 300) && (currentmA <= 450))
 450                 currentmA = (currentmA - 300) / 50;
 451         else if ((currentmA >= 500) && (currentmA <= 1500))
 452                 currentmA = (currentmA - 500) / 100 + 4;
 453         else {
 454                 dev_err(di->dev, "invalid charger_currentmA\n");
 455                 return;
 456         }
 457
 458         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, currentmA,
 459                                                 CHARGERUSB_VICHRG);
 460         if (ret)
 461                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 462 }
 463
 464 static void twl6030_config_cinlimit_reg(struct twl6030_bci_device_info *di,
 465                                                         unsigned int currentmA)
 466 {
 467         int ret;
 468
 469         if ((currentmA >= 50) && (currentmA <= 750))
 470                 currentmA = (currentmA - 50) / 50;
 471         else if ((currentmA > 750) && (currentmA <= 1500) &&
 472                         (di->features & TWL6032_SUBCLASS)) {
 473                         currentmA = ((currentmA % 100) ? 0x30 : 0x20) +
 474                                                 ((currentmA - 100) / 100);
 475         } else if (currentmA < 50) {
 476                 dev_err(di->dev, "invalid input current limit\n");
 477                 return;
 478         } else {
 479                 /* This is no current limit */
 480                 currentmA = 0x0F;
 481         }
 482
 483         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, currentmA,
 484                                         CHARGERUSB_CINLIMIT);
 485         if (ret)
 486                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 487 }
 488
 489 static void twl6030_config_limit1_reg(struct twl6030_bci_device_info *di,
 490                                                         unsigned int voltagemV)
 491 {
 492         int ret;
 493
 494         if ((voltagemV < 3500) || (voltagemV > 4760)) {
 495                 dev_err(di->dev, "invalid max_charger_voltagemV\n");
 496                 return;
 497         }
 498
 499         voltagemV = (voltagemV - 3500) / 20;
 500         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, voltagemV,
 501                                                 CHARGERUSB_CTRLLIMIT1);
 502         if (ret)
 503                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 504 }
 505
 506 static unsigned int twl6030_get_limit1_reg(struct twl6030_bci_device_info *di)
 507 {
 508         int ret;
 509         unsigned int voltagemV;
 510         u8 val = 0;
 511
 512         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val,
 513                                 CHARGERUSB_CTRLLIMIT1);
 514         if (ret) {
 515                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 516                 voltagemV = 0;
 517         } else
 518                 voltagemV = 3500 + (val * 20);
 519
 520         return voltagemV;
 521 }
 522
 523 static void twl6030_config_limit2_reg(struct twl6030_bci_device_info *di,
 524                                                         unsigned int currentmA)
 525 {
 526         int ret;
 527
 528         if ((currentmA >= 300) && (currentmA <= 450))
 529                 currentmA = (currentmA - 300) / 50;
 530         else if ((currentmA >= 500) && (currentmA <= 1500))
 531                 currentmA = (currentmA - 500) / 100 + 4;
 532         else {
 533                 dev_err(di->dev, "invalid max_charger_currentmA\n");
 534                 return;
 535         }
 536
 537         currentmA |= LOCK_LIMIT;
 538         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, currentmA,
 539                                                 CHARGERUSB_CTRLLIMIT2);
 540         if (ret)
 541                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 542 }
 543
 544 static const int vichrg[] = {
 545         300, 350, 400, 450, 500, 600, 700, 800,
 546         900, 1000, 1100, 1200, 1300, 1400, 1500, 300
 547 };
 548
 549 static unsigned int twl6030_get_limit2_reg(struct twl6030_bci_device_info *di)
 550 {
 551         int ret;
 552         unsigned int currentmA;
 553         u8 val = 0;
 554
 555         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val,
 556                                         CHARGERUSB_CTRLLIMIT2);
 557         if (ret) {
 558                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 559                 currentmA = 0;
 560         } else
 561                 currentmA = vichrg[val & 0xF];
 562
 563         return currentmA;
 564 }
 565
 566 /*
 567  * Return channel value
 568  * Or < 0 on failure.
 569  */
 570 static int twl6030_get_gpadc_conversion(struct twl6030_bci_device_info *di,
 571                                         int channel_no)
 572 {
 573         struct twl6030_gpadc_request req;
 574         int temp = 0;
 575         int ret;
 576
 577         req.channels = (1 << channel_no);
 578         req.method = TWL6030_GPADC_SW2;
 579         req.active = 0;
 580         req.func_cb = NULL;
 581         ret = twl6030_gpadc_conversion(&req);
 582         if (ret < 0)
 583                 return ret;
 584
 585         if (req.rbuf[channel_no] > 0)
 586                 temp = req.rbuf[channel_no];
 587
 588         return temp;
 589 }
 590
 591 static int is_battery_present(struct twl6030_bci_device_info *di)
 592 {
 593         int val;
 594         static unsigned int current_src_val;
 595
 596         /*
 597          * Prevent charging on batteries were id resistor is
 598          * less than 5K.
 599          */
 600         val = twl6030_get_gpadc_conversion(di,di->gpadc_vbat_chnl);
 601
 602         /*
 603          * twl6030_get_gpadc_conversion for
 604          * 6030 return resistance, for 6032 - voltage and
 605          * it should be converted to resistance before
 606          * using.
 607          */
 608         if (!current_src_val) {
 609                 u8 reg = 0;
 610
 611                 if (twl_i2c_read_u8(TWL_MODULE_MADC, &reg,
 612                                         TWL6030_GPADC_CTRL))
 613                         pr_err("%s: Error reading TWL6030_GPADC_CTRL\n",
 614                                 __func__);
 615
 616                 current_src_val = (reg & GPADC_CTRL_ISOURCE_EN) ?
 617                                         GPADC_ISOURCE_22uA :
 618                                         GPADC_ISOURCE_7uA;
 619         }
 620
 621         val = (val * 1000) / current_src_val;
 622
 623         if (val < BATTERY_DETECT_THRESHOLD)
 624                 return 0;
 625
 626         return 1;
 627 }
 628
 629 static void twl6030_stop_usb_charger(struct twl6030_bci_device_info *di)
 630 {
 631         int ret;
 632         u8 reg;
 633         //printk("*************twl6030_stop_usb_charger***************\n");
 634         if (di->use_hw_charger) {
 635                 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &reg,
 636                                 CHARGERUSB_CTRL1);
 637                 if (ret)
 638                         goto err;
 639                 reg |= HZ_MODE;
 640                 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, reg,
 641                                 CHARGERUSB_CTRL1);
 642                 if (ret)
 643                         goto err;
 644
 645                 return;
 646         }
 647
 648         di->charger_source = 0;
 649         di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
 650
 651         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0, CONTROLLER_CTRL1);
 652
 653 err:
 654         if (ret)
 655                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 656 }
 657
 658 static void twl6030_start_usb_charger(struct twl6030_bci_device_info *di)
 659 {
 660         int ret;
 661         u8 reg;
 662
 663
 664 //printk("***************twl6030_start_usb_charger*****************************************\n");
 665
 666         if (di->use_hw_charger) {
 667                 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &reg,
 668                                 CHARGERUSB_CTRL1);
 669                 if (ret)
 670                         goto err;
 671
 672                 reg &= ~HZ_MODE;
 673                 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, reg,
 674                                 CHARGERUSB_CTRL1);
 675                 if (ret)
 676                         goto err;
 677
 678                 return;
 679         }
 680
 681         if (!is_battery_present(di)) {
 682                 dev_info(di->dev, "BATTERY NOT DETECTED!\n");
 683                 return;
 684         }
 685
 686         if (di->charger_source == POWER_SUPPLY_TYPE_MAINS)
 687                 return;
 688
 689         dev_dbg(di->dev, "USB input current limit %dmA\n",
 690                                         di->charger_incurrentmA);
 691         if (di->charger_incurrentmA < 50) {
 692                 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
 693                                         0, CONTROLLER_CTRL1);
 694                 if (ret)
 695                         goto err;
 696
 697                 return;
 698         }
 699
 700         twl6030_config_vichrg_reg(di, di->charger_outcurrentmA);
 701         twl6030_config_cinlimit_reg(di, di->charger_incurrentmA);
 702         twl6030_config_voreg_reg(di, di->platform_data->max_bat_voltagemV);
 703         twl6030_config_iterm_reg(di, di->platform_data->termination_currentmA);
 704
 705         if (di->charger_incurrentmA >= 50) {
 706                 reg = CONTROLLER_CTRL1_EN_CHARGER;
 707
 708                 if (di->use_power_path)
 709                         reg |= CONTROLLER_CTRL1_EN_LINCH;
 710
 711                 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, reg,
 712                                 CONTROLLER_CTRL1);
 713                 if (ret)
 714                         goto err;
 715
 716                 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
 717         }
 718         return;
 719 err:
 720         pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 721 }
 722
 723 static void twl6030_stop_ac_charger(struct twl6030_bci_device_info *di)
 724 {
 725         long int events;
 726         int ret;
 727
 728         di->charger_source = 0;
 729         di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
 730         events = BQ2415x_STOP_CHARGING;
 731
 732         if (di->use_hw_charger)
 733                 return;
 734
 735         blocking_notifier_call_chain(&notifier_list, events, NULL);
 736
 737         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0, CONTROLLER_CTRL1);
 738         if (ret)
 739                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 740
 741         if (di->wakelock_enabled)
 742                 wake_unlock(&chrg_lock);
 743 }
 744
 745 static void twl6030_start_ac_charger(struct twl6030_bci_device_info *di)
 746 {
 747         long int events;
 748         int ret;
 749
 750         if (!is_battery_present(di)) {
 751                 dev_info(di->dev, "BATTERY NOT DETECTED!\n");
 752                 return;
 753         }
 754         dev_dbg(di->dev, "AC charger detected\n");
 755         di->charger_source = POWER_SUPPLY_TYPE_MAINS;
 756         di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
 757         events = BQ2415x_START_CHARGING;
 758
 759         if (di->use_hw_charger)
 760                 return;
 761
 762         blocking_notifier_call_chain(&notifier_list, events, NULL);
 763
 764         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
 765                         CONTROLLER_CTRL1_EN_CHARGER |
 766                         CONTROLLER_CTRL1_SEL_CHARGER,
 767                         CONTROLLER_CTRL1);
 768         if (ret)
 769                 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
 770
 771         if (di->wakelock_enabled)
 772                 wake_lock(&chrg_lock);
 773 }
 774
 775 static void twl6030_stop_charger(struct twl6030_bci_device_info *di)
 776 {
 777         //printk("$$$$$$$$$$$$twl6030_stop_charger$$$$$$$$$$$$\n");
 778         if (di->charger_source == POWER_SUPPLY_TYPE_MAINS)
 779                 twl6030_stop_ac_charger(di);
 780         else if (di->charger_source == POWER_SUPPLY_TYPE_USB)
 781                 twl6030_stop_usb_charger(di);
 782 }
 783
 784 static void twl6032_charger_ctrl_interrupt(struct twl6030_bci_device_info *di)
 785 {
 786         u8 stat_toggle, stat_reset, stat_set = 0;
 787         u8 present_state = 0, linear_state;
 788         u8 present_status = 0;
 789         int err;
 790
 791         err = twl_i2c_read_u8(TWL6032_MODULE_CHARGER, &present_state,
 792                         LINEAR_CHRG_STS);
 793         if (err < 0) {
 794                 dev_err(di->dev, "%s: Error access to TWL6030 (%d)\n",
 795                                                                 __func__, err);
 796                 return;
 797         }
 798
 799         err = twl_i2c_read_u8(TWL6032_MODULE_CHARGER, &present_status,
 800                         CHARGERUSB_INT_STATUS);
 801         if (err < 0) {
 802                 dev_err(di->dev, "%s: Error access to TWL6030 (%d)\n",
 803                                                                 __func__, err);
 804                 return;
 805         }
 806
 807         linear_state = di->linear_stat;
 808
 809         stat_toggle = linear_state ^ present_state;
 810         stat_set = stat_toggle & present_state;
 811         stat_reset = stat_toggle & linear_state;
 812         di->linear_stat = present_state;
 813
 814         if (stat_set & LINEAR_CHRG_STS_CRYSTL_OSC_OK)
 815                 dev_dbg(di->dev, "Linear status: CRYSTAL OSC OK\n");
 816         if (present_state & LINEAR_CHRG_STS_END_OF_CHARGE) {
 817                 dev_dbg(di->dev, "Linear status: END OF CHARGE\n");
 818                 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 819         }
 820         if (present_status & EN_LINCH) {
 821                 dev_dbg(di->dev, "Linear status: START OF CHARGE\n");
 822                 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
 823         }
 824
 825         if (stat_set & LINEAR_CHRG_STS_VBATOV) {
 826                 dev_dbg(di->dev, "Linear Status: VBATOV\n");
 827                 di->bat_health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 828         }
 829         if (stat_reset & LINEAR_CHRG_STS_VBATOV) {
 830                 dev_dbg(di->dev, "Linear Status: VBATOV\n");
 831                 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
 832         }
 833
 834         if (stat_set & LINEAR_CHRG_STS_VSYSOV)
 835                 dev_dbg(di->dev, "Linear Status: VSYSOV\n");
 836         if (stat_set & LINEAR_CHRG_STS_DPPM_STS)
 837                 dev_dbg(di->dev, "Linear Status: DPPM STS\n");
 838         if (stat_set & LINEAR_CHRG_STS_CV_STS)
 839                 dev_dbg(di->dev, "Linear Status: CV STS\n");
 840         if (stat_set & LINEAR_CHRG_STS_CC_STS)
 841                 dev_dbg(di->dev, "Linear Status: CC STS\n");
 842 }
 843
 844 /*
 845  * Interrupt service routine
 846  *
 847  * Attends to TWL 6030 power module interruptions events, specifically
 848  * USB_PRES (USB charger presence) CHG_PRES (AC charger presence) events
 849  *
 850  */
 851 static irqreturn_t twl6030charger_ctrl_interrupt(int irq, void *_di)
 852 {
 853 //      printk("%s\n", __func__);
 854
 855         struct twl6030_bci_device_info *di = _di;
 856         int ret;
 857         int charger_fault = 0;
 858         long int events;
 859         u8 stat_toggle, stat_reset, stat_set = 0;
 860         u8 charge_state = 0;
 861         u8 present_charge_state = 0;
 862         u8 ac_or_vbus, no_ac_and_vbus = 0;
 863         u8 hw_state = 0, temp = 0;
 864
 865         /* read charger controller_stat1 */
 866         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &present_charge_state,
 867                 CONTROLLER_STAT1);
 868         if (ret) {
 869                 /*
 870                  * Since present state read failed, charger_state is no
 871                  * longer valid, reset to zero inorder to detect next events
 872                  */
 873                 charge_state = 0;
 874                 return IRQ_NONE;
 875         }
 876
 877         ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &hw_state, STS_HW_CONDITIONS);
 878         if (ret)
 879                 goto err;
 880
 881         charge_state = di->stat1;
 882
 883         stat_toggle = charge_state ^ present_charge_state;
 884         stat_set = stat_toggle & present_charge_state;
 885         stat_reset = stat_toggle & charge_state;
 886
 887         no_ac_and_vbus = !((present_charge_state) & (VBUS_DET | VAC_DET));
 888         ac_or_vbus = charge_state & (VBUS_DET | VAC_DET);
 889         if (no_ac_and_vbus && ac_or_vbus) {
 890                 di->charger_source = 0;
 891                 dev_dbg(di->dev, "No Charging source\n");
 892                 /* disable charging when no source present */
 893         }
 894
 895         charge_state = present_charge_state;
 896         di->stat1 = present_charge_state;
 897         if ((charge_state & VAC_DET) &&
 898                 (charge_state & CONTROLLER_STAT1_EXTCHRG_STATZ)) {
 899                 events = BQ2415x_CHARGER_FAULT;
 900                 blocking_notifier_call_chain(&notifier_list, events, NULL);
 901         }
 902
 903         if (stat_reset & VBUS_DET) {
 904                 /* On a USB detach, UNMASK VBUS OVP if masked*/
 905                 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &temp,
 906                                 CHARGERUSB_INT_MASK);
 907                 if (ret)
 908                         goto err;
 909
 910                 if (temp & MASK_MCHARGERUSB_FAULT) {
 911                         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
 912                                         (temp & ~MASK_MCHARGERUSB_FAULT),
 913                                         CHARGERUSB_INT_MASK);
 914                         if (ret)
 915                                 goto err;
 916                 }
 917                 di->usb_online = 0;
 918                 dev_info(di->dev, "usb removed\n");
 919                 twl6030_stop_usb_charger(di);
 920                 if (present_charge_state & VAC_DET)
 921                         twl6030_start_ac_charger(di);
 922
 923         }
 924
 925         if (stat_set & VBUS_DET) {
 926                 /* In HOST mode (ID GROUND) when a device is connected,
 927                  * Mask VBUS OVP interrupt and do no enable usb
 928                  * charging
 929                  */
 930                 if (hw_state & STS_USB_ID) {
 931                         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER,
 932                                         &temp,
 933                                         CHARGERUSB_INT_MASK);
 934                         if (ret)
 935                                 goto err;
 936
 937                         if (!(temp & MASK_MCHARGERUSB_FAULT)) {
 938                                 ret = twl_i2c_write_u8(
 939                                                 TWL6030_MODULE_CHARGER,
 940                                                 (temp | MASK_MCHARGERUSB_FAULT),
 941                                                 CHARGERUSB_INT_MASK);
 942                                 if (ret)
 943                                         goto err;
 944                         }
 945                 } else {
 946                         di->usb_online = POWER_SUPPLY_TYPE_USB;
 947                         if ((present_charge_state & VAC_DET) &&
 948                                         (di->vac_priority == 2))
 949                                 dev_info(di->dev, "USB charger detected"
 950                                                 ", continue with VAC\n");
 951                         else {
 952                                 di->charger_source =
 953                                                 POWER_SUPPLY_TYPE_USB;
 954                                 di->charge_status =
 955                                                 POWER_SUPPLY_STATUS_CHARGING;
 956                         }
 957                         dev_info(di->dev, "vbus detect\n");
 958                 }
 959         }
 960
 961         if (stat_reset & VAC_DET) {
 962                 di->ac_online = 0;
 963                 dev_info(di->dev, "vac removed\n");
 964                 twl6030_stop_ac_charger(di);
 965                 if (present_charge_state & VBUS_DET) {
 966                         di->charger_source = POWER_SUPPLY_TYPE_USB;
 967                         di->charge_status =
 968                                         POWER_SUPPLY_STATUS_CHARGING;
 969                         twl6030_start_usb_charger(di);
 970                 }
 971         }
 972         if (stat_set & VAC_DET) {
 973                 di->ac_online = POWER_SUPPLY_TYPE_MAINS;
 974                 if ((present_charge_state & VBUS_DET) &&
 975                                 (di->vac_priority == 3))
 976                         dev_info(di->dev,
 977                                         "AC charger detected"
 978                                         ", continue with VBUS\n");
 979                 else
 980                         twl6030_start_ac_charger(di);
 981         }
 982
 983         if (stat_set & CONTROLLER_STAT1_FAULT_WDG) {
 984                 charger_fault = 1;
 985                 dev_info(di->dev, "Fault watchdog fired\n");
 986         }
 987         if (stat_reset & CONTROLLER_STAT1_FAULT_WDG)
 988                 dev_err(di->dev, "Fault watchdog recovered\n");
 989         if (stat_set & CONTROLLER_STAT1_BAT_REMOVED)
 990                 dev_err(di->dev, "Battery removed\n");
 991         if (stat_reset & CONTROLLER_STAT1_BAT_REMOVED)
 992                 dev_err(di->dev, "Battery inserted\n");
 993         if (stat_set & CONTROLLER_STAT1_BAT_TEMP_OVRANGE) {
 994                 dev_err(di->dev, "Battery temperature overrange\n");
 995                 di->bat_health = POWER_SUPPLY_HEALTH_OVERHEAT;
 996         }
 997         if (stat_reset & CONTROLLER_STAT1_BAT_TEMP_OVRANGE) {
 998                 dev_dbg(di->dev, "Battery temperature within range\n");
 999                 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1000         }
1001         if (di->features & TWL6032_SUBCLASS)
1002                 twl6032_charger_ctrl_interrupt(di);
1003
1004         if (charger_fault) {
1005                 twl6030_stop_usb_charger(di);
1006                 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1007                 dev_dbg(di->dev, "Charger Fault stop charging\n");
1008         }
1009
1010         if (di->capacity != -1)
1011                 power_supply_changed(&di->bat);
1012         else {
1013                 cancel_delayed_work(&di->twl6030_bci_monitor_work);
1014                 queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work, 0);
1015         }
1016 err:
1017         return IRQ_HANDLED;
1018 }
1019
1020 static irqreturn_t twl6030charger_fault_interrupt(int irq, void *_di)
1021 {
1022         struct twl6030_bci_device_info *di = _di;
1023         int charger_fault = 0;
1024         int ret;
1025
1026         u8 usb_charge_sts = 0, usb_charge_sts1 = 0, usb_charge_sts2 = 0;
1027
1028         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts,
1029                                                 CHARGERUSB_INT_STATUS);
1030         if (ret)
1031                 goto err;
1032
1033         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts1,
1034                                                 CHARGERUSB_STATUS_INT1);
1035         if (ret)
1036                 goto err;
1037
1038         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts2,
1039                                                 CHARGERUSB_STATUS_INT2);
1040         if (ret)
1041                 goto err;
1042
1043         di->status_int1 = usb_charge_sts1;
1044         di->status_int2 = usb_charge_sts2;
1045         if (usb_charge_sts & CURRENT_TERM_INT)
1046                 dev_dbg(di->dev, "USB CURRENT_TERM_INT\n");
1047         if (usb_charge_sts & CHARGERUSB_THMREG)
1048                 dev_dbg(di->dev, "USB CHARGERUSB_THMREG\n");
1049         if (usb_charge_sts & CHARGERUSB_FAULT)
1050                 dev_dbg(di->dev, "USB CHARGERUSB_FAULT\n");
1051
1052         if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_TMREG)
1053                 dev_dbg(di->dev, "USB CHARGER Thermal regulation activated\n");
1054         if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_NO_BAT)
1055                 dev_dbg(di->dev, "No Battery Present\n");
1056         if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_BST_OCP)
1057                 dev_dbg(di->dev, "USB CHARGER Boost Over current protection\n");
1058         if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_TH_SHUTD) {
1059                 charger_fault = 1;
1060                 dev_dbg(di->dev, "USB CHARGER Thermal Shutdown\n");
1061         }
1062         if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_BAT_OVP)
1063                 dev_dbg(di->dev, "USB CHARGER Bat Over Voltage Protection\n");
1064         if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_POOR_SRC)
1065                 dev_dbg(di->dev, "USB CHARGER Poor input source\n");
1066         if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_SLP_MODE)
1067                 dev_dbg(di->dev, "USB CHARGER Sleep mode\n");
1068         if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_VBUS_OVP)
1069                 dev_dbg(di->dev, "USB CHARGER VBUS over voltage\n");
1070
1071         if (usb_charge_sts2 & CHARGE_DONE) {
1072                 di->charge_status = POWER_SUPPLY_STATUS_FULL;
1073                 dev_dbg(di->dev, "USB charge done\n");
1074         }
1075         if (usb_charge_sts2 & CURRENT_TERM)
1076                 dev_dbg(di->dev, "USB CURRENT_TERM\n");
1077         if (usb_charge_sts2 & ICCLOOP)
1078                 dev_dbg(di->dev, "USB ICCLOOP\n");
1079         if (usb_charge_sts2 & ANTICOLLAPSE)
1080                 dev_dbg(di->dev, "USB ANTICOLLAPSE\n");
1081
1082         if (charger_fault) {
1083                 twl6030_stop_usb_charger(di);
1084                 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1085                 dev_dbg(di->dev, "Charger Fault stop charging\n");
1086         }
1087         dev_info(di->dev, "Charger fault detected STS, INT1, INT2 %x %x %x\n",
1088             usb_charge_sts, usb_charge_sts1, usb_charge_sts2);
1089
1090         power_supply_changed(&di->bat);
1091 err:
1092         return IRQ_HANDLED;
1093 }
1094
1095 /*
1096  * In HW charger mode on 6032 irq routines must only deal with updating
1097  * state of charger. The hardware deals with start/stop conditions
1098  * automatically.
1099  */
1100 static irqreturn_t twl6032charger_ctrl_interrupt_hw(int irq, void *_di)
1101 {
1102         struct twl6030_bci_device_info *di = _di;
1103         u8 stat1, linear;
1104         int charger_stop = 0, end_of_charge = 0;
1105         int ret;
1106
1107         //printk("xxxxxxxxxxxxxxxxxxxxxxxx twl6032charger_ctrl_interrupt_hw   xxxxxxxxxxxxxx\n");
1108         /* read charger controller_stat1 */
1109         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &stat1,
1110                         CONTROLLER_STAT1);
1111         if (ret)
1112                 goto out;
1113
1114         ret = twl_i2c_read_u8(TWL6032_MODULE_CHARGER, &linear,
1115                         LINEAR_CHRG_STS);
1116         if (ret < 0)
1117                 goto out;
1118
1119         if (!(stat1 & (VBUS_DET | VAC_DET))) {
1120                 charger_stop = 1;
1121                 di->ac_online = di->usb_online = 0;
1122                 //printk("%%%%%%%%%%%%%%charger_stop = 1%%%%%%%%%%%%%\n");
1123         }
1124
1125         if (!(di->usb_online || di->ac_online)) {
1126                 if (stat1 & VBUS_DET) {
1127                         di->usb_online = 1;
1128                         di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1129 //                      printk("%%%%%%%%%%%%%%di->usb_online = 1%%%%%%%%%%%%%\n");
1130
1131                         //schedule_work(&di->usb_work);
1132                 } else if (stat1 & VAC_DET) {
1133                         di->ac_online = 1;
1134                         di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1135 //                      printk("%%%%%%%%%%%%%%di->ac_online = 1%%%%%%%%%%%%%\n");
1136                 }
1137         }
1138
1139         if (stat1 & CONTROLLER_STAT1_FAULT_WDG) {
1140                 charger_stop = 1;
1141                 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1142                  dev_err(di->dev, "Charger error : Fault watchdog\n");
1143         }
1144         if (stat1 & CONTROLLER_STAT1_BAT_REMOVED) {
1145                 charger_stop = 1;
1146                 di->bat_health = POWER_SUPPLY_HEALTH_DEAD;
1147                 dev_info(di->dev, "Battery removed\n");
1148         }
1149         if (stat1 & CONTROLLER_STAT1_BAT_TEMP_OVRANGE) {
1150                 charger_stop = 1;
1151                  dev_dbg(di->dev,
1152                         "Charger error : Battery temperature overrange\n");
1153                 di->bat_health = POWER_SUPPLY_HEALTH_OVERHEAT;
1154         }
1155
1156         if ((stat1 & CONTROLLER_STAT1_LINCH_GATED) &&
1157                         di->use_power_path) {
1158
1159                 charger_stop = 1;
1160
1161                 if (linear & LINEAR_CHRG_STS_CRYSTL_OSC_OK) {
1162                         di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1163                          dev_dbg(di->dev, "Charger error: CRYSTAL OSC OK\n");
1164                 }
1165
1166                 if (linear & LINEAR_CHRG_STS_END_OF_CHARGE) {
1167                         end_of_charge = 1;
1168                         di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1169                         dev_dbg(di->dev, "Charger: Full charge\n");
1170                 }
1171
1172                 if (linear & LINEAR_CHRG_STS_VBATOV) {
1173                         di->bat_health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1174                          dev_dbg(di->dev,
1175                                 "Charger error : Linear Status: VBATOV\n");
1176                 }
1177
1178                 if (linear & LINEAR_CHRG_STS_VSYSOV) {
1179                         di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1180                          dev_dbg(di->dev,
1181                                 "Charger error : Linear Status: VSYSOV\n");
1182                 }
1183         }
1184
1185         if (charger_stop) {
1186                 if (!(stat1 & (VBUS_DET | VAC_DET))) {
1187                         di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1188                 } else {
1189                         if (end_of_charge)
1190                                 di->charge_status =
1191                                         POWER_SUPPLY_STATUS_FULL;
1192                         else
1193                                 di->charge_status =
1194                                         POWER_SUPPLY_STATUS_NOT_CHARGING;
1195                 }
1196         }
1197         //printk("%%%%%%%%%%%%%%%%%%twl6032charger_ctrl_interrupt_hw  end  xxxxxxxxxxxxxx\n");
1198
1199         power_supply_changed(&di->bat);
1200
1201 out:
1202         return IRQ_HANDLED;
1203 }
1204
1205 static irqreturn_t twl6032charger_fault_interrupt_hw(int irq, void *_di)
1206 {
1207         struct twl6030_bci_device_info *di = _di;
1208         int charger_stop = 0, charger_start = 0;
1209         int ret;
1210         u8 sts, sts_int1, sts_int2, stat1;
1211
1212         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &sts,
1213                                                 CHARGERUSB_INT_STATUS);
1214         if (ret)
1215                 goto out;
1216
1217         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &sts_int1,
1218                                                 CHARGERUSB_STATUS_INT1);
1219         if (ret)
1220                 goto out;
1221
1222         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &sts_int2,
1223                                                 CHARGERUSB_STATUS_INT2);
1224         if (ret)
1225                 goto out;
1226
1227         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &stat1,
1228                                                 CONTROLLER_STAT1);
1229         if (ret)
1230                 goto out;
1231
1232         if (sts & EN_LINCH) {
1233                 charger_start = 1;
1234                 dev_dbg(di->dev, "Charger: EN_LINCH\n");
1235                 goto out;
1236         }
1237
1238         if ((sts & CURRENT_TERM_INT) && !di->use_power_path) {
1239                 dev_dbg(di->dev, "Charger: CURRENT_TERM_INT\n");
1240
1241                 if (sts_int2 & CURRENT_TERM) {
1242                         charger_stop = 1;
1243                          dev_dbg(di->dev, "Charger error: CURRENT_TERM\n");
1244                 }
1245         }
1246
1247         if (sts & CHARGERUSB_STAT) {
1248                 dev_dbg(di->dev, "Charger: CHARGEUSB_STAT\n");
1249
1250                 if (sts_int2 & ANTICOLLAPSE)
1251                          dev_dbg(di->dev, "Charger error: ANTICOLLAPSE\n");
1252         }
1253
1254         if (sts & CHARGERUSB_THMREG) {
1255                 dev_dbg(di->dev, "Charger: CHARGERUSB_THMREG\n");
1256
1257                 if (sts_int1 & CHARGERUSB_STATUS_INT1_TMREG)
1258                         dev_dbg(di->dev, "Charger error: TMREG\n");
1259         }
1260
1261         if (sts & CHARGERUSB_FAULT) {
1262                 dev_dbg(di->dev, "Charger: CHARGERUSB_FAULT\n");
1263
1264                 charger_stop = 1;
1265
1266                 if (!di->use_power_path) {
1267                         if (sts_int1 & CHARGERUSB_STATUS_INT1_NO_BAT) {
1268                                 di->bat_health = POWER_SUPPLY_HEALTH_DEAD;
1269                                 dev_err(di->dev,
1270                                         "Charger error : NO_BAT\n");
1271                         }
1272                         if (sts_int1 & CHARGERUSB_STATUS_INT1_BAT_OVP) {
1273                                 di->bat_health =
1274                                         POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1275                                 dev_dbg(di->dev, "Charger error : BAT_OVP\n");
1276                         }
1277                 }
1278
1279                 if (sts_int1 & CHARGERUSB_STATUS_INT1_BST_OCP) {
1280                         di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1281                         printk(KERN_ERR "Charger error : BST_OCP\n");
1282                 }
1283                 if (sts_int1 & CHARGERUSB_STATUS_INT1_TH_SHUTD) {
1284                         di->bat_health = POWER_SUPPLY_HEALTH_OVERHEAT;
1285                         printk(KERN_ERR "Charger error : TH_SHUTD\n");
1286                 }
1287                 if (sts_int1 & CHARGERUSB_STATUS_INT1_POOR_SRC) {
1288                         di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1289                         printk(KERN_ERR "Charger error : POOR_SRC\n");
1290                 }
1291                 if (sts_int1 & CHARGERUSB_STATUS_INT1_SLP_MODE)
1292                         dev_dbg(di->dev, "Charger error: SLP_MODE\n");
1293
1294                 if (sts_int1 & CHARGERUSB_STATUS_INT1_VBUS_OVP) {
1295                         di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1296                         printk(KERN_ERR "Charger error : VBUS_OVP\n");
1297                 }
1298         }
1299
1300         if (charger_stop) {
1301                 if (!(stat1 & (VBUS_DET | VAC_DET)))
1302                         di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1303                 else
1304                         di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1305         }
1306
1307 out:
1308         if (charger_start) {
1309                 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1310                 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1311         }
1312
1313         power_supply_changed(&di->bat);
1314
1315         return IRQ_HANDLED;
1316 }
1317
1318 static void twl6030battery_current(struct twl6030_bci_device_info *di)
1319 {
1320         int ret = 0;
1321         u16 read_value = 0;
1322         s16 temp = 0;
1323         int current_now = 0;
1324
1325         /* FG_REG_10, 11 is 14 bit signed instantaneous current sample value */
1326         ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *)&read_value,
1327                                                                 FG_REG_10, 2);
1328         if (ret < 0) {
1329                 dev_info(di->dev, "failed to read FG_REG_10: current_now\n");
1330                 return;
1331         }
1332
1333         temp = ((s16)(read_value << 2) >> 2);
1334         current_now = temp - di->cc_offset;
1335
1336         /* current drawn per sec */
1337         current_now = current_now * fuelgauge_rate[di->fuelgauge_mode];
1338         /* current in mAmperes */
1339         current_now = (current_now * di->current_max_scale) >> 13;
1340         /* current in uAmperes */
1341         current_now = current_now * 1000;
1342         di->current_uA = current_now;
1343
1344         return;
1345 }
1346
1347 /*
1348  * Setup the twl6030 BCI module to enable backup
1349  * battery charging.
1350  */
1351 static int twl6030backupbatt_setup(void)
1352 {
1353         int ret;
1354         u8 rd_reg = 0;
1355
1356         ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &rd_reg, BBSPOR_CFG);
1357         if (ret)
1358                 return ret;
1359
1360         rd_reg |= BB_CHG_EN;
1361         ret = twl_i2c_write_u8(TWL6030_MODULE_ID0, rd_reg, BBSPOR_CFG);
1362
1363         return ret;
1364 }
1365
1366 /*
1367  * Setup the twl6030 BCI module to measure battery
1368  * temperature
1369  */
1370 static int twl6030battery_temp_setup(bool enable)
1371 {
1372         int ret;
1373         u8 rd_reg = 0;
1374
1375         ret = twl_i2c_read_u8(TWL_MODULE_MADC, &rd_reg, TWL6030_GPADC_CTRL);
1376         if (ret)
1377                 return ret;
1378
1379         if (enable)
1380                 rd_reg |= (GPADC_CTRL_TEMP1_EN | GPADC_CTRL_TEMP2_EN |
1381                         GPADC_CTRL_TEMP1_EN_MONITOR |
1382                         GPADC_CTRL_TEMP2_EN_MONITOR | GPADC_CTRL_SCALER_DIV4);
1383         else
1384                 rd_reg ^= (GPADC_CTRL_TEMP1_EN | GPADC_CTRL_TEMP2_EN |
1385                         GPADC_CTRL_TEMP1_EN_MONITOR |
1386                         GPADC_CTRL_TEMP2_EN_MONITOR | GPADC_CTRL_SCALER_DIV4);
1387
1388         ret = twl_i2c_write_u8(TWL_MODULE_MADC, rd_reg, TWL6030_GPADC_CTRL);
1389
1390         return ret;
1391 }
1392
1393 static int twl6030battery_voltage_setup(struct twl6030_bci_device_info *di)
1394 {
1395         int ret;
1396         u8 rd_reg = 0;
1397
1398         ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &rd_reg, REG_MISC1);
1399         if (ret)
1400                 return ret;
1401
1402         rd_reg = rd_reg | VAC_MEAS | VBAT_MEAS | BB_MEAS;
1403         ret = twl_i2c_write_u8(TWL6030_MODULE_ID0, rd_reg, REG_MISC1);
1404         if (ret)
1405                 return ret;
1406
1407         ret = twl_i2c_read_u8(TWL_MODULE_USB, &rd_reg, REG_USB_VBUS_CTRL_SET);
1408         if (ret)
1409                 return ret;
1410
1411         rd_reg = rd_reg | VBUS_MEAS;
1412         ret = twl_i2c_write_u8(TWL_MODULE_USB, rd_reg, REG_USB_VBUS_CTRL_SET);
1413         if (ret)
1414                 return ret;
1415
1416         ret = twl_i2c_read_u8(TWL_MODULE_USB, &rd_reg, REG_USB_ID_CTRL_SET);
1417         if (ret)
1418                 return ret;
1419
1420         rd_reg = rd_reg | ID_MEAS;
1421         ret = twl_i2c_write_u8(TWL_MODULE_USB, rd_reg, REG_USB_ID_CTRL_SET);
1422         if (ret)
1423                 return ret;
1424
1425         if (di->features & TWL6032_SUBCLASS)
1426                 ret = twl_i2c_write_u8(TWL_MODULE_MADC,
1427                                         GPADC_CTRL2_CH18_SCALER_EN,
1428                                         TWL6030_GPADC_CTRL2);
1429
1430         return ret;
1431 }
1432
1433 static int twl6030battery_current_setup(bool enable)
1434 {
1435         int ret = 0;
1436         u8  reg = 0;
1437
1438         /*
1439          * Writing 0 to REG_TOGGLE1 has no effect, so
1440          * can directly set/reset FG.
1441          */
1442         if (enable)
1443                 reg = FGDITHS | FGS;
1444         else
1445                 reg = FGDITHR | FGR;
1446
1447         ret = twl_i2c_write_u8(TWL6030_MODULE_ID1, reg, REG_TOGGLE1);
1448         if (ret)
1449                 return ret;
1450
1451          ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_CAL_EN, FG_REG_00);
1452
1453         return ret;
1454 }
1455
1456 static enum power_supply_property twl6030_bci_battery_props[] = {
1457         POWER_SUPPLY_PROP_STATUS,
1458         POWER_SUPPLY_PROP_HEALTH,
1459         POWER_SUPPLY_PROP_ONLINE,
1460         POWER_SUPPLY_PROP_VOLTAGE_NOW,
1461         POWER_SUPPLY_PROP_CURRENT_NOW,
1462         POWER_SUPPLY_PROP_CURRENT_AVG,
1463         POWER_SUPPLY_PROP_CAPACITY,
1464         POWER_SUPPLY_PROP_TEMP,
1465 };
1466
1467 static enum power_supply_property twl6030_usb_props[] = {
1468         POWER_SUPPLY_PROP_ONLINE,
1469         POWER_SUPPLY_PROP_VOLTAGE_NOW,
1470 };
1471
1472 static enum power_supply_property twl6030_ac_props[] = {
1473         POWER_SUPPLY_PROP_ONLINE,
1474         POWER_SUPPLY_PROP_VOLTAGE_NOW,
1475 };
1476
1477 static enum power_supply_property twl6030_bk_bci_battery_props[] = {
1478         POWER_SUPPLY_PROP_VOLTAGE_NOW,
1479 };
1480
1481 static void twl6030_current_avg(struct work_struct *work)
1482 {
1483 //      printk("%s\n", __func__);
1484
1485         s32 samples = 0;
1486         s16 cc_offset = 0;
1487         int current_avg_uA = 0;
1488         int ret;
1489         struct twl6030_bci_device_info *di = container_of(work,
1490                 struct twl6030_bci_device_info,
1491                 twl6030_current_avg_work.work);
1492
1493         di->charge_n2 = di->charge_n1;
1494         di->timer_n2 = di->timer_n1;
1495
1496         /* FG_REG_01, 02, 03 is 24 bit unsigned sample counter value */
1497         ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->timer_n1,
1498                                                         FG_REG_01, 3);
1499         if (ret < 0)
1500                 goto err;
1501         /*
1502          * FG_REG_04, 5, 6, 7 is 32 bit signed accumulator value
1503          * accumulates instantaneous current value
1504          */
1505         ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->charge_n1,
1506                                                         FG_REG_04, 4);
1507         if (ret < 0)
1508                 goto err;
1509         /* FG_REG_08, 09 is 10 bit signed calibration offset value */
1510         ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &cc_offset,
1511                                                         FG_REG_08, 2);
1512         if (ret < 0)
1513                 goto err;
1514         cc_offset = ((s16)(cc_offset << 6) >> 6);
1515         di->cc_offset = cc_offset;
1516
1517         samples = di->timer_n1 - di->timer_n2;
1518         /* check for timer overflow */
1519         if (di->timer_n1 < di->timer_n2)
1520                 samples = samples + (1 << 24);
1521
1522         /* offset is accumulative over number of samples */
1523         cc_offset = cc_offset * samples;
1524
1525         current_avg_uA = ((di->charge_n1 - di->charge_n2 - cc_offset)
1526                                         * di->current_max_scale) /
1527                                         fuelgauge_rate[di->fuelgauge_mode];
1528         /* clock is a fixed 32Khz */
1529         current_avg_uA >>= 15;
1530
1531         /* Correct for the fuelguage sampling rate */
1532         samples /= fuelgauge_rate[di->fuelgauge_mode] * 4;
1533
1534         /*
1535          * Only update the current average if we have had a valid number
1536          * of samples in the accumulation.
1537          */
1538         if (samples) {
1539                 current_avg_uA = current_avg_uA / samples;
1540                 di->current_avg_uA = current_avg_uA * 1000;
1541         }
1542
1543         queue_delayed_work(di->freezable_work, &di->twl6030_current_avg_work,
1544                 msecs_to_jiffies(1000 * di->current_avg_interval));
1545         return;
1546 err:
1547         pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
1548 }
1549 #define BATT_NUM  11
1550 struct batt_vol_cal{
1551         u32 disp_cal;
1552         u32 dis_charge_vol;
1553         u32 charge_vol;
1554 };
1555 static struct batt_vol_cal  batt_table[BATT_NUM] = {
1556         {0,3571,3730},//{1,3420,3525},{2,3420,3575},{3,3475,3600},{5,3505,3620},{7,3525,3644},
1557         {9,3628,3770},//{11,3557,3670},{13,3570,3684},{15,3580,3700},{17,3610,3715},
1558         {19,3670,3878},//{21,3640,3748},{23,3652,3756},{25,3662,3775},{27,3672,3790},
1559         {29,3719,3895},//{31,3687,3814},{33,3693,3818},{35,3699,3822},{37,3705,3825},
1560         {39,3770,3941},//{41,3714,3832},{43,3718,3834},{45,3722,3836},{47,3726,3837},
1561         {49,3801,3980},//{51,3734,3841},{53,3738,3842},{55,3742,3844},{57,3746,3844},
1562         {59,3849,4010},//{61,3756,3860},{63,3764,3864},{65,3774,3871},{67,3786,3890},
1563         {69,3864,4024},//{71,3808,3930},{73,3817,3977},{75,3827,3977},{77,3845,3997},
1564         {79,3884,4040},//{81,3964,4047},{83,3982,4064},{85,4002,4080},{87,4026,4096},
1565         {89,4001,4050},//{91,4034,4144},{93,4055,4150},{95,4085,4195},{97,4085,4195},
1566         {100,4070,4090},
1567 };
1568 #if 0
1569 static int capacity_changed(struct twl6030_bci_device_info *di)
1570 {
1571         int curr_capacity = di->capacity;
1572         int charger_source = di->charger_source;
1573         int charging_disabled = 0;
1574         struct batt_vol_cal *p;
1575         int i=0;
1576
1577         p = batt_table;
1578         /* Because system load is always greater than
1579          * termination current, we will never get a CHARGE DONE
1580          * int from BQ. And charging will alwys be in progress.
1581          * We consider Vbat>3900 to be a full battery.
1582          * Since Voltage measured during charging is Voreg ~4.2v,
1583          * we dont update capacity if we are charging.
1584          */
1585
1586         /* if it has been more than 10 minutes since our last update
1587          * and we are charging we force a update.
1588          */
1589         if (time_after(jiffies, di->ac_next_refresh)
1590                 && (di->charger_source != POWER_SUPPLY_TYPE_BATTERY)) {
1591                 charging_disabled = 1;
1592                 di->ac_next_refresh = jiffies +
1593                         msecs_to_jiffies(CHARGING_CAPACITY_UPDATE_PERIOD);
1594                 di->capacity = -1;
1595
1596                 /* We have to disable charging to read correct
1597                  * voltages.
1598                  */
1599                 twl6030_stop_charger(di);
1600                 /*voltage setteling time*/
1601                 msleep(200);
1602                 di->voltage_mV = twl6030_get_gpadc_conversion(di,
1603                                                 di->gpadc_vbat_chnl);
1604
1605         }
1606
1607         /* Setting the capacity level only makes sense when on
1608          * the battery is powering the board.
1609          */
1610          if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING){  //charge
1611                 if(di->voltage_mV >= p[BATT_NUM - 1].charge_vol){
1612                         curr_capacity = 100;
1613                 }
1614                 else{
1615                         if(di->voltage_mV <= p[0].charge_vol){
1616                                 curr_capacity = 0;
1617                         }
1618                         else{
1619                                 for(i = 0; i < BATT_NUM - 1; i++){
1620
1621                                         if((p[i].charge_vol <= di->voltage_mV) && (di->voltage_mV < (p[i+1].charge_vol))){
1622                                                 curr_capacity = p[i].disp_cal ;
1623                                                 break;
1624                                         }
1625                                 }
1626                         }
1627                 }
1628
1629         }
1630         else if (di->charge_status == POWER_SUPPLY_STATUS_DISCHARGING){  //discharge
1631                 if(di->voltage_mV >= p[BATT_NUM - 1].dis_charge_vol){
1632                         curr_capacity = 100;
1633                 }
1634                 else{
1635                         if(di->voltage_mV <= p[0].dis_charge_vol){
1636                                 curr_capacity = 0;
1637                         }
1638                         else{
1639                                 for(i = 0; i < BATT_NUM - 1; i++){
1640                                         if(((p[i].dis_charge_vol) <= di->voltage_mV) && (di->voltage_mV < (p[i+1].dis_charge_vol))){
1641                                                 curr_capacity = p[i].disp_cal ;
1642                                                 break;
1643                                         }
1644                                 }
1645                         }
1646
1647                 }
1648
1649
1650         }
1651
1652         /*
1653         if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING) {
1654                 if (di->voltage_mV < 3520)
1655                         curr_capacity = 0;
1656                 else if (di->voltage_mV < 3600 && di->voltage_mV >= 3500)
1657                         curr_capacity = 20;
1658                 else if (di->voltage_mV < 3700 && di->voltage_mV >= 3600)
1659                         curr_capacity = 50;
1660                 else if (di->voltage_mV < 3800 && di->voltage_mV >= 3700)
1661                         curr_capacity = 75;
1662                 else if (di->voltage_mV < 3900 && di->voltage_mV >= 3800)
1663                         curr_capacity = 90;
1664                 else if (di->voltage_mV >= 3900)
1665                                 curr_capacity = 100;
1666         }
1667
1668 */
1669
1670
1671         /* if we disabled charging to check capacity,
1672          * enable it again after we read the
1673          * correct voltage.
1674          */
1675         if (charging_disabled) {
1676                 if (charger_source == POWER_SUPPLY_TYPE_MAINS)
1677                         twl6030_start_ac_charger(di);
1678                 else if (charger_source == POWER_SUPPLY_TYPE_USB)
1679                         twl6030_start_usb_charger(di);
1680         }
1681
1682         /* if battery is not present we assume it is on battery simulator and
1683          * current capacity is set to 100%
1684          */
1685         if (!is_battery_present(di))
1686                 curr_capacity = 100;
1687
1688
1689        /* Debouncing of voltage change. */
1690         if (di->capacity == -1) {
1691                 di->capacity = curr_capacity;
1692                 di->capacity_debounce_count = 0;
1693                 return 1;
1694         }
1695 /*
1696         if (curr_capacity != di->prev_capacity) {
1697                 di->prev_capacity = curr_capacity;
1698                 di->capacity_debounce_count = 0;
1699         } else if (++di->capacity_debounce_count >= 4) {
1700                 di->capacity = curr_capacity;
1701                 di->capacity_debounce_count = 0;
1702                 return 1;
1703         }
1704 */
1705         return 1;
1706 }
1707 #endif
1708 static int  twl6030_batt_vol_to_capacity (struct twl6030_bci_device_info *di)
1709
1710 {
1711
1712         int i = 0;
1713         int capacity = 0;
1714         int BatVoltage;
1715
1716         struct batt_vol_cal *p;
1717         p = batt_table;
1718
1719         BatVoltage = di ->voltage_mV;
1720
1721         if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING){  //charge
1722                 if(BatVoltage >=  (p[BATT_NUM - 1].charge_vol)){
1723                         capacity = 100;
1724                 }
1725                 else{
1726                         if(BatVoltage <= (p[0].charge_vol)){
1727                                 capacity = 0;
1728                         }
1729                         else{
1730                                 for(i = 0; i < BATT_NUM - 1; i++){
1731
1732                                         if(((p[i].charge_vol) <= BatVoltage) && (BatVoltage < (p[i+1].charge_vol))){
1733                                              //   capacity = p[i].disp_cal ;
1734                         capacity = i * 10 + ((BatVoltage - p[i].charge_vol) * 10) / (p[i+1] .charge_vol- p[i].charge_vol);
1735
1736
1737                                                 break;
1738                                         }
1739                                 }
1740                         }
1741                 }
1742
1743         }
1744      else{  //discharge
1745                 if(BatVoltage >= (p[BATT_NUM - 1].dis_charge_vol)){
1746                         capacity = 100;
1747                 }
1748                 else{
1749                         if(BatVoltage <= (p[0].dis_charge_vol)){
1750                                 capacity = 0;
1751                         }
1752                         else{
1753                                 for(i = 0; i < BATT_NUM - 1; i++){
1754                                         if(((p[i].dis_charge_vol) <= BatVoltage) && (BatVoltage < (p[i+1].dis_charge_vol))){
1755                                         //        capacity = p[i].disp_cal ;
1756                         capacity = i * 10 + ((BatVoltage - p[i].dis_charge_vol) * 10) / (p[i+1] .dis_charge_vol- p[i].dis_charge_vol);
1757                                                 break;
1758                                         }
1759                                 }
1760                         }
1761
1762                 }
1763
1764
1765         }
1766
1767         return capacity;
1768
1769 }
1770
1771
1772
1773 void twl6030_batt_capacity_samples(struct twl6030_bci_device_info *di)
1774 {
1775         int capacity = 0;
1776         capacity = twl6030_batt_vol_to_capacity (di);
1777          twl6030battery_current(di);
1778         //printk("old-capactiyt == %d, now-capacity == %d , di->charge_status == %d,di->current_uA  = %d\n", di->capacity, capacity, di->charge_status,di->current_uA);
1779 ///////////////////////////////////////////////////////////////////////////////////////////////////////
1780
1781
1782 //      capacity = twl6030_batt_vol_to_capacity (di);
1783
1784         if (di->charge_status == POWER_SUPPLY_STATUS_FULL){
1785                 if (capacity < di->capacity){
1786                         if (di ->gBatCapacityChargeCnt >= NUM_CHARGE_MIN_SAMPLE){
1787                                 di ->gBatCapacityChargeCnt = 0;
1788                                 if (di -> capacity < 99){
1789                                         di -> capacity++;
1790                                 }
1791                         }
1792
1793                 }
1794
1795         }
1796
1797
1798         if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING){
1799                 if (capacity > di->capacity){
1800                         //Êµ¼Ê²ÉÑùµ½µÄÈÝÁ¿±ÈÏÔÊ¾µÄÈÝÁ¿´ó£¬Öð¼¶ÉÏÉý
1801                         if (++(di->gBatCapacityChargeCnt) >= NUM_CHARGE_MIN_SAMPLE){
1802                                 di ->gBatCapacityChargeCnt  = 0;
1803                                 if (di ->  capacity < 99){
1804                                         di -> capacity++;
1805
1806                                 }
1807                         }
1808                         di->gBatCapacityDisChargeCnt = 0;  //·ÅµçµÄ¼ÆÊýÖµÎª0
1809                 }
1810
1811         }
1812 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
1813         if ((di->charge_status == POWER_SUPPLY_STATUS_DISCHARGING)||(di->charge_status == POWER_SUPPLY_STATUS_NOT_CHARGING)){
1814
1815         //·ÅµçÊ±,Ö»ÔÊÐíµçÑ¹ÏÂ½µ
1816                 if (capacity < di -> capacity){
1817                         if (++(di->gBatCapacityDisChargeCnt) >= NUM_DISCHARGE_MIN_SAMPLE){
1818                                 di ->gBatCapacityDisChargeCnt = 0;
1819                                 if (di -> capacity > 0){
1820                                         di -> capacity-- ;
1821                                         //bat->bat_change  = 1;
1822                                 }
1823                         }
1824                 }
1825                 else{
1826                         di ->gBatCapacityDisChargeCnt = 0;
1827                 }
1828                 //di ->gBatCapacityChargeCnt = 0;
1829         }
1830                 di ->capacitytmp = capacity;
1831 }
1832
1833 static int twl6030_set_watchdog(struct twl6030_bci_device_info *di, int val)
1834 {
1835         di->watchdog_duration = val;
1836
1837         dev_dbg(di->dev, "Watchdog reset %d", val);
1838
1839         return twl_i2c_write_u8(TWL6030_MODULE_CHARGER, val, CONTROLLER_WDG);
1840
1841 }
1842 #if 0
1843 static void twl6030_bci_adc_set(struct twl6030_bci_device_info *di)
1844 {
1845         struct twl6030_gpadc_request req;
1846         int adc_code;
1847         int temp;
1848         int ret;
1849         //int level;
1850
1851         /* Kick the charger watchdog */
1852         if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING)
1853                 twl6030_set_watchdog(di, di->watchdog_duration);
1854
1855         req.method = TWL6030_GPADC_SW2;
1856         req.channels = (1 << 1) | (1 << di->gpadc_vbat_chnl) | (1 << 8);
1857         req.active = 0;
1858         req.func_cb = NULL;
1859         ret = twl6030_gpadc_conversion(&req);
1860
1861
1862         if (ret < 0) {
1863                 dev_dbg(di->dev, "gpadc conversion failed: %d\n", ret);
1864                 return;
1865         }
1866
1867         if (req.rbuf[di->gpadc_vbat_chnl] > 0)
1868                 di->voltage_mV = req.rbuf[di->gpadc_vbat_chnl];
1869
1870         if (req.rbuf[8] > 0)
1871                 di->bk_voltage_mV = req.rbuf[8];
1872
1873         if (di->platform_data->battery_tmp_tbl == NULL)
1874                 return;
1875
1876         adc_code = req.rbuf[1];
1877         for (temp = 0; temp < di->platform_data->tblsize; temp++) {
1878                 if (adc_code >= di->platform_data->
1879                                 battery_tmp_tbl[temp])
1880                         break;
1881         }
1882         //printk("twl6030_bci_adc_set---di->voltage_mV-=-%d,di->capacity = %d \n",di->voltage_mV,di->capacity);
1883         /* first 2 values are for negative temperature */
1884
1885 }
1886 #endif
1887 static void twl6030_bci_battery_work(struct work_struct *work)
1888 {
1889
1890         struct twl6030_bci_device_info *di = container_of(work,
1891                 struct twl6030_bci_device_info, twl6030_bci_monitor_work.work);
1892         struct twl6030_gpadc_request req;
1893         int adc_code;
1894         int temp;
1895         int ret;
1896 //      int level;
1897
1898         /* Kick the charger watchdog */
1899         if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING)
1900                 twl6030_set_watchdog(di, di->watchdog_duration);
1901
1902         req.method = TWL6030_GPADC_SW2;
1903         req.channels = (1 << 1) | (1 << di->gpadc_vbat_chnl) | (1 << 8);
1904         req.active = 0;
1905         req.func_cb = NULL;
1906         ret = twl6030_gpadc_conversion(&req);
1907
1908         queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work,
1909                         msecs_to_jiffies(TIMER_MS_COUNTS)); //* di->monitoring_interval
1910
1911         if (ret < 0) {
1912                 dev_dbg(di->dev, "gpadc conversion failed: %d\n", ret);
1913                 return;
1914         }
1915
1916         if (req.rbuf[di->gpadc_vbat_chnl] > 0)
1917                 di->voltage_mV = req.rbuf[di->gpadc_vbat_chnl];
1918
1919         if (req.rbuf[8] > 0)
1920                 di->bk_voltage_mV = req.rbuf[8];
1921
1922         if (di->platform_data->battery_tmp_tbl == NULL)
1923                 return;
1924
1925         adc_code = req.rbuf[1];
1926         for (temp = 0; temp < di->platform_data->tblsize; temp++) {
1927                 if (adc_code >= di->platform_data->
1928                                 battery_tmp_tbl[temp])
1929                         break;
1930         }
1931         //printk("workxxxxx---di->voltage_mV-=-%d,di->capacity = %d \n",di->voltage_mV,di->capacity);
1932         /* first 2 values are for negative temperature */
1933         di->temp_C = (temp - 2); /* in degrees Celsius */
1934 //      if (capacity_changed(di))  //xsf
1935         {
1936                 twl6030_batt_capacity_samples(di);
1937                 // di->capacity = level;
1938                 power_supply_changed(&di->bat);
1939         }
1940 }
1941
1942 static void twl6030_current_mode_changed(struct twl6030_bci_device_info *di)
1943 {
1944         int ret;
1945         //printk("%s\n", __func__);
1946
1947         /* FG_REG_01, 02, 03 is 24 bit unsigned sample counter value */
1948         ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->timer_n1,
1949                                                         FG_REG_01, 3);
1950         if (ret < 0)
1951                 goto err;
1952         /*
1953          * FG_REG_04, 5, 6, 7 is 32 bit signed accumulator value
1954          * accumulates instantaneous current value
1955          */
1956         ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->charge_n1,
1957                                                         FG_REG_04, 4);
1958         if (ret < 0)
1959                 goto err;
1960
1961         cancel_delayed_work(&di->twl6030_current_avg_work);
1962         queue_delayed_work(di->freezable_work, &di->twl6030_current_avg_work,
1963                 msecs_to_jiffies(1000 * di->current_avg_interval));
1964         return;
1965 err:
1966         pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
1967 }
1968
1969 static void twl6030_work_interval_changed(struct twl6030_bci_device_info *di)
1970 {
1971         //printk("%s\n", __func__);
1972
1973         cancel_delayed_work(&di->twl6030_bci_monitor_work);
1974         queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work,
1975                 msecs_to_jiffies(1000 * di->monitoring_interval));
1976 }
1977
1978 #define to_twl6030_bci_device_info(x) container_of((x), \
1979                         struct twl6030_bci_device_info, bat);
1980 #if 0
1981 static void twl6030_bci_battery_external_power_changed(struct power_supply *psy)
1982 {//     printk("%s\n", __func__);
1983
1984         struct twl6030_bci_device_info *di = to_twl6030_bci_device_info(psy);
1985
1986         cancel_delayed_work(&di->twl6030_bci_monitor_work);
1987         queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work, 0);
1988 }
1989 #endif
1990
1991 #define to_twl6030_ac_device_info(x) container_of((x), \
1992                 struct twl6030_bci_device_info, ac);
1993
1994 static int twl6030_ac_get_property(struct power_supply *psy,
1995                                         enum power_supply_property psp,
1996                                         union power_supply_propval *val)
1997 {
1998         u8 stat1;
1999         struct twl6030_bci_device_info *di = to_twl6030_ac_device_info(psy);
2000         switch (psp) {
2001         case POWER_SUPPLY_PROP_ONLINE:
2002                 twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &stat1,
2003                                         CONTROLLER_STAT1);
2004
2005                 if (stat1 & VAC_DET) {
2006                         val->intval =  1;
2007                 }
2008                 else
2009                         val->intval =  0;
2010
2011                 ///printk("&&&&&&&&&&&&ac---charge  ac->intval = %d &&&&&&&&&&&&&&&\n" ,val->intval);
2012
2013                 break;
2014         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2015                 val->intval = twl6030_get_gpadc_conversion(di, 9) * 1000;
2016
2017                 break;
2018         default:
2019                 return -EINVAL;
2020         }
2021
2022         return 0;
2023 }
2024
2025 #define to_twl6030_usb_device_info(x) container_of((x), \
2026                 struct twl6030_bci_device_info, usb);
2027
2028 static int twl6030_usb_get_property(struct power_supply *psy,
2029                                         enum power_supply_property psp,
2030                                         union power_supply_propval *val)
2031 {
2032         u8 stat1;
2033         struct twl6030_bci_device_info *di = to_twl6030_usb_device_info(psy);
2034         switch (psp) {
2035         case POWER_SUPPLY_PROP_ONLINE:
2036
2037                 twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &stat1,
2038                                         CONTROLLER_STAT1);
2039
2040                 if (stat1 & VBUS_DET) {
2041                         val->intval =  1;
2042                 }
2043                 else
2044                         val->intval =  0;
2045
2046                 //val->intval = di->usb_online; //xsf
2047
2048                 //printk("&&&&&&&&&&&&usb---charge  val->intval = %d &&&&&&&&&&&&&&&\n" ,val->intval);
2049                 break;
2050         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2051                 val->intval = twl6030_get_gpadc_conversion(di, 10) * 1000;
2052                 //printk("&&&&&&&&&&&&usb-voltage = &&&&&&&&&&&&&&&%d\n", val->intval);
2053                 break;
2054         default:
2055                 return -EINVAL;
2056         }
2057
2058         return 0;
2059 }
2060
2061 #define to_twl6030_bk_bci_device_info(x) container_of((x), \
2062                 struct twl6030_bci_device_info, bk_bat);
2063
2064 static int twl6030_bk_bci_battery_get_property(struct power_supply *psy,
2065                                         enum power_supply_property psp,
2066                                         union power_supply_propval *val)
2067 {
2068         struct twl6030_bci_device_info *di = to_twl6030_bk_bci_device_info(psy);
2069         val->intval = 0;
2070         switch (psp) {
2071         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2072                 val->intval = di->bk_voltage_mV * 1000;
2073                 break;
2074         default:
2075                 return -EINVAL;
2076         }
2077
2078         return 0;
2079 }
2080
2081 static int twl6030_bci_battery_get_property(struct power_supply *psy,
2082                                         enum power_supply_property psp,
2083                                         union power_supply_propval *val)
2084 {
2085         struct twl6030_bci_device_info *di;
2086
2087         di = to_twl6030_bci_device_info(psy);
2088
2089         switch (psp) {
2090         case POWER_SUPPLY_PROP_STATUS:
2091                 val->intval = di->charge_status;
2092                 break;
2093         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2094                 di->voltage_mV = twl6030_get_gpadc_conversion(di,
2095                                                 di->gpadc_vbat_chnl);
2096                 val->intval = di->voltage_mV * 1000;
2097                 break;
2098         case POWER_SUPPLY_PROP_CURRENT_NOW:
2099                 twl6030battery_current(di);
2100                 val->intval = di->current_uA;
2101                 break;
2102         case POWER_SUPPLY_PROP_TEMP:
2103                 val->intval = di->temp_C;
2104                 break;
2105         case POWER_SUPPLY_PROP_ONLINE:
2106                 val->intval = di->charger_source;
2107                 break;
2108         case POWER_SUPPLY_PROP_CURRENT_AVG:
2109                 val->intval = di->current_avg_uA;
2110                 break;
2111         case POWER_SUPPLY_PROP_HEALTH:
2112                 val->intval = di->bat_health;
2113                 break;
2114         case POWER_SUPPLY_PROP_CAPACITY:
2115                 val->intval = di->capacity;
2116                 break;
2117         default:
2118                 return -EINVAL;
2119         }
2120         return 0;
2121 }
2122
2123 int twl6030_register_notifier(struct notifier_block *nb,
2124                                 unsigned int events)
2125 {
2126         return blocking_notifier_chain_register(&notifier_list, nb);
2127 }
2128 EXPORT_SYMBOL_GPL(twl6030_register_notifier);
2129
2130 int twl6030_unregister_notifier(struct notifier_block *nb,
2131                                 unsigned int events)
2132 {
2133         return blocking_notifier_chain_unregister(&notifier_list, nb);
2134 }
2135 EXPORT_SYMBOL_GPL(twl6030_unregister_notifier);
2136
2137 static void twl6030_usb_charger_work(struct work_struct *work)
2138 {
2139         struct twl6030_bci_device_info  *di =
2140                 container_of(work, struct twl6030_bci_device_info, usb_work);
2141         switch (di->event) {
2142         case USB_EVENT_CHARGER:
2143                 /* POWER_SUPPLY_TYPE_USB_DCP */
2144                 di->usb_online = POWER_SUPPLY_TYPE_USB_DCP;
2145                 di->charger_incurrentmA = 1800;
2146                 break;
2147         case USB_EVENT_VBUS:
2148                 switch (di->usb_online) {
2149                 case POWER_SUPPLY_TYPE_USB_CDP:
2150                         /*
2151                          * Only 500mA here or high speed chirp
2152                          * handshaking may break
2153                          */
2154                         di->charger_incurrentmA = 500;
2155                 case POWER_SUPPLY_TYPE_USB:
2156                         break;
2157                 }
2158                 break;
2159         case USB_EVENT_NONE:
2160                 di->usb_online = 0;
2161                 di->charger_incurrentmA = 0;
2162                 break;
2163         case USB_EVENT_ENUMERATED:
2164                 if (di->usb_online == POWER_SUPPLY_TYPE_USB_CDP)
2165                         di->charger_incurrentmA = 560;
2166                 else
2167                         di->charger_incurrentmA = di->usb_max_power;
2168                 break;
2169         default:
2170                 return;
2171         }
2172         twl6030_start_usb_charger(di);
2173
2174         power_supply_changed(&di->usb);
2175 }
2176
2177 static int twl6030_usb_notifier_call(struct notifier_block *nb,
2178                 unsigned long event, void *data)
2179 {
2180         struct twl6030_bci_device_info *di =
2181                 container_of(nb, struct twl6030_bci_device_info, nb);
2182         di->event = event;
2183         switch (event) {
2184         case USB_EVENT_VBUS:
2185                 di->usb_online = *((unsigned int *) data);
2186                 break;
2187         case USB_EVENT_ENUMERATED:
2188                 di->usb_max_power = *((unsigned int *) data);
2189                 break;
2190         case USB_EVENT_CHARGER:
2191         case USB_EVENT_NONE:
2192                 break;
2193         case USB_EVENT_ID:
2194         default:
2195                 return NOTIFY_OK;
2196         }
2197
2198         schedule_work(&di->usb_work);
2199
2200         return NOTIFY_OK;
2201 }
2202
2203 static ssize_t set_fg_mode(struct device *dev,
2204                 struct device_attribute *attr, const char *buf, size_t count)
2205 {
2206         long val;
2207         int status = count;
2208         int ret;
2209         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2210
2211         if ((strict_strtol(buf, 10, &val) < 0) || (val > 3))
2212                 return -EINVAL;
2213         di->fuelgauge_mode = val;
2214         ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, (val << 6) | CC_CAL_EN,
2215                                                         FG_REG_00);
2216         if (ret)
2217                 return -EIO;
2218         twl6030_current_mode_changed(di);
2219         return status;
2220 }
2221
2222 static ssize_t show_fg_mode(struct device *dev,
2223                 struct device_attribute *attr, char *buf)
2224 {
2225         int val;
2226         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2227
2228         val = di->fuelgauge_mode;
2229         return sprintf(buf, "%d\n", val);
2230 }
2231
2232 static ssize_t set_charge_src(struct device *dev,
2233                 struct device_attribute *attr, const char *buf, size_t count)
2234 {
2235         long val;
2236         int status = count;
2237         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2238
2239         if ((strict_strtol(buf, 10, &val) < 0) || (val < 2) || (val > 3))
2240                 return -EINVAL;
2241         di->vac_priority = val;
2242         return status;
2243 }
2244
2245 static ssize_t show_charge_src(struct device *dev,
2246                         struct device_attribute *attr, char *buf)
2247 {
2248         int val;
2249         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2250
2251         val = di->vac_priority;
2252         return sprintf(buf, "%d\n", val);
2253 }
2254
2255 static ssize_t show_vbus_voltage(struct device *dev,
2256                 struct device_attribute *attr, char *buf)
2257 {
2258         int val;
2259         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2260
2261         val = twl6030_get_gpadc_conversion(di, 10);
2262
2263         return sprintf(buf, "%d\n", val);
2264 }
2265
2266 static ssize_t show_id_level(struct device *dev, struct device_attribute *attr,
2267                                                         char *buf)
2268 {
2269         int val;
2270         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2271
2272         val = twl6030_get_gpadc_conversion(di, 14);
2273
2274         return sprintf(buf, "%d\n", val);
2275 }
2276
2277 static ssize_t set_watchdog(struct device *dev,
2278                 struct device_attribute *attr, const char *buf, size_t count)
2279 {
2280         long val;
2281         int status = count;
2282         int ret;
2283         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2284
2285         if ((strict_strtol(buf, 10, &val) < 0) || (val < 1) || (val > 127))
2286                 return -EINVAL;
2287         ret = twl6030_set_watchdog(di, val);
2288         if (ret)
2289                 return -EIO;
2290
2291         return status;
2292 }
2293
2294 static ssize_t show_watchdog(struct device *dev,
2295                 struct device_attribute *attr, char *buf)
2296 {
2297         int val;
2298         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2299
2300         val = di->watchdog_duration;
2301         return sprintf(buf, "%d\n", val);
2302 }
2303
2304 static ssize_t show_fg_counter(struct device *dev,
2305                 struct device_attribute *attr, char *buf)
2306 {
2307         int fg_counter = 0;
2308         int ret;
2309
2310         ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &fg_counter,
2311                                                         FG_REG_01, 3);
2312         if (ret < 0)
2313                 return -EIO;
2314         return sprintf(buf, "%d\n", fg_counter);
2315 }
2316
2317 static ssize_t show_fg_accumulator(struct device *dev,
2318                 struct device_attribute *attr, char *buf)
2319 {
2320         long fg_accum = 0;
2321         int ret;
2322
2323         ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &fg_accum,
2324                                                         FG_REG_04, 4);
2325         if (ret > 0)
2326                 return -EIO;
2327
2328         return sprintf(buf, "%ld\n", fg_accum);
2329 }
2330
2331 static ssize_t show_fg_offset(struct device *dev,
2332                 struct device_attribute *attr, char *buf)
2333 {
2334         s16 fg_offset = 0;
2335         int ret;
2336
2337         ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &fg_offset,
2338                                                         FG_REG_08, 2);
2339         if (ret < 0)
2340                 return -EIO;
2341         fg_offset = ((s16)(fg_offset << 6) >> 6);
2342
2343         return sprintf(buf, "%d\n", fg_offset);
2344 }
2345
2346 static ssize_t set_fg_clear(struct device *dev, struct device_attribute *attr,
2347                                                 const char *buf, size_t count)
2348 {
2349         long val;
2350         int status = count;
2351         int ret;
2352
2353         if ((strict_strtol(buf, 10, &val) < 0) || (val != 1))
2354                 return -EINVAL;
2355         ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_AUTOCLEAR,
2356                                                         FG_REG_00);
2357         if (ret)
2358                 return -EIO;
2359
2360         return status;
2361 }
2362
2363 static ssize_t set_fg_cal(struct device *dev, struct device_attribute *attr,
2364                                                 const char *buf, size_t count)
2365 {
2366         long val;
2367         int status = count;
2368         int ret;
2369
2370         if ((strict_strtol(buf, 10, &val) < 0) || (val != 1))
2371                 return -EINVAL;
2372         ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_CAL_EN, FG_REG_00);
2373         if (ret)
2374                 return -EIO;
2375
2376         return status;
2377 }
2378
2379 static ssize_t set_charging(struct device *dev, struct device_attribute *attr,
2380                                           const char *buf, size_t count)
2381 {
2382         int status = count;
2383         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2384
2385         if (strncmp(buf, "startac", 7) == 0) {
2386                 if (di->charger_source == POWER_SUPPLY_TYPE_USB)
2387                         twl6030_stop_usb_charger(di);
2388                 twl6030_start_ac_charger(di);
2389         } else if (strncmp(buf, "startusb", 8) == 0) {
2390                 if (di->charger_source == POWER_SUPPLY_TYPE_MAINS)
2391                         twl6030_stop_ac_charger(di);
2392                 di->charger_source = POWER_SUPPLY_TYPE_USB;
2393                 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
2394                 twl6030_start_usb_charger(di);
2395         } else if (strncmp(buf, "stop" , 4) == 0)
2396                 twl6030_stop_charger(di);
2397         else
2398                 return -EINVAL;
2399
2400         return status;
2401 }
2402
2403 static ssize_t set_regulation_voltage(struct device *dev,
2404         struct device_attribute *attr, const char *buf, size_t count)
2405 {
2406         long val;
2407         int status = count;
2408         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2409
2410         if ((strict_strtol(buf, 10, &val) < 0) || (val < 3500)
2411                         || (val > di->platform_data->max_charger_voltagemV))
2412                 return -EINVAL;
2413         di->platform_data->max_bat_voltagemV = val;
2414         twl6030_config_voreg_reg(di, val);
2415
2416         return status;
2417 }
2418
2419 static ssize_t show_regulation_voltage(struct device *dev,
2420         struct device_attribute *attr, char *buf)
2421 {
2422         unsigned int val;
2423         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2424
2425         val = di->platform_data->max_bat_voltagemV;
2426         return sprintf(buf, "%u\n", val);
2427 }
2428
2429 static ssize_t set_termination_current(struct device *dev,
2430         struct device_attribute *attr, const char *buf, size_t count)
2431 {
2432         long val;
2433         int status = count;
2434         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2435
2436         if ((strict_strtol(buf, 10, &val) < 0) || (val < 50) || (val > 400))
2437                 return -EINVAL;
2438         di->platform_data->termination_currentmA = val;
2439         twl6030_config_iterm_reg(di, val);
2440
2441         return status;
2442 }
2443
2444 static ssize_t show_termination_current(struct device *dev,
2445                         struct device_attribute *attr, char *buf)
2446 {
2447         unsigned int val;
2448         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2449
2450         val = di->platform_data->termination_currentmA;
2451         return sprintf(buf, "%u\n", val);
2452 }
2453
2454 static ssize_t set_cin_limit(struct device *dev,
2455                 struct device_attribute *attr, const char *buf, size_t count)
2456 {
2457         long val;
2458         int status = count;
2459         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2460
2461         if ((strict_strtol(buf, 10, &val) < 0) || (val < 50) || (val > 1500))
2462                 return -EINVAL;
2463         di->charger_incurrentmA = val;
2464         twl6030_config_cinlimit_reg(di, val);
2465
2466         return status;
2467 }
2468
2469 static ssize_t show_cin_limit(struct device *dev, struct device_attribute *attr,
2470                                                                   char *buf)
2471 {
2472         unsigned int val;
2473         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2474
2475         val = di->charger_incurrentmA;
2476         return sprintf(buf, "%u\n", val);
2477 }
2478
2479 static ssize_t set_charge_current(struct device *dev,
2480                 struct device_attribute *attr, const char *buf, size_t count)
2481 {
2482         long val;
2483         int status = count;
2484         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2485
2486         if ((strict_strtol(buf, 10, &val) < 0) || (val < 300)
2487                         || (val > di->platform_data->max_charger_currentmA))
2488                 return -EINVAL;
2489         di->charger_outcurrentmA = val;
2490         twl6030_config_vichrg_reg(di, val);
2491
2492         return status;
2493 }
2494
2495 static ssize_t show_charge_current(struct device *dev,
2496                 struct device_attribute *attr, char *buf)
2497 {
2498         unsigned int val;
2499         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2500
2501         val = di->charger_outcurrentmA;
2502         return sprintf(buf, "%u\n", val);
2503 }
2504
2505 static ssize_t set_min_vbus(struct device *dev, struct device_attribute *attr,
2506                                   const char *buf, size_t count)
2507 {
2508         long val;
2509         int status = count;
2510         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2511
2512         if ((strict_strtol(buf, 10, &val) < 0) || (val < 4200) || (val > 4760))
2513                 return -EINVAL;
2514         di->min_vbus = val;
2515         twl6030_config_min_vbus_reg(di, val);
2516
2517         return status;
2518 }
2519
2520 static ssize_t show_min_vbus(struct device *dev, struct device_attribute *attr,
2521                                   char *buf)
2522 {
2523         unsigned int val;
2524         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2525
2526         val = di->min_vbus;
2527         return sprintf(buf, "%u\n", val);
2528 }
2529
2530 static ssize_t set_current_avg_interval(struct device *dev,
2531           struct device_attribute *attr, const char *buf, size_t count)
2532 {
2533         long val;
2534         int status = count;
2535         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2536
2537         if ((strict_strtol(buf, 10, &val) < 0) || (val < 10) || (val > 3600))
2538                 return -EINVAL;
2539         di->current_avg_interval = val;
2540         twl6030_current_mode_changed(di);
2541
2542         return status;
2543 }
2544
2545 static ssize_t show_current_avg_interval(struct device *dev,
2546                                   struct device_attribute *attr, char *buf)
2547 {
2548         unsigned int val;
2549         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2550
2551         val = di->current_avg_interval;
2552         return sprintf(buf, "%u\n", val);
2553 }
2554
2555 static ssize_t set_wakelock_enable(struct device *dev,
2556           struct device_attribute *attr, const char *buf, size_t count)
2557 {
2558         long val;
2559         int status = count;
2560         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2561
2562         if ((strict_strtol(buf, 10, &val) < 0) || (val < 0) || (val > 1))
2563                 return -EINVAL;
2564
2565         if ((val) && (di->charger_source == POWER_SUPPLY_TYPE_MAINS))
2566                 wake_lock(&chrg_lock);
2567         else
2568                 wake_unlock(&chrg_lock);
2569
2570         di->wakelock_enabled = val;
2571         return status;
2572 }
2573
2574 static ssize_t show_wakelock_enable(struct device *dev,
2575                                   struct device_attribute *attr, char *buf)
2576 {
2577         unsigned int val;
2578         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2579
2580         val = di->wakelock_enabled;
2581         return sprintf(buf, "%u\n", val);
2582 }
2583
2584 static ssize_t set_monitoring_interval(struct device *dev,
2585           struct device_attribute *attr, const char *buf, size_t count)
2586 {
2587         long val;
2588         int status = count;
2589         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2590
2591         if ((strict_strtol(buf, 10, &val) < 0) || (val < 10) || (val > 3600))
2592                 return -EINVAL;
2593         di->monitoring_interval = val;
2594         twl6030_work_interval_changed(di);
2595
2596         return status;
2597 }
2598
2599 static ssize_t show_monitoring_interval(struct device *dev,
2600                   struct device_attribute *attr, char *buf)
2601 {
2602         unsigned int val;
2603         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2604
2605         val = di->monitoring_interval;
2606         return sprintf(buf, "%u\n", val);
2607 }
2608
2609 static ssize_t show_bsi(struct device *dev,
2610                   struct device_attribute *attr, char *buf)
2611 {
2612         int val;
2613         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2614
2615         val = twl6030_get_gpadc_conversion(di, 0);
2616         return sprintf(buf, "%d\n", val);
2617 }
2618
2619 static ssize_t show_stat1(struct device *dev,
2620                 struct device_attribute *attr, char *buf)
2621 {
2622         unsigned val;
2623         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2624
2625         val = di->stat1;
2626         return sprintf(buf, "%u\n", val);
2627 }
2628
2629 static ssize_t show_status_int1(struct device *dev,
2630                 struct device_attribute *attr, char *buf)
2631 {
2632         unsigned val;
2633         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2634
2635         val = di->status_int1;
2636         return sprintf(buf, "%u\n", val);
2637 }
2638
2639 static ssize_t show_status_int2(struct device *dev,
2640                 struct device_attribute *attr, char *buf)
2641 {
2642         unsigned val;
2643         struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2644
2645         val = di->status_int2;
2646         return sprintf(buf, "%u\n", val);
2647 }
2648
2649 static DEVICE_ATTR(fg_mode, S_IWUSR | S_IRUGO, show_fg_mode, set_fg_mode);
2650 static DEVICE_ATTR(charge_src, S_IWUSR | S_IRUGO, show_charge_src,
2651                 set_charge_src);
2652 static DEVICE_ATTR(vbus_voltage, S_IRUGO, show_vbus_voltage, NULL);
2653 static DEVICE_ATTR(id_level, S_IRUGO, show_id_level, NULL);
2654 static DEVICE_ATTR(watchdog, S_IWUSR | S_IRUGO, show_watchdog, set_watchdog);
2655 static DEVICE_ATTR(fg_counter, S_IRUGO, show_fg_counter, NULL);
2656 static DEVICE_ATTR(fg_accumulator, S_IRUGO, show_fg_accumulator, NULL);
2657 static DEVICE_ATTR(fg_offset, S_IRUGO, show_fg_offset, NULL);
2658 static DEVICE_ATTR(fg_clear, S_IWUSR, NULL, set_fg_clear);
2659 static DEVICE_ATTR(fg_cal, S_IWUSR, NULL, set_fg_cal);
2660 static DEVICE_ATTR(charging, S_IWUSR | S_IRUGO, NULL, set_charging);
2661 static DEVICE_ATTR(regulation_voltage, S_IWUSR | S_IRUGO,
2662                 show_regulation_voltage, set_regulation_voltage);
2663 static DEVICE_ATTR(termination_current, S_IWUSR | S_IRUGO,
2664                 show_termination_current, set_termination_current);
2665 static DEVICE_ATTR(cin_limit, S_IWUSR | S_IRUGO, show_cin_limit,
2666                 set_cin_limit);
2667 static DEVICE_ATTR(charge_current, S_IWUSR | S_IRUGO, show_charge_current,
2668                 set_charge_current);
2669 static DEVICE_ATTR(min_vbus, S_IWUSR | S_IRUGO, show_min_vbus, set_min_vbus);
2670 static DEVICE_ATTR(monitoring_interval, S_IWUSR | S_IRUGO,
2671                 show_monitoring_interval, set_monitoring_interval);
2672 static DEVICE_ATTR(current_avg_interval, S_IWUSR | S_IRUGO,
2673                 show_current_avg_interval, set_current_avg_interval);
2674 static DEVICE_ATTR(wakelock_enable, S_IWUSR | S_IRUGO,
2675                 show_wakelock_enable, set_wakelock_enable);
2676 static DEVICE_ATTR(bsi, S_IRUGO, show_bsi, NULL);
2677 static DEVICE_ATTR(stat1, S_IRUGO, show_stat1, NULL);
2678 static DEVICE_ATTR(status_int1, S_IRUGO, show_status_int1, NULL);
2679 static DEVICE_ATTR(status_int2, S_IRUGO, show_status_int2, NULL);
2680
2681 static struct attribute *twl6030_bci_attributes[] = {
2682         &dev_attr_fg_mode.attr,
2683         &dev_attr_charge_src.attr,
2684         &dev_attr_vbus_voltage.attr,
2685         &dev_attr_id_level.attr,
2686         &dev_attr_watchdog.attr,
2687         &dev_attr_fg_counter.attr,
2688         &dev_attr_fg_accumulator.attr,
2689         &dev_attr_fg_offset.attr,
2690         &dev_attr_fg_clear.attr,
2691         &dev_attr_fg_cal.attr,
2692         &dev_attr_charging.attr,
2693         &dev_attr_regulation_voltage.attr,
2694         &dev_attr_termination_current.attr,
2695         &dev_attr_cin_limit.attr,
2696         &dev_attr_charge_current.attr,
2697         &dev_attr_min_vbus.attr,
2698         &dev_attr_monitoring_interval.attr,
2699         &dev_attr_current_avg_interval.attr,
2700         &dev_attr_bsi.attr,
2701         &dev_attr_stat1.attr,
2702         &dev_attr_status_int1.attr,
2703         &dev_attr_status_int2.attr,
2704         &dev_attr_wakelock_enable.attr,
2705         NULL,
2706 };
2707
2708 static const struct attribute_group twl6030_bci_attr_group = {
2709         .attrs = twl6030_bci_attributes,
2710 };
2711
2712 static char *twl6030_bci_supplied_to[] = {
2713         "twl6030_battery",
2714 };
2715
2716 extern int dwc_vbus_status(void);
2717
2718 static void twl6030_battery_update_status(struct twl6030_bci_device_info *di)
2719 {
2720         power_supply_changed(&di->bat);
2721         power_supply_changed(&di->usb);
2722         power_supply_changed(&di->ac);
2723
2724 }
2725 static void twl6030_battery_work(struct work_struct *work)
2726 {
2727
2728         struct twl6030_bci_device_info *di = container_of(work, struct twl6030_bci_device_info, work.work);
2729         twl6030_battery_update_status(di);
2730         //set charging current
2731                 twl_i2c_write_u8(TWL6030_MODULE_CHARGER,0x00,CHARGERUSB_CTRL1);
2732                 if(2 == dwc_vbus_status()){
2733                         twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0x2e,CHARGERUSB_CINLIMIT);     //set vbus input current is 1.5A
2734                         twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0x0b,CHARGERUSB_VICHRG);       //set mos output current is 1A
2735                 }
2736                 else if(1 == dwc_vbus_status()){
2737                         twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0x2e,CHARGERUSB_CINLIMIT);//set vbus input current is 500ma
2738                         twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0x09,CHARGERUSB_VICHRG);       //set mos output current is 500ma
2739                 }
2740         /* reschedule for the next time */
2741         queue_delayed_work(di->freezable_work, &di->work, di->interval);
2742 }
2743
2744 static int __devinit twl6030_bci_battery_probe(struct platform_device *pdev)
2745 {
2746         struct twl4030_bci_platform_data *pdata = pdev->dev.platform_data;
2747         struct twl6030_bci_device_info *di;
2748         int irq;
2749         int ret;
2750         u8 controller_stat = 0;
2751         u8 chargerusb_ctrl1 = 0;
2752         u8 hw_state = 0;
2753         u8 reg = 0;
2754         //printk("%s\n", __func__);
2755         if (!pdata) {
2756                 dev_info(&pdev->dev, "platform_data not available\n");
2757                 return -EINVAL;
2758         }
2759
2760         di = kzalloc(sizeof(*di), GFP_KERNEL);
2761         if (!di)
2762                 return -ENOMEM;
2763
2764         di->platform_data = kmemdup(pdata, sizeof(*pdata), GFP_KERNEL);
2765         if (!di->platform_data) {
2766                 kfree(di);
2767                 return -ENOMEM;
2768         }
2769
2770         if (pdata->monitoring_interval == 0) {
2771                 di->monitoring_interval = 10;
2772                 di->current_avg_interval = 10;
2773         } else {
2774                 di->monitoring_interval = pdata->monitoring_interval;
2775                 di->current_avg_interval = pdata->monitoring_interval;
2776         }
2777
2778         di->platform_data = pdata;
2779         di->features = pdata->features;
2780         di->dev = &pdev->dev;
2781
2782
2783 //      printk("di->feature = %d, TWL6032_SUBCLASS = %d\n",di->features,TWL6032_SUBCLASS);
2784         if (di->features & TWL6032_SUBCLASS) {
2785                 ret = twl_i2c_read_u8(TWL_MODULE_RTC, &reg, CHARGER_MODE_REG);
2786                 if (ret)
2787                         goto temp_setup_fail;
2788
2789                 if (reg & CHARGER_MODE_POWERPATH) {
2790                         dev_dbg(di->dev, "Charger: PowerPath\n");
2791                         di->use_power_path = 1;
2792                 } else {
2793                         dev_dbg(di->dev, "Charger: NON PowerPath\n");
2794                         di->use_power_path = 0;
2795                 }
2796
2797                 if (reg & CHARGER_MODE_AUTOCHARGE) {
2798                         dev_dbg(di->dev, "Charger: AutoCharge\n");
2799                         di->use_hw_charger = 1;
2800                 } else {
2801                         dev_dbg(di->dev, "Charger: NON AutoCharge\n");
2802                         di->use_hw_charger = 0;
2803                 }
2804         } else {
2805                 di->use_power_path = 0;
2806                 di->use_hw_charger = 0;
2807         }
2808 //      printk("di->feature = %d, TWL6032_SUBCLASS = %d,di->use_hw_charger =%d \n",di->features,TWL6032_SUBCLASS,di->use_hw_charger );
2809
2810
2811         if (di->use_hw_charger) {
2812                 di->platform_data->max_charger_currentmA =
2813                                 twl6030_get_limit2_reg(di);
2814                 di->platform_data->max_charger_voltagemV =
2815                                 twl6030_get_limit1_reg(di);
2816                 di->platform_data->termination_currentmA =
2817                                 twl6030_get_iterm_reg(di);
2818                 di->platform_data->max_bat_voltagemV =
2819                                 twl6030_get_voreg_reg(di);
2820         }
2821 //      printk("max_charger_currentmA = %d, max_charger_voltagemV = %d\n,termination_currentmA =%d, max_bat_voltagemV =%d \n",di->platform_data->max_charger_currentmA ,
2822 //              di->platform_data->max_charger_voltagemV,di->platform_data->termination_currentmA, di->platform_data->max_bat_voltagemV);
2823         di->bat.name = "twl6030_battery";
2824         di->bat.supplied_to = twl6030_bci_supplied_to;
2825         di->bat.num_supplicants = ARRAY_SIZE(twl6030_bci_supplied_to);
2826         di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
2827         di->bat.properties = twl6030_bci_battery_props;
2828         di->bat.num_properties = ARRAY_SIZE(twl6030_bci_battery_props);
2829         di->bat.get_property = twl6030_bci_battery_get_property;
2830         //di->bat.external_power_changed =
2831         //              twl6030_bci_battery_external_power_changed;
2832         di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
2833
2834         di->usb.name = "twl6030_usb";
2835         di->usb.type = POWER_SUPPLY_TYPE_USB;
2836         di->usb.properties = twl6030_usb_props;
2837         di->usb.num_properties = ARRAY_SIZE(twl6030_usb_props);
2838         di->usb.get_property = twl6030_usb_get_property;
2839
2840         di->ac.name = "twl6030_ac";
2841         di->ac.type = POWER_SUPPLY_TYPE_MAINS;
2842         di->ac.properties = twl6030_ac_props;
2843         di->ac.num_properties = ARRAY_SIZE(twl6030_ac_props);
2844         di->ac.get_property = twl6030_ac_get_property;
2845
2846         di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
2847
2848         di->bk_bat.name = "twl6030_bk_battery";
2849         di->bk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
2850         di->bk_bat.properties = twl6030_bk_bci_battery_props;
2851         di->bk_bat.num_properties = ARRAY_SIZE(twl6030_bk_bci_battery_props);
2852         di->bk_bat.get_property = twl6030_bk_bci_battery_get_property;
2853
2854         di->vac_priority = 2;
2855         di->capacity = -1;
2856         di->capacity_debounce_count = 0;
2857         di->ac_next_refresh = jiffies - 1;
2858         platform_set_drvdata(pdev, di);
2859
2860         /* calculate current max scale from sense */
2861         if (pdata->sense_resistor_mohm) {
2862                 di->current_max_scale = (62000) / pdata->sense_resistor_mohm;
2863         } else {
2864                 /* Set sensible defaults if platform data is missing */
2865                 if (di->features & TWL6032_SUBCLASS)
2866                         di->current_max_scale = 3100;
2867                 else
2868                         di->current_max_scale = 6200;
2869         }
2870
2871         wake_lock_init(&chrg_lock, WAKE_LOCK_SUSPEND, "ac_chrg_wake_lock");
2872         /* settings for temperature sensing */
2873         ret = twl6030battery_temp_setup(true);
2874         if (ret)
2875                 goto temp_setup_fail;
2876
2877         /* request charger fault interruption choosing between sw/hw mode */
2878         irq = platform_get_irq(pdev, 1);
2879         if (!di->use_hw_charger)
2880                 ret = request_threaded_irq(irq, NULL,
2881                                 twl6030charger_fault_interrupt,
2882                                 0, "twl_bci_fault", di);
2883         else
2884                 ret = request_threaded_irq(irq, NULL,
2885                                 twl6032charger_fault_interrupt_hw,
2886                                 0, "twl_bci_fault", di);
2887
2888         if (ret) {
2889                 dev_info(&pdev->dev, "could not request irq %d, status %d\n",
2890                         irq, ret);
2891                 goto temp_setup_fail;
2892         }
2893
2894         /* request charger ctrl interruption choosing between sw/hw mode */
2895         irq = platform_get_irq(pdev, 0);
2896         if (!di->use_hw_charger)
2897                 ret = request_threaded_irq(irq, NULL,
2898                                 twl6030charger_ctrl_interrupt,
2899                                 0, "twl_bci_ctrl", di);
2900         else
2901                 ret = request_threaded_irq(irq, NULL,
2902                                 twl6032charger_ctrl_interrupt_hw,
2903                                 0, "twl_bci_ctrl", di);  // Ò»Ö±ÔÚ¼ì²âµç³ØµÄ×´Ì¬
2904
2905         if (ret) {
2906                 dev_info(&pdev->dev, "could not request irq %d, status %d\n",
2907                         irq, ret);
2908                 goto chg_irq_fail;
2909         }
2910
2911         ret = power_supply_register(&pdev->dev, &di->bat);
2912         if (ret) {
2913                 dev_info(&pdev->dev, "failed to register main battery\n");
2914                 goto batt_failed;
2915         }
2916
2917         ret = power_supply_register(&pdev->dev, &di->usb);
2918         if (ret) {
2919                 dev_info(&pdev->dev, "failed to register usb power supply\n");
2920                 goto usb_failed;
2921         }
2922
2923         ret = power_supply_register(&pdev->dev, &di->ac);
2924         if (ret) {
2925                 dev_info(&pdev->dev, "failed to register ac power supply\n");
2926                 goto ac_failed;
2927         }
2928
2929         ret = power_supply_register(&pdev->dev, &di->bk_bat);
2930         if (ret) {
2931                 dev_info(&pdev->dev, "failed to register backup battery\n");
2932                 goto bk_batt_failed;
2933         }
2934         di->charge_n1 = 0;
2935         di->timer_n1 = 0;
2936
2937         //di->freezable_work = create_freezable_workqueue("battery");
2938 #if 1
2939         if (di->features & TWL6032_SUBCLASS) {
2940                 di->charger_incurrentmA = 1000;
2941                 di->gpadc_vbat_chnl = TWL6032_GPADC_VBAT_CHNL;
2942         } else {
2943                 di->charger_incurrentmA = twl6030_get_usb_max_power(di->otg);
2944                 di->gpadc_vbat_chnl = TWL6030_GPADC_VBAT_CHNL;
2945         }
2946 #endif
2947 #if 1
2948
2949         ret = twl6030battery_voltage_setup(di);
2950         if (ret)
2951                 dev_info(&pdev->dev, "voltage measurement setup failed\n");
2952
2953         ret = twl6030battery_current_setup(true);
2954         if (ret)
2955                 dev_info(&pdev->dev, "current measurement setup failed\n");
2956
2957
2958         di->voltage_mV = twl6030_get_gpadc_conversion(di, di->gpadc_vbat_chnl);
2959         di->voltage_mV = twl6030_get_gpadc_conversion(di, di->gpadc_vbat_chnl);
2960         di->capacity = twl6030_batt_vol_to_capacity( di);
2961         twl6030battery_current(di);
2962 #endif
2963         di->freezable_work = system_freezable_wq;
2964         INIT_DELAYED_WORK(&di->twl6030_bci_monitor_work,
2965                                 twl6030_bci_battery_work);
2966         queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work, 0);
2967 #if 1
2968         INIT_DELAYED_WORK_DEFERRABLE(&di->twl6030_current_avg_work,
2969                                                 twl6030_current_avg);
2970         queue_delayed_work(di->freezable_work, &di->twl6030_current_avg_work, 500);
2971 #endif
2972 #if 0
2973         ret = twl6030battery_voltage_setup(di);
2974         if (ret)
2975                 dev_info(&pdev->dev, "voltage measurement setup failed\n");
2976
2977         ret = twl6030battery_current_setup(true);
2978         if (ret)
2979                 dev_info(&pdev->dev, "current measurement setup failed\n");
2980 #endif
2981
2982 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2983         /* initialize for USB charging */
2984         if (!di->use_hw_charger) {
2985                 twl6030_config_limit1_reg(di, pdata->max_charger_voltagemV);
2986                 twl6030_config_limit2_reg(di,
2987                                 di->platform_data->max_charger_currentmA);
2988         }
2989         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MBAT_TEMP,
2990                                                 CONTROLLER_INT_MASK);
2991         if (ret)
2992                 goto bk_batt_failed;
2993
2994         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MASK_MCHARGERUSB_THMREG,
2995                                                 CHARGERUSB_INT_MASK);
2996         if (ret)
2997                 goto bk_batt_failed;
2998
2999         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &controller_stat,
3000                 CONTROLLER_STAT1);
3001         if (ret)
3002                 goto bk_batt_failed;
3003
3004         di->stat1 = controller_stat;
3005         di->charger_outcurrentmA = di->platform_data->max_charger_currentmA;
3006
3007         twl6030_set_watchdog(di, 32);
3008
3009         INIT_WORK(&di->usb_work, twl6030_usb_charger_work);
3010         di->nb.notifier_call = twl6030_usb_notifier_call;
3011         di->otg = otg_get_transceiver();
3012         if (di->otg) {
3013                 ret = otg_register_notifier(di->otg, &di->nb);
3014                 if (ret)
3015                         dev_err(&pdev->dev, "otg register notifier"
3016                                                 " failed %d\n", ret);
3017         } else
3018                 dev_err(&pdev->dev, "otg_get_transceiver failed %d\n", ret);
3019
3020
3021         if (di->features & TWL6032_SUBCLASS) {
3022                 di->charger_incurrentmA = 1000;
3023                 di->gpadc_vbat_chnl = TWL6032_GPADC_VBAT_CHNL;
3024         } else {
3025                 di->charger_incurrentmA = twl6030_get_usb_max_power(di->otg);
3026                 di->gpadc_vbat_chnl = TWL6030_GPADC_VBAT_CHNL;
3027         }
3028
3029         di->voltage_mV = twl6030_get_gpadc_conversion(di, di->gpadc_vbat_chnl);
3030         dev_info(&pdev->dev, "Battery Voltage at Bootup is %d mV\n",
3031                                                         di->voltage_mV);
3032
3033         ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &hw_state, STS_HW_CONDITIONS);
3034         if (ret)
3035                 goto  bk_batt_failed;
3036         if (!is_battery_present(di)) {
3037                 if (!(hw_state & STS_USB_ID)) {
3038                         dev_dbg(di->dev, "Put USB in HZ mode\n");
3039                         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER,
3040                                         &chargerusb_ctrl1, CHARGERUSB_CTRL1);
3041                         if (ret)
3042                                 goto  bk_batt_failed;
3043
3044                         chargerusb_ctrl1 |= HZ_MODE;  // high-impedance
3045                         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
3046                                          chargerusb_ctrl1, CHARGERUSB_CTRL1);
3047                         if (ret)
3048                                 goto  bk_batt_failed;
3049                 }
3050         } else if (!di->use_hw_charger) {
3051                 if (controller_stat & VAC_DET) {
3052                         di->ac_online = POWER_SUPPLY_TYPE_MAINS;
3053                         twl6030_start_ac_charger(di);
3054                 } else if (controller_stat & VBUS_DET) {
3055                         /*
3056                          * In HOST mode (ID GROUND) with a device connected,
3057                          * do no enable usb charging
3058                          */
3059                         if (!(hw_state & STS_USB_ID)) {
3060                                 di->usb_online = POWER_SUPPLY_TYPE_USB;
3061                                 di->charger_source = POWER_SUPPLY_TYPE_USB;
3062                                 di->charge_status =
3063                                                 POWER_SUPPLY_STATUS_CHARGING;
3064                                 di->event = USB_EVENT_VBUS;
3065                                 schedule_work(&di->usb_work);
3066                         }
3067                 }
3068         } else {
3069                 int fault, charge_usb, charge_ac;
3070
3071                 twl_i2c_read_u8(TWL6032_MODULE_CHARGER, &reg,
3072                                 CHARGERUSB_INT_STATUS);
3073
3074                 fault = !(di->stat1 & CONTROLLER_STAT1_LINCH_GATED) &&
3075                                 !(di->stat1 & CONTROLLER_STAT1_FAULT_WDG);
3076                 charge_usb = (di->stat1 & VBUS_DET) &&
3077                                 !(reg & CHARGERUSB_FAULT);
3078                 charge_ac = (di->stat1 & VAC_DET) &&
3079                                 !(di->stat1 & CONTROLLER_STAT1_EXTCHRG_STATZ);
3080
3081                 dev_dbg(di->dev, "boot charge state fault %d, usb %d, ac %d\n",
3082                                 fault, charge_usb, charge_ac);
3083
3084                 if (fault && (charge_usb || charge_ac))
3085                         di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
3086                 else {
3087                         if (di->stat1 & (VBUS_DET | VAC_DET))
3088                                 di->charge_status =
3089                                         POWER_SUPPLY_STATUS_NOT_CHARGING;
3090                         else
3091                                 di->charge_status =
3092                                         POWER_SUPPLY_STATUS_DISCHARGING;
3093                 }
3094         }
3095 #if 1
3096         di->interval = msecs_to_jiffies(1 * 1000);
3097         INIT_DELAYED_WORK(&di->work, twl6030_battery_work);
3098         queue_delayed_work(di->freezable_work, &di->work, 1*HZ);
3099 #endif
3100         ret = twl6030backupbatt_setup();
3101         if (ret)
3102                 dev_info(&pdev->dev, "Backup Bat charging setup failed\n");
3103
3104         twl6030_interrupt_unmask(TWL6030_CHARGER_CTRL_INT_MASK,
3105                                                 REG_INT_MSK_LINE_C);
3106         twl6030_interrupt_unmask(TWL6030_CHARGER_CTRL_INT_MASK,
3107                                                 REG_INT_MSK_STS_C);
3108         twl6030_interrupt_unmask(TWL6030_CHARGER_FAULT_INT_MASK,
3109                                                 REG_INT_MSK_LINE_C);
3110         twl6030_interrupt_unmask(TWL6030_CHARGER_FAULT_INT_MASK,
3111                                                 REG_INT_MSK_STS_C);
3112
3113         ret = sysfs_create_group(&pdev->dev.kobj, &twl6030_bci_attr_group);
3114         if (ret)
3115                 dev_info(&pdev->dev, "could not create sysfs files\n");
3116
3117         return 0;
3118
3119 bk_batt_failed:
3120         cancel_delayed_work(&di->twl6030_bci_monitor_work);
3121         power_supply_unregister(&di->ac);
3122 ac_failed:
3123         power_supply_unregister(&di->usb);
3124 usb_failed:
3125         power_supply_unregister(&di->bat);
3126 batt_failed:
3127         free_irq(irq, di);
3128 chg_irq_fail:
3129         irq = platform_get_irq(pdev, 1);
3130         free_irq(irq, di);
3131 temp_setup_fail:
3132         wake_lock_destroy(&chrg_lock);
3133         platform_set_drvdata(pdev, NULL);
3134         kfree(di);
3135
3136         return ret;
3137 }
3138
3139 static int __devexit twl6030_bci_battery_remove(struct platform_device *pdev)
3140 {
3141         struct twl6030_bci_device_info *di = platform_get_drvdata(pdev);
3142         int irq;
3143
3144         twl6030_interrupt_mask(TWL6030_CHARGER_CTRL_INT_MASK,
3145                                                 REG_INT_MSK_LINE_C);
3146         twl6030_interrupt_mask(TWL6030_CHARGER_CTRL_INT_MASK,
3147                                                 REG_INT_MSK_STS_C);
3148         twl6030_interrupt_mask(TWL6030_CHARGER_FAULT_INT_MASK,
3149                                                 REG_INT_MSK_LINE_C);
3150         twl6030_interrupt_mask(TWL6030_CHARGER_FAULT_INT_MASK,
3151                                                 REG_INT_MSK_STS_C);
3152
3153         irq = platform_get_irq(pdev, 0);
3154         free_irq(irq, di);
3155
3156         irq = platform_get_irq(pdev, 1);
3157         free_irq(irq, di);
3158
3159         otg_unregister_notifier(di->otg, &di->nb);
3160         sysfs_remove_group(&pdev->dev.kobj, &twl6030_bci_attr_group);
3161         cancel_delayed_work(&di->twl6030_bci_monitor_work);
3162         cancel_delayed_work(&di->twl6030_current_avg_work);
3163         flush_scheduled_work();
3164         power_supply_unregister(&di->bat);
3165         power_supply_unregister(&di->usb);
3166         power_supply_unregister(&di->ac);
3167         power_supply_unregister(&di->bk_bat);
3168         wake_lock_destroy(&chrg_lock);
3169         platform_set_drvdata(pdev, NULL);
3170         kfree(di->platform_data);
3171         kfree(di);
3172
3173         return 0;
3174 }
3175
3176 #ifdef CONFIG_PM
3177 static int twl6030_bci_battery_suspend(struct device *dev)
3178 {
3179 //      struct platform_device *pdev = to_platform_device(dev);
3180 //      struct twl6030_bci_device_info *di = platform_get_drvdata(pdev);
3181         long int events;
3182         u8 rd_reg = 0;
3183         int ret;
3184
3185         /* mask to prevent wakeup due to 32s timeout from External charger */
3186         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &rd_reg,
3187                                                 CONTROLLER_INT_MASK);
3188         if (ret)
3189                 goto err;
3190
3191         rd_reg |= MVAC_FAULT;
3192         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MBAT_TEMP,
3193                                                 CONTROLLER_INT_MASK);
3194         if (ret)
3195                 goto err;
3196
3197         //cancel_delayed_work(&di->work);
3198         //cancel_delayed_work(&di->twl6030_bci_monitor_work);
3199         //cancel_delayed_work(&di->twl6030_current_avg_work);
3200
3201         /* We cannot tolarate a sleep longer than 30 seconds
3202          * while on ac charging we have to reset the BQ watchdog timer.
3203          */
3204 //      if ((di->charger_source == POWER_SUPPLY_TYPE_MAINS) &&
3205 //              ((wakeup_timer_seconds > 25) || !wakeup_timer_seconds)) {
3206 //              wakeup_timer_seconds = 25;
3207 //      }
3208
3209         /*reset the BQ watch dog*/
3210         events = BQ2415x_RESET_TIMER;
3211         blocking_notifier_call_chain(&notifier_list, events, NULL);
3212
3213         ret = twl6030battery_temp_setup(false);
3214         if (ret) {
3215                 pr_err("%s: Temp measurement setup failed (%d)!\n",
3216                                 __func__, ret);
3217                 return ret;
3218         }
3219
3220         ret = twl6030battery_current_setup(false);
3221         if (ret) {
3222                 pr_err("%s: Current measurement setup failed (%d)!\n",
3223                                 __func__, ret);
3224                 return ret;
3225         }
3226
3227         return 0;
3228 err:
3229         pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
3230         return ret;
3231 }
3232
3233 static int twl6030_bci_battery_resume(struct device *dev)
3234 {
3235 //      struct platform_device *pdev = to_platform_device(dev);
3236 //      struct twl6030_bci_device_info *di = platform_get_drvdata(pdev);
3237         long int events;
3238         u8 rd_reg = 0;
3239         int ret;
3240
3241         ret = twl6030battery_temp_setup(true);
3242         if (ret) {
3243                 pr_err("%s: Temp measurement setup failed (%d)!\n",
3244                                 __func__, ret);
3245                 return ret;
3246         }
3247
3248         ret = twl6030battery_current_setup(true);
3249         if (ret) {
3250                 pr_err("%s: Current measurement setup failed (%d)!\n",
3251                                 __func__, ret);
3252                 return ret;
3253         }
3254
3255         ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &rd_reg, CONTROLLER_INT_MASK);
3256         if (ret)
3257                 goto err;
3258
3259         rd_reg &= ~(0xFF & MVAC_FAULT);
3260         ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MBAT_TEMP,
3261                                                 CONTROLLER_INT_MASK);
3262         if (ret)
3263                 goto err;
3264
3265         //queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work, 0);
3266         //queue_delayed_work(di->freezable_work, &di->twl6030_current_avg_work, 50);
3267         //queue_delayed_work(di->freezable_work, &di->work, di->interval);
3268
3269         events = BQ2415x_RESET_TIMER;
3270         blocking_notifier_call_chain(&notifier_list, events, NULL);
3271
3272         return 0;
3273 err:
3274         pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
3275         return ret;
3276 }
3277 #else
3278 #define twl6030_bci_battery_suspend     NULL
3279 #define twl6030_bci_battery_resume      NULL
3280 #endif /* CONFIG_PM */
3281
3282 static const struct dev_pm_ops pm_ops = {
3283         .suspend        = twl6030_bci_battery_suspend,
3284         .resume         = twl6030_bci_battery_resume,
3285 };
3286
3287 static struct platform_driver twl6030_bci_battery_driver = {
3288         .probe          = twl6030_bci_battery_probe,
3289         .remove         = __devexit_p(twl6030_bci_battery_remove),
3290         .driver         = {
3291                 .name   = "twl6030_bci",
3292                 .pm     = &pm_ops,
3293         },
3294 };
3295
3296 static int __init twl6030_battery_init(void)
3297 {
3298         return platform_driver_register(&twl6030_bci_battery_driver);
3299 }
3300 module_init(twl6030_battery_init);
3301
3302 static void __exit twl6030_battery_exit(void)
3303 {
3304         platform_driver_unregister(&twl6030_bci_battery_driver);
3305 }
3306 module_exit(twl6030_battery_exit);
3307
3308 MODULE_LICENSE("GPL");
3309 MODULE_ALIAS("platform:twl6030_bci");
3310 MODULE_AUTHOR("Texas Instruments Inc");