1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * TI BQ25890 charger driver 4 * 5 * Copyright (C) 2015 Intel Corporation 6 */ 7 8 #include <linux/module.h> 9 #include <linux/i2c.h> 10 #include <linux/power_supply.h> 11 #include <linux/power/bq25890_charger.h> 12 #include <linux/regmap.h> 13 #include <linux/regulator/driver.h> 14 #include <linux/types.h> 15 #include <linux/gpio/consumer.h> 16 #include <linux/interrupt.h> 17 #include <linux/delay.h> 18 #include <linux/usb/phy.h> 19 20 #include <linux/acpi.h> 21 #include <linux/of.h> 22 23 #define BQ25890_MANUFACTURER "Texas Instruments" 24 #define BQ25890_IRQ_PIN "bq25890_irq" 25 26 #define BQ25890_ID 3 27 #define BQ25895_ID 7 28 #define BQ25896_ID 0 29 30 #define PUMP_EXPRESS_START_DELAY (5 * HZ) 31 #define PUMP_EXPRESS_MAX_TRIES 6 32 #define PUMP_EXPRESS_VBUS_MARGIN_uV 1000000 33 34 enum bq25890_chip_version { 35 BQ25890, 36 BQ25892, 37 BQ25895, 38 BQ25896, 39 }; 40 41 static const char *const bq25890_chip_name[] = { 42 "BQ25890", 43 "BQ25892", 44 "BQ25895", 45 "BQ25896", 46 }; 47 48 enum bq25890_fields { 49 F_EN_HIZ, F_EN_ILIM, F_IINLIM, /* Reg00 */ 50 F_BHOT, F_BCOLD, F_VINDPM_OFS, /* Reg01 */ 51 F_CONV_START, F_CONV_RATE, F_BOOSTF, F_ICO_EN, 52 F_HVDCP_EN, F_MAXC_EN, F_FORCE_DPM, F_AUTO_DPDM_EN, /* Reg02 */ 53 F_BAT_LOAD_EN, F_WD_RST, F_OTG_CFG, F_CHG_CFG, F_SYSVMIN, 54 F_MIN_VBAT_SEL, /* Reg03 */ 55 F_PUMPX_EN, F_ICHG, /* Reg04 */ 56 F_IPRECHG, F_ITERM, /* Reg05 */ 57 F_VREG, F_BATLOWV, F_VRECHG, /* Reg06 */ 58 F_TERM_EN, F_STAT_DIS, F_WD, F_TMR_EN, F_CHG_TMR, 59 F_JEITA_ISET, /* Reg07 */ 60 F_BATCMP, F_VCLAMP, F_TREG, /* Reg08 */ 61 F_FORCE_ICO, F_TMR2X_EN, F_BATFET_DIS, F_JEITA_VSET, 62 F_BATFET_DLY, F_BATFET_RST_EN, F_PUMPX_UP, F_PUMPX_DN, /* Reg09 */ 63 F_BOOSTV, F_PFM_OTG_DIS, F_BOOSTI, /* Reg0A */ 64 F_VBUS_STAT, F_CHG_STAT, F_PG_STAT, F_SDP_STAT, F_0B_RSVD, 65 F_VSYS_STAT, /* Reg0B */ 66 F_WD_FAULT, F_BOOST_FAULT, F_CHG_FAULT, F_BAT_FAULT, 67 F_NTC_FAULT, /* Reg0C */ 68 F_FORCE_VINDPM, F_VINDPM, /* Reg0D */ 69 F_THERM_STAT, F_BATV, /* Reg0E */ 70 F_SYSV, /* Reg0F */ 71 F_TSPCT, /* Reg10 */ 72 F_VBUS_GD, F_VBUSV, /* Reg11 */ 73 F_ICHGR, /* Reg12 */ 74 F_VDPM_STAT, F_IDPM_STAT, F_IDPM_LIM, /* Reg13 */ 75 F_REG_RST, F_ICO_OPTIMIZED, F_PN, F_TS_PROFILE, F_DEV_REV, /* Reg14 */ 76 77 F_MAX_FIELDS 78 }; 79 80 /* initial field values, converted to register values */ 81 struct bq25890_init_data { 82 u8 ichg; /* charge current */ 83 u8 vreg; /* regulation voltage */ 84 u8 iterm; /* termination current */ 85 u8 iprechg; /* precharge current */ 86 u8 sysvmin; /* minimum system voltage limit */ 87 u8 boostv; /* boost regulation voltage */ 88 u8 boosti; /* boost current limit */ 89 u8 boostf; /* boost frequency */ 90 u8 ilim_en; /* enable ILIM pin */ 91 u8 treg; /* thermal regulation threshold */ 92 u8 rbatcomp; /* IBAT sense resistor value */ 93 u8 vclamp; /* IBAT compensation voltage limit */ 94 }; 95 96 struct bq25890_state { 97 u8 online; 98 u8 hiz; 99 u8 chrg_status; 100 u8 chrg_fault; 101 u8 vsys_status; 102 u8 boost_fault; 103 u8 bat_fault; 104 u8 ntc_fault; 105 }; 106 107 struct bq25890_device { 108 struct i2c_client *client; 109 struct device *dev; 110 struct power_supply *charger; 111 struct power_supply *secondary_chrg; 112 struct power_supply_desc desc; 113 char name[28]; /* "bq25890-charger-%d" */ 114 int id; 115 116 struct usb_phy *usb_phy; 117 struct notifier_block usb_nb; 118 struct work_struct usb_work; 119 struct delayed_work pump_express_work; 120 unsigned long usb_event; 121 122 struct regmap *rmap; 123 struct regmap_field *rmap_fields[F_MAX_FIELDS]; 124 125 bool skip_reset; 126 bool read_back_init_data; 127 bool force_hiz; 128 u32 pump_express_vbus_max; 129 u32 iinlim_percentage; 130 enum bq25890_chip_version chip_version; 131 struct bq25890_init_data init_data; 132 struct bq25890_state state; 133 134 struct mutex lock; /* protect state data */ 135 }; 136 137 static DEFINE_IDR(bq25890_id); 138 static DEFINE_MUTEX(bq25890_id_mutex); 139 140 static const struct regmap_range bq25890_readonly_reg_ranges[] = { 141 regmap_reg_range(0x0b, 0x0c), 142 regmap_reg_range(0x0e, 0x13), 143 }; 144 145 static const struct regmap_access_table bq25890_writeable_regs = { 146 .no_ranges = bq25890_readonly_reg_ranges, 147 .n_no_ranges = ARRAY_SIZE(bq25890_readonly_reg_ranges), 148 }; 149 150 static const struct regmap_range bq25890_volatile_reg_ranges[] = { 151 regmap_reg_range(0x00, 0x00), 152 regmap_reg_range(0x02, 0x02), 153 regmap_reg_range(0x09, 0x09), 154 regmap_reg_range(0x0b, 0x14), 155 }; 156 157 static const struct regmap_access_table bq25890_volatile_regs = { 158 .yes_ranges = bq25890_volatile_reg_ranges, 159 .n_yes_ranges = ARRAY_SIZE(bq25890_volatile_reg_ranges), 160 }; 161 162 static const struct regmap_config bq25890_regmap_config = { 163 .reg_bits = 8, 164 .val_bits = 8, 165 166 .max_register = 0x14, 167 .cache_type = REGCACHE_RBTREE, 168 169 .wr_table = &bq25890_writeable_regs, 170 .volatile_table = &bq25890_volatile_regs, 171 }; 172 173 static const struct reg_field bq25890_reg_fields[] = { 174 /* REG00 */ 175 [F_EN_HIZ] = REG_FIELD(0x00, 7, 7), 176 [F_EN_ILIM] = REG_FIELD(0x00, 6, 6), 177 [F_IINLIM] = REG_FIELD(0x00, 0, 5), 178 /* REG01 */ 179 [F_BHOT] = REG_FIELD(0x01, 6, 7), 180 [F_BCOLD] = REG_FIELD(0x01, 5, 5), 181 [F_VINDPM_OFS] = REG_FIELD(0x01, 0, 4), 182 /* REG02 */ 183 [F_CONV_START] = REG_FIELD(0x02, 7, 7), 184 [F_CONV_RATE] = REG_FIELD(0x02, 6, 6), 185 [F_BOOSTF] = REG_FIELD(0x02, 5, 5), 186 [F_ICO_EN] = REG_FIELD(0x02, 4, 4), 187 [F_HVDCP_EN] = REG_FIELD(0x02, 3, 3), // reserved on BQ25896 188 [F_MAXC_EN] = REG_FIELD(0x02, 2, 2), // reserved on BQ25896 189 [F_FORCE_DPM] = REG_FIELD(0x02, 1, 1), 190 [F_AUTO_DPDM_EN] = REG_FIELD(0x02, 0, 0), 191 /* REG03 */ 192 [F_BAT_LOAD_EN] = REG_FIELD(0x03, 7, 7), 193 [F_WD_RST] = REG_FIELD(0x03, 6, 6), 194 [F_OTG_CFG] = REG_FIELD(0x03, 5, 5), 195 [F_CHG_CFG] = REG_FIELD(0x03, 4, 4), 196 [F_SYSVMIN] = REG_FIELD(0x03, 1, 3), 197 [F_MIN_VBAT_SEL] = REG_FIELD(0x03, 0, 0), // BQ25896 only 198 /* REG04 */ 199 [F_PUMPX_EN] = REG_FIELD(0x04, 7, 7), 200 [F_ICHG] = REG_FIELD(0x04, 0, 6), 201 /* REG05 */ 202 [F_IPRECHG] = REG_FIELD(0x05, 4, 7), 203 [F_ITERM] = REG_FIELD(0x05, 0, 3), 204 /* REG06 */ 205 [F_VREG] = REG_FIELD(0x06, 2, 7), 206 [F_BATLOWV] = REG_FIELD(0x06, 1, 1), 207 [F_VRECHG] = REG_FIELD(0x06, 0, 0), 208 /* REG07 */ 209 [F_TERM_EN] = REG_FIELD(0x07, 7, 7), 210 [F_STAT_DIS] = REG_FIELD(0x07, 6, 6), 211 [F_WD] = REG_FIELD(0x07, 4, 5), 212 [F_TMR_EN] = REG_FIELD(0x07, 3, 3), 213 [F_CHG_TMR] = REG_FIELD(0x07, 1, 2), 214 [F_JEITA_ISET] = REG_FIELD(0x07, 0, 0), // reserved on BQ25895 215 /* REG08 */ 216 [F_BATCMP] = REG_FIELD(0x08, 5, 7), 217 [F_VCLAMP] = REG_FIELD(0x08, 2, 4), 218 [F_TREG] = REG_FIELD(0x08, 0, 1), 219 /* REG09 */ 220 [F_FORCE_ICO] = REG_FIELD(0x09, 7, 7), 221 [F_TMR2X_EN] = REG_FIELD(0x09, 6, 6), 222 [F_BATFET_DIS] = REG_FIELD(0x09, 5, 5), 223 [F_JEITA_VSET] = REG_FIELD(0x09, 4, 4), // reserved on BQ25895 224 [F_BATFET_DLY] = REG_FIELD(0x09, 3, 3), 225 [F_BATFET_RST_EN] = REG_FIELD(0x09, 2, 2), 226 [F_PUMPX_UP] = REG_FIELD(0x09, 1, 1), 227 [F_PUMPX_DN] = REG_FIELD(0x09, 0, 0), 228 /* REG0A */ 229 [F_BOOSTV] = REG_FIELD(0x0A, 4, 7), 230 [F_BOOSTI] = REG_FIELD(0x0A, 0, 2), // reserved on BQ25895 231 [F_PFM_OTG_DIS] = REG_FIELD(0x0A, 3, 3), // BQ25896 only 232 /* REG0B */ 233 [F_VBUS_STAT] = REG_FIELD(0x0B, 5, 7), 234 [F_CHG_STAT] = REG_FIELD(0x0B, 3, 4), 235 [F_PG_STAT] = REG_FIELD(0x0B, 2, 2), 236 [F_SDP_STAT] = REG_FIELD(0x0B, 1, 1), // reserved on BQ25896 237 [F_VSYS_STAT] = REG_FIELD(0x0B, 0, 0), 238 /* REG0C */ 239 [F_WD_FAULT] = REG_FIELD(0x0C, 7, 7), 240 [F_BOOST_FAULT] = REG_FIELD(0x0C, 6, 6), 241 [F_CHG_FAULT] = REG_FIELD(0x0C, 4, 5), 242 [F_BAT_FAULT] = REG_FIELD(0x0C, 3, 3), 243 [F_NTC_FAULT] = REG_FIELD(0x0C, 0, 2), 244 /* REG0D */ 245 [F_FORCE_VINDPM] = REG_FIELD(0x0D, 7, 7), 246 [F_VINDPM] = REG_FIELD(0x0D, 0, 6), 247 /* REG0E */ 248 [F_THERM_STAT] = REG_FIELD(0x0E, 7, 7), 249 [F_BATV] = REG_FIELD(0x0E, 0, 6), 250 /* REG0F */ 251 [F_SYSV] = REG_FIELD(0x0F, 0, 6), 252 /* REG10 */ 253 [F_TSPCT] = REG_FIELD(0x10, 0, 6), 254 /* REG11 */ 255 [F_VBUS_GD] = REG_FIELD(0x11, 7, 7), 256 [F_VBUSV] = REG_FIELD(0x11, 0, 6), 257 /* REG12 */ 258 [F_ICHGR] = REG_FIELD(0x12, 0, 6), 259 /* REG13 */ 260 [F_VDPM_STAT] = REG_FIELD(0x13, 7, 7), 261 [F_IDPM_STAT] = REG_FIELD(0x13, 6, 6), 262 [F_IDPM_LIM] = REG_FIELD(0x13, 0, 5), 263 /* REG14 */ 264 [F_REG_RST] = REG_FIELD(0x14, 7, 7), 265 [F_ICO_OPTIMIZED] = REG_FIELD(0x14, 6, 6), 266 [F_PN] = REG_FIELD(0x14, 3, 5), 267 [F_TS_PROFILE] = REG_FIELD(0x14, 2, 2), 268 [F_DEV_REV] = REG_FIELD(0x14, 0, 1) 269 }; 270 271 /* 272 * Most of the val -> idx conversions can be computed, given the minimum, 273 * maximum and the step between values. For the rest of conversions, we use 274 * lookup tables. 275 */ 276 enum bq25890_table_ids { 277 /* range tables */ 278 TBL_ICHG, 279 TBL_ITERM, 280 TBL_IINLIM, 281 TBL_VREG, 282 TBL_BOOSTV, 283 TBL_SYSVMIN, 284 TBL_VBUSV, 285 TBL_VBATCOMP, 286 TBL_RBATCOMP, 287 288 /* lookup tables */ 289 TBL_TREG, 290 TBL_BOOSTI, 291 TBL_TSPCT, 292 }; 293 294 /* Thermal Regulation Threshold lookup table, in degrees Celsius */ 295 static const u32 bq25890_treg_tbl[] = { 60, 80, 100, 120 }; 296 297 #define BQ25890_TREG_TBL_SIZE ARRAY_SIZE(bq25890_treg_tbl) 298 299 /* Boost mode current limit lookup table, in uA */ 300 static const u32 bq25890_boosti_tbl[] = { 301 500000, 700000, 1100000, 1300000, 1600000, 1800000, 2100000, 2400000 302 }; 303 304 #define BQ25890_BOOSTI_TBL_SIZE ARRAY_SIZE(bq25890_boosti_tbl) 305 306 /* NTC 10K temperature lookup table in tenths of a degree */ 307 static const u32 bq25890_tspct_tbl[] = { 308 850, 840, 830, 820, 810, 800, 790, 780, 309 770, 760, 750, 740, 730, 720, 710, 700, 310 690, 685, 680, 675, 670, 660, 650, 645, 311 640, 630, 620, 615, 610, 600, 590, 585, 312 580, 570, 565, 560, 550, 540, 535, 530, 313 520, 515, 510, 500, 495, 490, 480, 475, 314 470, 460, 455, 450, 440, 435, 430, 425, 315 420, 410, 405, 400, 390, 385, 380, 370, 316 365, 360, 355, 350, 340, 335, 330, 320, 317 310, 305, 300, 290, 285, 280, 275, 270, 318 260, 250, 245, 240, 230, 225, 220, 210, 319 205, 200, 190, 180, 175, 170, 160, 150, 320 145, 140, 130, 120, 115, 110, 100, 90, 321 80, 70, 60, 50, 40, 30, 20, 10, 322 0, -10, -20, -30, -40, -60, -70, -80, 323 -90, -10, -120, -140, -150, -170, -190, -210, 324 }; 325 326 #define BQ25890_TSPCT_TBL_SIZE ARRAY_SIZE(bq25890_tspct_tbl) 327 328 struct bq25890_range { 329 u32 min; 330 u32 max; 331 u32 step; 332 }; 333 334 struct bq25890_lookup { 335 const u32 *tbl; 336 u32 size; 337 }; 338 339 static const union { 340 struct bq25890_range rt; 341 struct bq25890_lookup lt; 342 } bq25890_tables[] = { 343 /* range tables */ 344 /* TODO: BQ25896 has max ICHG 3008 mA */ 345 [TBL_ICHG] = { .rt = {0, 5056000, 64000} }, /* uA */ 346 [TBL_ITERM] = { .rt = {64000, 1024000, 64000} }, /* uA */ 347 [TBL_IINLIM] = { .rt = {100000, 3250000, 50000} }, /* uA */ 348 [TBL_VREG] = { .rt = {3840000, 4608000, 16000} }, /* uV */ 349 [TBL_BOOSTV] = { .rt = {4550000, 5510000, 64000} }, /* uV */ 350 [TBL_SYSVMIN] = { .rt = {3000000, 3700000, 100000} }, /* uV */ 351 [TBL_VBUSV] = { .rt = {2600000, 15300000, 100000} }, /* uV */ 352 [TBL_VBATCOMP] = { .rt = {0, 224000, 32000} }, /* uV */ 353 [TBL_RBATCOMP] = { .rt = {0, 140000, 20000} }, /* uOhm */ 354 355 /* lookup tables */ 356 [TBL_TREG] = { .lt = {bq25890_treg_tbl, BQ25890_TREG_TBL_SIZE} }, 357 [TBL_BOOSTI] = { .lt = {bq25890_boosti_tbl, BQ25890_BOOSTI_TBL_SIZE} }, 358 [TBL_TSPCT] = { .lt = {bq25890_tspct_tbl, BQ25890_TSPCT_TBL_SIZE} } 359 }; 360 361 static int bq25890_field_read(struct bq25890_device *bq, 362 enum bq25890_fields field_id) 363 { 364 int ret; 365 int val; 366 367 ret = regmap_field_read(bq->rmap_fields[field_id], &val); 368 if (ret < 0) 369 return ret; 370 371 return val; 372 } 373 374 static int bq25890_field_write(struct bq25890_device *bq, 375 enum bq25890_fields field_id, u8 val) 376 { 377 return regmap_field_write(bq->rmap_fields[field_id], val); 378 } 379 380 static u8 bq25890_find_idx(u32 value, enum bq25890_table_ids id) 381 { 382 u8 idx; 383 384 if (id >= TBL_TREG) { 385 const u32 *tbl = bq25890_tables[id].lt.tbl; 386 u32 tbl_size = bq25890_tables[id].lt.size; 387 388 for (idx = 1; idx < tbl_size && tbl[idx] <= value; idx++) 389 ; 390 } else { 391 const struct bq25890_range *rtbl = &bq25890_tables[id].rt; 392 u8 rtbl_size; 393 394 rtbl_size = (rtbl->max - rtbl->min) / rtbl->step + 1; 395 396 for (idx = 1; 397 idx < rtbl_size && (idx * rtbl->step + rtbl->min <= value); 398 idx++) 399 ; 400 } 401 402 return idx - 1; 403 } 404 405 static u32 bq25890_find_val(u8 idx, enum bq25890_table_ids id) 406 { 407 const struct bq25890_range *rtbl; 408 409 /* lookup table? */ 410 if (id >= TBL_TREG) 411 return bq25890_tables[id].lt.tbl[idx]; 412 413 /* range table */ 414 rtbl = &bq25890_tables[id].rt; 415 416 return (rtbl->min + idx * rtbl->step); 417 } 418 419 enum bq25890_status { 420 STATUS_NOT_CHARGING, 421 STATUS_PRE_CHARGING, 422 STATUS_FAST_CHARGING, 423 STATUS_TERMINATION_DONE, 424 }; 425 426 enum bq25890_chrg_fault { 427 CHRG_FAULT_NORMAL, 428 CHRG_FAULT_INPUT, 429 CHRG_FAULT_THERMAL_SHUTDOWN, 430 CHRG_FAULT_TIMER_EXPIRED, 431 }; 432 433 enum bq25890_ntc_fault { 434 NTC_FAULT_NORMAL = 0, 435 NTC_FAULT_WARM = 2, 436 NTC_FAULT_COOL = 3, 437 NTC_FAULT_COLD = 5, 438 NTC_FAULT_HOT = 6, 439 }; 440 441 static bool bq25890_is_adc_property(enum power_supply_property psp) 442 { 443 switch (psp) { 444 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 445 case POWER_SUPPLY_PROP_CURRENT_NOW: 446 case POWER_SUPPLY_PROP_TEMP: 447 return true; 448 449 default: 450 return false; 451 } 452 } 453 454 static irqreturn_t __bq25890_handle_irq(struct bq25890_device *bq); 455 456 static int bq25890_get_vbus_voltage(struct bq25890_device *bq) 457 { 458 int ret; 459 460 ret = bq25890_field_read(bq, F_VBUSV); 461 if (ret < 0) 462 return ret; 463 464 return bq25890_find_val(ret, TBL_VBUSV); 465 } 466 467 static void bq25890_update_state(struct bq25890_device *bq, 468 enum power_supply_property psp, 469 struct bq25890_state *state) 470 { 471 bool do_adc_conv; 472 int ret; 473 474 mutex_lock(&bq->lock); 475 /* update state in case we lost an interrupt */ 476 __bq25890_handle_irq(bq); 477 *state = bq->state; 478 do_adc_conv = (!state->online || state->hiz) && bq25890_is_adc_property(psp); 479 if (do_adc_conv) 480 bq25890_field_write(bq, F_CONV_START, 1); 481 mutex_unlock(&bq->lock); 482 483 if (do_adc_conv) 484 regmap_field_read_poll_timeout(bq->rmap_fields[F_CONV_START], 485 ret, !ret, 25000, 1000000); 486 } 487 488 static int bq25890_power_supply_get_property(struct power_supply *psy, 489 enum power_supply_property psp, 490 union power_supply_propval *val) 491 { 492 struct bq25890_device *bq = power_supply_get_drvdata(psy); 493 struct bq25890_state state; 494 int ret; 495 496 bq25890_update_state(bq, psp, &state); 497 498 switch (psp) { 499 case POWER_SUPPLY_PROP_STATUS: 500 if (!state.online || state.hiz) 501 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 502 else if (state.chrg_status == STATUS_NOT_CHARGING) 503 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 504 else if (state.chrg_status == STATUS_PRE_CHARGING || 505 state.chrg_status == STATUS_FAST_CHARGING) 506 val->intval = POWER_SUPPLY_STATUS_CHARGING; 507 else if (state.chrg_status == STATUS_TERMINATION_DONE) 508 val->intval = POWER_SUPPLY_STATUS_FULL; 509 else 510 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 511 512 break; 513 514 case POWER_SUPPLY_PROP_CHARGE_TYPE: 515 if (!state.online || state.hiz || 516 state.chrg_status == STATUS_NOT_CHARGING || 517 state.chrg_status == STATUS_TERMINATION_DONE) 518 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; 519 else if (state.chrg_status == STATUS_PRE_CHARGING) 520 val->intval = POWER_SUPPLY_CHARGE_TYPE_STANDARD; 521 else if (state.chrg_status == STATUS_FAST_CHARGING) 522 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST; 523 else /* unreachable */ 524 val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; 525 break; 526 527 case POWER_SUPPLY_PROP_MANUFACTURER: 528 val->strval = BQ25890_MANUFACTURER; 529 break; 530 531 case POWER_SUPPLY_PROP_MODEL_NAME: 532 val->strval = bq25890_chip_name[bq->chip_version]; 533 break; 534 535 case POWER_SUPPLY_PROP_ONLINE: 536 val->intval = state.online && !state.hiz; 537 break; 538 539 case POWER_SUPPLY_PROP_HEALTH: 540 if (!state.chrg_fault && !state.bat_fault && !state.boost_fault) 541 val->intval = POWER_SUPPLY_HEALTH_GOOD; 542 else if (state.bat_fault) 543 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 544 else if (state.chrg_fault == CHRG_FAULT_TIMER_EXPIRED) 545 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE; 546 else if (state.chrg_fault == CHRG_FAULT_THERMAL_SHUTDOWN) 547 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 548 else 549 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 550 break; 551 552 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT: 553 val->intval = bq25890_find_val(bq->init_data.iprechg, TBL_ITERM); 554 break; 555 556 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: 557 val->intval = bq25890_find_val(bq->init_data.iterm, TBL_ITERM); 558 break; 559 560 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 561 ret = bq25890_field_read(bq, F_IINLIM); 562 if (ret < 0) 563 return ret; 564 565 val->intval = bq25890_find_val(ret, TBL_IINLIM); 566 break; 567 568 case POWER_SUPPLY_PROP_CURRENT_NOW: /* I_BAT now */ 569 /* 570 * This is ADC-sampled immediate charge current supplied 571 * from charger to battery. The property name is confusing, 572 * for clarification refer to: 573 * Documentation/ABI/testing/sysfs-class-power 574 * /sys/class/power_supply/<supply_name>/current_now 575 */ 576 ret = bq25890_field_read(bq, F_ICHGR); /* read measured value */ 577 if (ret < 0) 578 return ret; 579 580 /* converted_val = ADC_val * 50mA (table 10.3.19) */ 581 val->intval = ret * -50000; 582 break; 583 584 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: /* I_BAT user limit */ 585 /* 586 * This is user-configured constant charge current supplied 587 * from charger to battery in first phase of charging, when 588 * battery voltage is below constant charge voltage. 589 * 590 * This value reflects the current hardware setting. 591 * 592 * The POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX is the 593 * maximum value of this property. 594 */ 595 ret = bq25890_field_read(bq, F_ICHG); 596 if (ret < 0) 597 return ret; 598 val->intval = bq25890_find_val(ret, TBL_ICHG); 599 600 /* When temperature is too low, charge current is decreased */ 601 if (bq->state.ntc_fault == NTC_FAULT_COOL) { 602 ret = bq25890_field_read(bq, F_JEITA_ISET); 603 if (ret < 0) 604 return ret; 605 606 if (ret) 607 val->intval /= 5; 608 else 609 val->intval /= 2; 610 } 611 break; 612 613 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: /* I_BAT max */ 614 /* 615 * This is maximum allowed constant charge current supplied 616 * from charger to battery in first phase of charging, when 617 * battery voltage is below constant charge voltage. 618 * 619 * This value is constant for each battery and set from DT. 620 */ 621 val->intval = bq25890_find_val(bq->init_data.ichg, TBL_ICHG); 622 break; 623 624 case POWER_SUPPLY_PROP_VOLTAGE_NOW: /* V_BAT now */ 625 /* 626 * This is ADC-sampled immediate charge voltage supplied 627 * from charger to battery. The property name is confusing, 628 * for clarification refer to: 629 * Documentation/ABI/testing/sysfs-class-power 630 * /sys/class/power_supply/<supply_name>/voltage_now 631 */ 632 ret = bq25890_field_read(bq, F_BATV); /* read measured value */ 633 if (ret < 0) 634 return ret; 635 636 /* converted_val = 2.304V + ADC_val * 20mV (table 10.3.15) */ 637 val->intval = 2304000 + ret * 20000; 638 break; 639 640 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: /* V_BAT user limit */ 641 /* 642 * This is user-configured constant charge voltage supplied 643 * from charger to battery in second phase of charging, when 644 * battery voltage reached constant charge voltage. 645 * 646 * This value reflects the current hardware setting. 647 * 648 * The POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX is the 649 * maximum value of this property. 650 */ 651 ret = bq25890_field_read(bq, F_VREG); 652 if (ret < 0) 653 return ret; 654 655 val->intval = bq25890_find_val(ret, TBL_VREG); 656 break; 657 658 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: /* V_BAT max */ 659 /* 660 * This is maximum allowed constant charge voltage supplied 661 * from charger to battery in second phase of charging, when 662 * battery voltage reached constant charge voltage. 663 * 664 * This value is constant for each battery and set from DT. 665 */ 666 val->intval = bq25890_find_val(bq->init_data.vreg, TBL_VREG); 667 break; 668 669 case POWER_SUPPLY_PROP_TEMP: 670 ret = bq25890_field_read(bq, F_TSPCT); 671 if (ret < 0) 672 return ret; 673 674 /* convert TS percentage into rough temperature */ 675 val->intval = bq25890_find_val(ret, TBL_TSPCT); 676 break; 677 678 default: 679 return -EINVAL; 680 } 681 682 return 0; 683 } 684 685 static int bq25890_power_supply_set_property(struct power_supply *psy, 686 enum power_supply_property psp, 687 const union power_supply_propval *val) 688 { 689 struct bq25890_device *bq = power_supply_get_drvdata(psy); 690 struct bq25890_state state; 691 int maxval, ret; 692 u8 lval; 693 694 switch (psp) { 695 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 696 maxval = bq25890_find_val(bq->init_data.ichg, TBL_ICHG); 697 lval = bq25890_find_idx(min(val->intval, maxval), TBL_ICHG); 698 return bq25890_field_write(bq, F_ICHG, lval); 699 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 700 maxval = bq25890_find_val(bq->init_data.vreg, TBL_VREG); 701 lval = bq25890_find_idx(min(val->intval, maxval), TBL_VREG); 702 return bq25890_field_write(bq, F_VREG, lval); 703 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 704 lval = bq25890_find_idx(val->intval, TBL_IINLIM); 705 return bq25890_field_write(bq, F_IINLIM, lval); 706 case POWER_SUPPLY_PROP_ONLINE: 707 ret = bq25890_field_write(bq, F_EN_HIZ, !val->intval); 708 if (!ret) 709 bq->force_hiz = !val->intval; 710 bq25890_update_state(bq, psp, &state); 711 return ret; 712 default: 713 return -EINVAL; 714 } 715 } 716 717 static int bq25890_power_supply_property_is_writeable(struct power_supply *psy, 718 enum power_supply_property psp) 719 { 720 switch (psp) { 721 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 722 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 723 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 724 case POWER_SUPPLY_PROP_ONLINE: 725 return true; 726 default: 727 return false; 728 } 729 } 730 731 /* 732 * If there are multiple chargers the maximum current the external power-supply 733 * can deliver needs to be divided over the chargers. This is done according 734 * to the bq->iinlim_percentage setting. 735 */ 736 static int bq25890_charger_get_scaled_iinlim_regval(struct bq25890_device *bq, 737 int iinlim_ua) 738 { 739 iinlim_ua = iinlim_ua * bq->iinlim_percentage / 100; 740 return bq25890_find_idx(iinlim_ua, TBL_IINLIM); 741 } 742 743 /* On the BQ25892 try to get charger-type info from our supplier */ 744 static void bq25890_charger_external_power_changed(struct power_supply *psy) 745 { 746 struct bq25890_device *bq = power_supply_get_drvdata(psy); 747 union power_supply_propval val; 748 int input_current_limit, ret; 749 750 if (bq->chip_version != BQ25892) 751 return; 752 753 ret = power_supply_get_property_from_supplier(bq->charger, 754 POWER_SUPPLY_PROP_USB_TYPE, 755 &val); 756 if (ret) 757 return; 758 759 switch (val.intval) { 760 case POWER_SUPPLY_USB_TYPE_DCP: 761 input_current_limit = bq25890_charger_get_scaled_iinlim_regval(bq, 2000000); 762 if (bq->pump_express_vbus_max) { 763 queue_delayed_work(system_power_efficient_wq, 764 &bq->pump_express_work, 765 PUMP_EXPRESS_START_DELAY); 766 } 767 break; 768 case POWER_SUPPLY_USB_TYPE_CDP: 769 case POWER_SUPPLY_USB_TYPE_ACA: 770 input_current_limit = bq25890_charger_get_scaled_iinlim_regval(bq, 1500000); 771 break; 772 case POWER_SUPPLY_USB_TYPE_SDP: 773 default: 774 input_current_limit = bq25890_charger_get_scaled_iinlim_regval(bq, 500000); 775 } 776 777 bq25890_field_write(bq, F_IINLIM, input_current_limit); 778 } 779 780 static int bq25890_get_chip_state(struct bq25890_device *bq, 781 struct bq25890_state *state) 782 { 783 int i, ret; 784 785 struct { 786 enum bq25890_fields id; 787 u8 *data; 788 } state_fields[] = { 789 {F_CHG_STAT, &state->chrg_status}, 790 {F_PG_STAT, &state->online}, 791 {F_EN_HIZ, &state->hiz}, 792 {F_VSYS_STAT, &state->vsys_status}, 793 {F_BOOST_FAULT, &state->boost_fault}, 794 {F_BAT_FAULT, &state->bat_fault}, 795 {F_CHG_FAULT, &state->chrg_fault}, 796 {F_NTC_FAULT, &state->ntc_fault} 797 }; 798 799 for (i = 0; i < ARRAY_SIZE(state_fields); i++) { 800 ret = bq25890_field_read(bq, state_fields[i].id); 801 if (ret < 0) 802 return ret; 803 804 *state_fields[i].data = ret; 805 } 806 807 dev_dbg(bq->dev, "S:CHG/PG/HIZ/VSYS=%d/%d/%d/%d, F:CHG/BOOST/BAT/NTC=%d/%d/%d/%d\n", 808 state->chrg_status, state->online, 809 state->hiz, state->vsys_status, 810 state->chrg_fault, state->boost_fault, 811 state->bat_fault, state->ntc_fault); 812 813 return 0; 814 } 815 816 static irqreturn_t __bq25890_handle_irq(struct bq25890_device *bq) 817 { 818 bool adc_conv_rate, new_adc_conv_rate; 819 struct bq25890_state new_state; 820 int ret; 821 822 ret = bq25890_get_chip_state(bq, &new_state); 823 if (ret < 0) 824 return IRQ_NONE; 825 826 if (!memcmp(&bq->state, &new_state, sizeof(new_state))) 827 return IRQ_NONE; 828 829 /* 830 * Restore HiZ bit in case it was set by user. The chip does not retain 831 * this bit on cable replug, hence the bit must be reset manually here. 832 */ 833 if (new_state.online && !bq->state.online && bq->force_hiz) { 834 ret = bq25890_field_write(bq, F_EN_HIZ, bq->force_hiz); 835 if (ret < 0) 836 goto error; 837 new_state.hiz = 1; 838 } 839 840 /* Should period ADC sampling be enabled? */ 841 adc_conv_rate = bq->state.online && !bq->state.hiz; 842 new_adc_conv_rate = new_state.online && !new_state.hiz; 843 844 if (new_adc_conv_rate != adc_conv_rate) { 845 ret = bq25890_field_write(bq, F_CONV_RATE, new_adc_conv_rate); 846 if (ret < 0) 847 goto error; 848 } 849 850 bq->state = new_state; 851 power_supply_changed(bq->charger); 852 853 return IRQ_HANDLED; 854 error: 855 dev_err(bq->dev, "Error communicating with the chip: %pe\n", 856 ERR_PTR(ret)); 857 return IRQ_HANDLED; 858 } 859 860 static irqreturn_t bq25890_irq_handler_thread(int irq, void *private) 861 { 862 struct bq25890_device *bq = private; 863 irqreturn_t ret; 864 865 mutex_lock(&bq->lock); 866 ret = __bq25890_handle_irq(bq); 867 mutex_unlock(&bq->lock); 868 869 return ret; 870 } 871 872 static int bq25890_chip_reset(struct bq25890_device *bq) 873 { 874 int ret; 875 int rst_check_counter = 10; 876 877 ret = bq25890_field_write(bq, F_REG_RST, 1); 878 if (ret < 0) 879 return ret; 880 881 do { 882 ret = bq25890_field_read(bq, F_REG_RST); 883 if (ret < 0) 884 return ret; 885 886 usleep_range(5, 10); 887 } while (ret == 1 && --rst_check_counter); 888 889 if (!rst_check_counter) 890 return -ETIMEDOUT; 891 892 return 0; 893 } 894 895 static int bq25890_rw_init_data(struct bq25890_device *bq) 896 { 897 bool write = !bq->read_back_init_data; 898 int ret; 899 int i; 900 901 const struct { 902 enum bq25890_fields id; 903 u8 *value; 904 } init_data[] = { 905 {F_ICHG, &bq->init_data.ichg}, 906 {F_VREG, &bq->init_data.vreg}, 907 {F_ITERM, &bq->init_data.iterm}, 908 {F_IPRECHG, &bq->init_data.iprechg}, 909 {F_SYSVMIN, &bq->init_data.sysvmin}, 910 {F_BOOSTV, &bq->init_data.boostv}, 911 {F_BOOSTI, &bq->init_data.boosti}, 912 {F_BOOSTF, &bq->init_data.boostf}, 913 {F_EN_ILIM, &bq->init_data.ilim_en}, 914 {F_TREG, &bq->init_data.treg}, 915 {F_BATCMP, &bq->init_data.rbatcomp}, 916 {F_VCLAMP, &bq->init_data.vclamp}, 917 }; 918 919 for (i = 0; i < ARRAY_SIZE(init_data); i++) { 920 if (write) { 921 ret = bq25890_field_write(bq, init_data[i].id, 922 *init_data[i].value); 923 } else { 924 ret = bq25890_field_read(bq, init_data[i].id); 925 if (ret >= 0) 926 *init_data[i].value = ret; 927 } 928 if (ret < 0) { 929 dev_dbg(bq->dev, "Accessing init data failed %d\n", ret); 930 return ret; 931 } 932 } 933 934 return 0; 935 } 936 937 static int bq25890_hw_init(struct bq25890_device *bq) 938 { 939 int ret; 940 941 if (!bq->skip_reset) { 942 ret = bq25890_chip_reset(bq); 943 if (ret < 0) { 944 dev_dbg(bq->dev, "Reset failed %d\n", ret); 945 return ret; 946 } 947 } else { 948 /* 949 * Ensure charging is enabled, on some boards where the fw 950 * takes care of initalizition F_CHG_CFG is set to 0 before 951 * handing control over to the OS. 952 */ 953 ret = bq25890_field_write(bq, F_CHG_CFG, 1); 954 if (ret < 0) { 955 dev_dbg(bq->dev, "Enabling charging failed %d\n", ret); 956 return ret; 957 } 958 } 959 960 /* disable watchdog */ 961 ret = bq25890_field_write(bq, F_WD, 0); 962 if (ret < 0) { 963 dev_dbg(bq->dev, "Disabling watchdog failed %d\n", ret); 964 return ret; 965 } 966 967 /* initialize currents/voltages and other parameters */ 968 ret = bq25890_rw_init_data(bq); 969 if (ret) 970 return ret; 971 972 ret = bq25890_get_chip_state(bq, &bq->state); 973 if (ret < 0) { 974 dev_dbg(bq->dev, "Get state failed %d\n", ret); 975 return ret; 976 } 977 978 /* Configure ADC for continuous conversions when charging */ 979 ret = bq25890_field_write(bq, F_CONV_RATE, bq->state.online && !bq->state.hiz); 980 if (ret < 0) { 981 dev_dbg(bq->dev, "Config ADC failed %d\n", ret); 982 return ret; 983 } 984 985 return 0; 986 } 987 988 static const enum power_supply_property bq25890_power_supply_props[] = { 989 POWER_SUPPLY_PROP_MANUFACTURER, 990 POWER_SUPPLY_PROP_MODEL_NAME, 991 POWER_SUPPLY_PROP_STATUS, 992 POWER_SUPPLY_PROP_CHARGE_TYPE, 993 POWER_SUPPLY_PROP_ONLINE, 994 POWER_SUPPLY_PROP_HEALTH, 995 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 996 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 997 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 998 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, 999 POWER_SUPPLY_PROP_PRECHARGE_CURRENT, 1000 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, 1001 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 1002 POWER_SUPPLY_PROP_VOLTAGE_NOW, 1003 POWER_SUPPLY_PROP_CURRENT_NOW, 1004 POWER_SUPPLY_PROP_TEMP, 1005 }; 1006 1007 static char *bq25890_charger_supplied_to[] = { 1008 "main-battery", 1009 }; 1010 1011 static const struct power_supply_desc bq25890_power_supply_desc = { 1012 .type = POWER_SUPPLY_TYPE_USB, 1013 .properties = bq25890_power_supply_props, 1014 .num_properties = ARRAY_SIZE(bq25890_power_supply_props), 1015 .get_property = bq25890_power_supply_get_property, 1016 .set_property = bq25890_power_supply_set_property, 1017 .property_is_writeable = bq25890_power_supply_property_is_writeable, 1018 .external_power_changed = bq25890_charger_external_power_changed, 1019 }; 1020 1021 static int bq25890_power_supply_init(struct bq25890_device *bq) 1022 { 1023 struct power_supply_config psy_cfg = { .drv_data = bq, }; 1024 1025 /* Get ID for the device */ 1026 mutex_lock(&bq25890_id_mutex); 1027 bq->id = idr_alloc(&bq25890_id, bq, 0, 0, GFP_KERNEL); 1028 mutex_unlock(&bq25890_id_mutex); 1029 if (bq->id < 0) 1030 return bq->id; 1031 1032 snprintf(bq->name, sizeof(bq->name), "bq25890-charger-%d", bq->id); 1033 bq->desc = bq25890_power_supply_desc; 1034 bq->desc.name = bq->name; 1035 1036 psy_cfg.supplied_to = bq25890_charger_supplied_to; 1037 psy_cfg.num_supplicants = ARRAY_SIZE(bq25890_charger_supplied_to); 1038 1039 bq->charger = devm_power_supply_register(bq->dev, &bq->desc, &psy_cfg); 1040 1041 return PTR_ERR_OR_ZERO(bq->charger); 1042 } 1043 1044 static int bq25890_set_otg_cfg(struct bq25890_device *bq, u8 val) 1045 { 1046 int ret; 1047 1048 ret = bq25890_field_write(bq, F_OTG_CFG, val); 1049 if (ret < 0) 1050 dev_err(bq->dev, "Error switching to boost/charger mode: %d\n", ret); 1051 1052 return ret; 1053 } 1054 1055 static void bq25890_pump_express_work(struct work_struct *data) 1056 { 1057 struct bq25890_device *bq = 1058 container_of(data, struct bq25890_device, pump_express_work.work); 1059 union power_supply_propval value; 1060 int voltage, i, ret; 1061 1062 dev_dbg(bq->dev, "Start to request input voltage increasing\n"); 1063 1064 /* If there is a second charger put in Hi-Z mode */ 1065 if (bq->secondary_chrg) { 1066 value.intval = 0; 1067 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &value); 1068 } 1069 1070 /* Enable current pulse voltage control protocol */ 1071 ret = bq25890_field_write(bq, F_PUMPX_EN, 1); 1072 if (ret < 0) 1073 goto error_print; 1074 1075 for (i = 0; i < PUMP_EXPRESS_MAX_TRIES; i++) { 1076 voltage = bq25890_get_vbus_voltage(bq); 1077 if (voltage < 0) 1078 goto error_print; 1079 dev_dbg(bq->dev, "input voltage = %d uV\n", voltage); 1080 1081 if ((voltage + PUMP_EXPRESS_VBUS_MARGIN_uV) > 1082 bq->pump_express_vbus_max) 1083 break; 1084 1085 ret = bq25890_field_write(bq, F_PUMPX_UP, 1); 1086 if (ret < 0) 1087 goto error_print; 1088 1089 /* Note a single PUMPX up pulse-sequence takes 2.1s */ 1090 ret = regmap_field_read_poll_timeout(bq->rmap_fields[F_PUMPX_UP], 1091 ret, !ret, 100000, 3000000); 1092 if (ret < 0) 1093 goto error_print; 1094 1095 /* Make sure ADC has sampled Vbus before checking again */ 1096 msleep(1000); 1097 } 1098 1099 bq25890_field_write(bq, F_PUMPX_EN, 0); 1100 1101 if (bq->secondary_chrg) { 1102 value.intval = 1; 1103 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &value); 1104 } 1105 1106 dev_info(bq->dev, "Hi-voltage charging requested, input voltage is %d mV\n", 1107 voltage); 1108 1109 return; 1110 error_print: 1111 bq25890_field_write(bq, F_PUMPX_EN, 0); 1112 dev_err(bq->dev, "Failed to request hi-voltage charging\n"); 1113 } 1114 1115 static void bq25890_usb_work(struct work_struct *data) 1116 { 1117 int ret; 1118 struct bq25890_device *bq = 1119 container_of(data, struct bq25890_device, usb_work); 1120 1121 switch (bq->usb_event) { 1122 case USB_EVENT_ID: 1123 /* Enable boost mode */ 1124 bq25890_set_otg_cfg(bq, 1); 1125 break; 1126 1127 case USB_EVENT_NONE: 1128 /* Disable boost mode */ 1129 ret = bq25890_set_otg_cfg(bq, 0); 1130 if (ret == 0) 1131 power_supply_changed(bq->charger); 1132 break; 1133 } 1134 } 1135 1136 static int bq25890_usb_notifier(struct notifier_block *nb, unsigned long val, 1137 void *priv) 1138 { 1139 struct bq25890_device *bq = 1140 container_of(nb, struct bq25890_device, usb_nb); 1141 1142 bq->usb_event = val; 1143 queue_work(system_power_efficient_wq, &bq->usb_work); 1144 1145 return NOTIFY_OK; 1146 } 1147 1148 #ifdef CONFIG_REGULATOR 1149 static int bq25890_vbus_enable(struct regulator_dev *rdev) 1150 { 1151 struct bq25890_device *bq = rdev_get_drvdata(rdev); 1152 union power_supply_propval val = { 1153 .intval = 0, 1154 }; 1155 1156 /* 1157 * When enabling 5V boost / Vbus output, we need to put the secondary 1158 * charger in Hi-Z mode to avoid it trying to charge the secondary 1159 * battery from the 5V boost output. 1160 */ 1161 if (bq->secondary_chrg) 1162 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &val); 1163 1164 return bq25890_set_otg_cfg(bq, 1); 1165 } 1166 1167 static int bq25890_vbus_disable(struct regulator_dev *rdev) 1168 { 1169 struct bq25890_device *bq = rdev_get_drvdata(rdev); 1170 union power_supply_propval val = { 1171 .intval = 1, 1172 }; 1173 int ret; 1174 1175 ret = bq25890_set_otg_cfg(bq, 0); 1176 if (ret) 1177 return ret; 1178 1179 if (bq->secondary_chrg) 1180 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &val); 1181 1182 return 0; 1183 } 1184 1185 static int bq25890_vbus_is_enabled(struct regulator_dev *rdev) 1186 { 1187 struct bq25890_device *bq = rdev_get_drvdata(rdev); 1188 1189 return bq25890_field_read(bq, F_OTG_CFG); 1190 } 1191 1192 static int bq25890_vbus_get_voltage(struct regulator_dev *rdev) 1193 { 1194 struct bq25890_device *bq = rdev_get_drvdata(rdev); 1195 1196 return bq25890_get_vbus_voltage(bq); 1197 } 1198 1199 static int bq25890_vsys_get_voltage(struct regulator_dev *rdev) 1200 { 1201 struct bq25890_device *bq = rdev_get_drvdata(rdev); 1202 int ret; 1203 1204 /* Should be some output voltage ? */ 1205 ret = bq25890_field_read(bq, F_SYSV); /* read measured value */ 1206 if (ret < 0) 1207 return ret; 1208 1209 /* converted_val = 2.304V + ADC_val * 20mV (table 10.3.15) */ 1210 return 2304000 + ret * 20000; 1211 } 1212 1213 static const struct regulator_ops bq25890_vbus_ops = { 1214 .enable = bq25890_vbus_enable, 1215 .disable = bq25890_vbus_disable, 1216 .is_enabled = bq25890_vbus_is_enabled, 1217 .get_voltage = bq25890_vbus_get_voltage, 1218 }; 1219 1220 static const struct regulator_desc bq25890_vbus_desc = { 1221 .name = "usb_otg_vbus", 1222 .of_match = "usb-otg-vbus", 1223 .type = REGULATOR_VOLTAGE, 1224 .owner = THIS_MODULE, 1225 .ops = &bq25890_vbus_ops, 1226 }; 1227 1228 static const struct regulator_ops bq25890_vsys_ops = { 1229 .get_voltage = bq25890_vsys_get_voltage, 1230 }; 1231 1232 static const struct regulator_desc bq25890_vsys_desc = { 1233 .name = "vsys", 1234 .of_match = "vsys", 1235 .type = REGULATOR_VOLTAGE, 1236 .owner = THIS_MODULE, 1237 .ops = &bq25890_vsys_ops, 1238 }; 1239 1240 static int bq25890_register_regulator(struct bq25890_device *bq) 1241 { 1242 struct bq25890_platform_data *pdata = dev_get_platdata(bq->dev); 1243 struct regulator_config cfg = { 1244 .dev = bq->dev, 1245 .driver_data = bq, 1246 }; 1247 struct regulator_dev *reg; 1248 1249 if (pdata) 1250 cfg.init_data = pdata->regulator_init_data; 1251 1252 reg = devm_regulator_register(bq->dev, &bq25890_vbus_desc, &cfg); 1253 if (IS_ERR(reg)) { 1254 return dev_err_probe(bq->dev, PTR_ERR(reg), 1255 "registering vbus regulator"); 1256 } 1257 1258 /* pdata->regulator_init_data is for vbus only */ 1259 cfg.init_data = NULL; 1260 reg = devm_regulator_register(bq->dev, &bq25890_vsys_desc, &cfg); 1261 if (IS_ERR(reg)) { 1262 return dev_err_probe(bq->dev, PTR_ERR(reg), 1263 "registering vsys regulator"); 1264 } 1265 1266 return 0; 1267 } 1268 #else 1269 static inline int 1270 bq25890_register_regulator(struct bq25890_device *bq) 1271 { 1272 return 0; 1273 } 1274 #endif 1275 1276 static int bq25890_get_chip_version(struct bq25890_device *bq) 1277 { 1278 int id, rev; 1279 1280 id = bq25890_field_read(bq, F_PN); 1281 if (id < 0) { 1282 dev_err(bq->dev, "Cannot read chip ID: %d\n", id); 1283 return id; 1284 } 1285 1286 rev = bq25890_field_read(bq, F_DEV_REV); 1287 if (rev < 0) { 1288 dev_err(bq->dev, "Cannot read chip revision: %d\n", rev); 1289 return rev; 1290 } 1291 1292 switch (id) { 1293 case BQ25890_ID: 1294 bq->chip_version = BQ25890; 1295 break; 1296 1297 /* BQ25892 and BQ25896 share same ID 0 */ 1298 case BQ25896_ID: 1299 switch (rev) { 1300 case 2: 1301 bq->chip_version = BQ25896; 1302 break; 1303 case 1: 1304 bq->chip_version = BQ25892; 1305 break; 1306 default: 1307 dev_err(bq->dev, 1308 "Unknown device revision %d, assume BQ25892\n", 1309 rev); 1310 bq->chip_version = BQ25892; 1311 } 1312 break; 1313 1314 case BQ25895_ID: 1315 bq->chip_version = BQ25895; 1316 break; 1317 1318 default: 1319 dev_err(bq->dev, "Unknown chip ID %d\n", id); 1320 return -ENODEV; 1321 } 1322 1323 return 0; 1324 } 1325 1326 static int bq25890_irq_probe(struct bq25890_device *bq) 1327 { 1328 struct gpio_desc *irq; 1329 1330 irq = devm_gpiod_get(bq->dev, BQ25890_IRQ_PIN, GPIOD_IN); 1331 if (IS_ERR(irq)) 1332 return dev_err_probe(bq->dev, PTR_ERR(irq), 1333 "Could not probe irq pin.\n"); 1334 1335 return gpiod_to_irq(irq); 1336 } 1337 1338 static int bq25890_fw_read_u32_props(struct bq25890_device *bq) 1339 { 1340 int ret; 1341 u32 property; 1342 int i; 1343 struct bq25890_init_data *init = &bq->init_data; 1344 struct { 1345 char *name; 1346 bool optional; 1347 enum bq25890_table_ids tbl_id; 1348 u8 *conv_data; /* holds converted value from given property */ 1349 } props[] = { 1350 /* required properties */ 1351 {"ti,charge-current", false, TBL_ICHG, &init->ichg}, 1352 {"ti,battery-regulation-voltage", false, TBL_VREG, &init->vreg}, 1353 {"ti,termination-current", false, TBL_ITERM, &init->iterm}, 1354 {"ti,precharge-current", false, TBL_ITERM, &init->iprechg}, 1355 {"ti,minimum-sys-voltage", false, TBL_SYSVMIN, &init->sysvmin}, 1356 {"ti,boost-voltage", false, TBL_BOOSTV, &init->boostv}, 1357 {"ti,boost-max-current", false, TBL_BOOSTI, &init->boosti}, 1358 1359 /* optional properties */ 1360 {"ti,thermal-regulation-threshold", true, TBL_TREG, &init->treg}, 1361 {"ti,ibatcomp-micro-ohms", true, TBL_RBATCOMP, &init->rbatcomp}, 1362 {"ti,ibatcomp-clamp-microvolt", true, TBL_VBATCOMP, &init->vclamp}, 1363 }; 1364 1365 /* initialize data for optional properties */ 1366 init->treg = 3; /* 120 degrees Celsius */ 1367 init->rbatcomp = init->vclamp = 0; /* IBAT compensation disabled */ 1368 1369 for (i = 0; i < ARRAY_SIZE(props); i++) { 1370 ret = device_property_read_u32(bq->dev, props[i].name, 1371 &property); 1372 if (ret < 0) { 1373 if (props[i].optional) 1374 continue; 1375 1376 dev_err(bq->dev, "Unable to read property %d %s\n", ret, 1377 props[i].name); 1378 1379 return ret; 1380 } 1381 1382 *props[i].conv_data = bq25890_find_idx(property, 1383 props[i].tbl_id); 1384 } 1385 1386 return 0; 1387 } 1388 1389 static int bq25890_fw_probe(struct bq25890_device *bq) 1390 { 1391 int ret; 1392 struct bq25890_init_data *init = &bq->init_data; 1393 const char *str; 1394 u32 val; 1395 1396 ret = device_property_read_string(bq->dev, "linux,secondary-charger-name", &str); 1397 if (ret == 0) { 1398 bq->secondary_chrg = power_supply_get_by_name(str); 1399 if (!bq->secondary_chrg) 1400 return -EPROBE_DEFER; 1401 } 1402 1403 /* Optional, left at 0 if property is not present */ 1404 device_property_read_u32(bq->dev, "linux,pump-express-vbus-max", 1405 &bq->pump_express_vbus_max); 1406 1407 ret = device_property_read_u32(bq->dev, "linux,iinlim-percentage", &val); 1408 if (ret == 0) { 1409 if (val > 100) { 1410 dev_err(bq->dev, "Error linux,iinlim-percentage %u > 100\n", val); 1411 return -EINVAL; 1412 } 1413 bq->iinlim_percentage = val; 1414 } else { 1415 bq->iinlim_percentage = 100; 1416 } 1417 1418 bq->skip_reset = device_property_read_bool(bq->dev, "linux,skip-reset"); 1419 bq->read_back_init_data = device_property_read_bool(bq->dev, 1420 "linux,read-back-settings"); 1421 if (bq->read_back_init_data) 1422 return 0; 1423 1424 ret = bq25890_fw_read_u32_props(bq); 1425 if (ret < 0) 1426 return ret; 1427 1428 init->ilim_en = device_property_read_bool(bq->dev, "ti,use-ilim-pin"); 1429 init->boostf = device_property_read_bool(bq->dev, "ti,boost-low-freq"); 1430 1431 return 0; 1432 } 1433 1434 static void bq25890_non_devm_cleanup(void *data) 1435 { 1436 struct bq25890_device *bq = data; 1437 1438 cancel_delayed_work_sync(&bq->pump_express_work); 1439 1440 if (bq->id >= 0) { 1441 mutex_lock(&bq25890_id_mutex); 1442 idr_remove(&bq25890_id, bq->id); 1443 mutex_unlock(&bq25890_id_mutex); 1444 } 1445 } 1446 1447 static int bq25890_probe(struct i2c_client *client) 1448 { 1449 struct device *dev = &client->dev; 1450 struct bq25890_device *bq; 1451 int ret; 1452 1453 bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL); 1454 if (!bq) 1455 return -ENOMEM; 1456 1457 bq->client = client; 1458 bq->dev = dev; 1459 bq->id = -1; 1460 1461 mutex_init(&bq->lock); 1462 INIT_DELAYED_WORK(&bq->pump_express_work, bq25890_pump_express_work); 1463 1464 bq->rmap = devm_regmap_init_i2c(client, &bq25890_regmap_config); 1465 if (IS_ERR(bq->rmap)) 1466 return dev_err_probe(dev, PTR_ERR(bq->rmap), 1467 "failed to allocate register map\n"); 1468 1469 ret = devm_regmap_field_bulk_alloc(dev, bq->rmap, bq->rmap_fields, 1470 bq25890_reg_fields, F_MAX_FIELDS); 1471 if (ret) 1472 return ret; 1473 1474 i2c_set_clientdata(client, bq); 1475 1476 ret = bq25890_get_chip_version(bq); 1477 if (ret) { 1478 dev_err(dev, "Cannot read chip ID or unknown chip: %d\n", ret); 1479 return ret; 1480 } 1481 1482 ret = bq25890_fw_probe(bq); 1483 if (ret < 0) 1484 return dev_err_probe(dev, ret, "reading device properties\n"); 1485 1486 ret = bq25890_hw_init(bq); 1487 if (ret < 0) { 1488 dev_err(dev, "Cannot initialize the chip: %d\n", ret); 1489 return ret; 1490 } 1491 1492 if (client->irq <= 0) 1493 client->irq = bq25890_irq_probe(bq); 1494 1495 if (client->irq < 0) { 1496 dev_err(dev, "No irq resource found.\n"); 1497 return client->irq; 1498 } 1499 1500 /* OTG reporting */ 1501 bq->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2); 1502 1503 /* 1504 * This must be before bq25890_power_supply_init(), so that it runs 1505 * after devm unregisters the power_supply. 1506 */ 1507 ret = devm_add_action_or_reset(dev, bq25890_non_devm_cleanup, bq); 1508 if (ret) 1509 return ret; 1510 1511 ret = bq25890_register_regulator(bq); 1512 if (ret) 1513 return ret; 1514 1515 ret = bq25890_power_supply_init(bq); 1516 if (ret < 0) 1517 return dev_err_probe(dev, ret, "registering power supply\n"); 1518 1519 ret = devm_request_threaded_irq(dev, client->irq, NULL, 1520 bq25890_irq_handler_thread, 1521 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 1522 BQ25890_IRQ_PIN, bq); 1523 if (ret) 1524 return ret; 1525 1526 if (!IS_ERR_OR_NULL(bq->usb_phy)) { 1527 INIT_WORK(&bq->usb_work, bq25890_usb_work); 1528 bq->usb_nb.notifier_call = bq25890_usb_notifier; 1529 usb_register_notifier(bq->usb_phy, &bq->usb_nb); 1530 } 1531 1532 return 0; 1533 } 1534 1535 static void bq25890_remove(struct i2c_client *client) 1536 { 1537 struct bq25890_device *bq = i2c_get_clientdata(client); 1538 1539 if (!IS_ERR_OR_NULL(bq->usb_phy)) { 1540 usb_unregister_notifier(bq->usb_phy, &bq->usb_nb); 1541 cancel_work_sync(&bq->usb_work); 1542 } 1543 1544 if (!bq->skip_reset) { 1545 /* reset all registers to default values */ 1546 bq25890_chip_reset(bq); 1547 } 1548 } 1549 1550 static void bq25890_shutdown(struct i2c_client *client) 1551 { 1552 struct bq25890_device *bq = i2c_get_clientdata(client); 1553 1554 /* 1555 * TODO this if + return should probably be removed, but that would 1556 * introduce a function change for boards using the usb-phy framework. 1557 * This needs to be tested on such a board before making this change. 1558 */ 1559 if (!IS_ERR_OR_NULL(bq->usb_phy)) 1560 return; 1561 1562 /* 1563 * Turn off the 5v Boost regulator which outputs Vbus to the device's 1564 * Micro-USB or Type-C USB port. Leaving this on drains power and 1565 * this avoids the PMIC on some device-models seeing this as Vbus 1566 * getting inserted after shutdown, causing the device to immediately 1567 * power-up again. 1568 */ 1569 bq25890_set_otg_cfg(bq, 0); 1570 } 1571 1572 #ifdef CONFIG_PM_SLEEP 1573 static int bq25890_suspend(struct device *dev) 1574 { 1575 struct bq25890_device *bq = dev_get_drvdata(dev); 1576 1577 /* 1578 * If charger is removed, while in suspend, make sure ADC is diabled 1579 * since it consumes slightly more power. 1580 */ 1581 return bq25890_field_write(bq, F_CONV_RATE, 0); 1582 } 1583 1584 static int bq25890_resume(struct device *dev) 1585 { 1586 int ret; 1587 struct bq25890_device *bq = dev_get_drvdata(dev); 1588 1589 mutex_lock(&bq->lock); 1590 1591 ret = bq25890_get_chip_state(bq, &bq->state); 1592 if (ret < 0) 1593 goto unlock; 1594 1595 /* Re-enable ADC only if charger is plugged in. */ 1596 if (bq->state.online) { 1597 ret = bq25890_field_write(bq, F_CONV_RATE, 1); 1598 if (ret < 0) 1599 goto unlock; 1600 } 1601 1602 /* signal userspace, maybe state changed while suspended */ 1603 power_supply_changed(bq->charger); 1604 1605 unlock: 1606 mutex_unlock(&bq->lock); 1607 1608 return ret; 1609 } 1610 #endif 1611 1612 static const struct dev_pm_ops bq25890_pm = { 1613 SET_SYSTEM_SLEEP_PM_OPS(bq25890_suspend, bq25890_resume) 1614 }; 1615 1616 static const struct i2c_device_id bq25890_i2c_ids[] = { 1617 { "bq25890", 0 }, 1618 { "bq25892", 0 }, 1619 { "bq25895", 0 }, 1620 { "bq25896", 0 }, 1621 {}, 1622 }; 1623 MODULE_DEVICE_TABLE(i2c, bq25890_i2c_ids); 1624 1625 static const struct of_device_id bq25890_of_match[] __maybe_unused = { 1626 { .compatible = "ti,bq25890", }, 1627 { .compatible = "ti,bq25892", }, 1628 { .compatible = "ti,bq25895", }, 1629 { .compatible = "ti,bq25896", }, 1630 { }, 1631 }; 1632 MODULE_DEVICE_TABLE(of, bq25890_of_match); 1633 1634 #ifdef CONFIG_ACPI 1635 static const struct acpi_device_id bq25890_acpi_match[] = { 1636 {"BQ258900", 0}, 1637 {}, 1638 }; 1639 MODULE_DEVICE_TABLE(acpi, bq25890_acpi_match); 1640 #endif 1641 1642 static struct i2c_driver bq25890_driver = { 1643 .driver = { 1644 .name = "bq25890-charger", 1645 .of_match_table = of_match_ptr(bq25890_of_match), 1646 .acpi_match_table = ACPI_PTR(bq25890_acpi_match), 1647 .pm = &bq25890_pm, 1648 }, 1649 .probe_new = bq25890_probe, 1650 .remove = bq25890_remove, 1651 .shutdown = bq25890_shutdown, 1652 .id_table = bq25890_i2c_ids, 1653 }; 1654 module_i2c_driver(bq25890_driver); 1655 1656 MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>"); 1657 MODULE_DESCRIPTION("bq25890 charger driver"); 1658 MODULE_LICENSE("GPL"); 1659