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