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 34enum bq25890_chip_version { 35 BQ25890, 36 BQ25892, 37 BQ25895, 38 BQ25896, 39}; 40 41static const char *const bq25890_chip_name[] = { 42 "BQ25890", 43 "BQ25892", 44 "BQ25895", 45 "BQ25896", 46}; 47 48enum 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 */ 81struct 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 96struct 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 107struct 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 137static DEFINE_IDR(bq25890_id); 138static DEFINE_MUTEX(bq25890_id_mutex); 139 140static const struct regmap_range bq25890_readonly_reg_ranges[] = { 141 regmap_reg_range(0x0b, 0x0c), 142 regmap_reg_range(0x0e, 0x13), 143}; 144 145static 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 150static 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 157static 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 162static 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 173static 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 */ 276enum 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 */ 295static 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 */ 300static 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 */ 307static 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 328struct bq25890_range { 329 u32 min; 330 u32 max; 331 u32 step; 332}; 333 334struct bq25890_lookup { 335 const u32 *tbl; 336 u32 size; 337}; 338 339static 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 361static 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 374static 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 380static 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 405static 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 419enum bq25890_status { 420 STATUS_NOT_CHARGING, 421 STATUS_PRE_CHARGING, 422 STATUS_FAST_CHARGING, 423 STATUS_TERMINATION_DONE, 424}; 425 426enum bq25890_chrg_fault { 427 CHRG_FAULT_NORMAL, 428 CHRG_FAULT_INPUT, 429 CHRG_FAULT_THERMAL_SHUTDOWN, 430 CHRG_FAULT_TIMER_EXPIRED, 431}; 432 433enum 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 441static 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 454static irqreturn_t __bq25890_handle_irq(struct bq25890_device *bq); 455 456static 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 467static 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 488static 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 685static 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 717static 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 */ 736static 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 */ 744static 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(psy, 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 power_supply_changed(psy); 779} 780 781static int bq25890_get_chip_state(struct bq25890_device *bq, 782 struct bq25890_state *state) 783{ 784 int i, ret; 785 786 struct { 787 enum bq25890_fields id; 788 u8 *data; 789 } state_fields[] = { 790 {F_CHG_STAT, &state->chrg_status}, 791 {F_PG_STAT, &state->online}, 792 {F_EN_HIZ, &state->hiz}, 793 {F_VSYS_STAT, &state->vsys_status}, 794 {F_BOOST_FAULT, &state->boost_fault}, 795 {F_BAT_FAULT, &state->bat_fault}, 796 {F_CHG_FAULT, &state->chrg_fault}, 797 {F_NTC_FAULT, &state->ntc_fault} 798 }; 799 800 for (i = 0; i < ARRAY_SIZE(state_fields); i++) { 801 ret = bq25890_field_read(bq, state_fields[i].id); 802 if (ret < 0) 803 return ret; 804 805 *state_fields[i].data = ret; 806 } 807 808 dev_dbg(bq->dev, "S:CHG/PG/HIZ/VSYS=%d/%d/%d/%d, F:CHG/BOOST/BAT/NTC=%d/%d/%d/%d\n", 809 state->chrg_status, state->online, 810 state->hiz, state->vsys_status, 811 state->chrg_fault, state->boost_fault, 812 state->bat_fault, state->ntc_fault); 813 814 return 0; 815} 816 817static irqreturn_t __bq25890_handle_irq(struct bq25890_device *bq) 818{ 819 bool adc_conv_rate, new_adc_conv_rate; 820 struct bq25890_state new_state; 821 int ret; 822 823 ret = bq25890_get_chip_state(bq, &new_state); 824 if (ret < 0) 825 return IRQ_NONE; 826 827 if (!memcmp(&bq->state, &new_state, sizeof(new_state))) 828 return IRQ_NONE; 829 830 /* 831 * Restore HiZ bit in case it was set by user. The chip does not retain 832 * this bit on cable replug, hence the bit must be reset manually here. 833 */ 834 if (new_state.online && !bq->state.online && bq->force_hiz) { 835 ret = bq25890_field_write(bq, F_EN_HIZ, bq->force_hiz); 836 if (ret < 0) 837 goto error; 838 new_state.hiz = 1; 839 } 840 841 /* Should period ADC sampling be enabled? */ 842 adc_conv_rate = bq->state.online && !bq->state.hiz; 843 new_adc_conv_rate = new_state.online && !new_state.hiz; 844 845 if (new_adc_conv_rate != adc_conv_rate) { 846 ret = bq25890_field_write(bq, F_CONV_RATE, new_adc_conv_rate); 847 if (ret < 0) 848 goto error; 849 } 850 851 bq->state = new_state; 852 power_supply_changed(bq->charger); 853 854 return IRQ_HANDLED; 855error: 856 dev_err(bq->dev, "Error communicating with the chip: %pe\n", 857 ERR_PTR(ret)); 858 return IRQ_HANDLED; 859} 860 861static irqreturn_t bq25890_irq_handler_thread(int irq, void *private) 862{ 863 struct bq25890_device *bq = private; 864 irqreturn_t ret; 865 866 mutex_lock(&bq->lock); 867 ret = __bq25890_handle_irq(bq); 868 mutex_unlock(&bq->lock); 869 870 return ret; 871} 872 873static int bq25890_chip_reset(struct bq25890_device *bq) 874{ 875 int ret; 876 int rst_check_counter = 10; 877 878 ret = bq25890_field_write(bq, F_REG_RST, 1); 879 if (ret < 0) 880 return ret; 881 882 do { 883 ret = bq25890_field_read(bq, F_REG_RST); 884 if (ret < 0) 885 return ret; 886 887 usleep_range(5, 10); 888 } while (ret == 1 && --rst_check_counter); 889 890 if (!rst_check_counter) 891 return -ETIMEDOUT; 892 893 return 0; 894} 895 896static int bq25890_rw_init_data(struct bq25890_device *bq) 897{ 898 bool write = !bq->read_back_init_data; 899 int ret; 900 int i; 901 902 const struct { 903 enum bq25890_fields id; 904 u8 *value; 905 } init_data[] = { 906 {F_ICHG, &bq->init_data.ichg}, 907 {F_VREG, &bq->init_data.vreg}, 908 {F_ITERM, &bq->init_data.iterm}, 909 {F_IPRECHG, &bq->init_data.iprechg}, 910 {F_SYSVMIN, &bq->init_data.sysvmin}, 911 {F_BOOSTV, &bq->init_data.boostv}, 912 {F_BOOSTI, &bq->init_data.boosti}, 913 {F_BOOSTF, &bq->init_data.boostf}, 914 {F_EN_ILIM, &bq->init_data.ilim_en}, 915 {F_TREG, &bq->init_data.treg}, 916 {F_BATCMP, &bq->init_data.rbatcomp}, 917 {F_VCLAMP, &bq->init_data.vclamp}, 918 }; 919 920 for (i = 0; i < ARRAY_SIZE(init_data); i++) { 921 if (write) { 922 ret = bq25890_field_write(bq, init_data[i].id, 923 *init_data[i].value); 924 } else { 925 ret = bq25890_field_read(bq, init_data[i].id); 926 if (ret >= 0) 927 *init_data[i].value = ret; 928 } 929 if (ret < 0) { 930 dev_dbg(bq->dev, "Accessing init data failed %d\n", ret); 931 return ret; 932 } 933 } 934 935 return 0; 936} 937 938static int bq25890_hw_init(struct bq25890_device *bq) 939{ 940 int ret; 941 942 if (!bq->skip_reset) { 943 ret = bq25890_chip_reset(bq); 944 if (ret < 0) { 945 dev_dbg(bq->dev, "Reset failed %d\n", ret); 946 return ret; 947 } 948 } else { 949 /* 950 * Ensure charging is enabled, on some boards where the fw 951 * takes care of initalizition F_CHG_CFG is set to 0 before 952 * handing control over to the OS. 953 */ 954 ret = bq25890_field_write(bq, F_CHG_CFG, 1); 955 if (ret < 0) { 956 dev_dbg(bq->dev, "Enabling charging failed %d\n", ret); 957 return ret; 958 } 959 } 960 961 /* disable watchdog */ 962 ret = bq25890_field_write(bq, F_WD, 0); 963 if (ret < 0) { 964 dev_dbg(bq->dev, "Disabling watchdog failed %d\n", ret); 965 return ret; 966 } 967 968 /* initialize currents/voltages and other parameters */ 969 ret = bq25890_rw_init_data(bq); 970 if (ret) 971 return ret; 972 973 ret = bq25890_get_chip_state(bq, &bq->state); 974 if (ret < 0) { 975 dev_dbg(bq->dev, "Get state failed %d\n", ret); 976 return ret; 977 } 978 979 /* Configure ADC for continuous conversions when charging */ 980 ret = bq25890_field_write(bq, F_CONV_RATE, bq->state.online && !bq->state.hiz); 981 if (ret < 0) { 982 dev_dbg(bq->dev, "Config ADC failed %d\n", ret); 983 return ret; 984 } 985 986 return 0; 987} 988 989static const enum power_supply_property bq25890_power_supply_props[] = { 990 POWER_SUPPLY_PROP_MANUFACTURER, 991 POWER_SUPPLY_PROP_MODEL_NAME, 992 POWER_SUPPLY_PROP_STATUS, 993 POWER_SUPPLY_PROP_CHARGE_TYPE, 994 POWER_SUPPLY_PROP_ONLINE, 995 POWER_SUPPLY_PROP_HEALTH, 996 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 997 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 998 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 999 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, 1000 POWER_SUPPLY_PROP_PRECHARGE_CURRENT, 1001 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, 1002 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 1003 POWER_SUPPLY_PROP_VOLTAGE_NOW, 1004 POWER_SUPPLY_PROP_CURRENT_NOW, 1005 POWER_SUPPLY_PROP_TEMP, 1006}; 1007 1008static char *bq25890_charger_supplied_to[] = { 1009 "main-battery", 1010}; 1011 1012static const struct power_supply_desc bq25890_power_supply_desc = { 1013 .type = POWER_SUPPLY_TYPE_USB, 1014 .properties = bq25890_power_supply_props, 1015 .num_properties = ARRAY_SIZE(bq25890_power_supply_props), 1016 .get_property = bq25890_power_supply_get_property, 1017 .set_property = bq25890_power_supply_set_property, 1018 .property_is_writeable = bq25890_power_supply_property_is_writeable, 1019 .external_power_changed = bq25890_charger_external_power_changed, 1020}; 1021 1022static int bq25890_power_supply_init(struct bq25890_device *bq) 1023{ 1024 struct power_supply_config psy_cfg = { .drv_data = bq, }; 1025 1026 /* Get ID for the device */ 1027 mutex_lock(&bq25890_id_mutex); 1028 bq->id = idr_alloc(&bq25890_id, bq, 0, 0, GFP_KERNEL); 1029 mutex_unlock(&bq25890_id_mutex); 1030 if (bq->id < 0) 1031 return bq->id; 1032 1033 snprintf(bq->name, sizeof(bq->name), "bq25890-charger-%d", bq->id); 1034 bq->desc = bq25890_power_supply_desc; 1035 bq->desc.name = bq->name; 1036 1037 psy_cfg.supplied_to = bq25890_charger_supplied_to; 1038 psy_cfg.num_supplicants = ARRAY_SIZE(bq25890_charger_supplied_to); 1039 1040 bq->charger = devm_power_supply_register(bq->dev, &bq->desc, &psy_cfg); 1041 1042 return PTR_ERR_OR_ZERO(bq->charger); 1043} 1044 1045static int bq25890_set_otg_cfg(struct bq25890_device *bq, u8 val) 1046{ 1047 int ret; 1048 1049 ret = bq25890_field_write(bq, F_OTG_CFG, val); 1050 if (ret < 0) 1051 dev_err(bq->dev, "Error switching to boost/charger mode: %d\n", ret); 1052 1053 return ret; 1054} 1055 1056static void bq25890_pump_express_work(struct work_struct *data) 1057{ 1058 struct bq25890_device *bq = 1059 container_of(data, struct bq25890_device, pump_express_work.work); 1060 union power_supply_propval value; 1061 int voltage, i, ret; 1062 1063 dev_dbg(bq->dev, "Start to request input voltage increasing\n"); 1064 1065 /* If there is a second charger put in Hi-Z mode */ 1066 if (bq->secondary_chrg) { 1067 value.intval = 0; 1068 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &value); 1069 } 1070 1071 /* Enable current pulse voltage control protocol */ 1072 ret = bq25890_field_write(bq, F_PUMPX_EN, 1); 1073 if (ret < 0) 1074 goto error_print; 1075 1076 for (i = 0; i < PUMP_EXPRESS_MAX_TRIES; i++) { 1077 voltage = bq25890_get_vbus_voltage(bq); 1078 if (voltage < 0) 1079 goto error_print; 1080 dev_dbg(bq->dev, "input voltage = %d uV\n", voltage); 1081 1082 if ((voltage + PUMP_EXPRESS_VBUS_MARGIN_uV) > 1083 bq->pump_express_vbus_max) 1084 break; 1085 1086 ret = bq25890_field_write(bq, F_PUMPX_UP, 1); 1087 if (ret < 0) 1088 goto error_print; 1089 1090 /* Note a single PUMPX up pulse-sequence takes 2.1s */ 1091 ret = regmap_field_read_poll_timeout(bq->rmap_fields[F_PUMPX_UP], 1092 ret, !ret, 100000, 3000000); 1093 if (ret < 0) 1094 goto error_print; 1095 1096 /* Make sure ADC has sampled Vbus before checking again */ 1097 msleep(1000); 1098 } 1099 1100 bq25890_field_write(bq, F_PUMPX_EN, 0); 1101 1102 if (bq->secondary_chrg) { 1103 value.intval = 1; 1104 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &value); 1105 } 1106 1107 dev_info(bq->dev, "Hi-voltage charging requested, input voltage is %d mV\n", 1108 voltage); 1109 1110 power_supply_changed(bq->charger); 1111 1112 return; 1113error_print: 1114 bq25890_field_write(bq, F_PUMPX_EN, 0); 1115 dev_err(bq->dev, "Failed to request hi-voltage charging\n"); 1116} 1117 1118static void bq25890_usb_work(struct work_struct *data) 1119{ 1120 int ret; 1121 struct bq25890_device *bq = 1122 container_of(data, struct bq25890_device, usb_work); 1123 1124 switch (bq->usb_event) { 1125 case USB_EVENT_ID: 1126 /* Enable boost mode */ 1127 bq25890_set_otg_cfg(bq, 1); 1128 break; 1129 1130 case USB_EVENT_NONE: 1131 /* Disable boost mode */ 1132 ret = bq25890_set_otg_cfg(bq, 0); 1133 if (ret == 0) 1134 power_supply_changed(bq->charger); 1135 break; 1136 } 1137} 1138 1139static int bq25890_usb_notifier(struct notifier_block *nb, unsigned long val, 1140 void *priv) 1141{ 1142 struct bq25890_device *bq = 1143 container_of(nb, struct bq25890_device, usb_nb); 1144 1145 bq->usb_event = val; 1146 queue_work(system_power_efficient_wq, &bq->usb_work); 1147 1148 return NOTIFY_OK; 1149} 1150 1151#ifdef CONFIG_REGULATOR 1152static int bq25890_vbus_enable(struct regulator_dev *rdev) 1153{ 1154 struct bq25890_device *bq = rdev_get_drvdata(rdev); 1155 union power_supply_propval val = { 1156 .intval = 0, 1157 }; 1158 1159 /* 1160 * When enabling 5V boost / Vbus output, we need to put the secondary 1161 * charger in Hi-Z mode to avoid it trying to charge the secondary 1162 * battery from the 5V boost output. 1163 */ 1164 if (bq->secondary_chrg) 1165 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &val); 1166 1167 return bq25890_set_otg_cfg(bq, 1); 1168} 1169 1170static int bq25890_vbus_disable(struct regulator_dev *rdev) 1171{ 1172 struct bq25890_device *bq = rdev_get_drvdata(rdev); 1173 union power_supply_propval val = { 1174 .intval = 1, 1175 }; 1176 int ret; 1177 1178 ret = bq25890_set_otg_cfg(bq, 0); 1179 if (ret) 1180 return ret; 1181 1182 if (bq->secondary_chrg) 1183 power_supply_set_property(bq->secondary_chrg, POWER_SUPPLY_PROP_ONLINE, &val); 1184 1185 return 0; 1186} 1187 1188static int bq25890_vbus_is_enabled(struct regulator_dev *rdev) 1189{ 1190 struct bq25890_device *bq = rdev_get_drvdata(rdev); 1191 1192 return bq25890_field_read(bq, F_OTG_CFG); 1193} 1194 1195static int bq25890_vbus_get_voltage(struct regulator_dev *rdev) 1196{ 1197 struct bq25890_device *bq = rdev_get_drvdata(rdev); 1198 1199 return bq25890_get_vbus_voltage(bq); 1200} 1201 1202static int bq25890_vsys_get_voltage(struct regulator_dev *rdev) 1203{ 1204 struct bq25890_device *bq = rdev_get_drvdata(rdev); 1205 int ret; 1206 1207 /* Should be some output voltage ? */ 1208 ret = bq25890_field_read(bq, F_SYSV); /* read measured value */ 1209 if (ret < 0) 1210 return ret; 1211 1212 /* converted_val = 2.304V + ADC_val * 20mV (table 10.3.15) */ 1213 return 2304000 + ret * 20000; 1214} 1215 1216static const struct regulator_ops bq25890_vbus_ops = { 1217 .enable = bq25890_vbus_enable, 1218 .disable = bq25890_vbus_disable, 1219 .is_enabled = bq25890_vbus_is_enabled, 1220 .get_voltage = bq25890_vbus_get_voltage, 1221}; 1222 1223static const struct regulator_desc bq25890_vbus_desc = { 1224 .name = "usb_otg_vbus", 1225 .of_match = "usb-otg-vbus", 1226 .type = REGULATOR_VOLTAGE, 1227 .owner = THIS_MODULE, 1228 .ops = &bq25890_vbus_ops, 1229}; 1230 1231static const struct regulator_ops bq25890_vsys_ops = { 1232 .get_voltage = bq25890_vsys_get_voltage, 1233}; 1234 1235static const struct regulator_desc bq25890_vsys_desc = { 1236 .name = "vsys", 1237 .of_match = "vsys", 1238 .type = REGULATOR_VOLTAGE, 1239 .owner = THIS_MODULE, 1240 .ops = &bq25890_vsys_ops, 1241}; 1242 1243static int bq25890_register_regulator(struct bq25890_device *bq) 1244{ 1245 struct bq25890_platform_data *pdata = dev_get_platdata(bq->dev); 1246 struct regulator_config cfg = { 1247 .dev = bq->dev, 1248 .driver_data = bq, 1249 }; 1250 struct regulator_dev *reg; 1251 1252 if (pdata) 1253 cfg.init_data = pdata->regulator_init_data; 1254 1255 reg = devm_regulator_register(bq->dev, &bq25890_vbus_desc, &cfg); 1256 if (IS_ERR(reg)) { 1257 return dev_err_probe(bq->dev, PTR_ERR(reg), 1258 "registering vbus regulator"); 1259 } 1260 1261 /* pdata->regulator_init_data is for vbus only */ 1262 cfg.init_data = NULL; 1263 reg = devm_regulator_register(bq->dev, &bq25890_vsys_desc, &cfg); 1264 if (IS_ERR(reg)) { 1265 return dev_err_probe(bq->dev, PTR_ERR(reg), 1266 "registering vsys regulator"); 1267 } 1268 1269 return 0; 1270} 1271#else 1272static inline int 1273bq25890_register_regulator(struct bq25890_device *bq) 1274{ 1275 return 0; 1276} 1277#endif 1278 1279static int bq25890_get_chip_version(struct bq25890_device *bq) 1280{ 1281 int id, rev; 1282 1283 id = bq25890_field_read(bq, F_PN); 1284 if (id < 0) { 1285 dev_err(bq->dev, "Cannot read chip ID: %d\n", id); 1286 return id; 1287 } 1288 1289 rev = bq25890_field_read(bq, F_DEV_REV); 1290 if (rev < 0) { 1291 dev_err(bq->dev, "Cannot read chip revision: %d\n", rev); 1292 return rev; 1293 } 1294 1295 switch (id) { 1296 case BQ25890_ID: 1297 bq->chip_version = BQ25890; 1298 break; 1299 1300 /* BQ25892 and BQ25896 share same ID 0 */ 1301 case BQ25896_ID: 1302 switch (rev) { 1303 case 2: 1304 bq->chip_version = BQ25896; 1305 break; 1306 case 1: 1307 bq->chip_version = BQ25892; 1308 break; 1309 default: 1310 dev_err(bq->dev, 1311 "Unknown device revision %d, assume BQ25892\n", 1312 rev); 1313 bq->chip_version = BQ25892; 1314 } 1315 break; 1316 1317 case BQ25895_ID: 1318 bq->chip_version = BQ25895; 1319 break; 1320 1321 default: 1322 dev_err(bq->dev, "Unknown chip ID %d\n", id); 1323 return -ENODEV; 1324 } 1325 1326 return 0; 1327} 1328 1329static int bq25890_irq_probe(struct bq25890_device *bq) 1330{ 1331 struct gpio_desc *irq; 1332 1333 irq = devm_gpiod_get(bq->dev, BQ25890_IRQ_PIN, GPIOD_IN); 1334 if (IS_ERR(irq)) 1335 return dev_err_probe(bq->dev, PTR_ERR(irq), 1336 "Could not probe irq pin.\n"); 1337 1338 return gpiod_to_irq(irq); 1339} 1340 1341static int bq25890_fw_read_u32_props(struct bq25890_device *bq) 1342{ 1343 int ret; 1344 u32 property; 1345 int i; 1346 struct bq25890_init_data *init = &bq->init_data; 1347 struct { 1348 char *name; 1349 bool optional; 1350 enum bq25890_table_ids tbl_id; 1351 u8 *conv_data; /* holds converted value from given property */ 1352 } props[] = { 1353 /* required properties */ 1354 {"ti,charge-current", false, TBL_ICHG, &init->ichg}, 1355 {"ti,battery-regulation-voltage", false, TBL_VREG, &init->vreg}, 1356 {"ti,termination-current", false, TBL_ITERM, &init->iterm}, 1357 {"ti,precharge-current", false, TBL_ITERM, &init->iprechg}, 1358 {"ti,minimum-sys-voltage", false, TBL_SYSVMIN, &init->sysvmin}, 1359 {"ti,boost-voltage", false, TBL_BOOSTV, &init->boostv}, 1360 {"ti,boost-max-current", false, TBL_BOOSTI, &init->boosti}, 1361 1362 /* optional properties */ 1363 {"ti,thermal-regulation-threshold", true, TBL_TREG, &init->treg}, 1364 {"ti,ibatcomp-micro-ohms", true, TBL_RBATCOMP, &init->rbatcomp}, 1365 {"ti,ibatcomp-clamp-microvolt", true, TBL_VBATCOMP, &init->vclamp}, 1366 }; 1367 1368 /* initialize data for optional properties */ 1369 init->treg = 3; /* 120 degrees Celsius */ 1370 init->rbatcomp = init->vclamp = 0; /* IBAT compensation disabled */ 1371 1372 for (i = 0; i < ARRAY_SIZE(props); i++) { 1373 ret = device_property_read_u32(bq->dev, props[i].name, 1374 &property); 1375 if (ret < 0) { 1376 if (props[i].optional) 1377 continue; 1378 1379 dev_err(bq->dev, "Unable to read property %d %s\n", ret, 1380 props[i].name); 1381 1382 return ret; 1383 } 1384 1385 *props[i].conv_data = bq25890_find_idx(property, 1386 props[i].tbl_id); 1387 } 1388 1389 return 0; 1390} 1391 1392static int bq25890_fw_probe(struct bq25890_device *bq) 1393{ 1394 int ret; 1395 struct bq25890_init_data *init = &bq->init_data; 1396 const char *str; 1397 u32 val; 1398 1399 ret = device_property_read_string(bq->dev, "linux,secondary-charger-name", &str); 1400 if (ret == 0) { 1401 bq->secondary_chrg = power_supply_get_by_name(str); 1402 if (!bq->secondary_chrg) 1403 return -EPROBE_DEFER; 1404 } 1405 1406 /* Optional, left at 0 if property is not present */ 1407 device_property_read_u32(bq->dev, "linux,pump-express-vbus-max", 1408 &bq->pump_express_vbus_max); 1409 1410 ret = device_property_read_u32(bq->dev, "linux,iinlim-percentage", &val); 1411 if (ret == 0) { 1412 if (val > 100) { 1413 dev_err(bq->dev, "Error linux,iinlim-percentage %u > 100\n", val); 1414 return -EINVAL; 1415 } 1416 bq->iinlim_percentage = val; 1417 } else { 1418 bq->iinlim_percentage = 100; 1419 } 1420 1421 bq->skip_reset = device_property_read_bool(bq->dev, "linux,skip-reset"); 1422 bq->read_back_init_data = device_property_read_bool(bq->dev, 1423 "linux,read-back-settings"); 1424 if (bq->read_back_init_data) 1425 return 0; 1426 1427 ret = bq25890_fw_read_u32_props(bq); 1428 if (ret < 0) 1429 return ret; 1430 1431 init->ilim_en = device_property_read_bool(bq->dev, "ti,use-ilim-pin"); 1432 init->boostf = device_property_read_bool(bq->dev, "ti,boost-low-freq"); 1433 1434 return 0; 1435} 1436 1437static void bq25890_non_devm_cleanup(void *data) 1438{ 1439 struct bq25890_device *bq = data; 1440 1441 cancel_delayed_work_sync(&bq->pump_express_work); 1442 1443 if (bq->id >= 0) { 1444 mutex_lock(&bq25890_id_mutex); 1445 idr_remove(&bq25890_id, bq->id); 1446 mutex_unlock(&bq25890_id_mutex); 1447 } 1448} 1449 1450static int bq25890_probe(struct i2c_client *client) 1451{ 1452 struct device *dev = &client->dev; 1453 struct bq25890_device *bq; 1454 int ret; 1455 1456 bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL); 1457 if (!bq) 1458 return -ENOMEM; 1459 1460 bq->client = client; 1461 bq->dev = dev; 1462 bq->id = -1; 1463 1464 mutex_init(&bq->lock); 1465 INIT_DELAYED_WORK(&bq->pump_express_work, bq25890_pump_express_work); 1466 1467 bq->rmap = devm_regmap_init_i2c(client, &bq25890_regmap_config); 1468 if (IS_ERR(bq->rmap)) 1469 return dev_err_probe(dev, PTR_ERR(bq->rmap), 1470 "failed to allocate register map\n"); 1471 1472 ret = devm_regmap_field_bulk_alloc(dev, bq->rmap, bq->rmap_fields, 1473 bq25890_reg_fields, F_MAX_FIELDS); 1474 if (ret) 1475 return ret; 1476 1477 i2c_set_clientdata(client, bq); 1478 1479 ret = bq25890_get_chip_version(bq); 1480 if (ret) { 1481 dev_err(dev, "Cannot read chip ID or unknown chip: %d\n", ret); 1482 return ret; 1483 } 1484 1485 ret = bq25890_fw_probe(bq); 1486 if (ret < 0) 1487 return dev_err_probe(dev, ret, "reading device properties\n"); 1488 1489 ret = bq25890_hw_init(bq); 1490 if (ret < 0) { 1491 dev_err(dev, "Cannot initialize the chip: %d\n", ret); 1492 return ret; 1493 } 1494 1495 if (client->irq <= 0) 1496 client->irq = bq25890_irq_probe(bq); 1497 1498 if (client->irq < 0) { 1499 dev_err(dev, "No irq resource found.\n"); 1500 return client->irq; 1501 } 1502 1503 /* OTG reporting */ 1504 bq->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2); 1505 1506 /* 1507 * This must be before bq25890_power_supply_init(), so that it runs 1508 * after devm unregisters the power_supply. 1509 */ 1510 ret = devm_add_action_or_reset(dev, bq25890_non_devm_cleanup, bq); 1511 if (ret) 1512 return ret; 1513 1514 ret = bq25890_register_regulator(bq); 1515 if (ret) 1516 return ret; 1517 1518 ret = bq25890_power_supply_init(bq); 1519 if (ret < 0) 1520 return dev_err_probe(dev, ret, "registering power supply\n"); 1521 1522 ret = devm_request_threaded_irq(dev, client->irq, NULL, 1523 bq25890_irq_handler_thread, 1524 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 1525 BQ25890_IRQ_PIN, bq); 1526 if (ret) 1527 return ret; 1528 1529 if (!IS_ERR_OR_NULL(bq->usb_phy)) { 1530 INIT_WORK(&bq->usb_work, bq25890_usb_work); 1531 bq->usb_nb.notifier_call = bq25890_usb_notifier; 1532 usb_register_notifier(bq->usb_phy, &bq->usb_nb); 1533 } 1534 1535 return 0; 1536} 1537 1538static void bq25890_remove(struct i2c_client *client) 1539{ 1540 struct bq25890_device *bq = i2c_get_clientdata(client); 1541 1542 if (!IS_ERR_OR_NULL(bq->usb_phy)) { 1543 usb_unregister_notifier(bq->usb_phy, &bq->usb_nb); 1544 cancel_work_sync(&bq->usb_work); 1545 } 1546 1547 if (!bq->skip_reset) { 1548 /* reset all registers to default values */ 1549 bq25890_chip_reset(bq); 1550 } 1551} 1552 1553static void bq25890_shutdown(struct i2c_client *client) 1554{ 1555 struct bq25890_device *bq = i2c_get_clientdata(client); 1556 1557 /* 1558 * TODO this if + return should probably be removed, but that would 1559 * introduce a function change for boards using the usb-phy framework. 1560 * This needs to be tested on such a board before making this change. 1561 */ 1562 if (!IS_ERR_OR_NULL(bq->usb_phy)) 1563 return; 1564 1565 /* 1566 * Turn off the 5v Boost regulator which outputs Vbus to the device's 1567 * Micro-USB or Type-C USB port. Leaving this on drains power and 1568 * this avoids the PMIC on some device-models seeing this as Vbus 1569 * getting inserted after shutdown, causing the device to immediately 1570 * power-up again. 1571 */ 1572 bq25890_set_otg_cfg(bq, 0); 1573} 1574 1575#ifdef CONFIG_PM_SLEEP 1576static int bq25890_suspend(struct device *dev) 1577{ 1578 struct bq25890_device *bq = dev_get_drvdata(dev); 1579 1580 /* 1581 * If charger is removed, while in suspend, make sure ADC is diabled 1582 * since it consumes slightly more power. 1583 */ 1584 return bq25890_field_write(bq, F_CONV_RATE, 0); 1585} 1586 1587static int bq25890_resume(struct device *dev) 1588{ 1589 int ret; 1590 struct bq25890_device *bq = dev_get_drvdata(dev); 1591 1592 mutex_lock(&bq->lock); 1593 1594 ret = bq25890_get_chip_state(bq, &bq->state); 1595 if (ret < 0) 1596 goto unlock; 1597 1598 /* Re-enable ADC only if charger is plugged in. */ 1599 if (bq->state.online) { 1600 ret = bq25890_field_write(bq, F_CONV_RATE, 1); 1601 if (ret < 0) 1602 goto unlock; 1603 } 1604 1605 /* signal userspace, maybe state changed while suspended */ 1606 power_supply_changed(bq->charger); 1607 1608unlock: 1609 mutex_unlock(&bq->lock); 1610 1611 return ret; 1612} 1613#endif 1614 1615static const struct dev_pm_ops bq25890_pm = { 1616 SET_SYSTEM_SLEEP_PM_OPS(bq25890_suspend, bq25890_resume) 1617}; 1618 1619static const struct i2c_device_id bq25890_i2c_ids[] = { 1620 { "bq25890", 0 }, 1621 { "bq25892", 0 }, 1622 { "bq25895", 0 }, 1623 { "bq25896", 0 }, 1624 {}, 1625}; 1626MODULE_DEVICE_TABLE(i2c, bq25890_i2c_ids); 1627 1628static const struct of_device_id bq25890_of_match[] __maybe_unused = { 1629 { .compatible = "ti,bq25890", }, 1630 { .compatible = "ti,bq25892", }, 1631 { .compatible = "ti,bq25895", }, 1632 { .compatible = "ti,bq25896", }, 1633 { }, 1634}; 1635MODULE_DEVICE_TABLE(of, bq25890_of_match); 1636 1637#ifdef CONFIG_ACPI 1638static const struct acpi_device_id bq25890_acpi_match[] = { 1639 {"BQ258900", 0}, 1640 {}, 1641}; 1642MODULE_DEVICE_TABLE(acpi, bq25890_acpi_match); 1643#endif 1644 1645static struct i2c_driver bq25890_driver = { 1646 .driver = { 1647 .name = "bq25890-charger", 1648 .of_match_table = of_match_ptr(bq25890_of_match), 1649 .acpi_match_table = ACPI_PTR(bq25890_acpi_match), 1650 .pm = &bq25890_pm, 1651 }, 1652 .probe = bq25890_probe, 1653 .remove = bq25890_remove, 1654 .shutdown = bq25890_shutdown, 1655 .id_table = bq25890_i2c_ids, 1656}; 1657module_i2c_driver(bq25890_driver); 1658 1659MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>"); 1660MODULE_DESCRIPTION("bq25890 charger driver"); 1661MODULE_LICENSE("GPL"); 1662