drivers/power/supply/qcom_smbb.c

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