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