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