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