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