1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * TI BQ24257 charger driver 4 * 5 * Copyright (C) 2015 Intel Corporation 6 * 7 * Datasheets: 8 * https://www.ti.com/product/bq24250 9 * https://www.ti.com/product/bq24251 10 * https://www.ti.com/product/bq24257 11 */ 12 13#include <linux/module.h> 14#include <linux/i2c.h> 15#include <linux/power_supply.h> 16#include <linux/regmap.h> 17#include <linux/types.h> 18#include <linux/gpio/consumer.h> 19#include <linux/interrupt.h> 20#include <linux/delay.h> 21 22#include <linux/acpi.h> 23#include <linux/of.h> 24 25#define BQ24257_REG_1 0x00 26#define BQ24257_REG_2 0x01 27#define BQ24257_REG_3 0x02 28#define BQ24257_REG_4 0x03 29#define BQ24257_REG_5 0x04 30#define BQ24257_REG_6 0x05 31#define BQ24257_REG_7 0x06 32 33#define BQ24257_MANUFACTURER "Texas Instruments" 34#define BQ24257_PG_GPIO "pg" 35 36#define BQ24257_ILIM_SET_DELAY 1000 /* msec */ 37 38/* 39 * When adding support for new devices make sure that enum bq2425x_chip and 40 * bq2425x_chip_name[] always stay in sync! 41 */ 42enum bq2425x_chip { 43 BQ24250, 44 BQ24251, 45 BQ24257, 46}; 47 48static const char *const bq2425x_chip_name[] = { 49 "bq24250", 50 "bq24251", 51 "bq24257", 52}; 53 54enum bq24257_fields { 55 F_WD_FAULT, F_WD_EN, F_STAT, F_FAULT, /* REG 1 */ 56 F_RESET, F_IILIMIT, F_EN_STAT, F_EN_TERM, F_CE, F_HZ_MODE, /* REG 2 */ 57 F_VBAT, F_USB_DET, /* REG 3 */ 58 F_ICHG, F_ITERM, /* REG 4 */ 59 F_LOOP_STATUS, F_LOW_CHG, F_DPDM_EN, F_CE_STATUS, F_VINDPM, /* REG 5 */ 60 F_X2_TMR_EN, F_TMR, F_SYSOFF, F_TS_EN, F_TS_STAT, /* REG 6 */ 61 F_VOVP, F_CLR_VDP, F_FORCE_BATDET, F_FORCE_PTM, /* REG 7 */ 62 63 F_MAX_FIELDS 64}; 65 66/* initial field values, converted from uV/uA */ 67struct bq24257_init_data { 68 u8 ichg; /* charge current */ 69 u8 vbat; /* regulation voltage */ 70 u8 iterm; /* termination current */ 71 u8 iilimit; /* input current limit */ 72 u8 vovp; /* over voltage protection voltage */ 73 u8 vindpm; /* VDMP input threshold voltage */ 74}; 75 76struct bq24257_state { 77 u8 status; 78 u8 fault; 79 bool power_good; 80}; 81 82struct bq24257_device { 83 struct i2c_client *client; 84 struct device *dev; 85 struct power_supply *charger; 86 87 enum bq2425x_chip chip; 88 89 struct regmap *rmap; 90 struct regmap_field *rmap_fields[F_MAX_FIELDS]; 91 92 struct gpio_desc *pg; 93 94 struct delayed_work iilimit_setup_work; 95 96 struct bq24257_init_data init_data; 97 struct bq24257_state state; 98 99 struct mutex lock; /* protect state data */ 100 101 bool iilimit_autoset_enable; 102}; 103 104static bool bq24257_is_volatile_reg(struct device *dev, unsigned int reg) 105{ 106 switch (reg) { 107 case BQ24257_REG_2: 108 case BQ24257_REG_4: 109 return false; 110 111 default: 112 return true; 113 } 114} 115 116static const struct regmap_config bq24257_regmap_config = { 117 .reg_bits = 8, 118 .val_bits = 8, 119 120 .max_register = BQ24257_REG_7, 121 .cache_type = REGCACHE_RBTREE, 122 123 .volatile_reg = bq24257_is_volatile_reg, 124}; 125 126static const struct reg_field bq24257_reg_fields[] = { 127 /* REG 1 */ 128 [F_WD_FAULT] = REG_FIELD(BQ24257_REG_1, 7, 7), 129 [F_WD_EN] = REG_FIELD(BQ24257_REG_1, 6, 6), 130 [F_STAT] = REG_FIELD(BQ24257_REG_1, 4, 5), 131 [F_FAULT] = REG_FIELD(BQ24257_REG_1, 0, 3), 132 /* REG 2 */ 133 [F_RESET] = REG_FIELD(BQ24257_REG_2, 7, 7), 134 [F_IILIMIT] = REG_FIELD(BQ24257_REG_2, 4, 6), 135 [F_EN_STAT] = REG_FIELD(BQ24257_REG_2, 3, 3), 136 [F_EN_TERM] = REG_FIELD(BQ24257_REG_2, 2, 2), 137 [F_CE] = REG_FIELD(BQ24257_REG_2, 1, 1), 138 [F_HZ_MODE] = REG_FIELD(BQ24257_REG_2, 0, 0), 139 /* REG 3 */ 140 [F_VBAT] = REG_FIELD(BQ24257_REG_3, 2, 7), 141 [F_USB_DET] = REG_FIELD(BQ24257_REG_3, 0, 1), 142 /* REG 4 */ 143 [F_ICHG] = REG_FIELD(BQ24257_REG_4, 3, 7), 144 [F_ITERM] = REG_FIELD(BQ24257_REG_4, 0, 2), 145 /* REG 5 */ 146 [F_LOOP_STATUS] = REG_FIELD(BQ24257_REG_5, 6, 7), 147 [F_LOW_CHG] = REG_FIELD(BQ24257_REG_5, 5, 5), 148 [F_DPDM_EN] = REG_FIELD(BQ24257_REG_5, 4, 4), 149 [F_CE_STATUS] = REG_FIELD(BQ24257_REG_5, 3, 3), 150 [F_VINDPM] = REG_FIELD(BQ24257_REG_5, 0, 2), 151 /* REG 6 */ 152 [F_X2_TMR_EN] = REG_FIELD(BQ24257_REG_6, 7, 7), 153 [F_TMR] = REG_FIELD(BQ24257_REG_6, 5, 6), 154 [F_SYSOFF] = REG_FIELD(BQ24257_REG_6, 4, 4), 155 [F_TS_EN] = REG_FIELD(BQ24257_REG_6, 3, 3), 156 [F_TS_STAT] = REG_FIELD(BQ24257_REG_6, 0, 2), 157 /* REG 7 */ 158 [F_VOVP] = REG_FIELD(BQ24257_REG_7, 5, 7), 159 [F_CLR_VDP] = REG_FIELD(BQ24257_REG_7, 4, 4), 160 [F_FORCE_BATDET] = REG_FIELD(BQ24257_REG_7, 3, 3), 161 [F_FORCE_PTM] = REG_FIELD(BQ24257_REG_7, 2, 2) 162}; 163 164static const u32 bq24257_vbat_map[] = { 165 3500000, 3520000, 3540000, 3560000, 3580000, 3600000, 3620000, 3640000, 166 3660000, 3680000, 3700000, 3720000, 3740000, 3760000, 3780000, 3800000, 167 3820000, 3840000, 3860000, 3880000, 3900000, 3920000, 3940000, 3960000, 168 3980000, 4000000, 4020000, 4040000, 4060000, 4080000, 4100000, 4120000, 169 4140000, 4160000, 4180000, 4200000, 4220000, 4240000, 4260000, 4280000, 170 4300000, 4320000, 4340000, 4360000, 4380000, 4400000, 4420000, 4440000 171}; 172 173#define BQ24257_VBAT_MAP_SIZE ARRAY_SIZE(bq24257_vbat_map) 174 175static const u32 bq24257_ichg_map[] = { 176 500000, 550000, 600000, 650000, 700000, 750000, 800000, 850000, 900000, 177 950000, 1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000, 178 1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000, 179 1750000, 1800000, 1850000, 1900000, 1950000, 2000000 180}; 181 182#define BQ24257_ICHG_MAP_SIZE ARRAY_SIZE(bq24257_ichg_map) 183 184static const u32 bq24257_iterm_map[] = { 185 50000, 75000, 100000, 125000, 150000, 175000, 200000, 225000 186}; 187 188#define BQ24257_ITERM_MAP_SIZE ARRAY_SIZE(bq24257_iterm_map) 189 190static const u32 bq24257_iilimit_map[] = { 191 100000, 150000, 500000, 900000, 1500000, 2000000 192}; 193 194#define BQ24257_IILIMIT_MAP_SIZE ARRAY_SIZE(bq24257_iilimit_map) 195 196static const u32 bq24257_vovp_map[] = { 197 6000000, 6500000, 7000000, 8000000, 9000000, 9500000, 10000000, 198 10500000 199}; 200 201#define BQ24257_VOVP_MAP_SIZE ARRAY_SIZE(bq24257_vovp_map) 202 203static const u32 bq24257_vindpm_map[] = { 204 4200000, 4280000, 4360000, 4440000, 4520000, 4600000, 4680000, 205 4760000 206}; 207 208#define BQ24257_VINDPM_MAP_SIZE ARRAY_SIZE(bq24257_vindpm_map) 209 210static int bq24257_field_read(struct bq24257_device *bq, 211 enum bq24257_fields field_id) 212{ 213 int ret; 214 int val; 215 216 ret = regmap_field_read(bq->rmap_fields[field_id], &val); 217 if (ret < 0) 218 return ret; 219 220 return val; 221} 222 223static int bq24257_field_write(struct bq24257_device *bq, 224 enum bq24257_fields field_id, u8 val) 225{ 226 return regmap_field_write(bq->rmap_fields[field_id], val); 227} 228 229static u8 bq24257_find_idx(u32 value, const u32 *map, u8 map_size) 230{ 231 u8 idx; 232 233 for (idx = 1; idx < map_size; idx++) 234 if (value < map[idx]) 235 break; 236 237 return idx - 1; 238} 239 240enum bq24257_status { 241 STATUS_READY, 242 STATUS_CHARGE_IN_PROGRESS, 243 STATUS_CHARGE_DONE, 244 STATUS_FAULT, 245}; 246 247enum bq24257_fault { 248 FAULT_NORMAL, 249 FAULT_INPUT_OVP, 250 FAULT_INPUT_UVLO, 251 FAULT_SLEEP, 252 FAULT_BAT_TS, 253 FAULT_BAT_OVP, 254 FAULT_TS, 255 FAULT_TIMER, 256 FAULT_NO_BAT, 257 FAULT_ISET, 258 FAULT_INPUT_LDO_LOW, 259}; 260 261static int bq24257_get_input_current_limit(struct bq24257_device *bq, 262 union power_supply_propval *val) 263{ 264 int ret; 265 266 ret = bq24257_field_read(bq, F_IILIMIT); 267 if (ret < 0) 268 return ret; 269 270 /* 271 * The "External ILIM" and "Production & Test" modes are not exposed 272 * through this driver and not being covered by the lookup table. 273 * Should such a mode have become active let's return an error rather 274 * than exceeding the bounds of the lookup table and returning 275 * garbage. 276 */ 277 if (ret >= BQ24257_IILIMIT_MAP_SIZE) 278 return -ENODATA; 279 280 val->intval = bq24257_iilimit_map[ret]; 281 282 return 0; 283} 284 285static int bq24257_set_input_current_limit(struct bq24257_device *bq, 286 const union power_supply_propval *val) 287{ 288 /* 289 * Address the case where the user manually sets an input current limit 290 * while the charger auto-detection mechanism is active. In this 291 * case we want to abort and go straight to the user-specified value. 292 */ 293 if (bq->iilimit_autoset_enable) 294 cancel_delayed_work_sync(&bq->iilimit_setup_work); 295 296 return bq24257_field_write(bq, F_IILIMIT, 297 bq24257_find_idx(val->intval, 298 bq24257_iilimit_map, 299 BQ24257_IILIMIT_MAP_SIZE)); 300} 301 302static int bq24257_power_supply_get_property(struct power_supply *psy, 303 enum power_supply_property psp, 304 union power_supply_propval *val) 305{ 306 struct bq24257_device *bq = power_supply_get_drvdata(psy); 307 struct bq24257_state state; 308 309 mutex_lock(&bq->lock); 310 state = bq->state; 311 mutex_unlock(&bq->lock); 312 313 switch (psp) { 314 case POWER_SUPPLY_PROP_STATUS: 315 if (!state.power_good) 316 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 317 else if (state.status == STATUS_READY) 318 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 319 else if (state.status == STATUS_CHARGE_IN_PROGRESS) 320 val->intval = POWER_SUPPLY_STATUS_CHARGING; 321 else if (state.status == STATUS_CHARGE_DONE) 322 val->intval = POWER_SUPPLY_STATUS_FULL; 323 else 324 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 325 break; 326 327 case POWER_SUPPLY_PROP_MANUFACTURER: 328 val->strval = BQ24257_MANUFACTURER; 329 break; 330 331 case POWER_SUPPLY_PROP_MODEL_NAME: 332 val->strval = bq2425x_chip_name[bq->chip]; 333 break; 334 335 case POWER_SUPPLY_PROP_ONLINE: 336 val->intval = state.power_good; 337 break; 338 339 case POWER_SUPPLY_PROP_HEALTH: 340 switch (state.fault) { 341 case FAULT_NORMAL: 342 val->intval = POWER_SUPPLY_HEALTH_GOOD; 343 break; 344 345 case FAULT_INPUT_OVP: 346 case FAULT_BAT_OVP: 347 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 348 break; 349 350 case FAULT_TS: 351 case FAULT_BAT_TS: 352 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 353 break; 354 355 case FAULT_TIMER: 356 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE; 357 break; 358 359 default: 360 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 361 break; 362 } 363 364 break; 365 366 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 367 val->intval = bq24257_ichg_map[bq->init_data.ichg]; 368 break; 369 370 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 371 val->intval = bq24257_ichg_map[BQ24257_ICHG_MAP_SIZE - 1]; 372 break; 373 374 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 375 val->intval = bq24257_vbat_map[bq->init_data.vbat]; 376 break; 377 378 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 379 val->intval = bq24257_vbat_map[BQ24257_VBAT_MAP_SIZE - 1]; 380 break; 381 382 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: 383 val->intval = bq24257_iterm_map[bq->init_data.iterm]; 384 break; 385 386 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 387 return bq24257_get_input_current_limit(bq, val); 388 389 default: 390 return -EINVAL; 391 } 392 393 return 0; 394} 395 396static int bq24257_power_supply_set_property(struct power_supply *psy, 397 enum power_supply_property prop, 398 const union power_supply_propval *val) 399{ 400 struct bq24257_device *bq = power_supply_get_drvdata(psy); 401 402 switch (prop) { 403 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 404 return bq24257_set_input_current_limit(bq, val); 405 default: 406 return -EINVAL; 407 } 408} 409 410static int bq24257_power_supply_property_is_writeable(struct power_supply *psy, 411 enum power_supply_property psp) 412{ 413 switch (psp) { 414 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 415 return true; 416 default: 417 return false; 418 } 419} 420 421static int bq24257_get_chip_state(struct bq24257_device *bq, 422 struct bq24257_state *state) 423{ 424 int ret; 425 426 ret = bq24257_field_read(bq, F_STAT); 427 if (ret < 0) 428 return ret; 429 430 state->status = ret; 431 432 ret = bq24257_field_read(bq, F_FAULT); 433 if (ret < 0) 434 return ret; 435 436 state->fault = ret; 437 438 if (bq->pg) 439 state->power_good = !gpiod_get_value_cansleep(bq->pg); 440 else 441 /* 442 * If we have a chip without a dedicated power-good GPIO or 443 * some other explicit bit that would provide this information 444 * assume the power is good if there is no supply related 445 * fault - and not good otherwise. There is a possibility for 446 * other errors to mask that power in fact is not good but this 447 * is probably the best we can do here. 448 */ 449 switch (state->fault) { 450 case FAULT_INPUT_OVP: 451 case FAULT_INPUT_UVLO: 452 case FAULT_INPUT_LDO_LOW: 453 state->power_good = false; 454 break; 455 default: 456 state->power_good = true; 457 } 458 459 return 0; 460} 461 462static bool bq24257_state_changed(struct bq24257_device *bq, 463 struct bq24257_state *new_state) 464{ 465 int ret; 466 467 mutex_lock(&bq->lock); 468 ret = (bq->state.status != new_state->status || 469 bq->state.fault != new_state->fault || 470 bq->state.power_good != new_state->power_good); 471 mutex_unlock(&bq->lock); 472 473 return ret; 474} 475 476enum bq24257_loop_status { 477 LOOP_STATUS_NONE, 478 LOOP_STATUS_IN_DPM, 479 LOOP_STATUS_IN_CURRENT_LIMIT, 480 LOOP_STATUS_THERMAL, 481}; 482 483enum bq24257_in_ilimit { 484 IILIMIT_100, 485 IILIMIT_150, 486 IILIMIT_500, 487 IILIMIT_900, 488 IILIMIT_1500, 489 IILIMIT_2000, 490 IILIMIT_EXT, 491 IILIMIT_NONE, 492}; 493 494enum bq24257_vovp { 495 VOVP_6000, 496 VOVP_6500, 497 VOVP_7000, 498 VOVP_8000, 499 VOVP_9000, 500 VOVP_9500, 501 VOVP_10000, 502 VOVP_10500 503}; 504 505enum bq24257_vindpm { 506 VINDPM_4200, 507 VINDPM_4280, 508 VINDPM_4360, 509 VINDPM_4440, 510 VINDPM_4520, 511 VINDPM_4600, 512 VINDPM_4680, 513 VINDPM_4760 514}; 515 516enum bq24257_port_type { 517 PORT_TYPE_DCP, /* Dedicated Charging Port */ 518 PORT_TYPE_CDP, /* Charging Downstream Port */ 519 PORT_TYPE_SDP, /* Standard Downstream Port */ 520 PORT_TYPE_NON_STANDARD, 521}; 522 523enum bq24257_safety_timer { 524 SAFETY_TIMER_45, 525 SAFETY_TIMER_360, 526 SAFETY_TIMER_540, 527 SAFETY_TIMER_NONE, 528}; 529 530static int bq24257_iilimit_autoset(struct bq24257_device *bq) 531{ 532 int loop_status; 533 int iilimit; 534 int port_type; 535 int ret; 536 const u8 new_iilimit[] = { 537 [PORT_TYPE_DCP] = IILIMIT_2000, 538 [PORT_TYPE_CDP] = IILIMIT_2000, 539 [PORT_TYPE_SDP] = IILIMIT_500, 540 [PORT_TYPE_NON_STANDARD] = IILIMIT_500 541 }; 542 543 ret = bq24257_field_read(bq, F_LOOP_STATUS); 544 if (ret < 0) 545 goto error; 546 547 loop_status = ret; 548 549 ret = bq24257_field_read(bq, F_IILIMIT); 550 if (ret < 0) 551 goto error; 552 553 iilimit = ret; 554 555 /* 556 * All USB ports should be able to handle 500mA. If not, DPM will lower 557 * the charging current to accommodate the power source. No need to set 558 * a lower IILIMIT value. 559 */ 560 if (loop_status == LOOP_STATUS_IN_DPM && iilimit == IILIMIT_500) 561 return 0; 562 563 ret = bq24257_field_read(bq, F_USB_DET); 564 if (ret < 0) 565 goto error; 566 567 port_type = ret; 568 569 ret = bq24257_field_write(bq, F_IILIMIT, new_iilimit[port_type]); 570 if (ret < 0) 571 goto error; 572 573 ret = bq24257_field_write(bq, F_TMR, SAFETY_TIMER_360); 574 if (ret < 0) 575 goto error; 576 577 ret = bq24257_field_write(bq, F_CLR_VDP, 1); 578 if (ret < 0) 579 goto error; 580 581 dev_dbg(bq->dev, "port/loop = %d/%d -> iilimit = %d\n", 582 port_type, loop_status, new_iilimit[port_type]); 583 584 return 0; 585 586error: 587 dev_err(bq->dev, "%s: Error communicating with the chip.\n", __func__); 588 return ret; 589} 590 591static void bq24257_iilimit_setup_work(struct work_struct *work) 592{ 593 struct bq24257_device *bq = container_of(work, struct bq24257_device, 594 iilimit_setup_work.work); 595 596 bq24257_iilimit_autoset(bq); 597} 598 599static void bq24257_handle_state_change(struct bq24257_device *bq, 600 struct bq24257_state *new_state) 601{ 602 int ret; 603 struct bq24257_state old_state; 604 605 mutex_lock(&bq->lock); 606 old_state = bq->state; 607 mutex_unlock(&bq->lock); 608 609 /* 610 * Handle BQ2425x state changes observing whether the D+/D- based input 611 * current limit autoset functionality is enabled. 612 */ 613 if (!new_state->power_good) { 614 dev_dbg(bq->dev, "Power removed\n"); 615 if (bq->iilimit_autoset_enable) { 616 cancel_delayed_work_sync(&bq->iilimit_setup_work); 617 618 /* activate D+/D- port detection algorithm */ 619 ret = bq24257_field_write(bq, F_DPDM_EN, 1); 620 if (ret < 0) 621 goto error; 622 } 623 /* 624 * When power is removed always return to the default input 625 * current limit as configured during probe. 626 */ 627 ret = bq24257_field_write(bq, F_IILIMIT, bq->init_data.iilimit); 628 if (ret < 0) 629 goto error; 630 } else if (!old_state.power_good) { 631 dev_dbg(bq->dev, "Power inserted\n"); 632 633 if (bq->iilimit_autoset_enable) 634 /* configure input current limit */ 635 schedule_delayed_work(&bq->iilimit_setup_work, 636 msecs_to_jiffies(BQ24257_ILIM_SET_DELAY)); 637 } else if (new_state->fault == FAULT_NO_BAT) { 638 dev_warn(bq->dev, "Battery removed\n"); 639 } else if (new_state->fault == FAULT_TIMER) { 640 dev_err(bq->dev, "Safety timer expired! Battery dead?\n"); 641 } 642 643 return; 644 645error: 646 dev_err(bq->dev, "%s: Error communicating with the chip.\n", __func__); 647} 648 649static irqreturn_t bq24257_irq_handler_thread(int irq, void *private) 650{ 651 int ret; 652 struct bq24257_device *bq = private; 653 struct bq24257_state state; 654 655 ret = bq24257_get_chip_state(bq, &state); 656 if (ret < 0) 657 return IRQ_HANDLED; 658 659 if (!bq24257_state_changed(bq, &state)) 660 return IRQ_HANDLED; 661 662 dev_dbg(bq->dev, "irq(state changed): status/fault/pg = %d/%d/%d\n", 663 state.status, state.fault, state.power_good); 664 665 bq24257_handle_state_change(bq, &state); 666 667 mutex_lock(&bq->lock); 668 bq->state = state; 669 mutex_unlock(&bq->lock); 670 671 power_supply_changed(bq->charger); 672 673 return IRQ_HANDLED; 674} 675 676static int bq24257_hw_init(struct bq24257_device *bq) 677{ 678 int ret; 679 int i; 680 struct bq24257_state state; 681 682 const struct { 683 int field; 684 u32 value; 685 } init_data[] = { 686 {F_ICHG, bq->init_data.ichg}, 687 {F_VBAT, bq->init_data.vbat}, 688 {F_ITERM, bq->init_data.iterm}, 689 {F_VOVP, bq->init_data.vovp}, 690 {F_VINDPM, bq->init_data.vindpm}, 691 }; 692 693 /* 694 * Disable the watchdog timer to prevent the IC from going back to 695 * default settings after 50 seconds of I2C inactivity. 696 */ 697 ret = bq24257_field_write(bq, F_WD_EN, 0); 698 if (ret < 0) 699 return ret; 700 701 /* configure the charge currents and voltages */ 702 for (i = 0; i < ARRAY_SIZE(init_data); i++) { 703 ret = bq24257_field_write(bq, init_data[i].field, 704 init_data[i].value); 705 if (ret < 0) 706 return ret; 707 } 708 709 ret = bq24257_get_chip_state(bq, &state); 710 if (ret < 0) 711 return ret; 712 713 mutex_lock(&bq->lock); 714 bq->state = state; 715 mutex_unlock(&bq->lock); 716 717 if (!bq->iilimit_autoset_enable) { 718 dev_dbg(bq->dev, "manually setting iilimit = %u\n", 719 bq->init_data.iilimit); 720 721 /* program fixed input current limit */ 722 ret = bq24257_field_write(bq, F_IILIMIT, 723 bq->init_data.iilimit); 724 if (ret < 0) 725 return ret; 726 } else if (!state.power_good) 727 /* activate D+/D- detection algorithm */ 728 ret = bq24257_field_write(bq, F_DPDM_EN, 1); 729 else if (state.fault != FAULT_NO_BAT) 730 ret = bq24257_iilimit_autoset(bq); 731 732 return ret; 733} 734 735static enum power_supply_property bq24257_power_supply_props[] = { 736 POWER_SUPPLY_PROP_MANUFACTURER, 737 POWER_SUPPLY_PROP_MODEL_NAME, 738 POWER_SUPPLY_PROP_STATUS, 739 POWER_SUPPLY_PROP_ONLINE, 740 POWER_SUPPLY_PROP_HEALTH, 741 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 742 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 743 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 744 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, 745 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, 746 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 747}; 748 749static char *bq24257_charger_supplied_to[] = { 750 "main-battery", 751}; 752 753static const struct power_supply_desc bq24257_power_supply_desc = { 754 .name = "bq24257-charger", 755 .type = POWER_SUPPLY_TYPE_USB, 756 .properties = bq24257_power_supply_props, 757 .num_properties = ARRAY_SIZE(bq24257_power_supply_props), 758 .get_property = bq24257_power_supply_get_property, 759 .set_property = bq24257_power_supply_set_property, 760 .property_is_writeable = bq24257_power_supply_property_is_writeable, 761}; 762 763static ssize_t bq24257_show_ovp_voltage(struct device *dev, 764 struct device_attribute *attr, 765 char *buf) 766{ 767 struct power_supply *psy = dev_get_drvdata(dev); 768 struct bq24257_device *bq = power_supply_get_drvdata(psy); 769 770 return sysfs_emit(buf, "%u\n", bq24257_vovp_map[bq->init_data.vovp]); 771} 772 773static ssize_t bq24257_show_in_dpm_voltage(struct device *dev, 774 struct device_attribute *attr, 775 char *buf) 776{ 777 struct power_supply *psy = dev_get_drvdata(dev); 778 struct bq24257_device *bq = power_supply_get_drvdata(psy); 779 780 return sysfs_emit(buf, "%u\n", bq24257_vindpm_map[bq->init_data.vindpm]); 781} 782 783static ssize_t bq24257_sysfs_show_enable(struct device *dev, 784 struct device_attribute *attr, 785 char *buf) 786{ 787 struct power_supply *psy = dev_get_drvdata(dev); 788 struct bq24257_device *bq = power_supply_get_drvdata(psy); 789 int ret; 790 791 if (strcmp(attr->attr.name, "high_impedance_enable") == 0) 792 ret = bq24257_field_read(bq, F_HZ_MODE); 793 else if (strcmp(attr->attr.name, "sysoff_enable") == 0) 794 ret = bq24257_field_read(bq, F_SYSOFF); 795 else 796 return -EINVAL; 797 798 if (ret < 0) 799 return ret; 800 801 return sysfs_emit(buf, "%d\n", ret); 802} 803 804static ssize_t bq24257_sysfs_set_enable(struct device *dev, 805 struct device_attribute *attr, 806 const char *buf, 807 size_t count) 808{ 809 struct power_supply *psy = dev_get_drvdata(dev); 810 struct bq24257_device *bq = power_supply_get_drvdata(psy); 811 long val; 812 int ret; 813 814 if (kstrtol(buf, 10, &val) < 0) 815 return -EINVAL; 816 817 if (strcmp(attr->attr.name, "high_impedance_enable") == 0) 818 ret = bq24257_field_write(bq, F_HZ_MODE, (bool)val); 819 else if (strcmp(attr->attr.name, "sysoff_enable") == 0) 820 ret = bq24257_field_write(bq, F_SYSOFF, (bool)val); 821 else 822 return -EINVAL; 823 824 if (ret < 0) 825 return ret; 826 827 return count; 828} 829 830static DEVICE_ATTR(ovp_voltage, S_IRUGO, bq24257_show_ovp_voltage, NULL); 831static DEVICE_ATTR(in_dpm_voltage, S_IRUGO, bq24257_show_in_dpm_voltage, NULL); 832static DEVICE_ATTR(high_impedance_enable, S_IWUSR | S_IRUGO, 833 bq24257_sysfs_show_enable, bq24257_sysfs_set_enable); 834static DEVICE_ATTR(sysoff_enable, S_IWUSR | S_IRUGO, 835 bq24257_sysfs_show_enable, bq24257_sysfs_set_enable); 836 837static struct attribute *bq24257_charger_sysfs_attrs[] = { 838 &dev_attr_ovp_voltage.attr, 839 &dev_attr_in_dpm_voltage.attr, 840 &dev_attr_high_impedance_enable.attr, 841 &dev_attr_sysoff_enable.attr, 842 NULL, 843}; 844 845ATTRIBUTE_GROUPS(bq24257_charger_sysfs); 846 847static int bq24257_power_supply_init(struct bq24257_device *bq) 848{ 849 struct power_supply_config psy_cfg = { .drv_data = bq, }; 850 851 psy_cfg.attr_grp = bq24257_charger_sysfs_groups; 852 psy_cfg.supplied_to = bq24257_charger_supplied_to; 853 psy_cfg.num_supplicants = ARRAY_SIZE(bq24257_charger_supplied_to); 854 855 bq->charger = devm_power_supply_register(bq->dev, 856 &bq24257_power_supply_desc, 857 &psy_cfg); 858 859 return PTR_ERR_OR_ZERO(bq->charger); 860} 861 862static void bq24257_pg_gpio_probe(struct bq24257_device *bq) 863{ 864 bq->pg = devm_gpiod_get_optional(bq->dev, BQ24257_PG_GPIO, GPIOD_IN); 865 866 if (PTR_ERR(bq->pg) == -EPROBE_DEFER) { 867 dev_info(bq->dev, "probe retry requested for PG pin\n"); 868 return; 869 } else if (IS_ERR(bq->pg)) { 870 dev_err(bq->dev, "error probing PG pin\n"); 871 bq->pg = NULL; 872 return; 873 } 874 875 if (bq->pg) 876 dev_dbg(bq->dev, "probed PG pin = %d\n", desc_to_gpio(bq->pg)); 877} 878 879static int bq24257_fw_probe(struct bq24257_device *bq) 880{ 881 int ret; 882 u32 property; 883 884 /* Required properties */ 885 ret = device_property_read_u32(bq->dev, "ti,charge-current", &property); 886 if (ret < 0) 887 return ret; 888 889 bq->init_data.ichg = bq24257_find_idx(property, bq24257_ichg_map, 890 BQ24257_ICHG_MAP_SIZE); 891 892 ret = device_property_read_u32(bq->dev, "ti,battery-regulation-voltage", 893 &property); 894 if (ret < 0) 895 return ret; 896 897 bq->init_data.vbat = bq24257_find_idx(property, bq24257_vbat_map, 898 BQ24257_VBAT_MAP_SIZE); 899 900 ret = device_property_read_u32(bq->dev, "ti,termination-current", 901 &property); 902 if (ret < 0) 903 return ret; 904 905 bq->init_data.iterm = bq24257_find_idx(property, bq24257_iterm_map, 906 BQ24257_ITERM_MAP_SIZE); 907 908 /* Optional properties. If not provided use reasonable default. */ 909 ret = device_property_read_u32(bq->dev, "ti,current-limit", 910 &property); 911 if (ret < 0) { 912 bq->iilimit_autoset_enable = true; 913 914 /* 915 * Explicitly set a default value which will be needed for 916 * devices that don't support the automatic setting of the input 917 * current limit through the charger type detection mechanism. 918 */ 919 bq->init_data.iilimit = IILIMIT_500; 920 } else 921 bq->init_data.iilimit = 922 bq24257_find_idx(property, 923 bq24257_iilimit_map, 924 BQ24257_IILIMIT_MAP_SIZE); 925 926 ret = device_property_read_u32(bq->dev, "ti,ovp-voltage", 927 &property); 928 if (ret < 0) 929 bq->init_data.vovp = VOVP_6500; 930 else 931 bq->init_data.vovp = bq24257_find_idx(property, 932 bq24257_vovp_map, 933 BQ24257_VOVP_MAP_SIZE); 934 935 ret = device_property_read_u32(bq->dev, "ti,in-dpm-voltage", 936 &property); 937 if (ret < 0) 938 bq->init_data.vindpm = VINDPM_4360; 939 else 940 bq->init_data.vindpm = 941 bq24257_find_idx(property, 942 bq24257_vindpm_map, 943 BQ24257_VINDPM_MAP_SIZE); 944 945 return 0; 946} 947 948static int bq24257_probe(struct i2c_client *client) 949{ 950 const struct i2c_device_id *id = i2c_client_get_device_id(client); 951 struct i2c_adapter *adapter = client->adapter; 952 struct device *dev = &client->dev; 953 const struct acpi_device_id *acpi_id; 954 struct bq24257_device *bq; 955 int ret; 956 int i; 957 958 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 959 dev_err(dev, "No support for SMBUS_BYTE_DATA\n"); 960 return -ENODEV; 961 } 962 963 bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL); 964 if (!bq) 965 return -ENOMEM; 966 967 bq->client = client; 968 bq->dev = dev; 969 970 if (ACPI_HANDLE(dev)) { 971 acpi_id = acpi_match_device(dev->driver->acpi_match_table, 972 &client->dev); 973 if (!acpi_id) { 974 dev_err(dev, "Failed to match ACPI device\n"); 975 return -ENODEV; 976 } 977 bq->chip = (enum bq2425x_chip)acpi_id->driver_data; 978 } else { 979 bq->chip = (enum bq2425x_chip)id->driver_data; 980 } 981 982 mutex_init(&bq->lock); 983 984 bq->rmap = devm_regmap_init_i2c(client, &bq24257_regmap_config); 985 if (IS_ERR(bq->rmap)) { 986 dev_err(dev, "failed to allocate register map\n"); 987 return PTR_ERR(bq->rmap); 988 } 989 990 for (i = 0; i < ARRAY_SIZE(bq24257_reg_fields); i++) { 991 const struct reg_field *reg_fields = bq24257_reg_fields; 992 993 bq->rmap_fields[i] = devm_regmap_field_alloc(dev, bq->rmap, 994 reg_fields[i]); 995 if (IS_ERR(bq->rmap_fields[i])) { 996 dev_err(dev, "cannot allocate regmap field\n"); 997 return PTR_ERR(bq->rmap_fields[i]); 998 } 999 } 1000 1001 i2c_set_clientdata(client, bq); 1002 1003 if (!dev->platform_data) { 1004 ret = bq24257_fw_probe(bq); 1005 if (ret < 0) { 1006 dev_err(dev, "Cannot read device properties.\n"); 1007 return ret; 1008 } 1009 } else { 1010 return -ENODEV; 1011 } 1012 1013 /* 1014 * The BQ24250 doesn't support the D+/D- based charger type detection 1015 * used for the automatic setting of the input current limit setting so 1016 * explicitly disable that feature. 1017 */ 1018 if (bq->chip == BQ24250) 1019 bq->iilimit_autoset_enable = false; 1020 1021 if (bq->iilimit_autoset_enable) 1022 INIT_DELAYED_WORK(&bq->iilimit_setup_work, 1023 bq24257_iilimit_setup_work); 1024 1025 /* 1026 * The BQ24250 doesn't have a dedicated Power Good (PG) pin so let's 1027 * not probe for it and instead use a SW-based approach to determine 1028 * the PG state. We also use a SW-based approach for all other devices 1029 * if the PG pin is either not defined or can't be probed. 1030 */ 1031 if (bq->chip != BQ24250) 1032 bq24257_pg_gpio_probe(bq); 1033 1034 if (PTR_ERR(bq->pg) == -EPROBE_DEFER) 1035 return PTR_ERR(bq->pg); 1036 else if (!bq->pg) 1037 dev_info(bq->dev, "using SW-based power-good detection\n"); 1038 1039 /* reset all registers to defaults */ 1040 ret = bq24257_field_write(bq, F_RESET, 1); 1041 if (ret < 0) 1042 return ret; 1043 1044 /* 1045 * Put the RESET bit back to 0, in cache. For some reason the HW always 1046 * returns 1 on this bit, so this is the only way to avoid resetting the 1047 * chip every time we update another field in this register. 1048 */ 1049 ret = bq24257_field_write(bq, F_RESET, 0); 1050 if (ret < 0) 1051 return ret; 1052 1053 ret = bq24257_hw_init(bq); 1054 if (ret < 0) { 1055 dev_err(dev, "Cannot initialize the chip.\n"); 1056 return ret; 1057 } 1058 1059 ret = bq24257_power_supply_init(bq); 1060 if (ret < 0) { 1061 dev_err(dev, "Failed to register power supply\n"); 1062 return ret; 1063 } 1064 1065 ret = devm_request_threaded_irq(dev, client->irq, NULL, 1066 bq24257_irq_handler_thread, 1067 IRQF_TRIGGER_FALLING | 1068 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 1069 bq2425x_chip_name[bq->chip], bq); 1070 if (ret) { 1071 dev_err(dev, "Failed to request IRQ #%d\n", client->irq); 1072 return ret; 1073 } 1074 1075 return 0; 1076} 1077 1078static void bq24257_remove(struct i2c_client *client) 1079{ 1080 struct bq24257_device *bq = i2c_get_clientdata(client); 1081 1082 if (bq->iilimit_autoset_enable) 1083 cancel_delayed_work_sync(&bq->iilimit_setup_work); 1084 1085 bq24257_field_write(bq, F_RESET, 1); /* reset to defaults */ 1086} 1087 1088#ifdef CONFIG_PM_SLEEP 1089static int bq24257_suspend(struct device *dev) 1090{ 1091 struct bq24257_device *bq = dev_get_drvdata(dev); 1092 int ret = 0; 1093 1094 if (bq->iilimit_autoset_enable) 1095 cancel_delayed_work_sync(&bq->iilimit_setup_work); 1096 1097 /* reset all registers to default (and activate standalone mode) */ 1098 ret = bq24257_field_write(bq, F_RESET, 1); 1099 if (ret < 0) 1100 dev_err(bq->dev, "Cannot reset chip to standalone mode.\n"); 1101 1102 return ret; 1103} 1104 1105static int bq24257_resume(struct device *dev) 1106{ 1107 int ret; 1108 struct bq24257_device *bq = dev_get_drvdata(dev); 1109 1110 ret = regcache_drop_region(bq->rmap, BQ24257_REG_1, BQ24257_REG_7); 1111 if (ret < 0) 1112 return ret; 1113 1114 ret = bq24257_field_write(bq, F_RESET, 0); 1115 if (ret < 0) 1116 return ret; 1117 1118 ret = bq24257_hw_init(bq); 1119 if (ret < 0) { 1120 dev_err(bq->dev, "Cannot init chip after resume.\n"); 1121 return ret; 1122 } 1123 1124 /* signal userspace, maybe state changed while suspended */ 1125 power_supply_changed(bq->charger); 1126 1127 return 0; 1128} 1129#endif 1130 1131static const struct dev_pm_ops bq24257_pm = { 1132 SET_SYSTEM_SLEEP_PM_OPS(bq24257_suspend, bq24257_resume) 1133}; 1134 1135static const struct i2c_device_id bq24257_i2c_ids[] = { 1136 { "bq24250", BQ24250 }, 1137 { "bq24251", BQ24251 }, 1138 { "bq24257", BQ24257 }, 1139 {}, 1140}; 1141MODULE_DEVICE_TABLE(i2c, bq24257_i2c_ids); 1142 1143static const struct of_device_id bq24257_of_match[] __maybe_unused = { 1144 { .compatible = "ti,bq24250", }, 1145 { .compatible = "ti,bq24251", }, 1146 { .compatible = "ti,bq24257", }, 1147 { }, 1148}; 1149MODULE_DEVICE_TABLE(of, bq24257_of_match); 1150 1151#ifdef CONFIG_ACPI 1152static const struct acpi_device_id bq24257_acpi_match[] = { 1153 { "BQ242500", BQ24250 }, 1154 { "BQ242510", BQ24251 }, 1155 { "BQ242570", BQ24257 }, 1156 {}, 1157}; 1158MODULE_DEVICE_TABLE(acpi, bq24257_acpi_match); 1159#endif 1160 1161static struct i2c_driver bq24257_driver = { 1162 .driver = { 1163 .name = "bq24257-charger", 1164 .of_match_table = of_match_ptr(bq24257_of_match), 1165 .acpi_match_table = ACPI_PTR(bq24257_acpi_match), 1166 .pm = &bq24257_pm, 1167 }, 1168 .probe = bq24257_probe, 1169 .remove = bq24257_remove, 1170 .id_table = bq24257_i2c_ids, 1171}; 1172module_i2c_driver(bq24257_driver); 1173 1174MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>"); 1175MODULE_DESCRIPTION("bq24257 charger driver"); 1176MODULE_LICENSE("GPL"); 1177