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