drivers/power/supply/max17042_battery.c

   1 /*
   2  * Fuel gauge driver for Maxim 17042 / 8966 / 8997
   3  *  Note that Maxim 8966 and 8997 are mfd and this is its subdevice.
   4  *
   5  * Copyright (C) 2011 Samsung Electronics
   6  * MyungJoo Ham <myungjoo.ham@samsung.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  * This driver is based on max17040_battery.c
  23  */
  24
  25 #include <linux/init.h>
  26 #include <linux/module.h>
  27 #include <linux/slab.h>
  28 #include <linux/i2c.h>
  29 #include <linux/delay.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/pm.h>
  32 #include <linux/mod_devicetable.h>
  33 #include <linux/power_supply.h>
  34 #include <linux/power/max17042_battery.h>
  35 #include <linux/of.h>
  36 #include <linux/regmap.h>
  37
  38 /* Status register bits */
  39 #define STATUS_POR_BIT         (1 << 1)
  40 #define STATUS_BST_BIT         (1 << 3)
  41 #define STATUS_VMN_BIT         (1 << 8)
  42 #define STATUS_TMN_BIT         (1 << 9)
  43 #define STATUS_SMN_BIT         (1 << 10)
  44 #define STATUS_BI_BIT          (1 << 11)
  45 #define STATUS_VMX_BIT         (1 << 12)
  46 #define STATUS_TMX_BIT         (1 << 13)
  47 #define STATUS_SMX_BIT         (1 << 14)
  48 #define STATUS_BR_BIT          (1 << 15)
  49
  50 /* Interrupt mask bits */
  51 #define CONFIG_ALRT_BIT_ENBL    (1 << 2)
  52 #define STATUS_INTR_SOCMIN_BIT  (1 << 10)
  53 #define STATUS_INTR_SOCMAX_BIT  (1 << 14)
  54
  55 #define VFSOC0_LOCK             0x0000
  56 #define VFSOC0_UNLOCK           0x0080
  57 #define MODEL_UNLOCK1   0X0059
  58 #define MODEL_UNLOCK2   0X00C4
  59 #define MODEL_LOCK1             0X0000
  60 #define MODEL_LOCK2             0X0000
  61
  62 #define dQ_ACC_DIV      0x4
  63 #define dP_ACC_100      0x1900
  64 #define dP_ACC_200      0x3200
  65
  66 #define MAX17042_VMAX_TOLERANCE         50 /* 50 mV */
  67
  68 struct max17042_chip {
  69         struct i2c_client *client;
  70         struct regmap *regmap;
  71         struct power_supply *battery;
  72         enum max170xx_chip_type chip_type;
  73         struct max17042_platform_data *pdata;
  74         struct work_struct work;
  75         int    init_complete;
  76 };
  77
  78 static enum power_supply_property max17042_battery_props[] = {
  79         POWER_SUPPLY_PROP_STATUS,
  80         POWER_SUPPLY_PROP_PRESENT,
  81         POWER_SUPPLY_PROP_CYCLE_COUNT,
  82         POWER_SUPPLY_PROP_VOLTAGE_MAX,
  83         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
  84         POWER_SUPPLY_PROP_VOLTAGE_NOW,
  85         POWER_SUPPLY_PROP_VOLTAGE_AVG,
  86         POWER_SUPPLY_PROP_VOLTAGE_OCV,
  87         POWER_SUPPLY_PROP_CAPACITY,
  88         POWER_SUPPLY_PROP_CHARGE_FULL,
  89         POWER_SUPPLY_PROP_CHARGE_COUNTER,
  90         POWER_SUPPLY_PROP_TEMP,
  91         POWER_SUPPLY_PROP_TEMP_ALERT_MIN,
  92         POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
  93         POWER_SUPPLY_PROP_TEMP_MIN,
  94         POWER_SUPPLY_PROP_TEMP_MAX,
  95         POWER_SUPPLY_PROP_HEALTH,
  96         POWER_SUPPLY_PROP_CURRENT_NOW,
  97         POWER_SUPPLY_PROP_CURRENT_AVG,
  98 };
  99
 100 static int max17042_get_temperature(struct max17042_chip *chip, int *temp)
 101 {
 102         int ret;
 103         u32 data;
 104         struct regmap *map = chip->regmap;
 105
 106         ret = regmap_read(map, MAX17042_TEMP, &data);
 107         if (ret < 0)
 108                 return ret;
 109
 110         *temp = sign_extend32(data, 15);
 111         /* The value is converted into deci-centigrade scale */
 112         /* Units of LSB = 1 / 256 degree Celsius */
 113         *temp = *temp * 10 / 256;
 114         return 0;
 115 }
 116
 117 static int max17042_get_status(struct max17042_chip *chip, int *status)
 118 {
 119         int ret, charge_full, charge_now;
 120
 121         ret = power_supply_am_i_supplied(chip->battery);
 122         if (ret < 0) {
 123                 *status = POWER_SUPPLY_STATUS_UNKNOWN;
 124                 return 0;
 125         }
 126         if (ret == 0) {
 127                 *status = POWER_SUPPLY_STATUS_DISCHARGING;
 128                 return 0;
 129         }
 130
 131         /*
 132          * The MAX170xx has builtin end-of-charge detection and will update
 133          * FullCAP to match RepCap when it detects end of charging.
 134          *
 135          * When this cycle the battery gets charged to a higher (calculated)
 136          * capacity then the previous cycle then FullCAP will get updated
 137          * contineously once end-of-charge detection kicks in, so allow the
 138          * 2 to differ a bit.
 139          */
 140
 141         ret = regmap_read(chip->regmap, MAX17042_FullCAP, &charge_full);
 142         if (ret < 0)
 143                 return ret;
 144
 145         ret = regmap_read(chip->regmap, MAX17042_RepCap, &charge_now);
 146         if (ret < 0)
 147                 return ret;
 148
 149         if ((charge_full - charge_now) <= MAX17042_FULL_THRESHOLD)
 150                 *status = POWER_SUPPLY_STATUS_FULL;
 151         else
 152                 *status = POWER_SUPPLY_STATUS_CHARGING;
 153
 154         return 0;
 155 }
 156
 157 static int max17042_get_battery_health(struct max17042_chip *chip, int *health)
 158 {
 159         int temp, vavg, vbatt, ret;
 160         u32 val;
 161
 162         ret = regmap_read(chip->regmap, MAX17042_AvgVCELL, &val);
 163         if (ret < 0)
 164                 goto health_error;
 165
 166         /* bits [0-3] unused */
 167         vavg = val * 625 / 8;
 168         /* Convert to millivolts */
 169         vavg /= 1000;
 170
 171         ret = regmap_read(chip->regmap, MAX17042_VCELL, &val);
 172         if (ret < 0)
 173                 goto health_error;
 174
 175         /* bits [0-3] unused */
 176         vbatt = val * 625 / 8;
 177         /* Convert to millivolts */
 178         vbatt /= 1000;
 179
 180         if (vavg < chip->pdata->vmin) {
 181                 *health = POWER_SUPPLY_HEALTH_DEAD;
 182                 goto out;
 183         }
 184
 185         if (vbatt > chip->pdata->vmax + MAX17042_VMAX_TOLERANCE) {
 186                 *health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 187                 goto out;
 188         }
 189
 190         ret = max17042_get_temperature(chip, &temp);
 191         if (ret < 0)
 192                 goto health_error;
 193
 194         if (temp < chip->pdata->temp_min) {
 195                 *health = POWER_SUPPLY_HEALTH_COLD;
 196                 goto out;
 197         }
 198
 199         if (temp > chip->pdata->temp_max) {
 200                 *health = POWER_SUPPLY_HEALTH_OVERHEAT;
 201                 goto out;
 202         }
 203
 204         *health = POWER_SUPPLY_HEALTH_GOOD;
 205
 206 out:
 207         return 0;
 208
 209 health_error:
 210         return ret;
 211 }
 212
 213 static int max17042_get_property(struct power_supply *psy,
 214                             enum power_supply_property psp,
 215                             union power_supply_propval *val)
 216 {
 217         struct max17042_chip *chip = power_supply_get_drvdata(psy);
 218         struct regmap *map = chip->regmap;
 219         int ret;
 220         u32 data;
 221
 222         if (!chip->init_complete)
 223                 return -EAGAIN;
 224
 225         switch (psp) {
 226         case POWER_SUPPLY_PROP_STATUS:
 227                 ret = max17042_get_status(chip, &val->intval);
 228                 if (ret < 0)
 229                         return ret;
 230                 break;
 231         case POWER_SUPPLY_PROP_PRESENT:
 232                 ret = regmap_read(map, MAX17042_STATUS, &data);
 233                 if (ret < 0)
 234                         return ret;
 235
 236                 if (data & MAX17042_STATUS_BattAbsent)
 237                         val->intval = 0;
 238                 else
 239                         val->intval = 1;
 240                 break;
 241         case POWER_SUPPLY_PROP_CYCLE_COUNT:
 242                 ret = regmap_read(map, MAX17042_Cycles, &data);
 243                 if (ret < 0)
 244                         return ret;
 245
 246                 val->intval = data;
 247                 break;
 248         case POWER_SUPPLY_PROP_VOLTAGE_MAX:
 249                 ret = regmap_read(map, MAX17042_MinMaxVolt, &data);
 250                 if (ret < 0)
 251                         return ret;
 252
 253                 val->intval = data >> 8;
 254                 val->intval *= 20000; /* Units of LSB = 20mV */
 255                 break;
 256         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 257                 if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
 258                         ret = regmap_read(map, MAX17042_V_empty, &data);
 259                 else
 260                         ret = regmap_read(map, MAX17047_V_empty, &data);
 261                 if (ret < 0)
 262                         return ret;
 263
 264                 val->intval = data >> 7;
 265                 val->intval *= 10000; /* Units of LSB = 10mV */
 266                 break;
 267         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 268                 ret = regmap_read(map, MAX17042_VCELL, &data);
 269                 if (ret < 0)
 270                         return ret;
 271
 272                 val->intval = data * 625 / 8;
 273                 break;
 274         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
 275                 ret = regmap_read(map, MAX17042_AvgVCELL, &data);
 276                 if (ret < 0)
 277                         return ret;
 278
 279                 val->intval = data * 625 / 8;
 280                 break;
 281         case POWER_SUPPLY_PROP_VOLTAGE_OCV:
 282                 ret = regmap_read(map, MAX17042_OCVInternal, &data);
 283                 if (ret < 0)
 284                         return ret;
 285
 286                 val->intval = data * 625 / 8;
 287                 break;
 288         case POWER_SUPPLY_PROP_CAPACITY:
 289                 ret = regmap_read(map, MAX17042_RepSOC, &data);
 290                 if (ret < 0)
 291                         return ret;
 292
 293                 val->intval = data >> 8;
 294                 break;
 295         case POWER_SUPPLY_PROP_CHARGE_FULL:
 296                 ret = regmap_read(map, MAX17042_FullCAP, &data);
 297                 if (ret < 0)
 298                         return ret;
 299
 300                 val->intval = data * 1000 / 2;
 301                 break;
 302         case POWER_SUPPLY_PROP_CHARGE_COUNTER:
 303                 ret = regmap_read(map, MAX17042_QH, &data);
 304                 if (ret < 0)
 305                         return ret;
 306
 307                 val->intval = data * 1000 / 2;
 308                 break;
 309         case POWER_SUPPLY_PROP_TEMP:
 310                 ret = max17042_get_temperature(chip, &val->intval);
 311                 if (ret < 0)
 312                         return ret;
 313                 break;
 314         case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
 315                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
 316                 if (ret < 0)
 317                         return ret;
 318                 /* LSB is Alert Minimum. In deci-centigrade */
 319                 val->intval = sign_extend32(data & 0xff, 7) * 10;
 320                 break;
 321         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
 322                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
 323                 if (ret < 0)
 324                         return ret;
 325                 /* MSB is Alert Maximum. In deci-centigrade */
 326                 val->intval = sign_extend32(data >> 8, 7) * 10;
 327                 break;
 328         case POWER_SUPPLY_PROP_TEMP_MIN:
 329                 val->intval = chip->pdata->temp_min;
 330                 break;
 331         case POWER_SUPPLY_PROP_TEMP_MAX:
 332                 val->intval = chip->pdata->temp_max;
 333                 break;
 334         case POWER_SUPPLY_PROP_HEALTH:
 335                 ret = max17042_get_battery_health(chip, &val->intval);
 336                 if (ret < 0)
 337                         return ret;
 338                 break;
 339         case POWER_SUPPLY_PROP_CURRENT_NOW:
 340                 if (chip->pdata->enable_current_sense) {
 341                         ret = regmap_read(map, MAX17042_Current, &data);
 342                         if (ret < 0)
 343                                 return ret;
 344
 345                         val->intval = sign_extend32(data, 15);
 346                         val->intval *= 1562500 / chip->pdata->r_sns;
 347                 } else {
 348                         return -EINVAL;
 349                 }
 350                 break;
 351         case POWER_SUPPLY_PROP_CURRENT_AVG:
 352                 if (chip->pdata->enable_current_sense) {
 353                         ret = regmap_read(map, MAX17042_AvgCurrent, &data);
 354                         if (ret < 0)
 355                                 return ret;
 356
 357                         val->intval = sign_extend32(data, 15);
 358                         val->intval *= 1562500 / chip->pdata->r_sns;
 359                 } else {
 360                         return -EINVAL;
 361                 }
 362                 break;
 363         default:
 364                 return -EINVAL;
 365         }
 366         return 0;
 367 }
 368
 369 static int max17042_set_property(struct power_supply *psy,
 370                             enum power_supply_property psp,
 371                             const union power_supply_propval *val)
 372 {
 373         struct max17042_chip *chip = power_supply_get_drvdata(psy);
 374         struct regmap *map = chip->regmap;
 375         int ret = 0;
 376         u32 data;
 377         int8_t temp;
 378
 379         switch (psp) {
 380         case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
 381                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
 382                 if (ret < 0)
 383                         return ret;
 384
 385                 /* Input in deci-centigrade, convert to centigrade */
 386                 temp = val->intval / 10;
 387                 /* force min < max */
 388                 if (temp >= (int8_t)(data >> 8))
 389                         temp = (int8_t)(data >> 8) - 1;
 390                 /* Write both MAX and MIN ALERT */
 391                 data = (data & 0xff00) + temp;
 392                 ret = regmap_write(map, MAX17042_TALRT_Th, data);
 393                 break;
 394         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
 395                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
 396                 if (ret < 0)
 397                         return ret;
 398
 399                 /* Input in Deci-Centigrade, convert to centigrade */
 400                 temp = val->intval / 10;
 401                 /* force max > min */
 402                 if (temp <= (int8_t)(data & 0xff))
 403                         temp = (int8_t)(data & 0xff) + 1;
 404                 /* Write both MAX and MIN ALERT */
 405                 data = (data & 0xff) + (temp << 8);
 406                 ret = regmap_write(map, MAX17042_TALRT_Th, data);
 407                 break;
 408         default:
 409                 ret = -EINVAL;
 410         }
 411
 412         return ret;
 413 }
 414
 415 static int max17042_property_is_writeable(struct power_supply *psy,
 416                 enum power_supply_property psp)
 417 {
 418         int ret;
 419
 420         switch (psp) {
 421         case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
 422         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
 423                 ret = 1;
 424                 break;
 425         default:
 426                 ret = 0;
 427         }
 428
 429         return ret;
 430 }
 431
 432 static void max17042_external_power_changed(struct power_supply *psy)
 433 {
 434         power_supply_changed(psy);
 435 }
 436
 437 static int max17042_write_verify_reg(struct regmap *map, u8 reg, u32 value)
 438 {
 439         int retries = 8;
 440         int ret;
 441         u32 read_value;
 442
 443         do {
 444                 ret = regmap_write(map, reg, value);
 445                 regmap_read(map, reg, &read_value);
 446                 if (read_value != value) {
 447                         ret = -EIO;
 448                         retries--;
 449                 }
 450         } while (retries && read_value != value);
 451
 452         if (ret < 0)
 453                 pr_err("%s: err %d\n", __func__, ret);
 454
 455         return ret;
 456 }
 457
 458 static inline void max17042_override_por(struct regmap *map,
 459                                          u8 reg, u16 value)
 460 {
 461         if (value)
 462                 regmap_write(map, reg, value);
 463 }
 464
 465 static inline void max10742_unlock_model(struct max17042_chip *chip)
 466 {
 467         struct regmap *map = chip->regmap;
 468
 469         regmap_write(map, MAX17042_MLOCKReg1, MODEL_UNLOCK1);
 470         regmap_write(map, MAX17042_MLOCKReg2, MODEL_UNLOCK2);
 471 }
 472
 473 static inline void max10742_lock_model(struct max17042_chip *chip)
 474 {
 475         struct regmap *map = chip->regmap;
 476
 477         regmap_write(map, MAX17042_MLOCKReg1, MODEL_LOCK1);
 478         regmap_write(map, MAX17042_MLOCKReg2, MODEL_LOCK2);
 479 }
 480
 481 static inline void max17042_write_model_data(struct max17042_chip *chip,
 482                                         u8 addr, int size)
 483 {
 484         struct regmap *map = chip->regmap;
 485         int i;
 486
 487         for (i = 0; i < size; i++)
 488                 regmap_write(map, addr + i,
 489                         chip->pdata->config_data->cell_char_tbl[i]);
 490 }
 491
 492 static inline void max17042_read_model_data(struct max17042_chip *chip,
 493                                         u8 addr, u16 *data, int size)
 494 {
 495         struct regmap *map = chip->regmap;
 496         int i;
 497         u32 tmp;
 498
 499         for (i = 0; i < size; i++) {
 500                 regmap_read(map, addr + i, &tmp);
 501                 data[i] = (u16)tmp;
 502         }
 503 }
 504
 505 static inline int max17042_model_data_compare(struct max17042_chip *chip,
 506                                         u16 *data1, u16 *data2, int size)
 507 {
 508         int i;
 509
 510         if (memcmp(data1, data2, size)) {
 511                 dev_err(&chip->client->dev, "%s compare failed\n", __func__);
 512                 for (i = 0; i < size; i++)
 513                         dev_info(&chip->client->dev, "0x%x, 0x%x",
 514                                 data1[i], data2[i]);
 515                 dev_info(&chip->client->dev, "\n");
 516                 return -EINVAL;
 517         }
 518         return 0;
 519 }
 520
 521 static int max17042_init_model(struct max17042_chip *chip)
 522 {
 523         int ret;
 524         int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
 525         u16 *temp_data;
 526
 527         temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
 528         if (!temp_data)
 529                 return -ENOMEM;
 530
 531         max10742_unlock_model(chip);
 532         max17042_write_model_data(chip, MAX17042_MODELChrTbl,
 533                                 table_size);
 534         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
 535                                 table_size);
 536
 537         ret = max17042_model_data_compare(
 538                 chip,
 539                 chip->pdata->config_data->cell_char_tbl,
 540                 temp_data,
 541                 table_size);
 542
 543         max10742_lock_model(chip);
 544         kfree(temp_data);
 545
 546         return ret;
 547 }
 548
 549 static int max17042_verify_model_lock(struct max17042_chip *chip)
 550 {
 551         int i;
 552         int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
 553         u16 *temp_data;
 554         int ret = 0;
 555
 556         temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
 557         if (!temp_data)
 558                 return -ENOMEM;
 559
 560         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
 561                                 table_size);
 562         for (i = 0; i < table_size; i++)
 563                 if (temp_data[i])
 564                         ret = -EINVAL;
 565
 566         kfree(temp_data);
 567         return ret;
 568 }
 569
 570 static void max17042_write_config_regs(struct max17042_chip *chip)
 571 {
 572         struct max17042_config_data *config = chip->pdata->config_data;
 573         struct regmap *map = chip->regmap;
 574
 575         regmap_write(map, MAX17042_CONFIG, config->config);
 576         regmap_write(map, MAX17042_LearnCFG, config->learn_cfg);
 577         regmap_write(map, MAX17042_FilterCFG,
 578                         config->filter_cfg);
 579         regmap_write(map, MAX17042_RelaxCFG, config->relax_cfg);
 580         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17047 ||
 581                         chip->chip_type == MAXIM_DEVICE_TYPE_MAX17050)
 582                 regmap_write(map, MAX17047_FullSOCThr,
 583                                                 config->full_soc_thresh);
 584 }
 585
 586 static void  max17042_write_custom_regs(struct max17042_chip *chip)
 587 {
 588         struct max17042_config_data *config = chip->pdata->config_data;
 589         struct regmap *map = chip->regmap;
 590
 591         max17042_write_verify_reg(map, MAX17042_RCOMP0, config->rcomp0);
 592         max17042_write_verify_reg(map, MAX17042_TempCo, config->tcompc0);
 593         max17042_write_verify_reg(map, MAX17042_ICHGTerm, config->ichgt_term);
 594         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042) {
 595                 regmap_write(map, MAX17042_EmptyTempCo, config->empty_tempco);
 596                 max17042_write_verify_reg(map, MAX17042_K_empty0,
 597                                         config->kempty0);
 598         } else {
 599                 max17042_write_verify_reg(map, MAX17047_QRTbl00,
 600                                                 config->qrtbl00);
 601                 max17042_write_verify_reg(map, MAX17047_QRTbl10,
 602                                                 config->qrtbl10);
 603                 max17042_write_verify_reg(map, MAX17047_QRTbl20,
 604                                                 config->qrtbl20);
 605                 max17042_write_verify_reg(map, MAX17047_QRTbl30,
 606                                                 config->qrtbl30);
 607         }
 608 }
 609
 610 static void max17042_update_capacity_regs(struct max17042_chip *chip)
 611 {
 612         struct max17042_config_data *config = chip->pdata->config_data;
 613         struct regmap *map = chip->regmap;
 614
 615         max17042_write_verify_reg(map, MAX17042_FullCAP,
 616                                 config->fullcap);
 617         regmap_write(map, MAX17042_DesignCap, config->design_cap);
 618         max17042_write_verify_reg(map, MAX17042_FullCAPNom,
 619                                 config->fullcapnom);
 620 }
 621
 622 static void max17042_reset_vfsoc0_reg(struct max17042_chip *chip)
 623 {
 624         unsigned int vfSoc;
 625         struct regmap *map = chip->regmap;
 626
 627         regmap_read(map, MAX17042_VFSOC, &vfSoc);
 628         regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_UNLOCK);
 629         max17042_write_verify_reg(map, MAX17042_VFSOC0, vfSoc);
 630         regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_LOCK);
 631 }
 632
 633 static void max17042_load_new_capacity_params(struct max17042_chip *chip)
 634 {
 635         u32 full_cap0, rep_cap, dq_acc, vfSoc;
 636         u32 rem_cap;
 637
 638         struct max17042_config_data *config = chip->pdata->config_data;
 639         struct regmap *map = chip->regmap;
 640
 641         regmap_read(map, MAX17042_FullCAP0, &full_cap0);
 642         regmap_read(map, MAX17042_VFSOC, &vfSoc);
 643
 644         /* fg_vfSoc needs to shifted by 8 bits to get the
 645          * perc in 1% accuracy, to get the right rem_cap multiply
 646          * full_cap0, fg_vfSoc and devide by 100
 647          */
 648         rem_cap = ((vfSoc >> 8) * full_cap0) / 100;
 649         max17042_write_verify_reg(map, MAX17042_RemCap, rem_cap);
 650
 651         rep_cap = rem_cap;
 652         max17042_write_verify_reg(map, MAX17042_RepCap, rep_cap);
 653
 654         /* Write dQ_acc to 200% of Capacity and dP_acc to 200% */
 655         dq_acc = config->fullcap / dQ_ACC_DIV;
 656         max17042_write_verify_reg(map, MAX17042_dQacc, dq_acc);
 657         max17042_write_verify_reg(map, MAX17042_dPacc, dP_ACC_200);
 658
 659         max17042_write_verify_reg(map, MAX17042_FullCAP,
 660                         config->fullcap);
 661         regmap_write(map, MAX17042_DesignCap,
 662                         config->design_cap);
 663         max17042_write_verify_reg(map, MAX17042_FullCAPNom,
 664                         config->fullcapnom);
 665         /* Update SOC register with new SOC */
 666         regmap_write(map, MAX17042_RepSOC, vfSoc);
 667 }
 668
 669 /*
 670  * Block write all the override values coming from platform data.
 671  * This function MUST be called before the POR initialization proceedure
 672  * specified by maxim.
 673  */
 674 static inline void max17042_override_por_values(struct max17042_chip *chip)
 675 {
 676         struct regmap *map = chip->regmap;
 677         struct max17042_config_data *config = chip->pdata->config_data;
 678
 679         max17042_override_por(map, MAX17042_TGAIN, config->tgain);
 680         max17042_override_por(map, MAx17042_TOFF, config->toff);
 681         max17042_override_por(map, MAX17042_CGAIN, config->cgain);
 682         max17042_override_por(map, MAX17042_COFF, config->coff);
 683
 684         max17042_override_por(map, MAX17042_VALRT_Th, config->valrt_thresh);
 685         max17042_override_por(map, MAX17042_TALRT_Th, config->talrt_thresh);
 686         max17042_override_por(map, MAX17042_SALRT_Th,
 687                                                 config->soc_alrt_thresh);
 688         max17042_override_por(map, MAX17042_CONFIG, config->config);
 689         max17042_override_por(map, MAX17042_SHDNTIMER, config->shdntimer);
 690
 691         max17042_override_por(map, MAX17042_DesignCap, config->design_cap);
 692         max17042_override_por(map, MAX17042_ICHGTerm, config->ichgt_term);
 693
 694         max17042_override_por(map, MAX17042_AtRate, config->at_rate);
 695         max17042_override_por(map, MAX17042_LearnCFG, config->learn_cfg);
 696         max17042_override_por(map, MAX17042_FilterCFG, config->filter_cfg);
 697         max17042_override_por(map, MAX17042_RelaxCFG, config->relax_cfg);
 698         max17042_override_por(map, MAX17042_MiscCFG, config->misc_cfg);
 699         max17042_override_por(map, MAX17042_MaskSOC, config->masksoc);
 700
 701         max17042_override_por(map, MAX17042_FullCAP, config->fullcap);
 702         max17042_override_por(map, MAX17042_FullCAPNom, config->fullcapnom);
 703         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
 704                 max17042_override_por(map, MAX17042_SOC_empty,
 705                                                 config->socempty);
 706         max17042_override_por(map, MAX17042_LAvg_empty, config->lavg_empty);
 707         max17042_override_por(map, MAX17042_dQacc, config->dqacc);
 708         max17042_override_por(map, MAX17042_dPacc, config->dpacc);
 709
 710         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
 711                 max17042_override_por(map, MAX17042_V_empty, config->vempty);
 712         else
 713                 max17042_override_por(map, MAX17047_V_empty, config->vempty);
 714         max17042_override_por(map, MAX17042_TempNom, config->temp_nom);
 715         max17042_override_por(map, MAX17042_TempLim, config->temp_lim);
 716         max17042_override_por(map, MAX17042_FCTC, config->fctc);
 717         max17042_override_por(map, MAX17042_RCOMP0, config->rcomp0);
 718         max17042_override_por(map, MAX17042_TempCo, config->tcompc0);
 719         if (chip->chip_type) {
 720                 max17042_override_por(map, MAX17042_EmptyTempCo,
 721                                                 config->empty_tempco);
 722                 max17042_override_por(map, MAX17042_K_empty0,
 723                                                 config->kempty0);
 724         }
 725 }
 726
 727 static int max17042_init_chip(struct max17042_chip *chip)
 728 {
 729         struct regmap *map = chip->regmap;
 730         int ret;
 731
 732         max17042_override_por_values(chip);
 733         /* After Power up, the MAX17042 requires 500mS in order
 734          * to perform signal debouncing and initial SOC reporting
 735          */
 736         msleep(500);
 737
 738         /* Initialize configaration */
 739         max17042_write_config_regs(chip);
 740
 741         /* write cell characterization data */
 742         ret = max17042_init_model(chip);
 743         if (ret) {
 744                 dev_err(&chip->client->dev, "%s init failed\n",
 745                         __func__);
 746                 return -EIO;
 747         }
 748
 749         ret = max17042_verify_model_lock(chip);
 750         if (ret) {
 751                 dev_err(&chip->client->dev, "%s lock verify failed\n",
 752                         __func__);
 753                 return -EIO;
 754         }
 755         /* write custom parameters */
 756         max17042_write_custom_regs(chip);
 757
 758         /* update capacity params */
 759         max17042_update_capacity_regs(chip);
 760
 761         /* delay must be atleast 350mS to allow VFSOC
 762          * to be calculated from the new configuration
 763          */
 764         msleep(350);
 765
 766         /* reset vfsoc0 reg */
 767         max17042_reset_vfsoc0_reg(chip);
 768
 769         /* load new capacity params */
 770         max17042_load_new_capacity_params(chip);
 771
 772         /* Init complete, Clear the POR bit */
 773         regmap_update_bits(map, MAX17042_STATUS, STATUS_POR_BIT, 0x0);
 774         return 0;
 775 }
 776
 777 static void max17042_set_soc_threshold(struct max17042_chip *chip, u16 off)
 778 {
 779         struct regmap *map = chip->regmap;
 780         u32 soc, soc_tr;
 781
 782         /* program interrupt thesholds such that we should
 783          * get interrupt for every 'off' perc change in the soc
 784          */
 785         regmap_read(map, MAX17042_RepSOC, &soc);
 786         soc >>= 8;
 787         soc_tr = (soc + off) << 8;
 788         soc_tr |= (soc - off);
 789         regmap_write(map, MAX17042_SALRT_Th, soc_tr);
 790 }
 791
 792 static irqreturn_t max17042_thread_handler(int id, void *dev)
 793 {
 794         struct max17042_chip *chip = dev;
 795         u32 val;
 796
 797         regmap_read(chip->regmap, MAX17042_STATUS, &val);
 798         if ((val & STATUS_INTR_SOCMIN_BIT) ||
 799                 (val & STATUS_INTR_SOCMAX_BIT)) {
 800                 dev_info(&chip->client->dev, "SOC threshold INTR\n");
 801                 max17042_set_soc_threshold(chip, 1);
 802         }
 803
 804         power_supply_changed(chip->battery);
 805         return IRQ_HANDLED;
 806 }
 807
 808 static void max17042_init_worker(struct work_struct *work)
 809 {
 810         struct max17042_chip *chip = container_of(work,
 811                                 struct max17042_chip, work);
 812         int ret;
 813
 814         /* Initialize registers according to values from the platform data */
 815         if (chip->pdata->enable_por_init && chip->pdata->config_data) {
 816                 ret = max17042_init_chip(chip);
 817                 if (ret)
 818                         return;
 819         }
 820
 821         chip->init_complete = 1;
 822 }
 823
 824 #ifdef CONFIG_OF
 825 static struct max17042_platform_data *
 826 max17042_get_pdata(struct max17042_chip *chip)
 827 {
 828         struct device *dev = &chip->client->dev;
 829         struct device_node *np = dev->of_node;
 830         u32 prop;
 831         struct max17042_platform_data *pdata;
 832
 833         if (!np)
 834                 return dev->platform_data;
 835
 836         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 837         if (!pdata)
 838                 return NULL;
 839
 840         /*
 841          * Require current sense resistor value to be specified for
 842          * current-sense functionality to be enabled at all.
 843          */
 844         if (of_property_read_u32(np, "maxim,rsns-microohm", &prop) == 0) {
 845                 pdata->r_sns = prop;
 846                 pdata->enable_current_sense = true;
 847         }
 848
 849         if (of_property_read_s32(np, "maxim,cold-temp", &pdata->temp_min))
 850                 pdata->temp_min = INT_MIN;
 851         if (of_property_read_s32(np, "maxim,over-heat-temp", &pdata->temp_max))
 852                 pdata->temp_max = INT_MAX;
 853         if (of_property_read_s32(np, "maxim,dead-volt", &pdata->vmin))
 854                 pdata->vmin = INT_MIN;
 855         if (of_property_read_s32(np, "maxim,over-volt", &pdata->vmax))
 856                 pdata->vmax = INT_MAX;
 857
 858         return pdata;
 859 }
 860 #else
 861 static struct max17042_reg_data max17047_default_pdata_init_regs[] = {
 862         /*
 863          * Some firmwares do not set FullSOCThr, Enable End-of-Charge Detection
 864          * when the voltage FG reports 95%, as recommended in the datasheet.
 865          */
 866         { MAX17047_FullSOCThr, MAX17042_BATTERY_FULL << 8 },
 867 };
 868
 869 static struct max17042_platform_data *
 870 max17042_get_pdata(struct max17042_chip *chip)
 871 {
 872         struct device *dev = &chip->client->dev;
 873         struct max17042_platform_data *pdata;
 874         int ret, misc_cfg;
 875
 876         if (dev->platform_data)
 877                 return dev->platform_data;
 878
 879         /*
 880          * The MAX17047 gets used on x86 where we might not have pdata, assume
 881          * the firmware will already have initialized the fuel-gauge and provide
 882          * default values for the non init bits to make things work.
 883          */
 884         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 885         if (!pdata)
 886                 return pdata;
 887
 888         if (chip->chip_type != MAXIM_DEVICE_TYPE_MAX17042) {
 889                 pdata->init_data = max17047_default_pdata_init_regs;
 890                 pdata->num_init_data =
 891                         ARRAY_SIZE(max17047_default_pdata_init_regs);
 892         }
 893
 894         ret = regmap_read(chip->regmap, MAX17042_MiscCFG, &misc_cfg);
 895         if (ret < 0)
 896                 return NULL;
 897
 898         /* If bits 0-1 are set to 3 then only Voltage readings are used */
 899         if ((misc_cfg & 0x3) == 0x3)
 900                 pdata->enable_current_sense = false;
 901         else
 902                 pdata->enable_current_sense = true;
 903
 904         pdata->vmin = MAX17042_DEFAULT_VMIN;
 905         pdata->vmax = MAX17042_DEFAULT_VMAX;
 906         pdata->temp_min = MAX17042_DEFAULT_TEMP_MIN;
 907         pdata->temp_max = MAX17042_DEFAULT_TEMP_MAX;
 908
 909         return pdata;
 910 }
 911 #endif
 912
 913 static const struct regmap_config max17042_regmap_config = {
 914         .reg_bits = 8,
 915         .val_bits = 16,
 916         .val_format_endian = REGMAP_ENDIAN_NATIVE,
 917 };
 918
 919 static const struct power_supply_desc max17042_psy_desc = {
 920         .name           = "max170xx_battery",
 921         .type           = POWER_SUPPLY_TYPE_BATTERY,
 922         .get_property   = max17042_get_property,
 923         .set_property   = max17042_set_property,
 924         .property_is_writeable  = max17042_property_is_writeable,
 925         .external_power_changed = max17042_external_power_changed,
 926         .properties     = max17042_battery_props,
 927         .num_properties = ARRAY_SIZE(max17042_battery_props),
 928 };
 929
 930 static const struct power_supply_desc max17042_no_current_sense_psy_desc = {
 931         .name           = "max170xx_battery",
 932         .type           = POWER_SUPPLY_TYPE_BATTERY,
 933         .get_property   = max17042_get_property,
 934         .set_property   = max17042_set_property,
 935         .property_is_writeable  = max17042_property_is_writeable,
 936         .properties     = max17042_battery_props,
 937         .num_properties = ARRAY_SIZE(max17042_battery_props) - 2,
 938 };
 939
 940 static int max17042_probe(struct i2c_client *client,
 941                         const struct i2c_device_id *id)
 942 {
 943         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
 944         const struct power_supply_desc *max17042_desc = &max17042_psy_desc;
 945         struct power_supply_config psy_cfg = {};
 946         struct max17042_chip *chip;
 947         int ret;
 948         int i;
 949         u32 val;
 950
 951         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
 952                 return -EIO;
 953
 954         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
 955         if (!chip)
 956                 return -ENOMEM;
 957
 958         chip->client = client;
 959         chip->chip_type = id->driver_data;
 960         chip->regmap = devm_regmap_init_i2c(client, &max17042_regmap_config);
 961         if (IS_ERR(chip->regmap)) {
 962                 dev_err(&client->dev, "Failed to initialize regmap\n");
 963                 return -EINVAL;
 964         }
 965
 966         chip->pdata = max17042_get_pdata(chip);
 967         if (!chip->pdata) {
 968                 dev_err(&client->dev, "no platform data provided\n");
 969                 return -EINVAL;
 970         }
 971
 972         i2c_set_clientdata(client, chip);
 973         psy_cfg.drv_data = chip;
 974
 975         /* When current is not measured,
 976          * CURRENT_NOW and CURRENT_AVG properties should be invisible. */
 977         if (!chip->pdata->enable_current_sense)
 978                 max17042_desc = &max17042_no_current_sense_psy_desc;
 979
 980         if (chip->pdata->r_sns == 0)
 981                 chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR;
 982
 983         if (chip->pdata->init_data)
 984                 for (i = 0; i < chip->pdata->num_init_data; i++)
 985                         regmap_write(chip->regmap,
 986                                         chip->pdata->init_data[i].addr,
 987                                         chip->pdata->init_data[i].data);
 988
 989         if (!chip->pdata->enable_current_sense) {
 990                 regmap_write(chip->regmap, MAX17042_CGAIN, 0x0000);
 991                 regmap_write(chip->regmap, MAX17042_MiscCFG, 0x0003);
 992                 regmap_write(chip->regmap, MAX17042_LearnCFG, 0x0007);
 993         }
 994
 995         chip->battery = devm_power_supply_register(&client->dev, max17042_desc,
 996                                                    &psy_cfg);
 997         if (IS_ERR(chip->battery)) {
 998                 dev_err(&client->dev, "failed: power supply register\n");
 999                 return PTR_ERR(chip->battery);
1000         }
1001
1002         if (client->irq) {
1003                 ret = devm_request_threaded_irq(&client->dev, client->irq,
1004                                                 NULL,
1005                                                 max17042_thread_handler,
1006                                                 IRQF_TRIGGER_FALLING |
1007                                                 IRQF_ONESHOT,
1008                                                 chip->battery->desc->name,
1009                                                 chip);
1010                 if (!ret) {
1011                         regmap_update_bits(chip->regmap, MAX17042_CONFIG,
1012                                         CONFIG_ALRT_BIT_ENBL,
1013                                         CONFIG_ALRT_BIT_ENBL);
1014                         max17042_set_soc_threshold(chip, 1);
1015                 } else {
1016                         client->irq = 0;
1017                         dev_err(&client->dev, "%s(): cannot get IRQ\n",
1018                                 __func__);
1019                 }
1020         }
1021
1022         regmap_read(chip->regmap, MAX17042_STATUS, &val);
1023         if (val & STATUS_POR_BIT) {
1024                 INIT_WORK(&chip->work, max17042_init_worker);
1025                 schedule_work(&chip->work);
1026         } else {
1027                 chip->init_complete = 1;
1028         }
1029
1030         return 0;
1031 }
1032
1033 #ifdef CONFIG_PM_SLEEP
1034 static int max17042_suspend(struct device *dev)
1035 {
1036         struct max17042_chip *chip = dev_get_drvdata(dev);
1037
1038         /*
1039          * disable the irq and enable irq_wake
1040          * capability to the interrupt line.
1041          */
1042         if (chip->client->irq) {
1043                 disable_irq(chip->client->irq);
1044                 enable_irq_wake(chip->client->irq);
1045         }
1046
1047         return 0;
1048 }
1049
1050 static int max17042_resume(struct device *dev)
1051 {
1052         struct max17042_chip *chip = dev_get_drvdata(dev);
1053
1054         if (chip->client->irq) {
1055                 disable_irq_wake(chip->client->irq);
1056                 enable_irq(chip->client->irq);
1057                 /* re-program the SOC thresholds to 1% change */
1058                 max17042_set_soc_threshold(chip, 1);
1059         }
1060
1061         return 0;
1062 }
1063 #endif
1064
1065 static SIMPLE_DEV_PM_OPS(max17042_pm_ops, max17042_suspend,
1066                         max17042_resume);
1067
1068 #ifdef CONFIG_OF
1069 static const struct of_device_id max17042_dt_match[] = {
1070         { .compatible = "maxim,max17042" },
1071         { .compatible = "maxim,max17047" },
1072         { .compatible = "maxim,max17050" },
1073         { },
1074 };
1075 MODULE_DEVICE_TABLE(of, max17042_dt_match);
1076 #endif
1077
1078 static const struct i2c_device_id max17042_id[] = {
1079         { "max17042", MAXIM_DEVICE_TYPE_MAX17042 },
1080         { "max17047", MAXIM_DEVICE_TYPE_MAX17047 },
1081         { "max17050", MAXIM_DEVICE_TYPE_MAX17050 },
1082         { }
1083 };
1084 MODULE_DEVICE_TABLE(i2c, max17042_id);
1085
1086 static struct i2c_driver max17042_i2c_driver = {
1087         .driver = {
1088                 .name   = "max17042",
1089                 .of_match_table = of_match_ptr(max17042_dt_match),
1090                 .pm     = &max17042_pm_ops,
1091         },
1092         .probe          = max17042_probe,
1093         .id_table       = max17042_id,
1094 };
1095 module_i2c_driver(max17042_i2c_driver);
1096
1097 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
1098 MODULE_DESCRIPTION("MAX17042 Fuel Gauge");
1099 MODULE_LICENSE("GPL");