drivers/power/twl4030_bci_battery.c

   1 /*
   2  * linux/drivers/power/twl4030_bci_battery.c
   3  *
   4  * OMAP2430/3430 BCI battery driver for Linux
   5  *
   6  * Copyright (C) 2008 Texas Instruments, Inc.
   7  * Author: Texas Instruments, Inc.
   8  *
   9  * This package is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  *
  13  * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  15  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  16  */
  17
  18 /* Boot with automatic charge */
  19 #define CHARGE_MODE 1
  20
  21 #include <linux/init.h>
  22 #include <linux/module.h>
  23 #include <linux/device.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/delay.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/i2c/twl4030.h>
  28 #include <linux/power_supply.h>
  29 #include <linux/i2c/twl4030-madc.h>
  30
  31 #define T2_BATTERY_VOLT         0x04
  32 #define T2_BATTERY_TEMP         0x06
  33 #define T2_BATTERY_CUR          0x08
  34
  35 /* charger constants */
  36 #define NO_PW_CONN              0
  37 #define AC_PW_CONN              0x01
  38 #define USB_PW_CONN             0x02
  39
  40 /* TWL4030_MODULE_USB */
  41 #define REG_POWER_CTRL          0x0AC
  42 #define OTG_EN                  0x020
  43 #define REG_PHY_CLK_CTRL        0x0FE
  44 #define REG_PHY_CLK_CTRL_STS    0x0FF
  45 #define PHY_DPLL_CLK            0x01
  46
  47 #define REG_BCICTL1             0x023
  48 #define REG_BCICTL2             0x024
  49 #define CGAIN                   0x020
  50 #define ITHEN                   0x010
  51 #define ITHSENS                 0x007
  52
  53 /* Boot BCI flag bits */
  54 #define BCIAUTOWEN              0x020
  55 #define CONFIG_DONE             0x010
  56 #define CVENAC                  0x004
  57 #define BCIAUTOUSB              0x002
  58 #define BCIAUTOAC               0x001
  59 #define BCIMSTAT_MASK           0x03F
  60
  61 /* Boot BCI register */
  62 #define REG_BOOT_BCI            0x007
  63 #define REG_CTRL1               0x00
  64 #define REG_SW1SELECT_MSB       0x07
  65 #define SW1_CH9_SEL             0x02
  66 #define REG_CTRL_SW1            0x012
  67 #define SW1_TRIGGER             0x020
  68 #define EOC_SW1                 0x002
  69 #define REG_GPCH9               0x049
  70 #define REG_STS_HW_CONDITIONS   0x0F
  71 #define STS_VBUS                0x080
  72 #define STS_CHG                 0x02
  73 #define STS_USB_ID              0x04
  74 #define REG_BCIMSTATEC          0x02
  75 #define REG_BCIMFSTS4           0x010
  76 #define REG_BCIMFSTS2           0x00E
  77 #define REG_BCIMFSTS3           0x00F
  78 #define REG_BCIMFSTS1           0x001
  79 #define USBFASTMCHG             0x004
  80 #define BATSTSPCHG              0x004
  81 #define BATSTSMCHG              0x040
  82 #define VBATOV4                 0x020
  83 #define VBATOV3                 0x010
  84 #define VBATOV2                 0x008
  85 #define VBATOV1                 0x004
  86 #define REG_BB_CFG              0x012
  87 #define BBCHEN                  0x010
  88
  89 /* GPBR */
  90 #define REG_GPBR1               0x0c
  91 #define MADC_HFCLK_EN           0x80
  92 #define DEFAULT_MADC_CLK_EN     0x10
  93
  94 /* Power supply charge interrupt */
  95 #define REG_PWR_ISR1            0x00
  96 #define REG_PWR_IMR1            0x01
  97 #define REG_PWR_EDR1            0x05
  98 #define REG_PWR_SIH_CTRL        0x007
  99
 100 #define USB_PRES                0x004
 101 #define CHG_PRES                0x002
 102
 103 #define USB_PRES_RISING         0x020
 104 #define USB_PRES_FALLING        0x010
 105 #define CHG_PRES_RISING         0x008
 106 #define CHG_PRES_FALLING        0x004
 107 #define AC_STATEC               0x20
 108 #define USB_STATEC              0x10
 109 #define COR                     0x004
 110
 111 /* interrupt status registers */
 112 #define REG_BCIISR1A            0x0
 113 #define REG_BCIISR2A            0x01
 114
 115 /* Interrupt flags bits BCIISR1 */
 116 #define BATSTS_ISR1             0x080
 117 #define VBATLVL_ISR1            0x001
 118
 119 /* Interrupt mask registers for int1*/
 120 #define REG_BCIIMR1A            0x002
 121 #define REG_BCIIMR2A            0x003
 122
 123  /* Interrupt masks for BCIIMR1 */
 124 #define BATSTS_IMR1             0x080
 125 #define VBATLVL_IMR1            0x001
 126
 127 /* Interrupt edge detection register */
 128 #define REG_BCIEDR1             0x00A
 129 #define REG_BCIEDR2             0x00B
 130 #define REG_BCIEDR3             0x00C
 131
 132 /* BCIEDR2 */
 133 #define BATSTS_EDRRISIN         0x080
 134 #define BATSTS_EDRFALLING       0x040
 135
 136 /* BCIEDR3 */
 137 #define VBATLVL_EDRRISIN        0x02
 138
 139 /* BCIIREF1 */
 140 #define REG_BCIIREF1            0x027
 141 #define REG_BCIIREF2            0x028
 142
 143 /* BCIMFTH1 */
 144 #define REG_BCIMFTH1            0x016
 145
 146 /* Key */
 147 #define KEY_IIREF               0xE7
 148 #define KEY_FTH1                0xD2
 149 #define REG_BCIMFKEY            0x011
 150
 151 /* Step size and prescaler ratio */
 152 #define TEMP_STEP_SIZE          147
 153 #define TEMP_PSR_R              100
 154
 155 #define VOLT_STEP_SIZE          588
 156 #define VOLT_PSR_R              100
 157
 158 #define BK_VOLT_STEP_SIZE       441
 159 #define BK_VOLT_PSR_R           100
 160
 161 #define ENABLE          1
 162 #define DISABLE         1
 163
 164 struct twl4030_bci_device_info {
 165         struct device           *dev;
 166
 167         unsigned long           update_time;
 168         int                     voltage_uV;
 169         int                     bk_voltage_uV;
 170         int                     current_uA;
 171         int                     temp_C;
 172         int                     charge_status;
 173         int                     charge_source;
 174         int                     usb_current;
 175         int                     ac_current;
 176
 177         struct power_supply     bat;
 178         struct power_supply     bk_bat;
 179         struct delayed_work     twl4030_bci_monitor_work;
 180         struct delayed_work     twl4030_bk_bci_monitor_work;
 181
 182         struct twl4030_bci_platform_data *pdata;
 183 };
 184
 185 static int LVL_1, LVL_2, LVL_3, LVL_4;
 186
 187 static int read_bci_val(u8 reg_1);
 188 static inline int clear_n_set(u8 mod_no, u8 clear, u8 set, u8 reg);
 189 static int twl4030charger_presence(void);
 190
 191 /*
 192  * Report and clear the charger presence event.
 193  */
 194 static inline int twl4030charger_presence_evt(void)
 195 {
 196         int ret;
 197         u8 chg_sts, set = 0, clear = 0;
 198
 199         /* read charger power supply status */
 200         ret = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &chg_sts,
 201                 REG_STS_HW_CONDITIONS);
 202         if (ret)
 203                 return IRQ_NONE;
 204
 205         if (chg_sts & STS_CHG) { /* If the AC charger have been connected */
 206                 /* configuring falling edge detection for CHG_PRES */
 207                 set = CHG_PRES_FALLING;
 208                 clear = CHG_PRES_RISING;
 209         } else { /* If the AC charger have been disconnected */
 210                 /* configuring rising edge detection for CHG_PRES */
 211                 set = CHG_PRES_RISING;
 212                 clear = CHG_PRES_FALLING;
 213         }
 214
 215         /* Update the interrupt edge detection register */
 216         clear_n_set(TWL4030_MODULE_INT, clear, set, REG_PWR_EDR1);
 217
 218         return 0;
 219 }
 220
 221 /*
 222  * Interrupt service routine
 223  *
 224  * Attends to TWL 4030 power module interruptions events, specifically
 225  * USB_PRES (USB charger presence) CHG_PRES (AC charger presence) events
 226  *
 227  */
 228 static irqreturn_t twl4030charger_interrupt(int irq, void *_di)
 229 {
 230         struct twl4030_bci_device_info *di = _di;
 231
 232 #ifdef CONFIG_LOCKDEP
 233         /* WORKAROUND for lockdep forcing IRQF_DISABLED on us, which
 234          * we don't want and can't tolerate.  Although it might be
 235          * friendlier not to borrow this thread context...
 236          */
 237         local_irq_enable();
 238 #endif
 239
 240         twl4030charger_presence_evt();
 241         cancel_delayed_work(&di->twl4030_bci_monitor_work);
 242         schedule_delayed_work(&di->twl4030_bci_monitor_work, 0);
 243
 244         return IRQ_HANDLED;
 245 }
 246
 247 /*
 248  * This function handles the twl4030 battery presence interrupt
 249  */
 250 static int twl4030battery_presence_evt(void)
 251 {
 252         int ret;
 253         u8 batstsmchg, batstspchg;
 254
 255         /* check for the battery presence in main charge*/
 256         ret = twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE,
 257                         &batstsmchg, REG_BCIMFSTS3);
 258         if (ret)
 259                 return ret;
 260
 261         /* check for the battery presence in precharge */
 262         ret = twl4030_i2c_read_u8(TWL4030_MODULE_PRECHARGE,
 263                         &batstspchg, REG_BCIMFSTS1);
 264         if (ret)
 265                 return ret;
 266
 267         /*
 268          * REVISIT: Physically inserting/removing the batt
 269          * does not seem to generate an int on 3430ES2 SDP.
 270          */
 271         if ((batstspchg & BATSTSPCHG) || (batstsmchg & BATSTSMCHG)) {
 272                 /* In case of the battery insertion event */
 273                 ret = clear_n_set(TWL4030_MODULE_INTERRUPTS, BATSTS_EDRRISIN,
 274                         BATSTS_EDRFALLING, REG_BCIEDR2);
 275                 if (ret)
 276                         return ret;
 277         } else {
 278                 /* In case of the battery removal event */
 279                 ret = clear_n_set(TWL4030_MODULE_INTERRUPTS, BATSTS_EDRFALLING,
 280                         BATSTS_EDRRISIN, REG_BCIEDR2);
 281                 if (ret)
 282                         return ret;
 283         }
 284
 285         return 0;
 286 }
 287
 288 /*
 289  * This function handles the twl4030 battery voltage level interrupt.
 290  */
 291 static int twl4030battery_level_evt(void)
 292 {
 293         int ret;
 294         u8 mfst;
 295
 296         /* checking for threshold event */
 297         ret = twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE,
 298                         &mfst, REG_BCIMFSTS2);
 299         if (ret)
 300                 return ret;
 301
 302         /* REVISIT could use a bitmap */
 303         if (mfst & VBATOV4) {
 304                 LVL_4 = 1;
 305                 LVL_3 = 0;
 306                 LVL_2 = 0;
 307                 LVL_1 = 0;
 308         } else if (mfst & VBATOV3) {
 309                 LVL_4 = 0;
 310                 LVL_3 = 1;
 311                 LVL_2 = 0;
 312                 LVL_1 = 0;
 313         } else if (mfst & VBATOV2) {
 314                 LVL_4 = 0;
 315                 LVL_3 = 0;
 316                 LVL_2 = 1;
 317                 LVL_1 = 0;
 318         } else {
 319                 LVL_4 = 0;
 320                 LVL_3 = 0;
 321                 LVL_2 = 0;
 322                 LVL_1 = 1;
 323         }
 324
 325         return 0;
 326 }
 327
 328 /*
 329  * Interrupt service routine
 330  *
 331  * Attends to BCI interruptions events,
 332  * specifically BATSTS (battery connection and removal)
 333  * VBATOV (main battery voltage threshold) events
 334  *
 335  */
 336 static irqreturn_t twl4030battery_interrupt(int irq, void *_di)
 337 {
 338         u8 isr1a_val, isr2a_val, clear_2a, clear_1a;
 339         int ret;
 340
 341 #ifdef CONFIG_LOCKDEP
 342         /* WORKAROUND for lockdep forcing IRQF_DISABLED on us, which
 343          * we don't want and can't tolerate.  Although it might be
 344          * friendlier not to borrow this thread context...
 345          */
 346         local_irq_enable();
 347 #endif
 348
 349         ret = twl4030_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &isr1a_val,
 350                                 REG_BCIISR1A);
 351         if (ret)
 352                 return IRQ_NONE;
 353
 354         ret = twl4030_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &isr2a_val,
 355                                 REG_BCIISR2A);
 356         if (ret)
 357                 return IRQ_NONE;
 358
 359         clear_2a = (isr2a_val & VBATLVL_ISR1) ? (VBATLVL_ISR1) : 0;
 360         clear_1a = (isr1a_val & BATSTS_ISR1) ? (BATSTS_ISR1) : 0;
 361
 362         /* cleaning BCI interrupt status flags */
 363         ret = twl4030_i2c_write_u8(TWL4030_MODULE_INTERRUPTS,
 364                         clear_1a , REG_BCIISR1A);
 365         if (ret)
 366                 return IRQ_NONE;
 367
 368         ret = twl4030_i2c_write_u8(TWL4030_MODULE_INTERRUPTS,
 369                         clear_2a , REG_BCIISR2A);
 370         if (ret)
 371                 return IRQ_NONE;
 372
 373         /* battery connetion or removal event */
 374         if (isr1a_val & BATSTS_ISR1)
 375                 twl4030battery_presence_evt();
 376         /* battery voltage threshold event*/
 377         else if (isr2a_val & VBATLVL_ISR1)
 378                 twl4030battery_level_evt();
 379         else
 380                 return IRQ_NONE;
 381
 382         return IRQ_HANDLED;
 383 }
 384
 385 /*
 386  * Enable/Disable hardware battery level event notifications.
 387  */
 388 static int twl4030battery_hw_level_en(int enable)
 389 {
 390         int ret;
 391
 392         if (enable) {
 393                 /* unmask VBATOV interrupt for INT1 */
 394                 ret = clear_n_set(TWL4030_MODULE_INTERRUPTS, VBATLVL_IMR1,
 395                         0, REG_BCIIMR2A);
 396                 if (ret)
 397                         return ret;
 398
 399                 /* configuring interrupt edge detection for VBATOv */
 400                 ret = clear_n_set(TWL4030_MODULE_INTERRUPTS, 0,
 401                         VBATLVL_EDRRISIN, REG_BCIEDR3);
 402                 if (ret)
 403                         return ret;
 404         } else {
 405                 /* mask VBATOV interrupt for INT1 */
 406                 ret = clear_n_set(TWL4030_MODULE_INTERRUPTS, 0,
 407                         VBATLVL_IMR1, REG_BCIIMR2A);
 408                 if (ret)
 409                         return ret;
 410         }
 411
 412         return 0;
 413 }
 414
 415 /*
 416  * Enable/disable hardware battery presence event notifications.
 417  */
 418 static int twl4030battery_hw_presence_en(int enable)
 419 {
 420         int ret;
 421
 422         if (enable) {
 423                 /* unmask BATSTS interrupt for INT1 */
 424                 ret = clear_n_set(TWL4030_MODULE_INTERRUPTS, BATSTS_IMR1,
 425                         0, REG_BCIIMR1A);
 426                 if (ret)
 427                         return ret;
 428
 429                 /* configuring interrupt edge for BATSTS */
 430                 ret = clear_n_set(TWL4030_MODULE_INTERRUPTS, 0,
 431                         BATSTS_EDRRISIN | BATSTS_EDRFALLING, REG_BCIEDR2);
 432                 if (ret)
 433                         return ret;
 434         } else {
 435                 /* mask BATSTS interrupt for INT1 */
 436                 ret = clear_n_set(TWL4030_MODULE_INTERRUPTS, 0,
 437                         BATSTS_IMR1, REG_BCIIMR1A);
 438                 if (ret)
 439                         return ret;
 440         }
 441
 442         return 0;
 443 }
 444
 445 /*
 446  * Enable/Disable AC Charge funtionality.
 447  */
 448 static int twl4030charger_ac_en(int enable, int automatic)
 449 {
 450         int ret;
 451
 452         if (enable) {
 453                 /* forcing the field BCIAUTOAC (BOOT_BCI[0) to 1 */
 454                 if(!automatic) {
 455                         ret = clear_n_set(TWL4030_MODULE_PM_MASTER, BCIAUTOAC | CVENAC,
 456                                 (CONFIG_DONE | BCIAUTOWEN),
 457                                 REG_BOOT_BCI);
 458                 } else {
 459                         ret = clear_n_set(TWL4030_MODULE_PM_MASTER, 0,
 460                                 (CONFIG_DONE | BCIAUTOWEN | BCIAUTOAC | CVENAC),
 461                                 REG_BOOT_BCI);
 462                 }
 463                 if (ret)
 464                         return ret;
 465         } else {
 466                 /* forcing the field BCIAUTOAC (BOOT_BCI[0) to 0*/
 467                 ret = clear_n_set(TWL4030_MODULE_PM_MASTER, BCIAUTOAC,
 468                         (CONFIG_DONE | BCIAUTOWEN),
 469                         REG_BOOT_BCI);
 470                 if (ret)
 471                         return ret;
 472         }
 473
 474         return 0;
 475 }
 476
 477 /*
 478  * Enable/Disable USB Charge funtionality.
 479  */
 480 int twl4030charger_usb_en(int enable)
 481 {
 482         int ret;
 483
 484         if (enable) {
 485                 /* Check for USB charger conneted */
 486                 ret = twl4030charger_presence();
 487                 if (ret < 0)
 488                         return ret;
 489
 490                 if (!(ret & USB_PW_CONN))
 491                         return -ENXIO;
 492
 493                 /* forcing the field BCIAUTOUSB (BOOT_BCI[1]) to 1 */
 494                 ret = clear_n_set(TWL4030_MODULE_PM_MASTER, 0,
 495                         (CONFIG_DONE | BCIAUTOWEN | BCIAUTOUSB),
 496                         REG_BOOT_BCI);
 497                 if (ret)
 498                         return ret;
 499
 500                 /* forcing USBFASTMCHG(BCIMFSTS4[2]) to 1 */
 501                 ret = clear_n_set(TWL4030_MODULE_MAIN_CHARGE, 0,
 502                         USBFASTMCHG, REG_BCIMFSTS4);
 503                 if (ret)
 504                         return ret;
 505         } else {
 506                 ret = clear_n_set(TWL4030_MODULE_PM_MASTER, BCIAUTOUSB,
 507                         (CONFIG_DONE | BCIAUTOWEN), REG_BOOT_BCI);
 508                 if (ret)
 509                         return ret;
 510         }
 511
 512         return 0;
 513 }
 514
 515 /*
 516  * Return battery temperature
 517  * Or < 0 on failure.
 518  */
 519 static int twl4030battery_temperature(struct twl4030_bci_device_info *di)
 520 {
 521         u8 val;
 522         int temp, curr, volt, res, ret;
 523
 524         /* Is a temperature table specified? */
 525         if (!di->pdata->tblsize)
 526                 return 0;
 527
 528         /* Getting and calculating the thermistor voltage */
 529         ret = read_bci_val(T2_BATTERY_TEMP);
 530         if (ret < 0)
 531                 return ret;
 532
 533         volt = (ret * TEMP_STEP_SIZE) / TEMP_PSR_R;
 534
 535         /* Getting and calculating the supply current in micro ampers */
 536         ret = twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &val,
 537                  REG_BCICTL2);
 538         if (ret)
 539                 return 0;
 540
 541         curr = ((val & ITHSENS) + 1) * 10;
 542
 543         /* Getting and calculating the thermistor resistance in ohms*/
 544         res = volt * 1000 / curr;
 545
 546         /*calculating temperature*/
 547         for (temp = 58; temp >= 0; temp--) {
 548                 int actual = di->pdata->battery_tmp_tbl[temp];
 549                 if ((actual - res) >= 0)
 550                         break;
 551         }
 552
 553         /* Negative temperature */
 554         if (temp < 3) {
 555                 if (temp == 2)
 556                         temp = -1;
 557                 else if (temp == 1)
 558                         temp = -2;
 559                 else
 560                         temp = -3;
 561         }
 562
 563         return temp + 1;
 564 }
 565
 566 /*
 567  * Return battery voltage
 568  * Or < 0 on failure.
 569  */
 570 static int twl4030battery_voltage(void)
 571 {
 572         int volt = read_bci_val(T2_BATTERY_VOLT);
 573
 574         return (volt * VOLT_STEP_SIZE) / VOLT_PSR_R;
 575 }
 576
 577 /*
 578  * Return the battery current
 579  * Or < 0 on failure.
 580  */
 581 static int twl4030battery_current(void)
 582 {
 583         int ret, curr = read_bci_val(T2_BATTERY_CUR);
 584         u8 val;
 585
 586         ret = twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &val,
 587                 REG_BCICTL1);
 588         if (ret)
 589                 return ret;
 590
 591         if (val & CGAIN)
 592                 //ret = (int)((float)curr * 1.6617790811339199f * 2.0f - 1.7f);
 593                 ret = curr * 16618 * 2 - 1700 * 10000;
 594         else
 595                 //ret = (int)((float)curr * 1.6617790811339199f - 0.85f);
 596                 ret = curr * 16618 - 850 * 10000;
 597         ret /= 10000;
 598         return ret;
 599 }
 600
 601 /*
 602  * Return the battery backup voltage
 603  * Or < 0 on failure.
 604  */
 605 static int twl4030backupbatt_voltage(void)
 606 {
 607         struct twl4030_madc_request req;
 608         int temp;
 609
 610         req.channels = (1 << 9);
 611         req.do_avg = 0;
 612         req.method = TWL4030_MADC_SW1;
 613         req.active = 0;
 614         req.func_cb = NULL;
 615         twl4030_madc_conversion(&req);
 616         temp = (u16)req.rbuf[9];
 617
 618         return  (temp * BK_VOLT_STEP_SIZE) / BK_VOLT_PSR_R;
 619 }
 620
 621 /*
 622  * Returns an integer value, that means,
 623  * NO_PW_CONN  no power supply is connected
 624  * AC_PW_CONN  if the AC power supply is connected
 625  * USB_PW_CONN  if the USB power supply is connected
 626  * AC_PW_CONN + USB_PW_CONN if USB and AC power supplies are both connected
 627  *
 628  * Or < 0 on failure.
 629  */
 630 static int twl4030charger_presence(void)
 631 {
 632         int ret;
 633         u8 hwsts;
 634
 635         ret = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &hwsts,
 636                 REG_STS_HW_CONDITIONS);
 637         if (ret) {
 638                 pr_err("twl4030_bci: error reading STS_HW_CONDITIONS\n");
 639                 return ret;
 640         }
 641
 642         ret = (hwsts & STS_CHG) ? AC_PW_CONN : NO_PW_CONN;
 643
 644         /* in case we have STS_USB_ID, VBUS is driven by TWL itself */
 645         if ((hwsts & STS_VBUS) && !(hwsts & STS_USB_ID))
 646                 ret |= USB_PW_CONN;
 647
 648         pr_debug("USB charger: %d, HW_CONDITIONS %02x\n",
 649                 !!(ret & USB_PW_CONN), hwsts);
 650
 651         return ret;
 652 }
 653
 654 /*
 655  * Returns the main charge FSM status
 656  * Or < 0 on failure.
 657  */
 658 static int twl4030bci_status(void)
 659 {
 660         int ret;
 661         u8 status;
 662
 663         ret = twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE,
 664                 &status, REG_BCIMSTATEC);
 665         if (ret) {
 666                 pr_err("twl4030_bci: error reading BCIMSTATEC\n");
 667                 return ret;
 668         }
 669
 670         return (int) (status & BCIMSTAT_MASK);
 671 }
 672
 673 static int is_charge_state(int status)
 674 {
 675         status &= 0x0f;
 676         return (1 < status && status < 8);
 677 }
 678
 679 static int read_bci_val(u8 reg)
 680 {
 681         int ret, temp;
 682         u8 val;
 683
 684         /* reading MSB */
 685         ret = twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &val,
 686                 reg + 1);
 687         if (ret)
 688                 return ret;
 689
 690         temp = ((int)(val & 0x03)) << 8;
 691
 692         /* reading LSB */
 693         ret = twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &val,
 694                 reg);
 695         if (ret)
 696                 return ret;
 697
 698         return temp | val;
 699 }
 700
 701 /*
 702  * Settup the twl4030 BCI module to enable backup
 703  * battery charging.
 704  */
 705 static int twl4030backupbatt_voltage_setup(void)
 706 {
 707         int ret;
 708
 709         /* Starting backup batery charge */
 710         ret = clear_n_set(TWL4030_MODULE_PM_RECEIVER, 0, BBCHEN,
 711                 REG_BB_CFG);
 712         if (ret)
 713                 return ret;
 714
 715         return 0;
 716 }
 717
 718 /*
 719  * Settup the twl4030 BCI module to measure battery
 720  * temperature
 721  */
 722 static int twl4030battery_temp_setup(void)
 723 {
 724         u8 ret;
 725
 726         /* Enabling thermistor current */
 727         ret = clear_n_set(TWL4030_MODULE_MAIN_CHARGE, 0, 0x1B,
 728                 REG_BCICTL1);
 729         if (ret)
 730                 return ret;
 731
 732         return 0;
 733 }
 734
 735 /*
 736  * Sets and clears bits on an given register on a given module
 737  */
 738 static inline int clear_n_set(u8 mod_no, u8 clear, u8 set, u8 reg)
 739 {
 740         int ret;
 741         u8 val = 0;
 742
 743         /* Gets the initial register value */
 744         ret = twl4030_i2c_read_u8(mod_no, &val, reg);
 745         if (ret)
 746                 return ret;
 747         /* Clearing all those bits to clear */
 748         val &= ~(clear);
 749
 750         /* Setting all those bits to set */
 751         val |= set;
 752
 753         /* Update the register */
 754         ret = twl4030_i2c_write_u8(mod_no, val, reg);
 755         if (ret)
 756                 return ret;
 757
 758         return 0;
 759 }
 760
 761 int set_charge_current(int new_current)
 762 {
 763         u8 tmp, boot_bci_prev;
 764         int i, ret;
 765
 766         ret = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &boot_bci_prev, REG_BOOT_BCI);
 767         if (ret)
 768                 return ret;
 769
 770         /* Leave automatic mode as some things cannot be changed there. */
 771         ret = clear_n_set(TWL4030_MODULE_PM_MASTER, BCIAUTOAC | BCIAUTOUSB | CVENAC,
 772                         (CONFIG_DONE | BCIAUTOWEN), REG_BOOT_BCI);
 773         if (ret)
 774                 return ret;
 775
 776         ret = twl4030_i2c_write_u8(TWL4030_MODULE_MAIN_CHARGE, KEY_IIREF, REG_BCIMFKEY);
 777         if (ret)
 778                 return ret;
 779
 780         ret = twl4030_i2c_write_u8(TWL4030_MODULE_MAIN_CHARGE, new_current & 0xff, REG_BCIIREF1);
 781         if (ret)
 782                 return ret;
 783
 784         ret = twl4030_i2c_write_u8(TWL4030_MODULE_MAIN_CHARGE, KEY_IIREF, REG_BCIMFKEY);
 785         if (ret)
 786                 return ret;
 787
 788         ret = twl4030_i2c_write_u8(TWL4030_MODULE_MAIN_CHARGE, (new_current >> 8) & 0x1, REG_BCIIREF2);
 789         if (ret)
 790                 return ret;
 791
 792         /* Set CGAIN = 0 or 1 */
 793         if (new_current > 511) {
 794                 /* Set CGAIN = 1 -- need to wait until automatic charge turns off */
 795                 for (i = 0; i < 10; i++) {
 796                         clear_n_set(TWL4030_MODULE_MAIN_CHARGE, 0, CGAIN | 0x1B, REG_BCICTL1);
 797                         twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &tmp, REG_BCICTL1);
 798
 799                         ret = tmp & CGAIN;
 800                         if (ret)
 801                                 break;
 802                         mdelay(50);
 803                 }
 804         } else {
 805                 /* Set CGAIN = 0 -- need to wait until automatic charge turns off */
 806                 for (i = 0; i < 10; i++) {
 807                         clear_n_set(TWL4030_MODULE_MAIN_CHARGE, CGAIN, 0x1B, REG_BCICTL1);
 808                         twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &tmp, REG_BCICTL1);
 809
 810                         ret = !(tmp & CGAIN);
 811                         if (ret)
 812                                 break;
 813                         mdelay(50);
 814                 }
 815         }
 816
 817         if (!ret)
 818                 pr_err("CGAIN change failed\n");
 819
 820         ret = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, boot_bci_prev, REG_BOOT_BCI);
 821
 822         return ret;
 823 }
 824
 825 static enum power_supply_property twl4030_bci_battery_props[] = {
 826         POWER_SUPPLY_PROP_STATUS,
 827         POWER_SUPPLY_PROP_ONLINE,
 828         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 829         POWER_SUPPLY_PROP_CURRENT_NOW,
 830         POWER_SUPPLY_PROP_CAPACITY,
 831         POWER_SUPPLY_PROP_TEMP,
 832 };
 833
 834 static enum power_supply_property twl4030_bk_bci_battery_props[] = {
 835         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 836 };
 837
 838 static void
 839 twl4030_bk_bci_battery_read_status(struct twl4030_bci_device_info *di)
 840 {
 841         di->bk_voltage_uV = twl4030backupbatt_voltage();
 842 }
 843
 844 static void twl4030_bk_bci_battery_work(struct work_struct *work)
 845 {
 846         struct twl4030_bci_device_info *di = container_of(work,
 847                 struct twl4030_bci_device_info,
 848                 twl4030_bk_bci_monitor_work.work);
 849
 850         if(!di->pdata->no_backup_battery)
 851                 twl4030_bk_bci_battery_read_status(di);
 852         schedule_delayed_work(&di->twl4030_bk_bci_monitor_work, 500);
 853 }
 854
 855 static void twl4030_bci_battery_read_status(struct twl4030_bci_device_info *di)
 856 {
 857         di->temp_C = twl4030battery_temperature(di);
 858         di->voltage_uV = twl4030battery_voltage();
 859         di->current_uA = twl4030battery_current();
 860 }
 861
 862 static void twl4030_bci_battery_work(struct work_struct *work)
 863 {
 864         struct twl4030_bci_device_info *di = container_of(work,
 865                 struct twl4030_bci_device_info, twl4030_bci_monitor_work.work);
 866         int source;
 867
 868         twl4030_bci_battery_read_status(di);
 869
 870         source = power_supply_am_i_supplied(&di->bat);
 871         if (source)
 872                 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
 873         else
 874                 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
 875
 876         if (source != di->charge_source) {
 877                 pr_debug("charge source changed to %d\n", source);
 878
 879                 di->charge_source = source;
 880                 power_supply_changed(&di->bat);
 881                 if (source == POWER_SUPPLY_TYPE_MAINS)
 882                         set_charge_current(di->ac_current);
 883                 else
 884                         set_charge_current(di->usb_current);
 885         }
 886
 887         schedule_delayed_work(&di->twl4030_bci_monitor_work, HZ);
 888 }
 889
 890 #define to_twl4030_bk_bci_device_info(x) container_of((x), \
 891                 struct twl4030_bci_device_info, bk_bat);
 892
 893 static ssize_t
 894 show_charge_current(struct device *dev, struct device_attribute *attr, char *buf)
 895 {
 896         u8  ctl;
 897         int ret = read_bci_val(REG_BCIIREF1) & 0x1FF;
 898         twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, &ctl, REG_BCICTL1);
 899
 900         if (ctl & CGAIN)
 901                 ret |= 0x200;
 902
 903 #ifdef DEBUG
 904         /* Dump debug */
 905         twl4030battery_temp_setup();
 906 #endif
 907
 908         return sprintf(buf, "%d\n", ret);
 909 }
 910
 911 static ssize_t
 912 store_charge_current(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 913 {
 914         struct twl4030_bci_device_info *di = dev_get_drvdata(dev);
 915         unsigned long new_current;
 916         int ret;
 917
 918         ret = strict_strtoul(buf, 10, &new_current);
 919         if (ret)
 920                 return -EINVAL;
 921
 922         ret = set_charge_current(new_current);
 923         if (ret)
 924                 return ret;
 925
 926         if (di->charge_source == POWER_SUPPLY_TYPE_MAINS)
 927                 di->ac_current = new_current;
 928         else
 929                 di->usb_current = new_current;
 930
 931         return count;
 932 }
 933 static DEVICE_ATTR(charge_current, S_IRUGO | S_IWUSR, show_charge_current, store_charge_current);
 934
 935 static int twl4030_bk_bci_battery_get_property(struct power_supply *psy,
 936                                         enum power_supply_property psp,
 937                                         union power_supply_propval *val)
 938 {
 939         struct twl4030_bci_device_info *di = to_twl4030_bk_bci_device_info(psy);
 940
 941         switch (psp) {
 942         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 943                 val->intval = di->bk_voltage_uV;
 944                 break;
 945         default:
 946                 return -EINVAL;
 947         }
 948
 949         return 0;
 950 }
 951
 952 #define to_twl4030_bci_device_info(x) container_of((x), \
 953                         struct twl4030_bci_device_info, bat);
 954
 955 static int twl4030_bci_battery_get_property(struct power_supply *psy,
 956                                         enum power_supply_property psp,
 957                                         union power_supply_propval *val)
 958 {
 959         struct twl4030_bci_device_info *di;
 960         int status = 0;
 961
 962         di = to_twl4030_bci_device_info(psy);
 963
 964         switch (psp) {
 965         case POWER_SUPPLY_PROP_STATUS:
 966                 val->intval = di->charge_status;
 967                 return 0;
 968         default:
 969                 break;
 970         }
 971
 972         switch (psp) {
 973         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 974                 val->intval = di->voltage_uV;
 975                 break;
 976         case POWER_SUPPLY_PROP_CURRENT_NOW:
 977                 val->intval = di->current_uA;
 978                 break;
 979         case POWER_SUPPLY_PROP_TEMP:
 980                 val->intval = di->temp_C;
 981                 break;
 982         case POWER_SUPPLY_PROP_ONLINE:
 983                 status = twl4030bci_status();
 984                 if ((status & AC_STATEC) && is_charge_state(status))
 985                         val->intval = POWER_SUPPLY_TYPE_MAINS;
 986                 else if ((status & USB_STATEC) && is_charge_state(status))
 987                         val->intval = POWER_SUPPLY_TYPE_USB;
 988                 else
 989                         val->intval = 0;
 990                 break;
 991         case POWER_SUPPLY_PROP_CAPACITY:
 992                 /*
 993                  * need to get the correct percentage value per the
 994                  * battery characteristics. Approx values for now.
 995                  */
 996                 if (di->voltage_uV < 2894 || LVL_1) {
 997                         val->intval = 5;
 998                         LVL_1 = 0;
 999                 } else if ((di->voltage_uV < 3451 && di->voltage_uV > 2894)
1000                         || LVL_2) {
1001                         val->intval = 20;
1002                         LVL_2 = 0;
1003                 } else if ((di->voltage_uV < 3902 && di->voltage_uV > 3451)
1004                         || LVL_3) {
1005                         val->intval = 50;
1006                         LVL_3 = 0;
1007                 } else if ((di->voltage_uV < 3949 && di->voltage_uV > 3902)
1008                         || LVL_4) {
1009                         val->intval = 75;
1010                         LVL_4 = 0;
1011                 } else if (di->voltage_uV > 3949)
1012                         val->intval = 90;
1013                 break;
1014         default:
1015                 return -EINVAL;
1016         }
1017         return 0;
1018 }
1019
1020 static char *twl4030_bci_supplied_to[] = {
1021         "twl4030_bci_battery",
1022 };
1023
1024 static int __init twl4030_bci_battery_probe(struct platform_device *pdev)
1025 {
1026         struct twl4030_bci_platform_data *pdata = pdev->dev.platform_data;
1027         struct twl4030_bci_device_info *di;
1028         int irq;
1029         int ret;
1030
1031         di = kzalloc(sizeof(*di), GFP_KERNEL);
1032         if (!di)
1033                 return -ENOMEM;
1034
1035         di->dev = &pdev->dev;
1036         di->bat.name = "twl4030_bci_battery";
1037         di->bat.supplied_to = twl4030_bci_supplied_to;
1038         di->bat.num_supplicants = ARRAY_SIZE(twl4030_bci_supplied_to);
1039         di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
1040         di->bat.properties = twl4030_bci_battery_props;
1041         di->bat.num_properties = ARRAY_SIZE(twl4030_bci_battery_props);
1042         di->bat.get_property = twl4030_bci_battery_get_property;
1043         di->bat.external_power_changed = NULL;
1044
1045         di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
1046         di->ac_current = 820; /* ~1A */
1047         di->usb_current = 360; /* ~600mA */
1048
1049         di->bk_bat.name = "twl4030_bci_bk_battery";
1050         di->bk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
1051         di->bk_bat.properties = twl4030_bk_bci_battery_props;
1052         di->bk_bat.num_properties = ARRAY_SIZE(twl4030_bk_bci_battery_props);
1053         di->bk_bat.get_property = twl4030_bk_bci_battery_get_property;
1054         di->bk_bat.external_power_changed = NULL;
1055         di->pdata = pdata;
1056
1057         /* Set up clocks */
1058         clear_n_set(TWL4030_MODULE_INTBR, 0,
1059                         MADC_HFCLK_EN | DEFAULT_MADC_CLK_EN, REG_GPBR1);
1060
1061         twl4030charger_ac_en(ENABLE, CHARGE_MODE);
1062         twl4030charger_usb_en(ENABLE);
1063         twl4030battery_hw_level_en(ENABLE);
1064         twl4030battery_hw_presence_en(ENABLE);
1065
1066         platform_set_drvdata(pdev, di);
1067
1068         /* settings for temperature sensing */
1069         ret = twl4030battery_temp_setup();
1070         if (ret)
1071                 goto temp_setup_fail;
1072
1073         /* enabling GPCH09 for read back battery voltage */
1074         if(!di->pdata->no_backup_battery)
1075         {
1076                 ret = twl4030backupbatt_voltage_setup();
1077                 if (ret)
1078                         goto voltage_setup_fail;
1079         }
1080
1081         /* REVISIT do we need to request both IRQs ?? */
1082
1083         /* request BCI interruption */
1084         ret = request_irq(TWL4030_MODIRQ_BCI, twl4030battery_interrupt,
1085                 0, pdev->name, NULL);
1086         if (ret) {
1087                 dev_dbg(&pdev->dev, "could not request irq %d, status %d\n",
1088                         TWL4030_MODIRQ_BCI, ret);
1089                 goto batt_irq_fail;
1090         }
1091
1092         irq = platform_get_irq(pdev, 0);
1093
1094         /* request Power interruption */
1095         ret = request_irq(irq, twl4030charger_interrupt,
1096                 0, pdev->name, di);
1097
1098         if (ret) {
1099                 dev_dbg(&pdev->dev, "could not request irq %d, status %d\n",
1100                         irq, ret);
1101                 goto chg_irq_fail;
1102         }
1103
1104         ret = power_supply_register(&pdev->dev, &di->bat);
1105         if (ret) {
1106                 dev_dbg(&pdev->dev, "failed to register main battery\n");
1107                 goto batt_failed;
1108         }
1109
1110         INIT_DELAYED_WORK_DEFERRABLE(&di->twl4030_bci_monitor_work,
1111                                 twl4030_bci_battery_work);
1112         schedule_delayed_work(&di->twl4030_bci_monitor_work, HZ);
1113
1114         if(!pdata->no_backup_battery)
1115         {
1116                 ret = power_supply_register(&pdev->dev, &di->bk_bat);
1117                 if (ret) {
1118                         dev_dbg(&pdev->dev, "failed to register backup battery\n");
1119                         goto bk_batt_failed;
1120                 }
1121         }
1122
1123         ret = device_create_file(di->bat.dev, &dev_attr_charge_current);
1124         if (ret) {
1125                 dev_err(&pdev->dev, "failed to create sysfs entries\n");
1126                 goto bk_batt_failed;
1127         }
1128
1129         INIT_DELAYED_WORK_DEFERRABLE(&di->twl4030_bk_bci_monitor_work,
1130                                 twl4030_bk_bci_battery_work);
1131         schedule_delayed_work(&di->twl4030_bk_bci_monitor_work, 500);
1132
1133         return 0;
1134
1135 bk_batt_failed:
1136         if(!pdata->no_backup_battery)
1137                 power_supply_unregister(&di->bat);
1138 batt_failed:
1139         free_irq(irq, di);
1140 chg_irq_fail:
1141         free_irq(TWL4030_MODIRQ_BCI, NULL);
1142 batt_irq_fail:
1143 voltage_setup_fail:
1144 temp_setup_fail:
1145         twl4030charger_ac_en(DISABLE, CHARGE_MODE);
1146         twl4030charger_usb_en(DISABLE);
1147         twl4030battery_hw_level_en(DISABLE);
1148         twl4030battery_hw_presence_en(DISABLE);
1149         kfree(di);
1150
1151         return ret;
1152 }
1153
1154 static int __exit twl4030_bci_battery_remove(struct platform_device *pdev)
1155 {
1156         struct twl4030_bci_device_info *di = platform_get_drvdata(pdev);
1157         int irq = platform_get_irq(pdev, 0);
1158
1159         twl4030charger_ac_en(DISABLE, CHARGE_MODE);
1160         twl4030charger_usb_en(DISABLE);
1161         twl4030battery_hw_level_en(DISABLE);
1162         twl4030battery_hw_presence_en(DISABLE);
1163
1164         free_irq(TWL4030_MODIRQ_BCI, NULL);
1165         free_irq(irq, di);
1166
1167         flush_scheduled_work();
1168         power_supply_unregister(&di->bat);
1169         power_supply_unregister(&di->bk_bat);
1170         platform_set_drvdata(pdev, NULL);
1171         kfree(di);
1172
1173         return 0;
1174 }
1175
1176 #ifdef CONFIG_PM
1177 static int twl4030_bci_battery_suspend(struct platform_device *pdev,
1178         pm_message_t state)
1179 {
1180         struct twl4030_bci_device_info *di = platform_get_drvdata(pdev);
1181
1182         di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
1183         cancel_delayed_work(&di->twl4030_bci_monitor_work);
1184         cancel_delayed_work(&di->twl4030_bk_bci_monitor_work);
1185         return 0;
1186 }
1187
1188 static int twl4030_bci_battery_resume(struct platform_device *pdev)
1189 {
1190         struct twl4030_bci_device_info *di = platform_get_drvdata(pdev);
1191
1192         schedule_delayed_work(&di->twl4030_bci_monitor_work, 0);
1193         schedule_delayed_work(&di->twl4030_bk_bci_monitor_work, 50);
1194         return 0;
1195 }
1196 #else
1197 #define twl4030_bci_battery_suspend     NULL
1198 #define twl4030_bci_battery_resume      NULL
1199 #endif /* CONFIG_PM */
1200
1201 static struct platform_driver twl4030_bci_battery_driver = {
1202         .probe          = twl4030_bci_battery_probe,
1203         .remove         = __exit_p(twl4030_bci_battery_remove),
1204         .suspend        = twl4030_bci_battery_suspend,
1205         .resume         = twl4030_bci_battery_resume,
1206         .driver         = {
1207                 .name   = "twl4030_bci",
1208         },
1209 };
1210
1211 MODULE_LICENSE("GPL");
1212 MODULE_ALIAS("platform:twl4030_bci");
1213 MODULE_AUTHOR("Texas Instruments Inc");
1214
1215 static int __init twl4030_battery_init(void)
1216 {
1217         return platform_driver_register(&twl4030_bci_battery_driver);
1218 }
1219 module_init(twl4030_battery_init);
1220
1221 static void __exit twl4030_battery_exit(void)
1222 {
1223         platform_driver_unregister(&twl4030_bci_battery_driver);
1224 }
1225 module_exit(twl4030_battery_exit);
1226