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