drivers/power/supply/cpcap-battery.c

   1 /*
   2  * Battery driver for CPCAP PMIC
   3  *
   4  * Copyright (C) 2017 Tony Lindgren <tony@atomide.com>
   5  *
   6  * Some parts of the code based on earlier Motorola mapphone Linux kernel
   7  * drivers:
   8  *
   9  * Copyright (C) 2009-2010 Motorola, Inc.
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14
  15  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  16  * kind, whether express or implied; without even the implied warranty
  17  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #include <linux/delay.h>
  22 #include <linux/err.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/of_device.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/power_supply.h>
  29 #include <linux/reboot.h>
  30 #include <linux/regmap.h>
  31 #include <linux/moduleparam.h>
  32
  33 #include <linux/iio/consumer.h>
  34 #include <linux/iio/types.h>
  35 #include <linux/mfd/motorola-cpcap.h>
  36
  37 /*
  38  * Register bit defines for CPCAP_REG_BPEOL. Some of these seem to
  39  * map to MC13783UG.pdf "Table 5-19. Register 13, Power Control 0"
  40  * to enable BATTDETEN, LOBAT and EOL features. We currently use
  41  * LOBAT interrupts instead of EOL.
  42  */
  43 #define CPCAP_REG_BPEOL_BIT_EOL9        BIT(9)  /* Set for EOL irq */
  44 #define CPCAP_REG_BPEOL_BIT_EOL8        BIT(8)  /* Set for EOL irq */
  45 #define CPCAP_REG_BPEOL_BIT_UNKNOWN7    BIT(7)
  46 #define CPCAP_REG_BPEOL_BIT_UNKNOWN6    BIT(6)
  47 #define CPCAP_REG_BPEOL_BIT_UNKNOWN5    BIT(5)
  48 #define CPCAP_REG_BPEOL_BIT_EOL_MULTI   BIT(4)  /* Set for multiple EOL irqs */
  49 #define CPCAP_REG_BPEOL_BIT_UNKNOWN3    BIT(3)
  50 #define CPCAP_REG_BPEOL_BIT_UNKNOWN2    BIT(2)
  51 #define CPCAP_REG_BPEOL_BIT_BATTDETEN   BIT(1)  /* Enable battery detect */
  52 #define CPCAP_REG_BPEOL_BIT_EOLSEL      BIT(0)  /* BPDET = 0, EOL = 1 */
  53
  54 /*
  55  * Register bit defines for CPCAP_REG_CCC1. These seem similar to the twl6030
  56  * coulomb counter registers rather than the mc13892 registers. Both twl6030
  57  * and mc13892 set bits 2 and 1 to reset and clear registers. But mc13892
  58  * sets bit 0 to start the coulomb counter while twl6030 sets bit 0 to stop
  59  * the coulomb counter like cpcap does. So for now, we use the twl6030 style
  60  * naming for the registers.
  61  */
  62 #define CPCAP_REG_CCC1_ACTIVE_MODE1     BIT(4)  /* Update rate */
  63 #define CPCAP_REG_CCC1_ACTIVE_MODE0     BIT(3)  /* Update rate */
  64 #define CPCAP_REG_CCC1_AUTOCLEAR        BIT(2)  /* Resets sample registers */
  65 #define CPCAP_REG_CCC1_CAL_EN           BIT(1)  /* Clears after write in 1s */
  66 #define CPCAP_REG_CCC1_PAUSE            BIT(0)  /* Stop counters, allow write */
  67 #define CPCAP_REG_CCC1_RESET_MASK       (CPCAP_REG_CCC1_AUTOCLEAR | \
  68                                          CPCAP_REG_CCC1_CAL_EN)
  69
  70 #define CPCAP_REG_CCCC2_RATE1           BIT(5)
  71 #define CPCAP_REG_CCCC2_RATE0           BIT(4)
  72 #define CPCAP_REG_CCCC2_ENABLE          BIT(3)
  73
  74 #define CPCAP_BATTERY_CC_SAMPLE_PERIOD_MS       250
  75
  76 enum {
  77         CPCAP_BATTERY_IIO_BATTDET,
  78         CPCAP_BATTERY_IIO_VOLTAGE,
  79         CPCAP_BATTERY_IIO_CHRG_CURRENT,
  80         CPCAP_BATTERY_IIO_BATT_CURRENT,
  81         CPCAP_BATTERY_IIO_NR,
  82 };
  83
  84 enum cpcap_battery_irq_action {
  85         CPCAP_BATTERY_IRQ_ACTION_NONE,
  86         CPCAP_BATTERY_IRQ_ACTION_CC_CAL_DONE,
  87         CPCAP_BATTERY_IRQ_ACTION_BATTERY_LOW,
  88         CPCAP_BATTERY_IRQ_ACTION_POWEROFF,
  89 };
  90
  91 struct cpcap_interrupt_desc {
  92         const char *name;
  93         struct list_head node;
  94         int irq;
  95         enum cpcap_battery_irq_action action;
  96 };
  97
  98 struct cpcap_battery_config {
  99         int cd_factor;
 100         struct power_supply_info info;
 101         struct power_supply_battery_info bat;
 102 };
 103
 104 struct cpcap_coulomb_counter_data {
 105         s32 sample;             /* 24 or 32 bits */
 106         s32 accumulator;
 107         s16 offset;             /* 9 bits */
 108         s16 integrator;         /* 13 or 16 bits */
 109 };
 110
 111 enum cpcap_battery_state {
 112         CPCAP_BATTERY_STATE_PREVIOUS,
 113         CPCAP_BATTERY_STATE_LATEST,
 114         CPCAP_BATTERY_STATE_EMPTY,
 115         CPCAP_BATTERY_STATE_FULL,
 116         CPCAP_BATTERY_STATE_NR,
 117 };
 118
 119 struct cpcap_battery_state_data {
 120         int voltage;
 121         int current_ua;
 122         int counter_uah;
 123         int temperature;
 124         ktime_t time;
 125         struct cpcap_coulomb_counter_data cc;
 126 };
 127
 128 struct cpcap_battery_ddata {
 129         struct device *dev;
 130         struct regmap *reg;
 131         struct list_head irq_list;
 132         struct iio_channel *channels[CPCAP_BATTERY_IIO_NR];
 133         struct power_supply *psy;
 134         struct cpcap_battery_config config;
 135         struct cpcap_battery_state_data state[CPCAP_BATTERY_STATE_NR];
 136         u32 cc_lsb;             /* μAms per LSB */
 137         atomic_t active;
 138         int charge_full;
 139         int status;
 140         u16 vendor;
 141         unsigned int is_full:1;
 142 };
 143
 144 #define CPCAP_NO_BATTERY        -400
 145
 146 static bool ignore_temperature_probe;
 147 module_param(ignore_temperature_probe, bool, 0660);
 148
 149 static struct cpcap_battery_state_data *
 150 cpcap_battery_get_state(struct cpcap_battery_ddata *ddata,
 151                         enum cpcap_battery_state state)
 152 {
 153         if (state >= CPCAP_BATTERY_STATE_NR)
 154                 return NULL;
 155
 156         return &ddata->state[state];
 157 }
 158
 159 static struct cpcap_battery_state_data *
 160 cpcap_battery_latest(struct cpcap_battery_ddata *ddata)
 161 {
 162         return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_LATEST);
 163 }
 164
 165 static struct cpcap_battery_state_data *
 166 cpcap_battery_previous(struct cpcap_battery_ddata *ddata)
 167 {
 168         return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_PREVIOUS);
 169 }
 170
 171 static struct cpcap_battery_state_data *
 172 cpcap_battery_get_empty(struct cpcap_battery_ddata *ddata)
 173 {
 174         return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_EMPTY);
 175 }
 176
 177 static struct cpcap_battery_state_data *
 178 cpcap_battery_get_full(struct cpcap_battery_ddata *ddata)
 179 {
 180         return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_FULL);
 181 }
 182
 183 static int cpcap_charger_battery_temperature(struct cpcap_battery_ddata *ddata,
 184                                              int *value)
 185 {
 186         struct iio_channel *channel;
 187         int error;
 188
 189         channel = ddata->channels[CPCAP_BATTERY_IIO_BATTDET];
 190         error = iio_read_channel_processed(channel, value);
 191         if (error < 0) {
 192                 if (!ignore_temperature_probe)
 193                         dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
 194                 *value = CPCAP_NO_BATTERY;
 195
 196                 return error;
 197         }
 198
 199         *value /= 100;
 200
 201         return 0;
 202 }
 203
 204 static int cpcap_battery_get_voltage(struct cpcap_battery_ddata *ddata)
 205 {
 206         struct iio_channel *channel;
 207         int error, value = 0;
 208
 209         channel = ddata->channels[CPCAP_BATTERY_IIO_VOLTAGE];
 210         error = iio_read_channel_processed(channel, &value);
 211         if (error < 0) {
 212                 dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
 213
 214                 return 0;
 215         }
 216
 217         return value * 1000;
 218 }
 219
 220 static int cpcap_battery_get_current(struct cpcap_battery_ddata *ddata)
 221 {
 222         struct iio_channel *channel;
 223         int error, value = 0;
 224
 225         channel = ddata->channels[CPCAP_BATTERY_IIO_BATT_CURRENT];
 226         error = iio_read_channel_processed(channel, &value);
 227         if (error < 0) {
 228                 dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
 229
 230                 return 0;
 231         }
 232
 233         return value * 1000;
 234 }
 235
 236 /**
 237  * cpcap_battery_cc_raw_div - calculate and divide coulomb counter μAms values
 238  * @ddata: device driver data
 239  * @sample: coulomb counter sample value
 240  * @accumulator: coulomb counter integrator value
 241  * @offset: coulomb counter offset value
 242  * @divider: conversion divider
 243  *
 244  * Note that cc_lsb and cc_dur values are from Motorola Linux kernel
 245  * function data_get_avg_curr_ua() and seem to be based on measured test
 246  * results. It also has the following comment:
 247  *
 248  * Adjustment factors are applied here as a temp solution per the test
 249  * results. Need to work out a formal solution for this adjustment.
 250  *
 251  * A coulomb counter for similar hardware seems to be documented in
 252  * "TWL6030 Gas Gauging Basics (Rev. A)" swca095a.pdf in chapter
 253  * "10 Calculating Accumulated Current". We however follow what the
 254  * Motorola mapphone Linux kernel is doing as there may be either a
 255  * TI or ST coulomb counter in the PMIC.
 256  */
 257 static int cpcap_battery_cc_raw_div(struct cpcap_battery_ddata *ddata,
 258                                     s32 sample, s32 accumulator,
 259                                     s16 offset, u32 divider)
 260 {
 261         s64 acc;
 262
 263         if (!divider)
 264                 return 0;
 265
 266         acc = accumulator;
 267         acc -= (s64)sample * offset;
 268         acc *= ddata->cc_lsb;
 269         acc *= -1;
 270         acc = div_s64(acc, divider);
 271
 272         return acc;
 273 }
 274
 275 /* 3600000μAms = 1μAh */
 276 static int cpcap_battery_cc_to_uah(struct cpcap_battery_ddata *ddata,
 277                                    s32 sample, s32 accumulator,
 278                                    s16 offset)
 279 {
 280         return cpcap_battery_cc_raw_div(ddata, sample,
 281                                         accumulator, offset,
 282                                         3600000);
 283 }
 284
 285 static int cpcap_battery_cc_to_ua(struct cpcap_battery_ddata *ddata,
 286                                   s32 sample, s32 accumulator,
 287                                   s16 offset)
 288 {
 289         return cpcap_battery_cc_raw_div(ddata, sample,
 290                                         accumulator, offset,
 291                                         sample *
 292                                         CPCAP_BATTERY_CC_SAMPLE_PERIOD_MS);
 293 }
 294
 295 /**
 296  * cpcap_battery_read_accumulated - reads cpcap coulomb counter
 297  * @ddata: device driver data
 298  * @ccd: coulomb counter values
 299  *
 300  * Based on Motorola mapphone kernel function data_read_regs().
 301  * Looking at the registers, the coulomb counter seems similar to
 302  * the coulomb counter in TWL6030. See "TWL6030 Gas Gauging Basics
 303  * (Rev. A) swca095a.pdf for "10 Calculating Accumulated Current".
 304  *
 305  * Note that swca095a.pdf instructs to stop the coulomb counter
 306  * before reading to avoid values changing. Motorola mapphone
 307  * Linux kernel does not do it, so let's assume they've verified
 308  * the data produced is correct.
 309  */
 310 static int
 311 cpcap_battery_read_accumulated(struct cpcap_battery_ddata *ddata,
 312                                struct cpcap_coulomb_counter_data *ccd)
 313 {
 314         u16 buf[7];     /* CPCAP_REG_CCS1 to CCI */
 315         int error;
 316
 317         ccd->sample = 0;
 318         ccd->accumulator = 0;
 319         ccd->offset = 0;
 320         ccd->integrator = 0;
 321
 322         /* Read coulomb counter register range */
 323         error = regmap_bulk_read(ddata->reg, CPCAP_REG_CCS1,
 324                                  buf, ARRAY_SIZE(buf));
 325         if (error)
 326                 return 0;
 327
 328         /* Sample value CPCAP_REG_CCS1 & 2 */
 329         ccd->sample = (buf[1] & 0x0fff) << 16;
 330         ccd->sample |= buf[0];
 331         if (ddata->vendor == CPCAP_VENDOR_TI)
 332                 ccd->sample = sign_extend32(24, ccd->sample);
 333
 334         /* Accumulator value CPCAP_REG_CCA1 & 2 */
 335         ccd->accumulator = ((s16)buf[3]) << 16;
 336         ccd->accumulator |= buf[2];
 337
 338         /*
 339          * Coulomb counter calibration offset is CPCAP_REG_CCM,
 340          * REG_CCO seems unused
 341          */
 342         ccd->offset = buf[4];
 343         ccd->offset = sign_extend32(ccd->offset, 9);
 344
 345         /* Integrator register CPCAP_REG_CCI */
 346         if (ddata->vendor == CPCAP_VENDOR_TI)
 347                 ccd->integrator = sign_extend32(buf[6], 13);
 348         else
 349                 ccd->integrator = (s16)buf[6];
 350
 351         return cpcap_battery_cc_to_uah(ddata,
 352                                        ccd->sample,
 353                                        ccd->accumulator,
 354                                        ccd->offset);
 355 }
 356
 357 /**
 358  * cpcap_battery_cc_get_avg_current - read cpcap coulumb counter
 359  * @ddata: cpcap battery driver device data
 360  */
 361 static int cpcap_battery_cc_get_avg_current(struct cpcap_battery_ddata *ddata)
 362 {
 363         int value, acc, error;
 364         s32 sample;
 365         s16 offset;
 366
 367         /* Coulomb counter integrator */
 368         error = regmap_read(ddata->reg, CPCAP_REG_CCI, &value);
 369         if (error)
 370                 return error;
 371
 372         if (ddata->vendor == CPCAP_VENDOR_TI) {
 373                 acc = sign_extend32(value, 13);
 374                 sample = 1;
 375         } else {
 376                 acc = (s16)value;
 377                 sample = 4;
 378         }
 379
 380         /* Coulomb counter calibration offset  */
 381         error = regmap_read(ddata->reg, CPCAP_REG_CCM, &value);
 382         if (error)
 383                 return error;
 384
 385         offset = sign_extend32(value, 9);
 386
 387         return cpcap_battery_cc_to_ua(ddata, sample, acc, offset);
 388 }
 389
 390 static int cpcap_battery_get_charger_status(struct cpcap_battery_ddata *ddata,
 391                                             int *val)
 392 {
 393         union power_supply_propval prop;
 394         struct power_supply *charger;
 395         int error;
 396
 397         charger = power_supply_get_by_name("usb");
 398         if (!charger)
 399                 return -ENODEV;
 400
 401         error = power_supply_get_property(charger, POWER_SUPPLY_PROP_STATUS,
 402                                           &prop);
 403         if (error)
 404                 *val = POWER_SUPPLY_STATUS_UNKNOWN;
 405         else
 406                 *val = prop.intval;
 407
 408         power_supply_put(charger);
 409
 410         return error;
 411 }
 412
 413 static bool cpcap_battery_full(struct cpcap_battery_ddata *ddata)
 414 {
 415         struct cpcap_battery_state_data *state = cpcap_battery_latest(ddata);
 416         unsigned int vfull;
 417         int error, val;
 418
 419         error = cpcap_battery_get_charger_status(ddata, &val);
 420         if (!error) {
 421                 switch (val) {
 422                 case POWER_SUPPLY_STATUS_DISCHARGING:
 423                         dev_dbg(ddata->dev, "charger disconnected\n");
 424                         ddata->is_full = 0;
 425                         break;
 426                 case POWER_SUPPLY_STATUS_FULL:
 427                         dev_dbg(ddata->dev, "charger full status\n");
 428                         ddata->is_full = 1;
 429                         break;
 430                 default:
 431                         break;
 432                 }
 433         }
 434
 435         /*
 436          * The full battery voltage here can be inaccurate, it's used just to
 437          * filter out any trickle charging events. We clear the is_full status
 438          * on charger disconnect above anyways.
 439          */
 440         vfull = ddata->config.bat.constant_charge_voltage_max_uv - 120000;
 441
 442         if (ddata->is_full && state->voltage < vfull)
 443                 ddata->is_full = 0;
 444
 445         return ddata->is_full;
 446 }
 447
 448 static bool cpcap_battery_low(struct cpcap_battery_ddata *ddata)
 449 {
 450         struct cpcap_battery_state_data *state = cpcap_battery_latest(ddata);
 451         static bool is_low;
 452
 453         if (state->current_ua > 0 && (state->voltage <= 3350000 || is_low))
 454                 is_low = true;
 455         else
 456                 is_low = false;
 457
 458         return is_low;
 459 }
 460
 461 static int cpcap_battery_update_status(struct cpcap_battery_ddata *ddata)
 462 {
 463         struct cpcap_battery_state_data state, *latest, *previous,
 464                                         *empty, *full;
 465         ktime_t now;
 466         int error;
 467
 468         memset(&state, 0, sizeof(state));
 469         now = ktime_get();
 470
 471         latest = cpcap_battery_latest(ddata);
 472         if (latest) {
 473                 s64 delta_ms = ktime_to_ms(ktime_sub(now, latest->time));
 474
 475                 if (delta_ms < CPCAP_BATTERY_CC_SAMPLE_PERIOD_MS)
 476                         return delta_ms;
 477         }
 478
 479         state.time = now;
 480         state.voltage = cpcap_battery_get_voltage(ddata);
 481         state.current_ua = cpcap_battery_get_current(ddata);
 482         state.counter_uah = cpcap_battery_read_accumulated(ddata, &state.cc);
 483
 484         error = cpcap_charger_battery_temperature(ddata,
 485                                                   &state.temperature);
 486         if (error)
 487                 return error;
 488
 489         previous = cpcap_battery_previous(ddata);
 490         memcpy(previous, latest, sizeof(*previous));
 491         memcpy(latest, &state, sizeof(*latest));
 492
 493         if (cpcap_battery_full(ddata)) {
 494                 full = cpcap_battery_get_full(ddata);
 495                 memcpy(full, latest, sizeof(*full));
 496
 497                 empty = cpcap_battery_get_empty(ddata);
 498                 if (empty->voltage && empty->voltage != -1) {
 499                         empty->voltage = -1;
 500                         ddata->charge_full =
 501                                 empty->counter_uah - full->counter_uah;
 502                 } else if (ddata->charge_full) {
 503                         empty->voltage = -1;
 504                         empty->counter_uah =
 505                                 full->counter_uah + ddata->charge_full;
 506                 }
 507         } else if (cpcap_battery_low(ddata)) {
 508                 empty = cpcap_battery_get_empty(ddata);
 509                 memcpy(empty, latest, sizeof(*empty));
 510
 511                 full = cpcap_battery_get_full(ddata);
 512                 if (full->voltage) {
 513                         full->voltage = 0;
 514                         ddata->charge_full =
 515                                 empty->counter_uah - full->counter_uah;
 516                 }
 517         }
 518
 519         return 0;
 520 }
 521
 522 /*
 523  * Update battery status when cpcap-charger calls power_supply_changed().
 524  * This allows us to detect battery full condition before the charger
 525  * disconnects.
 526  */
 527 static void cpcap_battery_external_power_changed(struct power_supply *psy)
 528 {
 529         union power_supply_propval prop;
 530
 531         power_supply_get_property(psy, POWER_SUPPLY_PROP_STATUS, &prop);
 532 }
 533
 534 static enum power_supply_property cpcap_battery_props[] = {
 535         POWER_SUPPLY_PROP_STATUS,
 536         POWER_SUPPLY_PROP_PRESENT,
 537         POWER_SUPPLY_PROP_TECHNOLOGY,
 538         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 539         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
 540         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 541         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 542         POWER_SUPPLY_PROP_CURRENT_AVG,
 543         POWER_SUPPLY_PROP_CURRENT_NOW,
 544         POWER_SUPPLY_PROP_CHARGE_FULL,
 545         POWER_SUPPLY_PROP_CHARGE_NOW,
 546         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 547         POWER_SUPPLY_PROP_CHARGE_COUNTER,
 548         POWER_SUPPLY_PROP_POWER_NOW,
 549         POWER_SUPPLY_PROP_POWER_AVG,
 550         POWER_SUPPLY_PROP_CAPACITY,
 551         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 552         POWER_SUPPLY_PROP_SCOPE,
 553         POWER_SUPPLY_PROP_TEMP,
 554 };
 555
 556 static int cpcap_battery_get_property(struct power_supply *psy,
 557                                       enum power_supply_property psp,
 558                                       union power_supply_propval *val)
 559 {
 560         struct cpcap_battery_ddata *ddata = power_supply_get_drvdata(psy);
 561         struct cpcap_battery_state_data *latest, *previous, *empty;
 562         u32 sample;
 563         s32 accumulator;
 564         int cached;
 565         s64 tmp;
 566
 567         cached = cpcap_battery_update_status(ddata);
 568         if (cached < 0)
 569                 return cached;
 570
 571         latest = cpcap_battery_latest(ddata);
 572         previous = cpcap_battery_previous(ddata);
 573
 574         switch (psp) {
 575         case POWER_SUPPLY_PROP_PRESENT:
 576                 if (latest->temperature > CPCAP_NO_BATTERY || ignore_temperature_probe)
 577                         val->intval = 1;
 578                 else
 579                         val->intval = 0;
 580                 break;
 581         case POWER_SUPPLY_PROP_STATUS:
 582                 if (cpcap_battery_full(ddata)) {
 583                         val->intval = POWER_SUPPLY_STATUS_FULL;
 584                         break;
 585                 }
 586                 if (cpcap_battery_cc_get_avg_current(ddata) < 0)
 587                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 588                 else
 589                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 590                 break;
 591         case POWER_SUPPLY_PROP_TECHNOLOGY:
 592                 val->intval = ddata->config.info.technology;
 593                 break;
 594         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 595                 val->intval = cpcap_battery_get_voltage(ddata);
 596                 break;
 597         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 598                 val->intval = ddata->config.info.voltage_max_design;
 599                 break;
 600         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 601                 val->intval = ddata->config.info.voltage_min_design;
 602                 break;
 603         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 604                 val->intval = ddata->config.bat.constant_charge_voltage_max_uv;
 605                 break;
 606         case POWER_SUPPLY_PROP_CURRENT_AVG:
 607                 sample = latest->cc.sample - previous->cc.sample;
 608                 if (!sample) {
 609                         val->intval = cpcap_battery_cc_get_avg_current(ddata);
 610                         break;
 611                 }
 612                 accumulator = latest->cc.accumulator - previous->cc.accumulator;
 613                 val->intval = cpcap_battery_cc_to_ua(ddata, sample,
 614                                                      accumulator,
 615                                                      latest->cc.offset);
 616                 break;
 617         case POWER_SUPPLY_PROP_CURRENT_NOW:
 618                 val->intval = latest->current_ua;
 619                 break;
 620         case POWER_SUPPLY_PROP_CHARGE_COUNTER:
 621                 val->intval = latest->counter_uah;
 622                 break;
 623         case POWER_SUPPLY_PROP_POWER_NOW:
 624                 tmp = (latest->voltage / 10000) * latest->current_ua;
 625                 val->intval = div64_s64(tmp, 100);
 626                 break;
 627         case POWER_SUPPLY_PROP_POWER_AVG:
 628                 sample = latest->cc.sample - previous->cc.sample;
 629                 if (!sample) {
 630                         tmp = cpcap_battery_cc_get_avg_current(ddata);
 631                         tmp *= (latest->voltage / 10000);
 632                         val->intval = div64_s64(tmp, 100);
 633                         break;
 634                 }
 635                 accumulator = latest->cc.accumulator - previous->cc.accumulator;
 636                 tmp = cpcap_battery_cc_to_ua(ddata, sample, accumulator,
 637                                              latest->cc.offset);
 638                 tmp *= ((latest->voltage + previous->voltage) / 20000);
 639                 val->intval = div64_s64(tmp, 100);
 640                 break;
 641         case POWER_SUPPLY_PROP_CAPACITY:
 642                 empty = cpcap_battery_get_empty(ddata);
 643                 if (!empty->voltage || !ddata->charge_full)
 644                         return -ENODATA;
 645                 /* (ddata->charge_full / 200) is needed for rounding */
 646                 val->intval = empty->counter_uah - latest->counter_uah +
 647                         ddata->charge_full / 200;
 648                 val->intval = clamp(val->intval, 0, ddata->charge_full);
 649                 val->intval = val->intval * 100 / ddata->charge_full;
 650                 break;
 651         case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
 652                 if (cpcap_battery_full(ddata))
 653                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
 654                 else if (latest->voltage >= 3750000)
 655                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
 656                 else if (latest->voltage >= 3300000)
 657                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
 658                 else if (latest->voltage > 3100000)
 659                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
 660                 else if (latest->voltage <= 3100000)
 661                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
 662                 else
 663                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
 664                 break;
 665         case POWER_SUPPLY_PROP_CHARGE_NOW:
 666                 empty = cpcap_battery_get_empty(ddata);
 667                 if (!empty->voltage)
 668                         return -ENODATA;
 669                 val->intval = empty->counter_uah - latest->counter_uah;
 670                 if (val->intval < 0)
 671                         val->intval = 0;
 672                 else if (ddata->charge_full && ddata->charge_full < val->intval)
 673                         val->intval = ddata->charge_full;
 674                 break;
 675         case POWER_SUPPLY_PROP_CHARGE_FULL:
 676                 if (!ddata->charge_full)
 677                         return -ENODATA;
 678                 val->intval = ddata->charge_full;
 679                 break;
 680         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 681                 val->intval = ddata->config.info.charge_full_design;
 682                 break;
 683         case POWER_SUPPLY_PROP_SCOPE:
 684                 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
 685                 break;
 686         case POWER_SUPPLY_PROP_TEMP:
 687                 if (ignore_temperature_probe)
 688                         return -ENODATA;
 689                 val->intval = latest->temperature;
 690                 break;
 691         default:
 692                 return -EINVAL;
 693         }
 694
 695         return 0;
 696 }
 697
 698 static int cpcap_battery_update_charger(struct cpcap_battery_ddata *ddata,
 699                                         int const_charge_voltage)
 700 {
 701         union power_supply_propval prop;
 702         union power_supply_propval val;
 703         struct power_supply *charger;
 704         int error;
 705
 706         charger = power_supply_get_by_name("usb");
 707         if (!charger)
 708                 return -ENODEV;
 709
 710         error = power_supply_get_property(charger,
 711                                 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 712                                 &prop);
 713         if (error)
 714                 goto out_put;
 715
 716         /* Allow charger const voltage lower than battery const voltage */
 717         if (const_charge_voltage > prop.intval)
 718                 goto out_put;
 719
 720         val.intval = const_charge_voltage;
 721
 722         error = power_supply_set_property(charger,
 723                         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 724                         &val);
 725 out_put:
 726         power_supply_put(charger);
 727
 728         return error;
 729 }
 730
 731 static int cpcap_battery_set_property(struct power_supply *psy,
 732                                       enum power_supply_property psp,
 733                                       const union power_supply_propval *val)
 734 {
 735         struct cpcap_battery_ddata *ddata = power_supply_get_drvdata(psy);
 736
 737         switch (psp) {
 738         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 739                 if (val->intval < ddata->config.info.voltage_min_design)
 740                         return -EINVAL;
 741                 if (val->intval > ddata->config.info.voltage_max_design)
 742                         return -EINVAL;
 743
 744                 ddata->config.bat.constant_charge_voltage_max_uv = val->intval;
 745
 746                 return cpcap_battery_update_charger(ddata, val->intval);
 747         case POWER_SUPPLY_PROP_CHARGE_FULL:
 748                 if (val->intval < 0)
 749                         return -EINVAL;
 750                 if (val->intval > ddata->config.info.charge_full_design)
 751                         return -EINVAL;
 752
 753                 ddata->charge_full = val->intval;
 754
 755                 return 0;
 756         default:
 757                 return -EINVAL;
 758         }
 759
 760         return 0;
 761 }
 762
 763 static int cpcap_battery_property_is_writeable(struct power_supply *psy,
 764                                                enum power_supply_property psp)
 765 {
 766         switch (psp) {
 767         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 768         case POWER_SUPPLY_PROP_CHARGE_FULL:
 769                 return 1;
 770         default:
 771                 return 0;
 772         }
 773 }
 774
 775 static irqreturn_t cpcap_battery_irq_thread(int irq, void *data)
 776 {
 777         struct cpcap_battery_ddata *ddata = data;
 778         struct cpcap_battery_state_data *latest;
 779         struct cpcap_interrupt_desc *d;
 780
 781         if (!atomic_read(&ddata->active))
 782                 return IRQ_NONE;
 783
 784         list_for_each_entry(d, &ddata->irq_list, node) {
 785                 if (irq == d->irq)
 786                         break;
 787         }
 788
 789         if (list_entry_is_head(d, &ddata->irq_list, node))
 790                 return IRQ_NONE;
 791
 792         latest = cpcap_battery_latest(ddata);
 793
 794         switch (d->action) {
 795         case CPCAP_BATTERY_IRQ_ACTION_CC_CAL_DONE:
 796                 dev_info(ddata->dev, "Coulomb counter calibration done\n");
 797                 break;
 798         case CPCAP_BATTERY_IRQ_ACTION_BATTERY_LOW:
 799                 if (latest->current_ua >= 0)
 800                         dev_warn(ddata->dev, "Battery low at %imV!\n",
 801                                 latest->voltage / 1000);
 802                 break;
 803         case CPCAP_BATTERY_IRQ_ACTION_POWEROFF:
 804                 if (latest->current_ua >= 0 && latest->voltage <= 3200000) {
 805                         dev_emerg(ddata->dev,
 806                                   "Battery empty at %imV, powering off\n",
 807                                   latest->voltage / 1000);
 808                         orderly_poweroff(true);
 809                 }
 810                 break;
 811         default:
 812                 break;
 813         }
 814
 815         power_supply_changed(ddata->psy);
 816
 817         return IRQ_HANDLED;
 818 }
 819
 820 static int cpcap_battery_init_irq(struct platform_device *pdev,
 821                                   struct cpcap_battery_ddata *ddata,
 822                                   const char *name)
 823 {
 824         struct cpcap_interrupt_desc *d;
 825         int irq, error;
 826
 827         irq = platform_get_irq_byname(pdev, name);
 828         if (irq < 0)
 829                 return irq;
 830
 831         error = devm_request_threaded_irq(ddata->dev, irq, NULL,
 832                                           cpcap_battery_irq_thread,
 833                                           IRQF_SHARED | IRQF_ONESHOT,
 834                                           name, ddata);
 835         if (error) {
 836                 dev_err(ddata->dev, "could not get irq %s: %i\n",
 837                         name, error);
 838
 839                 return error;
 840         }
 841
 842         d = devm_kzalloc(ddata->dev, sizeof(*d), GFP_KERNEL);
 843         if (!d)
 844                 return -ENOMEM;
 845
 846         d->name = name;
 847         d->irq = irq;
 848
 849         if (!strncmp(name, "cccal", 5))
 850                 d->action = CPCAP_BATTERY_IRQ_ACTION_CC_CAL_DONE;
 851         else if (!strncmp(name, "lowbph", 6))
 852                 d->action = CPCAP_BATTERY_IRQ_ACTION_BATTERY_LOW;
 853         else if (!strncmp(name, "lowbpl", 6))
 854                 d->action = CPCAP_BATTERY_IRQ_ACTION_POWEROFF;
 855
 856         list_add(&d->node, &ddata->irq_list);
 857
 858         return 0;
 859 }
 860
 861 static int cpcap_battery_init_interrupts(struct platform_device *pdev,
 862                                          struct cpcap_battery_ddata *ddata)
 863 {
 864         static const char * const cpcap_battery_irqs[] = {
 865                 "eol", "lowbph", "lowbpl",
 866                 "chrgcurr1", "battdetb"
 867         };
 868         int i, error;
 869
 870         for (i = 0; i < ARRAY_SIZE(cpcap_battery_irqs); i++) {
 871                 error = cpcap_battery_init_irq(pdev, ddata,
 872                                                cpcap_battery_irqs[i]);
 873                 if (error)
 874                         return error;
 875         }
 876
 877         /* Enable calibration interrupt if already available in dts */
 878         cpcap_battery_init_irq(pdev, ddata, "cccal");
 879
 880         /* Enable low battery interrupts for 3.3V high and 3.1V low */
 881         error = regmap_update_bits(ddata->reg, CPCAP_REG_BPEOL,
 882                                    0xffff,
 883                                    CPCAP_REG_BPEOL_BIT_BATTDETEN);
 884         if (error)
 885                 return error;
 886
 887         return 0;
 888 }
 889
 890 static int cpcap_battery_init_iio(struct cpcap_battery_ddata *ddata)
 891 {
 892         const char * const names[CPCAP_BATTERY_IIO_NR] = {
 893                 "battdetb", "battp", "chg_isense", "batti",
 894         };
 895         int error, i;
 896
 897         for (i = 0; i < CPCAP_BATTERY_IIO_NR; i++) {
 898                 ddata->channels[i] = devm_iio_channel_get(ddata->dev,
 899                                                           names[i]);
 900                 if (IS_ERR(ddata->channels[i])) {
 901                         error = PTR_ERR(ddata->channels[i]);
 902                         goto out_err;
 903                 }
 904
 905                 if (!ddata->channels[i]->indio_dev) {
 906                         error = -ENXIO;
 907                         goto out_err;
 908                 }
 909         }
 910
 911         return 0;
 912
 913 out_err:
 914         return dev_err_probe(ddata->dev, error,
 915                              "could not initialize VBUS or ID IIO\n");
 916 }
 917
 918 /* Calibrate coulomb counter */
 919 static int cpcap_battery_calibrate(struct cpcap_battery_ddata *ddata)
 920 {
 921         int error, ccc1, value;
 922         unsigned long timeout;
 923
 924         error = regmap_read(ddata->reg, CPCAP_REG_CCC1, &ccc1);
 925         if (error)
 926                 return error;
 927
 928         timeout = jiffies + msecs_to_jiffies(6000);
 929
 930         /* Start calibration */
 931         error = regmap_update_bits(ddata->reg, CPCAP_REG_CCC1,
 932                                    0xffff,
 933                                    CPCAP_REG_CCC1_CAL_EN);
 934         if (error)
 935                 goto restore;
 936
 937         while (time_before(jiffies, timeout)) {
 938                 error = regmap_read(ddata->reg, CPCAP_REG_CCC1, &value);
 939                 if (error)
 940                         goto restore;
 941
 942                 if (!(value & CPCAP_REG_CCC1_CAL_EN))
 943                         break;
 944
 945                 error = regmap_read(ddata->reg, CPCAP_REG_CCM, &value);
 946                 if (error)
 947                         goto restore;
 948
 949                 msleep(300);
 950         }
 951
 952         /* Read calibration offset from CCM */
 953         error = regmap_read(ddata->reg, CPCAP_REG_CCM, &value);
 954         if (error)
 955                 goto restore;
 956
 957         dev_info(ddata->dev, "calibration done: 0x%04x\n", value);
 958
 959 restore:
 960         if (error)
 961                 dev_err(ddata->dev, "%s: error %i\n", __func__, error);
 962
 963         error = regmap_update_bits(ddata->reg, CPCAP_REG_CCC1,
 964                                    0xffff, ccc1);
 965         if (error)
 966                 dev_err(ddata->dev, "%s: restore error %i\n",
 967                         __func__, error);
 968
 969         return error;
 970 }
 971
 972 /*
 973  * Based on the values from Motorola mapphone Linux kernel. In the
 974  * the Motorola mapphone Linux kernel tree the value for pm_cd_factor
 975  * is passed to the kernel via device tree. If it turns out to be
 976  * something device specific we can consider that too later.
 977  *
 978  * And looking at the battery full and shutdown values for the stock
 979  * kernel on droid 4, full is 4351000 and software initiates shutdown
 980  * at 3078000. The device will die around 2743000.
 981  */
 982 static const struct cpcap_battery_config cpcap_battery_default_data = {
 983         .cd_factor = 0x3cc,
 984         .info.technology = POWER_SUPPLY_TECHNOLOGY_LION,
 985         .info.voltage_max_design = 4351000,
 986         .info.voltage_min_design = 3100000,
 987         .info.charge_full_design = 1740000,
 988         .bat.constant_charge_voltage_max_uv = 4200000,
 989 };
 990
 991 #ifdef CONFIG_OF
 992 static const struct of_device_id cpcap_battery_id_table[] = {
 993         {
 994                 .compatible = "motorola,cpcap-battery",
 995                 .data = &cpcap_battery_default_data,
 996         },
 997         {},
 998 };
 999 MODULE_DEVICE_TABLE(of, cpcap_battery_id_table);
1000 #endif
1001
1002 static const struct power_supply_desc cpcap_charger_battery_desc = {
1003         .name           = "battery",
1004         .type           = POWER_SUPPLY_TYPE_BATTERY,
1005         .properties     = cpcap_battery_props,
1006         .num_properties = ARRAY_SIZE(cpcap_battery_props),
1007         .get_property   = cpcap_battery_get_property,
1008         .set_property   = cpcap_battery_set_property,
1009         .property_is_writeable = cpcap_battery_property_is_writeable,
1010         .external_power_changed = cpcap_battery_external_power_changed,
1011 };
1012
1013 static int cpcap_battery_probe(struct platform_device *pdev)
1014 {
1015         struct cpcap_battery_ddata *ddata;
1016         const struct of_device_id *match;
1017         struct power_supply_config psy_cfg = {};
1018         int error;
1019
1020         match = of_match_device(of_match_ptr(cpcap_battery_id_table),
1021                                 &pdev->dev);
1022         if (!match)
1023                 return -EINVAL;
1024
1025         if (!match->data) {
1026                 dev_err(&pdev->dev, "no configuration data found\n");
1027
1028                 return -ENODEV;
1029         }
1030
1031         ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
1032         if (!ddata)
1033                 return -ENOMEM;
1034
1035         INIT_LIST_HEAD(&ddata->irq_list);
1036         ddata->dev = &pdev->dev;
1037         memcpy(&ddata->config, match->data, sizeof(ddata->config));
1038
1039         ddata->reg = dev_get_regmap(ddata->dev->parent, NULL);
1040         if (!ddata->reg)
1041                 return -ENODEV;
1042
1043         error = cpcap_get_vendor(ddata->dev, ddata->reg, &ddata->vendor);
1044         if (error)
1045                 return error;
1046
1047         switch (ddata->vendor) {
1048         case CPCAP_VENDOR_ST:
1049                 ddata->cc_lsb = 95374;  /* μAms per LSB */
1050                 break;
1051         case CPCAP_VENDOR_TI:
1052                 ddata->cc_lsb = 91501;  /* μAms per LSB */
1053                 break;
1054         default:
1055                 return -EINVAL;
1056         }
1057         ddata->cc_lsb = (ddata->cc_lsb * ddata->config.cd_factor) / 1000;
1058
1059         platform_set_drvdata(pdev, ddata);
1060
1061         error = cpcap_battery_init_interrupts(pdev, ddata);
1062         if (error)
1063                 return error;
1064
1065         error = cpcap_battery_init_iio(ddata);
1066         if (error)
1067                 return error;
1068
1069         psy_cfg.of_node = pdev->dev.of_node;
1070         psy_cfg.drv_data = ddata;
1071
1072         ddata->psy = devm_power_supply_register(ddata->dev,
1073                                                 &cpcap_charger_battery_desc,
1074                                                 &psy_cfg);
1075         error = PTR_ERR_OR_ZERO(ddata->psy);
1076         if (error) {
1077                 dev_err(ddata->dev, "failed to register power supply\n");
1078                 return error;
1079         }
1080
1081         atomic_set(&ddata->active, 1);
1082
1083         error = cpcap_battery_calibrate(ddata);
1084         if (error)
1085                 return error;
1086
1087         return 0;
1088 }
1089
1090 static int cpcap_battery_remove(struct platform_device *pdev)
1091 {
1092         struct cpcap_battery_ddata *ddata = platform_get_drvdata(pdev);
1093         int error;
1094
1095         atomic_set(&ddata->active, 0);
1096         error = regmap_update_bits(ddata->reg, CPCAP_REG_BPEOL,
1097                                    0xffff, 0);
1098         if (error)
1099                 dev_err(&pdev->dev, "could not disable: %i\n", error);
1100
1101         return 0;
1102 }
1103
1104 static struct platform_driver cpcap_battery_driver = {
1105         .driver = {
1106                 .name           = "cpcap_battery",
1107                 .of_match_table = of_match_ptr(cpcap_battery_id_table),
1108         },
1109         .probe  = cpcap_battery_probe,
1110         .remove = cpcap_battery_remove,
1111 };
1112 module_platform_driver(cpcap_battery_driver);
1113
1114 MODULE_LICENSE("GPL v2");
1115 MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
1116 MODULE_DESCRIPTION("CPCAP PMIC Battery Driver");