1 /* 2 * Summit Microelectronics SMB347 Battery Charger Driver 3 * 4 * Copyright (C) 2011, Intel Corporation 5 * 6 * Authors: Bruce E. Robertson <bruce.e.robertson@intel.com> 7 * Mika Westerberg <mika.westerberg@linux.intel.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 */ 13 14 #include <linux/err.h> 15 #include <linux/gpio.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/init.h> 19 #include <linux/interrupt.h> 20 #include <linux/i2c.h> 21 #include <linux/mutex.h> 22 #include <linux/power_supply.h> 23 #include <linux/power/smb347-charger.h> 24 #include <linux/regmap.h> 25 26 /* 27 * Configuration registers. These are mirrored to volatile RAM and can be 28 * written once %CMD_A_ALLOW_WRITE is set in %CMD_A register. They will be 29 * reloaded from non-volatile registers after POR. 30 */ 31 #define CFG_CHARGE_CURRENT 0x00 32 #define CFG_CHARGE_CURRENT_FCC_MASK 0xe0 33 #define CFG_CHARGE_CURRENT_FCC_SHIFT 5 34 #define CFG_CHARGE_CURRENT_PCC_MASK 0x18 35 #define CFG_CHARGE_CURRENT_PCC_SHIFT 3 36 #define CFG_CHARGE_CURRENT_TC_MASK 0x07 37 #define CFG_CURRENT_LIMIT 0x01 38 #define CFG_CURRENT_LIMIT_DC_MASK 0xf0 39 #define CFG_CURRENT_LIMIT_DC_SHIFT 4 40 #define CFG_CURRENT_LIMIT_USB_MASK 0x0f 41 #define CFG_FLOAT_VOLTAGE 0x03 42 #define CFG_FLOAT_VOLTAGE_FLOAT_MASK 0x3f 43 #define CFG_FLOAT_VOLTAGE_THRESHOLD_MASK 0xc0 44 #define CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT 6 45 #define CFG_STAT 0x05 46 #define CFG_STAT_DISABLED BIT(5) 47 #define CFG_STAT_ACTIVE_HIGH BIT(7) 48 #define CFG_PIN 0x06 49 #define CFG_PIN_EN_CTRL_MASK 0x60 50 #define CFG_PIN_EN_CTRL_ACTIVE_HIGH 0x40 51 #define CFG_PIN_EN_CTRL_ACTIVE_LOW 0x60 52 #define CFG_PIN_EN_APSD_IRQ BIT(1) 53 #define CFG_PIN_EN_CHARGER_ERROR BIT(2) 54 #define CFG_THERM 0x07 55 #define CFG_THERM_SOFT_HOT_COMPENSATION_MASK 0x03 56 #define CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT 0 57 #define CFG_THERM_SOFT_COLD_COMPENSATION_MASK 0x0c 58 #define CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT 2 59 #define CFG_THERM_MONITOR_DISABLED BIT(4) 60 #define CFG_SYSOK 0x08 61 #define CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED BIT(2) 62 #define CFG_OTHER 0x09 63 #define CFG_OTHER_RID_MASK 0xc0 64 #define CFG_OTHER_RID_ENABLED_AUTO_OTG 0xc0 65 #define CFG_OTG 0x0a 66 #define CFG_OTG_TEMP_THRESHOLD_MASK 0x30 67 #define CFG_OTG_TEMP_THRESHOLD_SHIFT 4 68 #define CFG_OTG_CC_COMPENSATION_MASK 0xc0 69 #define CFG_OTG_CC_COMPENSATION_SHIFT 6 70 #define CFG_TEMP_LIMIT 0x0b 71 #define CFG_TEMP_LIMIT_SOFT_HOT_MASK 0x03 72 #define CFG_TEMP_LIMIT_SOFT_HOT_SHIFT 0 73 #define CFG_TEMP_LIMIT_SOFT_COLD_MASK 0x0c 74 #define CFG_TEMP_LIMIT_SOFT_COLD_SHIFT 2 75 #define CFG_TEMP_LIMIT_HARD_HOT_MASK 0x30 76 #define CFG_TEMP_LIMIT_HARD_HOT_SHIFT 4 77 #define CFG_TEMP_LIMIT_HARD_COLD_MASK 0xc0 78 #define CFG_TEMP_LIMIT_HARD_COLD_SHIFT 6 79 #define CFG_FAULT_IRQ 0x0c 80 #define CFG_FAULT_IRQ_DCIN_UV BIT(2) 81 #define CFG_STATUS_IRQ 0x0d 82 #define CFG_STATUS_IRQ_TERMINATION_OR_TAPER BIT(4) 83 #define CFG_STATUS_IRQ_CHARGE_TIMEOUT BIT(7) 84 #define CFG_ADDRESS 0x0e 85 86 /* Command registers */ 87 #define CMD_A 0x30 88 #define CMD_A_CHG_ENABLED BIT(1) 89 #define CMD_A_SUSPEND_ENABLED BIT(2) 90 #define CMD_A_ALLOW_WRITE BIT(7) 91 #define CMD_B 0x31 92 #define CMD_C 0x33 93 94 /* Interrupt Status registers */ 95 #define IRQSTAT_A 0x35 96 #define IRQSTAT_C 0x37 97 #define IRQSTAT_C_TERMINATION_STAT BIT(0) 98 #define IRQSTAT_C_TERMINATION_IRQ BIT(1) 99 #define IRQSTAT_C_TAPER_IRQ BIT(3) 100 #define IRQSTAT_D 0x38 101 #define IRQSTAT_D_CHARGE_TIMEOUT_STAT BIT(2) 102 #define IRQSTAT_D_CHARGE_TIMEOUT_IRQ BIT(3) 103 #define IRQSTAT_E 0x39 104 #define IRQSTAT_E_USBIN_UV_STAT BIT(0) 105 #define IRQSTAT_E_USBIN_UV_IRQ BIT(1) 106 #define IRQSTAT_E_DCIN_UV_STAT BIT(4) 107 #define IRQSTAT_E_DCIN_UV_IRQ BIT(5) 108 #define IRQSTAT_F 0x3a 109 110 /* Status registers */ 111 #define STAT_A 0x3b 112 #define STAT_A_FLOAT_VOLTAGE_MASK 0x3f 113 #define STAT_B 0x3c 114 #define STAT_C 0x3d 115 #define STAT_C_CHG_ENABLED BIT(0) 116 #define STAT_C_HOLDOFF_STAT BIT(3) 117 #define STAT_C_CHG_MASK 0x06 118 #define STAT_C_CHG_SHIFT 1 119 #define STAT_C_CHG_TERM BIT(5) 120 #define STAT_C_CHARGER_ERROR BIT(6) 121 #define STAT_E 0x3f 122 123 #define SMB347_MAX_REGISTER 0x3f 124 125 /** 126 * struct smb347_charger - smb347 charger instance 127 * @lock: protects concurrent access to online variables 128 * @dev: pointer to device 129 * @regmap: pointer to driver regmap 130 * @mains: power_supply instance for AC/DC power 131 * @usb: power_supply instance for USB power 132 * @battery: power_supply instance for battery 133 * @mains_online: is AC/DC input connected 134 * @usb_online: is USB input connected 135 * @charging_enabled: is charging enabled 136 * @pdata: pointer to platform data 137 */ 138 struct smb347_charger { 139 struct mutex lock; 140 struct device *dev; 141 struct regmap *regmap; 142 struct power_supply *mains; 143 struct power_supply *usb; 144 struct power_supply *battery; 145 bool mains_online; 146 bool usb_online; 147 bool charging_enabled; 148 const struct smb347_charger_platform_data *pdata; 149 }; 150 151 /* Fast charge current in uA */ 152 static const unsigned int fcc_tbl[] = { 153 700000, 154 900000, 155 1200000, 156 1500000, 157 1800000, 158 2000000, 159 2200000, 160 2500000, 161 }; 162 163 /* Pre-charge current in uA */ 164 static const unsigned int pcc_tbl[] = { 165 100000, 166 150000, 167 200000, 168 250000, 169 }; 170 171 /* Termination current in uA */ 172 static const unsigned int tc_tbl[] = { 173 37500, 174 50000, 175 100000, 176 150000, 177 200000, 178 250000, 179 500000, 180 600000, 181 }; 182 183 /* Input current limit in uA */ 184 static const unsigned int icl_tbl[] = { 185 300000, 186 500000, 187 700000, 188 900000, 189 1200000, 190 1500000, 191 1800000, 192 2000000, 193 2200000, 194 2500000, 195 }; 196 197 /* Charge current compensation in uA */ 198 static const unsigned int ccc_tbl[] = { 199 250000, 200 700000, 201 900000, 202 1200000, 203 }; 204 205 /* Convert register value to current using lookup table */ 206 static int hw_to_current(const unsigned int *tbl, size_t size, unsigned int val) 207 { 208 if (val >= size) 209 return -EINVAL; 210 return tbl[val]; 211 } 212 213 /* Convert current to register value using lookup table */ 214 static int current_to_hw(const unsigned int *tbl, size_t size, unsigned int val) 215 { 216 size_t i; 217 218 for (i = 0; i < size; i++) 219 if (val < tbl[i]) 220 break; 221 return i > 0 ? i - 1 : -EINVAL; 222 } 223 224 /** 225 * smb347_update_ps_status - refreshes the power source status 226 * @smb: pointer to smb347 charger instance 227 * 228 * Function checks whether any power source is connected to the charger and 229 * updates internal state accordingly. If there is a change to previous state 230 * function returns %1, otherwise %0 and negative errno in case of errror. 231 */ 232 static int smb347_update_ps_status(struct smb347_charger *smb) 233 { 234 bool usb = false; 235 bool dc = false; 236 unsigned int val; 237 int ret; 238 239 ret = regmap_read(smb->regmap, IRQSTAT_E, &val); 240 if (ret < 0) 241 return ret; 242 243 /* 244 * Dc and usb are set depending on whether they are enabled in 245 * platform data _and_ whether corresponding undervoltage is set. 246 */ 247 if (smb->pdata->use_mains) 248 dc = !(val & IRQSTAT_E_DCIN_UV_STAT); 249 if (smb->pdata->use_usb) 250 usb = !(val & IRQSTAT_E_USBIN_UV_STAT); 251 252 mutex_lock(&smb->lock); 253 ret = smb->mains_online != dc || smb->usb_online != usb; 254 smb->mains_online = dc; 255 smb->usb_online = usb; 256 mutex_unlock(&smb->lock); 257 258 return ret; 259 } 260 261 /* 262 * smb347_is_ps_online - returns whether input power source is connected 263 * @smb: pointer to smb347 charger instance 264 * 265 * Returns %true if input power source is connected. Note that this is 266 * dependent on what platform has configured for usable power sources. For 267 * example if USB is disabled, this will return %false even if the USB cable 268 * is connected. 269 */ 270 static bool smb347_is_ps_online(struct smb347_charger *smb) 271 { 272 bool ret; 273 274 mutex_lock(&smb->lock); 275 ret = smb->usb_online || smb->mains_online; 276 mutex_unlock(&smb->lock); 277 278 return ret; 279 } 280 281 /** 282 * smb347_charging_status - returns status of charging 283 * @smb: pointer to smb347 charger instance 284 * 285 * Function returns charging status. %0 means no charging is in progress, 286 * %1 means pre-charging, %2 fast-charging and %3 taper-charging. 287 */ 288 static int smb347_charging_status(struct smb347_charger *smb) 289 { 290 unsigned int val; 291 int ret; 292 293 if (!smb347_is_ps_online(smb)) 294 return 0; 295 296 ret = regmap_read(smb->regmap, STAT_C, &val); 297 if (ret < 0) 298 return 0; 299 300 return (val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT; 301 } 302 303 static int smb347_charging_set(struct smb347_charger *smb, bool enable) 304 { 305 int ret = 0; 306 307 if (smb->pdata->enable_control != SMB347_CHG_ENABLE_SW) { 308 dev_dbg(smb->dev, "charging enable/disable in SW disabled\n"); 309 return 0; 310 } 311 312 mutex_lock(&smb->lock); 313 if (smb->charging_enabled != enable) { 314 ret = regmap_update_bits(smb->regmap, CMD_A, CMD_A_CHG_ENABLED, 315 enable ? CMD_A_CHG_ENABLED : 0); 316 if (!ret) 317 smb->charging_enabled = enable; 318 } 319 mutex_unlock(&smb->lock); 320 return ret; 321 } 322 323 static inline int smb347_charging_enable(struct smb347_charger *smb) 324 { 325 return smb347_charging_set(smb, true); 326 } 327 328 static inline int smb347_charging_disable(struct smb347_charger *smb) 329 { 330 return smb347_charging_set(smb, false); 331 } 332 333 static int smb347_start_stop_charging(struct smb347_charger *smb) 334 { 335 int ret; 336 337 /* 338 * Depending on whether valid power source is connected or not, we 339 * disable or enable the charging. We do it manually because it 340 * depends on how the platform has configured the valid inputs. 341 */ 342 if (smb347_is_ps_online(smb)) { 343 ret = smb347_charging_enable(smb); 344 if (ret < 0) 345 dev_err(smb->dev, "failed to enable charging\n"); 346 } else { 347 ret = smb347_charging_disable(smb); 348 if (ret < 0) 349 dev_err(smb->dev, "failed to disable charging\n"); 350 } 351 352 return ret; 353 } 354 355 static int smb347_set_charge_current(struct smb347_charger *smb) 356 { 357 int ret; 358 359 if (smb->pdata->max_charge_current) { 360 ret = current_to_hw(fcc_tbl, ARRAY_SIZE(fcc_tbl), 361 smb->pdata->max_charge_current); 362 if (ret < 0) 363 return ret; 364 365 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT, 366 CFG_CHARGE_CURRENT_FCC_MASK, 367 ret << CFG_CHARGE_CURRENT_FCC_SHIFT); 368 if (ret < 0) 369 return ret; 370 } 371 372 if (smb->pdata->pre_charge_current) { 373 ret = current_to_hw(pcc_tbl, ARRAY_SIZE(pcc_tbl), 374 smb->pdata->pre_charge_current); 375 if (ret < 0) 376 return ret; 377 378 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT, 379 CFG_CHARGE_CURRENT_PCC_MASK, 380 ret << CFG_CHARGE_CURRENT_PCC_SHIFT); 381 if (ret < 0) 382 return ret; 383 } 384 385 if (smb->pdata->termination_current) { 386 ret = current_to_hw(tc_tbl, ARRAY_SIZE(tc_tbl), 387 smb->pdata->termination_current); 388 if (ret < 0) 389 return ret; 390 391 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT, 392 CFG_CHARGE_CURRENT_TC_MASK, ret); 393 if (ret < 0) 394 return ret; 395 } 396 397 return 0; 398 } 399 400 static int smb347_set_current_limits(struct smb347_charger *smb) 401 { 402 int ret; 403 404 if (smb->pdata->mains_current_limit) { 405 ret = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl), 406 smb->pdata->mains_current_limit); 407 if (ret < 0) 408 return ret; 409 410 ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT, 411 CFG_CURRENT_LIMIT_DC_MASK, 412 ret << CFG_CURRENT_LIMIT_DC_SHIFT); 413 if (ret < 0) 414 return ret; 415 } 416 417 if (smb->pdata->usb_hc_current_limit) { 418 ret = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl), 419 smb->pdata->usb_hc_current_limit); 420 if (ret < 0) 421 return ret; 422 423 ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT, 424 CFG_CURRENT_LIMIT_USB_MASK, ret); 425 if (ret < 0) 426 return ret; 427 } 428 429 return 0; 430 } 431 432 static int smb347_set_voltage_limits(struct smb347_charger *smb) 433 { 434 int ret; 435 436 if (smb->pdata->pre_to_fast_voltage) { 437 ret = smb->pdata->pre_to_fast_voltage; 438 439 /* uV */ 440 ret = clamp_val(ret, 2400000, 3000000) - 2400000; 441 ret /= 200000; 442 443 ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE, 444 CFG_FLOAT_VOLTAGE_THRESHOLD_MASK, 445 ret << CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT); 446 if (ret < 0) 447 return ret; 448 } 449 450 if (smb->pdata->max_charge_voltage) { 451 ret = smb->pdata->max_charge_voltage; 452 453 /* uV */ 454 ret = clamp_val(ret, 3500000, 4500000) - 3500000; 455 ret /= 20000; 456 457 ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE, 458 CFG_FLOAT_VOLTAGE_FLOAT_MASK, ret); 459 if (ret < 0) 460 return ret; 461 } 462 463 return 0; 464 } 465 466 static int smb347_set_temp_limits(struct smb347_charger *smb) 467 { 468 bool enable_therm_monitor = false; 469 int ret = 0; 470 int val; 471 472 if (smb->pdata->chip_temp_threshold) { 473 val = smb->pdata->chip_temp_threshold; 474 475 /* degree C */ 476 val = clamp_val(val, 100, 130) - 100; 477 val /= 10; 478 479 ret = regmap_update_bits(smb->regmap, CFG_OTG, 480 CFG_OTG_TEMP_THRESHOLD_MASK, 481 val << CFG_OTG_TEMP_THRESHOLD_SHIFT); 482 if (ret < 0) 483 return ret; 484 } 485 486 if (smb->pdata->soft_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) { 487 val = smb->pdata->soft_cold_temp_limit; 488 489 val = clamp_val(val, 0, 15); 490 val /= 5; 491 /* this goes from higher to lower so invert the value */ 492 val = ~val & 0x3; 493 494 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT, 495 CFG_TEMP_LIMIT_SOFT_COLD_MASK, 496 val << CFG_TEMP_LIMIT_SOFT_COLD_SHIFT); 497 if (ret < 0) 498 return ret; 499 500 enable_therm_monitor = true; 501 } 502 503 if (smb->pdata->soft_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) { 504 val = smb->pdata->soft_hot_temp_limit; 505 506 val = clamp_val(val, 40, 55) - 40; 507 val /= 5; 508 509 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT, 510 CFG_TEMP_LIMIT_SOFT_HOT_MASK, 511 val << CFG_TEMP_LIMIT_SOFT_HOT_SHIFT); 512 if (ret < 0) 513 return ret; 514 515 enable_therm_monitor = true; 516 } 517 518 if (smb->pdata->hard_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) { 519 val = smb->pdata->hard_cold_temp_limit; 520 521 val = clamp_val(val, -5, 10) + 5; 522 val /= 5; 523 /* this goes from higher to lower so invert the value */ 524 val = ~val & 0x3; 525 526 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT, 527 CFG_TEMP_LIMIT_HARD_COLD_MASK, 528 val << CFG_TEMP_LIMIT_HARD_COLD_SHIFT); 529 if (ret < 0) 530 return ret; 531 532 enable_therm_monitor = true; 533 } 534 535 if (smb->pdata->hard_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) { 536 val = smb->pdata->hard_hot_temp_limit; 537 538 val = clamp_val(val, 50, 65) - 50; 539 val /= 5; 540 541 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT, 542 CFG_TEMP_LIMIT_HARD_HOT_MASK, 543 val << CFG_TEMP_LIMIT_HARD_HOT_SHIFT); 544 if (ret < 0) 545 return ret; 546 547 enable_therm_monitor = true; 548 } 549 550 /* 551 * If any of the temperature limits are set, we also enable the 552 * thermistor monitoring. 553 * 554 * When soft limits are hit, the device will start to compensate 555 * current and/or voltage depending on the configuration. 556 * 557 * When hard limit is hit, the device will suspend charging 558 * depending on the configuration. 559 */ 560 if (enable_therm_monitor) { 561 ret = regmap_update_bits(smb->regmap, CFG_THERM, 562 CFG_THERM_MONITOR_DISABLED, 0); 563 if (ret < 0) 564 return ret; 565 } 566 567 if (smb->pdata->suspend_on_hard_temp_limit) { 568 ret = regmap_update_bits(smb->regmap, CFG_SYSOK, 569 CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED, 0); 570 if (ret < 0) 571 return ret; 572 } 573 574 if (smb->pdata->soft_temp_limit_compensation != 575 SMB347_SOFT_TEMP_COMPENSATE_DEFAULT) { 576 val = smb->pdata->soft_temp_limit_compensation & 0x3; 577 578 ret = regmap_update_bits(smb->regmap, CFG_THERM, 579 CFG_THERM_SOFT_HOT_COMPENSATION_MASK, 580 val << CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT); 581 if (ret < 0) 582 return ret; 583 584 ret = regmap_update_bits(smb->regmap, CFG_THERM, 585 CFG_THERM_SOFT_COLD_COMPENSATION_MASK, 586 val << CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT); 587 if (ret < 0) 588 return ret; 589 } 590 591 if (smb->pdata->charge_current_compensation) { 592 val = current_to_hw(ccc_tbl, ARRAY_SIZE(ccc_tbl), 593 smb->pdata->charge_current_compensation); 594 if (val < 0) 595 return val; 596 597 ret = regmap_update_bits(smb->regmap, CFG_OTG, 598 CFG_OTG_CC_COMPENSATION_MASK, 599 (val & 0x3) << CFG_OTG_CC_COMPENSATION_SHIFT); 600 if (ret < 0) 601 return ret; 602 } 603 604 return ret; 605 } 606 607 /* 608 * smb347_set_writable - enables/disables writing to non-volatile registers 609 * @smb: pointer to smb347 charger instance 610 * 611 * You can enable/disable writing to the non-volatile configuration 612 * registers by calling this function. 613 * 614 * Returns %0 on success and negative errno in case of failure. 615 */ 616 static int smb347_set_writable(struct smb347_charger *smb, bool writable) 617 { 618 return regmap_update_bits(smb->regmap, CMD_A, CMD_A_ALLOW_WRITE, 619 writable ? CMD_A_ALLOW_WRITE : 0); 620 } 621 622 static int smb347_hw_init(struct smb347_charger *smb) 623 { 624 unsigned int val; 625 int ret; 626 627 ret = smb347_set_writable(smb, true); 628 if (ret < 0) 629 return ret; 630 631 /* 632 * Program the platform specific configuration values to the device 633 * first. 634 */ 635 ret = smb347_set_charge_current(smb); 636 if (ret < 0) 637 goto fail; 638 639 ret = smb347_set_current_limits(smb); 640 if (ret < 0) 641 goto fail; 642 643 ret = smb347_set_voltage_limits(smb); 644 if (ret < 0) 645 goto fail; 646 647 ret = smb347_set_temp_limits(smb); 648 if (ret < 0) 649 goto fail; 650 651 /* If USB charging is disabled we put the USB in suspend mode */ 652 if (!smb->pdata->use_usb) { 653 ret = regmap_update_bits(smb->regmap, CMD_A, 654 CMD_A_SUSPEND_ENABLED, 655 CMD_A_SUSPEND_ENABLED); 656 if (ret < 0) 657 goto fail; 658 } 659 660 /* 661 * If configured by platform data, we enable hardware Auto-OTG 662 * support for driving VBUS. Otherwise we disable it. 663 */ 664 ret = regmap_update_bits(smb->regmap, CFG_OTHER, CFG_OTHER_RID_MASK, 665 smb->pdata->use_usb_otg ? CFG_OTHER_RID_ENABLED_AUTO_OTG : 0); 666 if (ret < 0) 667 goto fail; 668 669 /* 670 * Make the charging functionality controllable by a write to the 671 * command register unless pin control is specified in the platform 672 * data. 673 */ 674 switch (smb->pdata->enable_control) { 675 case SMB347_CHG_ENABLE_PIN_ACTIVE_LOW: 676 val = CFG_PIN_EN_CTRL_ACTIVE_LOW; 677 break; 678 case SMB347_CHG_ENABLE_PIN_ACTIVE_HIGH: 679 val = CFG_PIN_EN_CTRL_ACTIVE_HIGH; 680 break; 681 default: 682 val = 0; 683 break; 684 } 685 686 ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CTRL_MASK, 687 val); 688 if (ret < 0) 689 goto fail; 690 691 /* Disable Automatic Power Source Detection (APSD) interrupt. */ 692 ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_APSD_IRQ, 0); 693 if (ret < 0) 694 goto fail; 695 696 ret = smb347_update_ps_status(smb); 697 if (ret < 0) 698 goto fail; 699 700 ret = smb347_start_stop_charging(smb); 701 702 fail: 703 smb347_set_writable(smb, false); 704 return ret; 705 } 706 707 static irqreturn_t smb347_interrupt(int irq, void *data) 708 { 709 struct smb347_charger *smb = data; 710 unsigned int stat_c, irqstat_c, irqstat_d, irqstat_e; 711 bool handled = false; 712 int ret; 713 714 ret = regmap_read(smb->regmap, STAT_C, &stat_c); 715 if (ret < 0) { 716 dev_warn(smb->dev, "reading STAT_C failed\n"); 717 return IRQ_NONE; 718 } 719 720 ret = regmap_read(smb->regmap, IRQSTAT_C, &irqstat_c); 721 if (ret < 0) { 722 dev_warn(smb->dev, "reading IRQSTAT_C failed\n"); 723 return IRQ_NONE; 724 } 725 726 ret = regmap_read(smb->regmap, IRQSTAT_D, &irqstat_d); 727 if (ret < 0) { 728 dev_warn(smb->dev, "reading IRQSTAT_D failed\n"); 729 return IRQ_NONE; 730 } 731 732 ret = regmap_read(smb->regmap, IRQSTAT_E, &irqstat_e); 733 if (ret < 0) { 734 dev_warn(smb->dev, "reading IRQSTAT_E failed\n"); 735 return IRQ_NONE; 736 } 737 738 /* 739 * If we get charger error we report the error back to user. 740 * If the error is recovered charging will resume again. 741 */ 742 if (stat_c & STAT_C_CHARGER_ERROR) { 743 dev_err(smb->dev, "charging stopped due to charger error\n"); 744 power_supply_changed(smb->battery); 745 handled = true; 746 } 747 748 /* 749 * If we reached the termination current the battery is charged and 750 * we can update the status now. Charging is automatically 751 * disabled by the hardware. 752 */ 753 if (irqstat_c & (IRQSTAT_C_TERMINATION_IRQ | IRQSTAT_C_TAPER_IRQ)) { 754 if (irqstat_c & IRQSTAT_C_TERMINATION_STAT) 755 power_supply_changed(smb->battery); 756 dev_dbg(smb->dev, "going to HW maintenance mode\n"); 757 handled = true; 758 } 759 760 /* 761 * If we got a charger timeout INT that means the charge 762 * full is not detected with in charge timeout value. 763 */ 764 if (irqstat_d & IRQSTAT_D_CHARGE_TIMEOUT_IRQ) { 765 dev_dbg(smb->dev, "total Charge Timeout INT received\n"); 766 767 if (irqstat_d & IRQSTAT_D_CHARGE_TIMEOUT_STAT) 768 dev_warn(smb->dev, "charging stopped due to timeout\n"); 769 power_supply_changed(smb->battery); 770 handled = true; 771 } 772 773 /* 774 * If we got an under voltage interrupt it means that AC/USB input 775 * was connected or disconnected. 776 */ 777 if (irqstat_e & (IRQSTAT_E_USBIN_UV_IRQ | IRQSTAT_E_DCIN_UV_IRQ)) { 778 if (smb347_update_ps_status(smb) > 0) { 779 smb347_start_stop_charging(smb); 780 if (smb->pdata->use_mains) 781 power_supply_changed(smb->mains); 782 if (smb->pdata->use_usb) 783 power_supply_changed(smb->usb); 784 } 785 handled = true; 786 } 787 788 return handled ? IRQ_HANDLED : IRQ_NONE; 789 } 790 791 static int smb347_irq_set(struct smb347_charger *smb, bool enable) 792 { 793 int ret; 794 795 ret = smb347_set_writable(smb, true); 796 if (ret < 0) 797 return ret; 798 799 /* 800 * Enable/disable interrupts for: 801 * - under voltage 802 * - termination current reached 803 * - charger timeout 804 * - charger error 805 */ 806 ret = regmap_update_bits(smb->regmap, CFG_FAULT_IRQ, 0xff, 807 enable ? CFG_FAULT_IRQ_DCIN_UV : 0); 808 if (ret < 0) 809 goto fail; 810 811 ret = regmap_update_bits(smb->regmap, CFG_STATUS_IRQ, 0xff, 812 enable ? (CFG_STATUS_IRQ_TERMINATION_OR_TAPER | 813 CFG_STATUS_IRQ_CHARGE_TIMEOUT) : 0); 814 if (ret < 0) 815 goto fail; 816 817 ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CHARGER_ERROR, 818 enable ? CFG_PIN_EN_CHARGER_ERROR : 0); 819 fail: 820 smb347_set_writable(smb, false); 821 return ret; 822 } 823 824 static inline int smb347_irq_enable(struct smb347_charger *smb) 825 { 826 return smb347_irq_set(smb, true); 827 } 828 829 static inline int smb347_irq_disable(struct smb347_charger *smb) 830 { 831 return smb347_irq_set(smb, false); 832 } 833 834 static int smb347_irq_init(struct smb347_charger *smb, 835 struct i2c_client *client) 836 { 837 const struct smb347_charger_platform_data *pdata = smb->pdata; 838 int ret, irq = gpio_to_irq(pdata->irq_gpio); 839 840 ret = gpio_request_one(pdata->irq_gpio, GPIOF_IN, client->name); 841 if (ret < 0) 842 goto fail; 843 844 ret = request_threaded_irq(irq, NULL, smb347_interrupt, 845 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 846 client->name, smb); 847 if (ret < 0) 848 goto fail_gpio; 849 850 ret = smb347_set_writable(smb, true); 851 if (ret < 0) 852 goto fail_irq; 853 854 /* 855 * Configure the STAT output to be suitable for interrupts: disable 856 * all other output (except interrupts) and make it active low. 857 */ 858 ret = regmap_update_bits(smb->regmap, CFG_STAT, 859 CFG_STAT_ACTIVE_HIGH | CFG_STAT_DISABLED, 860 CFG_STAT_DISABLED); 861 if (ret < 0) 862 goto fail_readonly; 863 864 smb347_set_writable(smb, false); 865 client->irq = irq; 866 return 0; 867 868 fail_readonly: 869 smb347_set_writable(smb, false); 870 fail_irq: 871 free_irq(irq, smb); 872 fail_gpio: 873 gpio_free(pdata->irq_gpio); 874 fail: 875 client->irq = 0; 876 return ret; 877 } 878 879 /* 880 * Returns the constant charge current programmed 881 * into the charger in uA. 882 */ 883 static int get_const_charge_current(struct smb347_charger *smb) 884 { 885 int ret, intval; 886 unsigned int v; 887 888 if (!smb347_is_ps_online(smb)) 889 return -ENODATA; 890 891 ret = regmap_read(smb->regmap, STAT_B, &v); 892 if (ret < 0) 893 return ret; 894 895 /* 896 * The current value is composition of FCC and PCC values 897 * and we can detect which table to use from bit 5. 898 */ 899 if (v & 0x20) { 900 intval = hw_to_current(fcc_tbl, ARRAY_SIZE(fcc_tbl), v & 7); 901 } else { 902 v >>= 3; 903 intval = hw_to_current(pcc_tbl, ARRAY_SIZE(pcc_tbl), v & 7); 904 } 905 906 return intval; 907 } 908 909 /* 910 * Returns the constant charge voltage programmed 911 * into the charger in uV. 912 */ 913 static int get_const_charge_voltage(struct smb347_charger *smb) 914 { 915 int ret, intval; 916 unsigned int v; 917 918 if (!smb347_is_ps_online(smb)) 919 return -ENODATA; 920 921 ret = regmap_read(smb->regmap, STAT_A, &v); 922 if (ret < 0) 923 return ret; 924 925 v &= STAT_A_FLOAT_VOLTAGE_MASK; 926 if (v > 0x3d) 927 v = 0x3d; 928 929 intval = 3500000 + v * 20000; 930 931 return intval; 932 } 933 934 static int smb347_mains_get_property(struct power_supply *psy, 935 enum power_supply_property prop, 936 union power_supply_propval *val) 937 { 938 struct smb347_charger *smb = power_supply_get_drvdata(psy); 939 int ret; 940 941 switch (prop) { 942 case POWER_SUPPLY_PROP_ONLINE: 943 val->intval = smb->mains_online; 944 break; 945 946 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 947 ret = get_const_charge_voltage(smb); 948 if (ret < 0) 949 return ret; 950 else 951 val->intval = ret; 952 break; 953 954 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 955 ret = get_const_charge_current(smb); 956 if (ret < 0) 957 return ret; 958 else 959 val->intval = ret; 960 break; 961 962 default: 963 return -EINVAL; 964 } 965 966 return 0; 967 } 968 969 static enum power_supply_property smb347_mains_properties[] = { 970 POWER_SUPPLY_PROP_ONLINE, 971 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 972 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 973 }; 974 975 static int smb347_usb_get_property(struct power_supply *psy, 976 enum power_supply_property prop, 977 union power_supply_propval *val) 978 { 979 struct smb347_charger *smb = power_supply_get_drvdata(psy); 980 int ret; 981 982 switch (prop) { 983 case POWER_SUPPLY_PROP_ONLINE: 984 val->intval = smb->usb_online; 985 break; 986 987 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 988 ret = get_const_charge_voltage(smb); 989 if (ret < 0) 990 return ret; 991 else 992 val->intval = ret; 993 break; 994 995 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 996 ret = get_const_charge_current(smb); 997 if (ret < 0) 998 return ret; 999 else 1000 val->intval = ret; 1001 break; 1002 1003 default: 1004 return -EINVAL; 1005 } 1006 1007 return 0; 1008 } 1009 1010 static enum power_supply_property smb347_usb_properties[] = { 1011 POWER_SUPPLY_PROP_ONLINE, 1012 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 1013 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 1014 }; 1015 1016 static int smb347_get_charging_status(struct smb347_charger *smb) 1017 { 1018 int ret, status; 1019 unsigned int val; 1020 1021 if (!smb347_is_ps_online(smb)) 1022 return POWER_SUPPLY_STATUS_DISCHARGING; 1023 1024 ret = regmap_read(smb->regmap, STAT_C, &val); 1025 if (ret < 0) 1026 return ret; 1027 1028 if ((val & STAT_C_CHARGER_ERROR) || 1029 (val & STAT_C_HOLDOFF_STAT)) { 1030 /* 1031 * set to NOT CHARGING upon charger error 1032 * or charging has stopped. 1033 */ 1034 status = POWER_SUPPLY_STATUS_NOT_CHARGING; 1035 } else { 1036 if ((val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT) { 1037 /* 1038 * set to charging if battery is in pre-charge, 1039 * fast charge or taper charging mode. 1040 */ 1041 status = POWER_SUPPLY_STATUS_CHARGING; 1042 } else if (val & STAT_C_CHG_TERM) { 1043 /* 1044 * set the status to FULL if battery is not in pre 1045 * charge, fast charge or taper charging mode AND 1046 * charging is terminated at least once. 1047 */ 1048 status = POWER_SUPPLY_STATUS_FULL; 1049 } else { 1050 /* 1051 * in this case no charger error or termination 1052 * occured but charging is not in progress!!! 1053 */ 1054 status = POWER_SUPPLY_STATUS_NOT_CHARGING; 1055 } 1056 } 1057 1058 return status; 1059 } 1060 1061 static int smb347_battery_get_property(struct power_supply *psy, 1062 enum power_supply_property prop, 1063 union power_supply_propval *val) 1064 { 1065 struct smb347_charger *smb = power_supply_get_drvdata(psy); 1066 const struct smb347_charger_platform_data *pdata = smb->pdata; 1067 int ret; 1068 1069 ret = smb347_update_ps_status(smb); 1070 if (ret < 0) 1071 return ret; 1072 1073 switch (prop) { 1074 case POWER_SUPPLY_PROP_STATUS: 1075 ret = smb347_get_charging_status(smb); 1076 if (ret < 0) 1077 return ret; 1078 val->intval = ret; 1079 break; 1080 1081 case POWER_SUPPLY_PROP_CHARGE_TYPE: 1082 if (!smb347_is_ps_online(smb)) 1083 return -ENODATA; 1084 1085 /* 1086 * We handle trickle and pre-charging the same, and taper 1087 * and none the same. 1088 */ 1089 switch (smb347_charging_status(smb)) { 1090 case 1: 1091 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 1092 break; 1093 case 2: 1094 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST; 1095 break; 1096 default: 1097 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; 1098 break; 1099 } 1100 break; 1101 1102 case POWER_SUPPLY_PROP_TECHNOLOGY: 1103 val->intval = pdata->battery_info.technology; 1104 break; 1105 1106 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 1107 val->intval = pdata->battery_info.voltage_min_design; 1108 break; 1109 1110 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 1111 val->intval = pdata->battery_info.voltage_max_design; 1112 break; 1113 1114 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 1115 val->intval = pdata->battery_info.charge_full_design; 1116 break; 1117 1118 case POWER_SUPPLY_PROP_MODEL_NAME: 1119 val->strval = pdata->battery_info.name; 1120 break; 1121 1122 default: 1123 return -EINVAL; 1124 } 1125 1126 return 0; 1127 } 1128 1129 static enum power_supply_property smb347_battery_properties[] = { 1130 POWER_SUPPLY_PROP_STATUS, 1131 POWER_SUPPLY_PROP_CHARGE_TYPE, 1132 POWER_SUPPLY_PROP_TECHNOLOGY, 1133 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 1134 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 1135 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 1136 POWER_SUPPLY_PROP_MODEL_NAME, 1137 }; 1138 1139 static bool smb347_volatile_reg(struct device *dev, unsigned int reg) 1140 { 1141 switch (reg) { 1142 case IRQSTAT_A: 1143 case IRQSTAT_C: 1144 case IRQSTAT_E: 1145 case IRQSTAT_F: 1146 case STAT_A: 1147 case STAT_B: 1148 case STAT_C: 1149 case STAT_E: 1150 return true; 1151 } 1152 1153 return false; 1154 } 1155 1156 static bool smb347_readable_reg(struct device *dev, unsigned int reg) 1157 { 1158 switch (reg) { 1159 case CFG_CHARGE_CURRENT: 1160 case CFG_CURRENT_LIMIT: 1161 case CFG_FLOAT_VOLTAGE: 1162 case CFG_STAT: 1163 case CFG_PIN: 1164 case CFG_THERM: 1165 case CFG_SYSOK: 1166 case CFG_OTHER: 1167 case CFG_OTG: 1168 case CFG_TEMP_LIMIT: 1169 case CFG_FAULT_IRQ: 1170 case CFG_STATUS_IRQ: 1171 case CFG_ADDRESS: 1172 case CMD_A: 1173 case CMD_B: 1174 case CMD_C: 1175 return true; 1176 } 1177 1178 return smb347_volatile_reg(dev, reg); 1179 } 1180 1181 static const struct regmap_config smb347_regmap = { 1182 .reg_bits = 8, 1183 .val_bits = 8, 1184 .max_register = SMB347_MAX_REGISTER, 1185 .volatile_reg = smb347_volatile_reg, 1186 .readable_reg = smb347_readable_reg, 1187 }; 1188 1189 static const struct power_supply_desc smb347_mains_desc = { 1190 .name = "smb347-mains", 1191 .type = POWER_SUPPLY_TYPE_MAINS, 1192 .get_property = smb347_mains_get_property, 1193 .properties = smb347_mains_properties, 1194 .num_properties = ARRAY_SIZE(smb347_mains_properties), 1195 }; 1196 1197 static const struct power_supply_desc smb347_usb_desc = { 1198 .name = "smb347-usb", 1199 .type = POWER_SUPPLY_TYPE_USB, 1200 .get_property = smb347_usb_get_property, 1201 .properties = smb347_usb_properties, 1202 .num_properties = ARRAY_SIZE(smb347_usb_properties), 1203 }; 1204 1205 static const struct power_supply_desc smb347_battery_desc = { 1206 .name = "smb347-battery", 1207 .type = POWER_SUPPLY_TYPE_BATTERY, 1208 .get_property = smb347_battery_get_property, 1209 .properties = smb347_battery_properties, 1210 .num_properties = ARRAY_SIZE(smb347_battery_properties), 1211 }; 1212 1213 static int smb347_probe(struct i2c_client *client, 1214 const struct i2c_device_id *id) 1215 { 1216 static char *battery[] = { "smb347-battery" }; 1217 const struct smb347_charger_platform_data *pdata; 1218 struct power_supply_config mains_usb_cfg = {}, battery_cfg = {}; 1219 struct device *dev = &client->dev; 1220 struct smb347_charger *smb; 1221 int ret; 1222 1223 pdata = dev->platform_data; 1224 if (!pdata) 1225 return -EINVAL; 1226 1227 if (!pdata->use_mains && !pdata->use_usb) 1228 return -EINVAL; 1229 1230 smb = devm_kzalloc(dev, sizeof(*smb), GFP_KERNEL); 1231 if (!smb) 1232 return -ENOMEM; 1233 1234 i2c_set_clientdata(client, smb); 1235 1236 mutex_init(&smb->lock); 1237 smb->dev = &client->dev; 1238 smb->pdata = pdata; 1239 1240 smb->regmap = devm_regmap_init_i2c(client, &smb347_regmap); 1241 if (IS_ERR(smb->regmap)) 1242 return PTR_ERR(smb->regmap); 1243 1244 ret = smb347_hw_init(smb); 1245 if (ret < 0) 1246 return ret; 1247 1248 mains_usb_cfg.supplied_to = battery; 1249 mains_usb_cfg.num_supplicants = ARRAY_SIZE(battery); 1250 mains_usb_cfg.drv_data = smb; 1251 if (smb->pdata->use_mains) { 1252 smb->mains = power_supply_register(dev, &smb347_mains_desc, 1253 &mains_usb_cfg); 1254 if (IS_ERR(smb->mains)) 1255 return PTR_ERR(smb->mains); 1256 } 1257 1258 if (smb->pdata->use_usb) { 1259 smb->usb = power_supply_register(dev, &smb347_usb_desc, 1260 &mains_usb_cfg); 1261 if (IS_ERR(smb->usb)) { 1262 if (smb->pdata->use_mains) 1263 power_supply_unregister(smb->mains); 1264 return PTR_ERR(smb->usb); 1265 } 1266 } 1267 1268 battery_cfg.drv_data = smb; 1269 smb->battery = power_supply_register(dev, &smb347_battery_desc, 1270 &battery_cfg); 1271 if (IS_ERR(smb->battery)) { 1272 if (smb->pdata->use_usb) 1273 power_supply_unregister(smb->usb); 1274 if (smb->pdata->use_mains) 1275 power_supply_unregister(smb->mains); 1276 return PTR_ERR(smb->battery); 1277 } 1278 1279 /* 1280 * Interrupt pin is optional. If it is connected, we setup the 1281 * interrupt support here. 1282 */ 1283 if (pdata->irq_gpio >= 0) { 1284 ret = smb347_irq_init(smb, client); 1285 if (ret < 0) { 1286 dev_warn(dev, "failed to initialize IRQ: %d\n", ret); 1287 dev_warn(dev, "disabling IRQ support\n"); 1288 } else { 1289 smb347_irq_enable(smb); 1290 } 1291 } 1292 1293 return 0; 1294 } 1295 1296 static int smb347_remove(struct i2c_client *client) 1297 { 1298 struct smb347_charger *smb = i2c_get_clientdata(client); 1299 1300 if (client->irq) { 1301 smb347_irq_disable(smb); 1302 free_irq(client->irq, smb); 1303 gpio_free(smb->pdata->irq_gpio); 1304 } 1305 1306 power_supply_unregister(smb->battery); 1307 if (smb->pdata->use_usb) 1308 power_supply_unregister(smb->usb); 1309 if (smb->pdata->use_mains) 1310 power_supply_unregister(smb->mains); 1311 return 0; 1312 } 1313 1314 static const struct i2c_device_id smb347_id[] = { 1315 { "smb347", 0 }, 1316 { } 1317 }; 1318 MODULE_DEVICE_TABLE(i2c, smb347_id); 1319 1320 static struct i2c_driver smb347_driver = { 1321 .driver = { 1322 .name = "smb347", 1323 }, 1324 .probe = smb347_probe, 1325 .remove = smb347_remove, 1326 .id_table = smb347_id, 1327 }; 1328 1329 module_i2c_driver(smb347_driver); 1330 1331 MODULE_AUTHOR("Bruce E. Robertson <bruce.e.robertson@intel.com>"); 1332 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>"); 1333 MODULE_DESCRIPTION("SMB347 battery charger driver"); 1334 MODULE_LICENSE("GPL"); 1335