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