1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (c) 2014, Sony Mobile Communications Inc. 3 * 4 * This driver is for the multi-block Switch-Mode Battery Charger and Boost 5 * (SMBB) hardware, found in Qualcomm PM8941 PMICs. The charger is an 6 * integrated, single-cell lithium-ion battery charger. 7 * 8 * Sub-components: 9 * - Charger core 10 * - Buck 11 * - DC charge-path 12 * - USB charge-path 13 * - Battery interface 14 * - Boost (not implemented) 15 * - Misc 16 * - HF-Buck 17 */ 18 19 #include <linux/errno.h> 20 #include <linux/interrupt.h> 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/mutex.h> 24 #include <linux/of.h> 25 #include <linux/platform_device.h> 26 #include <linux/power_supply.h> 27 #include <linux/regmap.h> 28 #include <linux/slab.h> 29 #include <linux/extcon-provider.h> 30 #include <linux/regulator/driver.h> 31 32 #define SMBB_CHG_VMAX 0x040 33 #define SMBB_CHG_VSAFE 0x041 34 #define SMBB_CHG_CFG 0x043 35 #define SMBB_CHG_IMAX 0x044 36 #define SMBB_CHG_ISAFE 0x045 37 #define SMBB_CHG_VIN_MIN 0x047 38 #define SMBB_CHG_CTRL 0x049 39 #define CTRL_EN BIT(7) 40 #define SMBB_CHG_VBAT_WEAK 0x052 41 #define SMBB_CHG_IBAT_TERM_CHG 0x05b 42 #define IBAT_TERM_CHG_IEOC BIT(7) 43 #define IBAT_TERM_CHG_IEOC_BMS BIT(7) 44 #define IBAT_TERM_CHG_IEOC_CHG 0 45 #define SMBB_CHG_VBAT_DET 0x05d 46 #define SMBB_CHG_TCHG_MAX_EN 0x060 47 #define TCHG_MAX_EN BIT(7) 48 #define SMBB_CHG_WDOG_TIME 0x062 49 #define SMBB_CHG_WDOG_EN 0x065 50 #define WDOG_EN BIT(7) 51 52 #define SMBB_BUCK_REG_MODE 0x174 53 #define BUCK_REG_MODE BIT(0) 54 #define BUCK_REG_MODE_VBAT BIT(0) 55 #define BUCK_REG_MODE_VSYS 0 56 57 #define SMBB_BAT_PRES_STATUS 0x208 58 #define PRES_STATUS_BAT_PRES BIT(7) 59 #define SMBB_BAT_TEMP_STATUS 0x209 60 #define TEMP_STATUS_OK BIT(7) 61 #define TEMP_STATUS_HOT BIT(6) 62 #define SMBB_BAT_BTC_CTRL 0x249 63 #define BTC_CTRL_COMP_EN BIT(7) 64 #define BTC_CTRL_COLD_EXT BIT(1) 65 #define BTC_CTRL_HOT_EXT_N BIT(0) 66 67 #define SMBB_USB_IMAX 0x344 68 #define SMBB_USB_OTG_CTL 0x348 69 #define OTG_CTL_EN BIT(0) 70 #define SMBB_USB_ENUM_TIMER_STOP 0x34e 71 #define ENUM_TIMER_STOP BIT(0) 72 #define SMBB_USB_SEC_ACCESS 0x3d0 73 #define SEC_ACCESS_MAGIC 0xa5 74 #define SMBB_USB_REV_BST 0x3ed 75 #define REV_BST_CHG_GONE BIT(7) 76 77 #define SMBB_DC_IMAX 0x444 78 79 #define SMBB_MISC_REV2 0x601 80 #define SMBB_MISC_BOOT_DONE 0x642 81 #define BOOT_DONE BIT(7) 82 83 #define STATUS_USBIN_VALID BIT(0) /* USB connection is valid */ 84 #define STATUS_DCIN_VALID BIT(1) /* DC connection is valid */ 85 #define STATUS_BAT_HOT BIT(2) /* Battery temp 1=Hot, 0=Cold */ 86 #define STATUS_BAT_OK BIT(3) /* Battery temp OK */ 87 #define STATUS_BAT_PRESENT BIT(4) /* Battery is present */ 88 #define STATUS_CHG_DONE BIT(5) /* Charge cycle is complete */ 89 #define STATUS_CHG_TRKL BIT(6) /* Trickle charging */ 90 #define STATUS_CHG_FAST BIT(7) /* Fast charging */ 91 #define STATUS_CHG_GONE BIT(8) /* No charger is connected */ 92 93 enum smbb_attr { 94 ATTR_BAT_ISAFE, 95 ATTR_BAT_IMAX, 96 ATTR_USBIN_IMAX, 97 ATTR_DCIN_IMAX, 98 ATTR_BAT_VSAFE, 99 ATTR_BAT_VMAX, 100 ATTR_BAT_VMIN, 101 ATTR_CHG_VDET, 102 ATTR_VIN_MIN, 103 _ATTR_CNT, 104 }; 105 106 struct smbb_charger { 107 unsigned int revision; 108 unsigned int addr; 109 struct device *dev; 110 struct extcon_dev *edev; 111 112 bool dc_disabled; 113 bool jeita_ext_temp; 114 unsigned long status; 115 struct mutex statlock; 116 117 unsigned int attr[_ATTR_CNT]; 118 119 struct power_supply *usb_psy; 120 struct power_supply *dc_psy; 121 struct power_supply *bat_psy; 122 struct regmap *regmap; 123 124 struct regulator_desc otg_rdesc; 125 struct regulator_dev *otg_reg; 126 }; 127 128 static const unsigned int smbb_usb_extcon_cable[] = { 129 EXTCON_USB, 130 EXTCON_NONE, 131 }; 132 133 static int smbb_vbat_weak_fn(unsigned int index) 134 { 135 return 2100000 + index * 100000; 136 } 137 138 static int smbb_vin_fn(unsigned int index) 139 { 140 if (index > 42) 141 return 5600000 + (index - 43) * 200000; 142 return 3400000 + index * 50000; 143 } 144 145 static int smbb_vmax_fn(unsigned int index) 146 { 147 return 3240000 + index * 10000; 148 } 149 150 static int smbb_vbat_det_fn(unsigned int index) 151 { 152 return 3240000 + index * 20000; 153 } 154 155 static int smbb_imax_fn(unsigned int index) 156 { 157 if (index < 2) 158 return 100000 + index * 50000; 159 return index * 100000; 160 } 161 162 static int smbb_bat_imax_fn(unsigned int index) 163 { 164 return index * 50000; 165 } 166 167 static unsigned int smbb_hw_lookup(unsigned int val, int (*fn)(unsigned int)) 168 { 169 unsigned int widx; 170 unsigned int sel; 171 172 for (widx = sel = 0; (*fn)(widx) <= val; ++widx) 173 sel = widx; 174 175 return sel; 176 } 177 178 static const struct smbb_charger_attr { 179 const char *name; 180 unsigned int reg; 181 unsigned int safe_reg; 182 unsigned int max; 183 unsigned int min; 184 unsigned int fail_ok; 185 int (*hw_fn)(unsigned int); 186 } smbb_charger_attrs[] = { 187 [ATTR_BAT_ISAFE] = { 188 .name = "qcom,fast-charge-safe-current", 189 .reg = SMBB_CHG_ISAFE, 190 .max = 3000000, 191 .min = 200000, 192 .hw_fn = smbb_bat_imax_fn, 193 .fail_ok = 1, 194 }, 195 [ATTR_BAT_IMAX] = { 196 .name = "qcom,fast-charge-current-limit", 197 .reg = SMBB_CHG_IMAX, 198 .safe_reg = SMBB_CHG_ISAFE, 199 .max = 3000000, 200 .min = 200000, 201 .hw_fn = smbb_bat_imax_fn, 202 }, 203 [ATTR_DCIN_IMAX] = { 204 .name = "qcom,dc-current-limit", 205 .reg = SMBB_DC_IMAX, 206 .max = 2500000, 207 .min = 100000, 208 .hw_fn = smbb_imax_fn, 209 }, 210 [ATTR_BAT_VSAFE] = { 211 .name = "qcom,fast-charge-safe-voltage", 212 .reg = SMBB_CHG_VSAFE, 213 .max = 5000000, 214 .min = 3240000, 215 .hw_fn = smbb_vmax_fn, 216 .fail_ok = 1, 217 }, 218 [ATTR_BAT_VMAX] = { 219 .name = "qcom,fast-charge-high-threshold-voltage", 220 .reg = SMBB_CHG_VMAX, 221 .safe_reg = SMBB_CHG_VSAFE, 222 .max = 5000000, 223 .min = 3240000, 224 .hw_fn = smbb_vmax_fn, 225 }, 226 [ATTR_BAT_VMIN] = { 227 .name = "qcom,fast-charge-low-threshold-voltage", 228 .reg = SMBB_CHG_VBAT_WEAK, 229 .max = 3600000, 230 .min = 2100000, 231 .hw_fn = smbb_vbat_weak_fn, 232 }, 233 [ATTR_CHG_VDET] = { 234 .name = "qcom,auto-recharge-threshold-voltage", 235 .reg = SMBB_CHG_VBAT_DET, 236 .max = 5000000, 237 .min = 3240000, 238 .hw_fn = smbb_vbat_det_fn, 239 }, 240 [ATTR_VIN_MIN] = { 241 .name = "qcom,minimum-input-voltage", 242 .reg = SMBB_CHG_VIN_MIN, 243 .max = 9600000, 244 .min = 4200000, 245 .hw_fn = smbb_vin_fn, 246 }, 247 [ATTR_USBIN_IMAX] = { 248 .name = "usb-charge-current-limit", 249 .reg = SMBB_USB_IMAX, 250 .max = 2500000, 251 .min = 100000, 252 .hw_fn = smbb_imax_fn, 253 }, 254 }; 255 256 static int smbb_charger_attr_write(struct smbb_charger *chg, 257 enum smbb_attr which, unsigned int val) 258 { 259 const struct smbb_charger_attr *prop; 260 unsigned int wval; 261 unsigned int out; 262 int rc; 263 264 prop = &smbb_charger_attrs[which]; 265 266 if (val > prop->max || val < prop->min) { 267 dev_err(chg->dev, "value out of range for %s [%u:%u]\n", 268 prop->name, prop->min, prop->max); 269 return -EINVAL; 270 } 271 272 if (prop->safe_reg) { 273 rc = regmap_read(chg->regmap, 274 chg->addr + prop->safe_reg, &wval); 275 if (rc) { 276 dev_err(chg->dev, 277 "unable to read safe value for '%s'\n", 278 prop->name); 279 return rc; 280 } 281 282 wval = prop->hw_fn(wval); 283 284 if (val > wval) { 285 dev_warn(chg->dev, 286 "%s above safe value, clamping at %u\n", 287 prop->name, wval); 288 val = wval; 289 } 290 } 291 292 wval = smbb_hw_lookup(val, prop->hw_fn); 293 294 rc = regmap_write(chg->regmap, chg->addr + prop->reg, wval); 295 if (rc) { 296 dev_err(chg->dev, "unable to update %s", prop->name); 297 return rc; 298 } 299 out = prop->hw_fn(wval); 300 if (out != val) { 301 dev_warn(chg->dev, 302 "%s inaccurate, rounded to %u\n", 303 prop->name, out); 304 } 305 306 dev_dbg(chg->dev, "%s <= %d\n", prop->name, out); 307 308 chg->attr[which] = out; 309 310 return 0; 311 } 312 313 static int smbb_charger_attr_read(struct smbb_charger *chg, 314 enum smbb_attr which) 315 { 316 const struct smbb_charger_attr *prop; 317 unsigned int val; 318 int rc; 319 320 prop = &smbb_charger_attrs[which]; 321 322 rc = regmap_read(chg->regmap, chg->addr + prop->reg, &val); 323 if (rc) { 324 dev_err(chg->dev, "failed to read %s\n", prop->name); 325 return rc; 326 } 327 val = prop->hw_fn(val); 328 dev_dbg(chg->dev, "%s => %d\n", prop->name, val); 329 330 chg->attr[which] = val; 331 332 return 0; 333 } 334 335 static int smbb_charger_attr_parse(struct smbb_charger *chg, 336 enum smbb_attr which) 337 { 338 const struct smbb_charger_attr *prop; 339 unsigned int val; 340 int rc; 341 342 prop = &smbb_charger_attrs[which]; 343 344 rc = of_property_read_u32(chg->dev->of_node, prop->name, &val); 345 if (rc == 0) { 346 rc = smbb_charger_attr_write(chg, which, val); 347 if (!rc || !prop->fail_ok) 348 return rc; 349 } 350 return smbb_charger_attr_read(chg, which); 351 } 352 353 static void smbb_set_line_flag(struct smbb_charger *chg, int irq, int flag) 354 { 355 bool state; 356 int ret; 357 358 ret = irq_get_irqchip_state(irq, IRQCHIP_STATE_LINE_LEVEL, &state); 359 if (ret < 0) { 360 dev_err(chg->dev, "failed to read irq line\n"); 361 return; 362 } 363 364 mutex_lock(&chg->statlock); 365 if (state) 366 chg->status |= flag; 367 else 368 chg->status &= ~flag; 369 mutex_unlock(&chg->statlock); 370 371 dev_dbg(chg->dev, "status = %03lx\n", chg->status); 372 } 373 374 static irqreturn_t smbb_usb_valid_handler(int irq, void *_data) 375 { 376 struct smbb_charger *chg = _data; 377 378 smbb_set_line_flag(chg, irq, STATUS_USBIN_VALID); 379 extcon_set_state_sync(chg->edev, EXTCON_USB, 380 chg->status & STATUS_USBIN_VALID); 381 power_supply_changed(chg->usb_psy); 382 383 return IRQ_HANDLED; 384 } 385 386 static irqreturn_t smbb_dc_valid_handler(int irq, void *_data) 387 { 388 struct smbb_charger *chg = _data; 389 390 smbb_set_line_flag(chg, irq, STATUS_DCIN_VALID); 391 if (!chg->dc_disabled) 392 power_supply_changed(chg->dc_psy); 393 394 return IRQ_HANDLED; 395 } 396 397 static irqreturn_t smbb_bat_temp_handler(int irq, void *_data) 398 { 399 struct smbb_charger *chg = _data; 400 unsigned int val; 401 int rc; 402 403 rc = regmap_read(chg->regmap, chg->addr + SMBB_BAT_TEMP_STATUS, &val); 404 if (rc) 405 return IRQ_HANDLED; 406 407 mutex_lock(&chg->statlock); 408 if (val & TEMP_STATUS_OK) { 409 chg->status |= STATUS_BAT_OK; 410 } else { 411 chg->status &= ~STATUS_BAT_OK; 412 if (val & TEMP_STATUS_HOT) 413 chg->status |= STATUS_BAT_HOT; 414 } 415 mutex_unlock(&chg->statlock); 416 417 power_supply_changed(chg->bat_psy); 418 return IRQ_HANDLED; 419 } 420 421 static irqreturn_t smbb_bat_present_handler(int irq, void *_data) 422 { 423 struct smbb_charger *chg = _data; 424 425 smbb_set_line_flag(chg, irq, STATUS_BAT_PRESENT); 426 power_supply_changed(chg->bat_psy); 427 428 return IRQ_HANDLED; 429 } 430 431 static irqreturn_t smbb_chg_done_handler(int irq, void *_data) 432 { 433 struct smbb_charger *chg = _data; 434 435 smbb_set_line_flag(chg, irq, STATUS_CHG_DONE); 436 power_supply_changed(chg->bat_psy); 437 438 return IRQ_HANDLED; 439 } 440 441 static irqreturn_t smbb_chg_gone_handler(int irq, void *_data) 442 { 443 struct smbb_charger *chg = _data; 444 445 smbb_set_line_flag(chg, irq, STATUS_CHG_GONE); 446 power_supply_changed(chg->bat_psy); 447 power_supply_changed(chg->usb_psy); 448 if (!chg->dc_disabled) 449 power_supply_changed(chg->dc_psy); 450 451 return IRQ_HANDLED; 452 } 453 454 static irqreturn_t smbb_chg_fast_handler(int irq, void *_data) 455 { 456 struct smbb_charger *chg = _data; 457 458 smbb_set_line_flag(chg, irq, STATUS_CHG_FAST); 459 power_supply_changed(chg->bat_psy); 460 461 return IRQ_HANDLED; 462 } 463 464 static irqreturn_t smbb_chg_trkl_handler(int irq, void *_data) 465 { 466 struct smbb_charger *chg = _data; 467 468 smbb_set_line_flag(chg, irq, STATUS_CHG_TRKL); 469 power_supply_changed(chg->bat_psy); 470 471 return IRQ_HANDLED; 472 } 473 474 static const struct smbb_irq { 475 const char *name; 476 irqreturn_t (*handler)(int, void *); 477 } smbb_charger_irqs[] = { 478 { "chg-done", smbb_chg_done_handler }, 479 { "chg-fast", smbb_chg_fast_handler }, 480 { "chg-trkl", smbb_chg_trkl_handler }, 481 { "bat-temp-ok", smbb_bat_temp_handler }, 482 { "bat-present", smbb_bat_present_handler }, 483 { "chg-gone", smbb_chg_gone_handler }, 484 { "usb-valid", smbb_usb_valid_handler }, 485 { "dc-valid", smbb_dc_valid_handler }, 486 }; 487 488 static int smbb_usbin_get_property(struct power_supply *psy, 489 enum power_supply_property psp, 490 union power_supply_propval *val) 491 { 492 struct smbb_charger *chg = power_supply_get_drvdata(psy); 493 int rc = 0; 494 495 switch (psp) { 496 case POWER_SUPPLY_PROP_ONLINE: 497 mutex_lock(&chg->statlock); 498 val->intval = !(chg->status & STATUS_CHG_GONE) && 499 (chg->status & STATUS_USBIN_VALID); 500 mutex_unlock(&chg->statlock); 501 break; 502 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT: 503 val->intval = chg->attr[ATTR_USBIN_IMAX]; 504 break; 505 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX: 506 val->intval = 2500000; 507 break; 508 default: 509 rc = -EINVAL; 510 break; 511 } 512 513 return rc; 514 } 515 516 static int smbb_usbin_set_property(struct power_supply *psy, 517 enum power_supply_property psp, 518 const union power_supply_propval *val) 519 { 520 struct smbb_charger *chg = power_supply_get_drvdata(psy); 521 int rc; 522 523 switch (psp) { 524 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT: 525 rc = smbb_charger_attr_write(chg, ATTR_USBIN_IMAX, 526 val->intval); 527 break; 528 default: 529 rc = -EINVAL; 530 break; 531 } 532 533 return rc; 534 } 535 536 static int smbb_dcin_get_property(struct power_supply *psy, 537 enum power_supply_property psp, 538 union power_supply_propval *val) 539 { 540 struct smbb_charger *chg = power_supply_get_drvdata(psy); 541 int rc = 0; 542 543 switch (psp) { 544 case POWER_SUPPLY_PROP_ONLINE: 545 mutex_lock(&chg->statlock); 546 val->intval = !(chg->status & STATUS_CHG_GONE) && 547 (chg->status & STATUS_DCIN_VALID); 548 mutex_unlock(&chg->statlock); 549 break; 550 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT: 551 val->intval = chg->attr[ATTR_DCIN_IMAX]; 552 break; 553 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX: 554 val->intval = 2500000; 555 break; 556 default: 557 rc = -EINVAL; 558 break; 559 } 560 561 return rc; 562 } 563 564 static int smbb_dcin_set_property(struct power_supply *psy, 565 enum power_supply_property psp, 566 const union power_supply_propval *val) 567 { 568 struct smbb_charger *chg = power_supply_get_drvdata(psy); 569 int rc; 570 571 switch (psp) { 572 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT: 573 rc = smbb_charger_attr_write(chg, ATTR_DCIN_IMAX, 574 val->intval); 575 break; 576 default: 577 rc = -EINVAL; 578 break; 579 } 580 581 return rc; 582 } 583 584 static int smbb_charger_writable_property(struct power_supply *psy, 585 enum power_supply_property psp) 586 { 587 return psp == POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT; 588 } 589 590 static int smbb_battery_get_property(struct power_supply *psy, 591 enum power_supply_property psp, 592 union power_supply_propval *val) 593 { 594 struct smbb_charger *chg = power_supply_get_drvdata(psy); 595 unsigned long status; 596 int rc = 0; 597 598 mutex_lock(&chg->statlock); 599 status = chg->status; 600 mutex_unlock(&chg->statlock); 601 602 switch (psp) { 603 case POWER_SUPPLY_PROP_STATUS: 604 if (status & STATUS_CHG_GONE) 605 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 606 else if (!(status & (STATUS_DCIN_VALID | STATUS_USBIN_VALID))) 607 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 608 else if (status & STATUS_CHG_DONE) 609 val->intval = POWER_SUPPLY_STATUS_FULL; 610 else if (!(status & STATUS_BAT_OK)) 611 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 612 else if (status & (STATUS_CHG_FAST | STATUS_CHG_TRKL)) 613 val->intval = POWER_SUPPLY_STATUS_CHARGING; 614 else /* everything is ok for charging, but we are not... */ 615 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 616 break; 617 case POWER_SUPPLY_PROP_HEALTH: 618 if (status & STATUS_BAT_OK) 619 val->intval = POWER_SUPPLY_HEALTH_GOOD; 620 else if (status & STATUS_BAT_HOT) 621 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 622 else 623 val->intval = POWER_SUPPLY_HEALTH_COLD; 624 break; 625 case POWER_SUPPLY_PROP_CHARGE_TYPE: 626 if (status & STATUS_CHG_FAST) 627 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST; 628 else if (status & STATUS_CHG_TRKL) 629 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 630 else 631 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; 632 break; 633 case POWER_SUPPLY_PROP_PRESENT: 634 val->intval = !!(status & STATUS_BAT_PRESENT); 635 break; 636 case POWER_SUPPLY_PROP_CURRENT_MAX: 637 val->intval = chg->attr[ATTR_BAT_IMAX]; 638 break; 639 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 640 val->intval = chg->attr[ATTR_BAT_VMAX]; 641 break; 642 case POWER_SUPPLY_PROP_TECHNOLOGY: 643 /* this charger is a single-cell lithium-ion battery charger 644 * only. If you hook up some other technology, there will be 645 * fireworks. 646 */ 647 val->intval = POWER_SUPPLY_TECHNOLOGY_LION; 648 break; 649 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 650 val->intval = 3000000; /* single-cell li-ion low end */ 651 break; 652 default: 653 rc = -EINVAL; 654 break; 655 } 656 657 return rc; 658 } 659 660 static int smbb_battery_set_property(struct power_supply *psy, 661 enum power_supply_property psp, 662 const union power_supply_propval *val) 663 { 664 struct smbb_charger *chg = power_supply_get_drvdata(psy); 665 int rc; 666 667 switch (psp) { 668 case POWER_SUPPLY_PROP_CURRENT_MAX: 669 rc = smbb_charger_attr_write(chg, ATTR_BAT_IMAX, val->intval); 670 break; 671 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 672 rc = smbb_charger_attr_write(chg, ATTR_BAT_VMAX, val->intval); 673 break; 674 default: 675 rc = -EINVAL; 676 break; 677 } 678 679 return rc; 680 } 681 682 static int smbb_battery_writable_property(struct power_supply *psy, 683 enum power_supply_property psp) 684 { 685 switch (psp) { 686 case POWER_SUPPLY_PROP_CURRENT_MAX: 687 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 688 return 1; 689 default: 690 return 0; 691 } 692 } 693 694 static enum power_supply_property smbb_charger_properties[] = { 695 POWER_SUPPLY_PROP_ONLINE, 696 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, 697 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, 698 }; 699 700 static enum power_supply_property smbb_battery_properties[] = { 701 POWER_SUPPLY_PROP_STATUS, 702 POWER_SUPPLY_PROP_HEALTH, 703 POWER_SUPPLY_PROP_PRESENT, 704 POWER_SUPPLY_PROP_CHARGE_TYPE, 705 POWER_SUPPLY_PROP_CURRENT_MAX, 706 POWER_SUPPLY_PROP_VOLTAGE_MAX, 707 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 708 POWER_SUPPLY_PROP_TECHNOLOGY, 709 }; 710 711 static const struct reg_off_mask_default { 712 unsigned int offset; 713 unsigned int mask; 714 unsigned int value; 715 unsigned int rev_mask; 716 } smbb_charger_setup[] = { 717 /* The bootloader is supposed to set this... make sure anyway. */ 718 { SMBB_MISC_BOOT_DONE, BOOT_DONE, BOOT_DONE }, 719 720 /* Disable software timer */ 721 { SMBB_CHG_TCHG_MAX_EN, TCHG_MAX_EN, 0 }, 722 723 /* Clear and disable watchdog */ 724 { SMBB_CHG_WDOG_TIME, 0xff, 160 }, 725 { SMBB_CHG_WDOG_EN, WDOG_EN, 0 }, 726 727 /* Use charger based EoC detection */ 728 { SMBB_CHG_IBAT_TERM_CHG, IBAT_TERM_CHG_IEOC, IBAT_TERM_CHG_IEOC_CHG }, 729 730 /* Disable GSM PA load adjustment. 731 * The PA signal is incorrectly connected on v2. 732 */ 733 { SMBB_CHG_CFG, 0xff, 0x00, BIT(3) }, 734 735 /* Use VBAT (not VSYS) to compensate for IR drop during fast charging */ 736 { SMBB_BUCK_REG_MODE, BUCK_REG_MODE, BUCK_REG_MODE_VBAT }, 737 738 /* Enable battery temperature comparators */ 739 { SMBB_BAT_BTC_CTRL, BTC_CTRL_COMP_EN, BTC_CTRL_COMP_EN }, 740 741 /* Stop USB enumeration timer */ 742 { SMBB_USB_ENUM_TIMER_STOP, ENUM_TIMER_STOP, ENUM_TIMER_STOP }, 743 744 #if 0 /* FIXME supposedly only to disable hardware ARB termination */ 745 { SMBB_USB_SEC_ACCESS, SEC_ACCESS_MAGIC }, 746 { SMBB_USB_REV_BST, 0xff, REV_BST_CHG_GONE }, 747 #endif 748 749 /* Stop USB enumeration timer, again */ 750 { SMBB_USB_ENUM_TIMER_STOP, ENUM_TIMER_STOP, ENUM_TIMER_STOP }, 751 752 /* Enable charging */ 753 { SMBB_CHG_CTRL, CTRL_EN, CTRL_EN }, 754 }; 755 756 static char *smbb_bif[] = { "smbb-bif" }; 757 758 static const struct power_supply_desc bat_psy_desc = { 759 .name = "smbb-bif", 760 .type = POWER_SUPPLY_TYPE_BATTERY, 761 .properties = smbb_battery_properties, 762 .num_properties = ARRAY_SIZE(smbb_battery_properties), 763 .get_property = smbb_battery_get_property, 764 .set_property = smbb_battery_set_property, 765 .property_is_writeable = smbb_battery_writable_property, 766 }; 767 768 static const struct power_supply_desc usb_psy_desc = { 769 .name = "smbb-usbin", 770 .type = POWER_SUPPLY_TYPE_USB, 771 .properties = smbb_charger_properties, 772 .num_properties = ARRAY_SIZE(smbb_charger_properties), 773 .get_property = smbb_usbin_get_property, 774 .set_property = smbb_usbin_set_property, 775 .property_is_writeable = smbb_charger_writable_property, 776 }; 777 778 static const struct power_supply_desc dc_psy_desc = { 779 .name = "smbb-dcin", 780 .type = POWER_SUPPLY_TYPE_MAINS, 781 .properties = smbb_charger_properties, 782 .num_properties = ARRAY_SIZE(smbb_charger_properties), 783 .get_property = smbb_dcin_get_property, 784 .set_property = smbb_dcin_set_property, 785 .property_is_writeable = smbb_charger_writable_property, 786 }; 787 788 static int smbb_chg_otg_enable(struct regulator_dev *rdev) 789 { 790 struct smbb_charger *chg = rdev_get_drvdata(rdev); 791 int rc; 792 793 rc = regmap_update_bits(chg->regmap, chg->addr + SMBB_USB_OTG_CTL, 794 OTG_CTL_EN, OTG_CTL_EN); 795 if (rc) 796 dev_err(chg->dev, "failed to update OTG_CTL\n"); 797 return rc; 798 } 799 800 static int smbb_chg_otg_disable(struct regulator_dev *rdev) 801 { 802 struct smbb_charger *chg = rdev_get_drvdata(rdev); 803 int rc; 804 805 rc = regmap_update_bits(chg->regmap, chg->addr + SMBB_USB_OTG_CTL, 806 OTG_CTL_EN, 0); 807 if (rc) 808 dev_err(chg->dev, "failed to update OTG_CTL\n"); 809 return rc; 810 } 811 812 static int smbb_chg_otg_is_enabled(struct regulator_dev *rdev) 813 { 814 struct smbb_charger *chg = rdev_get_drvdata(rdev); 815 unsigned int value = 0; 816 int rc; 817 818 rc = regmap_read(chg->regmap, chg->addr + SMBB_USB_OTG_CTL, &value); 819 if (rc) 820 dev_err(chg->dev, "failed to read OTG_CTL\n"); 821 822 return !!(value & OTG_CTL_EN); 823 } 824 825 static const struct regulator_ops smbb_chg_otg_ops = { 826 .enable = smbb_chg_otg_enable, 827 .disable = smbb_chg_otg_disable, 828 .is_enabled = smbb_chg_otg_is_enabled, 829 }; 830 831 static int smbb_charger_probe(struct platform_device *pdev) 832 { 833 struct power_supply_config bat_cfg = {}; 834 struct power_supply_config usb_cfg = {}; 835 struct power_supply_config dc_cfg = {}; 836 struct smbb_charger *chg; 837 struct regulator_config config = { }; 838 int rc, i; 839 840 chg = devm_kzalloc(&pdev->dev, sizeof(*chg), GFP_KERNEL); 841 if (!chg) 842 return -ENOMEM; 843 844 chg->dev = &pdev->dev; 845 mutex_init(&chg->statlock); 846 847 chg->regmap = dev_get_regmap(pdev->dev.parent, NULL); 848 if (!chg->regmap) { 849 dev_err(&pdev->dev, "failed to locate regmap\n"); 850 return -ENODEV; 851 } 852 853 rc = of_property_read_u32(pdev->dev.of_node, "reg", &chg->addr); 854 if (rc) { 855 dev_err(&pdev->dev, "missing or invalid 'reg' property\n"); 856 return rc; 857 } 858 859 rc = regmap_read(chg->regmap, chg->addr + SMBB_MISC_REV2, &chg->revision); 860 if (rc) { 861 dev_err(&pdev->dev, "unable to read revision\n"); 862 return rc; 863 } 864 865 chg->revision += 1; 866 if (chg->revision != 2 && chg->revision != 3) { 867 dev_err(&pdev->dev, "v1 hardware not supported\n"); 868 return -ENODEV; 869 } 870 dev_info(&pdev->dev, "Initializing SMBB rev %u", chg->revision); 871 872 chg->dc_disabled = of_property_read_bool(pdev->dev.of_node, "qcom,disable-dc"); 873 874 for (i = 0; i < _ATTR_CNT; ++i) { 875 rc = smbb_charger_attr_parse(chg, i); 876 if (rc) { 877 dev_err(&pdev->dev, "failed to parse/apply settings\n"); 878 return rc; 879 } 880 } 881 882 bat_cfg.drv_data = chg; 883 bat_cfg.of_node = pdev->dev.of_node; 884 chg->bat_psy = devm_power_supply_register(&pdev->dev, 885 &bat_psy_desc, 886 &bat_cfg); 887 if (IS_ERR(chg->bat_psy)) { 888 dev_err(&pdev->dev, "failed to register battery\n"); 889 return PTR_ERR(chg->bat_psy); 890 } 891 892 usb_cfg.drv_data = chg; 893 usb_cfg.supplied_to = smbb_bif; 894 usb_cfg.num_supplicants = ARRAY_SIZE(smbb_bif); 895 chg->usb_psy = devm_power_supply_register(&pdev->dev, 896 &usb_psy_desc, 897 &usb_cfg); 898 if (IS_ERR(chg->usb_psy)) { 899 dev_err(&pdev->dev, "failed to register USB power supply\n"); 900 return PTR_ERR(chg->usb_psy); 901 } 902 903 chg->edev = devm_extcon_dev_allocate(&pdev->dev, smbb_usb_extcon_cable); 904 if (IS_ERR(chg->edev)) { 905 dev_err(&pdev->dev, "failed to allocate extcon device\n"); 906 return -ENOMEM; 907 } 908 909 rc = devm_extcon_dev_register(&pdev->dev, chg->edev); 910 if (rc < 0) { 911 dev_err(&pdev->dev, "failed to register extcon device\n"); 912 return rc; 913 } 914 915 if (!chg->dc_disabled) { 916 dc_cfg.drv_data = chg; 917 dc_cfg.supplied_to = smbb_bif; 918 dc_cfg.num_supplicants = ARRAY_SIZE(smbb_bif); 919 chg->dc_psy = devm_power_supply_register(&pdev->dev, 920 &dc_psy_desc, 921 &dc_cfg); 922 if (IS_ERR(chg->dc_psy)) { 923 dev_err(&pdev->dev, "failed to register DC power supply\n"); 924 return PTR_ERR(chg->dc_psy); 925 } 926 } 927 928 for (i = 0; i < ARRAY_SIZE(smbb_charger_irqs); ++i) { 929 int irq; 930 931 irq = platform_get_irq_byname(pdev, smbb_charger_irqs[i].name); 932 if (irq < 0) 933 return irq; 934 935 smbb_charger_irqs[i].handler(irq, chg); 936 937 rc = devm_request_threaded_irq(&pdev->dev, irq, NULL, 938 smbb_charger_irqs[i].handler, IRQF_ONESHOT, 939 smbb_charger_irqs[i].name, chg); 940 if (rc) { 941 dev_err(&pdev->dev, "failed to request irq '%s'\n", 942 smbb_charger_irqs[i].name); 943 return rc; 944 } 945 } 946 947 /* 948 * otg regulator is used to control VBUS voltage direction 949 * when USB switches between host and gadget mode 950 */ 951 chg->otg_rdesc.id = -1; 952 chg->otg_rdesc.name = "otg-vbus"; 953 chg->otg_rdesc.ops = &smbb_chg_otg_ops; 954 chg->otg_rdesc.owner = THIS_MODULE; 955 chg->otg_rdesc.type = REGULATOR_VOLTAGE; 956 chg->otg_rdesc.supply_name = "usb-otg-in"; 957 chg->otg_rdesc.of_match = "otg-vbus"; 958 959 config.dev = &pdev->dev; 960 config.driver_data = chg; 961 962 chg->otg_reg = devm_regulator_register(&pdev->dev, &chg->otg_rdesc, 963 &config); 964 if (IS_ERR(chg->otg_reg)) 965 return PTR_ERR(chg->otg_reg); 966 967 chg->jeita_ext_temp = of_property_read_bool(pdev->dev.of_node, 968 "qcom,jeita-extended-temp-range"); 969 970 /* Set temperature range to [35%:70%] or [25%:80%] accordingly */ 971 rc = regmap_update_bits(chg->regmap, chg->addr + SMBB_BAT_BTC_CTRL, 972 BTC_CTRL_COLD_EXT | BTC_CTRL_HOT_EXT_N, 973 chg->jeita_ext_temp ? 974 BTC_CTRL_COLD_EXT : 975 BTC_CTRL_HOT_EXT_N); 976 if (rc) { 977 dev_err(&pdev->dev, 978 "unable to set %s temperature range\n", 979 chg->jeita_ext_temp ? "JEITA extended" : "normal"); 980 return rc; 981 } 982 983 for (i = 0; i < ARRAY_SIZE(smbb_charger_setup); ++i) { 984 const struct reg_off_mask_default *r = &smbb_charger_setup[i]; 985 986 if (r->rev_mask & BIT(chg->revision)) 987 continue; 988 989 rc = regmap_update_bits(chg->regmap, chg->addr + r->offset, 990 r->mask, r->value); 991 if (rc) { 992 dev_err(&pdev->dev, 993 "unable to initializing charging, bailing\n"); 994 return rc; 995 } 996 } 997 998 platform_set_drvdata(pdev, chg); 999 1000 return 0; 1001 } 1002 1003 static int smbb_charger_remove(struct platform_device *pdev) 1004 { 1005 struct smbb_charger *chg; 1006 1007 chg = platform_get_drvdata(pdev); 1008 1009 regmap_update_bits(chg->regmap, chg->addr + SMBB_CHG_CTRL, CTRL_EN, 0); 1010 1011 return 0; 1012 } 1013 1014 static const struct of_device_id smbb_charger_id_table[] = { 1015 { .compatible = "qcom,pm8941-charger" }, 1016 { } 1017 }; 1018 MODULE_DEVICE_TABLE(of, smbb_charger_id_table); 1019 1020 static struct platform_driver smbb_charger_driver = { 1021 .probe = smbb_charger_probe, 1022 .remove = smbb_charger_remove, 1023 .driver = { 1024 .name = "qcom-smbb", 1025 .of_match_table = smbb_charger_id_table, 1026 }, 1027 }; 1028 module_platform_driver(smbb_charger_driver); 1029 1030 MODULE_DESCRIPTION("Qualcomm Switch-Mode Battery Charger and Boost driver"); 1031 MODULE_LICENSE("GPL v2"); 1032