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_IC_VERSION 0x0092 67#define MAX17047_IC_VERSION 0x00AC /* same for max17050 */ 68 69struct max17042_chip { 70 struct i2c_client *client; 71 struct regmap *regmap; 72 struct power_supply battery; 73 enum max170xx_chip_type chip_type; 74 struct max17042_platform_data *pdata; 75 struct work_struct work; 76 int init_complete; 77}; 78 79static enum power_supply_property max17042_battery_props[] = { 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_CURRENT_NOW, 92 POWER_SUPPLY_PROP_CURRENT_AVG, 93}; 94 95static int max17042_get_property(struct power_supply *psy, 96 enum power_supply_property psp, 97 union power_supply_propval *val) 98{ 99 struct max17042_chip *chip = container_of(psy, 100 struct max17042_chip, battery); 101 struct regmap *map = chip->regmap; 102 int ret; 103 u32 data; 104 105 if (!chip->init_complete) 106 return -EAGAIN; 107 108 switch (psp) { 109 case POWER_SUPPLY_PROP_PRESENT: 110 ret = regmap_read(map, MAX17042_STATUS, &data); 111 if (ret < 0) 112 return ret; 113 114 if (data & MAX17042_STATUS_BattAbsent) 115 val->intval = 0; 116 else 117 val->intval = 1; 118 break; 119 case POWER_SUPPLY_PROP_CYCLE_COUNT: 120 ret = regmap_read(map, MAX17042_Cycles, &data); 121 if (ret < 0) 122 return ret; 123 124 val->intval = data; 125 break; 126 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 127 ret = regmap_read(map, MAX17042_MinMaxVolt, &data); 128 if (ret < 0) 129 return ret; 130 131 val->intval = data >> 8; 132 val->intval *= 20000; /* Units of LSB = 20mV */ 133 break; 134 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 135 if (chip->chip_type == MAX17042) 136 ret = regmap_read(map, MAX17042_V_empty, &data); 137 else 138 ret = regmap_read(map, MAX17047_V_empty, &data); 139 if (ret < 0) 140 return ret; 141 142 val->intval = data >> 7; 143 val->intval *= 10000; /* Units of LSB = 10mV */ 144 break; 145 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 146 ret = regmap_read(map, MAX17042_VCELL, &data); 147 if (ret < 0) 148 return ret; 149 150 val->intval = data * 625 / 8; 151 break; 152 case POWER_SUPPLY_PROP_VOLTAGE_AVG: 153 ret = regmap_read(map, MAX17042_AvgVCELL, &data); 154 if (ret < 0) 155 return ret; 156 157 val->intval = data * 625 / 8; 158 break; 159 case POWER_SUPPLY_PROP_VOLTAGE_OCV: 160 ret = regmap_read(map, MAX17042_OCVInternal, &data); 161 if (ret < 0) 162 return ret; 163 164 val->intval = data * 625 / 8; 165 break; 166 case POWER_SUPPLY_PROP_CAPACITY: 167 ret = regmap_read(map, MAX17042_RepSOC, &data); 168 if (ret < 0) 169 return ret; 170 171 val->intval = data >> 8; 172 break; 173 case POWER_SUPPLY_PROP_CHARGE_FULL: 174 ret = regmap_read(map, MAX17042_FullCAP, &data); 175 if (ret < 0) 176 return ret; 177 178 val->intval = data * 1000 / 2; 179 break; 180 case POWER_SUPPLY_PROP_CHARGE_COUNTER: 181 ret = regmap_read(map, MAX17042_QH, &data); 182 if (ret < 0) 183 return ret; 184 185 val->intval = data * 1000 / 2; 186 break; 187 case POWER_SUPPLY_PROP_TEMP: 188 ret = regmap_read(map, MAX17042_TEMP, &data); 189 if (ret < 0) 190 return ret; 191 192 val->intval = data; 193 /* The value is signed. */ 194 if (val->intval & 0x8000) { 195 val->intval = (0x7fff & ~val->intval) + 1; 196 val->intval *= -1; 197 } 198 /* The value is converted into deci-centigrade scale */ 199 /* Units of LSB = 1 / 256 degree Celsius */ 200 val->intval = val->intval * 10 / 256; 201 break; 202 case POWER_SUPPLY_PROP_CURRENT_NOW: 203 if (chip->pdata->enable_current_sense) { 204 ret = regmap_read(map, MAX17042_Current, &data); 205 if (ret < 0) 206 return ret; 207 208 val->intval = data; 209 if (val->intval & 0x8000) { 210 /* Negative */ 211 val->intval = ~val->intval & 0x7fff; 212 val->intval++; 213 val->intval *= -1; 214 } 215 val->intval *= 1562500 / chip->pdata->r_sns; 216 } else { 217 return -EINVAL; 218 } 219 break; 220 case POWER_SUPPLY_PROP_CURRENT_AVG: 221 if (chip->pdata->enable_current_sense) { 222 ret = regmap_read(map, MAX17042_AvgCurrent, &data); 223 if (ret < 0) 224 return ret; 225 226 val->intval = data; 227 if (val->intval & 0x8000) { 228 /* Negative */ 229 val->intval = ~val->intval & 0x7fff; 230 val->intval++; 231 val->intval *= -1; 232 } 233 val->intval *= 1562500 / chip->pdata->r_sns; 234 } else { 235 return -EINVAL; 236 } 237 break; 238 default: 239 return -EINVAL; 240 } 241 return 0; 242} 243 244static int max17042_write_verify_reg(struct regmap *map, u8 reg, u32 value) 245{ 246 int retries = 8; 247 int ret; 248 u32 read_value; 249 250 do { 251 ret = regmap_write(map, reg, value); 252 regmap_read(map, reg, &read_value); 253 if (read_value != value) { 254 ret = -EIO; 255 retries--; 256 } 257 } while (retries && read_value != value); 258 259 if (ret < 0) 260 pr_err("%s: err %d\n", __func__, ret); 261 262 return ret; 263} 264 265static inline void max17042_override_por(struct regmap *map, 266 u8 reg, u16 value) 267{ 268 if (value) 269 regmap_write(map, reg, value); 270} 271 272static inline void max10742_unlock_model(struct max17042_chip *chip) 273{ 274 struct regmap *map = chip->regmap; 275 regmap_write(map, MAX17042_MLOCKReg1, MODEL_UNLOCK1); 276 regmap_write(map, MAX17042_MLOCKReg2, MODEL_UNLOCK2); 277} 278 279static inline void max10742_lock_model(struct max17042_chip *chip) 280{ 281 struct regmap *map = chip->regmap; 282 283 regmap_write(map, MAX17042_MLOCKReg1, MODEL_LOCK1); 284 regmap_write(map, MAX17042_MLOCKReg2, MODEL_LOCK2); 285} 286 287static inline void max17042_write_model_data(struct max17042_chip *chip, 288 u8 addr, int size) 289{ 290 struct regmap *map = chip->regmap; 291 int i; 292 for (i = 0; i < size; i++) 293 regmap_write(map, addr + i, 294 chip->pdata->config_data->cell_char_tbl[i]); 295} 296 297static inline void max17042_read_model_data(struct max17042_chip *chip, 298 u8 addr, u32 *data, int size) 299{ 300 struct regmap *map = chip->regmap; 301 int i; 302 303 for (i = 0; i < size; i++) 304 regmap_read(map, addr + i, &data[i]); 305} 306 307static inline int max17042_model_data_compare(struct max17042_chip *chip, 308 u16 *data1, u16 *data2, int size) 309{ 310 int i; 311 312 if (memcmp(data1, data2, size)) { 313 dev_err(&chip->client->dev, "%s compare failed\n", __func__); 314 for (i = 0; i < size; i++) 315 dev_info(&chip->client->dev, "0x%x, 0x%x", 316 data1[i], data2[i]); 317 dev_info(&chip->client->dev, "\n"); 318 return -EINVAL; 319 } 320 return 0; 321} 322 323static int max17042_init_model(struct max17042_chip *chip) 324{ 325 int ret; 326 int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl); 327 u32 *temp_data; 328 329 temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL); 330 if (!temp_data) 331 return -ENOMEM; 332 333 max10742_unlock_model(chip); 334 max17042_write_model_data(chip, MAX17042_MODELChrTbl, 335 table_size); 336 max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data, 337 table_size); 338 339 ret = max17042_model_data_compare( 340 chip, 341 chip->pdata->config_data->cell_char_tbl, 342 (u16 *)temp_data, 343 table_size); 344 345 max10742_lock_model(chip); 346 kfree(temp_data); 347 348 return ret; 349} 350 351static int max17042_verify_model_lock(struct max17042_chip *chip) 352{ 353 int i; 354 int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl); 355 u32 *temp_data; 356 int ret = 0; 357 358 temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL); 359 if (!temp_data) 360 return -ENOMEM; 361 362 max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data, 363 table_size); 364 for (i = 0; i < table_size; i++) 365 if (temp_data[i]) 366 ret = -EINVAL; 367 368 kfree(temp_data); 369 return ret; 370} 371 372static void max17042_write_config_regs(struct max17042_chip *chip) 373{ 374 struct max17042_config_data *config = chip->pdata->config_data; 375 struct regmap *map = chip->regmap; 376 377 regmap_write(map, MAX17042_CONFIG, config->config); 378 regmap_write(map, MAX17042_LearnCFG, config->learn_cfg); 379 regmap_write(map, MAX17042_FilterCFG, 380 config->filter_cfg); 381 regmap_write(map, MAX17042_RelaxCFG, config->relax_cfg); 382 if (chip->chip_type == MAX17047) 383 regmap_write(map, MAX17047_FullSOCThr, 384 config->full_soc_thresh); 385} 386 387static void max17042_write_custom_regs(struct max17042_chip *chip) 388{ 389 struct max17042_config_data *config = chip->pdata->config_data; 390 struct regmap *map = chip->regmap; 391 392 max17042_write_verify_reg(map, MAX17042_RCOMP0, config->rcomp0); 393 max17042_write_verify_reg(map, MAX17042_TempCo, config->tcompc0); 394 max17042_write_verify_reg(map, MAX17042_ICHGTerm, config->ichgt_term); 395 if (chip->chip_type == MAX17042) { 396 regmap_write(map, MAX17042_EmptyTempCo, config->empty_tempco); 397 max17042_write_verify_reg(map, MAX17042_K_empty0, 398 config->kempty0); 399 } else { 400 max17042_write_verify_reg(map, MAX17047_QRTbl00, 401 config->qrtbl00); 402 max17042_write_verify_reg(map, MAX17047_QRTbl10, 403 config->qrtbl10); 404 max17042_write_verify_reg(map, MAX17047_QRTbl20, 405 config->qrtbl20); 406 max17042_write_verify_reg(map, MAX17047_QRTbl30, 407 config->qrtbl30); 408 } 409} 410 411static void max17042_update_capacity_regs(struct max17042_chip *chip) 412{ 413 struct max17042_config_data *config = chip->pdata->config_data; 414 struct regmap *map = chip->regmap; 415 416 max17042_write_verify_reg(map, MAX17042_FullCAP, 417 config->fullcap); 418 regmap_write(map, MAX17042_DesignCap, config->design_cap); 419 max17042_write_verify_reg(map, MAX17042_FullCAPNom, 420 config->fullcapnom); 421} 422 423static void max17042_reset_vfsoc0_reg(struct max17042_chip *chip) 424{ 425 unsigned int vfSoc; 426 struct regmap *map = chip->regmap; 427 428 regmap_read(map, MAX17042_VFSOC, &vfSoc); 429 regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_UNLOCK); 430 max17042_write_verify_reg(map, MAX17042_VFSOC0, vfSoc); 431 regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_LOCK); 432} 433 434static void max17042_load_new_capacity_params(struct max17042_chip *chip) 435{ 436 u32 full_cap0, rep_cap, dq_acc, vfSoc; 437 u32 rem_cap; 438 439 struct max17042_config_data *config = chip->pdata->config_data; 440 struct regmap *map = chip->regmap; 441 442 regmap_read(map, MAX17042_FullCAP0, &full_cap0); 443 regmap_read(map, MAX17042_VFSOC, &vfSoc); 444 445 /* fg_vfSoc needs to shifted by 8 bits to get the 446 * perc in 1% accuracy, to get the right rem_cap multiply 447 * full_cap0, fg_vfSoc and devide by 100 448 */ 449 rem_cap = ((vfSoc >> 8) * full_cap0) / 100; 450 max17042_write_verify_reg(map, MAX17042_RemCap, rem_cap); 451 452 rep_cap = rem_cap; 453 max17042_write_verify_reg(map, MAX17042_RepCap, rep_cap); 454 455 /* Write dQ_acc to 200% of Capacity and dP_acc to 200% */ 456 dq_acc = config->fullcap / dQ_ACC_DIV; 457 max17042_write_verify_reg(map, MAX17042_dQacc, dq_acc); 458 max17042_write_verify_reg(map, MAX17042_dPacc, dP_ACC_200); 459 460 max17042_write_verify_reg(map, MAX17042_FullCAP, 461 config->fullcap); 462 regmap_write(map, MAX17042_DesignCap, 463 config->design_cap); 464 max17042_write_verify_reg(map, MAX17042_FullCAPNom, 465 config->fullcapnom); 466 /* Update SOC register with new SOC */ 467 regmap_write(map, MAX17042_RepSOC, vfSoc); 468} 469 470/* 471 * Block write all the override values coming from platform data. 472 * This function MUST be called before the POR initialization proceedure 473 * specified by maxim. 474 */ 475static inline void max17042_override_por_values(struct max17042_chip *chip) 476{ 477 struct regmap *map = chip->regmap; 478 struct max17042_config_data *config = chip->pdata->config_data; 479 480 max17042_override_por(map, MAX17042_TGAIN, config->tgain); 481 max17042_override_por(map, MAx17042_TOFF, config->toff); 482 max17042_override_por(map, MAX17042_CGAIN, config->cgain); 483 max17042_override_por(map, MAX17042_COFF, config->coff); 484 485 max17042_override_por(map, MAX17042_VALRT_Th, config->valrt_thresh); 486 max17042_override_por(map, MAX17042_TALRT_Th, config->talrt_thresh); 487 max17042_override_por(map, MAX17042_SALRT_Th, 488 config->soc_alrt_thresh); 489 max17042_override_por(map, MAX17042_CONFIG, config->config); 490 max17042_override_por(map, MAX17042_SHDNTIMER, config->shdntimer); 491 492 max17042_override_por(map, MAX17042_DesignCap, config->design_cap); 493 max17042_override_por(map, MAX17042_ICHGTerm, config->ichgt_term); 494 495 max17042_override_por(map, MAX17042_AtRate, config->at_rate); 496 max17042_override_por(map, MAX17042_LearnCFG, config->learn_cfg); 497 max17042_override_por(map, MAX17042_FilterCFG, config->filter_cfg); 498 max17042_override_por(map, MAX17042_RelaxCFG, config->relax_cfg); 499 max17042_override_por(map, MAX17042_MiscCFG, config->misc_cfg); 500 max17042_override_por(map, MAX17042_MaskSOC, config->masksoc); 501 502 max17042_override_por(map, MAX17042_FullCAP, config->fullcap); 503 max17042_override_por(map, MAX17042_FullCAPNom, config->fullcapnom); 504 if (chip->chip_type == MAX17042) 505 max17042_override_por(map, MAX17042_SOC_empty, 506 config->socempty); 507 max17042_override_por(map, MAX17042_LAvg_empty, config->lavg_empty); 508 max17042_override_por(map, MAX17042_dQacc, config->dqacc); 509 max17042_override_por(map, MAX17042_dPacc, config->dpacc); 510 511 if (chip->chip_type == MAX17042) 512 max17042_override_por(map, MAX17042_V_empty, config->vempty); 513 else 514 max17042_override_por(map, MAX17047_V_empty, config->vempty); 515 max17042_override_por(map, MAX17042_TempNom, config->temp_nom); 516 max17042_override_por(map, MAX17042_TempLim, config->temp_lim); 517 max17042_override_por(map, MAX17042_FCTC, config->fctc); 518 max17042_override_por(map, MAX17042_RCOMP0, config->rcomp0); 519 max17042_override_por(map, MAX17042_TempCo, config->tcompc0); 520 if (chip->chip_type) { 521 max17042_override_por(map, MAX17042_EmptyTempCo, 522 config->empty_tempco); 523 max17042_override_por(map, MAX17042_K_empty0, 524 config->kempty0); 525 } 526} 527 528static int max17042_init_chip(struct max17042_chip *chip) 529{ 530 struct regmap *map = chip->regmap; 531 int ret; 532 int val; 533 534 max17042_override_por_values(chip); 535 /* After Power up, the MAX17042 requires 500mS in order 536 * to perform signal debouncing and initial SOC reporting 537 */ 538 msleep(500); 539 540 /* Initialize configaration */ 541 max17042_write_config_regs(chip); 542 543 /* write cell characterization data */ 544 ret = max17042_init_model(chip); 545 if (ret) { 546 dev_err(&chip->client->dev, "%s init failed\n", 547 __func__); 548 return -EIO; 549 } 550 551 ret = max17042_verify_model_lock(chip); 552 if (ret) { 553 dev_err(&chip->client->dev, "%s lock verify failed\n", 554 __func__); 555 return -EIO; 556 } 557 /* write custom parameters */ 558 max17042_write_custom_regs(chip); 559 560 /* update capacity params */ 561 max17042_update_capacity_regs(chip); 562 563 /* delay must be atleast 350mS to allow VFSOC 564 * to be calculated from the new configuration 565 */ 566 msleep(350); 567 568 /* reset vfsoc0 reg */ 569 max17042_reset_vfsoc0_reg(chip); 570 571 /* load new capacity params */ 572 max17042_load_new_capacity_params(chip); 573 574 /* Init complete, Clear the POR bit */ 575 regmap_read(map, MAX17042_STATUS, &val); 576 regmap_write(map, MAX17042_STATUS, val & (~STATUS_POR_BIT)); 577 return 0; 578} 579 580static void max17042_set_soc_threshold(struct max17042_chip *chip, u16 off) 581{ 582 struct regmap *map = chip->regmap; 583 u32 soc, soc_tr; 584 585 /* program interrupt thesholds such that we should 586 * get interrupt for every 'off' perc change in the soc 587 */ 588 regmap_read(map, MAX17042_RepSOC, &soc); 589 soc >>= 8; 590 soc_tr = (soc + off) << 8; 591 soc_tr |= (soc - off); 592 regmap_write(map, MAX17042_SALRT_Th, soc_tr); 593} 594 595static irqreturn_t max17042_thread_handler(int id, void *dev) 596{ 597 struct max17042_chip *chip = dev; 598 u32 val; 599 600 regmap_read(chip->regmap, MAX17042_STATUS, &val); 601 if ((val & STATUS_INTR_SOCMIN_BIT) || 602 (val & STATUS_INTR_SOCMAX_BIT)) { 603 dev_info(&chip->client->dev, "SOC threshold INTR\n"); 604 max17042_set_soc_threshold(chip, 1); 605 } 606 607 power_supply_changed(&chip->battery); 608 return IRQ_HANDLED; 609} 610 611static void max17042_init_worker(struct work_struct *work) 612{ 613 struct max17042_chip *chip = container_of(work, 614 struct max17042_chip, work); 615 int ret; 616 617 /* Initialize registers according to values from the platform data */ 618 if (chip->pdata->enable_por_init && chip->pdata->config_data) { 619 ret = max17042_init_chip(chip); 620 if (ret) 621 return; 622 } 623 624 chip->init_complete = 1; 625} 626 627#ifdef CONFIG_OF 628static struct max17042_platform_data * 629max17042_get_pdata(struct device *dev) 630{ 631 struct device_node *np = dev->of_node; 632 u32 prop; 633 struct max17042_platform_data *pdata; 634 635 if (!np) 636 return dev->platform_data; 637 638 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 639 if (!pdata) 640 return NULL; 641 642 /* 643 * Require current sense resistor value to be specified for 644 * current-sense functionality to be enabled at all. 645 */ 646 if (of_property_read_u32(np, "maxim,rsns-microohm", &prop) == 0) { 647 pdata->r_sns = prop; 648 pdata->enable_current_sense = true; 649 } 650 651 return pdata; 652} 653#else 654static struct max17042_platform_data * 655max17042_get_pdata(struct device *dev) 656{ 657 return dev->platform_data; 658} 659#endif 660 661static struct regmap_config max17042_regmap_config = { 662 .reg_bits = 8, 663 .val_bits = 16, 664 .val_format_endian = REGMAP_ENDIAN_NATIVE, 665}; 666 667static int max17042_probe(struct i2c_client *client, 668 const struct i2c_device_id *id) 669{ 670 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); 671 struct max17042_chip *chip; 672 int ret; 673 int i; 674 u32 val; 675 676 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) 677 return -EIO; 678 679 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); 680 if (!chip) 681 return -ENOMEM; 682 683 chip->client = client; 684 chip->regmap = devm_regmap_init_i2c(client, &max17042_regmap_config); 685 if (IS_ERR(chip->regmap)) { 686 dev_err(&client->dev, "Failed to initialize regmap\n"); 687 return -EINVAL; 688 } 689 690 chip->pdata = max17042_get_pdata(&client->dev); 691 if (!chip->pdata) { 692 dev_err(&client->dev, "no platform data provided\n"); 693 return -EINVAL; 694 } 695 696 i2c_set_clientdata(client, chip); 697 698 regmap_read(chip->regmap, MAX17042_DevName, &val); 699 if (val == MAX17042_IC_VERSION) { 700 dev_dbg(&client->dev, "chip type max17042 detected\n"); 701 chip->chip_type = MAX17042; 702 } else if (val == MAX17047_IC_VERSION) { 703 dev_dbg(&client->dev, "chip type max17047/50 detected\n"); 704 chip->chip_type = MAX17047; 705 } else { 706 dev_err(&client->dev, "device version mismatch: %x\n", val); 707 return -EIO; 708 } 709 710 chip->battery.name = "max170xx_battery"; 711 chip->battery.type = POWER_SUPPLY_TYPE_BATTERY; 712 chip->battery.get_property = max17042_get_property; 713 chip->battery.properties = max17042_battery_props; 714 chip->battery.num_properties = ARRAY_SIZE(max17042_battery_props); 715 716 /* When current is not measured, 717 * CURRENT_NOW and CURRENT_AVG properties should be invisible. */ 718 if (!chip->pdata->enable_current_sense) 719 chip->battery.num_properties -= 2; 720 721 if (chip->pdata->r_sns == 0) 722 chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR; 723 724 if (chip->pdata->init_data) 725 for (i = 0; i < chip->pdata->num_init_data; i++) 726 regmap_write(chip->regmap, 727 chip->pdata->init_data[i].addr, 728 chip->pdata->init_data[i].data); 729 730 if (!chip->pdata->enable_current_sense) { 731 regmap_write(chip->regmap, MAX17042_CGAIN, 0x0000); 732 regmap_write(chip->regmap, MAX17042_MiscCFG, 0x0003); 733 regmap_write(chip->regmap, MAX17042_LearnCFG, 0x0007); 734 } 735 736 ret = power_supply_register(&client->dev, &chip->battery); 737 if (ret) { 738 dev_err(&client->dev, "failed: power supply register\n"); 739 return ret; 740 } 741 742 if (client->irq) { 743 ret = request_threaded_irq(client->irq, NULL, 744 max17042_thread_handler, 745 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 746 chip->battery.name, chip); 747 if (!ret) { 748 regmap_read(chip->regmap, MAX17042_CONFIG, &val); 749 val |= CONFIG_ALRT_BIT_ENBL; 750 regmap_write(chip->regmap, MAX17042_CONFIG, val); 751 max17042_set_soc_threshold(chip, 1); 752 } else { 753 client->irq = 0; 754 dev_err(&client->dev, "%s(): cannot get IRQ\n", 755 __func__); 756 } 757 } 758 759 regmap_read(chip->regmap, MAX17042_STATUS, &val); 760 if (val & STATUS_POR_BIT) { 761 INIT_WORK(&chip->work, max17042_init_worker); 762 schedule_work(&chip->work); 763 } else { 764 chip->init_complete = 1; 765 } 766 767 return 0; 768} 769 770static int max17042_remove(struct i2c_client *client) 771{ 772 struct max17042_chip *chip = i2c_get_clientdata(client); 773 774 if (client->irq) 775 free_irq(client->irq, chip); 776 power_supply_unregister(&chip->battery); 777 return 0; 778} 779 780#ifdef CONFIG_PM_SLEEP 781static int max17042_suspend(struct device *dev) 782{ 783 struct max17042_chip *chip = dev_get_drvdata(dev); 784 785 /* 786 * disable the irq and enable irq_wake 787 * capability to the interrupt line. 788 */ 789 if (chip->client->irq) { 790 disable_irq(chip->client->irq); 791 enable_irq_wake(chip->client->irq); 792 } 793 794 return 0; 795} 796 797static int max17042_resume(struct device *dev) 798{ 799 struct max17042_chip *chip = dev_get_drvdata(dev); 800 801 if (chip->client->irq) { 802 disable_irq_wake(chip->client->irq); 803 enable_irq(chip->client->irq); 804 /* re-program the SOC thresholds to 1% change */ 805 max17042_set_soc_threshold(chip, 1); 806 } 807 808 return 0; 809} 810#endif 811 812static SIMPLE_DEV_PM_OPS(max17042_pm_ops, max17042_suspend, 813 max17042_resume); 814 815#ifdef CONFIG_OF 816static const struct of_device_id max17042_dt_match[] = { 817 { .compatible = "maxim,max17042" }, 818 { .compatible = "maxim,max17047" }, 819 { .compatible = "maxim,max17050" }, 820 { }, 821}; 822MODULE_DEVICE_TABLE(of, max17042_dt_match); 823#endif 824 825static const struct i2c_device_id max17042_id[] = { 826 { "max17042", 0 }, 827 { "max17047", 1 }, 828 { "max17050", 2 }, 829 { } 830}; 831MODULE_DEVICE_TABLE(i2c, max17042_id); 832 833static struct i2c_driver max17042_i2c_driver = { 834 .driver = { 835 .name = "max17042", 836 .of_match_table = of_match_ptr(max17042_dt_match), 837 .pm = &max17042_pm_ops, 838 }, 839 .probe = max17042_probe, 840 .remove = max17042_remove, 841 .id_table = max17042_id, 842}; 843module_i2c_driver(max17042_i2c_driver); 844 845MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>"); 846MODULE_DESCRIPTION("MAX17042 Fuel Gauge"); 847MODULE_LICENSE("GPL"); 848