drivers/power/supply/bq24190_charger.c

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