drivers/power/supply/bq24190_charger.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for the TI bq24190 battery charger.
   4  *
   5  * Author: Mark A. Greer <mgreer@animalcreek.com>
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/interrupt.h>
  10 #include <linux/delay.h>
  11 #include <linux/of_irq.h>
  12 #include <linux/of_device.h>
  13 #include <linux/pm_runtime.h>
  14 #include <linux/power_supply.h>
  15 #include <linux/power/bq24190_charger.h>
  16 #include <linux/regulator/driver.h>
  17 #include <linux/regulator/machine.h>
  18 #include <linux/workqueue.h>
  19 #include <linux/gpio.h>
  20 #include <linux/i2c.h>
  21 #include <linux/extcon-provider.h>
  22
  23 #define BQ24190_MANUFACTURER    "Texas Instruments"
  24
  25 #define BQ24190_REG_ISC         0x00 /* Input Source Control */
  26 #define BQ24190_REG_ISC_EN_HIZ_MASK             BIT(7)
  27 #define BQ24190_REG_ISC_EN_HIZ_SHIFT            7
  28 #define BQ24190_REG_ISC_VINDPM_MASK             (BIT(6) | BIT(5) | BIT(4) | \
  29                                                  BIT(3))
  30 #define BQ24190_REG_ISC_VINDPM_SHIFT            3
  31 #define BQ24190_REG_ISC_IINLIM_MASK             (BIT(2) | BIT(1) | BIT(0))
  32 #define BQ24190_REG_ISC_IINLIM_SHIFT            0
  33
  34 #define BQ24190_REG_POC         0x01 /* Power-On Configuration */
  35 #define BQ24190_REG_POC_RESET_MASK              BIT(7)
  36 #define BQ24190_REG_POC_RESET_SHIFT             7
  37 #define BQ24190_REG_POC_WDT_RESET_MASK          BIT(6)
  38 #define BQ24190_REG_POC_WDT_RESET_SHIFT         6
  39 #define BQ24190_REG_POC_CHG_CONFIG_MASK         (BIT(5) | BIT(4))
  40 #define BQ24190_REG_POC_CHG_CONFIG_SHIFT        4
  41 #define BQ24190_REG_POC_CHG_CONFIG_DISABLE              0x0
  42 #define BQ24190_REG_POC_CHG_CONFIG_CHARGE               0x1
  43 #define BQ24190_REG_POC_CHG_CONFIG_OTG                  0x2
  44 #define BQ24190_REG_POC_CHG_CONFIG_OTG_ALT              0x3
  45 #define BQ24190_REG_POC_SYS_MIN_MASK            (BIT(3) | BIT(2) | BIT(1))
  46 #define BQ24190_REG_POC_SYS_MIN_SHIFT           1
  47 #define BQ24190_REG_POC_SYS_MIN_MIN                     3000
  48 #define BQ24190_REG_POC_SYS_MIN_MAX                     3700
  49 #define BQ24190_REG_POC_BOOST_LIM_MASK          BIT(0)
  50 #define BQ24190_REG_POC_BOOST_LIM_SHIFT         0
  51
  52 #define BQ24190_REG_CCC         0x02 /* Charge Current Control */
  53 #define BQ24190_REG_CCC_ICHG_MASK               (BIT(7) | BIT(6) | BIT(5) | \
  54                                                  BIT(4) | BIT(3) | BIT(2))
  55 #define BQ24190_REG_CCC_ICHG_SHIFT              2
  56 #define BQ24190_REG_CCC_FORCE_20PCT_MASK        BIT(0)
  57 #define BQ24190_REG_CCC_FORCE_20PCT_SHIFT       0
  58
  59 #define BQ24190_REG_PCTCC       0x03 /* Pre-charge/Termination Current Cntl */
  60 #define BQ24190_REG_PCTCC_IPRECHG_MASK          (BIT(7) | BIT(6) | BIT(5) | \
  61                                                  BIT(4))
  62 #define BQ24190_REG_PCTCC_IPRECHG_SHIFT         4
  63 #define BQ24190_REG_PCTCC_IPRECHG_MIN                   128
  64 #define BQ24190_REG_PCTCC_IPRECHG_MAX                   2048
  65 #define BQ24190_REG_PCTCC_ITERM_MASK            (BIT(3) | BIT(2) | BIT(1) | \
  66                                                  BIT(0))
  67 #define BQ24190_REG_PCTCC_ITERM_SHIFT           0
  68 #define BQ24190_REG_PCTCC_ITERM_MIN                     128
  69 #define BQ24190_REG_PCTCC_ITERM_MAX                     2048
  70
  71 #define BQ24190_REG_CVC         0x04 /* Charge Voltage Control */
  72 #define BQ24190_REG_CVC_VREG_MASK               (BIT(7) | BIT(6) | BIT(5) | \
  73                                                  BIT(4) | BIT(3) | BIT(2))
  74 #define BQ24190_REG_CVC_VREG_SHIFT              2
  75 #define BQ24190_REG_CVC_BATLOWV_MASK            BIT(1)
  76 #define BQ24190_REG_CVC_BATLOWV_SHIFT           1
  77 #define BQ24190_REG_CVC_VRECHG_MASK             BIT(0)
  78 #define BQ24190_REG_CVC_VRECHG_SHIFT            0
  79
  80 #define BQ24190_REG_CTTC        0x05 /* Charge Term/Timer Control */
  81 #define BQ24190_REG_CTTC_EN_TERM_MASK           BIT(7)
  82 #define BQ24190_REG_CTTC_EN_TERM_SHIFT          7
  83 #define BQ24190_REG_CTTC_TERM_STAT_MASK         BIT(6)
  84 #define BQ24190_REG_CTTC_TERM_STAT_SHIFT        6
  85 #define BQ24190_REG_CTTC_WATCHDOG_MASK          (BIT(5) | BIT(4))
  86 #define BQ24190_REG_CTTC_WATCHDOG_SHIFT         4
  87 #define BQ24190_REG_CTTC_EN_TIMER_MASK          BIT(3)
  88 #define BQ24190_REG_CTTC_EN_TIMER_SHIFT         3
  89 #define BQ24190_REG_CTTC_CHG_TIMER_MASK         (BIT(2) | BIT(1))
  90 #define BQ24190_REG_CTTC_CHG_TIMER_SHIFT        1
  91 #define BQ24190_REG_CTTC_JEITA_ISET_MASK        BIT(0)
  92 #define BQ24190_REG_CTTC_JEITA_ISET_SHIFT       0
  93
  94 #define BQ24190_REG_ICTRC       0x06 /* IR Comp/Thermal Regulation Control */
  95 #define BQ24190_REG_ICTRC_BAT_COMP_MASK         (BIT(7) | BIT(6) | BIT(5))
  96 #define BQ24190_REG_ICTRC_BAT_COMP_SHIFT        5
  97 #define BQ24190_REG_ICTRC_VCLAMP_MASK           (BIT(4) | BIT(3) | BIT(2))
  98 #define BQ24190_REG_ICTRC_VCLAMP_SHIFT          2
  99 #define BQ24190_REG_ICTRC_TREG_MASK             (BIT(1) | BIT(0))
 100 #define BQ24190_REG_ICTRC_TREG_SHIFT            0
 101
 102 #define BQ24190_REG_MOC         0x07 /* Misc. Operation Control */
 103 #define BQ24190_REG_MOC_DPDM_EN_MASK            BIT(7)
 104 #define BQ24190_REG_MOC_DPDM_EN_SHIFT           7
 105 #define BQ24190_REG_MOC_TMR2X_EN_MASK           BIT(6)
 106 #define BQ24190_REG_MOC_TMR2X_EN_SHIFT          6
 107 #define BQ24190_REG_MOC_BATFET_DISABLE_MASK     BIT(5)
 108 #define BQ24190_REG_MOC_BATFET_DISABLE_SHIFT    5
 109 #define BQ24190_REG_MOC_JEITA_VSET_MASK         BIT(4)
 110 #define BQ24190_REG_MOC_JEITA_VSET_SHIFT        4
 111 #define BQ24190_REG_MOC_INT_MASK_MASK           (BIT(1) | BIT(0))
 112 #define BQ24190_REG_MOC_INT_MASK_SHIFT          0
 113
 114 #define BQ24190_REG_SS          0x08 /* System Status */
 115 #define BQ24190_REG_SS_VBUS_STAT_MASK           (BIT(7) | BIT(6))
 116 #define BQ24190_REG_SS_VBUS_STAT_SHIFT          6
 117 #define BQ24190_REG_SS_CHRG_STAT_MASK           (BIT(5) | BIT(4))
 118 #define BQ24190_REG_SS_CHRG_STAT_SHIFT          4
 119 #define BQ24190_REG_SS_DPM_STAT_MASK            BIT(3)
 120 #define BQ24190_REG_SS_DPM_STAT_SHIFT           3
 121 #define BQ24190_REG_SS_PG_STAT_MASK             BIT(2)
 122 #define BQ24190_REG_SS_PG_STAT_SHIFT            2
 123 #define BQ24190_REG_SS_THERM_STAT_MASK          BIT(1)
 124 #define BQ24190_REG_SS_THERM_STAT_SHIFT         1
 125 #define BQ24190_REG_SS_VSYS_STAT_MASK           BIT(0)
 126 #define BQ24190_REG_SS_VSYS_STAT_SHIFT          0
 127
 128 #define BQ24190_REG_F           0x09 /* Fault */
 129 #define BQ24190_REG_F_WATCHDOG_FAULT_MASK       BIT(7)
 130 #define BQ24190_REG_F_WATCHDOG_FAULT_SHIFT      7
 131 #define BQ24190_REG_F_BOOST_FAULT_MASK          BIT(6)
 132 #define BQ24190_REG_F_BOOST_FAULT_SHIFT         6
 133 #define BQ24190_REG_F_CHRG_FAULT_MASK           (BIT(5) | BIT(4))
 134 #define BQ24190_REG_F_CHRG_FAULT_SHIFT          4
 135 #define BQ24190_REG_F_BAT_FAULT_MASK            BIT(3)
 136 #define BQ24190_REG_F_BAT_FAULT_SHIFT           3
 137 #define BQ24190_REG_F_NTC_FAULT_MASK            (BIT(2) | BIT(1) | BIT(0))
 138 #define BQ24190_REG_F_NTC_FAULT_SHIFT           0
 139
 140 #define BQ24190_REG_VPRS        0x0A /* Vendor/Part/Revision Status */
 141 #define BQ24190_REG_VPRS_PN_MASK                (BIT(5) | BIT(4) | BIT(3))
 142 #define BQ24190_REG_VPRS_PN_SHIFT               3
 143 #define BQ24190_REG_VPRS_PN_24190                       0x4
 144 #define BQ24190_REG_VPRS_PN_24192                       0x5 /* Also 24193, 24196 */
 145 #define BQ24190_REG_VPRS_PN_24192I                      0x3
 146 #define BQ24190_REG_VPRS_TS_PROFILE_MASK        BIT(2)
 147 #define BQ24190_REG_VPRS_TS_PROFILE_SHIFT       2
 148 #define BQ24190_REG_VPRS_DEV_REG_MASK           (BIT(1) | BIT(0))
 149 #define BQ24190_REG_VPRS_DEV_REG_SHIFT          0
 150
 151 /*
 152  * The FAULT register is latched by the bq24190 (except for NTC_FAULT)
 153  * so the first read after a fault returns the latched value and subsequent
 154  * reads return the current value.  In order to return the fault status
 155  * to the user, have the interrupt handler save the reg's value and retrieve
 156  * it in the appropriate health/status routine.
 157  */
 158 struct bq24190_dev_info {
 159         struct i2c_client               *client;
 160         struct device                   *dev;
 161         struct extcon_dev               *edev;
 162         struct power_supply             *charger;
 163         struct power_supply             *battery;
 164         struct delayed_work             input_current_limit_work;
 165         char                            model_name[I2C_NAME_SIZE];
 166         bool                            initialized;
 167         bool                            irq_event;
 168         u16                             sys_min;
 169         u16                             iprechg;
 170         u16                             iterm;
 171         struct mutex                    f_reg_lock;
 172         u8                              f_reg;
 173         u8                              ss_reg;
 174         u8                              watchdog;
 175 };
 176
 177 static const unsigned int bq24190_usb_extcon_cable[] = {
 178         EXTCON_USB,
 179         EXTCON_NONE,
 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 ATTRIBUTE_GROUPS(bq24190_sysfs);
 411
 412 static void bq24190_sysfs_init_attrs(void)
 413 {
 414         int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
 415
 416         for (i = 0; i < limit; i++)
 417                 bq24190_sysfs_attrs[i] = &bq24190_sysfs_field_tbl[i].attr.attr;
 418
 419         bq24190_sysfs_attrs[limit] = NULL; /* Has additional entry for this */
 420 }
 421
 422 static struct bq24190_sysfs_field_info *bq24190_sysfs_field_lookup(
 423                 const char *name)
 424 {
 425         int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
 426
 427         for (i = 0; i < limit; i++)
 428                 if (!strcmp(name, bq24190_sysfs_field_tbl[i].attr.attr.name))
 429                         break;
 430
 431         if (i >= limit)
 432                 return NULL;
 433
 434         return &bq24190_sysfs_field_tbl[i];
 435 }
 436
 437 static ssize_t bq24190_sysfs_show(struct device *dev,
 438                 struct device_attribute *attr, char *buf)
 439 {
 440         struct power_supply *psy = dev_get_drvdata(dev);
 441         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
 442         struct bq24190_sysfs_field_info *info;
 443         ssize_t count;
 444         int ret;
 445         u8 v;
 446
 447         info = bq24190_sysfs_field_lookup(attr->attr.name);
 448         if (!info)
 449                 return -EINVAL;
 450
 451         ret = pm_runtime_get_sync(bdi->dev);
 452         if (ret < 0) {
 453                 pm_runtime_put_noidle(bdi->dev);
 454                 return ret;
 455         }
 456
 457         ret = bq24190_read_mask(bdi, info->reg, info->mask, info->shift, &v);
 458         if (ret)
 459                 count = ret;
 460         else
 461                 count = scnprintf(buf, PAGE_SIZE, "%hhx\n", v);
 462
 463         pm_runtime_mark_last_busy(bdi->dev);
 464         pm_runtime_put_autosuspend(bdi->dev);
 465
 466         return count;
 467 }
 468
 469 static ssize_t bq24190_sysfs_store(struct device *dev,
 470                 struct device_attribute *attr, const char *buf, size_t count)
 471 {
 472         struct power_supply *psy = dev_get_drvdata(dev);
 473         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
 474         struct bq24190_sysfs_field_info *info;
 475         int ret;
 476         u8 v;
 477
 478         info = bq24190_sysfs_field_lookup(attr->attr.name);
 479         if (!info)
 480                 return -EINVAL;
 481
 482         ret = kstrtou8(buf, 0, &v);
 483         if (ret < 0)
 484                 return ret;
 485
 486         ret = pm_runtime_get_sync(bdi->dev);
 487         if (ret < 0) {
 488                 pm_runtime_put_noidle(bdi->dev);
 489                 return ret;
 490         }
 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 #endif
 502
 503 #ifdef CONFIG_REGULATOR
 504 static int bq24190_set_charge_mode(struct regulator_dev *dev, u8 val)
 505 {
 506         struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
 507         int ret;
 508
 509         ret = pm_runtime_get_sync(bdi->dev);
 510         if (ret < 0) {
 511                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
 512                 pm_runtime_put_noidle(bdi->dev);
 513                 return ret;
 514         }
 515
 516         ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
 517                                  BQ24190_REG_POC_CHG_CONFIG_MASK,
 518                                  BQ24190_REG_POC_CHG_CONFIG_SHIFT, val);
 519
 520         pm_runtime_mark_last_busy(bdi->dev);
 521         pm_runtime_put_autosuspend(bdi->dev);
 522
 523         return ret;
 524 }
 525
 526 static int bq24190_vbus_enable(struct regulator_dev *dev)
 527 {
 528         return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_OTG);
 529 }
 530
 531 static int bq24190_vbus_disable(struct regulator_dev *dev)
 532 {
 533         return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_CHARGE);
 534 }
 535
 536 static int bq24190_vbus_is_enabled(struct regulator_dev *dev)
 537 {
 538         struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
 539         int ret;
 540         u8 val;
 541
 542         ret = pm_runtime_get_sync(bdi->dev);
 543         if (ret < 0) {
 544                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
 545                 pm_runtime_put_noidle(bdi->dev);
 546                 return ret;
 547         }
 548
 549         ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
 550                                 BQ24190_REG_POC_CHG_CONFIG_MASK,
 551                                 BQ24190_REG_POC_CHG_CONFIG_SHIFT, &val);
 552
 553         pm_runtime_mark_last_busy(bdi->dev);
 554         pm_runtime_put_autosuspend(bdi->dev);
 555
 556         if (ret)
 557                 return ret;
 558
 559         return (val == BQ24190_REG_POC_CHG_CONFIG_OTG ||
 560                 val == BQ24190_REG_POC_CHG_CONFIG_OTG_ALT);
 561 }
 562
 563 static const struct regulator_ops bq24190_vbus_ops = {
 564         .enable = bq24190_vbus_enable,
 565         .disable = bq24190_vbus_disable,
 566         .is_enabled = bq24190_vbus_is_enabled,
 567 };
 568
 569 static const struct regulator_desc bq24190_vbus_desc = {
 570         .name = "usb_otg_vbus",
 571         .of_match = "usb-otg-vbus",
 572         .type = REGULATOR_VOLTAGE,
 573         .owner = THIS_MODULE,
 574         .ops = &bq24190_vbus_ops,
 575         .fixed_uV = 5000000,
 576         .n_voltages = 1,
 577 };
 578
 579 static const struct regulator_init_data bq24190_vbus_init_data = {
 580         .constraints = {
 581                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
 582         },
 583 };
 584
 585 static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
 586 {
 587         struct bq24190_platform_data *pdata = bdi->dev->platform_data;
 588         struct regulator_config cfg = { };
 589         struct regulator_dev *reg;
 590         int ret = 0;
 591
 592         cfg.dev = bdi->dev;
 593         if (pdata && pdata->regulator_init_data)
 594                 cfg.init_data = pdata->regulator_init_data;
 595         else
 596                 cfg.init_data = &bq24190_vbus_init_data;
 597         cfg.driver_data = bdi;
 598         reg = devm_regulator_register(bdi->dev, &bq24190_vbus_desc, &cfg);
 599         if (IS_ERR(reg)) {
 600                 ret = PTR_ERR(reg);
 601                 dev_err(bdi->dev, "Can't register regulator: %d\n", ret);
 602         }
 603
 604         return ret;
 605 }
 606 #else
 607 static int bq24190_register_vbus_regulator(struct bq24190_dev_info *bdi)
 608 {
 609         return 0;
 610 }
 611 #endif
 612
 613 static int bq24190_set_config(struct bq24190_dev_info *bdi)
 614 {
 615         int ret;
 616         u8 v;
 617
 618         ret = bq24190_read(bdi, BQ24190_REG_CTTC, &v);
 619         if (ret < 0)
 620                 return ret;
 621
 622         bdi->watchdog = ((v & BQ24190_REG_CTTC_WATCHDOG_MASK) >>
 623                                         BQ24190_REG_CTTC_WATCHDOG_SHIFT);
 624
 625         /*
 626          * According to the "Host Mode and default Mode" section of the
 627          * manual, a write to any register causes the bq24190 to switch
 628          * from default mode to host mode.  It will switch back to default
 629          * mode after a WDT timeout unless the WDT is turned off as well.
 630          * So, by simply turning off the WDT, we accomplish both with the
 631          * same write.
 632          */
 633         v &= ~BQ24190_REG_CTTC_WATCHDOG_MASK;
 634
 635         ret = bq24190_write(bdi, BQ24190_REG_CTTC, v);
 636         if (ret < 0)
 637                 return ret;
 638
 639         if (bdi->sys_min) {
 640                 v = bdi->sys_min / 100 - 30; // manual section 9.5.1.2, table 9
 641                 ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
 642                                          BQ24190_REG_POC_SYS_MIN_MASK,
 643                                          BQ24190_REG_POC_SYS_MIN_SHIFT,
 644                                          v);
 645                 if (ret < 0)
 646                         return ret;
 647         }
 648
 649         if (bdi->iprechg) {
 650                 v = bdi->iprechg / 128 - 1; // manual section 9.5.1.4, table 11
 651                 ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
 652                                          BQ24190_REG_PCTCC_IPRECHG_MASK,
 653                                          BQ24190_REG_PCTCC_IPRECHG_SHIFT,
 654                                          v);
 655                 if (ret < 0)
 656                         return ret;
 657         }
 658
 659         if (bdi->iterm) {
 660                 v = bdi->iterm / 128 - 1; // manual section 9.5.1.4, table 11
 661                 ret = bq24190_write_mask(bdi, BQ24190_REG_PCTCC,
 662                                          BQ24190_REG_PCTCC_ITERM_MASK,
 663                                          BQ24190_REG_PCTCC_ITERM_SHIFT,
 664                                          v);
 665                 if (ret < 0)
 666                         return ret;
 667         }
 668
 669         return 0;
 670 }
 671
 672 static int bq24190_register_reset(struct bq24190_dev_info *bdi)
 673 {
 674         int ret, limit = 100;
 675         u8 v;
 676
 677         /*
 678          * This prop. can be passed on device instantiation from platform code:
 679          * struct property_entry pe[] =
 680          *   { PROPERTY_ENTRY_BOOL("disable-reset"), ... };
 681          * struct i2c_board_info bi =
 682          *   { .type = "bq24190", .addr = 0x6b, .properties = pe, .irq = irq };
 683          * struct i2c_adapter ad = { ... };
 684          * i2c_add_adapter(&ad);
 685          * i2c_new_client_device(&ad, &bi);
 686          */
 687         if (device_property_read_bool(bdi->dev, "disable-reset"))
 688                 return 0;
 689
 690         /* Reset the registers */
 691         ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
 692                         BQ24190_REG_POC_RESET_MASK,
 693                         BQ24190_REG_POC_RESET_SHIFT,
 694                         0x1);
 695         if (ret < 0)
 696                 return ret;
 697
 698         /* Reset bit will be cleared by hardware so poll until it is */
 699         do {
 700                 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
 701                                 BQ24190_REG_POC_RESET_MASK,
 702                                 BQ24190_REG_POC_RESET_SHIFT,
 703                                 &v);
 704                 if (ret < 0)
 705                         return ret;
 706
 707                 if (v == 0)
 708                         return 0;
 709
 710                 usleep_range(100, 200);
 711         } while (--limit);
 712
 713         return -EIO;
 714 }
 715
 716 /* Charger power supply property routines */
 717
 718 static int bq24190_charger_get_charge_type(struct bq24190_dev_info *bdi,
 719                 union power_supply_propval *val)
 720 {
 721         u8 v;
 722         int type, ret;
 723
 724         ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
 725                         BQ24190_REG_POC_CHG_CONFIG_MASK,
 726                         BQ24190_REG_POC_CHG_CONFIG_SHIFT,
 727                         &v);
 728         if (ret < 0)
 729                 return ret;
 730
 731         /* If POC[CHG_CONFIG] (REG01[5:4]) == 0, charge is disabled */
 732         if (!v) {
 733                 type = POWER_SUPPLY_CHARGE_TYPE_NONE;
 734         } else {
 735                 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
 736                                 BQ24190_REG_CCC_FORCE_20PCT_MASK,
 737                                 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
 738                                 &v);
 739                 if (ret < 0)
 740                         return ret;
 741
 742                 type = (v) ? POWER_SUPPLY_CHARGE_TYPE_TRICKLE :
 743                              POWER_SUPPLY_CHARGE_TYPE_FAST;
 744         }
 745
 746         val->intval = type;
 747
 748         return 0;
 749 }
 750
 751 static int bq24190_charger_set_charge_type(struct bq24190_dev_info *bdi,
 752                 const union power_supply_propval *val)
 753 {
 754         u8 chg_config, force_20pct, en_term;
 755         int ret;
 756
 757         /*
 758          * According to the "Termination when REG02[0] = 1" section of
 759          * the bq24190 manual, the trickle charge could be less than the
 760          * termination current so it recommends turning off the termination
 761          * function.
 762          *
 763          * Note: AFAICT from the datasheet, the user will have to manually
 764          * turn off the charging when in 20% mode.  If its not turned off,
 765          * there could be battery damage.  So, use this mode at your own risk.
 766          */
 767         switch (val->intval) {
 768         case POWER_SUPPLY_CHARGE_TYPE_NONE:
 769                 chg_config = 0x0;
 770                 break;
 771         case POWER_SUPPLY_CHARGE_TYPE_TRICKLE:
 772                 chg_config = 0x1;
 773                 force_20pct = 0x1;
 774                 en_term = 0x0;
 775                 break;
 776         case POWER_SUPPLY_CHARGE_TYPE_FAST:
 777                 chg_config = 0x1;
 778                 force_20pct = 0x0;
 779                 en_term = 0x1;
 780                 break;
 781         default:
 782                 return -EINVAL;
 783         }
 784
 785         if (chg_config) { /* Enabling the charger */
 786                 ret = bq24190_write_mask(bdi, BQ24190_REG_CCC,
 787                                 BQ24190_REG_CCC_FORCE_20PCT_MASK,
 788                                 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
 789                                 force_20pct);
 790                 if (ret < 0)
 791                         return ret;
 792
 793                 ret = bq24190_write_mask(bdi, BQ24190_REG_CTTC,
 794                                 BQ24190_REG_CTTC_EN_TERM_MASK,
 795                                 BQ24190_REG_CTTC_EN_TERM_SHIFT,
 796                                 en_term);
 797                 if (ret < 0)
 798                         return ret;
 799         }
 800
 801         return bq24190_write_mask(bdi, BQ24190_REG_POC,
 802                         BQ24190_REG_POC_CHG_CONFIG_MASK,
 803                         BQ24190_REG_POC_CHG_CONFIG_SHIFT, chg_config);
 804 }
 805
 806 static int bq24190_charger_get_health(struct bq24190_dev_info *bdi,
 807                 union power_supply_propval *val)
 808 {
 809         u8 v;
 810         int health;
 811
 812         mutex_lock(&bdi->f_reg_lock);
 813         v = bdi->f_reg;
 814         mutex_unlock(&bdi->f_reg_lock);
 815
 816         if (v & BQ24190_REG_F_NTC_FAULT_MASK) {
 817                 switch (v >> BQ24190_REG_F_NTC_FAULT_SHIFT & 0x7) {
 818                 case 0x1: /* TS1  Cold */
 819                 case 0x3: /* TS2  Cold */
 820                 case 0x5: /* Both Cold */
 821                         health = POWER_SUPPLY_HEALTH_COLD;
 822                         break;
 823                 case 0x2: /* TS1  Hot */
 824                 case 0x4: /* TS2  Hot */
 825                 case 0x6: /* Both Hot */
 826                         health = POWER_SUPPLY_HEALTH_OVERHEAT;
 827                         break;
 828                 default:
 829                         health = POWER_SUPPLY_HEALTH_UNKNOWN;
 830                 }
 831         } else if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
 832                 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 833         } else if (v & BQ24190_REG_F_CHRG_FAULT_MASK) {
 834                 switch (v >> BQ24190_REG_F_CHRG_FAULT_SHIFT & 0x3) {
 835                 case 0x1: /* Input Fault (VBUS OVP or VBAT<VBUS<3.8V) */
 836                         /*
 837                          * This could be over-voltage or under-voltage
 838                          * and there's no way to tell which.  Instead
 839                          * of looking foolish and returning 'OVERVOLTAGE'
 840                          * when its really under-voltage, just return
 841                          * 'UNSPEC_FAILURE'.
 842                          */
 843                         health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 844                         break;
 845                 case 0x2: /* Thermal Shutdown */
 846                         health = POWER_SUPPLY_HEALTH_OVERHEAT;
 847                         break;
 848                 case 0x3: /* Charge Safety Timer Expiration */
 849                         health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 850                         break;
 851                 default:  /* prevent compiler warning */
 852                         health = -1;
 853                 }
 854         } else if (v & BQ24190_REG_F_BOOST_FAULT_MASK) {
 855                 /*
 856                  * This could be over-current or over-voltage but there's
 857                  * no way to tell which.  Return 'OVERVOLTAGE' since there
 858                  * isn't an 'OVERCURRENT' value defined that we can return
 859                  * even if it was over-current.
 860                  */
 861                 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 862         } else {
 863                 health = POWER_SUPPLY_HEALTH_GOOD;
 864         }
 865
 866         val->intval = health;
 867
 868         return 0;
 869 }
 870
 871 static int bq24190_charger_get_online(struct bq24190_dev_info *bdi,
 872                 union power_supply_propval *val)
 873 {
 874         u8 pg_stat, batfet_disable;
 875         int ret;
 876
 877         ret = bq24190_read_mask(bdi, BQ24190_REG_SS,
 878                         BQ24190_REG_SS_PG_STAT_MASK,
 879                         BQ24190_REG_SS_PG_STAT_SHIFT, &pg_stat);
 880         if (ret < 0)
 881                 return ret;
 882
 883         ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
 884                         BQ24190_REG_MOC_BATFET_DISABLE_MASK,
 885                         BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
 886         if (ret < 0)
 887                 return ret;
 888
 889         val->intval = pg_stat && !batfet_disable;
 890
 891         return 0;
 892 }
 893
 894 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
 895                                       const union power_supply_propval *val);
 896 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
 897                                       union power_supply_propval *val);
 898 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
 899                                               union power_supply_propval *val);
 900 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
 901                                               const union power_supply_propval *val);
 902
 903 static int bq24190_charger_set_online(struct bq24190_dev_info *bdi,
 904                                       const union power_supply_propval *val)
 905 {
 906         return bq24190_battery_set_online(bdi, val);
 907 }
 908
 909 static int bq24190_charger_get_status(struct bq24190_dev_info *bdi,
 910                                       union power_supply_propval *val)
 911 {
 912         return bq24190_battery_get_status(bdi, val);
 913 }
 914
 915 static int bq24190_charger_get_temp_alert_max(struct bq24190_dev_info *bdi,
 916                                               union power_supply_propval *val)
 917 {
 918         return bq24190_battery_get_temp_alert_max(bdi, val);
 919 }
 920
 921 static int bq24190_charger_set_temp_alert_max(struct bq24190_dev_info *bdi,
 922                                               const union power_supply_propval *val)
 923 {
 924         return bq24190_battery_set_temp_alert_max(bdi, val);
 925 }
 926
 927 static int bq24190_charger_get_precharge(struct bq24190_dev_info *bdi,
 928                 union power_supply_propval *val)
 929 {
 930         u8 v;
 931         int ret;
 932
 933         ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
 934                         BQ24190_REG_PCTCC_IPRECHG_MASK,
 935                         BQ24190_REG_PCTCC_IPRECHG_SHIFT, &v);
 936         if (ret < 0)
 937                 return ret;
 938
 939         val->intval = ++v * 128 * 1000;
 940         return 0;
 941 }
 942
 943 static int bq24190_charger_get_charge_term(struct bq24190_dev_info *bdi,
 944                 union power_supply_propval *val)
 945 {
 946         u8 v;
 947         int ret;
 948
 949         ret = bq24190_read_mask(bdi, BQ24190_REG_PCTCC,
 950                         BQ24190_REG_PCTCC_ITERM_MASK,
 951                         BQ24190_REG_PCTCC_ITERM_SHIFT, &v);
 952         if (ret < 0)
 953                 return ret;
 954
 955         val->intval = ++v * 128 * 1000;
 956         return 0;
 957 }
 958
 959 static int bq24190_charger_get_current(struct bq24190_dev_info *bdi,
 960                 union power_supply_propval *val)
 961 {
 962         u8 v;
 963         int curr, ret;
 964
 965         ret = bq24190_get_field_val(bdi, BQ24190_REG_CCC,
 966                         BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
 967                         bq24190_ccc_ichg_values,
 968                         ARRAY_SIZE(bq24190_ccc_ichg_values), &curr);
 969         if (ret < 0)
 970                 return ret;
 971
 972         ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
 973                         BQ24190_REG_CCC_FORCE_20PCT_MASK,
 974                         BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
 975         if (ret < 0)
 976                 return ret;
 977
 978         /* If FORCE_20PCT is enabled, then current is 20% of ICHG value */
 979         if (v)
 980                 curr /= 5;
 981
 982         val->intval = curr;
 983         return 0;
 984 }
 985
 986 static int bq24190_charger_get_current_max(struct bq24190_dev_info *bdi,
 987                 union power_supply_propval *val)
 988 {
 989         int idx = ARRAY_SIZE(bq24190_ccc_ichg_values) - 1;
 990
 991         val->intval = bq24190_ccc_ichg_values[idx];
 992         return 0;
 993 }
 994
 995 static int bq24190_charger_set_current(struct bq24190_dev_info *bdi,
 996                 const union power_supply_propval *val)
 997 {
 998         u8 v;
 999         int ret, curr = val->intval;
1000
1001         ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
1002                         BQ24190_REG_CCC_FORCE_20PCT_MASK,
1003                         BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
1004         if (ret < 0)
1005                 return ret;
1006
1007         /* If FORCE_20PCT is enabled, have to multiply value passed in by 5 */
1008         if (v)
1009                 curr *= 5;
1010
1011         return bq24190_set_field_val(bdi, BQ24190_REG_CCC,
1012                         BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
1013                         bq24190_ccc_ichg_values,
1014                         ARRAY_SIZE(bq24190_ccc_ichg_values), curr);
1015 }
1016
1017 static int bq24190_charger_get_voltage(struct bq24190_dev_info *bdi,
1018                 union power_supply_propval *val)
1019 {
1020         int voltage, ret;
1021
1022         ret = bq24190_get_field_val(bdi, BQ24190_REG_CVC,
1023                         BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
1024                         bq24190_cvc_vreg_values,
1025                         ARRAY_SIZE(bq24190_cvc_vreg_values), &voltage);
1026         if (ret < 0)
1027                 return ret;
1028
1029         val->intval = voltage;
1030         return 0;
1031 }
1032
1033 static int bq24190_charger_get_voltage_max(struct bq24190_dev_info *bdi,
1034                 union power_supply_propval *val)
1035 {
1036         int idx = ARRAY_SIZE(bq24190_cvc_vreg_values) - 1;
1037
1038         val->intval = bq24190_cvc_vreg_values[idx];
1039         return 0;
1040 }
1041
1042 static int bq24190_charger_set_voltage(struct bq24190_dev_info *bdi,
1043                 const union power_supply_propval *val)
1044 {
1045         return bq24190_set_field_val(bdi, BQ24190_REG_CVC,
1046                         BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
1047                         bq24190_cvc_vreg_values,
1048                         ARRAY_SIZE(bq24190_cvc_vreg_values), val->intval);
1049 }
1050
1051 static int bq24190_charger_get_iinlimit(struct bq24190_dev_info *bdi,
1052                 union power_supply_propval *val)
1053 {
1054         int iinlimit, ret;
1055
1056         ret = bq24190_get_field_val(bdi, BQ24190_REG_ISC,
1057                         BQ24190_REG_ISC_IINLIM_MASK,
1058                         BQ24190_REG_ISC_IINLIM_SHIFT,
1059                         bq24190_isc_iinlim_values,
1060                         ARRAY_SIZE(bq24190_isc_iinlim_values), &iinlimit);
1061         if (ret < 0)
1062                 return ret;
1063
1064         val->intval = iinlimit;
1065         return 0;
1066 }
1067
1068 static int bq24190_charger_set_iinlimit(struct bq24190_dev_info *bdi,
1069                 const union power_supply_propval *val)
1070 {
1071         return bq24190_set_field_val(bdi, BQ24190_REG_ISC,
1072                         BQ24190_REG_ISC_IINLIM_MASK,
1073                         BQ24190_REG_ISC_IINLIM_SHIFT,
1074                         bq24190_isc_iinlim_values,
1075                         ARRAY_SIZE(bq24190_isc_iinlim_values), val->intval);
1076 }
1077
1078 static int bq24190_charger_get_property(struct power_supply *psy,
1079                 enum power_supply_property psp, union power_supply_propval *val)
1080 {
1081         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1082         int ret;
1083
1084         dev_dbg(bdi->dev, "prop: %d\n", psp);
1085
1086         ret = pm_runtime_get_sync(bdi->dev);
1087         if (ret < 0) {
1088                 pm_runtime_put_noidle(bdi->dev);
1089                 return ret;
1090         }
1091
1092         switch (psp) {
1093         case POWER_SUPPLY_PROP_CHARGE_TYPE:
1094                 ret = bq24190_charger_get_charge_type(bdi, val);
1095                 break;
1096         case POWER_SUPPLY_PROP_HEALTH:
1097                 ret = bq24190_charger_get_health(bdi, val);
1098                 break;
1099         case POWER_SUPPLY_PROP_ONLINE:
1100                 ret = bq24190_charger_get_online(bdi, val);
1101                 break;
1102         case POWER_SUPPLY_PROP_STATUS:
1103                 ret = bq24190_charger_get_status(bdi, val);
1104                 break;
1105         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1106                 ret =  bq24190_charger_get_temp_alert_max(bdi, val);
1107                 break;
1108         case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1109                 ret = bq24190_charger_get_precharge(bdi, val);
1110                 break;
1111         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1112                 ret = bq24190_charger_get_charge_term(bdi, val);
1113                 break;
1114         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1115                 ret = bq24190_charger_get_current(bdi, val);
1116                 break;
1117         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
1118                 ret = bq24190_charger_get_current_max(bdi, val);
1119                 break;
1120         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1121                 ret = bq24190_charger_get_voltage(bdi, val);
1122                 break;
1123         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
1124                 ret = bq24190_charger_get_voltage_max(bdi, val);
1125                 break;
1126         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1127                 ret = bq24190_charger_get_iinlimit(bdi, val);
1128                 break;
1129         case POWER_SUPPLY_PROP_SCOPE:
1130                 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1131                 ret = 0;
1132                 break;
1133         case POWER_SUPPLY_PROP_MODEL_NAME:
1134                 val->strval = bdi->model_name;
1135                 ret = 0;
1136                 break;
1137         case POWER_SUPPLY_PROP_MANUFACTURER:
1138                 val->strval = BQ24190_MANUFACTURER;
1139                 ret = 0;
1140                 break;
1141         default:
1142                 ret = -ENODATA;
1143         }
1144
1145         pm_runtime_mark_last_busy(bdi->dev);
1146         pm_runtime_put_autosuspend(bdi->dev);
1147
1148         return ret;
1149 }
1150
1151 static int bq24190_charger_set_property(struct power_supply *psy,
1152                 enum power_supply_property psp,
1153                 const union power_supply_propval *val)
1154 {
1155         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1156         int ret;
1157
1158         dev_dbg(bdi->dev, "prop: %d\n", psp);
1159
1160         ret = pm_runtime_get_sync(bdi->dev);
1161         if (ret < 0) {
1162                 pm_runtime_put_noidle(bdi->dev);
1163                 return ret;
1164         }
1165
1166         switch (psp) {
1167         case POWER_SUPPLY_PROP_ONLINE:
1168                 ret = bq24190_charger_set_online(bdi, val);
1169                 break;
1170         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1171                 ret = bq24190_charger_set_temp_alert_max(bdi, val);
1172                 break;
1173         case POWER_SUPPLY_PROP_CHARGE_TYPE:
1174                 ret = bq24190_charger_set_charge_type(bdi, val);
1175                 break;
1176         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1177                 ret = bq24190_charger_set_current(bdi, val);
1178                 break;
1179         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1180                 ret = bq24190_charger_set_voltage(bdi, val);
1181                 break;
1182         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1183                 ret = bq24190_charger_set_iinlimit(bdi, val);
1184                 break;
1185         default:
1186                 ret = -EINVAL;
1187         }
1188
1189         pm_runtime_mark_last_busy(bdi->dev);
1190         pm_runtime_put_autosuspend(bdi->dev);
1191
1192         return ret;
1193 }
1194
1195 static int bq24190_charger_property_is_writeable(struct power_supply *psy,
1196                 enum power_supply_property psp)
1197 {
1198         switch (psp) {
1199         case POWER_SUPPLY_PROP_ONLINE:
1200         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1201         case POWER_SUPPLY_PROP_CHARGE_TYPE:
1202         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1203         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1204         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1205                 return 1;
1206         default:
1207                 return 0;
1208         }
1209 }
1210
1211 static void bq24190_input_current_limit_work(struct work_struct *work)
1212 {
1213         struct bq24190_dev_info *bdi =
1214                 container_of(work, struct bq24190_dev_info,
1215                              input_current_limit_work.work);
1216
1217         power_supply_set_input_current_limit_from_supplier(bdi->charger);
1218 }
1219
1220 /* Sync the input-current-limit with our parent supply (if we have one) */
1221 static void bq24190_charger_external_power_changed(struct power_supply *psy)
1222 {
1223         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1224
1225         /*
1226          * The Power-Good detection may take up to 220ms, sometimes
1227          * the external charger detection is quicker, and the bq24190 will
1228          * reset to iinlim based on its own charger detection (which is not
1229          * hooked up when using external charger detection) resulting in a
1230          * too low default 500mA iinlim. Delay setting the input-current-limit
1231          * for 300ms to avoid this.
1232          */
1233         queue_delayed_work(system_wq, &bdi->input_current_limit_work,
1234                            msecs_to_jiffies(300));
1235 }
1236
1237 static enum power_supply_property bq24190_charger_properties[] = {
1238         POWER_SUPPLY_PROP_CHARGE_TYPE,
1239         POWER_SUPPLY_PROP_HEALTH,
1240         POWER_SUPPLY_PROP_ONLINE,
1241         POWER_SUPPLY_PROP_STATUS,
1242         POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1243         POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
1244         POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
1245         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1246         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
1247         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1248         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
1249         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1250         POWER_SUPPLY_PROP_SCOPE,
1251         POWER_SUPPLY_PROP_MODEL_NAME,
1252         POWER_SUPPLY_PROP_MANUFACTURER,
1253 };
1254
1255 static char *bq24190_charger_supplied_to[] = {
1256         "main-battery",
1257 };
1258
1259 static const struct power_supply_desc bq24190_charger_desc = {
1260         .name                   = "bq24190-charger",
1261         .type                   = POWER_SUPPLY_TYPE_USB,
1262         .properties             = bq24190_charger_properties,
1263         .num_properties         = ARRAY_SIZE(bq24190_charger_properties),
1264         .get_property           = bq24190_charger_get_property,
1265         .set_property           = bq24190_charger_set_property,
1266         .property_is_writeable  = bq24190_charger_property_is_writeable,
1267         .external_power_changed = bq24190_charger_external_power_changed,
1268 };
1269
1270 /* Battery power supply property routines */
1271
1272 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
1273                 union power_supply_propval *val)
1274 {
1275         u8 ss_reg, chrg_fault;
1276         int status, ret;
1277
1278         mutex_lock(&bdi->f_reg_lock);
1279         chrg_fault = bdi->f_reg;
1280         mutex_unlock(&bdi->f_reg_lock);
1281
1282         chrg_fault &= BQ24190_REG_F_CHRG_FAULT_MASK;
1283         chrg_fault >>= BQ24190_REG_F_CHRG_FAULT_SHIFT;
1284
1285         ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1286         if (ret < 0)
1287                 return ret;
1288
1289         /*
1290          * The battery must be discharging when any of these are true:
1291          * - there is no good power source;
1292          * - there is a charge fault.
1293          * Could also be discharging when in "supplement mode" but
1294          * there is no way to tell when its in that mode.
1295          */
1296         if (!(ss_reg & BQ24190_REG_SS_PG_STAT_MASK) || chrg_fault) {
1297                 status = POWER_SUPPLY_STATUS_DISCHARGING;
1298         } else {
1299                 ss_reg &= BQ24190_REG_SS_CHRG_STAT_MASK;
1300                 ss_reg >>= BQ24190_REG_SS_CHRG_STAT_SHIFT;
1301
1302                 switch (ss_reg) {
1303                 case 0x0: /* Not Charging */
1304                         status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1305                         break;
1306                 case 0x1: /* Pre-charge */
1307                 case 0x2: /* Fast Charging */
1308                         status = POWER_SUPPLY_STATUS_CHARGING;
1309                         break;
1310                 case 0x3: /* Charge Termination Done */
1311                         status = POWER_SUPPLY_STATUS_FULL;
1312                         break;
1313                 default:
1314                         ret = -EIO;
1315                 }
1316         }
1317
1318         if (!ret)
1319                 val->intval = status;
1320
1321         return ret;
1322 }
1323
1324 static int bq24190_battery_get_health(struct bq24190_dev_info *bdi,
1325                 union power_supply_propval *val)
1326 {
1327         u8 v;
1328         int health;
1329
1330         mutex_lock(&bdi->f_reg_lock);
1331         v = bdi->f_reg;
1332         mutex_unlock(&bdi->f_reg_lock);
1333
1334         if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
1335                 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1336         } else {
1337                 v &= BQ24190_REG_F_NTC_FAULT_MASK;
1338                 v >>= BQ24190_REG_F_NTC_FAULT_SHIFT;
1339
1340                 switch (v) {
1341                 case 0x0: /* Normal */
1342                         health = POWER_SUPPLY_HEALTH_GOOD;
1343                         break;
1344                 case 0x1: /* TS1 Cold */
1345                 case 0x3: /* TS2 Cold */
1346                 case 0x5: /* Both Cold */
1347                         health = POWER_SUPPLY_HEALTH_COLD;
1348                         break;
1349                 case 0x2: /* TS1 Hot */
1350                 case 0x4: /* TS2 Hot */
1351                 case 0x6: /* Both Hot */
1352                         health = POWER_SUPPLY_HEALTH_OVERHEAT;
1353                         break;
1354                 default:
1355                         health = POWER_SUPPLY_HEALTH_UNKNOWN;
1356                 }
1357         }
1358
1359         val->intval = health;
1360         return 0;
1361 }
1362
1363 static int bq24190_battery_get_online(struct bq24190_dev_info *bdi,
1364                 union power_supply_propval *val)
1365 {
1366         u8 batfet_disable;
1367         int ret;
1368
1369         ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
1370                         BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1371                         BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
1372         if (ret < 0)
1373                 return ret;
1374
1375         val->intval = !batfet_disable;
1376         return 0;
1377 }
1378
1379 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
1380                 const union power_supply_propval *val)
1381 {
1382         return bq24190_write_mask(bdi, BQ24190_REG_MOC,
1383                         BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1384                         BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, !val->intval);
1385 }
1386
1387 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
1388                 union power_supply_propval *val)
1389 {
1390         int temp, ret;
1391
1392         ret = bq24190_get_field_val(bdi, BQ24190_REG_ICTRC,
1393                         BQ24190_REG_ICTRC_TREG_MASK,
1394                         BQ24190_REG_ICTRC_TREG_SHIFT,
1395                         bq24190_ictrc_treg_values,
1396                         ARRAY_SIZE(bq24190_ictrc_treg_values), &temp);
1397         if (ret < 0)
1398                 return ret;
1399
1400         val->intval = temp;
1401         return 0;
1402 }
1403
1404 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
1405                 const union power_supply_propval *val)
1406 {
1407         return bq24190_set_field_val(bdi, BQ24190_REG_ICTRC,
1408                         BQ24190_REG_ICTRC_TREG_MASK,
1409                         BQ24190_REG_ICTRC_TREG_SHIFT,
1410                         bq24190_ictrc_treg_values,
1411                         ARRAY_SIZE(bq24190_ictrc_treg_values), val->intval);
1412 }
1413
1414 static int bq24190_battery_get_property(struct power_supply *psy,
1415                 enum power_supply_property psp, union power_supply_propval *val)
1416 {
1417         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1418         int ret;
1419
1420         dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1421         dev_dbg(bdi->dev, "prop: %d\n", psp);
1422
1423         ret = pm_runtime_get_sync(bdi->dev);
1424         if (ret < 0) {
1425                 pm_runtime_put_noidle(bdi->dev);
1426                 return ret;
1427         }
1428
1429         switch (psp) {
1430         case POWER_SUPPLY_PROP_STATUS:
1431                 ret = bq24190_battery_get_status(bdi, val);
1432                 break;
1433         case POWER_SUPPLY_PROP_HEALTH:
1434                 ret = bq24190_battery_get_health(bdi, val);
1435                 break;
1436         case POWER_SUPPLY_PROP_ONLINE:
1437                 ret = bq24190_battery_get_online(bdi, val);
1438                 break;
1439         case POWER_SUPPLY_PROP_TECHNOLOGY:
1440                 /* Could be Li-on or Li-polymer but no way to tell which */
1441                 val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
1442                 ret = 0;
1443                 break;
1444         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1445                 ret = bq24190_battery_get_temp_alert_max(bdi, val);
1446                 break;
1447         case POWER_SUPPLY_PROP_SCOPE:
1448                 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1449                 ret = 0;
1450                 break;
1451         default:
1452                 ret = -ENODATA;
1453         }
1454
1455         pm_runtime_mark_last_busy(bdi->dev);
1456         pm_runtime_put_autosuspend(bdi->dev);
1457
1458         return ret;
1459 }
1460
1461 static int bq24190_battery_set_property(struct power_supply *psy,
1462                 enum power_supply_property psp,
1463                 const union power_supply_propval *val)
1464 {
1465         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1466         int ret;
1467
1468         dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1469         dev_dbg(bdi->dev, "prop: %d\n", psp);
1470
1471         ret = pm_runtime_get_sync(bdi->dev);
1472         if (ret < 0) {
1473                 pm_runtime_put_noidle(bdi->dev);
1474                 return ret;
1475         }
1476
1477         switch (psp) {
1478         case POWER_SUPPLY_PROP_ONLINE:
1479                 ret = bq24190_battery_set_online(bdi, val);
1480                 break;
1481         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1482                 ret = bq24190_battery_set_temp_alert_max(bdi, val);
1483                 break;
1484         default:
1485                 ret = -EINVAL;
1486         }
1487
1488         pm_runtime_mark_last_busy(bdi->dev);
1489         pm_runtime_put_autosuspend(bdi->dev);
1490
1491         return ret;
1492 }
1493
1494 static int bq24190_battery_property_is_writeable(struct power_supply *psy,
1495                 enum power_supply_property psp)
1496 {
1497         int ret;
1498
1499         switch (psp) {
1500         case POWER_SUPPLY_PROP_ONLINE:
1501         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1502                 ret = 1;
1503                 break;
1504         default:
1505                 ret = 0;
1506         }
1507
1508         return ret;
1509 }
1510
1511 static enum power_supply_property bq24190_battery_properties[] = {
1512         POWER_SUPPLY_PROP_STATUS,
1513         POWER_SUPPLY_PROP_HEALTH,
1514         POWER_SUPPLY_PROP_ONLINE,
1515         POWER_SUPPLY_PROP_TECHNOLOGY,
1516         POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1517         POWER_SUPPLY_PROP_SCOPE,
1518 };
1519
1520 static const struct power_supply_desc bq24190_battery_desc = {
1521         .name                   = "bq24190-battery",
1522         .type                   = POWER_SUPPLY_TYPE_BATTERY,
1523         .properties             = bq24190_battery_properties,
1524         .num_properties         = ARRAY_SIZE(bq24190_battery_properties),
1525         .get_property           = bq24190_battery_get_property,
1526         .set_property           = bq24190_battery_set_property,
1527         .property_is_writeable  = bq24190_battery_property_is_writeable,
1528 };
1529
1530 static int bq24190_configure_usb_otg(struct bq24190_dev_info *bdi, u8 ss_reg)
1531 {
1532         bool otg_enabled;
1533         int ret;
1534
1535         otg_enabled = !!(ss_reg & BQ24190_REG_SS_VBUS_STAT_MASK);
1536         ret = extcon_set_state_sync(bdi->edev, EXTCON_USB, otg_enabled);
1537         if (ret < 0)
1538                 dev_err(bdi->dev, "Can't set extcon state to %d: %d\n",
1539                         otg_enabled, ret);
1540
1541         return ret;
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                 bq24190_configure_usb_otg(bdi, ss_reg);
1616         }
1617         if (alert_battery && bdi->battery)
1618                 power_supply_changed(bdi->battery);
1619
1620         dev_dbg(bdi->dev, "ss_reg: 0x%02x, f_reg: 0x%02x\n", ss_reg, f_reg);
1621 }
1622
1623 static irqreturn_t bq24190_irq_handler_thread(int irq, void *data)
1624 {
1625         struct bq24190_dev_info *bdi = data;
1626         int error;
1627
1628         bdi->irq_event = true;
1629         error = pm_runtime_get_sync(bdi->dev);
1630         if (error < 0) {
1631                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1632                 pm_runtime_put_noidle(bdi->dev);
1633                 return IRQ_NONE;
1634         }
1635         bq24190_check_status(bdi);
1636         pm_runtime_mark_last_busy(bdi->dev);
1637         pm_runtime_put_autosuspend(bdi->dev);
1638         bdi->irq_event = false;
1639
1640         return IRQ_HANDLED;
1641 }
1642
1643 static int bq24190_hw_init(struct bq24190_dev_info *bdi)
1644 {
1645         u8 v;
1646         int ret;
1647
1648         /* First check that the device really is what its supposed to be */
1649         ret = bq24190_read_mask(bdi, BQ24190_REG_VPRS,
1650                         BQ24190_REG_VPRS_PN_MASK,
1651                         BQ24190_REG_VPRS_PN_SHIFT,
1652                         &v);
1653         if (ret < 0)
1654                 return ret;
1655
1656         switch (v) {
1657         case BQ24190_REG_VPRS_PN_24190:
1658         case BQ24190_REG_VPRS_PN_24192:
1659         case BQ24190_REG_VPRS_PN_24192I:
1660                 break;
1661         default:
1662                 dev_err(bdi->dev, "Error unknown model: 0x%02x\n", v);
1663                 return -ENODEV;
1664         }
1665
1666         ret = bq24190_register_reset(bdi);
1667         if (ret < 0)
1668                 return ret;
1669
1670         ret = bq24190_set_config(bdi);
1671         if (ret < 0)
1672                 return ret;
1673
1674         return bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1675 }
1676
1677 static int bq24190_get_config(struct bq24190_dev_info *bdi)
1678 {
1679         const char * const s = "ti,system-minimum-microvolt";
1680         struct power_supply_battery_info info = {};
1681         int v;
1682
1683         if (device_property_read_u32(bdi->dev, s, &v) == 0) {
1684                 v /= 1000;
1685                 if (v >= BQ24190_REG_POC_SYS_MIN_MIN
1686                  && v <= BQ24190_REG_POC_SYS_MIN_MAX)
1687                         bdi->sys_min = v;
1688                 else
1689                         dev_warn(bdi->dev, "invalid value for %s: %u\n", s, v);
1690         }
1691
1692         if (bdi->dev->of_node &&
1693             !power_supply_get_battery_info(bdi->charger, &info)) {
1694                 v = info.precharge_current_ua / 1000;
1695                 if (v >= BQ24190_REG_PCTCC_IPRECHG_MIN
1696                  && v <= BQ24190_REG_PCTCC_IPRECHG_MAX)
1697                         bdi->iprechg = v;
1698                 else
1699                         dev_warn(bdi->dev, "invalid value for battery:precharge-current-microamp: %d\n",
1700                                  v);
1701
1702                 v = info.charge_term_current_ua / 1000;
1703                 if (v >= BQ24190_REG_PCTCC_ITERM_MIN
1704                  && v <= BQ24190_REG_PCTCC_ITERM_MAX)
1705                         bdi->iterm = v;
1706                 else
1707                         dev_warn(bdi->dev, "invalid value for battery:charge-term-current-microamp: %d\n",
1708                                  v);
1709         }
1710
1711         return 0;
1712 }
1713
1714 static int bq24190_probe(struct i2c_client *client,
1715                 const struct i2c_device_id *id)
1716 {
1717         struct i2c_adapter *adapter = client->adapter;
1718         struct device *dev = &client->dev;
1719         struct power_supply_config charger_cfg = {}, battery_cfg = {};
1720         struct bq24190_dev_info *bdi;
1721         int ret;
1722
1723         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1724                 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1725                 return -ENODEV;
1726         }
1727
1728         bdi = devm_kzalloc(dev, sizeof(*bdi), GFP_KERNEL);
1729         if (!bdi) {
1730                 dev_err(dev, "Can't alloc bdi struct\n");
1731                 return -ENOMEM;
1732         }
1733
1734         bdi->client = client;
1735         bdi->dev = dev;
1736         strncpy(bdi->model_name, id->name, I2C_NAME_SIZE);
1737         mutex_init(&bdi->f_reg_lock);
1738         bdi->f_reg = 0;
1739         bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1740         INIT_DELAYED_WORK(&bdi->input_current_limit_work,
1741                           bq24190_input_current_limit_work);
1742
1743         i2c_set_clientdata(client, bdi);
1744
1745         if (client->irq <= 0) {
1746                 dev_err(dev, "Can't get irq info\n");
1747                 return -EINVAL;
1748         }
1749
1750         bdi->edev = devm_extcon_dev_allocate(dev, bq24190_usb_extcon_cable);
1751         if (IS_ERR(bdi->edev))
1752                 return PTR_ERR(bdi->edev);
1753
1754         ret = devm_extcon_dev_register(dev, bdi->edev);
1755         if (ret < 0)
1756                 return ret;
1757
1758         pm_runtime_enable(dev);
1759         pm_runtime_use_autosuspend(dev);
1760         pm_runtime_set_autosuspend_delay(dev, 600);
1761         ret = pm_runtime_get_sync(dev);
1762         if (ret < 0) {
1763                 dev_err(dev, "pm_runtime_get failed: %i\n", ret);
1764                 goto out_pmrt;
1765         }
1766
1767 #ifdef CONFIG_SYSFS
1768         bq24190_sysfs_init_attrs();
1769         charger_cfg.attr_grp = bq24190_sysfs_groups;
1770 #endif
1771
1772         charger_cfg.drv_data = bdi;
1773         charger_cfg.of_node = dev->of_node;
1774         charger_cfg.supplied_to = bq24190_charger_supplied_to;
1775         charger_cfg.num_supplicants = ARRAY_SIZE(bq24190_charger_supplied_to),
1776         bdi->charger = power_supply_register(dev, &bq24190_charger_desc,
1777                                                 &charger_cfg);
1778         if (IS_ERR(bdi->charger)) {
1779                 dev_err(dev, "Can't register charger\n");
1780                 ret = PTR_ERR(bdi->charger);
1781                 goto out_pmrt;
1782         }
1783
1784         /* the battery class is deprecated and will be removed. */
1785         /* in the interim, this property hides it.              */
1786         if (!device_property_read_bool(dev, "omit-battery-class")) {
1787                 battery_cfg.drv_data = bdi;
1788                 bdi->battery = power_supply_register(dev, &bq24190_battery_desc,
1789                                                      &battery_cfg);
1790                 if (IS_ERR(bdi->battery)) {
1791                         dev_err(dev, "Can't register battery\n");
1792                         ret = PTR_ERR(bdi->battery);
1793                         goto out_charger;
1794                 }
1795         }
1796
1797         ret = bq24190_get_config(bdi);
1798         if (ret < 0) {
1799                 dev_err(dev, "Can't get devicetree config\n");
1800                 goto out_charger;
1801         }
1802
1803         ret = bq24190_hw_init(bdi);
1804         if (ret < 0) {
1805                 dev_err(dev, "Hardware init failed\n");
1806                 goto out_charger;
1807         }
1808
1809         ret = bq24190_configure_usb_otg(bdi, bdi->ss_reg);
1810         if (ret < 0)
1811                 goto out_charger;
1812
1813         bdi->initialized = true;
1814
1815         ret = devm_request_threaded_irq(dev, client->irq, NULL,
1816                         bq24190_irq_handler_thread,
1817                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1818                         "bq24190-charger", bdi);
1819         if (ret < 0) {
1820                 dev_err(dev, "Can't set up irq handler\n");
1821                 goto out_charger;
1822         }
1823
1824         ret = bq24190_register_vbus_regulator(bdi);
1825         if (ret < 0)
1826                 goto out_charger;
1827
1828         enable_irq_wake(client->irq);
1829
1830         pm_runtime_mark_last_busy(dev);
1831         pm_runtime_put_autosuspend(dev);
1832
1833         return 0;
1834
1835 out_charger:
1836         if (!IS_ERR_OR_NULL(bdi->battery))
1837                 power_supply_unregister(bdi->battery);
1838         power_supply_unregister(bdi->charger);
1839
1840 out_pmrt:
1841         pm_runtime_put_sync(dev);
1842         pm_runtime_dont_use_autosuspend(dev);
1843         pm_runtime_disable(dev);
1844         return ret;
1845 }
1846
1847 static int bq24190_remove(struct i2c_client *client)
1848 {
1849         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1850         int error;
1851
1852         error = pm_runtime_get_sync(bdi->dev);
1853         if (error < 0) {
1854                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1855                 pm_runtime_put_noidle(bdi->dev);
1856         }
1857
1858         bq24190_register_reset(bdi);
1859         if (bdi->battery)
1860                 power_supply_unregister(bdi->battery);
1861         power_supply_unregister(bdi->charger);
1862         if (error >= 0)
1863                 pm_runtime_put_sync(bdi->dev);
1864         pm_runtime_dont_use_autosuspend(bdi->dev);
1865         pm_runtime_disable(bdi->dev);
1866
1867         return 0;
1868 }
1869
1870 static __maybe_unused int bq24190_runtime_suspend(struct device *dev)
1871 {
1872         struct i2c_client *client = to_i2c_client(dev);
1873         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1874
1875         if (!bdi->initialized)
1876                 return 0;
1877
1878         dev_dbg(bdi->dev, "%s\n", __func__);
1879
1880         return 0;
1881 }
1882
1883 static __maybe_unused int bq24190_runtime_resume(struct device *dev)
1884 {
1885         struct i2c_client *client = to_i2c_client(dev);
1886         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1887
1888         if (!bdi->initialized)
1889                 return 0;
1890
1891         if (!bdi->irq_event) {
1892                 dev_dbg(bdi->dev, "checking events on possible wakeirq\n");
1893                 bq24190_check_status(bdi);
1894         }
1895
1896         return 0;
1897 }
1898
1899 static __maybe_unused int bq24190_pm_suspend(struct device *dev)
1900 {
1901         struct i2c_client *client = to_i2c_client(dev);
1902         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1903         int error;
1904
1905         error = pm_runtime_get_sync(bdi->dev);
1906         if (error < 0) {
1907                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1908                 pm_runtime_put_noidle(bdi->dev);
1909         }
1910
1911         bq24190_register_reset(bdi);
1912
1913         if (error >= 0) {
1914                 pm_runtime_mark_last_busy(bdi->dev);
1915                 pm_runtime_put_autosuspend(bdi->dev);
1916         }
1917
1918         return 0;
1919 }
1920
1921 static __maybe_unused int bq24190_pm_resume(struct device *dev)
1922 {
1923         struct i2c_client *client = to_i2c_client(dev);
1924         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1925         int error;
1926
1927         bdi->f_reg = 0;
1928         bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1929
1930         error = pm_runtime_get_sync(bdi->dev);
1931         if (error < 0) {
1932                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1933                 pm_runtime_put_noidle(bdi->dev);
1934         }
1935
1936         bq24190_register_reset(bdi);
1937         bq24190_set_config(bdi);
1938         bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1939
1940         if (error >= 0) {
1941                 pm_runtime_mark_last_busy(bdi->dev);
1942                 pm_runtime_put_autosuspend(bdi->dev);
1943         }
1944
1945         /* Things may have changed while suspended so alert upper layer */
1946         power_supply_changed(bdi->charger);
1947         if (bdi->battery)
1948                 power_supply_changed(bdi->battery);
1949
1950         return 0;
1951 }
1952
1953 static const struct dev_pm_ops bq24190_pm_ops = {
1954         SET_RUNTIME_PM_OPS(bq24190_runtime_suspend, bq24190_runtime_resume,
1955                            NULL)
1956         SET_SYSTEM_SLEEP_PM_OPS(bq24190_pm_suspend, bq24190_pm_resume)
1957 };
1958
1959 static const struct i2c_device_id bq24190_i2c_ids[] = {
1960         { "bq24190" },
1961         { "bq24192" },
1962         { "bq24192i" },
1963         { "bq24196" },
1964         { },
1965 };
1966 MODULE_DEVICE_TABLE(i2c, bq24190_i2c_ids);
1967
1968 #ifdef CONFIG_OF
1969 static const struct of_device_id bq24190_of_match[] = {
1970         { .compatible = "ti,bq24190", },
1971         { .compatible = "ti,bq24192", },
1972         { .compatible = "ti,bq24192i", },
1973         { .compatible = "ti,bq24196", },
1974         { },
1975 };
1976 MODULE_DEVICE_TABLE(of, bq24190_of_match);
1977 #else
1978 static const struct of_device_id bq24190_of_match[] = {
1979         { },
1980 };
1981 #endif
1982
1983 static struct i2c_driver bq24190_driver = {
1984         .probe          = bq24190_probe,
1985         .remove         = bq24190_remove,
1986         .id_table       = bq24190_i2c_ids,
1987         .driver = {
1988                 .name           = "bq24190-charger",
1989                 .pm             = &bq24190_pm_ops,
1990                 .of_match_table = of_match_ptr(bq24190_of_match),
1991         },
1992 };
1993 module_i2c_driver(bq24190_driver);
1994
1995 MODULE_LICENSE("GPL");
1996 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
1997 MODULE_DESCRIPTION("TI BQ24190 Charger Driver");