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 #include <linux/extcon-provider.h>
  25
  26 #define BQ24190_MANUFACTURER    "Texas Instruments"
  27
  28 #define BQ24190_REG_ISC         0x00 /* Input Source Control */
  29 #define BQ24190_REG_ISC_EN_HIZ_MASK             BIT(7)
  30 #define BQ24190_REG_ISC_EN_HIZ_SHIFT            7
  31 #define BQ24190_REG_ISC_VINDPM_MASK             (BIT(6) | BIT(5) | BIT(4) | \
  32                                                  BIT(3))
  33 #define BQ24190_REG_ISC_VINDPM_SHIFT            3
  34 #define BQ24190_REG_ISC_IINLIM_MASK             (BIT(2) | BIT(1) | BIT(0))
  35 #define BQ24190_REG_ISC_IINLIM_SHIFT            0
  36
  37 #define BQ24190_REG_POC         0x01 /* Power-On Configuration */
  38 #define BQ24190_REG_POC_RESET_MASK              BIT(7)
  39 #define BQ24190_REG_POC_RESET_SHIFT             7
  40 #define BQ24190_REG_POC_WDT_RESET_MASK          BIT(6)
  41 #define BQ24190_REG_POC_WDT_RESET_SHIFT         6
  42 #define BQ24190_REG_POC_CHG_CONFIG_MASK         (BIT(5) | BIT(4))
  43 #define BQ24190_REG_POC_CHG_CONFIG_SHIFT        4
  44 #define BQ24190_REG_POC_CHG_CONFIG_DISABLE              0x0
  45 #define BQ24190_REG_POC_CHG_CONFIG_CHARGE               0x1
  46 #define BQ24190_REG_POC_CHG_CONFIG_OTG                  0x2
  47 #define BQ24190_REG_POC_SYS_MIN_MASK            (BIT(3) | BIT(2) | BIT(1))
  48 #define BQ24190_REG_POC_SYS_MIN_SHIFT           1
  49 #define BQ24190_REG_POC_SYS_MIN_MIN                     3000
  50 #define BQ24190_REG_POC_SYS_MIN_MAX                     3700
  51 #define BQ24190_REG_POC_BOOST_LIM_MASK          BIT(0)
  52 #define BQ24190_REG_POC_BOOST_LIM_SHIFT         0
  53
  54 #define BQ24190_REG_CCC         0x02 /* Charge Current Control */
  55 #define BQ24190_REG_CCC_ICHG_MASK               (BIT(7) | BIT(6) | BIT(5) | \
  56                                                  BIT(4) | BIT(3) | BIT(2))
  57 #define BQ24190_REG_CCC_ICHG_SHIFT              2
  58 #define BQ24190_REG_CCC_FORCE_20PCT_MASK        BIT(0)
  59 #define BQ24190_REG_CCC_FORCE_20PCT_SHIFT       0
  60
  61 #define BQ24190_REG_PCTCC       0x03 /* Pre-charge/Termination Current Cntl */
  62 #define BQ24190_REG_PCTCC_IPRECHG_MASK          (BIT(7) | BIT(6) | BIT(5) | \
  63                                                  BIT(4))
  64 #define BQ24190_REG_PCTCC_IPRECHG_SHIFT         4
  65 #define BQ24190_REG_PCTCC_IPRECHG_MIN                   128
  66 #define BQ24190_REG_PCTCC_IPRECHG_MAX                   2048
  67 #define BQ24190_REG_PCTCC_ITERM_MASK            (BIT(3) | BIT(2) | BIT(1) | \
  68                                                  BIT(0))
  69 #define BQ24190_REG_PCTCC_ITERM_SHIFT           0
  70 #define BQ24190_REG_PCTCC_ITERM_MIN                     128
  71 #define BQ24190_REG_PCTCC_ITERM_MAX                     2048
  72
  73 #define BQ24190_REG_CVC         0x04 /* Charge Voltage Control */
  74 #define BQ24190_REG_CVC_VREG_MASK               (BIT(7) | BIT(6) | BIT(5) | \
  75                                                  BIT(4) | BIT(3) | BIT(2))
  76 #define BQ24190_REG_CVC_VREG_SHIFT              2
  77 #define BQ24190_REG_CVC_BATLOWV_MASK            BIT(1)
  78 #define BQ24190_REG_CVC_BATLOWV_SHIFT           1
  79 #define BQ24190_REG_CVC_VRECHG_MASK             BIT(0)
  80 #define BQ24190_REG_CVC_VRECHG_SHIFT            0
  81
  82 #define BQ24190_REG_CTTC        0x05 /* Charge Term/Timer Control */
  83 #define BQ24190_REG_CTTC_EN_TERM_MASK           BIT(7)
  84 #define BQ24190_REG_CTTC_EN_TERM_SHIFT          7
  85 #define BQ24190_REG_CTTC_TERM_STAT_MASK         BIT(6)
  86 #define BQ24190_REG_CTTC_TERM_STAT_SHIFT        6
  87 #define BQ24190_REG_CTTC_WATCHDOG_MASK          (BIT(5) | BIT(4))
  88 #define BQ24190_REG_CTTC_WATCHDOG_SHIFT         4
  89 #define BQ24190_REG_CTTC_EN_TIMER_MASK          BIT(3)
  90 #define BQ24190_REG_CTTC_EN_TIMER_SHIFT         3
  91 #define BQ24190_REG_CTTC_CHG_TIMER_MASK         (BIT(2) | BIT(1))
  92 #define BQ24190_REG_CTTC_CHG_TIMER_SHIFT        1
  93 #define BQ24190_REG_CTTC_JEITA_ISET_MASK        BIT(0)
  94 #define BQ24190_REG_CTTC_JEITA_ISET_SHIFT       0
  95
  96 #define BQ24190_REG_ICTRC       0x06 /* IR Comp/Thermal Regulation Control */
  97 #define BQ24190_REG_ICTRC_BAT_COMP_MASK         (BIT(7) | BIT(6) | BIT(5))
  98 #define BQ24190_REG_ICTRC_BAT_COMP_SHIFT        5
  99 #define BQ24190_REG_ICTRC_VCLAMP_MASK           (BIT(4) | BIT(3) | BIT(2))
 100 #define BQ24190_REG_ICTRC_VCLAMP_SHIFT          2
 101 #define BQ24190_REG_ICTRC_TREG_MASK             (BIT(1) | BIT(0))
 102 #define BQ24190_REG_ICTRC_TREG_SHIFT            0
 103
 104 #define BQ24190_REG_MOC         0x07 /* Misc. Operation Control */
 105 #define BQ24190_REG_MOC_DPDM_EN_MASK            BIT(7)
 106 #define BQ24190_REG_MOC_DPDM_EN_SHIFT           7
 107 #define BQ24190_REG_MOC_TMR2X_EN_MASK           BIT(6)
 108 #define BQ24190_REG_MOC_TMR2X_EN_SHIFT          6
 109 #define BQ24190_REG_MOC_BATFET_DISABLE_MASK     BIT(5)
 110 #define BQ24190_REG_MOC_BATFET_DISABLE_SHIFT    5
 111 #define BQ24190_REG_MOC_JEITA_VSET_MASK         BIT(4)
 112 #define BQ24190_REG_MOC_JEITA_VSET_SHIFT        4
 113 #define BQ24190_REG_MOC_INT_MASK_MASK           (BIT(1) | BIT(0))
 114 #define BQ24190_REG_MOC_INT_MASK_SHIFT          0
 115
 116 #define BQ24190_REG_SS          0x08 /* System Status */
 117 #define BQ24190_REG_SS_VBUS_STAT_MASK           (BIT(7) | BIT(6))
 118 #define BQ24190_REG_SS_VBUS_STAT_SHIFT          6
 119 #define BQ24190_REG_SS_CHRG_STAT_MASK           (BIT(5) | BIT(4))
 120 #define BQ24190_REG_SS_CHRG_STAT_SHIFT          4
 121 #define BQ24190_REG_SS_DPM_STAT_MASK            BIT(3)
 122 #define BQ24190_REG_SS_DPM_STAT_SHIFT           3
 123 #define BQ24190_REG_SS_PG_STAT_MASK             BIT(2)
 124 #define BQ24190_REG_SS_PG_STAT_SHIFT            2
 125 #define BQ24190_REG_SS_THERM_STAT_MASK          BIT(1)
 126 #define BQ24190_REG_SS_THERM_STAT_SHIFT         1
 127 #define BQ24190_REG_SS_VSYS_STAT_MASK           BIT(0)
 128 #define BQ24190_REG_SS_VSYS_STAT_SHIFT          0
 129
 130 #define BQ24190_REG_F           0x09 /* Fault */
 131 #define BQ24190_REG_F_WATCHDOG_FAULT_MASK       BIT(7)
 132 #define BQ24190_REG_F_WATCHDOG_FAULT_SHIFT      7
 133 #define BQ24190_REG_F_BOOST_FAULT_MASK          BIT(6)
 134 #define BQ24190_REG_F_BOOST_FAULT_SHIFT         6
 135 #define BQ24190_REG_F_CHRG_FAULT_MASK           (BIT(5) | BIT(4))
 136 #define BQ24190_REG_F_CHRG_FAULT_SHIFT          4
 137 #define BQ24190_REG_F_BAT_FAULT_MASK            BIT(3)
 138 #define BQ24190_REG_F_BAT_FAULT_SHIFT           3
 139 #define BQ24190_REG_F_NTC_FAULT_MASK            (BIT(2) | BIT(1) | BIT(0))
 140 #define BQ24190_REG_F_NTC_FAULT_SHIFT           0
 141
 142 #define BQ24190_REG_VPRS        0x0A /* Vendor/Part/Revision Status */
 143 #define BQ24190_REG_VPRS_PN_MASK                (BIT(5) | BIT(4) | BIT(3))
 144 #define BQ24190_REG_VPRS_PN_SHIFT               3
 145 #define BQ24190_REG_VPRS_PN_24190                       0x4
 146 #define BQ24190_REG_VPRS_PN_24192                       0x5 /* Also 24193, 24196 */
 147 #define BQ24190_REG_VPRS_PN_24192I                      0x3
 148 #define BQ24190_REG_VPRS_TS_PROFILE_MASK        BIT(2)
 149 #define BQ24190_REG_VPRS_TS_PROFILE_SHIFT       2
 150 #define BQ24190_REG_VPRS_DEV_REG_MASK           (BIT(1) | BIT(0))
 151 #define BQ24190_REG_VPRS_DEV_REG_SHIFT          0
 152
 153 /*
 154  * The FAULT register is latched by the bq24190 (except for NTC_FAULT)
 155  * so the first read after a fault returns the latched value and subsequent
 156  * reads return the current value.  In order to return the fault status
 157  * to the user, have the interrupt handler save the reg's value and retrieve
 158  * it in the appropriate health/status routine.
 159  */
 160 struct bq24190_dev_info {
 161         struct i2c_client               *client;
 162         struct device                   *dev;
 163         struct extcon_dev               *edev;
 164         struct power_supply             *charger;
 165         struct power_supply             *battery;
 166         struct delayed_work             input_current_limit_work;
 167         char                            model_name[I2C_NAME_SIZE];
 168         bool                            initialized;
 169         bool                            irq_event;
 170         u16                             sys_min;
 171         u16                             iprechg;
 172         u16                             iterm;
 173         struct mutex                    f_reg_lock;
 174         u8                              f_reg;
 175         u8                              ss_reg;
 176         u8                              watchdog;
 177 };
 178
 179 static const unsigned int bq24190_usb_extcon_cable[] = {
 180         EXTCON_USB,
 181         EXTCON_NONE,
 182 };
 183
 184 /*
 185  * The tables below provide a 2-way mapping for the value that goes in
 186  * the register field and the real-world value that it represents.
 187  * The index of the array is the value that goes in the register; the
 188  * number at that index in the array is the real-world value that it
 189  * represents.
 190  */
 191
 192 /* REG00[2:0] (IINLIM) in uAh */
 193 static const int bq24190_isc_iinlim_values[] = {
 194          100000,  150000,  500000,  900000, 1200000, 1500000, 2000000, 3000000
 195 };
 196
 197 /* REG02[7:2] (ICHG) in uAh */
 198 static const int bq24190_ccc_ichg_values[] = {
 199          512000,  576000,  640000,  704000,  768000,  832000,  896000,  960000,
 200         1024000, 1088000, 1152000, 1216000, 1280000, 1344000, 1408000, 1472000,
 201         1536000, 1600000, 1664000, 1728000, 1792000, 1856000, 1920000, 1984000,
 202         2048000, 2112000, 2176000, 2240000, 2304000, 2368000, 2432000, 2496000,
 203         2560000, 2624000, 2688000, 2752000, 2816000, 2880000, 2944000, 3008000,
 204         3072000, 3136000, 3200000, 3264000, 3328000, 3392000, 3456000, 3520000,
 205         3584000, 3648000, 3712000, 3776000, 3840000, 3904000, 3968000, 4032000,
 206         4096000, 4160000, 4224000, 4288000, 4352000, 4416000, 4480000, 4544000
 207 };
 208
 209 /* REG04[7:2] (VREG) in uV */
 210 static const int bq24190_cvc_vreg_values[] = {
 211         3504000, 3520000, 3536000, 3552000, 3568000, 3584000, 3600000, 3616000,
 212         3632000, 3648000, 3664000, 3680000, 3696000, 3712000, 3728000, 3744000,
 213         3760000, 3776000, 3792000, 3808000, 3824000, 3840000, 3856000, 3872000,
 214         3888000, 3904000, 3920000, 3936000, 3952000, 3968000, 3984000, 4000000,
 215         4016000, 4032000, 4048000, 4064000, 4080000, 4096000, 4112000, 4128000,
 216         4144000, 4160000, 4176000, 4192000, 4208000, 4224000, 4240000, 4256000,
 217         4272000, 4288000, 4304000, 4320000, 4336000, 4352000, 4368000, 4384000,
 218         4400000
 219 };
 220
 221 /* REG06[1:0] (TREG) in tenths of degrees Celsius */
 222 static const int bq24190_ictrc_treg_values[] = {
 223         600, 800, 1000, 1200
 224 };
 225
 226 /*
 227  * Return the index in 'tbl' of greatest value that is less than or equal to
 228  * 'val'.  The index range returned is 0 to 'tbl_size' - 1.  Assumes that
 229  * the values in 'tbl' are sorted from smallest to largest and 'tbl_size'
 230  * is less than 2^8.
 231  */
 232 static u8 bq24190_find_idx(const int tbl[], int tbl_size, int v)
 233 {
 234         int i;
 235
 236         for (i = 1; i < tbl_size; i++)
 237                 if (v < tbl[i])
 238                         break;
 239
 240         return i - 1;
 241 }
 242
 243 /* Basic driver I/O routines */
 244
 245 static int bq24190_read(struct bq24190_dev_info *bdi, u8 reg, u8 *data)
 246 {
 247         int ret;
 248
 249         ret = i2c_smbus_read_byte_data(bdi->client, reg);
 250         if (ret < 0)
 251                 return ret;
 252
 253         *data = ret;
 254         return 0;
 255 }
 256
 257 static int bq24190_write(struct bq24190_dev_info *bdi, u8 reg, u8 data)
 258 {
 259         return i2c_smbus_write_byte_data(bdi->client, reg, data);
 260 }
 261
 262 static int bq24190_read_mask(struct bq24190_dev_info *bdi, u8 reg,
 263                 u8 mask, u8 shift, u8 *data)
 264 {
 265         u8 v;
 266         int ret;
 267
 268         ret = bq24190_read(bdi, reg, &v);
 269         if (ret < 0)
 270                 return ret;
 271
 272         v &= mask;
 273         v >>= shift;
 274         *data = v;
 275
 276         return 0;
 277 }
 278
 279 static int bq24190_write_mask(struct bq24190_dev_info *bdi, u8 reg,
 280                 u8 mask, u8 shift, u8 data)
 281 {
 282         u8 v;
 283         int ret;
 284
 285         ret = bq24190_read(bdi, reg, &v);
 286         if (ret < 0)
 287                 return ret;
 288
 289         v &= ~mask;
 290         v |= ((data << shift) & mask);
 291
 292         return bq24190_write(bdi, reg, v);
 293 }
 294
 295 static int bq24190_get_field_val(struct bq24190_dev_info *bdi,
 296                 u8 reg, u8 mask, u8 shift,
 297                 const int tbl[], int tbl_size,
 298                 int *val)
 299 {
 300         u8 v;
 301         int ret;
 302
 303         ret = bq24190_read_mask(bdi, reg, mask, shift, &v);
 304         if (ret < 0)
 305                 return ret;
 306
 307         v = (v >= tbl_size) ? (tbl_size - 1) : v;
 308         *val = tbl[v];
 309
 310         return 0;
 311 }
 312
 313 static int bq24190_set_field_val(struct bq24190_dev_info *bdi,
 314                 u8 reg, u8 mask, u8 shift,
 315                 const int tbl[], int tbl_size,
 316                 int val)
 317 {
 318         u8 idx;
 319
 320         idx = bq24190_find_idx(tbl, tbl_size, val);
 321
 322         return bq24190_write_mask(bdi, reg, mask, shift, idx);
 323 }
 324
 325 #ifdef CONFIG_SYSFS
 326 /*
 327  * There are a numerous options that are configurable on the bq24190
 328  * that go well beyond what the power_supply properties provide access to.
 329  * Provide sysfs access to them so they can be examined and possibly modified
 330  * on the fly.  They will be provided for the charger power_supply object only
 331  * and will be prefixed by 'f_' to make them easier to recognize.
 332  */
 333
 334 #define BQ24190_SYSFS_FIELD(_name, r, f, m, store)                      \
 335 {                                                                       \
 336         .attr   = __ATTR(f_##_name, m, bq24190_sysfs_show, store),      \
 337         .reg    = BQ24190_REG_##r,                                      \
 338         .mask   = BQ24190_REG_##r##_##f##_MASK,                         \
 339         .shift  = BQ24190_REG_##r##_##f##_SHIFT,                        \
 340 }
 341
 342 #define BQ24190_SYSFS_FIELD_RW(_name, r, f)                             \
 343                 BQ24190_SYSFS_FIELD(_name, r, f, S_IWUSR | S_IRUGO,     \
 344                                 bq24190_sysfs_store)
 345
 346 #define BQ24190_SYSFS_FIELD_RO(_name, r, f)                             \
 347                 BQ24190_SYSFS_FIELD(_name, r, f, S_IRUGO, NULL)
 348
 349 static ssize_t bq24190_sysfs_show(struct device *dev,
 350                 struct device_attribute *attr, char *buf);
 351 static ssize_t bq24190_sysfs_store(struct device *dev,
 352                 struct device_attribute *attr, const char *buf, size_t count);
 353
 354 struct bq24190_sysfs_field_info {
 355         struct device_attribute attr;
 356         u8      reg;
 357         u8      mask;
 358         u8      shift;
 359 };
 360
 361 /* On i386 ptrace-abi.h defines SS that breaks the macro calls below. */
 362 #undef SS
 363
 364 static struct bq24190_sysfs_field_info bq24190_sysfs_field_tbl[] = {
 365                         /*      sysfs name      reg     field in reg */
 366         BQ24190_SYSFS_FIELD_RW(en_hiz,          ISC,    EN_HIZ),
 367         BQ24190_SYSFS_FIELD_RW(vindpm,          ISC,    VINDPM),
 368         BQ24190_SYSFS_FIELD_RW(iinlim,          ISC,    IINLIM),
 369         BQ24190_SYSFS_FIELD_RW(chg_config,      POC,    CHG_CONFIG),
 370         BQ24190_SYSFS_FIELD_RW(sys_min,         POC,    SYS_MIN),
 371         BQ24190_SYSFS_FIELD_RW(boost_lim,       POC,    BOOST_LIM),
 372         BQ24190_SYSFS_FIELD_RW(ichg,            CCC,    ICHG),
 373         BQ24190_SYSFS_FIELD_RW(force_20_pct,    CCC,    FORCE_20PCT),
 374         BQ24190_SYSFS_FIELD_RW(iprechg,         PCTCC,  IPRECHG),
 375         BQ24190_SYSFS_FIELD_RW(iterm,           PCTCC,  ITERM),
 376         BQ24190_SYSFS_FIELD_RW(vreg,            CVC,    VREG),
 377         BQ24190_SYSFS_FIELD_RW(batlowv,         CVC,    BATLOWV),
 378         BQ24190_SYSFS_FIELD_RW(vrechg,          CVC,    VRECHG),
 379         BQ24190_SYSFS_FIELD_RW(en_term,         CTTC,   EN_TERM),
 380         BQ24190_SYSFS_FIELD_RW(term_stat,       CTTC,   TERM_STAT),
 381         BQ24190_SYSFS_FIELD_RO(watchdog,        CTTC,   WATCHDOG),
 382         BQ24190_SYSFS_FIELD_RW(en_timer,        CTTC,   EN_TIMER),
 383         BQ24190_SYSFS_FIELD_RW(chg_timer,       CTTC,   CHG_TIMER),
 384         BQ24190_SYSFS_FIELD_RW(jeta_iset,       CTTC,   JEITA_ISET),
 385         BQ24190_SYSFS_FIELD_RW(bat_comp,        ICTRC,  BAT_COMP),
 386         BQ24190_SYSFS_FIELD_RW(vclamp,          ICTRC,  VCLAMP),
 387         BQ24190_SYSFS_FIELD_RW(treg,            ICTRC,  TREG),
 388         BQ24190_SYSFS_FIELD_RW(dpdm_en,         MOC,    DPDM_EN),
 389         BQ24190_SYSFS_FIELD_RW(tmr2x_en,        MOC,    TMR2X_EN),
 390         BQ24190_SYSFS_FIELD_RW(batfet_disable,  MOC,    BATFET_DISABLE),
 391         BQ24190_SYSFS_FIELD_RW(jeita_vset,      MOC,    JEITA_VSET),
 392         BQ24190_SYSFS_FIELD_RO(int_mask,        MOC,    INT_MASK),
 393         BQ24190_SYSFS_FIELD_RO(vbus_stat,       SS,     VBUS_STAT),
 394         BQ24190_SYSFS_FIELD_RO(chrg_stat,       SS,     CHRG_STAT),
 395         BQ24190_SYSFS_FIELD_RO(dpm_stat,        SS,     DPM_STAT),
 396         BQ24190_SYSFS_FIELD_RO(pg_stat,         SS,     PG_STAT),
 397         BQ24190_SYSFS_FIELD_RO(therm_stat,      SS,     THERM_STAT),
 398         BQ24190_SYSFS_FIELD_RO(vsys_stat,       SS,     VSYS_STAT),
 399         BQ24190_SYSFS_FIELD_RO(watchdog_fault,  F,      WATCHDOG_FAULT),
 400         BQ24190_SYSFS_FIELD_RO(boost_fault,     F,      BOOST_FAULT),
 401         BQ24190_SYSFS_FIELD_RO(chrg_fault,      F,      CHRG_FAULT),
 402         BQ24190_SYSFS_FIELD_RO(bat_fault,       F,      BAT_FAULT),
 403         BQ24190_SYSFS_FIELD_RO(ntc_fault,       F,      NTC_FAULT),
 404         BQ24190_SYSFS_FIELD_RO(pn,              VPRS,   PN),
 405         BQ24190_SYSFS_FIELD_RO(ts_profile,      VPRS,   TS_PROFILE),
 406         BQ24190_SYSFS_FIELD_RO(dev_reg,         VPRS,   DEV_REG),
 407 };
 408
 409 static struct attribute *
 410         bq24190_sysfs_attrs[ARRAY_SIZE(bq24190_sysfs_field_tbl) + 1];
 411
 412 ATTRIBUTE_GROUPS(bq24190_sysfs);
 413
 414 static void bq24190_sysfs_init_attrs(void)
 415 {
 416         int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
 417
 418         for (i = 0; i < limit; i++)
 419                 bq24190_sysfs_attrs[i] = &bq24190_sysfs_field_tbl[i].attr.attr;
 420
 421         bq24190_sysfs_attrs[limit] = NULL; /* Has additional entry for this */
 422 }
 423
 424 static struct bq24190_sysfs_field_info *bq24190_sysfs_field_lookup(
 425                 const char *name)
 426 {
 427         int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
 428
 429         for (i = 0; i < limit; i++)
 430                 if (!strcmp(name, bq24190_sysfs_field_tbl[i].attr.attr.name))
 431                         break;
 432
 433         if (i >= limit)
 434                 return NULL;
 435
 436         return &bq24190_sysfs_field_tbl[i];
 437 }
 438
 439 static ssize_t bq24190_sysfs_show(struct device *dev,
 440                 struct device_attribute *attr, char *buf)
 441 {
 442         struct power_supply *psy = dev_get_drvdata(dev);
 443         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
 444         struct bq24190_sysfs_field_info *info;
 445         ssize_t count;
 446         int ret;
 447         u8 v;
 448
 449         info = bq24190_sysfs_field_lookup(attr->attr.name);
 450         if (!info)
 451                 return -EINVAL;
 452
 453         ret = pm_runtime_get_sync(bdi->dev);
 454         if (ret < 0)
 455                 return ret;
 456
 457         ret = bq24190_read_mask(bdi, info->reg, info->mask, info->shift, &v);
 458         if (ret)
 459                 count = ret;
 460         else
 461                 count = scnprintf(buf, PAGE_SIZE, "%hhx\n", v);
 462
 463         pm_runtime_mark_last_busy(bdi->dev);
 464         pm_runtime_put_autosuspend(bdi->dev);
 465
 466         return count;
 467 }
 468
 469 static ssize_t bq24190_sysfs_store(struct device *dev,
 470                 struct device_attribute *attr, const char *buf, size_t count)
 471 {
 472         struct power_supply *psy = dev_get_drvdata(dev);
 473         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
 474         struct bq24190_sysfs_field_info *info;
 475         int ret;
 476         u8 v;
 477
 478         info = bq24190_sysfs_field_lookup(attr->attr.name);
 479         if (!info)
 480                 return -EINVAL;
 481
 482         ret = kstrtou8(buf, 0, &v);
 483         if (ret < 0)
 484                 return ret;
 485
 486         ret = pm_runtime_get_sync(bdi->dev);
 487         if (ret < 0)
 488                 return ret;
 489
 490         ret = bq24190_write_mask(bdi, info->reg, info->mask, info->shift, v);
 491         if (ret)
 492                 count = ret;
 493
 494         pm_runtime_mark_last_busy(bdi->dev);
 495         pm_runtime_put_autosuspend(bdi->dev);
 496
 497         return count;
 498 }
 499 #endif
 500
 501 #ifdef CONFIG_REGULATOR
 502 static int bq24190_set_charge_mode(struct regulator_dev *dev, u8 val)
 503 {
 504         struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
 505         int ret;
 506
 507         ret = pm_runtime_get_sync(bdi->dev);
 508         if (ret < 0) {
 509                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
 510                 pm_runtime_put_noidle(bdi->dev);
 511                 return ret;
 512         }
 513
 514         ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
 515                                  BQ24190_REG_POC_CHG_CONFIG_MASK,
 516                                  BQ24190_REG_POC_CHG_CONFIG_SHIFT, val);
 517
 518         pm_runtime_mark_last_busy(bdi->dev);
 519         pm_runtime_put_autosuspend(bdi->dev);
 520
 521         return ret;
 522 }
 523
 524 static int bq24190_vbus_enable(struct regulator_dev *dev)
 525 {
 526         return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_OTG);
 527 }
 528
 529 static int bq24190_vbus_disable(struct regulator_dev *dev)
 530 {
 531         return bq24190_set_charge_mode(dev, BQ24190_REG_POC_CHG_CONFIG_CHARGE);
 532 }
 533
 534 static int bq24190_vbus_is_enabled(struct regulator_dev *dev)
 535 {
 536         struct bq24190_dev_info *bdi = rdev_get_drvdata(dev);
 537         int ret;
 538         u8 val;
 539
 540         ret = pm_runtime_get_sync(bdi->dev);
 541         if (ret < 0) {
 542                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", ret);
 543                 pm_runtime_put_noidle(bdi->dev);
 544                 return ret;
 545         }
 546
 547         ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
 548                                 BQ24190_REG_POC_CHG_CONFIG_MASK,
 549                                 BQ24190_REG_POC_CHG_CONFIG_SHIFT, &val);
 550
 551         pm_runtime_mark_last_busy(bdi->dev);
 552         pm_runtime_put_autosuspend(bdi->dev);
 553
 554         return ret ? ret : val == BQ24190_REG_POC_CHG_CONFIG_OTG;
 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_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_get_sync(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_get_sync(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
1207         power_supply_set_input_current_limit_from_supplier(bdi->charger);
1208 }
1209
1210 /* Sync the input-current-limit with our parent supply (if we have one) */
1211 static void bq24190_charger_external_power_changed(struct power_supply *psy)
1212 {
1213         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1214
1215         /*
1216          * The Power-Good detection may take up to 220ms, sometimes
1217          * the external charger detection is quicker, and the bq24190 will
1218          * reset to iinlim based on its own charger detection (which is not
1219          * hooked up when using external charger detection) resulting in a
1220          * too low default 500mA iinlim. Delay setting the input-current-limit
1221          * for 300ms to avoid this.
1222          */
1223         queue_delayed_work(system_wq, &bdi->input_current_limit_work,
1224                            msecs_to_jiffies(300));
1225 }
1226
1227 static enum power_supply_property bq24190_charger_properties[] = {
1228         POWER_SUPPLY_PROP_CHARGE_TYPE,
1229         POWER_SUPPLY_PROP_HEALTH,
1230         POWER_SUPPLY_PROP_ONLINE,
1231         POWER_SUPPLY_PROP_STATUS,
1232         POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1233         POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
1234         POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
1235         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1236         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
1237         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1238         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
1239         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1240         POWER_SUPPLY_PROP_SCOPE,
1241         POWER_SUPPLY_PROP_MODEL_NAME,
1242         POWER_SUPPLY_PROP_MANUFACTURER,
1243 };
1244
1245 static char *bq24190_charger_supplied_to[] = {
1246         "main-battery",
1247 };
1248
1249 static const struct power_supply_desc bq24190_charger_desc = {
1250         .name                   = "bq24190-charger",
1251         .type                   = POWER_SUPPLY_TYPE_USB,
1252         .properties             = bq24190_charger_properties,
1253         .num_properties         = ARRAY_SIZE(bq24190_charger_properties),
1254         .get_property           = bq24190_charger_get_property,
1255         .set_property           = bq24190_charger_set_property,
1256         .property_is_writeable  = bq24190_charger_property_is_writeable,
1257         .external_power_changed = bq24190_charger_external_power_changed,
1258 };
1259
1260 /* Battery power supply property routines */
1261
1262 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
1263                 union power_supply_propval *val)
1264 {
1265         u8 ss_reg, chrg_fault;
1266         int status, ret;
1267
1268         mutex_lock(&bdi->f_reg_lock);
1269         chrg_fault = bdi->f_reg;
1270         mutex_unlock(&bdi->f_reg_lock);
1271
1272         chrg_fault &= BQ24190_REG_F_CHRG_FAULT_MASK;
1273         chrg_fault >>= BQ24190_REG_F_CHRG_FAULT_SHIFT;
1274
1275         ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1276         if (ret < 0)
1277                 return ret;
1278
1279         /*
1280          * The battery must be discharging when any of these are true:
1281          * - there is no good power source;
1282          * - there is a charge fault.
1283          * Could also be discharging when in "supplement mode" but
1284          * there is no way to tell when its in that mode.
1285          */
1286         if (!(ss_reg & BQ24190_REG_SS_PG_STAT_MASK) || chrg_fault) {
1287                 status = POWER_SUPPLY_STATUS_DISCHARGING;
1288         } else {
1289                 ss_reg &= BQ24190_REG_SS_CHRG_STAT_MASK;
1290                 ss_reg >>= BQ24190_REG_SS_CHRG_STAT_SHIFT;
1291
1292                 switch (ss_reg) {
1293                 case 0x0: /* Not Charging */
1294                         status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1295                         break;
1296                 case 0x1: /* Pre-charge */
1297                 case 0x2: /* Fast Charging */
1298                         status = POWER_SUPPLY_STATUS_CHARGING;
1299                         break;
1300                 case 0x3: /* Charge Termination Done */
1301                         status = POWER_SUPPLY_STATUS_FULL;
1302                         break;
1303                 default:
1304                         ret = -EIO;
1305                 }
1306         }
1307
1308         if (!ret)
1309                 val->intval = status;
1310
1311         return ret;
1312 }
1313
1314 static int bq24190_battery_get_health(struct bq24190_dev_info *bdi,
1315                 union power_supply_propval *val)
1316 {
1317         u8 v;
1318         int health;
1319
1320         mutex_lock(&bdi->f_reg_lock);
1321         v = bdi->f_reg;
1322         mutex_unlock(&bdi->f_reg_lock);
1323
1324         if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
1325                 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1326         } else {
1327                 v &= BQ24190_REG_F_NTC_FAULT_MASK;
1328                 v >>= BQ24190_REG_F_NTC_FAULT_SHIFT;
1329
1330                 switch (v) {
1331                 case 0x0: /* Normal */
1332                         health = POWER_SUPPLY_HEALTH_GOOD;
1333                         break;
1334                 case 0x1: /* TS1 Cold */
1335                 case 0x3: /* TS2 Cold */
1336                 case 0x5: /* Both Cold */
1337                         health = POWER_SUPPLY_HEALTH_COLD;
1338                         break;
1339                 case 0x2: /* TS1 Hot */
1340                 case 0x4: /* TS2 Hot */
1341                 case 0x6: /* Both Hot */
1342                         health = POWER_SUPPLY_HEALTH_OVERHEAT;
1343                         break;
1344                 default:
1345                         health = POWER_SUPPLY_HEALTH_UNKNOWN;
1346                 }
1347         }
1348
1349         val->intval = health;
1350         return 0;
1351 }
1352
1353 static int bq24190_battery_get_online(struct bq24190_dev_info *bdi,
1354                 union power_supply_propval *val)
1355 {
1356         u8 batfet_disable;
1357         int ret;
1358
1359         ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
1360                         BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1361                         BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
1362         if (ret < 0)
1363                 return ret;
1364
1365         val->intval = !batfet_disable;
1366         return 0;
1367 }
1368
1369 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
1370                 const union power_supply_propval *val)
1371 {
1372         return bq24190_write_mask(bdi, BQ24190_REG_MOC,
1373                         BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1374                         BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, !val->intval);
1375 }
1376
1377 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
1378                 union power_supply_propval *val)
1379 {
1380         int temp, ret;
1381
1382         ret = bq24190_get_field_val(bdi, BQ24190_REG_ICTRC,
1383                         BQ24190_REG_ICTRC_TREG_MASK,
1384                         BQ24190_REG_ICTRC_TREG_SHIFT,
1385                         bq24190_ictrc_treg_values,
1386                         ARRAY_SIZE(bq24190_ictrc_treg_values), &temp);
1387         if (ret < 0)
1388                 return ret;
1389
1390         val->intval = temp;
1391         return 0;
1392 }
1393
1394 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
1395                 const union power_supply_propval *val)
1396 {
1397         return bq24190_set_field_val(bdi, BQ24190_REG_ICTRC,
1398                         BQ24190_REG_ICTRC_TREG_MASK,
1399                         BQ24190_REG_ICTRC_TREG_SHIFT,
1400                         bq24190_ictrc_treg_values,
1401                         ARRAY_SIZE(bq24190_ictrc_treg_values), val->intval);
1402 }
1403
1404 static int bq24190_battery_get_property(struct power_supply *psy,
1405                 enum power_supply_property psp, union power_supply_propval *val)
1406 {
1407         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1408         int ret;
1409
1410         dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1411         dev_dbg(bdi->dev, "prop: %d\n", psp);
1412
1413         ret = pm_runtime_get_sync(bdi->dev);
1414         if (ret < 0)
1415                 return ret;
1416
1417         switch (psp) {
1418         case POWER_SUPPLY_PROP_STATUS:
1419                 ret = bq24190_battery_get_status(bdi, val);
1420                 break;
1421         case POWER_SUPPLY_PROP_HEALTH:
1422                 ret = bq24190_battery_get_health(bdi, val);
1423                 break;
1424         case POWER_SUPPLY_PROP_ONLINE:
1425                 ret = bq24190_battery_get_online(bdi, val);
1426                 break;
1427         case POWER_SUPPLY_PROP_TECHNOLOGY:
1428                 /* Could be Li-on or Li-polymer but no way to tell which */
1429                 val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
1430                 ret = 0;
1431                 break;
1432         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1433                 ret = bq24190_battery_get_temp_alert_max(bdi, val);
1434                 break;
1435         case POWER_SUPPLY_PROP_SCOPE:
1436                 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1437                 ret = 0;
1438                 break;
1439         default:
1440                 ret = -ENODATA;
1441         }
1442
1443         pm_runtime_mark_last_busy(bdi->dev);
1444         pm_runtime_put_autosuspend(bdi->dev);
1445
1446         return ret;
1447 }
1448
1449 static int bq24190_battery_set_property(struct power_supply *psy,
1450                 enum power_supply_property psp,
1451                 const union power_supply_propval *val)
1452 {
1453         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1454         int ret;
1455
1456         dev_warn(bdi->dev, "warning: /sys/class/power_supply/bq24190-battery is deprecated\n");
1457         dev_dbg(bdi->dev, "prop: %d\n", psp);
1458
1459         ret = pm_runtime_get_sync(bdi->dev);
1460         if (ret < 0)
1461                 return ret;
1462
1463         switch (psp) {
1464         case POWER_SUPPLY_PROP_ONLINE:
1465                 ret = bq24190_battery_set_online(bdi, val);
1466                 break;
1467         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1468                 ret = bq24190_battery_set_temp_alert_max(bdi, val);
1469                 break;
1470         default:
1471                 ret = -EINVAL;
1472         }
1473
1474         pm_runtime_mark_last_busy(bdi->dev);
1475         pm_runtime_put_autosuspend(bdi->dev);
1476
1477         return ret;
1478 }
1479
1480 static int bq24190_battery_property_is_writeable(struct power_supply *psy,
1481                 enum power_supply_property psp)
1482 {
1483         int ret;
1484
1485         switch (psp) {
1486         case POWER_SUPPLY_PROP_ONLINE:
1487         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1488                 ret = 1;
1489                 break;
1490         default:
1491                 ret = 0;
1492         }
1493
1494         return ret;
1495 }
1496
1497 static enum power_supply_property bq24190_battery_properties[] = {
1498         POWER_SUPPLY_PROP_STATUS,
1499         POWER_SUPPLY_PROP_HEALTH,
1500         POWER_SUPPLY_PROP_ONLINE,
1501         POWER_SUPPLY_PROP_TECHNOLOGY,
1502         POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1503         POWER_SUPPLY_PROP_SCOPE,
1504 };
1505
1506 static const struct power_supply_desc bq24190_battery_desc = {
1507         .name                   = "bq24190-battery",
1508         .type                   = POWER_SUPPLY_TYPE_BATTERY,
1509         .properties             = bq24190_battery_properties,
1510         .num_properties         = ARRAY_SIZE(bq24190_battery_properties),
1511         .get_property           = bq24190_battery_get_property,
1512         .set_property           = bq24190_battery_set_property,
1513         .property_is_writeable  = bq24190_battery_property_is_writeable,
1514 };
1515
1516 static int bq24190_configure_usb_otg(struct bq24190_dev_info *bdi, u8 ss_reg)
1517 {
1518         bool otg_enabled;
1519         int ret;
1520
1521         otg_enabled = !!(ss_reg & BQ24190_REG_SS_VBUS_STAT_MASK);
1522         ret = extcon_set_state_sync(bdi->edev, EXTCON_USB, otg_enabled);
1523         if (ret < 0)
1524                 dev_err(bdi->dev, "Can't set extcon state to %d: %d\n",
1525                         otg_enabled, ret);
1526
1527         return ret;
1528 }
1529
1530 static void bq24190_check_status(struct bq24190_dev_info *bdi)
1531 {
1532         const u8 battery_mask_ss = BQ24190_REG_SS_CHRG_STAT_MASK;
1533         const u8 battery_mask_f = BQ24190_REG_F_BAT_FAULT_MASK
1534                                 | BQ24190_REG_F_NTC_FAULT_MASK;
1535         bool alert_charger = false, alert_battery = false;
1536         u8 ss_reg = 0, f_reg = 0;
1537         int i, ret;
1538
1539         ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1540         if (ret < 0) {
1541                 dev_err(bdi->dev, "Can't read SS reg: %d\n", ret);
1542                 return;
1543         }
1544
1545         i = 0;
1546         do {
1547                 ret = bq24190_read(bdi, BQ24190_REG_F, &f_reg);
1548                 if (ret < 0) {
1549                         dev_err(bdi->dev, "Can't read F reg: %d\n", ret);
1550                         return;
1551                 }
1552         } while (f_reg && ++i < 2);
1553
1554         /* ignore over/under voltage fault after disconnect */
1555         if (f_reg == (1 << BQ24190_REG_F_CHRG_FAULT_SHIFT) &&
1556             !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK))
1557                 f_reg = 0;
1558
1559         if (f_reg != bdi->f_reg) {
1560                 dev_warn(bdi->dev,
1561                         "Fault: boost %d, charge %d, battery %d, ntc %d\n",
1562                         !!(f_reg & BQ24190_REG_F_BOOST_FAULT_MASK),
1563                         !!(f_reg & BQ24190_REG_F_CHRG_FAULT_MASK),
1564                         !!(f_reg & BQ24190_REG_F_BAT_FAULT_MASK),
1565                         !!(f_reg & BQ24190_REG_F_NTC_FAULT_MASK));
1566
1567                 mutex_lock(&bdi->f_reg_lock);
1568                 if ((bdi->f_reg & battery_mask_f) != (f_reg & battery_mask_f))
1569                         alert_battery = true;
1570                 if ((bdi->f_reg & ~battery_mask_f) != (f_reg & ~battery_mask_f))
1571                         alert_charger = true;
1572                 bdi->f_reg = f_reg;
1573                 mutex_unlock(&bdi->f_reg_lock);
1574         }
1575
1576         if (ss_reg != bdi->ss_reg) {
1577                 /*
1578                  * The device is in host mode so when PG_STAT goes from 1->0
1579                  * (i.e., power removed) HIZ needs to be disabled.
1580                  */
1581                 if ((bdi->ss_reg & BQ24190_REG_SS_PG_STAT_MASK) &&
1582                                 !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK)) {
1583                         ret = bq24190_write_mask(bdi, BQ24190_REG_ISC,
1584                                         BQ24190_REG_ISC_EN_HIZ_MASK,
1585                                         BQ24190_REG_ISC_EN_HIZ_SHIFT,
1586                                         0);
1587                         if (ret < 0)
1588                                 dev_err(bdi->dev, "Can't access ISC reg: %d\n",
1589                                         ret);
1590                 }
1591
1592                 if ((bdi->ss_reg & battery_mask_ss) != (ss_reg & battery_mask_ss))
1593                         alert_battery = true;
1594                 if ((bdi->ss_reg & ~battery_mask_ss) != (ss_reg & ~battery_mask_ss))
1595                         alert_charger = true;
1596                 bdi->ss_reg = ss_reg;
1597         }
1598
1599         if (alert_charger || alert_battery) {
1600                 power_supply_changed(bdi->charger);
1601                 bq24190_configure_usb_otg(bdi, ss_reg);
1602         }
1603         if (alert_battery && bdi->battery)
1604                 power_supply_changed(bdi->battery);
1605
1606         dev_dbg(bdi->dev, "ss_reg: 0x%02x, f_reg: 0x%02x\n", ss_reg, f_reg);
1607 }
1608
1609 static irqreturn_t bq24190_irq_handler_thread(int irq, void *data)
1610 {
1611         struct bq24190_dev_info *bdi = data;
1612         int error;
1613
1614         bdi->irq_event = true;
1615         error = pm_runtime_get_sync(bdi->dev);
1616         if (error < 0) {
1617                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1618                 pm_runtime_put_noidle(bdi->dev);
1619                 return IRQ_NONE;
1620         }
1621         bq24190_check_status(bdi);
1622         pm_runtime_mark_last_busy(bdi->dev);
1623         pm_runtime_put_autosuspend(bdi->dev);
1624         bdi->irq_event = false;
1625
1626         return IRQ_HANDLED;
1627 }
1628
1629 static int bq24190_hw_init(struct bq24190_dev_info *bdi)
1630 {
1631         u8 v;
1632         int ret;
1633
1634         /* First check that the device really is what its supposed to be */
1635         ret = bq24190_read_mask(bdi, BQ24190_REG_VPRS,
1636                         BQ24190_REG_VPRS_PN_MASK,
1637                         BQ24190_REG_VPRS_PN_SHIFT,
1638                         &v);
1639         if (ret < 0)
1640                 return ret;
1641
1642         switch (v) {
1643         case BQ24190_REG_VPRS_PN_24190:
1644         case BQ24190_REG_VPRS_PN_24192:
1645         case BQ24190_REG_VPRS_PN_24192I:
1646                 break;
1647         default:
1648                 dev_err(bdi->dev, "Error unknown model: 0x%02x\n", v);
1649                 return -ENODEV;
1650         }
1651
1652         ret = bq24190_register_reset(bdi);
1653         if (ret < 0)
1654                 return ret;
1655
1656         ret = bq24190_set_config(bdi);
1657         if (ret < 0)
1658                 return ret;
1659
1660         return bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1661 }
1662
1663 static int bq24190_get_config(struct bq24190_dev_info *bdi)
1664 {
1665         const char * const s = "ti,system-minimum-microvolt";
1666         struct power_supply_battery_info info = {};
1667         int v;
1668
1669         if (device_property_read_u32(bdi->dev, s, &v) == 0) {
1670                 v /= 1000;
1671                 if (v >= BQ24190_REG_POC_SYS_MIN_MIN
1672                  && v <= BQ24190_REG_POC_SYS_MIN_MAX)
1673                         bdi->sys_min = v;
1674                 else
1675                         dev_warn(bdi->dev, "invalid value for %s: %u\n", s, v);
1676         }
1677
1678         if (bdi->dev->of_node &&
1679             !power_supply_get_battery_info(bdi->charger, &info)) {
1680                 v = info.precharge_current_ua / 1000;
1681                 if (v >= BQ24190_REG_PCTCC_IPRECHG_MIN
1682                  && v <= BQ24190_REG_PCTCC_IPRECHG_MAX)
1683                         bdi->iprechg = v;
1684                 else
1685                         dev_warn(bdi->dev, "invalid value for battery:precharge-current-microamp: %d\n",
1686                                  v);
1687
1688                 v = info.charge_term_current_ua / 1000;
1689                 if (v >= BQ24190_REG_PCTCC_ITERM_MIN
1690                  && v <= BQ24190_REG_PCTCC_ITERM_MAX)
1691                         bdi->iterm = v;
1692                 else
1693                         dev_warn(bdi->dev, "invalid value for battery:charge-term-current-microamp: %d\n",
1694                                  v);
1695         }
1696
1697         return 0;
1698 }
1699
1700 static int bq24190_probe(struct i2c_client *client,
1701                 const struct i2c_device_id *id)
1702 {
1703         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
1704         struct device *dev = &client->dev;
1705         struct power_supply_config charger_cfg = {}, battery_cfg = {};
1706         struct bq24190_dev_info *bdi;
1707         int ret;
1708
1709         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1710                 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1711                 return -ENODEV;
1712         }
1713
1714         bdi = devm_kzalloc(dev, sizeof(*bdi), GFP_KERNEL);
1715         if (!bdi) {
1716                 dev_err(dev, "Can't alloc bdi struct\n");
1717                 return -ENOMEM;
1718         }
1719
1720         bdi->client = client;
1721         bdi->dev = dev;
1722         strncpy(bdi->model_name, id->name, I2C_NAME_SIZE);
1723         mutex_init(&bdi->f_reg_lock);
1724         bdi->f_reg = 0;
1725         bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1726         INIT_DELAYED_WORK(&bdi->input_current_limit_work,
1727                           bq24190_input_current_limit_work);
1728
1729         i2c_set_clientdata(client, bdi);
1730
1731         if (client->irq <= 0) {
1732                 dev_err(dev, "Can't get irq info\n");
1733                 return -EINVAL;
1734         }
1735
1736         bdi->edev = devm_extcon_dev_allocate(dev, bq24190_usb_extcon_cable);
1737         if (IS_ERR(bdi->edev))
1738                 return PTR_ERR(bdi->edev);
1739
1740         ret = devm_extcon_dev_register(dev, bdi->edev);
1741         if (ret < 0)
1742                 return ret;
1743
1744         pm_runtime_enable(dev);
1745         pm_runtime_use_autosuspend(dev);
1746         pm_runtime_set_autosuspend_delay(dev, 600);
1747         ret = pm_runtime_get_sync(dev);
1748         if (ret < 0) {
1749                 dev_err(dev, "pm_runtime_get failed: %i\n", ret);
1750                 goto out_pmrt;
1751         }
1752
1753 #ifdef CONFIG_SYSFS
1754         bq24190_sysfs_init_attrs();
1755         charger_cfg.attr_grp = bq24190_sysfs_groups;
1756 #endif
1757
1758         charger_cfg.drv_data = bdi;
1759         charger_cfg.of_node = dev->of_node;
1760         charger_cfg.supplied_to = bq24190_charger_supplied_to;
1761         charger_cfg.num_supplicants = ARRAY_SIZE(bq24190_charger_supplied_to),
1762         bdi->charger = power_supply_register(dev, &bq24190_charger_desc,
1763                                                 &charger_cfg);
1764         if (IS_ERR(bdi->charger)) {
1765                 dev_err(dev, "Can't register charger\n");
1766                 ret = PTR_ERR(bdi->charger);
1767                 goto out_pmrt;
1768         }
1769
1770         /* the battery class is deprecated and will be removed. */
1771         /* in the interim, this property hides it.              */
1772         if (!device_property_read_bool(dev, "omit-battery-class")) {
1773                 battery_cfg.drv_data = bdi;
1774                 bdi->battery = power_supply_register(dev, &bq24190_battery_desc,
1775                                                      &battery_cfg);
1776                 if (IS_ERR(bdi->battery)) {
1777                         dev_err(dev, "Can't register battery\n");
1778                         ret = PTR_ERR(bdi->battery);
1779                         goto out_charger;
1780                 }
1781         }
1782
1783         ret = bq24190_get_config(bdi);
1784         if (ret < 0) {
1785                 dev_err(dev, "Can't get devicetree config\n");
1786                 goto out_charger;
1787         }
1788
1789         ret = bq24190_hw_init(bdi);
1790         if (ret < 0) {
1791                 dev_err(dev, "Hardware init failed\n");
1792                 goto out_charger;
1793         }
1794
1795         ret = bq24190_configure_usb_otg(bdi, bdi->ss_reg);
1796         if (ret < 0)
1797                 goto out_charger;
1798
1799         bdi->initialized = true;
1800
1801         ret = devm_request_threaded_irq(dev, client->irq, NULL,
1802                         bq24190_irq_handler_thread,
1803                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1804                         "bq24190-charger", bdi);
1805         if (ret < 0) {
1806                 dev_err(dev, "Can't set up irq handler\n");
1807                 goto out_charger;
1808         }
1809
1810         ret = bq24190_register_vbus_regulator(bdi);
1811         if (ret < 0)
1812                 goto out_charger;
1813
1814         enable_irq_wake(client->irq);
1815
1816         pm_runtime_mark_last_busy(dev);
1817         pm_runtime_put_autosuspend(dev);
1818
1819         return 0;
1820
1821 out_charger:
1822         if (!IS_ERR_OR_NULL(bdi->battery))
1823                 power_supply_unregister(bdi->battery);
1824         power_supply_unregister(bdi->charger);
1825
1826 out_pmrt:
1827         pm_runtime_put_sync(dev);
1828         pm_runtime_dont_use_autosuspend(dev);
1829         pm_runtime_disable(dev);
1830         return ret;
1831 }
1832
1833 static int bq24190_remove(struct i2c_client *client)
1834 {
1835         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1836         int error;
1837
1838         error = pm_runtime_get_sync(bdi->dev);
1839         if (error < 0) {
1840                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1841                 pm_runtime_put_noidle(bdi->dev);
1842         }
1843
1844         bq24190_register_reset(bdi);
1845         if (bdi->battery)
1846                 power_supply_unregister(bdi->battery);
1847         power_supply_unregister(bdi->charger);
1848         if (error >= 0)
1849                 pm_runtime_put_sync(bdi->dev);
1850         pm_runtime_dont_use_autosuspend(bdi->dev);
1851         pm_runtime_disable(bdi->dev);
1852
1853         return 0;
1854 }
1855
1856 static __maybe_unused int bq24190_runtime_suspend(struct device *dev)
1857 {
1858         struct i2c_client *client = to_i2c_client(dev);
1859         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1860
1861         if (!bdi->initialized)
1862                 return 0;
1863
1864         dev_dbg(bdi->dev, "%s\n", __func__);
1865
1866         return 0;
1867 }
1868
1869 static __maybe_unused int bq24190_runtime_resume(struct device *dev)
1870 {
1871         struct i2c_client *client = to_i2c_client(dev);
1872         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1873
1874         if (!bdi->initialized)
1875                 return 0;
1876
1877         if (!bdi->irq_event) {
1878                 dev_dbg(bdi->dev, "checking events on possible wakeirq\n");
1879                 bq24190_check_status(bdi);
1880         }
1881
1882         return 0;
1883 }
1884
1885 static __maybe_unused int bq24190_pm_suspend(struct device *dev)
1886 {
1887         struct i2c_client *client = to_i2c_client(dev);
1888         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1889         int error;
1890
1891         error = pm_runtime_get_sync(bdi->dev);
1892         if (error < 0) {
1893                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1894                 pm_runtime_put_noidle(bdi->dev);
1895         }
1896
1897         bq24190_register_reset(bdi);
1898
1899         if (error >= 0) {
1900                 pm_runtime_mark_last_busy(bdi->dev);
1901                 pm_runtime_put_autosuspend(bdi->dev);
1902         }
1903
1904         return 0;
1905 }
1906
1907 static __maybe_unused int bq24190_pm_resume(struct device *dev)
1908 {
1909         struct i2c_client *client = to_i2c_client(dev);
1910         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1911         int error;
1912
1913         bdi->f_reg = 0;
1914         bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1915
1916         error = pm_runtime_get_sync(bdi->dev);
1917         if (error < 0) {
1918                 dev_warn(bdi->dev, "pm_runtime_get failed: %i\n", error);
1919                 pm_runtime_put_noidle(bdi->dev);
1920         }
1921
1922         bq24190_register_reset(bdi);
1923         bq24190_set_config(bdi);
1924         bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1925
1926         if (error >= 0) {
1927                 pm_runtime_mark_last_busy(bdi->dev);
1928                 pm_runtime_put_autosuspend(bdi->dev);
1929         }
1930
1931         /* Things may have changed while suspended so alert upper layer */
1932         power_supply_changed(bdi->charger);
1933         if (bdi->battery)
1934                 power_supply_changed(bdi->battery);
1935
1936         return 0;
1937 }
1938
1939 static const struct dev_pm_ops bq24190_pm_ops = {
1940         SET_RUNTIME_PM_OPS(bq24190_runtime_suspend, bq24190_runtime_resume,
1941                            NULL)
1942         SET_SYSTEM_SLEEP_PM_OPS(bq24190_pm_suspend, bq24190_pm_resume)
1943 };
1944
1945 static const struct i2c_device_id bq24190_i2c_ids[] = {
1946         { "bq24190" },
1947         { "bq24192" },
1948         { "bq24192i" },
1949         { "bq24196" },
1950         { },
1951 };
1952 MODULE_DEVICE_TABLE(i2c, bq24190_i2c_ids);
1953
1954 #ifdef CONFIG_OF
1955 static const struct of_device_id bq24190_of_match[] = {
1956         { .compatible = "ti,bq24190", },
1957         { .compatible = "ti,bq24192", },
1958         { .compatible = "ti,bq24192i", },
1959         { .compatible = "ti,bq24196", },
1960         { },
1961 };
1962 MODULE_DEVICE_TABLE(of, bq24190_of_match);
1963 #else
1964 static const struct of_device_id bq24190_of_match[] = {
1965         { },
1966 };
1967 #endif
1968
1969 static struct i2c_driver bq24190_driver = {
1970         .probe          = bq24190_probe,
1971         .remove         = bq24190_remove,
1972         .id_table       = bq24190_i2c_ids,
1973         .driver = {
1974                 .name           = "bq24190-charger",
1975                 .pm             = &bq24190_pm_ops,
1976                 .of_match_table = of_match_ptr(bq24190_of_match),
1977         },
1978 };
1979 module_i2c_driver(bq24190_driver);
1980
1981 MODULE_LICENSE("GPL");
1982 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
1983 MODULE_DESCRIPTION("TI BQ24190 Charger Driver");