drivers/power/supply/bq24190_charger.c

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