drivers/power/supply/bq24190_charger.c

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