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