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