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