1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (C) 2018 Spreadtrum Communications Inc. 3 4 #include <linux/gpio/consumer.h> 5 #include <linux/iio/consumer.h> 6 #include <linux/interrupt.h> 7 #include <linux/kernel.h> 8 #include <linux/module.h> 9 #include <linux/nvmem-consumer.h> 10 #include <linux/of.h> 11 #include <linux/platform_device.h> 12 #include <linux/power_supply.h> 13 #include <linux/regmap.h> 14 #include <linux/slab.h> 15 16 /* PMIC global control registers definition */ 17 #define SC27XX_MODULE_EN0 0xc08 18 #define SC27XX_CLK_EN0 0xc18 19 #define SC27XX_FGU_EN BIT(7) 20 #define SC27XX_FGU_RTC_EN BIT(6) 21 22 /* FGU registers definition */ 23 #define SC27XX_FGU_START 0x0 24 #define SC27XX_FGU_CONFIG 0x4 25 #define SC27XX_FGU_ADC_CONFIG 0x8 26 #define SC27XX_FGU_STATUS 0xc 27 #define SC27XX_FGU_INT_EN 0x10 28 #define SC27XX_FGU_INT_CLR 0x14 29 #define SC27XX_FGU_INT_STS 0x1c 30 #define SC27XX_FGU_VOLTAGE 0x20 31 #define SC27XX_FGU_OCV 0x24 32 #define SC27XX_FGU_POCV 0x28 33 #define SC27XX_FGU_CURRENT 0x2c 34 #define SC27XX_FGU_LOW_OVERLOAD 0x34 35 #define SC27XX_FGU_CLBCNT_SETH 0x50 36 #define SC27XX_FGU_CLBCNT_SETL 0x54 37 #define SC27XX_FGU_CLBCNT_DELTH 0x58 38 #define SC27XX_FGU_CLBCNT_DELTL 0x5c 39 #define SC27XX_FGU_CLBCNT_VALH 0x68 40 #define SC27XX_FGU_CLBCNT_VALL 0x6c 41 #define SC27XX_FGU_CLBCNT_QMAXL 0x74 42 #define SC27XX_FGU_USER_AREA_SET 0xa0 43 #define SC27XX_FGU_USER_AREA_CLEAR 0xa4 44 #define SC27XX_FGU_USER_AREA_STATUS 0xa8 45 46 #define SC27XX_WRITE_SELCLB_EN BIT(0) 47 #define SC27XX_FGU_CLBCNT_MASK GENMASK(15, 0) 48 #define SC27XX_FGU_CLBCNT_SHIFT 16 49 #define SC27XX_FGU_LOW_OVERLOAD_MASK GENMASK(12, 0) 50 51 #define SC27XX_FGU_INT_MASK GENMASK(9, 0) 52 #define SC27XX_FGU_LOW_OVERLOAD_INT BIT(0) 53 #define SC27XX_FGU_CLBCNT_DELTA_INT BIT(2) 54 55 #define SC27XX_FGU_MODE_AREA_MASK GENMASK(15, 12) 56 #define SC27XX_FGU_CAP_AREA_MASK GENMASK(11, 0) 57 #define SC27XX_FGU_MODE_AREA_SHIFT 12 58 59 #define SC27XX_FGU_FIRST_POWERTON GENMASK(3, 0) 60 #define SC27XX_FGU_DEFAULT_CAP GENMASK(11, 0) 61 #define SC27XX_FGU_NORMAIL_POWERTON 0x5 62 63 #define SC27XX_FGU_CUR_BASIC_ADC 8192 64 #define SC27XX_FGU_SAMPLE_HZ 2 65 /* micro Ohms */ 66 #define SC27XX_FGU_IDEAL_RESISTANCE 20000 67 68 /* 69 * struct sc27xx_fgu_data: describe the FGU device 70 * @regmap: regmap for register access 71 * @dev: platform device 72 * @battery: battery power supply 73 * @base: the base offset for the controller 74 * @lock: protect the structure 75 * @gpiod: GPIO for battery detection 76 * @channel: IIO channel to get battery temperature 77 * @charge_chan: IIO channel to get charge voltage 78 * @internal_resist: the battery internal resistance in mOhm 79 * @total_cap: the total capacity of the battery in mAh 80 * @init_cap: the initial capacity of the battery in mAh 81 * @alarm_cap: the alarm capacity 82 * @init_clbcnt: the initial coulomb counter 83 * @max_volt: the maximum constant input voltage in millivolt 84 * @min_volt: the minimum drained battery voltage in microvolt 85 * @table_len: the capacity table length 86 * @resist_table_len: the resistance table length 87 * @cur_1000ma_adc: ADC value corresponding to 1000 mA 88 * @vol_1000mv_adc: ADC value corresponding to 1000 mV 89 * @calib_resist: the real resistance of coulomb counter chip in uOhm 90 * @cap_table: capacity table with corresponding ocv 91 * @resist_table: resistance percent table with corresponding temperature 92 */ 93 struct sc27xx_fgu_data { 94 struct regmap *regmap; 95 struct device *dev; 96 struct power_supply *battery; 97 u32 base; 98 struct mutex lock; 99 struct gpio_desc *gpiod; 100 struct iio_channel *channel; 101 struct iio_channel *charge_chan; 102 bool bat_present; 103 int internal_resist; 104 int total_cap; 105 int init_cap; 106 int alarm_cap; 107 int init_clbcnt; 108 int max_volt; 109 int min_volt; 110 int table_len; 111 int resist_table_len; 112 int cur_1000ma_adc; 113 int vol_1000mv_adc; 114 int calib_resist; 115 struct power_supply_battery_ocv_table *cap_table; 116 struct power_supply_resistance_temp_table *resist_table; 117 }; 118 119 static int sc27xx_fgu_cap_to_clbcnt(struct sc27xx_fgu_data *data, int capacity); 120 static void sc27xx_fgu_capacity_calibration(struct sc27xx_fgu_data *data, 121 int cap, bool int_mode); 122 static void sc27xx_fgu_adjust_cap(struct sc27xx_fgu_data *data, int cap); 123 static int sc27xx_fgu_get_temp(struct sc27xx_fgu_data *data, int *temp); 124 125 static const char * const sc27xx_charger_supply_name[] = { 126 "sc2731_charger", 127 "sc2720_charger", 128 "sc2721_charger", 129 "sc2723_charger", 130 }; 131 132 static int sc27xx_fgu_adc_to_current(struct sc27xx_fgu_data *data, int adc) 133 { 134 return DIV_ROUND_CLOSEST(adc * 1000, data->cur_1000ma_adc); 135 } 136 137 static int sc27xx_fgu_adc_to_voltage(struct sc27xx_fgu_data *data, int adc) 138 { 139 return DIV_ROUND_CLOSEST(adc * 1000, data->vol_1000mv_adc); 140 } 141 142 static int sc27xx_fgu_voltage_to_adc(struct sc27xx_fgu_data *data, int vol) 143 { 144 return DIV_ROUND_CLOSEST(vol * data->vol_1000mv_adc, 1000); 145 } 146 147 static bool sc27xx_fgu_is_first_poweron(struct sc27xx_fgu_data *data) 148 { 149 int ret, status, cap, mode; 150 151 ret = regmap_read(data->regmap, 152 data->base + SC27XX_FGU_USER_AREA_STATUS, &status); 153 if (ret) 154 return false; 155 156 /* 157 * We use low 4 bits to save the last battery capacity and high 12 bits 158 * to save the system boot mode. 159 */ 160 mode = (status & SC27XX_FGU_MODE_AREA_MASK) >> SC27XX_FGU_MODE_AREA_SHIFT; 161 cap = status & SC27XX_FGU_CAP_AREA_MASK; 162 163 /* 164 * When FGU has been powered down, the user area registers became 165 * default value (0xffff), which can be used to valid if the system is 166 * first power on or not. 167 */ 168 if (mode == SC27XX_FGU_FIRST_POWERTON || cap == SC27XX_FGU_DEFAULT_CAP) 169 return true; 170 171 return false; 172 } 173 174 static int sc27xx_fgu_save_boot_mode(struct sc27xx_fgu_data *data, 175 int boot_mode) 176 { 177 int ret; 178 179 ret = regmap_update_bits(data->regmap, 180 data->base + SC27XX_FGU_USER_AREA_CLEAR, 181 SC27XX_FGU_MODE_AREA_MASK, 182 SC27XX_FGU_MODE_AREA_MASK); 183 if (ret) 184 return ret; 185 186 /* 187 * Since the user area registers are put on power always-on region, 188 * then these registers changing time will be a little long. Thus 189 * here we should delay 200us to wait until values are updated 190 * successfully according to the datasheet. 191 */ 192 udelay(200); 193 194 ret = regmap_update_bits(data->regmap, 195 data->base + SC27XX_FGU_USER_AREA_SET, 196 SC27XX_FGU_MODE_AREA_MASK, 197 boot_mode << SC27XX_FGU_MODE_AREA_SHIFT); 198 if (ret) 199 return ret; 200 201 /* 202 * Since the user area registers are put on power always-on region, 203 * then these registers changing time will be a little long. Thus 204 * here we should delay 200us to wait until values are updated 205 * successfully according to the datasheet. 206 */ 207 udelay(200); 208 209 /* 210 * According to the datasheet, we should set the USER_AREA_CLEAR to 0 to 211 * make the user area data available, otherwise we can not save the user 212 * area data. 213 */ 214 return regmap_update_bits(data->regmap, 215 data->base + SC27XX_FGU_USER_AREA_CLEAR, 216 SC27XX_FGU_MODE_AREA_MASK, 0); 217 } 218 219 static int sc27xx_fgu_save_last_cap(struct sc27xx_fgu_data *data, int cap) 220 { 221 int ret; 222 223 ret = regmap_update_bits(data->regmap, 224 data->base + SC27XX_FGU_USER_AREA_CLEAR, 225 SC27XX_FGU_CAP_AREA_MASK, 226 SC27XX_FGU_CAP_AREA_MASK); 227 if (ret) 228 return ret; 229 230 /* 231 * Since the user area registers are put on power always-on region, 232 * then these registers changing time will be a little long. Thus 233 * here we should delay 200us to wait until values are updated 234 * successfully according to the datasheet. 235 */ 236 udelay(200); 237 238 ret = regmap_update_bits(data->regmap, 239 data->base + SC27XX_FGU_USER_AREA_SET, 240 SC27XX_FGU_CAP_AREA_MASK, cap); 241 if (ret) 242 return ret; 243 244 /* 245 * Since the user area registers are put on power always-on region, 246 * then these registers changing time will be a little long. Thus 247 * here we should delay 200us to wait until values are updated 248 * successfully according to the datasheet. 249 */ 250 udelay(200); 251 252 /* 253 * According to the datasheet, we should set the USER_AREA_CLEAR to 0 to 254 * make the user area data available, otherwise we can not save the user 255 * area data. 256 */ 257 return regmap_update_bits(data->regmap, 258 data->base + SC27XX_FGU_USER_AREA_CLEAR, 259 SC27XX_FGU_CAP_AREA_MASK, 0); 260 } 261 262 static int sc27xx_fgu_read_last_cap(struct sc27xx_fgu_data *data, int *cap) 263 { 264 int ret, value; 265 266 ret = regmap_read(data->regmap, 267 data->base + SC27XX_FGU_USER_AREA_STATUS, &value); 268 if (ret) 269 return ret; 270 271 *cap = value & SC27XX_FGU_CAP_AREA_MASK; 272 return 0; 273 } 274 275 /* 276 * When system boots on, we can not read battery capacity from coulomb 277 * registers, since now the coulomb registers are invalid. So we should 278 * calculate the battery open circuit voltage, and get current battery 279 * capacity according to the capacity table. 280 */ 281 static int sc27xx_fgu_get_boot_capacity(struct sc27xx_fgu_data *data, int *cap) 282 { 283 int volt, cur, oci, ocv, ret; 284 bool is_first_poweron = sc27xx_fgu_is_first_poweron(data); 285 286 /* 287 * If system is not the first power on, we should use the last saved 288 * battery capacity as the initial battery capacity. Otherwise we should 289 * re-calculate the initial battery capacity. 290 */ 291 if (!is_first_poweron) { 292 ret = sc27xx_fgu_read_last_cap(data, cap); 293 if (ret) 294 return ret; 295 296 return sc27xx_fgu_save_boot_mode(data, SC27XX_FGU_NORMAIL_POWERTON); 297 } 298 299 /* 300 * After system booting on, the SC27XX_FGU_CLBCNT_QMAXL register saved 301 * the first sampled open circuit current. 302 */ 303 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CLBCNT_QMAXL, 304 &cur); 305 if (ret) 306 return ret; 307 308 cur <<= 1; 309 oci = sc27xx_fgu_adc_to_current(data, cur - SC27XX_FGU_CUR_BASIC_ADC); 310 311 /* 312 * Should get the OCV from SC27XX_FGU_POCV register at the system 313 * beginning. It is ADC values reading from registers which need to 314 * convert the corresponding voltage. 315 */ 316 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_POCV, &volt); 317 if (ret) 318 return ret; 319 320 volt = sc27xx_fgu_adc_to_voltage(data, volt); 321 ocv = volt * 1000 - oci * data->internal_resist; 322 323 /* 324 * Parse the capacity table to look up the correct capacity percent 325 * according to current battery's corresponding OCV values. 326 */ 327 *cap = power_supply_ocv2cap_simple(data->cap_table, data->table_len, 328 ocv); 329 330 ret = sc27xx_fgu_save_last_cap(data, *cap); 331 if (ret) 332 return ret; 333 334 return sc27xx_fgu_save_boot_mode(data, SC27XX_FGU_NORMAIL_POWERTON); 335 } 336 337 static int sc27xx_fgu_set_clbcnt(struct sc27xx_fgu_data *data, int clbcnt) 338 { 339 int ret; 340 341 ret = regmap_update_bits(data->regmap, 342 data->base + SC27XX_FGU_CLBCNT_SETL, 343 SC27XX_FGU_CLBCNT_MASK, clbcnt); 344 if (ret) 345 return ret; 346 347 ret = regmap_update_bits(data->regmap, 348 data->base + SC27XX_FGU_CLBCNT_SETH, 349 SC27XX_FGU_CLBCNT_MASK, 350 clbcnt >> SC27XX_FGU_CLBCNT_SHIFT); 351 if (ret) 352 return ret; 353 354 return regmap_update_bits(data->regmap, data->base + SC27XX_FGU_START, 355 SC27XX_WRITE_SELCLB_EN, 356 SC27XX_WRITE_SELCLB_EN); 357 } 358 359 static int sc27xx_fgu_get_clbcnt(struct sc27xx_fgu_data *data, int *clb_cnt) 360 { 361 int ccl, cch, ret; 362 363 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CLBCNT_VALL, 364 &ccl); 365 if (ret) 366 return ret; 367 368 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CLBCNT_VALH, 369 &cch); 370 if (ret) 371 return ret; 372 373 *clb_cnt = ccl & SC27XX_FGU_CLBCNT_MASK; 374 *clb_cnt |= (cch & SC27XX_FGU_CLBCNT_MASK) << SC27XX_FGU_CLBCNT_SHIFT; 375 376 return 0; 377 } 378 379 static int sc27xx_fgu_get_capacity(struct sc27xx_fgu_data *data, int *cap) 380 { 381 int ret, cur_clbcnt, delta_clbcnt, delta_cap, temp; 382 383 /* Get current coulomb counters firstly */ 384 ret = sc27xx_fgu_get_clbcnt(data, &cur_clbcnt); 385 if (ret) 386 return ret; 387 388 delta_clbcnt = cur_clbcnt - data->init_clbcnt; 389 390 /* 391 * Convert coulomb counter to delta capacity (mAh), and set multiplier 392 * as 10 to improve the precision. 393 */ 394 temp = DIV_ROUND_CLOSEST(delta_clbcnt * 10, 36 * SC27XX_FGU_SAMPLE_HZ); 395 temp = sc27xx_fgu_adc_to_current(data, temp / 1000); 396 397 /* 398 * Convert to capacity percent of the battery total capacity, 399 * and multiplier is 100 too. 400 */ 401 delta_cap = DIV_ROUND_CLOSEST(temp * 100, data->total_cap); 402 *cap = delta_cap + data->init_cap; 403 404 /* Calibrate the battery capacity in a normal range. */ 405 sc27xx_fgu_capacity_calibration(data, *cap, false); 406 407 return 0; 408 } 409 410 static int sc27xx_fgu_get_vbat_vol(struct sc27xx_fgu_data *data, int *val) 411 { 412 int ret, vol; 413 414 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_VOLTAGE, &vol); 415 if (ret) 416 return ret; 417 418 /* 419 * It is ADC values reading from registers which need to convert to 420 * corresponding voltage values. 421 */ 422 *val = sc27xx_fgu_adc_to_voltage(data, vol); 423 424 return 0; 425 } 426 427 static int sc27xx_fgu_get_current(struct sc27xx_fgu_data *data, int *val) 428 { 429 int ret, cur; 430 431 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CURRENT, &cur); 432 if (ret) 433 return ret; 434 435 /* 436 * It is ADC values reading from registers which need to convert to 437 * corresponding current values. 438 */ 439 *val = sc27xx_fgu_adc_to_current(data, cur - SC27XX_FGU_CUR_BASIC_ADC); 440 441 return 0; 442 } 443 444 static int sc27xx_fgu_get_vbat_ocv(struct sc27xx_fgu_data *data, int *val) 445 { 446 int vol, cur, ret, temp, resistance; 447 448 ret = sc27xx_fgu_get_vbat_vol(data, &vol); 449 if (ret) 450 return ret; 451 452 ret = sc27xx_fgu_get_current(data, &cur); 453 if (ret) 454 return ret; 455 456 resistance = data->internal_resist; 457 if (data->resist_table_len > 0) { 458 ret = sc27xx_fgu_get_temp(data, &temp); 459 if (ret) 460 return ret; 461 462 resistance = power_supply_temp2resist_simple(data->resist_table, 463 data->resist_table_len, temp); 464 resistance = data->internal_resist * resistance / 100; 465 } 466 467 /* Return the battery OCV in micro volts. */ 468 *val = vol * 1000 - cur * resistance; 469 470 return 0; 471 } 472 473 static int sc27xx_fgu_get_charge_vol(struct sc27xx_fgu_data *data, int *val) 474 { 475 int ret, vol; 476 477 ret = iio_read_channel_processed(data->charge_chan, &vol); 478 if (ret < 0) 479 return ret; 480 481 *val = vol * 1000; 482 return 0; 483 } 484 485 static int sc27xx_fgu_get_temp(struct sc27xx_fgu_data *data, int *temp) 486 { 487 return iio_read_channel_processed(data->channel, temp); 488 } 489 490 static int sc27xx_fgu_get_health(struct sc27xx_fgu_data *data, int *health) 491 { 492 int ret, vol; 493 494 ret = sc27xx_fgu_get_vbat_vol(data, &vol); 495 if (ret) 496 return ret; 497 498 if (vol > data->max_volt) 499 *health = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 500 else 501 *health = POWER_SUPPLY_HEALTH_GOOD; 502 503 return 0; 504 } 505 506 static int sc27xx_fgu_get_status(struct sc27xx_fgu_data *data, int *status) 507 { 508 union power_supply_propval val; 509 struct power_supply *psy; 510 int i, ret = -EINVAL; 511 512 for (i = 0; i < ARRAY_SIZE(sc27xx_charger_supply_name); i++) { 513 psy = power_supply_get_by_name(sc27xx_charger_supply_name[i]); 514 if (!psy) 515 continue; 516 517 ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_STATUS, 518 &val); 519 power_supply_put(psy); 520 if (ret) 521 return ret; 522 523 *status = val.intval; 524 } 525 526 return ret; 527 } 528 529 static int sc27xx_fgu_get_property(struct power_supply *psy, 530 enum power_supply_property psp, 531 union power_supply_propval *val) 532 { 533 struct sc27xx_fgu_data *data = power_supply_get_drvdata(psy); 534 int ret = 0; 535 int value; 536 537 mutex_lock(&data->lock); 538 539 switch (psp) { 540 case POWER_SUPPLY_PROP_STATUS: 541 ret = sc27xx_fgu_get_status(data, &value); 542 if (ret) 543 goto error; 544 545 val->intval = value; 546 break; 547 548 case POWER_SUPPLY_PROP_HEALTH: 549 ret = sc27xx_fgu_get_health(data, &value); 550 if (ret) 551 goto error; 552 553 val->intval = value; 554 break; 555 556 case POWER_SUPPLY_PROP_PRESENT: 557 val->intval = data->bat_present; 558 break; 559 560 case POWER_SUPPLY_PROP_TEMP: 561 ret = sc27xx_fgu_get_temp(data, &value); 562 if (ret) 563 goto error; 564 565 val->intval = value; 566 break; 567 568 case POWER_SUPPLY_PROP_TECHNOLOGY: 569 val->intval = POWER_SUPPLY_TECHNOLOGY_LION; 570 break; 571 572 case POWER_SUPPLY_PROP_CAPACITY: 573 ret = sc27xx_fgu_get_capacity(data, &value); 574 if (ret) 575 goto error; 576 577 val->intval = value; 578 break; 579 580 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 581 ret = sc27xx_fgu_get_vbat_vol(data, &value); 582 if (ret) 583 goto error; 584 585 val->intval = value * 1000; 586 break; 587 588 case POWER_SUPPLY_PROP_VOLTAGE_OCV: 589 ret = sc27xx_fgu_get_vbat_ocv(data, &value); 590 if (ret) 591 goto error; 592 593 val->intval = value; 594 break; 595 596 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: 597 ret = sc27xx_fgu_get_charge_vol(data, &value); 598 if (ret) 599 goto error; 600 601 val->intval = value; 602 break; 603 604 case POWER_SUPPLY_PROP_CURRENT_NOW: 605 case POWER_SUPPLY_PROP_CURRENT_AVG: 606 ret = sc27xx_fgu_get_current(data, &value); 607 if (ret) 608 goto error; 609 610 val->intval = value * 1000; 611 break; 612 613 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 614 val->intval = data->total_cap * 1000; 615 break; 616 617 default: 618 ret = -EINVAL; 619 break; 620 } 621 622 error: 623 mutex_unlock(&data->lock); 624 return ret; 625 } 626 627 static int sc27xx_fgu_set_property(struct power_supply *psy, 628 enum power_supply_property psp, 629 const union power_supply_propval *val) 630 { 631 struct sc27xx_fgu_data *data = power_supply_get_drvdata(psy); 632 int ret; 633 634 mutex_lock(&data->lock); 635 636 switch (psp) { 637 case POWER_SUPPLY_PROP_CAPACITY: 638 ret = sc27xx_fgu_save_last_cap(data, val->intval); 639 if (ret < 0) 640 dev_err(data->dev, "failed to save battery capacity\n"); 641 break; 642 643 case POWER_SUPPLY_PROP_CALIBRATE: 644 sc27xx_fgu_adjust_cap(data, val->intval); 645 ret = 0; 646 break; 647 648 default: 649 ret = -EINVAL; 650 } 651 652 mutex_unlock(&data->lock); 653 654 return ret; 655 } 656 657 static void sc27xx_fgu_external_power_changed(struct power_supply *psy) 658 { 659 struct sc27xx_fgu_data *data = power_supply_get_drvdata(psy); 660 661 power_supply_changed(data->battery); 662 } 663 664 static int sc27xx_fgu_property_is_writeable(struct power_supply *psy, 665 enum power_supply_property psp) 666 { 667 return psp == POWER_SUPPLY_PROP_CAPACITY || 668 psp == POWER_SUPPLY_PROP_CALIBRATE; 669 } 670 671 static enum power_supply_property sc27xx_fgu_props[] = { 672 POWER_SUPPLY_PROP_STATUS, 673 POWER_SUPPLY_PROP_HEALTH, 674 POWER_SUPPLY_PROP_PRESENT, 675 POWER_SUPPLY_PROP_TEMP, 676 POWER_SUPPLY_PROP_TECHNOLOGY, 677 POWER_SUPPLY_PROP_CAPACITY, 678 POWER_SUPPLY_PROP_VOLTAGE_NOW, 679 POWER_SUPPLY_PROP_VOLTAGE_OCV, 680 POWER_SUPPLY_PROP_CURRENT_NOW, 681 POWER_SUPPLY_PROP_CURRENT_AVG, 682 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 683 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 684 POWER_SUPPLY_PROP_CALIBRATE, 685 }; 686 687 static const struct power_supply_desc sc27xx_fgu_desc = { 688 .name = "sc27xx-fgu", 689 .type = POWER_SUPPLY_TYPE_BATTERY, 690 .properties = sc27xx_fgu_props, 691 .num_properties = ARRAY_SIZE(sc27xx_fgu_props), 692 .get_property = sc27xx_fgu_get_property, 693 .set_property = sc27xx_fgu_set_property, 694 .external_power_changed = sc27xx_fgu_external_power_changed, 695 .property_is_writeable = sc27xx_fgu_property_is_writeable, 696 }; 697 698 static void sc27xx_fgu_adjust_cap(struct sc27xx_fgu_data *data, int cap) 699 { 700 int ret; 701 702 data->init_cap = cap; 703 ret = sc27xx_fgu_get_clbcnt(data, &data->init_clbcnt); 704 if (ret) 705 dev_err(data->dev, "failed to get init coulomb counter\n"); 706 } 707 708 static void sc27xx_fgu_capacity_calibration(struct sc27xx_fgu_data *data, 709 int cap, bool int_mode) 710 { 711 int ret, ocv, chg_sts, adc; 712 713 ret = sc27xx_fgu_get_vbat_ocv(data, &ocv); 714 if (ret) { 715 dev_err(data->dev, "get battery ocv error.\n"); 716 return; 717 } 718 719 ret = sc27xx_fgu_get_status(data, &chg_sts); 720 if (ret) { 721 dev_err(data->dev, "get charger status error.\n"); 722 return; 723 } 724 725 /* 726 * If we are in charging mode, then we do not need to calibrate the 727 * lower capacity. 728 */ 729 if (chg_sts == POWER_SUPPLY_STATUS_CHARGING) 730 return; 731 732 if ((ocv > data->cap_table[0].ocv && cap < 100) || cap > 100) { 733 /* 734 * If current OCV value is larger than the max OCV value in 735 * OCV table, or the current capacity is larger than 100, 736 * we should force the inititial capacity to 100. 737 */ 738 sc27xx_fgu_adjust_cap(data, 100); 739 } else if (ocv <= data->cap_table[data->table_len - 1].ocv) { 740 /* 741 * If current OCV value is leass than the minimum OCV value in 742 * OCV table, we should force the inititial capacity to 0. 743 */ 744 sc27xx_fgu_adjust_cap(data, 0); 745 } else if ((ocv > data->cap_table[data->table_len - 1].ocv && cap <= 0) || 746 (ocv > data->min_volt && cap <= data->alarm_cap)) { 747 /* 748 * If current OCV value is not matchable with current capacity, 749 * we should re-calculate current capacity by looking up the 750 * OCV table. 751 */ 752 int cur_cap = power_supply_ocv2cap_simple(data->cap_table, 753 data->table_len, ocv); 754 755 sc27xx_fgu_adjust_cap(data, cur_cap); 756 } else if (ocv <= data->min_volt) { 757 /* 758 * If current OCV value is less than the low alarm voltage, but 759 * current capacity is larger than the alarm capacity, we should 760 * adjust the inititial capacity to alarm capacity. 761 */ 762 if (cap > data->alarm_cap) { 763 sc27xx_fgu_adjust_cap(data, data->alarm_cap); 764 } else { 765 int cur_cap; 766 767 /* 768 * If current capacity is equal with 0 or less than 0 769 * (some error occurs), we should adjust inititial 770 * capacity to the capacity corresponding to current OCV 771 * value. 772 */ 773 cur_cap = power_supply_ocv2cap_simple(data->cap_table, 774 data->table_len, 775 ocv); 776 sc27xx_fgu_adjust_cap(data, cur_cap); 777 } 778 779 if (!int_mode) 780 return; 781 782 /* 783 * After adjusting the battery capacity, we should set the 784 * lowest alarm voltage instead. 785 */ 786 data->min_volt = data->cap_table[data->table_len - 1].ocv; 787 data->alarm_cap = power_supply_ocv2cap_simple(data->cap_table, 788 data->table_len, 789 data->min_volt); 790 791 adc = sc27xx_fgu_voltage_to_adc(data, data->min_volt / 1000); 792 regmap_update_bits(data->regmap, 793 data->base + SC27XX_FGU_LOW_OVERLOAD, 794 SC27XX_FGU_LOW_OVERLOAD_MASK, adc); 795 } 796 } 797 798 static irqreturn_t sc27xx_fgu_interrupt(int irq, void *dev_id) 799 { 800 struct sc27xx_fgu_data *data = dev_id; 801 int ret, cap; 802 u32 status; 803 804 mutex_lock(&data->lock); 805 806 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_INT_STS, 807 &status); 808 if (ret) 809 goto out; 810 811 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_CLR, 812 status, status); 813 if (ret) 814 goto out; 815 816 /* 817 * When low overload voltage interrupt happens, we should calibrate the 818 * battery capacity in lower voltage stage. 819 */ 820 if (!(status & SC27XX_FGU_LOW_OVERLOAD_INT)) 821 goto out; 822 823 ret = sc27xx_fgu_get_capacity(data, &cap); 824 if (ret) 825 goto out; 826 827 sc27xx_fgu_capacity_calibration(data, cap, true); 828 829 out: 830 mutex_unlock(&data->lock); 831 832 power_supply_changed(data->battery); 833 return IRQ_HANDLED; 834 } 835 836 static irqreturn_t sc27xx_fgu_bat_detection(int irq, void *dev_id) 837 { 838 struct sc27xx_fgu_data *data = dev_id; 839 int state; 840 841 mutex_lock(&data->lock); 842 843 state = gpiod_get_value_cansleep(data->gpiod); 844 if (state < 0) { 845 dev_err(data->dev, "failed to get gpio state\n"); 846 mutex_unlock(&data->lock); 847 return IRQ_RETVAL(state); 848 } 849 850 data->bat_present = !!state; 851 852 mutex_unlock(&data->lock); 853 854 power_supply_changed(data->battery); 855 return IRQ_HANDLED; 856 } 857 858 static void sc27xx_fgu_disable(void *_data) 859 { 860 struct sc27xx_fgu_data *data = _data; 861 862 regmap_update_bits(data->regmap, SC27XX_CLK_EN0, SC27XX_FGU_RTC_EN, 0); 863 regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, SC27XX_FGU_EN, 0); 864 } 865 866 static int sc27xx_fgu_cap_to_clbcnt(struct sc27xx_fgu_data *data, int capacity) 867 { 868 /* 869 * Get current capacity (mAh) = battery total capacity (mAh) * 870 * current capacity percent (capacity / 100). 871 */ 872 int cur_cap = DIV_ROUND_CLOSEST(data->total_cap * capacity, 100); 873 874 /* 875 * Convert current capacity (mAh) to coulomb counter according to the 876 * formula: 1 mAh =3.6 coulomb. 877 */ 878 return DIV_ROUND_CLOSEST(cur_cap * 36 * data->cur_1000ma_adc * SC27XX_FGU_SAMPLE_HZ, 10); 879 } 880 881 static int sc27xx_fgu_calibration(struct sc27xx_fgu_data *data) 882 { 883 struct nvmem_cell *cell; 884 int calib_data, cal_4200mv; 885 void *buf; 886 size_t len; 887 888 cell = nvmem_cell_get(data->dev, "fgu_calib"); 889 if (IS_ERR(cell)) 890 return PTR_ERR(cell); 891 892 buf = nvmem_cell_read(cell, &len); 893 nvmem_cell_put(cell); 894 895 if (IS_ERR(buf)) 896 return PTR_ERR(buf); 897 898 memcpy(&calib_data, buf, min(len, sizeof(u32))); 899 900 /* 901 * Get the ADC value corresponding to 4200 mV from eFuse controller 902 * according to below formula. Then convert to ADC values corresponding 903 * to 1000 mV and 1000 mA. 904 */ 905 cal_4200mv = (calib_data & 0x1ff) + 6963 - 4096 - 256; 906 data->vol_1000mv_adc = DIV_ROUND_CLOSEST(cal_4200mv * 10, 42); 907 data->cur_1000ma_adc = 908 DIV_ROUND_CLOSEST(data->vol_1000mv_adc * 4 * data->calib_resist, 909 SC27XX_FGU_IDEAL_RESISTANCE); 910 911 kfree(buf); 912 return 0; 913 } 914 915 static int sc27xx_fgu_hw_init(struct sc27xx_fgu_data *data) 916 { 917 struct power_supply_battery_info info = { }; 918 struct power_supply_battery_ocv_table *table; 919 int ret, delta_clbcnt, alarm_adc; 920 921 ret = power_supply_get_battery_info(data->battery, &info); 922 if (ret) { 923 dev_err(data->dev, "failed to get battery information\n"); 924 return ret; 925 } 926 927 data->total_cap = info.charge_full_design_uah / 1000; 928 data->max_volt = info.constant_charge_voltage_max_uv / 1000; 929 data->internal_resist = info.factory_internal_resistance_uohm / 1000; 930 data->min_volt = info.voltage_min_design_uv; 931 932 /* 933 * For SC27XX fuel gauge device, we only use one ocv-capacity 934 * table in normal temperature 20 Celsius. 935 */ 936 table = power_supply_find_ocv2cap_table(&info, 20, &data->table_len); 937 if (!table) 938 return -EINVAL; 939 940 data->cap_table = devm_kmemdup(data->dev, table, 941 data->table_len * sizeof(*table), 942 GFP_KERNEL); 943 if (!data->cap_table) { 944 power_supply_put_battery_info(data->battery, &info); 945 return -ENOMEM; 946 } 947 948 data->alarm_cap = power_supply_ocv2cap_simple(data->cap_table, 949 data->table_len, 950 data->min_volt); 951 if (!data->alarm_cap) 952 data->alarm_cap += 1; 953 954 data->resist_table_len = info.resist_table_size; 955 if (data->resist_table_len > 0) { 956 data->resist_table = devm_kmemdup(data->dev, info.resist_table, 957 data->resist_table_len * 958 sizeof(struct power_supply_resistance_temp_table), 959 GFP_KERNEL); 960 if (!data->resist_table) { 961 power_supply_put_battery_info(data->battery, &info); 962 return -ENOMEM; 963 } 964 } 965 966 power_supply_put_battery_info(data->battery, &info); 967 968 ret = sc27xx_fgu_calibration(data); 969 if (ret) 970 return ret; 971 972 /* Enable the FGU module */ 973 ret = regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, 974 SC27XX_FGU_EN, SC27XX_FGU_EN); 975 if (ret) { 976 dev_err(data->dev, "failed to enable fgu\n"); 977 return ret; 978 } 979 980 /* Enable the FGU RTC clock to make it work */ 981 ret = regmap_update_bits(data->regmap, SC27XX_CLK_EN0, 982 SC27XX_FGU_RTC_EN, SC27XX_FGU_RTC_EN); 983 if (ret) { 984 dev_err(data->dev, "failed to enable fgu RTC clock\n"); 985 goto disable_fgu; 986 } 987 988 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_CLR, 989 SC27XX_FGU_INT_MASK, SC27XX_FGU_INT_MASK); 990 if (ret) { 991 dev_err(data->dev, "failed to clear interrupt status\n"); 992 goto disable_clk; 993 } 994 995 /* 996 * Set the voltage low overload threshold, which means when the battery 997 * voltage is lower than this threshold, the controller will generate 998 * one interrupt to notify. 999 */ 1000 alarm_adc = sc27xx_fgu_voltage_to_adc(data, data->min_volt / 1000); 1001 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_LOW_OVERLOAD, 1002 SC27XX_FGU_LOW_OVERLOAD_MASK, alarm_adc); 1003 if (ret) { 1004 dev_err(data->dev, "failed to set fgu low overload\n"); 1005 goto disable_clk; 1006 } 1007 1008 /* 1009 * Set the coulomb counter delta threshold, that means when the coulomb 1010 * counter change is multiples of the delta threshold, the controller 1011 * will generate one interrupt to notify the users to update the battery 1012 * capacity. Now we set the delta threshold as a counter value of 1% 1013 * capacity. 1014 */ 1015 delta_clbcnt = sc27xx_fgu_cap_to_clbcnt(data, 1); 1016 1017 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_CLBCNT_DELTL, 1018 SC27XX_FGU_CLBCNT_MASK, delta_clbcnt); 1019 if (ret) { 1020 dev_err(data->dev, "failed to set low delta coulomb counter\n"); 1021 goto disable_clk; 1022 } 1023 1024 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_CLBCNT_DELTH, 1025 SC27XX_FGU_CLBCNT_MASK, 1026 delta_clbcnt >> SC27XX_FGU_CLBCNT_SHIFT); 1027 if (ret) { 1028 dev_err(data->dev, "failed to set high delta coulomb counter\n"); 1029 goto disable_clk; 1030 } 1031 1032 /* 1033 * Get the boot battery capacity when system powers on, which is used to 1034 * initialize the coulomb counter. After that, we can read the coulomb 1035 * counter to measure the battery capacity. 1036 */ 1037 ret = sc27xx_fgu_get_boot_capacity(data, &data->init_cap); 1038 if (ret) { 1039 dev_err(data->dev, "failed to get boot capacity\n"); 1040 goto disable_clk; 1041 } 1042 1043 /* 1044 * Convert battery capacity to the corresponding initial coulomb counter 1045 * and set into coulomb counter registers. 1046 */ 1047 data->init_clbcnt = sc27xx_fgu_cap_to_clbcnt(data, data->init_cap); 1048 ret = sc27xx_fgu_set_clbcnt(data, data->init_clbcnt); 1049 if (ret) { 1050 dev_err(data->dev, "failed to initialize coulomb counter\n"); 1051 goto disable_clk; 1052 } 1053 1054 return 0; 1055 1056 disable_clk: 1057 regmap_update_bits(data->regmap, SC27XX_CLK_EN0, SC27XX_FGU_RTC_EN, 0); 1058 disable_fgu: 1059 regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, SC27XX_FGU_EN, 0); 1060 1061 return ret; 1062 } 1063 1064 static int sc27xx_fgu_probe(struct platform_device *pdev) 1065 { 1066 struct device *dev = &pdev->dev; 1067 struct device_node *np = dev->of_node; 1068 struct power_supply_config fgu_cfg = { }; 1069 struct sc27xx_fgu_data *data; 1070 int ret, irq; 1071 1072 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 1073 if (!data) 1074 return -ENOMEM; 1075 1076 data->regmap = dev_get_regmap(dev->parent, NULL); 1077 if (!data->regmap) { 1078 dev_err(dev, "failed to get regmap\n"); 1079 return -ENODEV; 1080 } 1081 1082 ret = device_property_read_u32(dev, "reg", &data->base); 1083 if (ret) { 1084 dev_err(dev, "failed to get fgu address\n"); 1085 return ret; 1086 } 1087 1088 ret = device_property_read_u32(&pdev->dev, 1089 "sprd,calib-resistance-micro-ohms", 1090 &data->calib_resist); 1091 if (ret) { 1092 dev_err(&pdev->dev, 1093 "failed to get fgu calibration resistance\n"); 1094 return ret; 1095 } 1096 1097 data->channel = devm_iio_channel_get(dev, "bat-temp"); 1098 if (IS_ERR(data->channel)) { 1099 dev_err(dev, "failed to get IIO channel\n"); 1100 return PTR_ERR(data->channel); 1101 } 1102 1103 data->charge_chan = devm_iio_channel_get(dev, "charge-vol"); 1104 if (IS_ERR(data->charge_chan)) { 1105 dev_err(dev, "failed to get charge IIO channel\n"); 1106 return PTR_ERR(data->charge_chan); 1107 } 1108 1109 data->gpiod = devm_gpiod_get(dev, "bat-detect", GPIOD_IN); 1110 if (IS_ERR(data->gpiod)) { 1111 dev_err(dev, "failed to get battery detection GPIO\n"); 1112 return PTR_ERR(data->gpiod); 1113 } 1114 1115 ret = gpiod_get_value_cansleep(data->gpiod); 1116 if (ret < 0) { 1117 dev_err(dev, "failed to get gpio state\n"); 1118 return ret; 1119 } 1120 1121 data->bat_present = !!ret; 1122 mutex_init(&data->lock); 1123 data->dev = dev; 1124 platform_set_drvdata(pdev, data); 1125 1126 fgu_cfg.drv_data = data; 1127 fgu_cfg.of_node = np; 1128 data->battery = devm_power_supply_register(dev, &sc27xx_fgu_desc, 1129 &fgu_cfg); 1130 if (IS_ERR(data->battery)) { 1131 dev_err(dev, "failed to register power supply\n"); 1132 return PTR_ERR(data->battery); 1133 } 1134 1135 ret = sc27xx_fgu_hw_init(data); 1136 if (ret) { 1137 dev_err(dev, "failed to initialize fgu hardware\n"); 1138 return ret; 1139 } 1140 1141 ret = devm_add_action_or_reset(dev, sc27xx_fgu_disable, data); 1142 if (ret) { 1143 dev_err(dev, "failed to add fgu disable action\n"); 1144 return ret; 1145 } 1146 1147 irq = platform_get_irq(pdev, 0); 1148 if (irq < 0) { 1149 dev_err(dev, "no irq resource specified\n"); 1150 return irq; 1151 } 1152 1153 ret = devm_request_threaded_irq(data->dev, irq, NULL, 1154 sc27xx_fgu_interrupt, 1155 IRQF_NO_SUSPEND | IRQF_ONESHOT, 1156 pdev->name, data); 1157 if (ret) { 1158 dev_err(data->dev, "failed to request fgu IRQ\n"); 1159 return ret; 1160 } 1161 1162 irq = gpiod_to_irq(data->gpiod); 1163 if (irq < 0) { 1164 dev_err(dev, "failed to translate GPIO to IRQ\n"); 1165 return irq; 1166 } 1167 1168 ret = devm_request_threaded_irq(dev, irq, NULL, 1169 sc27xx_fgu_bat_detection, 1170 IRQF_ONESHOT | IRQF_TRIGGER_RISING | 1171 IRQF_TRIGGER_FALLING, 1172 pdev->name, data); 1173 if (ret) { 1174 dev_err(dev, "failed to request IRQ\n"); 1175 return ret; 1176 } 1177 1178 return 0; 1179 } 1180 1181 #ifdef CONFIG_PM_SLEEP 1182 static int sc27xx_fgu_resume(struct device *dev) 1183 { 1184 struct sc27xx_fgu_data *data = dev_get_drvdata(dev); 1185 int ret; 1186 1187 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN, 1188 SC27XX_FGU_LOW_OVERLOAD_INT | 1189 SC27XX_FGU_CLBCNT_DELTA_INT, 0); 1190 if (ret) { 1191 dev_err(data->dev, "failed to disable fgu interrupts\n"); 1192 return ret; 1193 } 1194 1195 return 0; 1196 } 1197 1198 static int sc27xx_fgu_suspend(struct device *dev) 1199 { 1200 struct sc27xx_fgu_data *data = dev_get_drvdata(dev); 1201 int ret, status, ocv; 1202 1203 ret = sc27xx_fgu_get_status(data, &status); 1204 if (ret) 1205 return ret; 1206 1207 /* 1208 * If we are charging, then no need to enable the FGU interrupts to 1209 * adjust the battery capacity. 1210 */ 1211 if (status != POWER_SUPPLY_STATUS_NOT_CHARGING && 1212 status != POWER_SUPPLY_STATUS_DISCHARGING) 1213 return 0; 1214 1215 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN, 1216 SC27XX_FGU_LOW_OVERLOAD_INT, 1217 SC27XX_FGU_LOW_OVERLOAD_INT); 1218 if (ret) { 1219 dev_err(data->dev, "failed to enable low voltage interrupt\n"); 1220 return ret; 1221 } 1222 1223 ret = sc27xx_fgu_get_vbat_ocv(data, &ocv); 1224 if (ret) 1225 goto disable_int; 1226 1227 /* 1228 * If current OCV is less than the minimum voltage, we should enable the 1229 * coulomb counter threshold interrupt to notify events to adjust the 1230 * battery capacity. 1231 */ 1232 if (ocv < data->min_volt) { 1233 ret = regmap_update_bits(data->regmap, 1234 data->base + SC27XX_FGU_INT_EN, 1235 SC27XX_FGU_CLBCNT_DELTA_INT, 1236 SC27XX_FGU_CLBCNT_DELTA_INT); 1237 if (ret) { 1238 dev_err(data->dev, 1239 "failed to enable coulomb threshold int\n"); 1240 goto disable_int; 1241 } 1242 } 1243 1244 return 0; 1245 1246 disable_int: 1247 regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN, 1248 SC27XX_FGU_LOW_OVERLOAD_INT, 0); 1249 return ret; 1250 } 1251 #endif 1252 1253 static const struct dev_pm_ops sc27xx_fgu_pm_ops = { 1254 SET_SYSTEM_SLEEP_PM_OPS(sc27xx_fgu_suspend, sc27xx_fgu_resume) 1255 }; 1256 1257 static const struct of_device_id sc27xx_fgu_of_match[] = { 1258 { .compatible = "sprd,sc2731-fgu", }, 1259 { } 1260 }; 1261 1262 static struct platform_driver sc27xx_fgu_driver = { 1263 .probe = sc27xx_fgu_probe, 1264 .driver = { 1265 .name = "sc27xx-fgu", 1266 .of_match_table = sc27xx_fgu_of_match, 1267 .pm = &sc27xx_fgu_pm_ops, 1268 } 1269 }; 1270 1271 module_platform_driver(sc27xx_fgu_driver); 1272 1273 MODULE_DESCRIPTION("Spreadtrum SC27XX PMICs Fual Gauge Unit Driver"); 1274 MODULE_LICENSE("GPL v2"); 1275