drivers/power/supply/bq24190_charger.c

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