drivers/power/supply/bq24190_charger.c

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