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