drivers/power/twl4030_charger.c

   1 /*
   2  * TWL4030/TPS65950 BCI (Battery Charger Interface) driver
   3  *
   4  * Copyright (C) 2010 Gražvydas Ignotas <notasas@gmail.com>
   5  *
   6  * based on twl4030_bci_battery.c by TI
   7  * Copyright (C) 2008 Texas Instruments, Inc.
   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 as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  */
  14
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/slab.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/i2c/twl.h>
  21 #include <linux/power_supply.h>
  22 #include <linux/notifier.h>
  23 #include <linux/usb/otg.h>
  24 #include <linux/ratelimit.h>
  25 #include <linux/regulator/machine.h>
  26
  27 #define TWL4030_BCIMSTATEC      0x02
  28 #define TWL4030_BCIICHG         0x08
  29 #define TWL4030_BCIVAC          0x0a
  30 #define TWL4030_BCIVBUS         0x0c
  31 #define TWL4030_BCIMFSTS3       0x0f
  32 #define TWL4030_BCIMFSTS4       0x10
  33 #define TWL4030_BCIMFKEY        0x11
  34 #define TWL4030_BCICTL1         0x23
  35 #define TWL4030_BCIIREF1        0x27
  36 #define TWL4030_BCIIREF2        0x28
  37
  38 #define TWL4030_BCIAUTOWEN      BIT(5)
  39 #define TWL4030_CONFIG_DONE     BIT(4)
  40 #define TWL4030_CVENAC          BIT(2)
  41 #define TWL4030_BCIAUTOUSB      BIT(1)
  42 #define TWL4030_BCIAUTOAC       BIT(0)
  43 #define TWL4030_CGAIN           BIT(5)
  44 #define TWL4030_USBFASTMCHG     BIT(2)
  45 #define TWL4030_STS_VBUS        BIT(7)
  46 #define TWL4030_STS_USB_ID      BIT(2)
  47 #define TWL4030_STS_CHG         BIT(1)
  48
  49 /* BCI interrupts */
  50 #define TWL4030_WOVF            BIT(0) /* Watchdog overflow */
  51 #define TWL4030_TMOVF           BIT(1) /* Timer overflow */
  52 #define TWL4030_ICHGHIGH        BIT(2) /* Battery charge current high */
  53 #define TWL4030_ICHGLOW         BIT(3) /* Battery cc. low / FSM state change */
  54 #define TWL4030_ICHGEOC         BIT(4) /* Battery current end-of-charge */
  55 #define TWL4030_TBATOR2         BIT(5) /* Battery temperature out of range 2 */
  56 #define TWL4030_TBATOR1         BIT(6) /* Battery temperature out of range 1 */
  57 #define TWL4030_BATSTS          BIT(7) /* Battery status */
  58
  59 #define TWL4030_VBATLVL         BIT(0) /* VBAT level */
  60 #define TWL4030_VBATOV          BIT(1) /* VBAT overvoltage */
  61 #define TWL4030_VBUSOV          BIT(2) /* VBUS overvoltage */
  62 #define TWL4030_ACCHGOV         BIT(3) /* Ac charger overvoltage */
  63
  64 #define TWL4030_MSTATEC_USB             BIT(4)
  65 #define TWL4030_MSTATEC_AC              BIT(5)
  66 #define TWL4030_MSTATEC_MASK            0x0f
  67 #define TWL4030_MSTATEC_QUICK1          0x02
  68 #define TWL4030_MSTATEC_QUICK7          0x07
  69 #define TWL4030_MSTATEC_COMPLETE1       0x0b
  70 #define TWL4030_MSTATEC_COMPLETE4       0x0e
  71
  72 #define TWL4030_KEY_IIREF               0xe7
  73 #define TWL4030_BATSTSMCHG              BIT(6)
  74
  75 static bool allow_usb = 1;
  76 module_param(allow_usb, bool, 0644);
  77 MODULE_PARM_DESC(allow_usb, "Allow USB charge drawing default current");
  78
  79 struct twl4030_bci {
  80         struct device           *dev;
  81         struct power_supply     ac;
  82         struct power_supply     usb;
  83         struct otg_transceiver  *transceiver;
  84         struct notifier_block   otg_nb;
  85         struct work_struct      work;
  86         int                     irq_chg;
  87         int                     irq_bci;
  88         bool                    ac_charge_enable;
  89         bool                    usb_charge_enable;
  90         int                     usb_current;
  91         int                     ac_current;
  92         enum power_supply_type  current_supply;
  93         struct regulator        *usb_reg;
  94         int                     usb_enabled;
  95         int                     irq_had_charger;
  96
  97         unsigned long           event;
  98         struct ratelimit_state  ratelimit;
  99 };
 100
 101 /*
 102  * clear and set bits on an given register on a given module
 103  */
 104 static int twl4030_clear_set(u8 mod_no, u8 clear, u8 set, u8 reg)
 105 {
 106         u8 val = 0;
 107         int ret;
 108
 109         ret = twl_i2c_read_u8(mod_no, &val, reg);
 110         if (ret)
 111                 return ret;
 112
 113         val &= ~clear;
 114         val |= set;
 115
 116         return twl_i2c_write_u8(mod_no, val, reg);
 117 }
 118
 119 static int twl4030_bci_read(u8 reg, u8 *val)
 120 {
 121         return twl_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, val, reg);
 122 }
 123
 124 static int twl4030_bci_write(u8 reg, u8 val)
 125 {
 126         return twl_i2c_write_u8(TWL4030_MODULE_MAIN_CHARGE, val, reg);
 127 }
 128
 129 static int twl4030_clear_set_boot_bci(u8 clear, u8 set)
 130 {
 131         return twl4030_clear_set(TWL4030_MODULE_PM_MASTER, clear,
 132                         TWL4030_CONFIG_DONE | TWL4030_BCIAUTOWEN | set,
 133                         TWL4030_PM_MASTER_BOOT_BCI);
 134 }
 135
 136 static int twl4030bci_read_adc_val(u8 reg)
 137 {
 138         int ret, temp;
 139         u8 val;
 140
 141         /* read MSB */
 142         ret = twl4030_bci_read(reg + 1, &val);
 143         if (ret)
 144                 return ret;
 145
 146         temp = (int)(val & 0x03) << 8;
 147
 148         /* read LSB */
 149         ret = twl4030_bci_read(reg, &val);
 150         if (ret)
 151                 return ret;
 152
 153         return temp | val;
 154 }
 155
 156 /*
 157  * Check if VBUS power is present
 158  */
 159 static int twl4030_bci_have_vbus(struct twl4030_bci *bci)
 160 {
 161         int ret;
 162         u8 hwsts;
 163
 164         ret = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &hwsts,
 165                               TWL4030_PM_MASTER_STS_HW_CONDITIONS);
 166         if (ret < 0)
 167                 return 0;
 168
 169         dev_dbg(bci->dev, "check_vbus: HW_CONDITIONS %02x\n", hwsts);
 170
 171         /* in case we also have STS_USB_ID, VBUS is driven by TWL itself */
 172         if ((hwsts & TWL4030_STS_VBUS) && !(hwsts & TWL4030_STS_USB_ID))
 173                 return 1;
 174
 175         return 0;
 176 }
 177
 178 /*
 179  * Enable/Disable USB Charge functionality.
 180  */
 181 static int twl4030_charger_enable_usb(struct twl4030_bci *bci, bool enable)
 182 {
 183         int ret;
 184
 185         if (enable) {
 186                 if (!bci->usb_charge_enable)
 187                         return -EACCES;
 188
 189                 /* Check for USB charger conneted */
 190                 if (!twl4030_bci_have_vbus(bci))
 191                         return -ENODEV;
 192
 193                 /*
 194                  * Until we can find out what current the device can provide,
 195                  * require a module param to enable USB charging.
 196                  */
 197                 if (!allow_usb) {
 198                         dev_warn(bci->dev, "USB charging is disabled.\n");
 199                         return -EACCES;
 200                 }
 201
 202                 /* Need to keep regulator on */
 203                 if (!bci->usb_enabled &&
 204                     bci->usb_reg &&
 205                     regulator_enable(bci->usb_reg) == 0)
 206                         bci->usb_enabled = 1;
 207
 208                 /* forcing the field BCIAUTOUSB (BOOT_BCI[1]) to 1 */
 209                 ret = twl4030_clear_set_boot_bci(0, TWL4030_BCIAUTOUSB);
 210                 if (ret < 0)
 211                         return ret;
 212
 213                 /* forcing USBFASTMCHG(BCIMFSTS4[2]) to 1 */
 214                 ret = twl4030_clear_set(TWL4030_MODULE_MAIN_CHARGE, 0,
 215                         TWL4030_USBFASTMCHG, TWL4030_BCIMFSTS4);
 216         } else {
 217                 ret = twl4030_clear_set_boot_bci(TWL4030_BCIAUTOUSB, 0);
 218                 if (bci->usb_enabled &&
 219                     regulator_disable(bci->usb_reg) == 0)
 220                         bci->usb_enabled = 0;
 221         }
 222
 223         return ret;
 224 }
 225
 226 /*
 227  * Enable/Disable AC Charge funtionality.
 228  */
 229 static int twl4030_charger_enable_ac(bool enable)
 230 {
 231         int ret;
 232
 233         if (enable)
 234                 ret = twl4030_clear_set_boot_bci(0, TWL4030_BCIAUTOAC);
 235         else
 236                 ret = twl4030_clear_set_boot_bci(TWL4030_BCIAUTOAC, 0);
 237
 238         return ret;
 239 }
 240
 241 static int set_charge_current(struct twl4030_bci *bci, int new_current)
 242 {
 243         u8 val, boot_bci_prev, cgain_set, cgain_clear;
 244         int ret, ret2;
 245
 246         ret = twl4030_bci_read(TWL4030_BCIMFSTS3, &val);
 247         if (ret)
 248                 goto out_norestore;
 249
 250         if (!(val & TWL4030_BATSTSMCHG)) {
 251                 dev_err(bci->dev, "missing battery, can't change charge_current\n");
 252                 goto out_norestore;
 253         }
 254
 255         ret = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &boot_bci_prev,
 256                 TWL4030_PM_MASTER_BOOT_BCI);
 257         if (ret)
 258                 goto out_norestore;
 259
 260         /*
 261          * Stop automatic charging here, because charge current change
 262          * requires multiple register writes and CGAIN change requires
 263          * automatic charge to be stopped (and CV mode disabled too).
 264          */
 265         ret = twl4030_clear_set_boot_bci(
 266                 TWL4030_CVENAC | TWL4030_BCIAUTOAC | TWL4030_BCIAUTOUSB, 0);
 267         if (ret)
 268                 goto out;
 269
 270         ret = twl4030_bci_write(TWL4030_BCIMFKEY, TWL4030_KEY_IIREF);
 271         if (ret)
 272                 goto out;
 273
 274         ret = twl4030_bci_write(TWL4030_BCIIREF1, new_current & 0xff);
 275         if (ret)
 276                 goto out;
 277
 278         ret = twl4030_bci_write(TWL4030_BCIMFKEY, TWL4030_KEY_IIREF);
 279         if (ret)
 280                 goto out;
 281
 282         ret = twl4030_bci_write(TWL4030_BCIIREF2, (new_current >> 8) & 0x1);
 283         if (ret)
 284                 goto out;
 285
 286         /* Set CGAIN = 0 or 1 */
 287         if (new_current > 511) {
 288                 cgain_set = TWL4030_CGAIN;
 289                 cgain_clear = 0;
 290         } else {
 291                 cgain_set = 0;
 292                 cgain_clear = TWL4030_CGAIN;
 293         }
 294
 295         ret = twl4030_clear_set(TWL4030_MODULE_MAIN_CHARGE,
 296                         cgain_clear, cgain_set, TWL4030_BCICTL1);
 297         if (ret)
 298                 goto out;
 299
 300         ret = twl4030_bci_read(TWL4030_BCICTL1, &val);
 301         if (ret != 0 || (val & TWL4030_CGAIN) != cgain_set) {
 302                 dev_err(bci->dev, "CGAIN change failed\n");
 303                 goto out;
 304         }
 305
 306 out:
 307         ret2 = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, boot_bci_prev,
 308                 TWL4030_PM_MASTER_BOOT_BCI);
 309         if (ret2 != 0)
 310                 dev_err(bci->dev, "failed boot_bci restore: %d\n", ret2);
 311
 312 out_norestore:
 313         if (ret != 0)
 314                 dev_err(bci->dev, "charge current change failed: %d\n", ret);
 315
 316         return ret;
 317 }
 318
 319 /*
 320  * TWL4030 CHG_PRES (AC charger presence) events
 321  */
 322 static irqreturn_t twl4030_charger_interrupt(int irq, void *arg)
 323 {
 324         struct twl4030_bci *bci = arg;
 325         int have_charger;
 326         u8 hw_cond;
 327         int ret;
 328
 329         ret = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &hw_cond,
 330                               TWL4030_PM_MASTER_STS_HW_CONDITIONS);
 331         if (ret < 0) {
 332                 dev_err(bci->dev, "HW_CONDITIONS read failed: %d\n", ret);
 333                 goto out;
 334         }
 335
 336         have_charger = (hw_cond & TWL4030_STS_CHG) ? 1 : 0;
 337         if (have_charger == bci->irq_had_charger)
 338                 goto out;
 339         bci->irq_had_charger = have_charger;
 340
 341         dev_dbg(bci->dev, "CHG_PRES irq, hw_cond %02x\n", hw_cond);
 342         power_supply_changed(&bci->ac);
 343         power_supply_changed(&bci->usb);
 344
 345 out:
 346         return IRQ_HANDLED;
 347 }
 348
 349 /*
 350  * TWL4030 BCI monitoring events
 351  */
 352 static irqreturn_t twl4030_bci_interrupt(int irq, void *arg)
 353 {
 354         struct twl4030_bci *bci = arg;
 355         u8 irqs1, irqs2;
 356         int ret;
 357
 358         ret = twl_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &irqs1,
 359                               TWL4030_INTERRUPTS_BCIISR1A);
 360         if (ret < 0)
 361                 return IRQ_HANDLED;
 362
 363         ret = twl_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &irqs2,
 364                               TWL4030_INTERRUPTS_BCIISR2A);
 365         if (ret < 0)
 366                 return IRQ_HANDLED;
 367
 368         dev_dbg(bci->dev, "BCI irq %02x %02x\n", irqs2, irqs1);
 369
 370         if (irqs1 & (TWL4030_ICHGLOW | TWL4030_ICHGEOC)) {
 371                 /* charger state change, inform the core */
 372                 power_supply_changed(&bci->ac);
 373                 power_supply_changed(&bci->usb);
 374         }
 375
 376         /* various monitoring events, for now we just log them here */
 377         if (irqs1 & (TWL4030_TBATOR2 | TWL4030_TBATOR1) &&
 378                         __ratelimit(&bci->ratelimit))
 379                 dev_warn(bci->dev, "battery temperature out of range\n");
 380
 381         if (irqs1 & TWL4030_BATSTS && __ratelimit(&bci->ratelimit))
 382                 dev_crit(bci->dev, "battery disconnected\n");
 383
 384         if (irqs2 & TWL4030_VBATOV && __ratelimit(&bci->ratelimit))
 385                 dev_crit(bci->dev, "VBAT overvoltage\n");
 386
 387         if (irqs2 & TWL4030_VBUSOV && __ratelimit(&bci->ratelimit))
 388                 dev_crit(bci->dev, "VBUS overvoltage\n");
 389
 390         if (irqs2 & TWL4030_ACCHGOV && __ratelimit(&bci->ratelimit))
 391                 dev_crit(bci->dev, "Ac charger overvoltage\n");
 392
 393         /* ack the interrupts */
 394         twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, irqs1,
 395                          TWL4030_INTERRUPTS_BCIISR1A);
 396         twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, irqs2,
 397                          TWL4030_INTERRUPTS_BCIISR2A);
 398
 399         return IRQ_HANDLED;
 400 }
 401
 402 static void twl4030_bci_usb_work(struct work_struct *data)
 403 {
 404         struct twl4030_bci *bci = container_of(data, struct twl4030_bci, work);
 405
 406         switch (bci->event) {
 407         case USB_EVENT_VBUS:
 408         case USB_EVENT_CHARGER:
 409                 twl4030_charger_enable_usb(bci, true);
 410                 break;
 411         case USB_EVENT_NONE:
 412                 twl4030_charger_enable_usb(bci, false);
 413                 break;
 414         }
 415 }
 416
 417 static int twl4030_bci_usb_ncb(struct notifier_block *nb, unsigned long val,
 418                                void *priv)
 419 {
 420         struct twl4030_bci *bci = container_of(nb, struct twl4030_bci, otg_nb);
 421
 422         dev_dbg(bci->dev, "OTG notify %lu\n", val);
 423
 424         bci->event = val;
 425         schedule_work(&bci->work);
 426
 427         return NOTIFY_OK;
 428 }
 429
 430 /*
 431  * TI provided formulas:
 432  * CGAIN == 0: ICHG = (BCIICHG * 1.7) / (2^10 - 1) - 0.85
 433  * CGAIN == 1: ICHG = (BCIICHG * 3.4) / (2^10 - 1) - 1.7
 434  * Here we use integer approximation of:
 435  * CGAIN == 0: val * 1.6618 - 0.85
 436  * CGAIN == 1: (val * 1.6618 - 0.85) * 2
 437  */
 438 static int twl4030_charger_get_current(void)
 439 {
 440         int curr;
 441         int ret;
 442         u8 bcictl1;
 443
 444         curr = twl4030bci_read_adc_val(TWL4030_BCIICHG);
 445         if (curr < 0)
 446                 return curr;
 447
 448         ret = twl4030_bci_read(TWL4030_BCICTL1, &bcictl1);
 449         if (ret)
 450                 return ret;
 451
 452         ret = (curr * 16618 - 850 * 10000) / 10;
 453         if (bcictl1 & TWL4030_CGAIN)
 454                 ret *= 2;
 455
 456         return ret;
 457 }
 458
 459 static ssize_t twl4030_bci_ac_show_enable(struct device *dev,
 460                                           struct device_attribute *attr,
 461                                           char *buf)
 462 {
 463         u8 boot_bci;
 464         int ret;
 465
 466         ret = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &boot_bci,
 467                               TWL4030_PM_MASTER_BOOT_BCI);
 468         if (ret)
 469                 return ret;
 470
 471         return sprintf(buf, "%d\n", (boot_bci & TWL4030_BCIAUTOAC) ? 1 : 0);
 472 }
 473
 474 static ssize_t twl4030_bci_ac_store_enable(struct device *dev,
 475                                            struct device_attribute *attr,
 476                                            const char *buf, size_t count)
 477 {
 478         struct power_supply *psy = dev_get_drvdata(dev);
 479         struct twl4030_bci *bci = container_of(psy, struct twl4030_bci, ac);
 480         unsigned long enable;
 481         int ret;
 482
 483         ret = strict_strtoul(buf, 10, &enable);
 484         if (ret || enable > 1)
 485                 return -EINVAL;
 486
 487         bci->ac_charge_enable = enable;
 488         twl4030_charger_enable_ac(enable);
 489
 490         return count;
 491 }
 492 static struct device_attribute dev_attr_enable_ac =
 493         __ATTR(enable, S_IRUGO | S_IWUSR, twl4030_bci_ac_show_enable,
 494         twl4030_bci_ac_store_enable);
 495
 496 static ssize_t twl4030_bci_usb_show_enable(struct device *dev,
 497                                            struct device_attribute *attr,
 498                                            char *buf)
 499 {
 500         u8 boot_bci;
 501         int ret;
 502
 503         ret = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &boot_bci,
 504                               TWL4030_PM_MASTER_BOOT_BCI);
 505         if (ret)
 506                 return ret;
 507
 508         return sprintf(buf, "%d\n", (boot_bci & TWL4030_BCIAUTOUSB) ? 1 : 0);
 509 }
 510
 511 static ssize_t twl4030_bci_usb_store_enable(struct device *dev,
 512                                             struct device_attribute *attr,
 513                                             const char *buf, size_t count)
 514 {
 515         struct power_supply *psy = dev_get_drvdata(dev);
 516         struct twl4030_bci *bci = container_of(psy, struct twl4030_bci, usb);
 517         unsigned long enable;
 518         int ret;
 519
 520         ret = strict_strtoul(buf, 10, &enable);
 521         if (ret || enable > 1)
 522                 return -EINVAL;
 523
 524         bci->usb_charge_enable = enable;
 525         twl4030_charger_enable_usb(bci, enable);
 526
 527         return count;
 528 }
 529 static struct device_attribute dev_attr_enable_usb =
 530         __ATTR(enable, S_IRUGO | S_IWUSR, twl4030_bci_usb_show_enable,
 531         twl4030_bci_usb_store_enable);
 532
 533 static ssize_t show_charge_current(struct device *dev,
 534                         struct device_attribute *attr, char *buf)
 535 {
 536         int ret, val;
 537         u8 ctl;
 538
 539         val = twl4030bci_read_adc_val(TWL4030_BCIIREF1);
 540         if (val < 0)
 541                 return val;
 542         ret = twl4030_bci_read(TWL4030_BCICTL1, &ctl);
 543         if (ret < 0)
 544                 return ret;
 545
 546         val &= 0x1ff;
 547         if (ctl & TWL4030_CGAIN)
 548                 val |= 0x200;
 549
 550         return sprintf(buf, "%d\n", val);
 551 }
 552
 553 static ssize_t store_charge_current(struct device *dev,
 554                         struct device_attribute *attr, const char *buf,
 555                         size_t count)
 556 {
 557         struct power_supply *psy = dev_get_drvdata(dev);
 558         struct twl4030_bci *bci = dev_get_drvdata(psy->dev->parent);
 559         unsigned long new_current;
 560         int ret;
 561
 562         ret = strict_strtoul(buf, 10, &new_current);
 563         if (ret)
 564                 return -EINVAL;
 565
 566         ret = set_charge_current(bci, new_current);
 567         if (ret)
 568                 return ret;
 569
 570         if (psy->type == POWER_SUPPLY_TYPE_MAINS)
 571                 bci->ac_current = new_current;
 572         else
 573                 bci->usb_current = new_current;
 574
 575         return count;
 576 }
 577 static DEVICE_ATTR(charge_current, S_IRUGO | S_IWUSR, show_charge_current,
 578         store_charge_current);
 579
 580 static struct attribute *bci_ac_attrs[] = {
 581         &dev_attr_enable_ac.attr,
 582         &dev_attr_charge_current.attr,
 583         NULL,
 584 };
 585
 586 static struct attribute *bci_usb_attrs[] = {
 587         &dev_attr_enable_usb.attr,
 588         &dev_attr_charge_current.attr,
 589         NULL,
 590 };
 591
 592 static const struct attribute_group bci_ac_attr_group = {
 593         .attrs = bci_ac_attrs,
 594 };
 595
 596 static const struct attribute_group bci_usb_attr_group = {
 597         .attrs = bci_usb_attrs,
 598 };
 599
 600 /*
 601  * Returns the main charge FSM state
 602  * Or < 0 on failure.
 603  */
 604 static int twl4030bci_state(struct twl4030_bci *bci)
 605 {
 606         int ret;
 607         u8 state;
 608
 609         ret = twl4030_bci_read(TWL4030_BCIMSTATEC, &state);
 610         if (ret) {
 611                 pr_err("twl4030_bci: error reading BCIMSTATEC\n");
 612                 return ret;
 613         }
 614
 615         dev_dbg(bci->dev, "state: %02x\n", state);
 616
 617         return state;
 618 }
 619
 620 static int twl4030_bci_state_to_status(int state)
 621 {
 622         state &= TWL4030_MSTATEC_MASK;
 623         if (TWL4030_MSTATEC_QUICK1 <= state && state <= TWL4030_MSTATEC_QUICK7)
 624                 return POWER_SUPPLY_STATUS_CHARGING;
 625         else if (TWL4030_MSTATEC_COMPLETE1 <= state &&
 626                                         state <= TWL4030_MSTATEC_COMPLETE4)
 627                 return POWER_SUPPLY_STATUS_FULL;
 628         else
 629                 return POWER_SUPPLY_STATUS_NOT_CHARGING;
 630 }
 631
 632 static int twl4030_bci_get_property(struct power_supply *psy,
 633                                     enum power_supply_property psp,
 634                                     union power_supply_propval *val)
 635 {
 636         struct twl4030_bci *bci = dev_get_drvdata(psy->dev->parent);
 637         int is_charging;
 638         int state;
 639         int ret;
 640
 641         state = twl4030bci_state(bci);
 642         if (state < 0)
 643                 return state;
 644
 645         if (psy->type == POWER_SUPPLY_TYPE_USB)
 646                 is_charging = state & TWL4030_MSTATEC_USB;
 647         else
 648                 is_charging = state & TWL4030_MSTATEC_AC;
 649         if (is_charging && psy->type != bci->current_supply) {
 650                 if (psy->type == POWER_SUPPLY_TYPE_USB)
 651                         set_charge_current(bci, bci->usb_current);
 652                 else
 653                         set_charge_current(bci, bci->ac_current);
 654                 bci->current_supply = psy->type;
 655         }
 656
 657         switch (psp) {
 658         case POWER_SUPPLY_PROP_STATUS:
 659                 if (is_charging)
 660                         val->intval = twl4030_bci_state_to_status(state);
 661                 else
 662                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 663                 break;
 664         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 665                 /* charging must be active for meaningful result */
 666                 if (!is_charging)
 667                         return -ENODATA;
 668                 if (psy->type == POWER_SUPPLY_TYPE_USB) {
 669                         ret = twl4030bci_read_adc_val(TWL4030_BCIVBUS);
 670                         if (ret < 0)
 671                                 return ret;
 672                         /* BCIVBUS uses ADCIN8, 7/1023 V/step */
 673                         val->intval = ret * 6843;
 674                 } else {
 675                         ret = twl4030bci_read_adc_val(TWL4030_BCIVAC);
 676                         if (ret < 0)
 677                                 return ret;
 678                         /* BCIVAC uses ADCIN11, 10/1023 V/step */
 679                         val->intval = ret * 9775;
 680                 }
 681                 break;
 682         case POWER_SUPPLY_PROP_CURRENT_NOW:
 683                 if (!is_charging)
 684                         return -ENODATA;
 685                 /* current measurement is shared between AC and USB */
 686                 ret = twl4030_charger_get_current();
 687                 if (ret < 0)
 688                         return ret;
 689                 val->intval = ret;
 690                 break;
 691         case POWER_SUPPLY_PROP_ONLINE:
 692                 val->intval = is_charging &&
 693                         twl4030_bci_state_to_status(state) !=
 694                                 POWER_SUPPLY_STATUS_NOT_CHARGING;
 695                 break;
 696         default:
 697                 return -EINVAL;
 698         }
 699
 700         return 0;
 701 }
 702
 703 static enum power_supply_property twl4030_charger_props[] = {
 704         POWER_SUPPLY_PROP_STATUS,
 705         POWER_SUPPLY_PROP_ONLINE,
 706         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 707         POWER_SUPPLY_PROP_CURRENT_NOW,
 708 };
 709
 710 static int __init twl4030_bci_probe(struct platform_device *pdev)
 711 {
 712         const struct twl4030_bci_platform_data *pdata = pdev->dev.platform_data;
 713         struct twl4030_bci *bci;
 714         int ret;
 715         u32 reg;
 716
 717         if (pdata == NULL) {
 718                 dev_err(&pdev->dev, "No platform data\n");
 719                 return -EINVAL;
 720         }
 721
 722         bci = kzalloc(sizeof(*bci), GFP_KERNEL);
 723         if (bci == NULL)
 724                 return -ENOMEM;
 725
 726         bci->dev = &pdev->dev;
 727         bci->irq_chg = platform_get_irq(pdev, 0);
 728         bci->irq_bci = platform_get_irq(pdev, 1);
 729         bci->ac_current = 860; /* ~1.2A */
 730         bci->usb_current = 360; /* ~600mA */
 731         bci->irq_had_charger = -1;
 732
 733         platform_set_drvdata(pdev, bci);
 734
 735         ratelimit_state_init(&bci->ratelimit, HZ, 2);
 736
 737         bci->ac.name = "twl4030_ac";
 738         bci->ac.type = POWER_SUPPLY_TYPE_MAINS;
 739         bci->ac.properties = twl4030_charger_props;
 740         bci->ac.num_properties = ARRAY_SIZE(twl4030_charger_props);
 741         bci->ac.get_property = twl4030_bci_get_property;
 742         bci->ac.supplied_to = pdata->supplied_to;
 743         bci->ac.num_supplicants = pdata->num_supplicants;
 744
 745         ret = power_supply_register(&pdev->dev, &bci->ac);
 746         if (ret) {
 747                 dev_err(&pdev->dev, "failed to register ac: %d\n", ret);
 748                 goto fail_register_ac;
 749         }
 750
 751         bci->usb.name = "twl4030_usb";
 752         bci->usb.type = POWER_SUPPLY_TYPE_USB;
 753         bci->usb.properties = twl4030_charger_props;
 754         bci->usb.num_properties = ARRAY_SIZE(twl4030_charger_props);
 755         bci->usb.get_property = twl4030_bci_get_property;
 756         bci->usb.supplied_to = pdata->supplied_to;
 757         bci->usb.num_supplicants = pdata->num_supplicants;
 758
 759         bci->usb_reg = regulator_get(bci->dev, "bci3v1");
 760         if (IS_ERR(bci->usb_reg)) {
 761                 dev_warn(&pdev->dev, "regulator get bci3v1 failed\n");
 762                 bci->usb_reg = NULL;
 763         }
 764
 765         ret = power_supply_register(&pdev->dev, &bci->usb);
 766         if (ret) {
 767                 dev_err(&pdev->dev, "failed to register usb: %d\n", ret);
 768                 goto fail_register_usb;
 769         }
 770
 771         ret = request_threaded_irq(bci->irq_chg, NULL,
 772                         twl4030_charger_interrupt, 0, pdev->name, bci);
 773         if (ret < 0) {
 774                 dev_err(&pdev->dev, "could not request irq %d, status %d\n",
 775                         bci->irq_chg, ret);
 776                 goto fail_chg_irq;
 777         }
 778
 779         ret = request_threaded_irq(bci->irq_bci, NULL,
 780                         twl4030_bci_interrupt, 0, pdev->name, bci);
 781         if (ret < 0) {
 782                 dev_err(&pdev->dev, "could not request irq %d, status %d\n",
 783                         bci->irq_bci, ret);
 784                 goto fail_bci_irq;
 785         }
 786
 787         INIT_WORK(&bci->work, twl4030_bci_usb_work);
 788
 789         bci->transceiver = otg_get_transceiver();
 790         if (bci->transceiver != NULL) {
 791                 bci->otg_nb.notifier_call = twl4030_bci_usb_ncb;
 792                 otg_register_notifier(bci->transceiver, &bci->otg_nb);
 793         }
 794
 795         ret = sysfs_create_group(&bci->ac.dev->kobj, &bci_ac_attr_group);
 796         if (ret) {
 797                 dev_err(&pdev->dev, "failed to create sysfs group: %d\n", ret);
 798                 goto fail_sysfs1;
 799         }
 800
 801         ret = sysfs_create_group(&bci->usb.dev->kobj, &bci_usb_attr_group);
 802         if (ret) {
 803                 dev_err(&pdev->dev, "failed to create sysfs group: %d\n", ret);
 804                 goto fail_sysfs2;
 805         }
 806
 807         /* Enable interrupts now. */
 808         reg = ~(u32)(TWL4030_ICHGLOW | TWL4030_ICHGEOC | TWL4030_TBATOR2 |
 809                 TWL4030_TBATOR1 | TWL4030_BATSTS);
 810         ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
 811                                TWL4030_INTERRUPTS_BCIIMR1A);
 812         if (ret < 0) {
 813                 dev_err(&pdev->dev, "failed to unmask interrupts: %d\n", ret);
 814                 goto fail_unmask_interrupts;
 815         }
 816
 817         reg = ~(u32)(TWL4030_VBATOV | TWL4030_VBUSOV | TWL4030_ACCHGOV);
 818         ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
 819                                TWL4030_INTERRUPTS_BCIIMR2A);
 820         if (ret < 0)
 821                 dev_warn(&pdev->dev, "failed to unmask interrupts: %d\n", ret);
 822
 823         bci->ac_charge_enable = true;
 824         bci->usb_charge_enable = true;
 825         twl4030_charger_enable_ac(true);
 826         twl4030_charger_enable_usb(bci, true);
 827
 828         return 0;
 829
 830 fail_unmask_interrupts:
 831         sysfs_remove_group(&bci->usb.dev->kobj, &bci_usb_attr_group);
 832 fail_sysfs2:
 833         sysfs_remove_group(&bci->ac.dev->kobj, &bci_ac_attr_group);
 834 fail_sysfs1:
 835         if (bci->transceiver != NULL) {
 836                 otg_unregister_notifier(bci->transceiver, &bci->otg_nb);
 837                 otg_put_transceiver(bci->transceiver);
 838         }
 839         free_irq(bci->irq_bci, bci);
 840 fail_bci_irq:
 841         free_irq(bci->irq_chg, bci);
 842 fail_chg_irq:
 843         power_supply_unregister(&bci->usb);
 844 fail_register_usb:
 845         power_supply_unregister(&bci->ac);
 846 fail_register_ac:
 847         platform_set_drvdata(pdev, NULL);
 848         kfree(bci);
 849
 850         return ret;
 851 }
 852
 853 static int __exit twl4030_bci_remove(struct platform_device *pdev)
 854 {
 855         struct twl4030_bci *bci = platform_get_drvdata(pdev);
 856
 857         sysfs_remove_group(&bci->usb.dev->kobj, &bci_usb_attr_group);
 858         sysfs_remove_group(&bci->ac.dev->kobj, &bci_ac_attr_group);
 859
 860         twl4030_charger_enable_ac(false);
 861         twl4030_charger_enable_usb(bci, false);
 862
 863         /* mask interrupts */
 864         twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, 0xff,
 865                          TWL4030_INTERRUPTS_BCIIMR1A);
 866         twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, 0xff,
 867                          TWL4030_INTERRUPTS_BCIIMR2A);
 868
 869         if (bci->transceiver != NULL) {
 870                 otg_unregister_notifier(bci->transceiver, &bci->otg_nb);
 871                 otg_put_transceiver(bci->transceiver);
 872         }
 873         free_irq(bci->irq_bci, bci);
 874         free_irq(bci->irq_chg, bci);
 875         power_supply_unregister(&bci->usb);
 876         power_supply_unregister(&bci->ac);
 877         platform_set_drvdata(pdev, NULL);
 878         kfree(bci);
 879
 880         return 0;
 881 }
 882
 883 static struct platform_driver twl4030_bci_driver = {
 884         .driver = {
 885                 .name   = "twl4030_bci",
 886                 .owner  = THIS_MODULE,
 887         },
 888         .remove = __exit_p(twl4030_bci_remove),
 889 };
 890
 891 static int __init twl4030_bci_init(void)
 892 {
 893         return platform_driver_probe(&twl4030_bci_driver, twl4030_bci_probe);
 894 }
 895 module_init(twl4030_bci_init);
 896
 897 static void __exit twl4030_bci_exit(void)
 898 {
 899         platform_driver_unregister(&twl4030_bci_driver);
 900 }
 901 module_exit(twl4030_bci_exit);
 902
 903 MODULE_AUTHOR("Gražvydas Ignotas");
 904 MODULE_DESCRIPTION("TWL4030 Battery Charger Interface driver");
 905 MODULE_LICENSE("GPL");
 906 MODULE_ALIAS("platform:twl4030_bci");