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/gpio.h>
  19 #include <linux/i2c.h>
  20
  21 #include <linux/power/bq24190_charger.h>
  22
  23
  24 #define BQ24190_MANUFACTURER    "Texas Instruments"
  25
  26 #define BQ24190_REG_ISC         0x00 /* Input Source Control */
  27 #define BQ24190_REG_ISC_EN_HIZ_MASK             BIT(7)
  28 #define BQ24190_REG_ISC_EN_HIZ_SHIFT            7
  29 #define BQ24190_REG_ISC_VINDPM_MASK             (BIT(6) | BIT(5) | BIT(4) | \
  30                                                  BIT(3))
  31 #define BQ24190_REG_ISC_VINDPM_SHIFT            3
  32 #define BQ24190_REG_ISC_IINLIM_MASK             (BIT(2) | BIT(1) | BIT(0))
  33 #define BQ24190_REG_ISC_IINLIM_SHIFT            0
  34
  35 #define BQ24190_REG_POC         0x01 /* Power-On Configuration */
  36 #define BQ24190_REG_POC_RESET_MASK              BIT(7)
  37 #define BQ24190_REG_POC_RESET_SHIFT             7
  38 #define BQ24190_REG_POC_WDT_RESET_MASK          BIT(6)
  39 #define BQ24190_REG_POC_WDT_RESET_SHIFT         6
  40 #define BQ24190_REG_POC_CHG_CONFIG_MASK         (BIT(5) | BIT(4))
  41 #define BQ24190_REG_POC_CHG_CONFIG_SHIFT        4
  42 #define BQ24190_REG_POC_SYS_MIN_MASK            (BIT(3) | BIT(2) | BIT(1))
  43 #define BQ24190_REG_POC_SYS_MIN_SHIFT           1
  44 #define BQ24190_REG_POC_BOOST_LIM_MASK          BIT(0)
  45 #define BQ24190_REG_POC_BOOST_LIM_SHIFT         0
  46
  47 #define BQ24190_REG_CCC         0x02 /* Charge Current Control */
  48 #define BQ24190_REG_CCC_ICHG_MASK               (BIT(7) | BIT(6) | BIT(5) | \
  49                                                  BIT(4) | BIT(3) | BIT(2))
  50 #define BQ24190_REG_CCC_ICHG_SHIFT              2
  51 #define BQ24190_REG_CCC_FORCE_20PCT_MASK        BIT(0)
  52 #define BQ24190_REG_CCC_FORCE_20PCT_SHIFT       0
  53
  54 #define BQ24190_REG_PCTCC       0x03 /* Pre-charge/Termination Current Cntl */
  55 #define BQ24190_REG_PCTCC_IPRECHG_MASK          (BIT(7) | BIT(6) | BIT(5) | \
  56                                                  BIT(4))
  57 #define BQ24190_REG_PCTCC_IPRECHG_SHIFT         4
  58 #define BQ24190_REG_PCTCC_ITERM_MASK            (BIT(3) | BIT(2) | BIT(1) | \
  59                                                  BIT(0))
  60 #define BQ24190_REG_PCTCC_ITERM_SHIFT           0
  61
  62 #define BQ24190_REG_CVC         0x04 /* Charge Voltage Control */
  63 #define BQ24190_REG_CVC_VREG_MASK               (BIT(7) | BIT(6) | BIT(5) | \
  64                                                  BIT(4) | BIT(3) | BIT(2))
  65 #define BQ24190_REG_CVC_VREG_SHIFT              2
  66 #define BQ24190_REG_CVC_BATLOWV_MASK            BIT(1)
  67 #define BQ24190_REG_CVC_BATLOWV_SHIFT           1
  68 #define BQ24190_REG_CVC_VRECHG_MASK             BIT(0)
  69 #define BQ24190_REG_CVC_VRECHG_SHIFT            0
  70
  71 #define BQ24190_REG_CTTC        0x05 /* Charge Term/Timer Control */
  72 #define BQ24190_REG_CTTC_EN_TERM_MASK           BIT(7)
  73 #define BQ24190_REG_CTTC_EN_TERM_SHIFT          7
  74 #define BQ24190_REG_CTTC_TERM_STAT_MASK         BIT(6)
  75 #define BQ24190_REG_CTTC_TERM_STAT_SHIFT        6
  76 #define BQ24190_REG_CTTC_WATCHDOG_MASK          (BIT(5) | BIT(4))
  77 #define BQ24190_REG_CTTC_WATCHDOG_SHIFT         4
  78 #define BQ24190_REG_CTTC_EN_TIMER_MASK          BIT(3)
  79 #define BQ24190_REG_CTTC_EN_TIMER_SHIFT         3
  80 #define BQ24190_REG_CTTC_CHG_TIMER_MASK         (BIT(2) | BIT(1))
  81 #define BQ24190_REG_CTTC_CHG_TIMER_SHIFT        1
  82 #define BQ24190_REG_CTTC_JEITA_ISET_MASK        BIT(0)
  83 #define BQ24190_REG_CTTC_JEITA_ISET_SHIFT       0
  84
  85 #define BQ24190_REG_ICTRC       0x06 /* IR Comp/Thermal Regulation Control */
  86 #define BQ24190_REG_ICTRC_BAT_COMP_MASK         (BIT(7) | BIT(6) | BIT(5))
  87 #define BQ24190_REG_ICTRC_BAT_COMP_SHIFT        5
  88 #define BQ24190_REG_ICTRC_VCLAMP_MASK           (BIT(4) | BIT(3) | BIT(2))
  89 #define BQ24190_REG_ICTRC_VCLAMP_SHIFT          2
  90 #define BQ24190_REG_ICTRC_TREG_MASK             (BIT(1) | BIT(0))
  91 #define BQ24190_REG_ICTRC_TREG_SHIFT            0
  92
  93 #define BQ24190_REG_MOC         0x07 /* Misc. Operation Control */
  94 #define BQ24190_REG_MOC_DPDM_EN_MASK            BIT(7)
  95 #define BQ24190_REG_MOC_DPDM_EN_SHIFT           7
  96 #define BQ24190_REG_MOC_TMR2X_EN_MASK           BIT(6)
  97 #define BQ24190_REG_MOC_TMR2X_EN_SHIFT          6
  98 #define BQ24190_REG_MOC_BATFET_DISABLE_MASK     BIT(5)
  99 #define BQ24190_REG_MOC_BATFET_DISABLE_SHIFT    5
 100 #define BQ24190_REG_MOC_JEITA_VSET_MASK         BIT(4)
 101 #define BQ24190_REG_MOC_JEITA_VSET_SHIFT        4
 102 #define BQ24190_REG_MOC_INT_MASK_MASK           (BIT(1) | BIT(0))
 103 #define BQ24190_REG_MOC_INT_MASK_SHIFT          0
 104
 105 #define BQ24190_REG_SS          0x08 /* System Status */
 106 #define BQ24190_REG_SS_VBUS_STAT_MASK           (BIT(7) | BIT(6))
 107 #define BQ24190_REG_SS_VBUS_STAT_SHIFT          6
 108 #define BQ24190_REG_SS_CHRG_STAT_MASK           (BIT(5) | BIT(4))
 109 #define BQ24190_REG_SS_CHRG_STAT_SHIFT          4
 110 #define BQ24190_REG_SS_DPM_STAT_MASK            BIT(3)
 111 #define BQ24190_REG_SS_DPM_STAT_SHIFT           3
 112 #define BQ24190_REG_SS_PG_STAT_MASK             BIT(2)
 113 #define BQ24190_REG_SS_PG_STAT_SHIFT            2
 114 #define BQ24190_REG_SS_THERM_STAT_MASK          BIT(1)
 115 #define BQ24190_REG_SS_THERM_STAT_SHIFT         1
 116 #define BQ24190_REG_SS_VSYS_STAT_MASK           BIT(0)
 117 #define BQ24190_REG_SS_VSYS_STAT_SHIFT          0
 118
 119 #define BQ24190_REG_F           0x09 /* Fault */
 120 #define BQ24190_REG_F_WATCHDOG_FAULT_MASK       BIT(7)
 121 #define BQ24190_REG_F_WATCHDOG_FAULT_SHIFT      7
 122 #define BQ24190_REG_F_BOOST_FAULT_MASK          BIT(6)
 123 #define BQ24190_REG_F_BOOST_FAULT_SHIFT         6
 124 #define BQ24190_REG_F_CHRG_FAULT_MASK           (BIT(5) | BIT(4))
 125 #define BQ24190_REG_F_CHRG_FAULT_SHIFT          4
 126 #define BQ24190_REG_F_BAT_FAULT_MASK            BIT(3)
 127 #define BQ24190_REG_F_BAT_FAULT_SHIFT           3
 128 #define BQ24190_REG_F_NTC_FAULT_MASK            (BIT(2) | BIT(1) | BIT(0))
 129 #define BQ24190_REG_F_NTC_FAULT_SHIFT           0
 130
 131 #define BQ24190_REG_VPRS        0x0A /* Vendor/Part/Revision Status */
 132 #define BQ24190_REG_VPRS_PN_MASK                (BIT(5) | BIT(4) | BIT(3))
 133 #define BQ24190_REG_VPRS_PN_SHIFT               3
 134 #define BQ24190_REG_VPRS_PN_24190                       0x4
 135 #define BQ24190_REG_VPRS_PN_24192                       0x5 /* Also 24193 */
 136 #define BQ24190_REG_VPRS_PN_24192I                      0x3
 137 #define BQ24190_REG_VPRS_TS_PROFILE_MASK        BIT(2)
 138 #define BQ24190_REG_VPRS_TS_PROFILE_SHIFT       2
 139 #define BQ24190_REG_VPRS_DEV_REG_MASK           (BIT(1) | BIT(0))
 140 #define BQ24190_REG_VPRS_DEV_REG_SHIFT          0
 141
 142 /*
 143  * The FAULT register is latched by the bq24190 (except for NTC_FAULT)
 144  * so the first read after a fault returns the latched value and subsequent
 145  * reads return the current value.  In order to return the fault status
 146  * to the user, have the interrupt handler save the reg's value and retrieve
 147  * it in the appropriate health/status routine.  Each routine has its own
 148  * flag indicating whether it should use the value stored by the last run
 149  * of the interrupt handler or do an actual reg read.  That way each routine
 150  * can report back whatever fault may have occured.
 151  */
 152 struct bq24190_dev_info {
 153         struct i2c_client               *client;
 154         struct device                   *dev;
 155         struct power_supply             *charger;
 156         struct power_supply             *battery;
 157         char                            model_name[I2C_NAME_SIZE];
 158         kernel_ulong_t                  model;
 159         unsigned int                    gpio_int;
 160         unsigned int                    irq;
 161         struct mutex                    f_reg_lock;
 162         bool                            charger_health_valid;
 163         bool                            battery_health_valid;
 164         bool                            battery_status_valid;
 165         u8                              f_reg;
 166         u8                              ss_reg;
 167         u8                              watchdog;
 168 };
 169
 170 /*
 171  * The tables below provide a 2-way mapping for the value that goes in
 172  * the register field and the real-world value that it represents.
 173  * The index of the array is the value that goes in the register; the
 174  * number at that index in the array is the real-world value that it
 175  * represents.
 176  */
 177 /* REG02[7:2] (ICHG) in uAh */
 178 static const int bq24190_ccc_ichg_values[] = {
 179          512000,  576000,  640000,  704000,  768000,  832000,  896000,  960000,
 180         1024000, 1088000, 1152000, 1216000, 1280000, 1344000, 1408000, 1472000,
 181         1536000, 1600000, 1664000, 1728000, 1792000, 1856000, 1920000, 1984000,
 182         2048000, 2112000, 2176000, 2240000, 2304000, 2368000, 2432000, 2496000,
 183         2560000, 2624000, 2688000, 2752000, 2816000, 2880000, 2944000, 3008000,
 184         3072000, 3136000, 3200000, 3264000, 3328000, 3392000, 3456000, 3520000,
 185         3584000, 3648000, 3712000, 3776000, 3840000, 3904000, 3968000, 4032000,
 186         4096000, 4160000, 4224000, 4288000, 4352000, 4416000, 4480000, 4544000
 187 };
 188
 189 /* REG04[7:2] (VREG) in uV */
 190 static const int bq24190_cvc_vreg_values[] = {
 191         3504000, 3520000, 3536000, 3552000, 3568000, 3584000, 3600000, 3616000,
 192         3632000, 3648000, 3664000, 3680000, 3696000, 3712000, 3728000, 3744000,
 193         3760000, 3776000, 3792000, 3808000, 3824000, 3840000, 3856000, 3872000,
 194         3888000, 3904000, 3920000, 3936000, 3952000, 3968000, 3984000, 4000000,
 195         4016000, 4032000, 4048000, 4064000, 4080000, 4096000, 4112000, 4128000,
 196         4144000, 4160000, 4176000, 4192000, 4208000, 4224000, 4240000, 4256000,
 197         4272000, 4288000, 4304000, 4320000, 4336000, 4352000, 4368000, 4384000,
 198         4400000
 199 };
 200
 201 /* REG06[1:0] (TREG) in tenths of degrees Celsius */
 202 static const int bq24190_ictrc_treg_values[] = {
 203         600, 800, 1000, 1200
 204 };
 205
 206 /*
 207  * Return the index in 'tbl' of greatest value that is less than or equal to
 208  * 'val'.  The index range returned is 0 to 'tbl_size' - 1.  Assumes that
 209  * the values in 'tbl' are sorted from smallest to largest and 'tbl_size'
 210  * is less than 2^8.
 211  */
 212 static u8 bq24190_find_idx(const int tbl[], int tbl_size, int v)
 213 {
 214         int i;
 215
 216         for (i = 1; i < tbl_size; i++)
 217                 if (v < tbl[i])
 218                         break;
 219
 220         return i - 1;
 221 }
 222
 223 /* Basic driver I/O routines */
 224
 225 static int bq24190_read(struct bq24190_dev_info *bdi, u8 reg, u8 *data)
 226 {
 227         int ret;
 228
 229         ret = i2c_smbus_read_byte_data(bdi->client, reg);
 230         if (ret < 0)
 231                 return ret;
 232
 233         *data = ret;
 234         return 0;
 235 }
 236
 237 static int bq24190_write(struct bq24190_dev_info *bdi, u8 reg, u8 data)
 238 {
 239         return i2c_smbus_write_byte_data(bdi->client, reg, data);
 240 }
 241
 242 static int bq24190_read_mask(struct bq24190_dev_info *bdi, u8 reg,
 243                 u8 mask, u8 shift, u8 *data)
 244 {
 245         u8 v;
 246         int ret;
 247
 248         ret = bq24190_read(bdi, reg, &v);
 249         if (ret < 0)
 250                 return ret;
 251
 252         v &= mask;
 253         v >>= shift;
 254         *data = v;
 255
 256         return 0;
 257 }
 258
 259 static int bq24190_write_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 |= ((data << shift) & mask);
 271
 272         return bq24190_write(bdi, reg, v);
 273 }
 274
 275 static int bq24190_get_field_val(struct bq24190_dev_info *bdi,
 276                 u8 reg, u8 mask, u8 shift,
 277                 const int tbl[], int tbl_size,
 278                 int *val)
 279 {
 280         u8 v;
 281         int ret;
 282
 283         ret = bq24190_read_mask(bdi, reg, mask, shift, &v);
 284         if (ret < 0)
 285                 return ret;
 286
 287         v = (v >= tbl_size) ? (tbl_size - 1) : v;
 288         *val = tbl[v];
 289
 290         return 0;
 291 }
 292
 293 static int bq24190_set_field_val(struct bq24190_dev_info *bdi,
 294                 u8 reg, u8 mask, u8 shift,
 295                 const int tbl[], int tbl_size,
 296                 int val)
 297 {
 298         u8 idx;
 299
 300         idx = bq24190_find_idx(tbl, tbl_size, val);
 301
 302         return bq24190_write_mask(bdi, reg, mask, shift, idx);
 303 }
 304
 305 #ifdef CONFIG_SYSFS
 306 /*
 307  * There are a numerous options that are configurable on the bq24190
 308  * that go well beyond what the power_supply properties provide access to.
 309  * Provide sysfs access to them so they can be examined and possibly modified
 310  * on the fly.  They will be provided for the charger power_supply object only
 311  * and will be prefixed by 'f_' to make them easier to recognize.
 312  */
 313
 314 #define BQ24190_SYSFS_FIELD(_name, r, f, m, store)                      \
 315 {                                                                       \
 316         .attr   = __ATTR(f_##_name, m, bq24190_sysfs_show, store),      \
 317         .reg    = BQ24190_REG_##r,                                      \
 318         .mask   = BQ24190_REG_##r##_##f##_MASK,                         \
 319         .shift  = BQ24190_REG_##r##_##f##_SHIFT,                        \
 320 }
 321
 322 #define BQ24190_SYSFS_FIELD_RW(_name, r, f)                             \
 323                 BQ24190_SYSFS_FIELD(_name, r, f, S_IWUSR | S_IRUGO,     \
 324                                 bq24190_sysfs_store)
 325
 326 #define BQ24190_SYSFS_FIELD_RO(_name, r, f)                             \
 327                 BQ24190_SYSFS_FIELD(_name, r, f, S_IRUGO, NULL)
 328
 329 static ssize_t bq24190_sysfs_show(struct device *dev,
 330                 struct device_attribute *attr, char *buf);
 331 static ssize_t bq24190_sysfs_store(struct device *dev,
 332                 struct device_attribute *attr, const char *buf, size_t count);
 333
 334 struct bq24190_sysfs_field_info {
 335         struct device_attribute attr;
 336         u8      reg;
 337         u8      mask;
 338         u8      shift;
 339 };
 340
 341 /* On i386 ptrace-abi.h defines SS that breaks the macro calls below. */
 342 #undef SS
 343
 344 static struct bq24190_sysfs_field_info bq24190_sysfs_field_tbl[] = {
 345                         /*      sysfs name      reg     field in reg */
 346         BQ24190_SYSFS_FIELD_RW(en_hiz,          ISC,    EN_HIZ),
 347         BQ24190_SYSFS_FIELD_RW(vindpm,          ISC,    VINDPM),
 348         BQ24190_SYSFS_FIELD_RW(iinlim,          ISC,    IINLIM),
 349         BQ24190_SYSFS_FIELD_RW(chg_config,      POC,    CHG_CONFIG),
 350         BQ24190_SYSFS_FIELD_RW(sys_min,         POC,    SYS_MIN),
 351         BQ24190_SYSFS_FIELD_RW(boost_lim,       POC,    BOOST_LIM),
 352         BQ24190_SYSFS_FIELD_RW(ichg,            CCC,    ICHG),
 353         BQ24190_SYSFS_FIELD_RW(force_20_pct,    CCC,    FORCE_20PCT),
 354         BQ24190_SYSFS_FIELD_RW(iprechg,         PCTCC,  IPRECHG),
 355         BQ24190_SYSFS_FIELD_RW(iterm,           PCTCC,  ITERM),
 356         BQ24190_SYSFS_FIELD_RW(vreg,            CVC,    VREG),
 357         BQ24190_SYSFS_FIELD_RW(batlowv,         CVC,    BATLOWV),
 358         BQ24190_SYSFS_FIELD_RW(vrechg,          CVC,    VRECHG),
 359         BQ24190_SYSFS_FIELD_RW(en_term,         CTTC,   EN_TERM),
 360         BQ24190_SYSFS_FIELD_RW(term_stat,       CTTC,   TERM_STAT),
 361         BQ24190_SYSFS_FIELD_RO(watchdog,        CTTC,   WATCHDOG),
 362         BQ24190_SYSFS_FIELD_RW(en_timer,        CTTC,   EN_TIMER),
 363         BQ24190_SYSFS_FIELD_RW(chg_timer,       CTTC,   CHG_TIMER),
 364         BQ24190_SYSFS_FIELD_RW(jeta_iset,       CTTC,   JEITA_ISET),
 365         BQ24190_SYSFS_FIELD_RW(bat_comp,        ICTRC,  BAT_COMP),
 366         BQ24190_SYSFS_FIELD_RW(vclamp,          ICTRC,  VCLAMP),
 367         BQ24190_SYSFS_FIELD_RW(treg,            ICTRC,  TREG),
 368         BQ24190_SYSFS_FIELD_RW(dpdm_en,         MOC,    DPDM_EN),
 369         BQ24190_SYSFS_FIELD_RW(tmr2x_en,        MOC,    TMR2X_EN),
 370         BQ24190_SYSFS_FIELD_RW(batfet_disable,  MOC,    BATFET_DISABLE),
 371         BQ24190_SYSFS_FIELD_RW(jeita_vset,      MOC,    JEITA_VSET),
 372         BQ24190_SYSFS_FIELD_RO(int_mask,        MOC,    INT_MASK),
 373         BQ24190_SYSFS_FIELD_RO(vbus_stat,       SS,     VBUS_STAT),
 374         BQ24190_SYSFS_FIELD_RO(chrg_stat,       SS,     CHRG_STAT),
 375         BQ24190_SYSFS_FIELD_RO(dpm_stat,        SS,     DPM_STAT),
 376         BQ24190_SYSFS_FIELD_RO(pg_stat,         SS,     PG_STAT),
 377         BQ24190_SYSFS_FIELD_RO(therm_stat,      SS,     THERM_STAT),
 378         BQ24190_SYSFS_FIELD_RO(vsys_stat,       SS,     VSYS_STAT),
 379         BQ24190_SYSFS_FIELD_RO(watchdog_fault,  F,      WATCHDOG_FAULT),
 380         BQ24190_SYSFS_FIELD_RO(boost_fault,     F,      BOOST_FAULT),
 381         BQ24190_SYSFS_FIELD_RO(chrg_fault,      F,      CHRG_FAULT),
 382         BQ24190_SYSFS_FIELD_RO(bat_fault,       F,      BAT_FAULT),
 383         BQ24190_SYSFS_FIELD_RO(ntc_fault,       F,      NTC_FAULT),
 384         BQ24190_SYSFS_FIELD_RO(pn,              VPRS,   PN),
 385         BQ24190_SYSFS_FIELD_RO(ts_profile,      VPRS,   TS_PROFILE),
 386         BQ24190_SYSFS_FIELD_RO(dev_reg,         VPRS,   DEV_REG),
 387 };
 388
 389 static struct attribute *
 390         bq24190_sysfs_attrs[ARRAY_SIZE(bq24190_sysfs_field_tbl) + 1];
 391
 392 static const struct attribute_group bq24190_sysfs_attr_group = {
 393         .attrs = bq24190_sysfs_attrs,
 394 };
 395
 396 static void bq24190_sysfs_init_attrs(void)
 397 {
 398         int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
 399
 400         for (i = 0; i < limit; i++)
 401                 bq24190_sysfs_attrs[i] = &bq24190_sysfs_field_tbl[i].attr.attr;
 402
 403         bq24190_sysfs_attrs[limit] = NULL; /* Has additional entry for this */
 404 }
 405
 406 static struct bq24190_sysfs_field_info *bq24190_sysfs_field_lookup(
 407                 const char *name)
 408 {
 409         int i, limit = ARRAY_SIZE(bq24190_sysfs_field_tbl);
 410
 411         for (i = 0; i < limit; i++)
 412                 if (!strcmp(name, bq24190_sysfs_field_tbl[i].attr.attr.name))
 413                         break;
 414
 415         if (i >= limit)
 416                 return NULL;
 417
 418         return &bq24190_sysfs_field_tbl[i];
 419 }
 420
 421 static ssize_t bq24190_sysfs_show(struct device *dev,
 422                 struct device_attribute *attr, char *buf)
 423 {
 424         struct power_supply *psy = dev_get_drvdata(dev);
 425         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
 426         struct bq24190_sysfs_field_info *info;
 427         int ret;
 428         u8 v;
 429
 430         info = bq24190_sysfs_field_lookup(attr->attr.name);
 431         if (!info)
 432                 return -EINVAL;
 433
 434         ret = bq24190_read_mask(bdi, info->reg, info->mask, info->shift, &v);
 435         if (ret)
 436                 return ret;
 437
 438         return scnprintf(buf, PAGE_SIZE, "%hhx\n", v);
 439 }
 440
 441 static ssize_t bq24190_sysfs_store(struct device *dev,
 442                 struct device_attribute *attr, const char *buf, size_t count)
 443 {
 444         struct power_supply *psy = dev_get_drvdata(dev);
 445         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
 446         struct bq24190_sysfs_field_info *info;
 447         int ret;
 448         u8 v;
 449
 450         info = bq24190_sysfs_field_lookup(attr->attr.name);
 451         if (!info)
 452                 return -EINVAL;
 453
 454         ret = kstrtou8(buf, 0, &v);
 455         if (ret < 0)
 456                 return ret;
 457
 458         ret = bq24190_write_mask(bdi, info->reg, info->mask, info->shift, v);
 459         if (ret)
 460                 return ret;
 461
 462         return count;
 463 }
 464
 465 static int bq24190_sysfs_create_group(struct bq24190_dev_info *bdi)
 466 {
 467         bq24190_sysfs_init_attrs();
 468
 469         return sysfs_create_group(&bdi->charger->dev.kobj,
 470                         &bq24190_sysfs_attr_group);
 471 }
 472
 473 static void bq24190_sysfs_remove_group(struct bq24190_dev_info *bdi)
 474 {
 475         sysfs_remove_group(&bdi->charger->dev.kobj, &bq24190_sysfs_attr_group);
 476 }
 477 #else
 478 static int bq24190_sysfs_create_group(struct bq24190_dev_info *bdi)
 479 {
 480         return 0;
 481 }
 482
 483 static inline void bq24190_sysfs_remove_group(struct bq24190_dev_info *bdi) {}
 484 #endif
 485
 486 /*
 487  * According to the "Host Mode and default Mode" section of the
 488  * manual, a write to any register causes the bq24190 to switch
 489  * from default mode to host mode.  It will switch back to default
 490  * mode after a WDT timeout unless the WDT is turned off as well.
 491  * So, by simply turning off the WDT, we accomplish both with the
 492  * same write.
 493  */
 494 static int bq24190_set_mode_host(struct bq24190_dev_info *bdi)
 495 {
 496         int ret;
 497         u8 v;
 498
 499         ret = bq24190_read(bdi, BQ24190_REG_CTTC, &v);
 500         if (ret < 0)
 501                 return ret;
 502
 503         bdi->watchdog = ((v & BQ24190_REG_CTTC_WATCHDOG_MASK) >>
 504                                         BQ24190_REG_CTTC_WATCHDOG_SHIFT);
 505         v &= ~BQ24190_REG_CTTC_WATCHDOG_MASK;
 506
 507         return bq24190_write(bdi, BQ24190_REG_CTTC, v);
 508 }
 509
 510 static int bq24190_register_reset(struct bq24190_dev_info *bdi)
 511 {
 512         int ret, limit = 100;
 513         u8 v;
 514
 515         /* Reset the registers */
 516         ret = bq24190_write_mask(bdi, BQ24190_REG_POC,
 517                         BQ24190_REG_POC_RESET_MASK,
 518                         BQ24190_REG_POC_RESET_SHIFT,
 519                         0x1);
 520         if (ret < 0)
 521                 return ret;
 522
 523         /* Reset bit will be cleared by hardware so poll until it is */
 524         do {
 525                 ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
 526                                 BQ24190_REG_POC_RESET_MASK,
 527                                 BQ24190_REG_POC_RESET_SHIFT,
 528                                 &v);
 529                 if (ret < 0)
 530                         return ret;
 531
 532                 if (!v)
 533                         break;
 534
 535                 udelay(10);
 536         } while (--limit);
 537
 538         if (!limit)
 539                 return -EIO;
 540
 541         return 0;
 542 }
 543
 544 /* Charger power supply property routines */
 545
 546 static int bq24190_charger_get_charge_type(struct bq24190_dev_info *bdi,
 547                 union power_supply_propval *val)
 548 {
 549         u8 v;
 550         int type, ret;
 551
 552         ret = bq24190_read_mask(bdi, BQ24190_REG_POC,
 553                         BQ24190_REG_POC_CHG_CONFIG_MASK,
 554                         BQ24190_REG_POC_CHG_CONFIG_SHIFT,
 555                         &v);
 556         if (ret < 0)
 557                 return ret;
 558
 559         /* If POC[CHG_CONFIG] (REG01[5:4]) == 0, charge is disabled */
 560         if (!v) {
 561                 type = POWER_SUPPLY_CHARGE_TYPE_NONE;
 562         } else {
 563                 ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
 564                                 BQ24190_REG_CCC_FORCE_20PCT_MASK,
 565                                 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
 566                                 &v);
 567                 if (ret < 0)
 568                         return ret;
 569
 570                 type = (v) ? POWER_SUPPLY_CHARGE_TYPE_TRICKLE :
 571                              POWER_SUPPLY_CHARGE_TYPE_FAST;
 572         }
 573
 574         val->intval = type;
 575
 576         return 0;
 577 }
 578
 579 static int bq24190_charger_set_charge_type(struct bq24190_dev_info *bdi,
 580                 const union power_supply_propval *val)
 581 {
 582         u8 chg_config, force_20pct, en_term;
 583         int ret;
 584
 585         /*
 586          * According to the "Termination when REG02[0] = 1" section of
 587          * the bq24190 manual, the trickle charge could be less than the
 588          * termination current so it recommends turning off the termination
 589          * function.
 590          *
 591          * Note: AFAICT from the datasheet, the user will have to manually
 592          * turn off the charging when in 20% mode.  If its not turned off,
 593          * there could be battery damage.  So, use this mode at your own risk.
 594          */
 595         switch (val->intval) {
 596         case POWER_SUPPLY_CHARGE_TYPE_NONE:
 597                 chg_config = 0x0;
 598                 break;
 599         case POWER_SUPPLY_CHARGE_TYPE_TRICKLE:
 600                 chg_config = 0x1;
 601                 force_20pct = 0x1;
 602                 en_term = 0x0;
 603                 break;
 604         case POWER_SUPPLY_CHARGE_TYPE_FAST:
 605                 chg_config = 0x1;
 606                 force_20pct = 0x0;
 607                 en_term = 0x1;
 608                 break;
 609         default:
 610                 return -EINVAL;
 611         }
 612
 613         if (chg_config) { /* Enabling the charger */
 614                 ret = bq24190_write_mask(bdi, BQ24190_REG_CCC,
 615                                 BQ24190_REG_CCC_FORCE_20PCT_MASK,
 616                                 BQ24190_REG_CCC_FORCE_20PCT_SHIFT,
 617                                 force_20pct);
 618                 if (ret < 0)
 619                         return ret;
 620
 621                 ret = bq24190_write_mask(bdi, BQ24190_REG_CTTC,
 622                                 BQ24190_REG_CTTC_EN_TERM_MASK,
 623                                 BQ24190_REG_CTTC_EN_TERM_SHIFT,
 624                                 en_term);
 625                 if (ret < 0)
 626                         return ret;
 627         }
 628
 629         return bq24190_write_mask(bdi, BQ24190_REG_POC,
 630                         BQ24190_REG_POC_CHG_CONFIG_MASK,
 631                         BQ24190_REG_POC_CHG_CONFIG_SHIFT, chg_config);
 632 }
 633
 634 static int bq24190_charger_get_health(struct bq24190_dev_info *bdi,
 635                 union power_supply_propval *val)
 636 {
 637         u8 v;
 638         int health, ret;
 639
 640         mutex_lock(&bdi->f_reg_lock);
 641
 642         if (bdi->charger_health_valid) {
 643                 v = bdi->f_reg;
 644                 bdi->charger_health_valid = false;
 645                 mutex_unlock(&bdi->f_reg_lock);
 646         } else {
 647                 mutex_unlock(&bdi->f_reg_lock);
 648
 649                 ret = bq24190_read(bdi, BQ24190_REG_F, &v);
 650                 if (ret < 0)
 651                         return ret;
 652         }
 653
 654         if (v & BQ24190_REG_F_BOOST_FAULT_MASK) {
 655                 /*
 656                  * This could be over-current or over-voltage but there's
 657                  * no way to tell which.  Return 'OVERVOLTAGE' since there
 658                  * isn't an 'OVERCURRENT' value defined that we can return
 659                  * even if it was over-current.
 660                  */
 661                 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 662         } else {
 663                 v &= BQ24190_REG_F_CHRG_FAULT_MASK;
 664                 v >>= BQ24190_REG_F_CHRG_FAULT_SHIFT;
 665
 666                 switch (v) {
 667                 case 0x0: /* Normal */
 668                         health = POWER_SUPPLY_HEALTH_GOOD;
 669                         break;
 670                 case 0x1: /* Input Fault (VBUS OVP or VBAT<VBUS<3.8V) */
 671                         /*
 672                          * This could be over-voltage or under-voltage
 673                          * and there's no way to tell which.  Instead
 674                          * of looking foolish and returning 'OVERVOLTAGE'
 675                          * when its really under-voltage, just return
 676                          * 'UNSPEC_FAILURE'.
 677                          */
 678                         health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 679                         break;
 680                 case 0x2: /* Thermal Shutdown */
 681                         health = POWER_SUPPLY_HEALTH_OVERHEAT;
 682                         break;
 683                 case 0x3: /* Charge Safety Timer Expiration */
 684                         health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 685                         break;
 686                 default:
 687                         health = POWER_SUPPLY_HEALTH_UNKNOWN;
 688                 }
 689         }
 690
 691         val->intval = health;
 692
 693         return 0;
 694 }
 695
 696 static int bq24190_charger_get_online(struct bq24190_dev_info *bdi,
 697                 union power_supply_propval *val)
 698 {
 699         u8 v;
 700         int ret;
 701
 702         ret = bq24190_read_mask(bdi, BQ24190_REG_SS,
 703                         BQ24190_REG_SS_PG_STAT_MASK,
 704                         BQ24190_REG_SS_PG_STAT_SHIFT, &v);
 705         if (ret < 0)
 706                 return ret;
 707
 708         val->intval = v;
 709         return 0;
 710 }
 711
 712 static int bq24190_charger_get_current(struct bq24190_dev_info *bdi,
 713                 union power_supply_propval *val)
 714 {
 715         u8 v;
 716         int curr, ret;
 717
 718         ret = bq24190_get_field_val(bdi, BQ24190_REG_CCC,
 719                         BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
 720                         bq24190_ccc_ichg_values,
 721                         ARRAY_SIZE(bq24190_ccc_ichg_values), &curr);
 722         if (ret < 0)
 723                 return ret;
 724
 725         ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
 726                         BQ24190_REG_CCC_FORCE_20PCT_MASK,
 727                         BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
 728         if (ret < 0)
 729                 return ret;
 730
 731         /* If FORCE_20PCT is enabled, then current is 20% of ICHG value */
 732         if (v)
 733                 curr /= 5;
 734
 735         val->intval = curr;
 736         return 0;
 737 }
 738
 739 static int bq24190_charger_get_current_max(struct bq24190_dev_info *bdi,
 740                 union power_supply_propval *val)
 741 {
 742         int idx = ARRAY_SIZE(bq24190_ccc_ichg_values) - 1;
 743
 744         val->intval = bq24190_ccc_ichg_values[idx];
 745         return 0;
 746 }
 747
 748 static int bq24190_charger_set_current(struct bq24190_dev_info *bdi,
 749                 const union power_supply_propval *val)
 750 {
 751         u8 v;
 752         int ret, curr = val->intval;
 753
 754         ret = bq24190_read_mask(bdi, BQ24190_REG_CCC,
 755                         BQ24190_REG_CCC_FORCE_20PCT_MASK,
 756                         BQ24190_REG_CCC_FORCE_20PCT_SHIFT, &v);
 757         if (ret < 0)
 758                 return ret;
 759
 760         /* If FORCE_20PCT is enabled, have to multiply value passed in by 5 */
 761         if (v)
 762                 curr *= 5;
 763
 764         return bq24190_set_field_val(bdi, BQ24190_REG_CCC,
 765                         BQ24190_REG_CCC_ICHG_MASK, BQ24190_REG_CCC_ICHG_SHIFT,
 766                         bq24190_ccc_ichg_values,
 767                         ARRAY_SIZE(bq24190_ccc_ichg_values), curr);
 768 }
 769
 770 static int bq24190_charger_get_voltage(struct bq24190_dev_info *bdi,
 771                 union power_supply_propval *val)
 772 {
 773         int voltage, ret;
 774
 775         ret = bq24190_get_field_val(bdi, BQ24190_REG_CVC,
 776                         BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
 777                         bq24190_cvc_vreg_values,
 778                         ARRAY_SIZE(bq24190_cvc_vreg_values), &voltage);
 779         if (ret < 0)
 780                 return ret;
 781
 782         val->intval = voltage;
 783         return 0;
 784 }
 785
 786 static int bq24190_charger_get_voltage_max(struct bq24190_dev_info *bdi,
 787                 union power_supply_propval *val)
 788 {
 789         int idx = ARRAY_SIZE(bq24190_cvc_vreg_values) - 1;
 790
 791         val->intval = bq24190_cvc_vreg_values[idx];
 792         return 0;
 793 }
 794
 795 static int bq24190_charger_set_voltage(struct bq24190_dev_info *bdi,
 796                 const union power_supply_propval *val)
 797 {
 798         return bq24190_set_field_val(bdi, BQ24190_REG_CVC,
 799                         BQ24190_REG_CVC_VREG_MASK, BQ24190_REG_CVC_VREG_SHIFT,
 800                         bq24190_cvc_vreg_values,
 801                         ARRAY_SIZE(bq24190_cvc_vreg_values), val->intval);
 802 }
 803
 804 static int bq24190_charger_get_property(struct power_supply *psy,
 805                 enum power_supply_property psp, union power_supply_propval *val)
 806 {
 807         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
 808         int ret;
 809
 810         dev_dbg(bdi->dev, "prop: %d\n", psp);
 811
 812         pm_runtime_get_sync(bdi->dev);
 813
 814         switch (psp) {
 815         case POWER_SUPPLY_PROP_CHARGE_TYPE:
 816                 ret = bq24190_charger_get_charge_type(bdi, val);
 817                 break;
 818         case POWER_SUPPLY_PROP_HEALTH:
 819                 ret = bq24190_charger_get_health(bdi, val);
 820                 break;
 821         case POWER_SUPPLY_PROP_ONLINE:
 822                 ret = bq24190_charger_get_online(bdi, val);
 823                 break;
 824         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 825                 ret = bq24190_charger_get_current(bdi, val);
 826                 break;
 827         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 828                 ret = bq24190_charger_get_current_max(bdi, val);
 829                 break;
 830         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 831                 ret = bq24190_charger_get_voltage(bdi, val);
 832                 break;
 833         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 834                 ret = bq24190_charger_get_voltage_max(bdi, val);
 835                 break;
 836         case POWER_SUPPLY_PROP_SCOPE:
 837                 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
 838                 ret = 0;
 839                 break;
 840         case POWER_SUPPLY_PROP_MODEL_NAME:
 841                 val->strval = bdi->model_name;
 842                 ret = 0;
 843                 break;
 844         case POWER_SUPPLY_PROP_MANUFACTURER:
 845                 val->strval = BQ24190_MANUFACTURER;
 846                 ret = 0;
 847                 break;
 848         default:
 849                 ret = -ENODATA;
 850         }
 851
 852         pm_runtime_put_sync(bdi->dev);
 853         return ret;
 854 }
 855
 856 static int bq24190_charger_set_property(struct power_supply *psy,
 857                 enum power_supply_property psp,
 858                 const union power_supply_propval *val)
 859 {
 860         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
 861         int ret;
 862
 863         dev_dbg(bdi->dev, "prop: %d\n", psp);
 864
 865         pm_runtime_get_sync(bdi->dev);
 866
 867         switch (psp) {
 868         case POWER_SUPPLY_PROP_CHARGE_TYPE:
 869                 ret = bq24190_charger_set_charge_type(bdi, val);
 870                 break;
 871         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 872                 ret = bq24190_charger_set_current(bdi, val);
 873                 break;
 874         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 875                 ret = bq24190_charger_set_voltage(bdi, val);
 876                 break;
 877         default:
 878                 ret = -EINVAL;
 879         }
 880
 881         pm_runtime_put_sync(bdi->dev);
 882         return ret;
 883 }
 884
 885 static int bq24190_charger_property_is_writeable(struct power_supply *psy,
 886                 enum power_supply_property psp)
 887 {
 888         int ret;
 889
 890         switch (psp) {
 891         case POWER_SUPPLY_PROP_CHARGE_TYPE:
 892         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 893         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 894                 ret = 1;
 895                 break;
 896         default:
 897                 ret = 0;
 898         }
 899
 900         return ret;
 901 }
 902
 903 static enum power_supply_property bq24190_charger_properties[] = {
 904         POWER_SUPPLY_PROP_CHARGE_TYPE,
 905         POWER_SUPPLY_PROP_HEALTH,
 906         POWER_SUPPLY_PROP_ONLINE,
 907         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 908         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 909         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 910         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 911         POWER_SUPPLY_PROP_SCOPE,
 912         POWER_SUPPLY_PROP_MODEL_NAME,
 913         POWER_SUPPLY_PROP_MANUFACTURER,
 914 };
 915
 916 static char *bq24190_charger_supplied_to[] = {
 917         "main-battery",
 918 };
 919
 920 static const struct power_supply_desc bq24190_charger_desc = {
 921         .name                   = "bq24190-charger",
 922         .type                   = POWER_SUPPLY_TYPE_USB,
 923         .properties             = bq24190_charger_properties,
 924         .num_properties         = ARRAY_SIZE(bq24190_charger_properties),
 925         .get_property           = bq24190_charger_get_property,
 926         .set_property           = bq24190_charger_set_property,
 927         .property_is_writeable  = bq24190_charger_property_is_writeable,
 928 };
 929
 930 /* Battery power supply property routines */
 931
 932 static int bq24190_battery_get_status(struct bq24190_dev_info *bdi,
 933                 union power_supply_propval *val)
 934 {
 935         u8 ss_reg, chrg_fault;
 936         int status, ret;
 937
 938         mutex_lock(&bdi->f_reg_lock);
 939
 940         if (bdi->battery_status_valid) {
 941                 chrg_fault = bdi->f_reg;
 942                 bdi->battery_status_valid = false;
 943                 mutex_unlock(&bdi->f_reg_lock);
 944         } else {
 945                 mutex_unlock(&bdi->f_reg_lock);
 946
 947                 ret = bq24190_read(bdi, BQ24190_REG_F, &chrg_fault);
 948                 if (ret < 0)
 949                         return ret;
 950         }
 951
 952         chrg_fault &= BQ24190_REG_F_CHRG_FAULT_MASK;
 953         chrg_fault >>= BQ24190_REG_F_CHRG_FAULT_SHIFT;
 954
 955         ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
 956         if (ret < 0)
 957                 return ret;
 958
 959         /*
 960          * The battery must be discharging when any of these are true:
 961          * - there is no good power source;
 962          * - there is a charge fault.
 963          * Could also be discharging when in "supplement mode" but
 964          * there is no way to tell when its in that mode.
 965          */
 966         if (!(ss_reg & BQ24190_REG_SS_PG_STAT_MASK) || chrg_fault) {
 967                 status = POWER_SUPPLY_STATUS_DISCHARGING;
 968         } else {
 969                 ss_reg &= BQ24190_REG_SS_CHRG_STAT_MASK;
 970                 ss_reg >>= BQ24190_REG_SS_CHRG_STAT_SHIFT;
 971
 972                 switch (ss_reg) {
 973                 case 0x0: /* Not Charging */
 974                         status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 975                         break;
 976                 case 0x1: /* Pre-charge */
 977                 case 0x2: /* Fast Charging */
 978                         status = POWER_SUPPLY_STATUS_CHARGING;
 979                         break;
 980                 case 0x3: /* Charge Termination Done */
 981                         status = POWER_SUPPLY_STATUS_FULL;
 982                         break;
 983                 default:
 984                         ret = -EIO;
 985                 }
 986         }
 987
 988         if (!ret)
 989                 val->intval = status;
 990
 991         return ret;
 992 }
 993
 994 static int bq24190_battery_get_health(struct bq24190_dev_info *bdi,
 995                 union power_supply_propval *val)
 996 {
 997         u8 v;
 998         int health, ret;
 999
1000         mutex_lock(&bdi->f_reg_lock);
1001
1002         if (bdi->battery_health_valid) {
1003                 v = bdi->f_reg;
1004                 bdi->battery_health_valid = false;
1005                 mutex_unlock(&bdi->f_reg_lock);
1006         } else {
1007                 mutex_unlock(&bdi->f_reg_lock);
1008
1009                 ret = bq24190_read(bdi, BQ24190_REG_F, &v);
1010                 if (ret < 0)
1011                         return ret;
1012         }
1013
1014         if (v & BQ24190_REG_F_BAT_FAULT_MASK) {
1015                 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1016         } else {
1017                 v &= BQ24190_REG_F_NTC_FAULT_MASK;
1018                 v >>= BQ24190_REG_F_NTC_FAULT_SHIFT;
1019
1020                 switch (v) {
1021                 case 0x0: /* Normal */
1022                         health = POWER_SUPPLY_HEALTH_GOOD;
1023                         break;
1024                 case 0x1: /* TS1 Cold */
1025                 case 0x3: /* TS2 Cold */
1026                 case 0x5: /* Both Cold */
1027                         health = POWER_SUPPLY_HEALTH_COLD;
1028                         break;
1029                 case 0x2: /* TS1 Hot */
1030                 case 0x4: /* TS2 Hot */
1031                 case 0x6: /* Both Hot */
1032                         health = POWER_SUPPLY_HEALTH_OVERHEAT;
1033                         break;
1034                 default:
1035                         health = POWER_SUPPLY_HEALTH_UNKNOWN;
1036                 }
1037         }
1038
1039         val->intval = health;
1040         return 0;
1041 }
1042
1043 static int bq24190_battery_get_online(struct bq24190_dev_info *bdi,
1044                 union power_supply_propval *val)
1045 {
1046         u8 batfet_disable;
1047         int ret;
1048
1049         ret = bq24190_read_mask(bdi, BQ24190_REG_MOC,
1050                         BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1051                         BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, &batfet_disable);
1052         if (ret < 0)
1053                 return ret;
1054
1055         val->intval = !batfet_disable;
1056         return 0;
1057 }
1058
1059 static int bq24190_battery_set_online(struct bq24190_dev_info *bdi,
1060                 const union power_supply_propval *val)
1061 {
1062         return bq24190_write_mask(bdi, BQ24190_REG_MOC,
1063                         BQ24190_REG_MOC_BATFET_DISABLE_MASK,
1064                         BQ24190_REG_MOC_BATFET_DISABLE_SHIFT, !val->intval);
1065 }
1066
1067 static int bq24190_battery_get_temp_alert_max(struct bq24190_dev_info *bdi,
1068                 union power_supply_propval *val)
1069 {
1070         int temp, ret;
1071
1072         ret = bq24190_get_field_val(bdi, BQ24190_REG_ICTRC,
1073                         BQ24190_REG_ICTRC_TREG_MASK,
1074                         BQ24190_REG_ICTRC_TREG_SHIFT,
1075                         bq24190_ictrc_treg_values,
1076                         ARRAY_SIZE(bq24190_ictrc_treg_values), &temp);
1077         if (ret < 0)
1078                 return ret;
1079
1080         val->intval = temp;
1081         return 0;
1082 }
1083
1084 static int bq24190_battery_set_temp_alert_max(struct bq24190_dev_info *bdi,
1085                 const union power_supply_propval *val)
1086 {
1087         return bq24190_set_field_val(bdi, BQ24190_REG_ICTRC,
1088                         BQ24190_REG_ICTRC_TREG_MASK,
1089                         BQ24190_REG_ICTRC_TREG_SHIFT,
1090                         bq24190_ictrc_treg_values,
1091                         ARRAY_SIZE(bq24190_ictrc_treg_values), val->intval);
1092 }
1093
1094 static int bq24190_battery_get_property(struct power_supply *psy,
1095                 enum power_supply_property psp, union power_supply_propval *val)
1096 {
1097         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1098         int ret;
1099
1100         dev_dbg(bdi->dev, "prop: %d\n", psp);
1101
1102         pm_runtime_get_sync(bdi->dev);
1103
1104         switch (psp) {
1105         case POWER_SUPPLY_PROP_STATUS:
1106                 ret = bq24190_battery_get_status(bdi, val);
1107                 break;
1108         case POWER_SUPPLY_PROP_HEALTH:
1109                 ret = bq24190_battery_get_health(bdi, val);
1110                 break;
1111         case POWER_SUPPLY_PROP_ONLINE:
1112                 ret = bq24190_battery_get_online(bdi, val);
1113                 break;
1114         case POWER_SUPPLY_PROP_TECHNOLOGY:
1115                 /* Could be Li-on or Li-polymer but no way to tell which */
1116                 val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
1117                 ret = 0;
1118                 break;
1119         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1120                 ret = bq24190_battery_get_temp_alert_max(bdi, val);
1121                 break;
1122         case POWER_SUPPLY_PROP_SCOPE:
1123                 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
1124                 ret = 0;
1125                 break;
1126         default:
1127                 ret = -ENODATA;
1128         }
1129
1130         pm_runtime_put_sync(bdi->dev);
1131         return ret;
1132 }
1133
1134 static int bq24190_battery_set_property(struct power_supply *psy,
1135                 enum power_supply_property psp,
1136                 const union power_supply_propval *val)
1137 {
1138         struct bq24190_dev_info *bdi = power_supply_get_drvdata(psy);
1139         int ret;
1140
1141         dev_dbg(bdi->dev, "prop: %d\n", psp);
1142
1143         pm_runtime_get_sync(bdi->dev);
1144
1145         switch (psp) {
1146         case POWER_SUPPLY_PROP_ONLINE:
1147                 ret = bq24190_battery_set_online(bdi, val);
1148                 break;
1149         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1150                 ret = bq24190_battery_set_temp_alert_max(bdi, val);
1151                 break;
1152         default:
1153                 ret = -EINVAL;
1154         }
1155
1156         pm_runtime_put_sync(bdi->dev);
1157         return ret;
1158 }
1159
1160 static int bq24190_battery_property_is_writeable(struct power_supply *psy,
1161                 enum power_supply_property psp)
1162 {
1163         int ret;
1164
1165         switch (psp) {
1166         case POWER_SUPPLY_PROP_ONLINE:
1167         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
1168                 ret = 1;
1169                 break;
1170         default:
1171                 ret = 0;
1172         }
1173
1174         return ret;
1175 }
1176
1177 static enum power_supply_property bq24190_battery_properties[] = {
1178         POWER_SUPPLY_PROP_STATUS,
1179         POWER_SUPPLY_PROP_HEALTH,
1180         POWER_SUPPLY_PROP_ONLINE,
1181         POWER_SUPPLY_PROP_TECHNOLOGY,
1182         POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
1183         POWER_SUPPLY_PROP_SCOPE,
1184 };
1185
1186 static const struct power_supply_desc bq24190_battery_desc = {
1187         .name                   = "bq24190-battery",
1188         .type                   = POWER_SUPPLY_TYPE_BATTERY,
1189         .properties             = bq24190_battery_properties,
1190         .num_properties         = ARRAY_SIZE(bq24190_battery_properties),
1191         .get_property           = bq24190_battery_get_property,
1192         .set_property           = bq24190_battery_set_property,
1193         .property_is_writeable  = bq24190_battery_property_is_writeable,
1194 };
1195
1196 static irqreturn_t bq24190_irq_handler_thread(int irq, void *data)
1197 {
1198         struct bq24190_dev_info *bdi = data;
1199         const u8 battery_mask_ss = BQ24190_REG_SS_CHRG_STAT_MASK;
1200         const u8 battery_mask_f = BQ24190_REG_F_BAT_FAULT_MASK
1201                                 | BQ24190_REG_F_NTC_FAULT_MASK;
1202         bool alert_charger = false, alert_battery = false;
1203         u8 ss_reg = 0, f_reg = 0;
1204         int ret;
1205
1206         pm_runtime_get_sync(bdi->dev);
1207
1208         ret = bq24190_read(bdi, BQ24190_REG_SS, &ss_reg);
1209         if (ret < 0) {
1210                 dev_err(bdi->dev, "Can't read SS reg: %d\n", ret);
1211                 goto out;
1212         }
1213
1214         if (ss_reg != bdi->ss_reg) {
1215                 /*
1216                  * The device is in host mode so when PG_STAT goes from 1->0
1217                  * (i.e., power removed) HIZ needs to be disabled.
1218                  */
1219                 if ((bdi->ss_reg & BQ24190_REG_SS_PG_STAT_MASK) &&
1220                                 !(ss_reg & BQ24190_REG_SS_PG_STAT_MASK)) {
1221                         ret = bq24190_write_mask(bdi, BQ24190_REG_ISC,
1222                                         BQ24190_REG_ISC_EN_HIZ_MASK,
1223                                         BQ24190_REG_ISC_EN_HIZ_SHIFT,
1224                                         0);
1225                         if (ret < 0)
1226                                 dev_err(bdi->dev, "Can't access ISC reg: %d\n",
1227                                         ret);
1228                 }
1229
1230                 if ((bdi->ss_reg & battery_mask_ss) != (ss_reg & battery_mask_ss))
1231                         alert_battery = true;
1232                 if ((bdi->ss_reg & ~battery_mask_ss) != (ss_reg & ~battery_mask_ss))
1233                         alert_charger = true;
1234
1235                 bdi->ss_reg = ss_reg;
1236         }
1237
1238         mutex_lock(&bdi->f_reg_lock);
1239
1240         ret = bq24190_read(bdi, BQ24190_REG_F, &f_reg);
1241         if (ret < 0) {
1242                 mutex_unlock(&bdi->f_reg_lock);
1243                 dev_err(bdi->dev, "Can't read F reg: %d\n", ret);
1244                 goto out;
1245         }
1246
1247         if (f_reg != bdi->f_reg) {
1248                 if ((bdi->f_reg & battery_mask_f) != (f_reg & battery_mask_f))
1249                         alert_battery = true;
1250                 if ((bdi->f_reg & ~battery_mask_f) != (f_reg & ~battery_mask_f))
1251                         alert_charger = true;
1252
1253                 bdi->f_reg = f_reg;
1254                 bdi->charger_health_valid = true;
1255                 bdi->battery_health_valid = true;
1256                 bdi->battery_status_valid = true;
1257         }
1258
1259         mutex_unlock(&bdi->f_reg_lock);
1260
1261         if (alert_charger)
1262                 power_supply_changed(bdi->charger);
1263         if (alert_battery)
1264                 power_supply_changed(bdi->battery);
1265
1266 out:
1267         pm_runtime_put_sync(bdi->dev);
1268
1269         dev_dbg(bdi->dev, "ss_reg: 0x%02x, f_reg: 0x%02x\n", ss_reg, f_reg);
1270
1271         return IRQ_HANDLED;
1272 }
1273
1274 static int bq24190_hw_init(struct bq24190_dev_info *bdi)
1275 {
1276         u8 v;
1277         int ret;
1278
1279         pm_runtime_get_sync(bdi->dev);
1280
1281         /* First check that the device really is what its supposed to be */
1282         ret = bq24190_read_mask(bdi, BQ24190_REG_VPRS,
1283                         BQ24190_REG_VPRS_PN_MASK,
1284                         BQ24190_REG_VPRS_PN_SHIFT,
1285                         &v);
1286         if (ret < 0)
1287                 goto out;
1288
1289         if (v != bdi->model) {
1290                 ret = -ENODEV;
1291                 goto out;
1292         }
1293
1294         ret = bq24190_register_reset(bdi);
1295         if (ret < 0)
1296                 goto out;
1297
1298         ret = bq24190_set_mode_host(bdi);
1299         if (ret < 0)
1300                 goto out;
1301
1302         ret = bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1303 out:
1304         pm_runtime_put_sync(bdi->dev);
1305         return ret;
1306 }
1307
1308 #ifdef CONFIG_OF
1309 static int bq24190_setup_dt(struct bq24190_dev_info *bdi)
1310 {
1311         bdi->irq = irq_of_parse_and_map(bdi->dev->of_node, 0);
1312         if (bdi->irq <= 0)
1313                 return -1;
1314
1315         return 0;
1316 }
1317 #else
1318 static int bq24190_setup_dt(struct bq24190_dev_info *bdi)
1319 {
1320         return -1;
1321 }
1322 #endif
1323
1324 static int bq24190_setup_pdata(struct bq24190_dev_info *bdi,
1325                 struct bq24190_platform_data *pdata)
1326 {
1327         int ret;
1328
1329         if (!gpio_is_valid(pdata->gpio_int))
1330                 return -1;
1331
1332         ret = gpio_request(pdata->gpio_int, dev_name(bdi->dev));
1333         if (ret < 0)
1334                 return -1;
1335
1336         ret = gpio_direction_input(pdata->gpio_int);
1337         if (ret < 0)
1338                 goto out;
1339
1340         bdi->irq = gpio_to_irq(pdata->gpio_int);
1341         if (!bdi->irq)
1342                 goto out;
1343
1344         bdi->gpio_int = pdata->gpio_int;
1345         return 0;
1346
1347 out:
1348         gpio_free(pdata->gpio_int);
1349         return -1;
1350 }
1351
1352 static int bq24190_probe(struct i2c_client *client,
1353                 const struct i2c_device_id *id)
1354 {
1355         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
1356         struct device *dev = &client->dev;
1357         struct bq24190_platform_data *pdata = client->dev.platform_data;
1358         struct power_supply_config charger_cfg = {}, battery_cfg = {};
1359         struct bq24190_dev_info *bdi;
1360         int ret;
1361
1362         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1363                 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1364                 return -ENODEV;
1365         }
1366
1367         bdi = devm_kzalloc(dev, sizeof(*bdi), GFP_KERNEL);
1368         if (!bdi) {
1369                 dev_err(dev, "Can't alloc bdi struct\n");
1370                 return -ENOMEM;
1371         }
1372
1373         bdi->client = client;
1374         bdi->dev = dev;
1375         bdi->model = id->driver_data;
1376         strncpy(bdi->model_name, id->name, I2C_NAME_SIZE);
1377         mutex_init(&bdi->f_reg_lock);
1378         bdi->f_reg = 0;
1379         bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1380         bdi->charger_health_valid = false;
1381         bdi->battery_health_valid = false;
1382         bdi->battery_status_valid = false;
1383
1384         i2c_set_clientdata(client, bdi);
1385
1386         if (dev->of_node)
1387                 ret = bq24190_setup_dt(bdi);
1388         else
1389                 ret = bq24190_setup_pdata(bdi, pdata);
1390
1391         if (ret) {
1392                 dev_err(dev, "Can't get irq info\n");
1393                 return -EINVAL;
1394         }
1395
1396         pm_runtime_enable(dev);
1397         pm_runtime_resume(dev);
1398
1399         ret = bq24190_hw_init(bdi);
1400         if (ret < 0) {
1401                 dev_err(dev, "Hardware init failed\n");
1402                 goto out1;
1403         }
1404
1405         charger_cfg.drv_data = bdi;
1406         charger_cfg.supplied_to = bq24190_charger_supplied_to;
1407         charger_cfg.num_supplicants = ARRAY_SIZE(bq24190_charger_supplied_to),
1408         bdi->charger = power_supply_register(dev, &bq24190_charger_desc,
1409                                                 &charger_cfg);
1410         if (IS_ERR(bdi->charger)) {
1411                 dev_err(dev, "Can't register charger\n");
1412                 ret = PTR_ERR(bdi->charger);
1413                 goto out1;
1414         }
1415
1416         battery_cfg.drv_data = bdi;
1417         bdi->battery = power_supply_register(dev, &bq24190_battery_desc,
1418                                                 &battery_cfg);
1419         if (IS_ERR(bdi->battery)) {
1420                 dev_err(dev, "Can't register battery\n");
1421                 ret = PTR_ERR(bdi->battery);
1422                 goto out2;
1423         }
1424
1425         ret = bq24190_sysfs_create_group(bdi);
1426         if (ret) {
1427                 dev_err(dev, "Can't create sysfs entries\n");
1428                 goto out3;
1429         }
1430
1431         ret = devm_request_threaded_irq(dev, bdi->irq, NULL,
1432                         bq24190_irq_handler_thread,
1433                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1434                         "bq24190-charger", bdi);
1435         if (ret < 0) {
1436                 dev_err(dev, "Can't set up irq handler\n");
1437                 goto out4;
1438         }
1439
1440         return 0;
1441
1442 out4:
1443         bq24190_sysfs_remove_group(bdi);
1444 out3:
1445         power_supply_unregister(bdi->battery);
1446 out2:
1447         power_supply_unregister(bdi->charger);
1448 out1:
1449         pm_runtime_disable(dev);
1450         if (bdi->gpio_int)
1451                 gpio_free(bdi->gpio_int);
1452
1453         return ret;
1454 }
1455
1456 static int bq24190_remove(struct i2c_client *client)
1457 {
1458         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1459
1460         pm_runtime_get_sync(bdi->dev);
1461         bq24190_register_reset(bdi);
1462         pm_runtime_put_sync(bdi->dev);
1463
1464         bq24190_sysfs_remove_group(bdi);
1465         power_supply_unregister(bdi->battery);
1466         power_supply_unregister(bdi->charger);
1467         pm_runtime_disable(bdi->dev);
1468
1469         if (bdi->gpio_int)
1470                 gpio_free(bdi->gpio_int);
1471
1472         return 0;
1473 }
1474
1475 #ifdef CONFIG_PM_SLEEP
1476 static int bq24190_pm_suspend(struct device *dev)
1477 {
1478         struct i2c_client *client = to_i2c_client(dev);
1479         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1480
1481         pm_runtime_get_sync(bdi->dev);
1482         bq24190_register_reset(bdi);
1483         pm_runtime_put_sync(bdi->dev);
1484
1485         return 0;
1486 }
1487
1488 static int bq24190_pm_resume(struct device *dev)
1489 {
1490         struct i2c_client *client = to_i2c_client(dev);
1491         struct bq24190_dev_info *bdi = i2c_get_clientdata(client);
1492
1493         bdi->f_reg = 0;
1494         bdi->ss_reg = BQ24190_REG_SS_VBUS_STAT_MASK; /* impossible state */
1495         bdi->charger_health_valid = false;
1496         bdi->battery_health_valid = false;
1497         bdi->battery_status_valid = false;
1498
1499         pm_runtime_get_sync(bdi->dev);
1500         bq24190_register_reset(bdi);
1501         bq24190_set_mode_host(bdi);
1502         bq24190_read(bdi, BQ24190_REG_SS, &bdi->ss_reg);
1503         pm_runtime_put_sync(bdi->dev);
1504
1505         /* Things may have changed while suspended so alert upper layer */
1506         power_supply_changed(bdi->charger);
1507         power_supply_changed(bdi->battery);
1508
1509         return 0;
1510 }
1511 #endif
1512
1513 static SIMPLE_DEV_PM_OPS(bq24190_pm_ops, bq24190_pm_suspend, bq24190_pm_resume);
1514
1515 /*
1516  * Only support the bq24190 right now.  The bq24192, bq24192i, and bq24193
1517  * are similar but not identical so the driver needs to be extended to
1518  * support them.
1519  */
1520 static const struct i2c_device_id bq24190_i2c_ids[] = {
1521         { "bq24190", BQ24190_REG_VPRS_PN_24190 },
1522         { },
1523 };
1524 MODULE_DEVICE_TABLE(i2c, bq24190_i2c_ids);
1525
1526 #ifdef CONFIG_OF
1527 static const struct of_device_id bq24190_of_match[] = {
1528         { .compatible = "ti,bq24190", },
1529         { },
1530 };
1531 MODULE_DEVICE_TABLE(of, bq24190_of_match);
1532 #else
1533 static const struct of_device_id bq24190_of_match[] = {
1534         { },
1535 };
1536 #endif
1537
1538 static struct i2c_driver bq24190_driver = {
1539         .probe          = bq24190_probe,
1540         .remove         = bq24190_remove,
1541         .id_table       = bq24190_i2c_ids,
1542         .driver = {
1543                 .name           = "bq24190-charger",
1544                 .pm             = &bq24190_pm_ops,
1545                 .of_match_table = of_match_ptr(bq24190_of_match),
1546         },
1547 };
1548 module_i2c_driver(bq24190_driver);
1549
1550 MODULE_LICENSE("GPL");
1551 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
1552 MODULE_DESCRIPTION("TI BQ24190 Charger Driver");