drivers/power/supply/twl4030_charger.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * TWL4030/TPS65950 BCI (Battery Charger Interface) driver
   4  *
   5  * Copyright (C) 2010 Gražvydas Ignotas <notasas@gmail.com>
   6  *
   7  * based on twl4030_bci_battery.c by TI
   8  * Copyright (C) 2008 Texas Instruments, Inc.
   9  */
  10
  11 #include <linux/init.h>
  12 #include <linux/module.h>
  13 #include <linux/slab.h>
  14 #include <linux/err.h>
  15 #include <linux/of.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/mfd/twl.h>
  19 #include <linux/power_supply.h>
  20 #include <linux/notifier.h>
  21 #include <linux/usb/otg.h>
  22 #include <linux/iio/consumer.h>
  23
  24 #define TWL4030_BCIMDEN         0x00
  25 #define TWL4030_BCIMDKEY        0x01
  26 #define TWL4030_BCIMSTATEC      0x02
  27 #define TWL4030_BCIICHG         0x08
  28 #define TWL4030_BCIVAC          0x0a
  29 #define TWL4030_BCIVBUS         0x0c
  30 #define TWL4030_BCIMFSTS3       0x0F
  31 #define TWL4030_BCIMFSTS4       0x10
  32 #define TWL4030_BCICTL1         0x23
  33 #define TWL4030_BB_CFG          0x12
  34 #define TWL4030_BCIIREF1        0x27
  35 #define TWL4030_BCIIREF2        0x28
  36 #define TWL4030_BCIMFKEY        0x11
  37 #define TWL4030_BCIMFEN3        0x14
  38 #define TWL4030_BCIMFTH8        0x1d
  39 #define TWL4030_BCIMFTH9        0x1e
  40 #define TWL4030_BCIWDKEY        0x21
  41
  42 #define TWL4030_BCIMFSTS1       0x01
  43
  44 #define TWL4030_BCIAUTOWEN      BIT(5)
  45 #define TWL4030_CONFIG_DONE     BIT(4)
  46 #define TWL4030_CVENAC          BIT(2)
  47 #define TWL4030_BCIAUTOUSB      BIT(1)
  48 #define TWL4030_BCIAUTOAC       BIT(0)
  49 #define TWL4030_CGAIN           BIT(5)
  50 #define TWL4030_USBFASTMCHG     BIT(2)
  51 #define TWL4030_STS_VBUS        BIT(7)
  52 #define TWL4030_STS_USB_ID      BIT(2)
  53 #define TWL4030_BBCHEN          BIT(4)
  54 #define TWL4030_BBSEL_MASK      0x0c
  55 #define TWL4030_BBSEL_2V5       0x00
  56 #define TWL4030_BBSEL_3V0       0x04
  57 #define TWL4030_BBSEL_3V1       0x08
  58 #define TWL4030_BBSEL_3V2       0x0c
  59 #define TWL4030_BBISEL_MASK     0x03
  60 #define TWL4030_BBISEL_25uA     0x00
  61 #define TWL4030_BBISEL_150uA    0x01
  62 #define TWL4030_BBISEL_500uA    0x02
  63 #define TWL4030_BBISEL_1000uA   0x03
  64
  65 #define TWL4030_BATSTSPCHG      BIT(2)
  66 #define TWL4030_BATSTSMCHG      BIT(6)
  67
  68 /* BCI interrupts */
  69 #define TWL4030_WOVF            BIT(0) /* Watchdog overflow */
  70 #define TWL4030_TMOVF           BIT(1) /* Timer overflow */
  71 #define TWL4030_ICHGHIGH        BIT(2) /* Battery charge current high */
  72 #define TWL4030_ICHGLOW         BIT(3) /* Battery cc. low / FSM state change */
  73 #define TWL4030_ICHGEOC         BIT(4) /* Battery current end-of-charge */
  74 #define TWL4030_TBATOR2         BIT(5) /* Battery temperature out of range 2 */
  75 #define TWL4030_TBATOR1         BIT(6) /* Battery temperature out of range 1 */
  76 #define TWL4030_BATSTS          BIT(7) /* Battery status */
  77
  78 #define TWL4030_VBATLVL         BIT(0) /* VBAT level */
  79 #define TWL4030_VBATOV          BIT(1) /* VBAT overvoltage */
  80 #define TWL4030_VBUSOV          BIT(2) /* VBUS overvoltage */
  81 #define TWL4030_ACCHGOV         BIT(3) /* Ac charger overvoltage */
  82
  83 #define TWL4030_MSTATEC_USB             BIT(4)
  84 #define TWL4030_MSTATEC_AC              BIT(5)
  85 #define TWL4030_MSTATEC_MASK            0x0f
  86 #define TWL4030_MSTATEC_QUICK1          0x02
  87 #define TWL4030_MSTATEC_QUICK7          0x07
  88 #define TWL4030_MSTATEC_COMPLETE1       0x0b
  89 #define TWL4030_MSTATEC_COMPLETE4       0x0e
  90
  91 /*
  92  * If AC (Accessory Charger) voltage exceeds 4.5V (MADC 11)
  93  * then AC is available.
  94  */
  95 static inline int ac_available(struct iio_channel *channel_vac)
  96 {
  97         int val, err;
  98
  99         if (!channel_vac)
 100                 return 0;
 101
 102         err = iio_read_channel_processed(channel_vac, &val);
 103         if (err < 0)
 104                 return 0;
 105         return val > 4500;
 106 }
 107
 108 static bool allow_usb;
 109 module_param(allow_usb, bool, 0644);
 110 MODULE_PARM_DESC(allow_usb, "Allow USB charge drawing default current");
 111
 112 struct twl4030_bci {
 113         struct device           *dev;
 114         struct power_supply     *ac;
 115         struct power_supply     *usb;
 116         struct usb_phy          *transceiver;
 117         struct notifier_block   usb_nb;
 118         struct work_struct      work;
 119         int                     irq_chg;
 120         int                     irq_bci;
 121         int                     usb_enabled;
 122
 123         /*
 124          * ichg_* and *_cur values in uA. If any are 'large', we set
 125          * CGAIN to '1' which doubles the range for half the
 126          * precision.
 127          */
 128         unsigned int            ichg_eoc, ichg_lo, ichg_hi;
 129         unsigned int            usb_cur, ac_cur;
 130         struct iio_channel      *channel_vac;
 131         bool                    ac_is_active;
 132         int                     usb_mode, ac_mode; /* charging mode requested */
 133 #define CHARGE_OFF      0
 134 #define CHARGE_AUTO     1
 135 #define CHARGE_LINEAR   2
 136
 137         /* When setting the USB current we slowly increase the
 138          * requested current until target is reached or the voltage
 139          * drops below 4.75V.  In the latter case we step back one
 140          * step.
 141          */
 142         unsigned int            usb_cur_target;
 143         struct delayed_work     current_worker;
 144 #define USB_CUR_STEP    20000   /* 20mA at a time */
 145 #define USB_MIN_VOLT    4750000 /* 4.75V */
 146 #define USB_CUR_DELAY   msecs_to_jiffies(100)
 147 #define USB_MAX_CURRENT 1700000 /* TWL4030 caps at 1.7A */
 148
 149         unsigned long           event;
 150 };
 151
 152 /* strings for 'usb_mode' values */
 153 static const char *modes[] = { "off", "auto", "continuous" };
 154
 155 /*
 156  * clear and set bits on an given register on a given module
 157  */
 158 static int twl4030_clear_set(u8 mod_no, u8 clear, u8 set, u8 reg)
 159 {
 160         u8 val = 0;
 161         int ret;
 162
 163         ret = twl_i2c_read_u8(mod_no, &val, reg);
 164         if (ret)
 165                 return ret;
 166
 167         val &= ~clear;
 168         val |= set;
 169
 170         return twl_i2c_write_u8(mod_no, val, reg);
 171 }
 172
 173 static int twl4030_bci_read(u8 reg, u8 *val)
 174 {
 175         return twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, val, reg);
 176 }
 177
 178 static int twl4030_clear_set_boot_bci(u8 clear, u8 set)
 179 {
 180         return twl4030_clear_set(TWL_MODULE_PM_MASTER, clear,
 181                         TWL4030_CONFIG_DONE | TWL4030_BCIAUTOWEN | set,
 182                         TWL4030_PM_MASTER_BOOT_BCI);
 183 }
 184
 185 static int twl4030bci_read_adc_val(u8 reg)
 186 {
 187         int ret, temp;
 188         u8 val;
 189
 190         /* read MSB */
 191         ret = twl4030_bci_read(reg + 1, &val);
 192         if (ret)
 193                 return ret;
 194
 195         temp = (int)(val & 0x03) << 8;
 196
 197         /* read LSB */
 198         ret = twl4030_bci_read(reg, &val);
 199         if (ret)
 200                 return ret;
 201
 202         return temp | val;
 203 }
 204
 205 /*
 206  * TI provided formulas:
 207  * CGAIN == 0: ICHG = (BCIICHG * 1.7) / (2^10 - 1) - 0.85
 208  * CGAIN == 1: ICHG = (BCIICHG * 3.4) / (2^10 - 1) - 1.7
 209  * Here we use integer approximation of:
 210  * CGAIN == 0: val * 1.6618 - 0.85 * 1000
 211  * CGAIN == 1: (val * 1.6618 - 0.85 * 1000) * 2
 212  */
 213 /*
 214  * convert twl register value for currents into uA
 215  */
 216 static int regval2ua(int regval, bool cgain)
 217 {
 218         if (cgain)
 219                 return (regval * 16618 - 8500 * 1000) / 5;
 220         else
 221                 return (regval * 16618 - 8500 * 1000) / 10;
 222 }
 223
 224 /*
 225  * convert uA currents into twl register value
 226  */
 227 static int ua2regval(int ua, bool cgain)
 228 {
 229         int ret;
 230         if (cgain)
 231                 ua /= 2;
 232         ret = (ua * 10 + 8500 * 1000) / 16618;
 233         /* rounding problems */
 234         if (ret < 512)
 235                 ret = 512;
 236         return ret;
 237 }
 238
 239 static int twl4030_charger_update_current(struct twl4030_bci *bci)
 240 {
 241         int status;
 242         int cur;
 243         unsigned reg, cur_reg;
 244         u8 bcictl1, oldreg, fullreg;
 245         bool cgain = false;
 246         u8 boot_bci;
 247
 248         /*
 249          * If AC (Accessory Charger) voltage exceeds 4.5V (MADC 11)
 250          * and AC is enabled, set current for 'ac'
 251          */
 252         if (ac_available(bci->channel_vac)) {
 253                 cur = bci->ac_cur;
 254                 bci->ac_is_active = true;
 255         } else {
 256                 cur = bci->usb_cur;
 257                 bci->ac_is_active = false;
 258                 if (cur > bci->usb_cur_target) {
 259                         cur = bci->usb_cur_target;
 260                         bci->usb_cur = cur;
 261                 }
 262                 if (cur < bci->usb_cur_target)
 263                         schedule_delayed_work(&bci->current_worker, USB_CUR_DELAY);
 264         }
 265
 266         /* First, check thresholds and see if cgain is needed */
 267         if (bci->ichg_eoc >= 200000)
 268                 cgain = true;
 269         if (bci->ichg_lo >= 400000)
 270                 cgain = true;
 271         if (bci->ichg_hi >= 820000)
 272                 cgain = true;
 273         if (cur > 852000)
 274                 cgain = true;
 275
 276         status = twl4030_bci_read(TWL4030_BCICTL1, &bcictl1);
 277         if (status < 0)
 278                 return status;
 279         if (twl_i2c_read_u8(TWL_MODULE_PM_MASTER, &boot_bci,
 280                             TWL4030_PM_MASTER_BOOT_BCI) < 0)
 281                 boot_bci = 0;
 282         boot_bci &= 7;
 283
 284         if ((!!cgain) != !!(bcictl1 & TWL4030_CGAIN))
 285                 /* Need to turn for charging while we change the
 286                  * CGAIN bit.  Leave it off while everything is
 287                  * updated.
 288                  */
 289                 twl4030_clear_set_boot_bci(boot_bci, 0);
 290
 291         /*
 292          * For ichg_eoc, the hardware only supports reg values matching
 293          * 100XXXX000, and requires the XXXX be stored in the high nibble
 294          * of TWL4030_BCIMFTH8.
 295          */
 296         reg = ua2regval(bci->ichg_eoc, cgain);
 297         if (reg > 0x278)
 298                 reg = 0x278;
 299         if (reg < 0x200)
 300                 reg = 0x200;
 301         reg = (reg >> 3) & 0xf;
 302         fullreg = reg << 4;
 303
 304         /*
 305          * For ichg_lo, reg value must match 10XXXX0000.
 306          * XXXX is stored in low nibble of TWL4030_BCIMFTH8.
 307          */
 308         reg = ua2regval(bci->ichg_lo, cgain);
 309         if (reg > 0x2F0)
 310                 reg = 0x2F0;
 311         if (reg < 0x200)
 312                 reg = 0x200;
 313         reg = (reg >> 4) & 0xf;
 314         fullreg |= reg;
 315
 316         /* ichg_eoc and ichg_lo live in same register */
 317         status = twl4030_bci_read(TWL4030_BCIMFTH8, &oldreg);
 318         if (status < 0)
 319                 return status;
 320         if (oldreg != fullreg) {
 321                 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0xF4,
 322                                           TWL4030_BCIMFKEY);
 323                 if (status < 0)
 324                         return status;
 325                 twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
 326                                  fullreg, TWL4030_BCIMFTH8);
 327         }
 328
 329         /* ichg_hi threshold must be 1XXXX01100 (I think) */
 330         reg = ua2regval(bci->ichg_hi, cgain);
 331         if (reg > 0x3E0)
 332                 reg = 0x3E0;
 333         if (reg < 0x200)
 334                 reg = 0x200;
 335         fullreg = (reg >> 5) & 0xF;
 336         fullreg <<= 4;
 337         status = twl4030_bci_read(TWL4030_BCIMFTH9, &oldreg);
 338         if (status < 0)
 339                 return status;
 340         if ((oldreg & 0xF0) != fullreg) {
 341                 fullreg |= (oldreg & 0x0F);
 342                 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0xE7,
 343                                           TWL4030_BCIMFKEY);
 344                 if (status < 0)
 345                         return status;
 346                 twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
 347                                  fullreg, TWL4030_BCIMFTH9);
 348         }
 349
 350         /*
 351          * And finally, set the current.  This is stored in
 352          * two registers.
 353          */
 354         reg = ua2regval(cur, cgain);
 355         /* we have only 10 bits */
 356         if (reg > 0x3ff)
 357                 reg = 0x3ff;
 358         status = twl4030_bci_read(TWL4030_BCIIREF1, &oldreg);
 359         if (status < 0)
 360                 return status;
 361         cur_reg = oldreg;
 362         status = twl4030_bci_read(TWL4030_BCIIREF2, &oldreg);
 363         if (status < 0)
 364                 return status;
 365         cur_reg |= oldreg << 8;
 366         if (reg != oldreg) {
 367                 /* disable write protection for one write access for
 368                  * BCIIREF */
 369                 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0xE7,
 370                                           TWL4030_BCIMFKEY);
 371                 if (status < 0)
 372                         return status;
 373                 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
 374                                           (reg & 0x100) ? 3 : 2,
 375                                           TWL4030_BCIIREF2);
 376                 if (status < 0)
 377                         return status;
 378                 /* disable write protection for one write access for
 379                  * BCIIREF */
 380                 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0xE7,
 381                                           TWL4030_BCIMFKEY);
 382                 if (status < 0)
 383                         return status;
 384                 status = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
 385                                           reg & 0xff,
 386                                           TWL4030_BCIIREF1);
 387         }
 388         if ((!!cgain) != !!(bcictl1 & TWL4030_CGAIN)) {
 389                 /* Flip CGAIN and re-enable charging */
 390                 bcictl1 ^= TWL4030_CGAIN;
 391                 twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
 392                                  bcictl1, TWL4030_BCICTL1);
 393                 twl4030_clear_set_boot_bci(0, boot_bci);
 394         }
 395         return 0;
 396 }
 397
 398 static int twl4030_charger_get_current(void);
 399
 400 static void twl4030_current_worker(struct work_struct *data)
 401 {
 402         int v, curr;
 403         int res;
 404         struct twl4030_bci *bci = container_of(data, struct twl4030_bci,
 405                                                current_worker.work);
 406
 407         res = twl4030bci_read_adc_val(TWL4030_BCIVBUS);
 408         if (res < 0)
 409                 v = 0;
 410         else
 411                 /* BCIVBUS uses ADCIN8, 7/1023 V/step */
 412                 v = res * 6843;
 413         curr = twl4030_charger_get_current();
 414
 415         dev_dbg(bci->dev, "v=%d cur=%d limit=%d target=%d\n", v, curr,
 416                 bci->usb_cur, bci->usb_cur_target);
 417
 418         if (v < USB_MIN_VOLT) {
 419                 /* Back up and stop adjusting. */
 420                 if (bci->usb_cur >= USB_CUR_STEP)
 421                         bci->usb_cur -= USB_CUR_STEP;
 422                 bci->usb_cur_target = bci->usb_cur;
 423         } else if (bci->usb_cur >= bci->usb_cur_target ||
 424                    bci->usb_cur + USB_CUR_STEP > USB_MAX_CURRENT) {
 425                 /* Reached target and voltage is OK - stop */
 426                 return;
 427         } else {
 428                 bci->usb_cur += USB_CUR_STEP;
 429                 schedule_delayed_work(&bci->current_worker, USB_CUR_DELAY);
 430         }
 431         twl4030_charger_update_current(bci);
 432 }
 433
 434 /*
 435  * Enable/Disable USB Charge functionality.
 436  */
 437 static int twl4030_charger_enable_usb(struct twl4030_bci *bci, bool enable)
 438 {
 439         int ret;
 440         u32 reg;
 441
 442         if (bci->usb_mode == CHARGE_OFF)
 443                 enable = false;
 444         if (enable && !IS_ERR_OR_NULL(bci->transceiver)) {
 445
 446                 twl4030_charger_update_current(bci);
 447
 448                 /* Need to keep phy powered */
 449                 if (!bci->usb_enabled) {
 450                         pm_runtime_get_sync(bci->transceiver->dev);
 451                         bci->usb_enabled = 1;
 452                 }
 453
 454                 if (bci->usb_mode == CHARGE_AUTO) {
 455                         /* Enable interrupts now. */
 456                         reg = ~(u32)(TWL4030_ICHGLOW | TWL4030_ICHGEOC |
 457                                         TWL4030_TBATOR2 | TWL4030_TBATOR1 |
 458                                         TWL4030_BATSTS);
 459                         ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
 460                                        TWL4030_INTERRUPTS_BCIIMR1A);
 461                         if (ret < 0) {
 462                                 dev_err(bci->dev,
 463                                         "failed to unmask interrupts: %d\n",
 464                                         ret);
 465                                 return ret;
 466                         }
 467                         /* forcing the field BCIAUTOUSB (BOOT_BCI[1]) to 1 */
 468                         ret = twl4030_clear_set_boot_bci(0, TWL4030_BCIAUTOUSB);
 469                 }
 470
 471                 /* forcing USBFASTMCHG(BCIMFSTS4[2]) to 1 */
 472                 ret = twl4030_clear_set(TWL_MODULE_MAIN_CHARGE, 0,
 473                         TWL4030_USBFASTMCHG, TWL4030_BCIMFSTS4);
 474                 if (bci->usb_mode == CHARGE_LINEAR) {
 475                         /* Enable interrupts now. */
 476                         reg = ~(u32)(TWL4030_ICHGLOW | TWL4030_TBATOR2 |
 477                                         TWL4030_TBATOR1 | TWL4030_BATSTS);
 478                         ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
 479                                        TWL4030_INTERRUPTS_BCIIMR1A);
 480                         if (ret < 0) {
 481                                 dev_err(bci->dev,
 482                                         "failed to unmask interrupts: %d\n",
 483                                         ret);
 484                                 return ret;
 485                         }
 486                         twl4030_clear_set_boot_bci(TWL4030_BCIAUTOAC|TWL4030_CVENAC, 0);
 487                         /* Watch dog key: WOVF acknowledge */
 488                         ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0x33,
 489                                                TWL4030_BCIWDKEY);
 490                         /* 0x24 + EKEY6: off mode */
 491                         ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0x2a,
 492                                                TWL4030_BCIMDKEY);
 493                         /* EKEY2: Linear charge: USB path */
 494                         ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0x26,
 495                                                TWL4030_BCIMDKEY);
 496                         /* WDKEY5: stop watchdog count */
 497                         ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0xf3,
 498                                                TWL4030_BCIWDKEY);
 499                         /* enable MFEN3 access */
 500                         ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0x9c,
 501                                                TWL4030_BCIMFKEY);
 502                          /* ICHGEOCEN - end-of-charge monitor (current < 80mA)
 503                           *                      (charging continues)
 504                           * ICHGLOWEN - current level monitor (charge continues)
 505                           * don't monitor over-current or heat save
 506                           */
 507                         ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0xf0,
 508                                                TWL4030_BCIMFEN3);
 509                 }
 510         } else {
 511                 ret = twl4030_clear_set_boot_bci(TWL4030_BCIAUTOUSB, 0);
 512                 ret |= twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE, 0x2a,
 513                                         TWL4030_BCIMDKEY);
 514                 if (bci->usb_enabled) {
 515                         pm_runtime_mark_last_busy(bci->transceiver->dev);
 516                         pm_runtime_put_autosuspend(bci->transceiver->dev);
 517                         bci->usb_enabled = 0;
 518                 }
 519                 bci->usb_cur = 0;
 520         }
 521
 522         return ret;
 523 }
 524
 525 /*
 526  * Enable/Disable AC Charge funtionality.
 527  */
 528 static int twl4030_charger_enable_ac(struct twl4030_bci *bci, bool enable)
 529 {
 530         int ret;
 531
 532         if (bci->ac_mode == CHARGE_OFF)
 533                 enable = false;
 534
 535         if (enable)
 536                 ret = twl4030_clear_set_boot_bci(0, TWL4030_BCIAUTOAC);
 537         else
 538                 ret = twl4030_clear_set_boot_bci(TWL4030_BCIAUTOAC, 0);
 539
 540         return ret;
 541 }
 542
 543 /*
 544  * Enable/Disable charging of Backup Battery.
 545  */
 546 static int twl4030_charger_enable_backup(int uvolt, int uamp)
 547 {
 548         int ret;
 549         u8 flags;
 550
 551         if (uvolt < 2500000 ||
 552             uamp < 25) {
 553                 /* disable charging of backup battery */
 554                 ret = twl4030_clear_set(TWL_MODULE_PM_RECEIVER,
 555                                         TWL4030_BBCHEN, 0, TWL4030_BB_CFG);
 556                 return ret;
 557         }
 558
 559         flags = TWL4030_BBCHEN;
 560         if (uvolt >= 3200000)
 561                 flags |= TWL4030_BBSEL_3V2;
 562         else if (uvolt >= 3100000)
 563                 flags |= TWL4030_BBSEL_3V1;
 564         else if (uvolt >= 3000000)
 565                 flags |= TWL4030_BBSEL_3V0;
 566         else
 567                 flags |= TWL4030_BBSEL_2V5;
 568
 569         if (uamp >= 1000)
 570                 flags |= TWL4030_BBISEL_1000uA;
 571         else if (uamp >= 500)
 572                 flags |= TWL4030_BBISEL_500uA;
 573         else if (uamp >= 150)
 574                 flags |= TWL4030_BBISEL_150uA;
 575         else
 576                 flags |= TWL4030_BBISEL_25uA;
 577
 578         ret = twl4030_clear_set(TWL_MODULE_PM_RECEIVER,
 579                                 TWL4030_BBSEL_MASK | TWL4030_BBISEL_MASK,
 580                                 flags,
 581                                 TWL4030_BB_CFG);
 582
 583         return ret;
 584 }
 585
 586 /*
 587  * TWL4030 CHG_PRES (AC charger presence) events
 588  */
 589 static irqreturn_t twl4030_charger_interrupt(int irq, void *arg)
 590 {
 591         struct twl4030_bci *bci = arg;
 592
 593         dev_dbg(bci->dev, "CHG_PRES irq\n");
 594         /* reset current on each 'plug' event */
 595         bci->ac_cur = 500000;
 596         twl4030_charger_update_current(bci);
 597         power_supply_changed(bci->ac);
 598         power_supply_changed(bci->usb);
 599
 600         return IRQ_HANDLED;
 601 }
 602
 603 /*
 604  * TWL4030 BCI monitoring events
 605  */
 606 static irqreturn_t twl4030_bci_interrupt(int irq, void *arg)
 607 {
 608         struct twl4030_bci *bci = arg;
 609         u8 irqs1, irqs2;
 610         int ret;
 611
 612         ret = twl_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &irqs1,
 613                               TWL4030_INTERRUPTS_BCIISR1A);
 614         if (ret < 0)
 615                 return IRQ_HANDLED;
 616
 617         ret = twl_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &irqs2,
 618                               TWL4030_INTERRUPTS_BCIISR2A);
 619         if (ret < 0)
 620                 return IRQ_HANDLED;
 621
 622         dev_dbg(bci->dev, "BCI irq %02x %02x\n", irqs2, irqs1);
 623
 624         if (irqs1 & (TWL4030_ICHGLOW | TWL4030_ICHGEOC)) {
 625                 /* charger state change, inform the core */
 626                 power_supply_changed(bci->ac);
 627                 power_supply_changed(bci->usb);
 628         }
 629         twl4030_charger_update_current(bci);
 630
 631         /* various monitoring events, for now we just log them here */
 632         if (irqs1 & (TWL4030_TBATOR2 | TWL4030_TBATOR1))
 633                 dev_warn(bci->dev, "battery temperature out of range\n");
 634
 635         if (irqs1 & TWL4030_BATSTS)
 636                 dev_crit(bci->dev, "battery disconnected\n");
 637
 638         if (irqs2 & TWL4030_VBATOV)
 639                 dev_crit(bci->dev, "VBAT overvoltage\n");
 640
 641         if (irqs2 & TWL4030_VBUSOV)
 642                 dev_crit(bci->dev, "VBUS overvoltage\n");
 643
 644         if (irqs2 & TWL4030_ACCHGOV)
 645                 dev_crit(bci->dev, "Ac charger overvoltage\n");
 646
 647         return IRQ_HANDLED;
 648 }
 649
 650 static void twl4030_bci_usb_work(struct work_struct *data)
 651 {
 652         struct twl4030_bci *bci = container_of(data, struct twl4030_bci, work);
 653
 654         switch (bci->event) {
 655         case USB_EVENT_VBUS:
 656         case USB_EVENT_CHARGER:
 657                 twl4030_charger_enable_usb(bci, true);
 658                 break;
 659         case USB_EVENT_NONE:
 660                 twl4030_charger_enable_usb(bci, false);
 661                 break;
 662         }
 663 }
 664
 665 static int twl4030_bci_usb_ncb(struct notifier_block *nb, unsigned long val,
 666                                void *priv)
 667 {
 668         struct twl4030_bci *bci = container_of(nb, struct twl4030_bci, usb_nb);
 669
 670         dev_dbg(bci->dev, "OTG notify %lu\n", val);
 671
 672         /* reset current on each 'plug' event */
 673         if (allow_usb)
 674                 bci->usb_cur_target = 500000;
 675         else
 676                 bci->usb_cur_target = 100000;
 677
 678         bci->event = val;
 679         schedule_work(&bci->work);
 680
 681         return NOTIFY_OK;
 682 }
 683
 684 /*
 685  * sysfs charger enabled store
 686  */
 687 static ssize_t
 688 twl4030_bci_mode_store(struct device *dev, struct device_attribute *attr,
 689                           const char *buf, size_t n)
 690 {
 691         struct twl4030_bci *bci = dev_get_drvdata(dev->parent);
 692         int mode;
 693         int status;
 694
 695         mode = sysfs_match_string(modes, buf);
 696         if (mode < 0)
 697                 return mode;
 698
 699         if (dev == &bci->ac->dev) {
 700                 if (mode == 2)
 701                         return -EINVAL;
 702                 twl4030_charger_enable_ac(bci, false);
 703                 bci->ac_mode = mode;
 704                 status = twl4030_charger_enable_ac(bci, true);
 705         } else {
 706                 twl4030_charger_enable_usb(bci, false);
 707                 bci->usb_mode = mode;
 708                 status = twl4030_charger_enable_usb(bci, true);
 709         }
 710         return (status == 0) ? n : status;
 711 }
 712
 713 /*
 714  * sysfs charger enabled show
 715  */
 716 static ssize_t
 717 twl4030_bci_mode_show(struct device *dev,
 718                              struct device_attribute *attr, char *buf)
 719 {
 720         struct twl4030_bci *bci = dev_get_drvdata(dev->parent);
 721         int len = 0;
 722         int i;
 723         int mode = bci->usb_mode;
 724
 725         if (dev == &bci->ac->dev)
 726                 mode = bci->ac_mode;
 727
 728         for (i = 0; i < ARRAY_SIZE(modes); i++)
 729                 if (mode == i)
 730                         len += sysfs_emit_at(buf, len, "[%s] ", modes[i]);
 731                 else
 732                         len += sysfs_emit_at(buf, len, "%s ", modes[i]);
 733         buf[len-1] = '\n';
 734         return len;
 735 }
 736 static DEVICE_ATTR(mode, 0644, twl4030_bci_mode_show,
 737                    twl4030_bci_mode_store);
 738
 739 static int twl4030_charger_get_current(void)
 740 {
 741         int curr;
 742         int ret;
 743         u8 bcictl1;
 744
 745         curr = twl4030bci_read_adc_val(TWL4030_BCIICHG);
 746         if (curr < 0)
 747                 return curr;
 748
 749         ret = twl4030_bci_read(TWL4030_BCICTL1, &bcictl1);
 750         if (ret)
 751                 return ret;
 752
 753         return regval2ua(curr, bcictl1 & TWL4030_CGAIN);
 754 }
 755
 756 /*
 757  * Returns the main charge FSM state
 758  * Or < 0 on failure.
 759  */
 760 static int twl4030bci_state(struct twl4030_bci *bci)
 761 {
 762         int ret;
 763         u8 state;
 764
 765         ret = twl4030_bci_read(TWL4030_BCIMSTATEC, &state);
 766         if (ret) {
 767                 dev_err(bci->dev, "error reading BCIMSTATEC\n");
 768                 return ret;
 769         }
 770
 771         dev_dbg(bci->dev, "state: %02x\n", state);
 772
 773         return state;
 774 }
 775
 776 static int twl4030_bci_state_to_status(int state)
 777 {
 778         state &= TWL4030_MSTATEC_MASK;
 779         if (TWL4030_MSTATEC_QUICK1 <= state && state <= TWL4030_MSTATEC_QUICK7)
 780                 return POWER_SUPPLY_STATUS_CHARGING;
 781         else if (TWL4030_MSTATEC_COMPLETE1 <= state &&
 782                                         state <= TWL4030_MSTATEC_COMPLETE4)
 783                 return POWER_SUPPLY_STATUS_FULL;
 784         else
 785                 return POWER_SUPPLY_STATUS_NOT_CHARGING;
 786 }
 787
 788 static int twl4030_bci_get_property(struct power_supply *psy,
 789                                     enum power_supply_property psp,
 790                                     union power_supply_propval *val)
 791 {
 792         struct twl4030_bci *bci = dev_get_drvdata(psy->dev.parent);
 793         int is_charging;
 794         int state;
 795         int ret;
 796
 797         state = twl4030bci_state(bci);
 798         if (state < 0)
 799                 return state;
 800
 801         if (psy->desc->type == POWER_SUPPLY_TYPE_USB)
 802                 is_charging = state & TWL4030_MSTATEC_USB;
 803         else
 804                 is_charging = state & TWL4030_MSTATEC_AC;
 805         if (!is_charging) {
 806                 u8 s;
 807                 ret = twl4030_bci_read(TWL4030_BCIMDEN, &s);
 808                 if (ret < 0)
 809                         return ret;
 810                 if (psy->desc->type == POWER_SUPPLY_TYPE_USB)
 811                         is_charging = s & 1;
 812                 else
 813                         is_charging = s & 2;
 814                 if (is_charging)
 815                         /* A little white lie */
 816                         state = TWL4030_MSTATEC_QUICK1;
 817         }
 818
 819         switch (psp) {
 820         case POWER_SUPPLY_PROP_STATUS:
 821                 if (is_charging)
 822                         val->intval = twl4030_bci_state_to_status(state);
 823                 else
 824                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 825                 break;
 826         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 827                 /* charging must be active for meaningful result */
 828                 if (!is_charging)
 829                         return -ENODATA;
 830                 if (psy->desc->type == POWER_SUPPLY_TYPE_USB) {
 831                         ret = twl4030bci_read_adc_val(TWL4030_BCIVBUS);
 832                         if (ret < 0)
 833                                 return ret;
 834                         /* BCIVBUS uses ADCIN8, 7/1023 V/step */
 835                         val->intval = ret * 6843;
 836                 } else {
 837                         ret = twl4030bci_read_adc_val(TWL4030_BCIVAC);
 838                         if (ret < 0)
 839                                 return ret;
 840                         /* BCIVAC uses ADCIN11, 10/1023 V/step */
 841                         val->intval = ret * 9775;
 842                 }
 843                 break;
 844         case POWER_SUPPLY_PROP_CURRENT_NOW:
 845                 if (!is_charging)
 846                         return -ENODATA;
 847                 /* current measurement is shared between AC and USB */
 848                 ret = twl4030_charger_get_current();
 849                 if (ret < 0)
 850                         return ret;
 851                 val->intval = ret;
 852                 break;
 853         case POWER_SUPPLY_PROP_ONLINE:
 854                 val->intval = is_charging &&
 855                         twl4030_bci_state_to_status(state) !=
 856                                 POWER_SUPPLY_STATUS_NOT_CHARGING;
 857                 break;
 858         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 859                 val->intval = -1;
 860                 if (psy->desc->type != POWER_SUPPLY_TYPE_USB) {
 861                         if (!bci->ac_is_active)
 862                                 val->intval = bci->ac_cur;
 863                 } else {
 864                         if (bci->ac_is_active)
 865                                 val->intval = bci->usb_cur_target;
 866                 }
 867                 if (val->intval < 0) {
 868                         u8 bcictl1;
 869
 870                         val->intval = twl4030bci_read_adc_val(TWL4030_BCIIREF1);
 871                         if (val->intval < 0)
 872                                 return val->intval;
 873                         ret = twl4030_bci_read(TWL4030_BCICTL1, &bcictl1);
 874                         if (ret < 0)
 875                                 return ret;
 876                         val->intval = regval2ua(val->intval, bcictl1 &
 877                                                         TWL4030_CGAIN);
 878                 }
 879                 break;
 880         default:
 881                 return -EINVAL;
 882         }
 883
 884         return 0;
 885 }
 886
 887 static int twl4030_bci_set_property(struct power_supply *psy,
 888                                     enum power_supply_property psp,
 889                                     const union power_supply_propval *val)
 890 {
 891         struct twl4030_bci *bci = dev_get_drvdata(psy->dev.parent);
 892
 893         switch (psp) {
 894         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 895                 if (psy->desc->type == POWER_SUPPLY_TYPE_USB)
 896                         bci->usb_cur_target = val->intval;
 897                 else
 898                         bci->ac_cur = val->intval;
 899                 twl4030_charger_update_current(bci);
 900                 break;
 901         default:
 902                 return -EINVAL;
 903         }
 904
 905         return 0;
 906 }
 907
 908 static int twl4030_bci_property_is_writeable(struct power_supply *psy,
 909                                       enum power_supply_property psp)
 910 {
 911         switch (psp) {
 912         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 913                 return true;
 914         default:
 915                 return false;
 916         }
 917 }
 918
 919 static enum power_supply_property twl4030_charger_props[] = {
 920         POWER_SUPPLY_PROP_STATUS,
 921         POWER_SUPPLY_PROP_ONLINE,
 922         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 923         POWER_SUPPLY_PROP_CURRENT_NOW,
 924         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
 925 };
 926
 927 #ifdef CONFIG_OF
 928 static const struct twl4030_bci_platform_data *
 929 twl4030_bci_parse_dt(struct device *dev)
 930 {
 931         struct device_node *np = dev->of_node;
 932         struct twl4030_bci_platform_data *pdata;
 933         u32 num;
 934
 935         if (!np)
 936                 return NULL;
 937         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 938         if (!pdata)
 939                 return pdata;
 940
 941         if (of_property_read_u32(np, "ti,bb-uvolt", &num) == 0)
 942                 pdata->bb_uvolt = num;
 943         if (of_property_read_u32(np, "ti,bb-uamp", &num) == 0)
 944                 pdata->bb_uamp = num;
 945         return pdata;
 946 }
 947 #else
 948 static inline const struct twl4030_bci_platform_data *
 949 twl4030_bci_parse_dt(struct device *dev)
 950 {
 951         return NULL;
 952 }
 953 #endif
 954
 955 static const struct power_supply_desc twl4030_bci_ac_desc = {
 956         .name           = "twl4030_ac",
 957         .type           = POWER_SUPPLY_TYPE_MAINS,
 958         .properties     = twl4030_charger_props,
 959         .num_properties = ARRAY_SIZE(twl4030_charger_props),
 960         .get_property   = twl4030_bci_get_property,
 961         .set_property   = twl4030_bci_set_property,
 962         .property_is_writeable  = twl4030_bci_property_is_writeable,
 963 };
 964
 965 static const struct power_supply_desc twl4030_bci_usb_desc = {
 966         .name           = "twl4030_usb",
 967         .type           = POWER_SUPPLY_TYPE_USB,
 968         .properties     = twl4030_charger_props,
 969         .num_properties = ARRAY_SIZE(twl4030_charger_props),
 970         .get_property   = twl4030_bci_get_property,
 971         .set_property   = twl4030_bci_set_property,
 972         .property_is_writeable  = twl4030_bci_property_is_writeable,
 973 };
 974
 975 static int twl4030_bci_probe(struct platform_device *pdev)
 976 {
 977         struct twl4030_bci *bci;
 978         const struct twl4030_bci_platform_data *pdata = pdev->dev.platform_data;
 979         int ret;
 980         u32 reg;
 981
 982         bci = devm_kzalloc(&pdev->dev, sizeof(*bci), GFP_KERNEL);
 983         if (bci == NULL)
 984                 return -ENOMEM;
 985
 986         if (!pdata)
 987                 pdata = twl4030_bci_parse_dt(&pdev->dev);
 988
 989         bci->ichg_eoc = 80100; /* Stop charging when current drops to here */
 990         bci->ichg_lo = 241000; /* Low threshold */
 991         bci->ichg_hi = 500000; /* High threshold */
 992         bci->ac_cur = 500000; /* 500mA */
 993         if (allow_usb)
 994                 bci->usb_cur_target = 500000;  /* 500mA */
 995         else
 996                 bci->usb_cur_target = 100000;  /* 100mA */
 997         bci->usb_mode = CHARGE_AUTO;
 998         bci->ac_mode = CHARGE_AUTO;
 999
1000         bci->dev = &pdev->dev;
1001         bci->irq_chg = platform_get_irq(pdev, 0);
1002         bci->irq_bci = platform_get_irq(pdev, 1);
1003
1004         platform_set_drvdata(pdev, bci);
1005
1006         INIT_WORK(&bci->work, twl4030_bci_usb_work);
1007         INIT_DELAYED_WORK(&bci->current_worker, twl4030_current_worker);
1008
1009         bci->channel_vac = devm_iio_channel_get(&pdev->dev, "vac");
1010         if (IS_ERR(bci->channel_vac)) {
1011                 ret = PTR_ERR(bci->channel_vac);
1012                 if (ret == -EPROBE_DEFER)
1013                         return ret;     /* iio not ready */
1014                 dev_warn(&pdev->dev, "could not request vac iio channel (%d)",
1015                         ret);
1016                 bci->channel_vac = NULL;
1017         }
1018
1019         if (bci->dev->of_node) {
1020                 struct device_node *phynode;
1021
1022                 phynode = of_get_compatible_child(bci->dev->of_node->parent,
1023                                                   "ti,twl4030-usb");
1024                 if (phynode) {
1025                         bci->usb_nb.notifier_call = twl4030_bci_usb_ncb;
1026                         bci->transceiver = devm_usb_get_phy_by_node(
1027                                 bci->dev, phynode, &bci->usb_nb);
1028                         of_node_put(phynode);
1029                         if (IS_ERR(bci->transceiver)) {
1030                                 ret = PTR_ERR(bci->transceiver);
1031                                 if (ret == -EPROBE_DEFER)
1032                                         return ret;     /* phy not ready */
1033                                 dev_warn(&pdev->dev, "could not request transceiver (%d)",
1034                                         ret);
1035                                 bci->transceiver = NULL;
1036                         }
1037                 }
1038         }
1039
1040         bci->ac = devm_power_supply_register(&pdev->dev, &twl4030_bci_ac_desc,
1041                                              NULL);
1042         if (IS_ERR(bci->ac)) {
1043                 ret = PTR_ERR(bci->ac);
1044                 dev_err(&pdev->dev, "failed to register ac: %d\n", ret);
1045                 return ret;
1046         }
1047
1048         bci->usb = devm_power_supply_register(&pdev->dev, &twl4030_bci_usb_desc,
1049                                               NULL);
1050         if (IS_ERR(bci->usb)) {
1051                 ret = PTR_ERR(bci->usb);
1052                 dev_err(&pdev->dev, "failed to register usb: %d\n", ret);
1053                 return ret;
1054         }
1055
1056         ret = devm_request_threaded_irq(&pdev->dev, bci->irq_chg, NULL,
1057                         twl4030_charger_interrupt, IRQF_ONESHOT, pdev->name,
1058                         bci);
1059         if (ret < 0) {
1060                 dev_err(&pdev->dev, "could not request irq %d, status %d\n",
1061                         bci->irq_chg, ret);
1062                 return ret;
1063         }
1064
1065         ret = devm_request_threaded_irq(&pdev->dev, bci->irq_bci, NULL,
1066                         twl4030_bci_interrupt, IRQF_ONESHOT, pdev->name, bci);
1067         if (ret < 0) {
1068                 dev_err(&pdev->dev, "could not request irq %d, status %d\n",
1069                         bci->irq_bci, ret);
1070                 return ret;
1071         }
1072
1073         /* Enable interrupts now. */
1074         reg = ~(u32)(TWL4030_ICHGLOW | TWL4030_ICHGEOC | TWL4030_TBATOR2 |
1075                 TWL4030_TBATOR1 | TWL4030_BATSTS);
1076         ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
1077                                TWL4030_INTERRUPTS_BCIIMR1A);
1078         if (ret < 0) {
1079                 dev_err(&pdev->dev, "failed to unmask interrupts: %d\n", ret);
1080                 return ret;
1081         }
1082
1083         reg = ~(u32)(TWL4030_VBATOV | TWL4030_VBUSOV | TWL4030_ACCHGOV);
1084         ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
1085                                TWL4030_INTERRUPTS_BCIIMR2A);
1086         if (ret < 0)
1087                 dev_warn(&pdev->dev, "failed to unmask interrupts: %d\n", ret);
1088
1089         twl4030_charger_update_current(bci);
1090         if (device_create_file(&bci->usb->dev, &dev_attr_mode))
1091                 dev_warn(&pdev->dev, "could not create sysfs file\n");
1092         if (device_create_file(&bci->ac->dev, &dev_attr_mode))
1093                 dev_warn(&pdev->dev, "could not create sysfs file\n");
1094
1095         twl4030_charger_enable_ac(bci, true);
1096         if (!IS_ERR_OR_NULL(bci->transceiver))
1097                 twl4030_bci_usb_ncb(&bci->usb_nb,
1098                                     bci->transceiver->last_event,
1099                                     NULL);
1100         else
1101                 twl4030_charger_enable_usb(bci, false);
1102         if (pdata)
1103                 twl4030_charger_enable_backup(pdata->bb_uvolt,
1104                                               pdata->bb_uamp);
1105         else
1106                 twl4030_charger_enable_backup(0, 0);
1107
1108         return 0;
1109 }
1110
1111 static void twl4030_bci_remove(struct platform_device *pdev)
1112 {
1113         struct twl4030_bci *bci = platform_get_drvdata(pdev);
1114
1115         twl4030_charger_enable_ac(bci, false);
1116         twl4030_charger_enable_usb(bci, false);
1117         twl4030_charger_enable_backup(0, 0);
1118
1119         device_remove_file(&bci->usb->dev, &dev_attr_mode);
1120         device_remove_file(&bci->ac->dev, &dev_attr_mode);
1121         /* mask interrupts */
1122         twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, 0xff,
1123                          TWL4030_INTERRUPTS_BCIIMR1A);
1124         twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, 0xff,
1125                          TWL4030_INTERRUPTS_BCIIMR2A);
1126 }
1127
1128 static const struct of_device_id twl_bci_of_match[] __maybe_unused = {
1129         {.compatible = "ti,twl4030-bci", },
1130         { }
1131 };
1132 MODULE_DEVICE_TABLE(of, twl_bci_of_match);
1133
1134 static struct platform_driver twl4030_bci_driver = {
1135         .probe = twl4030_bci_probe,
1136         .remove_new = twl4030_bci_remove,
1137         .driver = {
1138                 .name   = "twl4030_bci",
1139                 .of_match_table = of_match_ptr(twl_bci_of_match),
1140         },
1141 };
1142 module_platform_driver(twl4030_bci_driver);
1143
1144 MODULE_AUTHOR("Gražvydas Ignotas");
1145 MODULE_DESCRIPTION("TWL4030 Battery Charger Interface driver");
1146 MODULE_LICENSE("GPL");
1147 MODULE_ALIAS("platform:twl4030_bci");