drivers/power/supply/bq24190_charger.c

   1 /*
   2  * Driver for the TI bq24190 battery charger.
   3  *
   4  * Author: Mark A. Greer <mgreer@animalcreek.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/delay.h>
  14 #include <linux/extcon.h>
  15 #include <linux/of_irq.h>
  16 #include <linux/of_device.h>
  17 #include <linux/pm_runtime.h>
  18 #include <linux/power_supply.h>
  19 #include <linux/power/bq24190_charger.h>
  20 #include <linux/regulator/driver.h>
  21 #include <linux/regulator/machine.h>
  22 #include <linux/workqueue.h>
  23 #include <linux/gpio.h>
  24 #include <linux/i2c.h>
  25
  26 #define BQ24190_MANUFACTURER    "Texas Instruments"
  27
  28 #define BQ24190_REG_ISC         0x00 /* Input Source Control */
  29 #define BQ24190_REG_ISC_EN_HIZ_MASK             BIT(7)
  30 #define BQ24190_REG_ISC_EN_HIZ_SHIFT            7
  31 #define BQ24190_REG_ISC_VINDPM_MASK             (BIT(6) | BIT(5) | BIT(4) | \
  32                                                  BIT(3))
  33 #define BQ24190_REG_ISC_VINDPM_SHIFT            3
  34 #define BQ24190_REG_ISC_IINLIM_MASK             (BIT(2) | BIT(1) | BIT(0))
  35 #define BQ24190_REG_ISC_IINLIM_SHIFT            0
  36
  37 #define BQ24190_REG_POC         0x01 /* Power-On Configuration */
  38 #define BQ24190_REG_POC_RESET_MASK              BIT(7)
  39 #define BQ24190_REG_POC_RESET_SHIFT             7
  40 #define BQ24190_REG_POC_WDT_RESET_MASK          BIT(6)
  41 #define BQ24190_REG_POC_WDT_RESET_SHIFT         6
  42 #define BQ24190_REG_POC_CHG_CONFIG_MASK         (BIT(5) | BIT(4))
  43 #define BQ24190_REG_POC_CHG_CONFIG_SHIFT        4
  44 #define BQ24190_REG_POC_CHG_CONFIG_DISABLE              0x0
  45 #define BQ24190_REG_POC_CHG_CONFIG_CHARGE               0x1
  46 #define BQ24190_REG_POC_CHG_CONFIG_OTG                  0x2
  47 #define BQ24190_REG_POC_CHG_CONFIG_OTG_ALT              0x3
  48 #define BQ24190_REG_POC_SYS_MIN_MASK            (BIT(3) | BIT(2) | BIT(1))
  49 #define BQ24190_REG_POC_SYS_MIN_SHIFT           1
  50 #define BQ24190_REG_POC_SYS_MIN_MIN                     3000
  51 #define BQ24190_REG_POC_SYS_MIN_MAX                     3700
  52 #define BQ24190_REG_POC_BOOST_LIM_MASK          BIT(0)
  53 #define BQ24190_REG_POC_BOOST_LIM_SHIFT         0
  54
  55 #define BQ24190_REG_CCC         0x02 /* Charge Current Control */
  56 #define BQ24190_REG_CCC_ICHG_MASK               (BIT(7) | BIT(6) | BIT(5) | \
  57                                                  BIT(4) | BIT(3) | BIT(2))
  58 #define BQ24190_REG_CCC_ICHG_SHIFT              2
  59 #define BQ24190_REG_CCC_FORCE_20PCT_MASK        BIT(0)
  60 #define BQ24190_REG_CCC_FORCE_20PCT_SHIFT       0
  61
  62 #define BQ24190_REG_PCTCC       0x03 /* Pre-charge/Termination Current Cntl */
  63 #define BQ24190_REG_PCTCC_IPRECHG_MASK          (BIT(7) | BIT(6) | BIT(5) | \
  64                                                  BIT(4))
  65 #define BQ24190_REG_PCTCC_IPRECHG_SHIFT         4
  66 #define BQ24190_REG_PCTCC_IPRECHG_MIN                   128
  67 #define BQ24190_REG_PCTCC_IPRECHG_MAX                   2048
  68 #define BQ24190_REG_PCTCC_ITERM_MASK            (BIT(3) | BIT(2) | BIT(1) | \
  69                                                  BIT(0))
  70 #define BQ24190_REG_PCTCC_ITERM_SHIFT           0
  71 #define BQ24190_REG_PCTCC_ITERM_MIN                     128
  72 #define BQ24190_REG_PCTCC_ITERM_MAX                     2048
  73
  74 #define BQ24190_REG_CVC         0x04 /* Charge Voltage Control */
  75 #define BQ24190_REG_CVC_VREG_MASK               (BIT(7) | BIT(6) | BIT(5) | \
  76                                                  BIT(4) | BIT(3) | BIT(2))
  77 #define BQ24190_REG_CVC_VREG_SHIFT              2
  78 #define BQ24190_REG_CVC_BATLOWV_MASK            BIT(1)
  79 #define BQ24190_REG_CVC_BATLOWV_SHIFT           1
  80 #define BQ24190_REG_CVC_VRECHG_MASK             BIT(0)
  81 #define BQ24190_REG_CVC_VRECHG_SHIFT            0
  82
  83 #define BQ24190_REG_CTTC        0x05 /* Charge Term/Timer Control */
  84 #define BQ24190_REG_CTTC_EN_TERM_MASK           BIT(7)
  85 #define BQ24190_REG_CTTC_EN_TERM_SHIFT          7
  86 #define BQ24190_REG_CTTC_TERM_STAT_MASK         BIT(6)
  87 #define BQ24190_REG_CTTC_TERM_STAT_SHIFT        6
  88 #define BQ24190_REG_CTTC_WATCHDOG_MASK          (BIT(5) | BIT(4))
  89 #define BQ24190_REG_CTTC_WATCHDOG_SHIFT         4
  90 #define BQ24190_REG_CTTC_EN_TIMER_MASK          BIT(3)
  91 #define BQ24190_REG_CTTC_EN_TIMER_SHIFT         3
  92 #define BQ24190_REG_CTTC_CHG_TIMER_MASK         (BIT(2) | BIT(1))
  93 #define BQ24190_REG_CTTC_CHG_TIMER_SHIFT        1
  94 #define BQ24190_REG_CTTC_JEITA_ISET_MASK        BIT(0)
  95 #define BQ24190_REG_CTTC_JEITA_ISET_SHIFT       0
  96
  97 #define BQ24190_REG_ICTRC       0x06 /* IR Comp/Thermal Regulation Control */
  98 #define BQ24190_REG_ICTRC_BAT_COMP_MASK         (BIT(7) | BIT(6) | BIT(5))
  99 #define BQ24190_REG_ICTRC_BAT_COMP_SHIFT        5
 100 #define BQ24190_REG_ICTRC_VCLAMP_MASK           (BIT(4) | BIT(3) | BIT(2))
 101 #define BQ24190_REG_ICTRC_VCLAMP_SHIFT          2
 102 #define BQ24190_REG_ICTRC_TREG_MASK             (BIT(1) | BIT(0))
 103 #define BQ24190_REG_ICTRC_TREG_SHIFT            0
 104
 105 #define BQ24190_REG_MOC         0x07 /* Misc. Operation Control */
 106 #define BQ24190_REG_MOC_DPDM_EN_MASK            BIT(7)
 107 #define BQ24190_REG_MOC_DPDM_EN_SHIFT           7
 108 #define BQ24190_REG_MOC_TMR2X_EN_MASK           BIT(6)
 109 #define BQ24190_REG_MOC_TMR2X_EN_SHIFT          6
 110 #define BQ24190_REG_MOC_BATFET_DISABLE_MASK     BIT(5)
 111 #define BQ24190_REG_MOC_BATFET_DISABLE_SHIFT    5
 112 #define BQ24190_REG_MOC_JEITA_VSET_MASK         BIT(4)
 113 #define BQ24190_REG_MOC_JEITA_VSET_SHIFT        4
 114 #define BQ24190_REG_MOC_INT_MASK_MASK           (BIT(1) | BIT(0))
 115 #define BQ24190_REG_MOC_INT_MASK_SHIFT          0
 116
 117 #define BQ24190_REG_SS          0x08 /* System Status */
 118 #define BQ24190_REG_SS_VBUS_STAT_MASK           (BIT(7) | BIT(6))
 119 #define BQ24190_REG_SS_VBUS_STAT_SHIFT          6
 120 #define BQ24190_REG_SS_CHRG_STAT_MASK           (BIT(5) | BIT(4))
 121 #define BQ24190_REG_SS_CHRG_STAT_SHIFT          4
 122 #define BQ24190_REG_SS_DPM_STAT_MASK            BIT(3)
 123 #define BQ24190_REG_SS_DPM_STAT_SHIFT           3
 124 #define BQ24190_REG_SS_PG_STAT_MASK             BIT(2)
 125 #define BQ24190_REG_SS_PG_STAT_SHIFT            2
 126 #define BQ24190_REG_SS_THERM_STAT_MASK          BIT(1)
 127 #define BQ24190_REG_SS_THERM_STAT_SHIFT         1
 128 #define BQ24190_REG_SS_VSYS_STAT_MASK           BIT(0)
 129 #define BQ24190_REG_SS_VSYS_STAT_SHIFT          0
 130
 131 #define BQ24190_REG_F           0x09 /* Fault */
 132 #define BQ24190_REG_F_WATCHDOG_FAULT_MASK       BIT(7)
 133 #define BQ24190_REG_F_WATCHDOG_FAULT_SHIFT      7
 134 #define BQ24190_REG_F_BOOST_FAULT_MASK          BIT(6)
 135 #define BQ24190_REG_F_BOOST_FAULT_SHIFT         6
 136 #define BQ24190_REG_F_CHRG_FAULT_MASK           (BIT(5) | BIT(4))
 137 #define BQ24190_REG_F_CHRG_FAULT_SHIFT          4
 138 #define BQ24190_REG_F_BAT_FAULT_MASK            BIT(3)
 139 #define BQ24190_REG_F_BAT_FAULT_SHIFT           3
 140 #define BQ24190_REG_F_NTC_FAULT_MASK            (BIT(2) | BIT(1) | BIT(0))
 141 #define BQ24190_REG_F_NTC_FAULT_SHIFT           0
 142
 143 #define BQ24190_REG_VPRS        0x0A /* Vendor/Part/Revision Status */
 144 #define BQ24190_REG_VPRS_PN_MASK                (BIT(5) | BIT(4) | BIT(3))
 145 #define BQ24190_REG_VPRS_PN_SHIFT               3
 146 #define BQ24190_REG_VPRS_PN_24190                       0x4
 147 #define BQ24190_REG_VPRS_PN_24192                       0x5 /* Also 24193 */
 148 #define BQ24190_REG_VPRS_PN_24192I                      0x3
 149 #define BQ24190_REG_VPRS_TS_PROFILE_MASK        BIT(2)
 150 #define BQ24190_REG_VPRS_TS_PROFILE_SHIFT       2
 151 #define BQ24190_REG_VPRS_DEV_REG_MASK           (BIT(1) | BIT(0))
 152 #define BQ24190_REG_VPRS_DEV_REG_SHIFT          0
 153
 154 /*
 155  * The FAULT register is latched by the bq24190 (except for NTC_FAULT)
 156  * so the first read after a fault returns the latched value and subsequent
 157  * reads return the current value.  In order to return the fault status
 158  * to the user, have the interrupt handler save the reg's value and retrieve
 159  * it in the appropriate health/status routine.
 160  */
 161 struct bq24190_dev_info {
 162         struct i2c_client               *client;
 163         struct device                   *dev;
 164         struct power_supply             *charger;
 165         struct power_supply             *battery;
 166         struct extcon_dev               *extcon;
 167         struct notifier_block           extcon_nb;
 168         struct delayed_work             extcon_work;
 169         struct delayed_work             input_current_limit_work;
 170         char                            model_name[I2C_NAME_SIZE];
 171         bool                            initialized;
 172         bool                            irq_event;
 173         u16                             sys_min;
 174         u16                             iprechg;
 175         u16                             iterm;
 176         struct mutex                    f_reg_lock;
 177         u8                              f_reg;
 178         u8                              ss_reg;
 179         u8                              watchdog;
 180 };
 181
 182 /*
 183  * The tables below provide a 2-way mapping for the value that goes in
 184  * the register field and the real-world value that it represents.
 185  * The index of the array is the value that goes in the register; the
 186  * number at that index in the array is the real-world value that it
 187  * represents.
 188  */
 189
 190 /* REG00[2:0] (IINLIM) in uAh */
 191 static const int bq24190_isc_iinlim_values[] = {
 192          100000,  150000,  500000,  900000, 1200000, 1500000, 2000000, 3000000
 193 };
 194
 195 /* REG02[7:2] (ICHG) in uAh */
 196 static const int bq24190_ccc_ichg_values[] = {
 197          512000,  576000,  640000,  704000,  768000,  832000,  896000,  960000,
 198         1024000, 1088000, 1152000, 1216000, 1280000, 1344000, 1408000, 1472000,
 199         1536000, 1600000, 1664000, 1728000, 1792000, 1856000, 1920000, 1984000,
 200         2048000, 2112000, 2176000, 2240000, 2304000, 2368000, 2432000, 2496000,
 201         2560000, 2624000, 2688000, 2752000, 2816000, 2880000, 2944000, 3008000,
 202         3072000, 3136000, 3200000, 3264000, 3328000, 3392000, 3456000, 3520000,
 203         3584000, 3648000, 3712000, 3776000, 3840000, 3904000, 3968000, 4032000,
 204         4096000, 4160000, 4224000, 4288000, 4352000, 4416000, 4480000, 4544000
 205 };
 206
 207 /* REG04[7:2] (VREG) in uV */
 208 static const int bq24190_cvc_vreg_values[] = {
 209         3504000, 3520000, 3536000, 3552000, 3568000, 3584000, 3600000, 3616000,
 210         3632000, 3648000, 3664000, 3680000, 3696000, 3712000, 3728000, 3744000,
 211         3760000, 3776000, 3792000, 3808000, 3824000, 3840000, 3856000, 3872000,
 212         3888000, 3904000, 3920000, 3936000, 3952000, 3968000, 3984000, 4000000,
 213         4016000, 4032000, 4048000, 4064000, 4080000, 4096000, 4112000, 4128000,
 214         4144000, 4160000, 4176000, 4192000, 4208000, 4224000, 4240000, 4256000,
 215         4272000, 4288000, 4304000, 4320000, 4336000, 4352000, 4368000, 4384000,
 216         4400000
 217 };
 218
 219 /* REG06[1:0] (TREG) in tenths of degrees Celsius */
 220 static const int bq24190_ictrc_treg_values[] = {
 221         600, 800, 1000, 1200
 222 };
 223
 224 /*
 225  * Return the index in 'tbl' of greatest value that is less than or equal to
 226  * 'val'.  The index range returned is 0 to 'tbl_size' - 1.  Assumes that
 227  * the values in 'tbl' are sorted from smallest to largest and 'tbl_size'
 228  * is less than 2^8.
 229  */
 230 static u8 bq24190_find_idx(const int tbl[], int tbl_size, int v)
 231 {
 232         int i;
 233
 234         for (i = 1; i < tbl_size; i++)
 235                 if (v < tbl[i])
 236                         break;
 237
 238         return i - 1;
 239 }
 240
 241 /* Basic driver I/O routines */
 242
 243 static int bq24190_read(struct bq24190_dev_info *bdi, u8 reg, u8 *data)
 244 {
 245         int ret;
 246
 247         ret = i2c_smbus_read_byte_data(bdi->client, reg);
 248         if (ret < 0)
 249                 return ret;
 250
 251         *data = ret;
 252         return 0;
 253 }
 254
 255 static int bq24190_write(struct bq24190_dev_info *bdi, u8 reg, u8 data)
 256 {
 257         return i2c_smbus_write_byte_data(bdi->client, reg, data);
 258 }
 259
 260 static int bq24190_read_mask(struct bq24190_dev_info *bdi, u8 reg,
 261                 u8 mask, u8 shift, u8 *data)
 262 {
 263         u8 v;
 264         int ret;
 265
 266         ret = bq24190_read(bdi, reg, &v);
 267         if (ret < 0)
 268                 return ret;
 269
 270         v &= mask;
 271         v >>= shift;
 272         *data = v;
 273
 274         return 0;
 275 }
 276
 277 static int bq24190_write_mask(struct bq24190_dev_info *bdi, u8 reg,
 278                 u8 mask, u8 shift, u8 data)
 279 {
 280         u8 v;
 281         int ret;
 282
 283         ret = bq24190_read(bdi, reg, &v);
 284         if (ret < 0)
 285                 return ret;
 286
 287         v &= ~mask;
 288         v |= ((data << shift) & mask);
 289
 290         return bq24190_write(bdi, reg, v);
 291 }
 292
 293 static int bq24190_get_field_val(struct bq24190_dev_info *bdi,
 294                 u8 reg, u8 mask, u8 shift,
 295                 const int tbl[], int tbl_size,
 296                 int *val)
 297 {
 298         u8 v;
 299         int ret;
 300
 301         ret = bq24190_read_mask(bdi, reg, mask, shift, &v);
 302         if (ret < 0)
 303                 return ret;
 304
 305         v = (v >= tbl_size) ? (tbl_size - 1) : v;
 306         *val = tbl[v];
 307
 308         return 0;
 309 }
 310
 311 static int bq24190_set_field_val(struct bq24190_dev_info *bdi,
 312                 u8 reg, u8 mask, u8 shift,
 313                 const int tbl[], int tbl_size,
 314                 int val)
 315 {
 316         u8 idx;
 317
 318         idx = bq24190_find_idx(tbl, tbl_size, val);
 319
 320         return bq24190_write_mask(bdi, reg, mask, shift, idx);
 321 }
 322
 323 #ifdef CONFIG_SYSFS
 324 /*
 325  * There are a numerous options that are configurable on the bq24190
 326  * that go well beyond what the power_supply properties provide access to.
 327  * Provide sysfs access to them so they can be examined and possibly modified
 328  * on the fly.  They will be provided for the charger power_supply object only
 329  * and will be prefixed by 'f_' to make them easier to recognize.
 330  */
 331
 332 #define BQ24190_SYSFS_FIELD(_name, r, f, m, store)                      \
 333 {                                                                       \
 334         .attr   = __ATTR(f_##_name, m, bq24190_sysfs_show, store),      \
 335         .reg    = BQ24190_REG_##r,                                      \
 336         .mask   = BQ24190_REG_##r##_##f##_MASK,                         \
 337         .shift  = BQ24190_REG_##r##_##f##_SHIFT,                        \
 338 }
 339
 340 #define BQ24190_SYSFS_FIELD_RW(_name, r, f)                             \
 341                 BQ24190_SYSFS_FIELD(_name, r, f, S_IWUSR | S_IRUGO,     \
 342                                 bq24190_sysfs_store)
 343
 344 #define BQ24190_SYSFS_FIELD_RO(_name, r, f)                             \
 345                 BQ24190_SYSFS_FIELD(_name, r, f, S_IRUGO, NULL)
 346
 347 static ssize_t bq24190_sysfs_show(struct device *dev,
 348                 struct device_attribute *attr, char *buf);
 349 static ssize_t bq24190_sysfs_store(struct device *dev,
 350                 struct device_attribute *attr, const char *buf, size_t count);
 351
 352 struct bq24190_sysfs_field_info {
 353         struct device_attribute attr;
 354         u8      reg;
 355         u8      mask;
 356         u8      shift;
 357 };
 358
 359 /* On i386 ptrace-abi.h defines SS that breaks the macro calls below. */
 360 #undef SS
 361
 362 static struct bq24190_sysfs_field_info bq24190_sysfs_field_tbl[] = {
 363                         /*      sysfs name      reg     field in reg */
 364         BQ24190_SYSFS_FIELD_RW(en_hiz,          ISC,    EN_HIZ),
 365         BQ24190_SYSFS_FIELD_RW(vindpm,          ISC,    VINDPM),
 366         BQ24190_SYSFS_FIELD_RW(iinlim,          ISC,    IINLIM),
 367         BQ24190_SYSFS_FIELD_RW(chg_config,      POC,    CHG_CONFIG),
 368         BQ24190_SYSFS_FIELD_RW(sys_min,         POC,    SYS_MIN),
 369         BQ24190_SYSFS_FIELD_RW(boost_lim,       POC,    BOOST_LIM),
 370         BQ24190_SYSFS_FIELD_RW(ichg,            CCC,    ICHG),
 371         BQ24190_SYSFS_FIELD_RW(force_20_pct,    CCC,    FORCE_20PCT),
 372         BQ24190_SYSFS_FIELD_RW(iprechg,         PCTCC,  IPRECHG),
 373         BQ24190_SYSFS_FIELD_RW(iterm,           PCTCC,  ITERM),
 374         BQ24190_SYSFS_FIELD_RW(vreg,            CVC,    VREG),
 375         BQ24190_SYSFS_FIELD_RW(batlowv,         CVC,    BATLOWV),
 376         BQ24190_SYSFS_FIELD_RW(vrechg,          CVC,    VRECHG),
 377         BQ24190_SYSFS_FIELD_RW(en_term,         CTTC,   EN_TERM),
 378         BQ24190_SYSFS_FIELD_RW(term_stat,       CTTC,   TERM_STAT),
 379         BQ24190_SYSFS_FIELD_RO(watchdog,        CTTC,   WATCHDOG),
 380         BQ24190_SYSFS_FIELD_RW(en_timer,        CTTC,   EN_TIMER),
 381         BQ24190_SYSFS_FIELD_RW(chg_timer,       CTTC,   CHG_TIMER),
 382         BQ24190_SYSFS_FIELD_RW(jeta_iset,       CTTC,   JEITA_ISET),
 383         BQ24190_SYSFS_FIELD_RW(bat_comp,        ICTRC,  BAT_COMP),
 384         BQ24190_SYSFS_FIELD_RW(vclamp,          ICTRC,  VCLAMP),
 385         BQ24190_SYSFS_FIELD_RW(treg,            ICTRC,  TREG),
 386         BQ24190_SYSFS_FIELD_RW(dpdm_en,         MOC,    DPDM_EN),
 387         BQ24190_SYSFS_FIELD_RW(tmr2x_en,        MOC,    TMR2X_EN),
 388         BQ24190_SYSFS_FIELD_RW(batfet_disable,  MOC,    BATFET_DISABLE),
 389         BQ24190_SYSFS_FIELD_RW(jeita_vset,      MOC,    JEITA_VSET),
 390         BQ24190_SYSFS_FIELD_RO(int_mask,        MOC,    INT_MASK),
 391         BQ24190_SYSFS_FIELD_RO(vbus_stat,       SS,     VBUS_STAT),
 392         BQ24190_SYSFS_FIELD_RO(chrg_stat,       SS,     CHRG_STAT),
 393         BQ24190_SYSFS_FIELD_RO(dpm_stat,        SS,     DPM_STAT),
 394         BQ24190_SYSFS_FIELD_RO(pg_stat,         SS,     PG_STAT),
 395         BQ24190_SYSFS_FIELD_RO(therm_stat,      SS,     THERM_STAT),
 396         BQ24190_SYSFS_FIELD_RO(vsys_stat,       SS,     VSYS_STAT),
 397         BQ24190_SYSFS_FIELD_RO(watchdog_fault,  F,      WATCHDOG_FAULT),
 398         BQ24190_SYSFS_FIELD_RO(boost_fault,     F,      BOOST_FAULT),
 399         BQ24190_SYSFS_FIELD_RO(chrg_fault,      F,      CHRG_FAULT),
 400         BQ24190_SYSFS_FIELD_RO(bat_fault,       F,      BAT_FAULT),
 401         BQ24190_SYSFS_FIELD_RO(ntc_fault,       F,      NTC_FAULT),
 402         BQ24190_SYSFS_FIELD_RO(pn,              VPRS,   PN),
 403         BQ24190_SYSFS_FIELD_RO(ts_profile,      VPRS,   TS_PROFILE),
 404         BQ24190_SYSFS_FIELD_RO(dev_reg,         VPRS,   DEV_REG),
 405 };
 406
 407 static struct attribute *
 408         bq24190_sysfs_attrs[ARRAY_SIZE(bq24190_sysfs_field_tbl) + 1];
 409
 410 static const struct attribute_group bq24190_sysfs_attr_group = {
 411         .attrs = bq24190_sysfs_attrs,
 412 };
 413
 414 static void bq24190_sysfs_init_attrs(void)
 415 {
 416         int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
 417
 418         for (i = 0; i < limit; i++)
 419                 bq24190_sysfs_attrs[i] = &bq24190_sysfs_field_tbl[i].attr.attr;
 420
 421         bq24190_sysfs_attrs[limit] = NULL; /* Has additional entry for this */
 422 }
 423
 424 static struct bq24190_sysfs_field_info *bq24190_sysfs_field_lookup(
 425                 const char *name)
 426 {
 427         int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
 428
 429         for (i = 0; i < limit; i++)
 430                 if (!strcmp(name, bq24190_sysfs_field_tbl[i].attr.attr.name))
 431                         break;
 432
 433         if (i >= limit)
 434                 return NULL;
 435
 436         return &bq24190_sysfs_field_tbl[i];
 437 }
 438
 439 static ssize_t bq24190_sysfs_show(struct device *dev,
 440                 struct device_attribute *attr, char *buf)
 441 {
 442         struct power_supply *psy = dev_get_drvdata(dev);
 443         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
 444         struct bq24190_sysfs_field_info *info;
 445         ssize_t count;
 446         int ret;
 447         u8 v;
 448
 449         info = bq24190_sysfs_field_lookup(attr->attr.name);
 450         if (!info)
 451                 return -EINVAL;
 452
 453         ret = pm_runtime_get_sync(bdi->dev);
 454         if (ret < 0) {
 455                 pm_runtime_put_noidle(bdi->dev);
 456                 return ret;
 457         }
 458
 459         ret = bq24190_read_mask(bdi, info->reg, info->mask, info->shift, &v);
 460         if (ret)
 461                 count = ret;
 462         else
 463                 count = scnprintf(buf, PAGE_SIZE, "%hhx\n", v);
 464
 465         pm_runtime_mark_last_busy(bdi->dev);
 466         pm_runtime_put_autosuspend(bdi->dev);
 467
 468         return count;
 469 }
 470
 471 static ssize_t bq24190_sysfs_store(struct device *dev,
 472                 struct device_attribute *attr, const char *buf, size_t count)
 473 {
 474         struct power_supply *psy = dev_get_drvdata(dev);
 475         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
 476         struct bq24190_sysfs_field_info *info;
 477         int ret;
 478         u8 v;
 479
 480         info = bq24190_sysfs_field_lookup(attr->attr.name);
 481         if (!info)
 482                 return -EINVAL;
 483
 484         ret = kstrtou8(buf, 0, &v);
 485         if (ret < 0)
 486                 return ret;
 487
 488         ret = pm_runtime_get_sync(bdi->dev);
 489         if (ret < 0)
 490                 return ret;
 491
 492         ret = bq24190_write_mask(bdi, info->reg, info->mask, info->shift, v);
 493         if (ret)
 494                 count = ret;
 495
 496         pm_runtime_mark_last_busy(bdi->dev);
 497         pm_runtime_put_autosuspend(bdi->dev);
 498
 499         return count;
 500 }
 501
 502 static int bq24190_sysfs_create_group(struct bq24190_dev_info *bdi)
 503 {
 504         bq24190_sysfs_init_attrs();
 505
 506         return sysfs_create_group(&bdi->charger->dev.kobj,
 507                         &bq24190_sysfs_attr_group);
 508 }
 509
 510 static void bq24190_sysfs_remove_group(struct bq24190_dev_info *bdi)
 511 {
 512         sysfs_remove_group(&bdi->charger->dev.kobj, &bq24190_sysfs_attr_group);
 513 }
 514 #else
 515 static int bq24190_sysfs_create_group(struct bq24190_dev_info *bdi)
 516 {
 517         return 0;
 518 }
 519
 520 static inline void bq24190_sysfs_remove_group(struct bq24190_dev_info *bdi) {}
 521 #endif
 522
 523 #ifdef CONFIG_REGULATOR
 524 static int bq24190_set_charge_mode(struct regulator_dev *dev, u8 val)
 525 {
 526         struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
 527         int ret;
 528
 529         ret = pm_runtime_get_sync(bdi->dev);
 530         if (ret < 0) {
 531                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
 532                 pm_runtime_put_noidle(bdi->dev);
 533                 return ret;
 534         }
 535
 536         ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
 537                                  BQ24190_REG_POC_CHG_CONFIG_MASK,
 538                                  BQ24190_REG_POC_CHG_CONFIG_SHIFT, val);
 539
 540         pm_runtime_mark_last_busy(bdi->dev);
 541         pm_runtime_put_autosuspend(bdi->dev);
 542
 543         return ret;
 544 }
 545
 546 static int bq24190_vbus_enable(struct regulator_dev *dev)
 547 {
 548         return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_OTG);
 549 }
 550
 551 static int bq24190_vbus_disable(struct regulator_dev *dev)
 552 {
 553         return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_CHARGE);
 554 }
 555
 556 static int bq24190_vbus_is_enabled(struct regulator_dev *dev)
 557 {
 558         struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
 559         int ret;
 560         u8 val;
 561
 562         ret = pm_runtime_get_sync(bdi->dev);
 563         if (ret < 0) {
 564                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
 565                 pm_runtime_put_noidle(bdi->dev);
 566                 return ret;
 567         }
 568
 569         ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
 570                                 BQ24190_REG_POC_CHG_CONFIG_MASK,
 571                                 BQ24190_REG_POC_CHG_CONFIG_SHIFT, &val);
 572
 573         pm_runtime_mark_last_busy(bdi->dev);
 574         pm_runtime_put_autosuspend(bdi->dev);
 575
 576         if (ret)
 577                 return ret;
 578
 579         return (val == BQ24190_REG_POC_CHG_CONFIG_OTG ||
 580                 val == BQ24190_REG_POC_CHG_CONFIG_OTG_ALT);
 581 }
 582
 583 static const struct regulator_ops bq24190_vbus_ops = {
 584         .enable = bq24190_vbus_enable,
 585         .disable = bq24190_vbus_disable,
 586         .is_enabled = bq24190_vbus_is_enabled,
 587 };
 588
 589 static const struct regulator_desc bq24190_vbus_desc = {
 590         .name = "usb_otg_vbus",
 591         .type = REGULATOR_VOLTAGE,
 592         .owner = THIS_MODULE,
 593         .ops = &bq24190_vbus_ops,
 594         .fixed_uV = 5000000,
 595         .n_voltages = 1,
 596 };
 597
 598 static const struct regulator_init_data bq24190_vbus_init_data = {
 599         .constraints = {
 600                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
 601         },
 602 };
 603
 604 static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
 605 {
 606         struct bq24190_platform_data *pdata = bdi->dev->platform_data;
 607         struct regulator_config cfg = { };
 608         struct regulator_dev *reg;
 609         int ret = 0;
 610
 611         cfg.dev = bdi->dev;
 612         if (pdata && pdata->regulator_init_data)
 613                 cfg.init_data = pdata->regulator_init_data;
 614         else
 615                 cfg.init_data = &bq24190_vbus_init_data;
 616         cfg.driver_data = bdi;
 617         reg = devm_regulator_register(bdi->dev, &bq24190_vbus_desc, &cfg);
 618         if (IS_ERR(reg)) {
 619                 ret = PTR_ERR(reg);
 620                 dev_err(bdi->dev, "Can't register regulator: %d\n", ret);
 621         }
 622
 623         return ret;
 624 }
 625 #else
 626 static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
 627 {
 628         return 0;
 629 }
 630 #endif
 631
 632 static int bq24190_set_config(struct bq24190_dev_info *bdi)
 633 {
 634         int ret;
 635         u8 v;
 636
 637         ret = bq24190_read(bdi, BQ24190_REG_CTTC, &v);
 638         if (ret < 0)
 639                 return ret;
 640
 641         bdi->watchdog = ((v & BQ24190_REG_CTTC_WATCHDOG_MASK) >>
 642                                         BQ24190_REG_CTTC_WATCHDOG_SHIFT);
 643
 644         /*
 645          * According to the "Host Mode and default Mode" section of the
 646          * manual, a write to any register causes the bq24190 to switch
 647          * from default mode to host mode.  It will switch back to default
 648          * mode after a WDT timeout unless the WDT is turned off as well.
 649          * So, by simply turning off the WDT, we accomplish both with the
 650          * same write.
 651          */
 652         v &= ~BQ24190_REG_CTTC_WATCHDOG_MASK;
 653
 654         ret = bq24190_write(bdi, BQ24190_REG_CTTC, v);
 655         if (ret < 0)
 656                 return ret;
 657
 658         if (bdi->sys_min) {
 659                 v = bdi->sys_min / 100 - 30; // manual section 9.5.1.2, table 9
 660                 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
 661                                          BQ24190_REG_POC_SYS_MIN_MASK,
 662                                          BQ24190_REG_POC_SYS_MIN_SHIFT,
 663                                          v);
 664                 if (ret < 0)
 665                         return ret;
 666         }
 667
 668         if (bdi->iprechg) {
 669                 v = bdi->iprechg / 128 - 1; // manual section 9.5.1.4, table 11
 670                 ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
 671                                          BQ24190_REG_PCTCC_IPRECHG_MASK,
 672                                          BQ24190_REG_PCTCC_IPRECHG_SHIFT,
 673                                          v);
 674                 if (ret < 0)
 675                         return ret;
 676         }
 677
 678         if (bdi->iterm) {
 679                 v = bdi->iterm / 128 - 1; // manual section 9.5.1.4, table 11
 680                 ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
 681                                          BQ24190_REG_PCTCC_ITERM_MASK,
 682                                          BQ24190_REG_PCTCC_ITERM_SHIFT,
 683                                          v);
 684                 if (ret < 0)
 685                         return ret;
 686         }
 687
 688         return 0;
 689 }
 690
 691 static int bq24190_register_reset(struct bq24190_dev_info *bdi)
 692 {
 693         int ret, limit = 100;
 694         u8 v;
 695
 696         if (device_property_read_bool(bdi->dev, "disable-reset"))
 697                 return 0;
 698
 699         /* Reset the registers */
 700         ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
 701                         BQ24190_REG_POC_RESET_MASK,
 702                         BQ24190_REG_POC_RESET_SHIFT,
 703                         0x1);
 704         if (ret < 0)
 705                 return ret;
 706
 707         /* Reset bit will be cleared by hardware so poll until it is */
 708         do {
 709                 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
 710                                 BQ24190_REG_POC_RESET_MASK,
 711                                 BQ24190_REG_POC_RESET_SHIFT,
 712                                 &v);
 713                 if (ret < 0)
 714                         return ret;
 715
 716                 if (v == 0)
 717                         return 0;
 718
 719                 usleep_range(100, 200);
 720         } while (--limit);
 721
 722         return -EIO;
 723 }
 724
 725 /* Charger power supply property routines */
 726
 727 static int bq24190_charger_get_charge_type(struct bq24190_dev_info *bdi,
 728                 union power_supply_propval *val)
 729 {
 730         u8 v;
 731         int type, ret;
 732
 733         ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
 734                         BQ24190_REG_POC_CHG_CONFIG_MASK,
 735                         BQ24190_REG_POC_CHG_CONFIG_SHIFT,
 736                         &v);
 737         if (ret < 0)
 738                 return ret;
 739
 740         /* If POC[CHG_CONFIG] (REG01[5:4]) == 0, charge is disabled */
 741         if (!v) {
 742                 type = POWER_SUPPLY_CHARGE_TYPE_NONE;
 743         } else {
 744                 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
 745                                 BQ24190_REG_CCC_FORCE_20PCT_MASK,
 746                                 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
 747                                 &v);
 748                 if (ret < 0)
 749                         return ret;
 750
 751                 type = (v) ? POWER_SUPPLY_CHARGE_TYPE_TRICKLE :
 752                              POWER_SUPPLY_CHARGE_TYPE_FAST;
 753         }
 754
 755         val->intval = type;
 756
 757         return 0;
 758 }
 759
 760 static int bq24190_charger_set_charge_type(struct bq24190_dev_info *bdi,
 761                 const union power_supply_propval *val)
 762 {
 763         u8 chg_config, force_20pct, en_term;
 764         int ret;
 765
 766         /*
 767          * According to the "Termination when REG02[0] = 1" section of
 768          * the bq24190 manual, the trickle charge could be less than the
 769          * termination current so it recommends turning off the termination
 770          * function.
 771          *
 772          * Note: AFAICT from the datasheet, the user will have to manually
 773          * turn off the charging when in 20% mode.  If its not turned off,
 774          * there could be battery damage.  So, use this mode at your own risk.
 775          */
 776         switch (val->intval) {
 777         case POWER_SUPPLY_CHARGE_TYPE_NONE:
 778                 chg_config = 0x0;
 779                 break;
 780         case POWER_SUPPLY_CHARGE_TYPE_TRICKLE:
 781                 chg_config = 0x1;
 782                 force_20pct = 0x1;
 783                 en_term = 0x0;
 784                 break;
 785         case POWER_SUPPLY_CHARGE_TYPE_FAST:
 786                 chg_config = 0x1;
 787                 force_20pct = 0x0;
 788                 en_term = 0x1;
 789                 break;
 790         default:
 791                 return -EINVAL;
 792         }
 793
 794         if (chg_config) { /* Enabling the charger */
 795                 ret = bq24190_write_mask(bdi, BQ24190_REG_CCC,
 796                                 BQ24190_REG_CCC_FORCE_20PCT_MASK,
 797                                 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
 798                                 force_20pct);
 799                 if (ret < 0)
 800                         return ret;
 801
 802                 ret = bq24190_write_mask(bdi, BQ24190_REG_CTTC,
 803                                 BQ24190_REG_CTTC_EN_TERM_MASK,
 804                                 BQ24190_REG_CTTC_EN_TERM_SHIFT,
 805                                 en_term);
 806                 if (ret < 0)
 807                         return ret;
 808         }
 809
 810         return bq24190_write_mask(bdi, BQ24190_REG_POC,
 811                         BQ24190_REG_POC_CHG_CONFIG_MASK,
 812                         BQ24190_REG_POC_CHG_CONFIG_SHIFT, chg_config);
 813 }
 814
 815 static int bq24190_charger_get_health(struct bq24190_dev_info *bdi,
 816                 union power_supply_propval *val)
 817 {
 818         u8 v;
 819         int health;
 820
 821         mutex_lock(&bdi->f_reg_lock);
 822         v = bdi->f_reg;
 823         mutex_unlock(&bdi->f_reg_lock);
 824
 825         if (v & BQ24190_REG_F_NTC_FAULT_MASK) {
 826                 switch (v >> BQ24190_REG_F_NTC_FAULT_SHIFT & 0x7) {
 827                 case 0x1: /* TS1  Cold */
 828                 case 0x3: /* TS2  Cold */
 829                 case 0x5: /* Both Cold */
 830                         health = POWER_SUPPLY_HEALTH_COLD;
 831                         break;
 832                 case 0x2: /* TS1  Hot */
 833                 case 0x4: /* TS2  Hot */
 834                 case 0x6: /* Both Hot */
 835                         health = POWER_SUPPLY_HEALTH_OVERHEAT;
 836                         break;
 837                 default:
 838                         health = POWER_SUPPLY_HEALTH_UNKNOWN;
 839                 }
 840         } else if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
 841                 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 842         } else if (v & BQ24190_REG_F_CHRG_FAULT_MASK) {
 843                 switch (v >> BQ24190_REG_F_CHRG_FAULT_SHIFT & 0x3) {
 844                 case 0x1: /* Input Fault (VBUS OVP or VBAT<VBUS<3.8V) */
 845                         /*
 846                          * This could be over-voltage or under-voltage
 847                          * and there's no way to tell which.  Instead
 848                          * of looking foolish and returning 'OVERVOLTAGE'
 849                          * when its really under-voltage, just return
 850                          * 'UNSPEC_FAILURE'.
 851                          */
 852                         health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 853                         break;
 854                 case 0x2: /* Thermal Shutdown */
 855                         health = POWER_SUPPLY_HEALTH_OVERHEAT;
 856                         break;
 857                 case 0x3: /* Charge Safety Timer Expiration */
 858                         health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 859                         break;
 860                 default:  /* prevent compiler warning */
 861                         health = -1;
 862                 }
 863         } else if (v & BQ24190_REG_F_BOOST_FAULT_MASK) {
 864                 /*
 865                  * This could be over-current or over-voltage but there's
 866                  * no way to tell which.  Return 'OVERVOLTAGE' since there
 867                  * isn't an 'OVERCURRENT' value defined that we can return
 868                  * even if it was over-current.
 869                  */
 870                 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 871         } else {
 872                 health = POWER_SUPPLY_HEALTH_GOOD;
 873         }
 874
 875         val->intval = health;
 876
 877         return 0;
 878 }
 879
 880 static int bq24190_charger_get_online(struct bq24190_dev_info *bdi,
 881                 union power_supply_propval *val)
 882 {
 883         u8 pg_stat, batfet_disable;
 884         int ret;
 885
 886         ret = bq24190_read_mask(bdi, BQ24190_REG_SS,
 887                         BQ24190_REG_SS_PG_STAT_MASK,
 888                         BQ24190_REG_SS_PG_STAT_SHIFT, &pg_stat);
 889         if (ret < 0)
 890                 return ret;
 891
 892         ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
 893                         BQ24190_REG_MOC_BATFET_DISABLE_MASK,
 894                         BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
 895         if (ret < 0)
 896                 return ret;
 897
 898         val->intval = pg_stat && !batfet_disable;
 899
 900         return 0;
 901 }
 902
 903 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
 904                                       const union power_supply_propval *val);
 905 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
 906                                       union power_supply_propval *val);
 907 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
 908                                               union power_supply_propval *val);
 909 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
 910                                               const union power_supply_propval *val);
 911
 912 static int bq24190_charger_set_online(struct bq24190_dev_info *bdi,
 913                                       const union power_supply_propval *val)
 914 {
 915         return bq24190_battery_set_online(bdi, val);
 916 }
 917
 918 static int bq24190_charger_get_status(struct bq24190_dev_info *bdi,
 919                                       union power_supply_propval *val)
 920 {
 921         return bq24190_battery_get_status(bdi, val);
 922 }
 923
 924 static int bq24190_charger_get_temp_alert_max(struct bq24190_dev_info *bdi,
 925                                               union power_supply_propval *val)
 926 {
 927         return bq24190_battery_get_temp_alert_max(bdi, val);
 928 }
 929
 930 static int bq24190_charger_set_temp_alert_max(struct bq24190_dev_info *bdi,
 931                                               const union power_supply_propval *val)
 932 {
 933         return bq24190_battery_set_temp_alert_max(bdi, val);
 934 }
 935
 936 static int bq24190_charger_get_precharge(struct bq24190_dev_info *bdi,
 937                 union power_supply_propval *val)
 938 {
 939         u8 v;
 940         int ret;
 941
 942         ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
 943                         BQ24190_REG_PCTCC_IPRECHG_MASK,
 944                         BQ24190_REG_PCTCC_IPRECHG_SHIFT, &v);
 945         if (ret < 0)
 946                 return ret;
 947
 948         val->intval = ++v * 128 * 1000;
 949         return 0;
 950 }
 951
 952 static int bq24190_charger_get_charge_term(struct bq24190_dev_info *bdi,
 953                 union power_supply_propval *val)
 954 {
 955         u8 v;
 956         int ret;
 957
 958         ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
 959                         BQ24190_REG_PCTCC_ITERM_MASK,
 960                         BQ24190_REG_PCTCC_ITERM_SHIFT, &v);
 961         if (ret < 0)
 962                 return ret;
 963
 964         val->intval = ++v * 128 * 1000;
 965         return 0;
 966 }
 967
 968 static int bq24190_charger_get_current(struct bq24190_dev_info *bdi,
 969                 union power_supply_propval *val)
 970 {
 971         u8 v;
 972         int curr, ret;
 973
 974         ret = bq24190_get_field_val(bdi, BQ24190_REG_CCC,
 975                         BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
 976                         bq24190_ccc_ichg_values,
 977                         ARRAY_SIZE(bq24190_ccc_ichg_values), &curr);
 978         if (ret < 0)
 979                 return ret;
 980
 981         ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
 982                         BQ24190_REG_CCC_FORCE_20PCT_MASK,
 983                         BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
 984         if (ret < 0)
 985                 return ret;
 986
 987         /* If FORCE_20PCT is enabled, then current is 20% of ICHG value */
 988         if (v)
 989                 curr /= 5;
 990
 991         val->intval = curr;
 992         return 0;
 993 }
 994
 995 static int bq24190_charger_get_current_max(struct bq24190_dev_info *bdi,
 996                 union power_supply_propval *val)
 997 {
 998         int idx = ARRAY_SIZE(bq24190_ccc_ichg_values) - 1;
 999
1000         val->intval = bq24190_ccc_ichg_values[idx];
1001         return 0;
1002 }
1003
1004 static int bq24190_charger_set_current(struct bq24190_dev_info *bdi,
1005                 const union power_supply_propval *val)
1006 {
1007         u8 v;
1008         int ret, curr = val->intval;
1009
1010         ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
1011                         BQ24190_REG_CCC_FORCE_20PCT_MASK,
1012                         BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
1013         if (ret < 0)
1014                 return ret;
1015
1016         /* If FORCE_20PCT is enabled, have to multiply value passed in by 5 */
1017         if (v)
1018                 curr *= 5;
1019
1020         return bq24190_set_field_val(bdi, BQ24190_REG_CCC,
1021                         BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
1022                         bq24190_ccc_ichg_values,
1023                         ARRAY_SIZE(bq24190_ccc_ichg_values), curr);
1024 }
1025
1026 static int bq24190_charger_get_voltage(struct bq24190_dev_info *bdi,
1027                 union power_supply_propval *val)
1028 {
1029         int voltage, ret;
1030
1031         ret = bq24190_get_field_val(bdi, BQ24190_REG_CVC,
1032                         BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
1033                         bq24190_cvc_vreg_values,
1034                         ARRAY_SIZE(bq24190_cvc_vreg_values), &voltage);
1035         if (ret < 0)
1036                 return ret;
1037
1038         val->intval = voltage;
1039         return 0;
1040 }
1041
1042 static int bq24190_charger_get_voltage_max(struct bq24190_dev_info *bdi,
1043                 union power_supply_propval *val)
1044 {
1045         int idx = ARRAY_SIZE(bq24190_cvc_vreg_values) - 1;
1046
1047         val->intval = bq24190_cvc_vreg_values[idx];
1048         return 0;
1049 }
1050
1051 static int bq24190_charger_set_voltage(struct bq24190_dev_info *bdi,
1052                 const union power_supply_propval *val)
1053 {
1054         return bq24190_set_field_val(bdi, BQ24190_REG_CVC,
1055                         BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
1056                         bq24190_cvc_vreg_values,
1057                         ARRAY_SIZE(bq24190_cvc_vreg_values), val->intval);
1058 }
1059
1060 static int bq24190_charger_get_iinlimit(struct bq24190_dev_info *bdi,
1061                 union power_supply_propval *val)
1062 {
1063         int iinlimit, ret;
1064
1065         ret = bq24190_get_field_val(bdi, BQ24190_REG_ISC,
1066                         BQ24190_REG_ISC_IINLIM_MASK,
1067                         BQ24190_REG_ISC_IINLIM_SHIFT,
1068                         bq24190_isc_iinlim_values,
1069                         ARRAY_SIZE(bq24190_isc_iinlim_values), &iinlimit);
1070         if (ret < 0)
1071                 return ret;
1072
1073         val->intval = iinlimit;
1074         return 0;
1075 }
1076
1077 static int bq24190_charger_set_iinlimit(struct bq24190_dev_info *bdi,
1078                 const union power_supply_propval *val)
1079 {
1080         return bq24190_set_field_val(bdi, BQ24190_REG_ISC,
1081                         BQ24190_REG_ISC_IINLIM_MASK,
1082                         BQ24190_REG_ISC_IINLIM_SHIFT,
1083                         bq24190_isc_iinlim_values,
1084                         ARRAY_SIZE(bq24190_isc_iinlim_values), val->intval);
1085 }
1086
1087 static int bq24190_charger_get_property(struct power_supply *psy,
1088                 enum power_supply_property psp, union power_supply_propval *val)
1089 {
1090         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1091         int ret;
1092
1093         dev_dbg(bdi->dev, "prop: %d\n", psp);
1094
1095         ret = pm_runtime_get_sync(bdi->dev);
1096         if (ret < 0) {
1097                 pm_runtime_put_noidle(bdi->dev);
1098                 return ret;
1099         }
1100
1101         switch (psp) {
1102         case POWER_SUPPLY_PROP_CHARGE_TYPE:
1103                 ret = bq24190_charger_get_charge_type(bdi, val);
1104                 break;
1105         case POWER_SUPPLY_PROP_HEALTH:
1106                 ret = bq24190_charger_get_health(bdi, val);
1107                 break;
1108         case POWER_SUPPLY_PROP_ONLINE:
1109                 ret = bq24190_charger_get_online(bdi, val);
1110                 break;
1111         case POWER_SUPPLY_PROP_STATUS:
1112                 ret = bq24190_charger_get_status(bdi, val);
1113                 break;
1114         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1115                 ret =  bq24190_charger_get_temp_alert_max(bdi, val);
1116                 break;
1117         case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1118                 ret = bq24190_charger_get_precharge(bdi, val);
1119                 break;
1120         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1121                 ret = bq24190_charger_get_charge_term(bdi, val);
1122                 break;
1123         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1124                 ret = bq24190_charger_get_current(bdi, val);
1125                 break;
1126         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
1127                 ret = bq24190_charger_get_current_max(bdi, val);
1128                 break;
1129         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1130                 ret = bq24190_charger_get_voltage(bdi, val);
1131                 break;
1132         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
1133                 ret = bq24190_charger_get_voltage_max(bdi, val);
1134                 break;
1135         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1136                 ret = bq24190_charger_get_iinlimit(bdi, val);
1137                 break;
1138         case POWER_SUPPLY_PROP_SCOPE:
1139                 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1140                 ret = 0;
1141                 break;
1142         case POWER_SUPPLY_PROP_MODEL_NAME:
1143                 val->strval = bdi->model_name;
1144                 ret = 0;
1145                 break;
1146         case POWER_SUPPLY_PROP_MANUFACTURER:
1147                 val->strval = BQ24190_MANUFACTURER;
1148                 ret = 0;
1149                 break;
1150         default:
1151                 ret = -ENODATA;
1152         }
1153
1154         pm_runtime_mark_last_busy(bdi->dev);
1155         pm_runtime_put_autosuspend(bdi->dev);
1156
1157         return ret;
1158 }
1159
1160 static int bq24190_charger_set_property(struct power_supply *psy,
1161                 enum power_supply_property psp,
1162                 const union power_supply_propval *val)
1163 {
1164         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1165         int ret;
1166
1167         dev_dbg(bdi->dev, "prop: %d\n", psp);
1168
1169         ret = pm_runtime_get_sync(bdi->dev);
1170         if (ret < 0) {
1171                 pm_runtime_put_noidle(bdi->dev);
1172                 return ret;
1173         }
1174
1175         switch (psp) {
1176         case POWER_SUPPLY_PROP_ONLINE:
1177                 ret = bq24190_charger_set_online(bdi, val);
1178                 break;
1179         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1180                 ret = bq24190_charger_set_temp_alert_max(bdi, val);
1181                 break;
1182         case POWER_SUPPLY_PROP_CHARGE_TYPE:
1183                 ret = bq24190_charger_set_charge_type(bdi, val);
1184                 break;
1185         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1186                 ret = bq24190_charger_set_current(bdi, val);
1187                 break;
1188         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1189                 ret = bq24190_charger_set_voltage(bdi, val);
1190                 break;
1191         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1192                 ret = bq24190_charger_set_iinlimit(bdi, val);
1193                 break;
1194         default:
1195                 ret = -EINVAL;
1196         }
1197
1198         pm_runtime_mark_last_busy(bdi->dev);
1199         pm_runtime_put_autosuspend(bdi->dev);
1200
1201         return ret;
1202 }
1203
1204 static int bq24190_charger_property_is_writeable(struct power_supply *psy,
1205                 enum power_supply_property psp)
1206 {
1207         int ret;
1208
1209         switch (psp) {
1210         case POWER_SUPPLY_PROP_ONLINE:
1211         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1212         case POWER_SUPPLY_PROP_CHARGE_TYPE:
1213         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1214         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1215         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1216                 ret = 1;
1217                 break;
1218         default:
1219                 ret = 0;
1220         }
1221
1222         return ret;
1223 }
1224
1225 static void bq24190_input_current_limit_work(struct work_struct *work)
1226 {
1227         struct bq24190_dev_info *bdi =
1228                 container_of(work, struct bq24190_dev_info,
1229                              input_current_limit_work.work);
1230
1231         power_supply_set_input_current_limit_from_supplier(bdi->charger);
1232 }
1233
1234 /* Sync the input-current-limit with our parent supply (if we have one) */
1235 static void bq24190_charger_external_power_changed(struct power_supply *psy)
1236 {
1237         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1238
1239         /*
1240          * The Power-Good detection may take up to 220ms, sometimes
1241          * the external charger detection is quicker, and the bq24190 will
1242          * reset to iinlim based on its own charger detection (which is not
1243          * hooked up when using external charger detection) resulting in a
1244          * too low default 500mA iinlim. Delay setting the input-current-limit
1245          * for 300ms to avoid this.
1246          */
1247         queue_delayed_work(system_wq, &bdi->input_current_limit_work,
1248                            msecs_to_jiffies(300));
1249 }
1250
1251 static enum power_supply_property bq24190_charger_properties[] = {
1252         POWER_SUPPLY_PROP_CHARGE_TYPE,
1253         POWER_SUPPLY_PROP_HEALTH,
1254         POWER_SUPPLY_PROP_ONLINE,
1255         POWER_SUPPLY_PROP_STATUS,
1256         POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1257         POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
1258         POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
1259         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1260         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
1261         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1262         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
1263         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1264         POWER_SUPPLY_PROP_SCOPE,
1265         POWER_SUPPLY_PROP_MODEL_NAME,
1266         POWER_SUPPLY_PROP_MANUFACTURER,
1267 };
1268
1269 static char *bq24190_charger_supplied_to[] = {
1270         "main-battery",
1271 };
1272
1273 static const struct power_supply_desc bq24190_charger_desc = {
1274         .name                   = "bq24190-charger",
1275         .type                   = POWER_SUPPLY_TYPE_USB,
1276         .properties             = bq24190_charger_properties,
1277         .num_properties         = ARRAY_SIZE(bq24190_charger_properties),
1278         .get_property           = bq24190_charger_get_property,
1279         .set_property           = bq24190_charger_set_property,
1280         .property_is_writeable  = bq24190_charger_property_is_writeable,
1281         .external_power_changed = bq24190_charger_external_power_changed,
1282 };
1283
1284 /* Battery power supply property routines */
1285
1286 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
1287                 union power_supply_propval *val)
1288 {
1289         u8 ss_reg, chrg_fault;
1290         int status, ret;
1291
1292         mutex_lock(&bdi->f_reg_lock);
1293         chrg_fault = bdi->f_reg;
1294         mutex_unlock(&bdi->f_reg_lock);
1295
1296         chrg_fault &= BQ24190_REG_F_CHRG_FAULT_MASK;
1297         chrg_fault >>= BQ24190_REG_F_CHRG_FAULT_SHIFT;
1298
1299         ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1300         if (ret < 0)
1301                 return ret;
1302
1303         /*
1304          * The battery must be discharging when any of these are true:
1305          * - there is no good power source;
1306          * - there is a charge fault.
1307          * Could also be discharging when in "supplement mode" but
1308          * there is no way to tell when its in that mode.
1309          */
1310         if (!(ss_reg & BQ24190_REG_SS_PG_STAT_MASK) || chrg_fault) {
1311                 status = POWER_SUPPLY_STATUS_DISCHARGING;
1312         } else {
1313                 ss_reg &= BQ24190_REG_SS_CHRG_STAT_MASK;
1314                 ss_reg >>= BQ24190_REG_SS_CHRG_STAT_SHIFT;
1315
1316                 switch (ss_reg) {
1317                 case 0x0: /* Not Charging */
1318                         status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1319                         break;
1320                 case 0x1: /* Pre-charge */
1321                 case 0x2: /* Fast Charging */
1322                         status = POWER_SUPPLY_STATUS_CHARGING;
1323                         break;
1324                 case 0x3: /* Charge Termination Done */
1325                         status = POWER_SUPPLY_STATUS_FULL;
1326                         break;
1327                 default:
1328                         ret = -EIO;
1329                 }
1330         }
1331
1332         if (!ret)
1333                 val->intval = status;
1334
1335         return ret;
1336 }
1337
1338 static int bq24190_battery_get_health(struct bq24190_dev_info *bdi,
1339                 union power_supply_propval *val)
1340 {
1341         u8 v;
1342         int health;
1343
1344         mutex_lock(&bdi->f_reg_lock);
1345         v = bdi->f_reg;
1346         mutex_unlock(&bdi->f_reg_lock);
1347
1348         if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
1349                 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1350         } else {
1351                 v &= BQ24190_REG_F_NTC_FAULT_MASK;
1352                 v >>= BQ24190_REG_F_NTC_FAULT_SHIFT;
1353
1354                 switch (v) {
1355                 case 0x0: /* Normal */
1356                         health = POWER_SUPPLY_HEALTH_GOOD;
1357                         break;
1358                 case 0x1: /* TS1 Cold */
1359                 case 0x3: /* TS2 Cold */
1360                 case 0x5: /* Both Cold */
1361                         health = POWER_SUPPLY_HEALTH_COLD;
1362                         break;
1363                 case 0x2: /* TS1 Hot */
1364                 case 0x4: /* TS2 Hot */
1365                 case 0x6: /* Both Hot */
1366                         health = POWER_SUPPLY_HEALTH_OVERHEAT;
1367                         break;
1368                 default:
1369                         health = POWER_SUPPLY_HEALTH_UNKNOWN;
1370                 }
1371         }
1372
1373         val->intval = health;
1374         return 0;
1375 }
1376
1377 static int bq24190_battery_get_online(struct bq24190_dev_info *bdi,
1378                 union power_supply_propval *val)
1379 {
1380         u8 batfet_disable;
1381         int ret;
1382
1383         ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
1384                         BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1385                         BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
1386         if (ret < 0)
1387                 return ret;
1388
1389         val->intval = !batfet_disable;
1390         return 0;
1391 }
1392
1393 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
1394                 const union power_supply_propval *val)
1395 {
1396         return bq24190_write_mask(bdi, BQ24190_REG_MOC,
1397                         BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1398                         BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, !val->intval);
1399 }
1400
1401 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
1402                 union power_supply_propval *val)
1403 {
1404         int temp, ret;
1405
1406         ret = bq24190_get_field_val(bdi, BQ24190_REG_ICTRC,
1407                         BQ24190_REG_ICTRC_TREG_MASK,
1408                         BQ24190_REG_ICTRC_TREG_SHIFT,
1409                         bq24190_ictrc_treg_values,
1410                         ARRAY_SIZE(bq24190_ictrc_treg_values), &temp);
1411         if (ret < 0)
1412                 return ret;
1413
1414         val->intval = temp;
1415         return 0;
1416 }
1417
1418 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
1419                 const union power_supply_propval *val)
1420 {
1421         return bq24190_set_field_val(bdi, BQ24190_REG_ICTRC,
1422                         BQ24190_REG_ICTRC_TREG_MASK,
1423                         BQ24190_REG_ICTRC_TREG_SHIFT,
1424                         bq24190_ictrc_treg_values,
1425                         ARRAY_SIZE(bq24190_ictrc_treg_values), val->intval);
1426 }
1427
1428 static int bq24190_battery_get_property(struct power_supply *psy,
1429                 enum power_supply_property psp, union power_supply_propval *val)
1430 {
1431         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1432         int ret;
1433
1434         dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1435         dev_dbg(bdi->dev, "prop: %d\n", psp);
1436
1437         ret = pm_runtime_get_sync(bdi->dev);
1438         if (ret < 0) {
1439                 pm_runtime_put_noidle(bdi->dev);
1440                 return ret;
1441         }
1442
1443         switch (psp) {
1444         case POWER_SUPPLY_PROP_STATUS:
1445                 ret = bq24190_battery_get_status(bdi, val);
1446                 break;
1447         case POWER_SUPPLY_PROP_HEALTH:
1448                 ret = bq24190_battery_get_health(bdi, val);
1449                 break;
1450         case POWER_SUPPLY_PROP_ONLINE:
1451                 ret = bq24190_battery_get_online(bdi, val);
1452                 break;
1453         case POWER_SUPPLY_PROP_TECHNOLOGY:
1454                 /* Could be Li-on or Li-polymer but no way to tell which */
1455                 val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
1456                 ret = 0;
1457                 break;
1458         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1459                 ret = bq24190_battery_get_temp_alert_max(bdi, val);
1460                 break;
1461         case POWER_SUPPLY_PROP_SCOPE:
1462                 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1463                 ret = 0;
1464                 break;
1465         default:
1466                 ret = -ENODATA;
1467         }
1468
1469         pm_runtime_mark_last_busy(bdi->dev);
1470         pm_runtime_put_autosuspend(bdi->dev);
1471
1472         return ret;
1473 }
1474
1475 static int bq24190_battery_set_property(struct power_supply *psy,
1476                 enum power_supply_property psp,
1477                 const union power_supply_propval *val)
1478 {
1479         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1480         int ret;
1481
1482         dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1483         dev_dbg(bdi->dev, "prop: %d\n", psp);
1484
1485         ret = pm_runtime_get_sync(bdi->dev);
1486         if (ret < 0) {
1487                 pm_runtime_put_noidle(bdi->dev);
1488                 return ret;
1489         }
1490
1491         switch (psp) {
1492         case POWER_SUPPLY_PROP_ONLINE:
1493                 ret = bq24190_battery_set_online(bdi, val);
1494                 break;
1495         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1496                 ret = bq24190_battery_set_temp_alert_max(bdi, val);
1497                 break;
1498         default:
1499                 ret = -EINVAL;
1500         }
1501
1502         pm_runtime_mark_last_busy(bdi->dev);
1503         pm_runtime_put_autosuspend(bdi->dev);
1504
1505         return ret;
1506 }
1507
1508 static int bq24190_battery_property_is_writeable(struct power_supply *psy,
1509                 enum power_supply_property psp)
1510 {
1511         int ret;
1512
1513         switch (psp) {
1514         case POWER_SUPPLY_PROP_ONLINE:
1515         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1516                 ret = 1;
1517                 break;
1518         default:
1519                 ret = 0;
1520         }
1521
1522         return ret;
1523 }
1524
1525 static enum power_supply_property bq24190_battery_properties[] = {
1526         POWER_SUPPLY_PROP_STATUS,
1527         POWER_SUPPLY_PROP_HEALTH,
1528         POWER_SUPPLY_PROP_ONLINE,
1529         POWER_SUPPLY_PROP_TECHNOLOGY,
1530         POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1531         POWER_SUPPLY_PROP_SCOPE,
1532 };
1533
1534 static const struct power_supply_desc bq24190_battery_desc = {
1535         .name                   = "bq24190-battery",
1536         .type                   = POWER_SUPPLY_TYPE_BATTERY,
1537         .properties             = bq24190_battery_properties,
1538         .num_properties         = ARRAY_SIZE(bq24190_battery_properties),
1539         .get_property           = bq24190_battery_get_property,
1540         .set_property           = bq24190_battery_set_property,
1541         .property_is_writeable  = bq24190_battery_property_is_writeable,
1542 };
1543
1544 static void bq24190_check_status(struct bq24190_dev_info *bdi)
1545 {
1546         const u8 battery_mask_ss = BQ24190_REG_SS_CHRG_STAT_MASK;
1547         const u8 battery_mask_f = BQ24190_REG_F_BAT_FAULT_MASK
1548                                 | BQ24190_REG_F_NTC_FAULT_MASK;
1549         bool alert_charger = false, alert_battery = false;
1550         u8 ss_reg = 0, f_reg = 0;
1551         int i, ret;
1552
1553         ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1554         if (ret < 0) {
1555                 dev_err(bdi->dev, "Can't read SS reg: %d\n", ret);
1556                 return;
1557         }
1558
1559         i = 0;
1560         do {
1561                 ret = bq24190_read(bdi, BQ24190_REG_F, &f_reg);
1562                 if (ret < 0) {
1563                         dev_err(bdi->dev, "Can't read F reg: %d\n", ret);
1564                         return;
1565                 }
1566         } while (f_reg && ++i < 2);
1567
1568         /* ignore over/under voltage fault after disconnect */
1569         if (f_reg == (1 << BQ24190_REG_F_CHRG_FAULT_SHIFT) &&
1570             !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK))
1571                 f_reg = 0;
1572
1573         if (f_reg != bdi->f_reg) {
1574                 dev_warn(bdi->dev,
1575                         "Fault: boost %d, charge %d, battery %d, ntc %d\n",
1576                         !!(f_reg & BQ24190_REG_F_BOOST_FAULT_MASK),
1577                         !!(f_reg & BQ24190_REG_F_CHRG_FAULT_MASK),
1578                         !!(f_reg & BQ24190_REG_F_BAT_FAULT_MASK),
1579                         !!(f_reg & BQ24190_REG_F_NTC_FAULT_MASK));
1580
1581                 mutex_lock(&bdi->f_reg_lock);
1582                 if ((bdi->f_reg & battery_mask_f) != (f_reg & battery_mask_f))
1583                         alert_battery = true;
1584                 if ((bdi->f_reg & ~battery_mask_f) != (f_reg & ~battery_mask_f))
1585                         alert_charger = true;
1586                 bdi->f_reg = f_reg;
1587                 mutex_unlock(&bdi->f_reg_lock);
1588         }
1589
1590         if (ss_reg != bdi->ss_reg) {
1591                 /*
1592                  * The device is in host mode so when PG_STAT goes from 1->0
1593                  * (i.e., power removed) HIZ needs to be disabled.
1594                  */
1595                 if ((bdi->ss_reg & BQ24190_REG_SS_PG_STAT_MASK) &&
1596                                 !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK)) {
1597                         ret = bq24190_write_mask(bdi, BQ24190_REG_ISC,
1598                                         BQ24190_REG_ISC_EN_HIZ_MASK,
1599                                         BQ24190_REG_ISC_EN_HIZ_SHIFT,
1600                                         0);
1601                         if (ret < 0)
1602                                 dev_err(bdi->dev, "Can't access ISC reg: %d\n",
1603                                         ret);
1604                 }
1605
1606                 if ((bdi->ss_reg & battery_mask_ss) != (ss_reg & battery_mask_ss))
1607                         alert_battery = true;
1608                 if ((bdi->ss_reg & ~battery_mask_ss) != (ss_reg & ~battery_mask_ss))
1609                         alert_charger = true;
1610                 bdi->ss_reg = ss_reg;
1611         }
1612
1613         if (alert_charger || alert_battery)
1614                 power_supply_changed(bdi->charger);
1615         if (alert_battery && bdi->battery)
1616                 power_supply_changed(bdi->battery);
1617
1618         dev_dbg(bdi->dev, "ss_reg: 0x%02x, f_reg: 0x%02x\n", ss_reg, f_reg);
1619 }
1620
1621 static irqreturn_t bq24190_irq_handler_thread(int irq, void *data)
1622 {
1623         struct bq24190_dev_info *bdi = data;
1624         int error;
1625
1626         bdi->irq_event = true;
1627         error = pm_runtime_get_sync(bdi->dev);
1628         if (error < 0) {
1629                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1630                 pm_runtime_put_noidle(bdi->dev);
1631                 return IRQ_NONE;
1632         }
1633         bq24190_check_status(bdi);
1634         pm_runtime_mark_last_busy(bdi->dev);
1635         pm_runtime_put_autosuspend(bdi->dev);
1636         bdi->irq_event = false;
1637
1638         return IRQ_HANDLED;
1639 }
1640
1641 static void bq24190_extcon_work(struct work_struct *work)
1642 {
1643         struct bq24190_dev_info *bdi =
1644                 container_of(work, struct bq24190_dev_info, extcon_work.work);
1645         int error, iinlim = 0;
1646         u8 v;
1647
1648         error = pm_runtime_get_sync(bdi->dev);
1649         if (error < 0) {
1650                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1651                 pm_runtime_put_noidle(bdi->dev);
1652                 return;
1653         }
1654
1655         if      (extcon_get_state(bdi->extcon, EXTCON_CHG_USB_SDP) == 1)
1656                 iinlim =  500000;
1657         else if (extcon_get_state(bdi->extcon, EXTCON_CHG_USB_CDP) == 1 ||
1658                  extcon_get_state(bdi->extcon, EXTCON_CHG_USB_ACA) == 1)
1659                 iinlim = 1500000;
1660         else if (extcon_get_state(bdi->extcon, EXTCON_CHG_USB_DCP) == 1)
1661                 iinlim = 2000000;
1662
1663         if (iinlim) {
1664                 error = bq24190_set_field_val(bdi, BQ24190_REG_ISC,
1665                                               BQ24190_REG_ISC_IINLIM_MASK,
1666                                               BQ24190_REG_ISC_IINLIM_SHIFT,
1667                                               bq24190_isc_iinlim_values,
1668                                               ARRAY_SIZE(bq24190_isc_iinlim_values),
1669                                               iinlim);
1670                 if (error < 0)
1671                         dev_err(bdi->dev, "Can't set IINLIM: %d\n", error);
1672         }
1673
1674         /* if no charger found and in USB host mode, set OTG 5V boost, else normal */
1675         if (!iinlim && extcon_get_state(bdi->extcon, EXTCON_USB_HOST) == 1)
1676                 v = BQ24190_REG_POC_CHG_CONFIG_OTG;
1677         else
1678                 v = BQ24190_REG_POC_CHG_CONFIG_CHARGE;
1679
1680         error = bq24190_write_mask(bdi, BQ24190_REG_POC,
1681                                    BQ24190_REG_POC_CHG_CONFIG_MASK,
1682                                    BQ24190_REG_POC_CHG_CONFIG_SHIFT,
1683                                    v);
1684         if (error < 0)
1685                 dev_err(bdi->dev, "Can't set CHG_CONFIG: %d\n", error);
1686
1687         pm_runtime_mark_last_busy(bdi->dev);
1688         pm_runtime_put_autosuspend(bdi->dev);
1689 }
1690
1691 static int bq24190_extcon_event(struct notifier_block *nb, unsigned long event,
1692                                 void *param)
1693 {
1694         struct bq24190_dev_info *bdi =
1695                 container_of(nb, struct bq24190_dev_info, extcon_nb);
1696
1697         /*
1698          * The Power-Good detection may take up to 220ms, sometimes
1699          * the external charger detection is quicker, and the bq24190 will
1700          * reset to iinlim based on its own charger detection (which is not
1701          * hooked up when using external charger detection) resulting in
1702          * a too low default 500mA iinlim. Delay applying the extcon value
1703          * for 300ms to avoid this.
1704          */
1705         queue_delayed_work(system_wq, &bdi->extcon_work, msecs_to_jiffies(300));
1706
1707         return NOTIFY_OK;
1708 }
1709
1710 static int bq24190_hw_init(struct bq24190_dev_info *bdi)
1711 {
1712         u8 v;
1713         int ret;
1714
1715         /* First check that the device really is what its supposed to be */
1716         ret = bq24190_read_mask(bdi, BQ24190_REG_VPRS,
1717                         BQ24190_REG_VPRS_PN_MASK,
1718                         BQ24190_REG_VPRS_PN_SHIFT,
1719                         &v);
1720         if (ret < 0)
1721                 return ret;
1722
1723         if (v != BQ24190_REG_VPRS_PN_24190 &&
1724             v != BQ24190_REG_VPRS_PN_24192I) {
1725                 dev_err(bdi->dev, "Error unknown model: 0x%02x\n", v);
1726                 return -ENODEV;
1727         }
1728
1729         ret = bq24190_register_reset(bdi);
1730         if (ret < 0)
1731                 return ret;
1732
1733         ret = bq24190_set_config(bdi);
1734         if (ret < 0)
1735                 return ret;
1736
1737         return bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1738 }
1739
1740 static int bq24190_get_config(struct bq24190_dev_info *bdi)
1741 {
1742         const char * const s = "ti,system-minimum-microvolt";
1743         struct power_supply_battery_info info = {};
1744         int v;
1745
1746         if (device_property_read_u32(bdi->dev, s, &v) == 0) {
1747                 v /= 1000;
1748                 if (v >= BQ24190_REG_POC_SYS_MIN_MIN
1749                  && v <= BQ24190_REG_POC_SYS_MIN_MAX)
1750                         bdi->sys_min = v;
1751                 else
1752                         dev_warn(bdi->dev, "invalid value for %s: %u\n", s, v);
1753         }
1754
1755         if (bdi->dev->of_node &&
1756             !power_supply_get_battery_info(bdi->charger, &info)) {
1757                 v = info.precharge_current_ua / 1000;
1758                 if (v >= BQ24190_REG_PCTCC_IPRECHG_MIN
1759                  && v <= BQ24190_REG_PCTCC_IPRECHG_MAX)
1760                         bdi->iprechg = v;
1761                 else
1762                         dev_warn(bdi->dev, "invalid value for battery:precharge-current-microamp: %d\n",
1763                                  v);
1764
1765                 v = info.charge_term_current_ua / 1000;
1766                 if (v >= BQ24190_REG_PCTCC_ITERM_MIN
1767                  && v <= BQ24190_REG_PCTCC_ITERM_MAX)
1768                         bdi->iterm = v;
1769                 else
1770                         dev_warn(bdi->dev, "invalid value for battery:charge-term-current-microamp: %d\n",
1771                                  v);
1772         }
1773
1774         return 0;
1775 }
1776
1777 static int bq24190_probe(struct i2c_client *client,
1778                 const struct i2c_device_id *id)
1779 {
1780         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
1781         struct device *dev = &client->dev;
1782         struct power_supply_config charger_cfg = {}, battery_cfg = {};
1783         struct bq24190_dev_info *bdi;
1784         const char *name;
1785         int ret;
1786
1787         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1788                 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1789                 return -ENODEV;
1790         }
1791
1792         bdi = devm_kzalloc(dev, sizeof(*bdi), GFP_KERNEL);
1793         if (!bdi) {
1794                 dev_err(dev, "Can't alloc bdi struct\n");
1795                 return -ENOMEM;
1796         }
1797
1798         bdi->client = client;
1799         bdi->dev = dev;
1800         strncpy(bdi->model_name, id->name, I2C_NAME_SIZE);
1801         mutex_init(&bdi->f_reg_lock);
1802         bdi->f_reg = 0;
1803         bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1804         INIT_DELAYED_WORK(&bdi->input_current_limit_work,
1805                           bq24190_input_current_limit_work);
1806
1807         i2c_set_clientdata(client, bdi);
1808
1809         if (client->irq <= 0) {
1810                 dev_err(dev, "Can't get irq info\n");
1811                 return -EINVAL;
1812         }
1813
1814         /*
1815          * Devicetree platforms should get extcon via phandle (not yet supported).
1816          * On ACPI platforms, extcon clients may invoke us with:
1817          * struct property_entry pe[] =
1818          *   { PROPERTY_ENTRY_STRING("extcon-name", client_name), ... };
1819          * struct i2c_board_info bi =
1820          *   { .type = "bq24190", .addr = 0x6b, .properties = pe, .irq = irq };
1821          * struct i2c_adapter ad = { ... };
1822          * i2c_add_adapter(&ad);
1823          * i2c_new_device(&ad, &bi);
1824          */
1825         if (device_property_read_string(dev, "extcon-name", &name) == 0) {
1826                 bdi->extcon = extcon_get_extcon_dev(name);
1827                 if (!bdi->extcon)
1828                         return -EPROBE_DEFER;
1829
1830                 dev_info(bdi->dev, "using extcon device %s\n", name);
1831         }
1832
1833         pm_runtime_enable(dev);
1834         pm_runtime_use_autosuspend(dev);
1835         pm_runtime_set_autosuspend_delay(dev, 600);
1836         ret = pm_runtime_get_sync(dev);
1837         if (ret < 0) {
1838                 dev_err(dev, "pm_runtime_get failed: %i\n", ret);
1839                 goto out_pmrt;
1840         }
1841
1842         charger_cfg.drv_data = bdi;
1843         charger_cfg.of_node = dev->of_node;
1844         charger_cfg.supplied_to = bq24190_charger_supplied_to;
1845         charger_cfg.num_supplicants = ARRAY_SIZE(bq24190_charger_supplied_to),
1846         bdi->charger = power_supply_register(dev, &bq24190_charger_desc,
1847                                                 &charger_cfg);
1848         if (IS_ERR(bdi->charger)) {
1849                 dev_err(dev, "Can't register charger\n");
1850                 ret = PTR_ERR(bdi->charger);
1851                 goto out_pmrt;
1852         }
1853
1854         /* the battery class is deprecated and will be removed. */
1855         /* in the interim, this property hides it.              */
1856         if (!device_property_read_bool(dev, "omit-battery-class")) {
1857                 battery_cfg.drv_data = bdi;
1858                 bdi->battery = power_supply_register(dev, &bq24190_battery_desc,
1859                                                      &battery_cfg);
1860                 if (IS_ERR(bdi->battery)) {
1861                         dev_err(dev, "Can't register battery\n");
1862                         ret = PTR_ERR(bdi->battery);
1863                         goto out_charger;
1864                 }
1865         }
1866
1867         ret = bq24190_get_config(bdi);
1868         if (ret < 0) {
1869                 dev_err(dev, "Can't get devicetree config\n");
1870                 goto out_charger;
1871         }
1872
1873         ret = bq24190_hw_init(bdi);
1874         if (ret < 0) {
1875                 dev_err(dev, "Hardware init failed\n");
1876                 goto out_charger;
1877         }
1878
1879         ret = bq24190_sysfs_create_group(bdi);
1880         if (ret < 0) {
1881                 dev_err(dev, "Can't create sysfs entries\n");
1882                 goto out_charger;
1883         }
1884
1885         bdi->initialized = true;
1886
1887         ret = devm_request_threaded_irq(dev, client->irq, NULL,
1888                         bq24190_irq_handler_thread,
1889                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1890                         "bq24190-charger", bdi);
1891         if (ret < 0) {
1892                 dev_err(dev, "Can't set up irq handler\n");
1893                 goto out_sysfs;
1894         }
1895
1896         ret = bq24190_register_vbus_regulator(bdi);
1897         if (ret < 0)
1898                 goto out_sysfs;
1899
1900         if (bdi->extcon) {
1901                 INIT_DELAYED_WORK(&bdi->extcon_work, bq24190_extcon_work);
1902                 bdi->extcon_nb.notifier_call = bq24190_extcon_event;
1903                 ret = devm_extcon_register_notifier_all(dev, bdi->extcon,
1904                                                         &bdi->extcon_nb);
1905                 if (ret) {
1906                         dev_err(dev, "Can't register extcon\n");
1907                         goto out_sysfs;
1908                 }
1909
1910                 /* Sync initial cable state */
1911                 queue_delayed_work(system_wq, &bdi->extcon_work, 0);
1912         }
1913
1914         enable_irq_wake(client->irq);
1915
1916         pm_runtime_mark_last_busy(dev);
1917         pm_runtime_put_autosuspend(dev);
1918
1919         return 0;
1920
1921 out_sysfs:
1922         bq24190_sysfs_remove_group(bdi);
1923
1924 out_charger:
1925         if (!IS_ERR_OR_NULL(bdi->battery))
1926                 power_supply_unregister(bdi->battery);
1927         power_supply_unregister(bdi->charger);
1928
1929 out_pmrt:
1930         pm_runtime_put_sync(dev);
1931         pm_runtime_dont_use_autosuspend(dev);
1932         pm_runtime_disable(dev);
1933         return ret;
1934 }
1935
1936 static int bq24190_remove(struct i2c_client *client)
1937 {
1938         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1939         int error;
1940
1941         error = pm_runtime_get_sync(bdi->dev);
1942         if (error < 0) {
1943                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1944                 pm_runtime_put_noidle(bdi->dev);
1945         }
1946
1947         bq24190_register_reset(bdi);
1948         bq24190_sysfs_remove_group(bdi);
1949         if (bdi->battery)
1950                 power_supply_unregister(bdi->battery);
1951         power_supply_unregister(bdi->charger);
1952         if (error >= 0)
1953                 pm_runtime_put_sync(bdi->dev);
1954         pm_runtime_dont_use_autosuspend(bdi->dev);
1955         pm_runtime_disable(bdi->dev);
1956
1957         return 0;
1958 }
1959
1960 static __maybe_unused int bq24190_runtime_suspend(struct device *dev)
1961 {
1962         struct i2c_client *client = to_i2c_client(dev);
1963         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1964
1965         if (!bdi->initialized)
1966                 return 0;
1967
1968         dev_dbg(bdi->dev, "%s\n", __func__);
1969
1970         return 0;
1971 }
1972
1973 static __maybe_unused int bq24190_runtime_resume(struct device *dev)
1974 {
1975         struct i2c_client *client = to_i2c_client(dev);
1976         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1977
1978         if (!bdi->initialized)
1979                 return 0;
1980
1981         if (!bdi->irq_event) {
1982                 dev_dbg(bdi->dev, "checking events on possible wakeirq\n");
1983                 bq24190_check_status(bdi);
1984         }
1985
1986         return 0;
1987 }
1988
1989 static __maybe_unused int bq24190_pm_suspend(struct device *dev)
1990 {
1991         struct i2c_client *client = to_i2c_client(dev);
1992         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1993         int error;
1994
1995         error = pm_runtime_get_sync(bdi->dev);
1996         if (error < 0) {
1997                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1998                 pm_runtime_put_noidle(bdi->dev);
1999         }
2000
2001         bq24190_register_reset(bdi);
2002
2003         if (error >= 0) {
2004                 pm_runtime_mark_last_busy(bdi->dev);
2005                 pm_runtime_put_autosuspend(bdi->dev);
2006         }
2007
2008         return 0;
2009 }
2010
2011 static __maybe_unused int bq24190_pm_resume(struct device *dev)
2012 {
2013         struct i2c_client *client = to_i2c_client(dev);
2014         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
2015         int error;
2016
2017         bdi->f_reg = 0;
2018         bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
2019
2020         error = pm_runtime_get_sync(bdi->dev);
2021         if (error < 0) {
2022                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
2023                 pm_runtime_put_noidle(bdi->dev);
2024         }
2025
2026         bq24190_register_reset(bdi);
2027         bq24190_set_config(bdi);
2028         bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
2029
2030         if (error >= 0) {
2031                 pm_runtime_mark_last_busy(bdi->dev);
2032                 pm_runtime_put_autosuspend(bdi->dev);
2033         }
2034
2035         /* Things may have changed while suspended so alert upper layer */
2036         power_supply_changed(bdi->charger);
2037         if (bdi->battery)
2038                 power_supply_changed(bdi->battery);
2039
2040         return 0;
2041 }
2042
2043 static const struct dev_pm_ops bq24190_pm_ops = {
2044         SET_RUNTIME_PM_OPS(bq24190_runtime_suspend, bq24190_runtime_resume,
2045                            NULL)
2046         SET_SYSTEM_SLEEP_PM_OPS(bq24190_pm_suspend, bq24190_pm_resume)
2047 };
2048
2049 static const struct i2c_device_id bq24190_i2c_ids[] = {
2050         { "bq24190" },
2051         { "bq24192i" },
2052         { },
2053 };
2054 MODULE_DEVICE_TABLE(i2c, bq24190_i2c_ids);
2055
2056 #ifdef CONFIG_OF
2057 static const struct of_device_id bq24190_of_match[] = {
2058         { .compatible = "ti,bq24190", },
2059         { .compatible = "ti,bq24192i", },
2060         { },
2061 };
2062 MODULE_DEVICE_TABLE(of, bq24190_of_match);
2063 #else
2064 static const struct of_device_id bq24190_of_match[] = {
2065         { },
2066 };
2067 #endif
2068
2069 static struct i2c_driver bq24190_driver = {
2070         .probe          = bq24190_probe,
2071         .remove         = bq24190_remove,
2072         .id_table       = bq24190_i2c_ids,
2073         .driver = {
2074                 .name           = "bq24190-charger",
2075                 .pm             = &bq24190_pm_ops,
2076                 .of_match_table = of_match_ptr(bq24190_of_match),
2077         },
2078 };
2079 module_i2c_driver(bq24190_driver);
2080
2081 MODULE_LICENSE("GPL");
2082 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
2083 MODULE_DESCRIPTION("TI BQ24190 Charger Driver");