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