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 case POWER_SUPPLY_PROP_CHARGE_NOW: 618 ret = sc27xx_fgu_get_clbcnt(data, &value); 619 if (ret) 620 goto error; 621 622 value = DIV_ROUND_CLOSEST(value * 10, 623 36 * SC27XX_FGU_SAMPLE_HZ); 624 val->intval = sc27xx_fgu_adc_to_current(data, value); 625 626 break; 627 628 default: 629 ret = -EINVAL; 630 break; 631 } 632 633 error: 634 mutex_unlock(&data->lock); 635 return ret; 636 } 637 638 static int sc27xx_fgu_set_property(struct power_supply *psy, 639 enum power_supply_property psp, 640 const union power_supply_propval *val) 641 { 642 struct sc27xx_fgu_data *data = power_supply_get_drvdata(psy); 643 int ret; 644 645 mutex_lock(&data->lock); 646 647 switch (psp) { 648 case POWER_SUPPLY_PROP_CAPACITY: 649 ret = sc27xx_fgu_save_last_cap(data, val->intval); 650 if (ret < 0) 651 dev_err(data->dev, "failed to save battery capacity\n"); 652 break; 653 654 case POWER_SUPPLY_PROP_CALIBRATE: 655 sc27xx_fgu_adjust_cap(data, val->intval); 656 ret = 0; 657 break; 658 659 default: 660 ret = -EINVAL; 661 } 662 663 mutex_unlock(&data->lock); 664 665 return ret; 666 } 667 668 static void sc27xx_fgu_external_power_changed(struct power_supply *psy) 669 { 670 struct sc27xx_fgu_data *data = power_supply_get_drvdata(psy); 671 672 power_supply_changed(data->battery); 673 } 674 675 static int sc27xx_fgu_property_is_writeable(struct power_supply *psy, 676 enum power_supply_property psp) 677 { 678 return psp == POWER_SUPPLY_PROP_CAPACITY || 679 psp == POWER_SUPPLY_PROP_CALIBRATE; 680 } 681 682 static enum power_supply_property sc27xx_fgu_props[] = { 683 POWER_SUPPLY_PROP_STATUS, 684 POWER_SUPPLY_PROP_HEALTH, 685 POWER_SUPPLY_PROP_PRESENT, 686 POWER_SUPPLY_PROP_TEMP, 687 POWER_SUPPLY_PROP_TECHNOLOGY, 688 POWER_SUPPLY_PROP_CAPACITY, 689 POWER_SUPPLY_PROP_VOLTAGE_NOW, 690 POWER_SUPPLY_PROP_VOLTAGE_OCV, 691 POWER_SUPPLY_PROP_CURRENT_NOW, 692 POWER_SUPPLY_PROP_CURRENT_AVG, 693 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, 694 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 695 POWER_SUPPLY_PROP_CALIBRATE, 696 POWER_SUPPLY_PROP_CHARGE_NOW 697 }; 698 699 static const struct power_supply_desc sc27xx_fgu_desc = { 700 .name = "sc27xx-fgu", 701 .type = POWER_SUPPLY_TYPE_BATTERY, 702 .properties = sc27xx_fgu_props, 703 .num_properties = ARRAY_SIZE(sc27xx_fgu_props), 704 .get_property = sc27xx_fgu_get_property, 705 .set_property = sc27xx_fgu_set_property, 706 .external_power_changed = sc27xx_fgu_external_power_changed, 707 .property_is_writeable = sc27xx_fgu_property_is_writeable, 708 }; 709 710 static void sc27xx_fgu_adjust_cap(struct sc27xx_fgu_data *data, int cap) 711 { 712 int ret; 713 714 data->init_cap = cap; 715 ret = sc27xx_fgu_get_clbcnt(data, &data->init_clbcnt); 716 if (ret) 717 dev_err(data->dev, "failed to get init coulomb counter\n"); 718 } 719 720 static void sc27xx_fgu_capacity_calibration(struct sc27xx_fgu_data *data, 721 int cap, bool int_mode) 722 { 723 int ret, ocv, chg_sts, adc; 724 725 ret = sc27xx_fgu_get_vbat_ocv(data, &ocv); 726 if (ret) { 727 dev_err(data->dev, "get battery ocv error.\n"); 728 return; 729 } 730 731 ret = sc27xx_fgu_get_status(data, &chg_sts); 732 if (ret) { 733 dev_err(data->dev, "get charger status error.\n"); 734 return; 735 } 736 737 /* 738 * If we are in charging mode, then we do not need to calibrate the 739 * lower capacity. 740 */ 741 if (chg_sts == POWER_SUPPLY_STATUS_CHARGING) 742 return; 743 744 if ((ocv > data->cap_table[0].ocv && cap < 100) || cap > 100) { 745 /* 746 * If current OCV value is larger than the max OCV value in 747 * OCV table, or the current capacity is larger than 100, 748 * we should force the inititial capacity to 100. 749 */ 750 sc27xx_fgu_adjust_cap(data, 100); 751 } else if (ocv <= data->cap_table[data->table_len - 1].ocv) { 752 /* 753 * If current OCV value is leass than the minimum OCV value in 754 * OCV table, we should force the inititial capacity to 0. 755 */ 756 sc27xx_fgu_adjust_cap(data, 0); 757 } else if ((ocv > data->cap_table[data->table_len - 1].ocv && cap <= 0) || 758 (ocv > data->min_volt && cap <= data->alarm_cap)) { 759 /* 760 * If current OCV value is not matchable with current capacity, 761 * we should re-calculate current capacity by looking up the 762 * OCV table. 763 */ 764 int cur_cap = power_supply_ocv2cap_simple(data->cap_table, 765 data->table_len, ocv); 766 767 sc27xx_fgu_adjust_cap(data, cur_cap); 768 } else if (ocv <= data->min_volt) { 769 /* 770 * If current OCV value is less than the low alarm voltage, but 771 * current capacity is larger than the alarm capacity, we should 772 * adjust the inititial capacity to alarm capacity. 773 */ 774 if (cap > data->alarm_cap) { 775 sc27xx_fgu_adjust_cap(data, data->alarm_cap); 776 } else { 777 int cur_cap; 778 779 /* 780 * If current capacity is equal with 0 or less than 0 781 * (some error occurs), we should adjust inititial 782 * capacity to the capacity corresponding to current OCV 783 * value. 784 */ 785 cur_cap = power_supply_ocv2cap_simple(data->cap_table, 786 data->table_len, 787 ocv); 788 sc27xx_fgu_adjust_cap(data, cur_cap); 789 } 790 791 if (!int_mode) 792 return; 793 794 /* 795 * After adjusting the battery capacity, we should set the 796 * lowest alarm voltage instead. 797 */ 798 data->min_volt = data->cap_table[data->table_len - 1].ocv; 799 data->alarm_cap = power_supply_ocv2cap_simple(data->cap_table, 800 data->table_len, 801 data->min_volt); 802 803 adc = sc27xx_fgu_voltage_to_adc(data, data->min_volt / 1000); 804 regmap_update_bits(data->regmap, 805 data->base + SC27XX_FGU_LOW_OVERLOAD, 806 SC27XX_FGU_LOW_OVERLOAD_MASK, adc); 807 } 808 } 809 810 static irqreturn_t sc27xx_fgu_interrupt(int irq, void *dev_id) 811 { 812 struct sc27xx_fgu_data *data = dev_id; 813 int ret, cap; 814 u32 status; 815 816 mutex_lock(&data->lock); 817 818 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_INT_STS, 819 &status); 820 if (ret) 821 goto out; 822 823 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_CLR, 824 status, status); 825 if (ret) 826 goto out; 827 828 /* 829 * When low overload voltage interrupt happens, we should calibrate the 830 * battery capacity in lower voltage stage. 831 */ 832 if (!(status & SC27XX_FGU_LOW_OVERLOAD_INT)) 833 goto out; 834 835 ret = sc27xx_fgu_get_capacity(data, &cap); 836 if (ret) 837 goto out; 838 839 sc27xx_fgu_capacity_calibration(data, cap, true); 840 841 out: 842 mutex_unlock(&data->lock); 843 844 power_supply_changed(data->battery); 845 return IRQ_HANDLED; 846 } 847 848 static irqreturn_t sc27xx_fgu_bat_detection(int irq, void *dev_id) 849 { 850 struct sc27xx_fgu_data *data = dev_id; 851 int state; 852 853 mutex_lock(&data->lock); 854 855 state = gpiod_get_value_cansleep(data->gpiod); 856 if (state < 0) { 857 dev_err(data->dev, "failed to get gpio state\n"); 858 mutex_unlock(&data->lock); 859 return IRQ_RETVAL(state); 860 } 861 862 data->bat_present = !!state; 863 864 mutex_unlock(&data->lock); 865 866 power_supply_changed(data->battery); 867 return IRQ_HANDLED; 868 } 869 870 static void sc27xx_fgu_disable(void *_data) 871 { 872 struct sc27xx_fgu_data *data = _data; 873 874 regmap_update_bits(data->regmap, SC27XX_CLK_EN0, SC27XX_FGU_RTC_EN, 0); 875 regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, SC27XX_FGU_EN, 0); 876 } 877 878 static int sc27xx_fgu_cap_to_clbcnt(struct sc27xx_fgu_data *data, int capacity) 879 { 880 /* 881 * Get current capacity (mAh) = battery total capacity (mAh) * 882 * current capacity percent (capacity / 100). 883 */ 884 int cur_cap = DIV_ROUND_CLOSEST(data->total_cap * capacity, 100); 885 886 /* 887 * Convert current capacity (mAh) to coulomb counter according to the 888 * formula: 1 mAh =3.6 coulomb. 889 */ 890 return DIV_ROUND_CLOSEST(cur_cap * 36 * data->cur_1000ma_adc * SC27XX_FGU_SAMPLE_HZ, 10); 891 } 892 893 static int sc27xx_fgu_calibration(struct sc27xx_fgu_data *data) 894 { 895 struct nvmem_cell *cell; 896 int calib_data, cal_4200mv; 897 void *buf; 898 size_t len; 899 900 cell = nvmem_cell_get(data->dev, "fgu_calib"); 901 if (IS_ERR(cell)) 902 return PTR_ERR(cell); 903 904 buf = nvmem_cell_read(cell, &len); 905 nvmem_cell_put(cell); 906 907 if (IS_ERR(buf)) 908 return PTR_ERR(buf); 909 910 memcpy(&calib_data, buf, min(len, sizeof(u32))); 911 912 /* 913 * Get the ADC value corresponding to 4200 mV from eFuse controller 914 * according to below formula. Then convert to ADC values corresponding 915 * to 1000 mV and 1000 mA. 916 */ 917 cal_4200mv = (calib_data & 0x1ff) + 6963 - 4096 - 256; 918 data->vol_1000mv_adc = DIV_ROUND_CLOSEST(cal_4200mv * 10, 42); 919 data->cur_1000ma_adc = 920 DIV_ROUND_CLOSEST(data->vol_1000mv_adc * 4 * data->calib_resist, 921 SC27XX_FGU_IDEAL_RESISTANCE); 922 923 kfree(buf); 924 return 0; 925 } 926 927 static int sc27xx_fgu_hw_init(struct sc27xx_fgu_data *data) 928 { 929 struct power_supply_battery_info info = { }; 930 struct power_supply_battery_ocv_table *table; 931 int ret, delta_clbcnt, alarm_adc; 932 933 ret = power_supply_get_battery_info(data->battery, &info); 934 if (ret) { 935 dev_err(data->dev, "failed to get battery information\n"); 936 return ret; 937 } 938 939 data->total_cap = info.charge_full_design_uah / 1000; 940 data->max_volt = info.constant_charge_voltage_max_uv / 1000; 941 data->internal_resist = info.factory_internal_resistance_uohm / 1000; 942 data->min_volt = info.voltage_min_design_uv; 943 944 /* 945 * For SC27XX fuel gauge device, we only use one ocv-capacity 946 * table in normal temperature 20 Celsius. 947 */ 948 table = power_supply_find_ocv2cap_table(&info, 20, &data->table_len); 949 if (!table) 950 return -EINVAL; 951 952 data->cap_table = devm_kmemdup(data->dev, table, 953 data->table_len * sizeof(*table), 954 GFP_KERNEL); 955 if (!data->cap_table) { 956 power_supply_put_battery_info(data->battery, &info); 957 return -ENOMEM; 958 } 959 960 data->alarm_cap = power_supply_ocv2cap_simple(data->cap_table, 961 data->table_len, 962 data->min_volt); 963 if (!data->alarm_cap) 964 data->alarm_cap += 1; 965 966 data->resist_table_len = info.resist_table_size; 967 if (data->resist_table_len > 0) { 968 data->resist_table = devm_kmemdup(data->dev, info.resist_table, 969 data->resist_table_len * 970 sizeof(struct power_supply_resistance_temp_table), 971 GFP_KERNEL); 972 if (!data->resist_table) { 973 power_supply_put_battery_info(data->battery, &info); 974 return -ENOMEM; 975 } 976 } 977 978 power_supply_put_battery_info(data->battery, &info); 979 980 ret = sc27xx_fgu_calibration(data); 981 if (ret) 982 return ret; 983 984 /* Enable the FGU module */ 985 ret = regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, 986 SC27XX_FGU_EN, SC27XX_FGU_EN); 987 if (ret) { 988 dev_err(data->dev, "failed to enable fgu\n"); 989 return ret; 990 } 991 992 /* Enable the FGU RTC clock to make it work */ 993 ret = regmap_update_bits(data->regmap, SC27XX_CLK_EN0, 994 SC27XX_FGU_RTC_EN, SC27XX_FGU_RTC_EN); 995 if (ret) { 996 dev_err(data->dev, "failed to enable fgu RTC clock\n"); 997 goto disable_fgu; 998 } 999 1000 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_CLR, 1001 SC27XX_FGU_INT_MASK, SC27XX_FGU_INT_MASK); 1002 if (ret) { 1003 dev_err(data->dev, "failed to clear interrupt status\n"); 1004 goto disable_clk; 1005 } 1006 1007 /* 1008 * Set the voltage low overload threshold, which means when the battery 1009 * voltage is lower than this threshold, the controller will generate 1010 * one interrupt to notify. 1011 */ 1012 alarm_adc = sc27xx_fgu_voltage_to_adc(data, data->min_volt / 1000); 1013 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_LOW_OVERLOAD, 1014 SC27XX_FGU_LOW_OVERLOAD_MASK, alarm_adc); 1015 if (ret) { 1016 dev_err(data->dev, "failed to set fgu low overload\n"); 1017 goto disable_clk; 1018 } 1019 1020 /* 1021 * Set the coulomb counter delta threshold, that means when the coulomb 1022 * counter change is multiples of the delta threshold, the controller 1023 * will generate one interrupt to notify the users to update the battery 1024 * capacity. Now we set the delta threshold as a counter value of 1% 1025 * capacity. 1026 */ 1027 delta_clbcnt = sc27xx_fgu_cap_to_clbcnt(data, 1); 1028 1029 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_CLBCNT_DELTL, 1030 SC27XX_FGU_CLBCNT_MASK, delta_clbcnt); 1031 if (ret) { 1032 dev_err(data->dev, "failed to set low delta coulomb counter\n"); 1033 goto disable_clk; 1034 } 1035 1036 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_CLBCNT_DELTH, 1037 SC27XX_FGU_CLBCNT_MASK, 1038 delta_clbcnt >> SC27XX_FGU_CLBCNT_SHIFT); 1039 if (ret) { 1040 dev_err(data->dev, "failed to set high delta coulomb counter\n"); 1041 goto disable_clk; 1042 } 1043 1044 /* 1045 * Get the boot battery capacity when system powers on, which is used to 1046 * initialize the coulomb counter. After that, we can read the coulomb 1047 * counter to measure the battery capacity. 1048 */ 1049 ret = sc27xx_fgu_get_boot_capacity(data, &data->init_cap); 1050 if (ret) { 1051 dev_err(data->dev, "failed to get boot capacity\n"); 1052 goto disable_clk; 1053 } 1054 1055 /* 1056 * Convert battery capacity to the corresponding initial coulomb counter 1057 * and set into coulomb counter registers. 1058 */ 1059 data->init_clbcnt = sc27xx_fgu_cap_to_clbcnt(data, data->init_cap); 1060 ret = sc27xx_fgu_set_clbcnt(data, data->init_clbcnt); 1061 if (ret) { 1062 dev_err(data->dev, "failed to initialize coulomb counter\n"); 1063 goto disable_clk; 1064 } 1065 1066 return 0; 1067 1068 disable_clk: 1069 regmap_update_bits(data->regmap, SC27XX_CLK_EN0, SC27XX_FGU_RTC_EN, 0); 1070 disable_fgu: 1071 regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, SC27XX_FGU_EN, 0); 1072 1073 return ret; 1074 } 1075 1076 static int sc27xx_fgu_probe(struct platform_device *pdev) 1077 { 1078 struct device *dev = &pdev->dev; 1079 struct device_node *np = dev->of_node; 1080 struct power_supply_config fgu_cfg = { }; 1081 struct sc27xx_fgu_data *data; 1082 int ret, irq; 1083 1084 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 1085 if (!data) 1086 return -ENOMEM; 1087 1088 data->regmap = dev_get_regmap(dev->parent, NULL); 1089 if (!data->regmap) { 1090 dev_err(dev, "failed to get regmap\n"); 1091 return -ENODEV; 1092 } 1093 1094 ret = device_property_read_u32(dev, "reg", &data->base); 1095 if (ret) { 1096 dev_err(dev, "failed to get fgu address\n"); 1097 return ret; 1098 } 1099 1100 ret = device_property_read_u32(&pdev->dev, 1101 "sprd,calib-resistance-micro-ohms", 1102 &data->calib_resist); 1103 if (ret) { 1104 dev_err(&pdev->dev, 1105 "failed to get fgu calibration resistance\n"); 1106 return ret; 1107 } 1108 1109 data->channel = devm_iio_channel_get(dev, "bat-temp"); 1110 if (IS_ERR(data->channel)) { 1111 dev_err(dev, "failed to get IIO channel\n"); 1112 return PTR_ERR(data->channel); 1113 } 1114 1115 data->charge_chan = devm_iio_channel_get(dev, "charge-vol"); 1116 if (IS_ERR(data->charge_chan)) { 1117 dev_err(dev, "failed to get charge IIO channel\n"); 1118 return PTR_ERR(data->charge_chan); 1119 } 1120 1121 data->gpiod = devm_gpiod_get(dev, "bat-detect", GPIOD_IN); 1122 if (IS_ERR(data->gpiod)) { 1123 dev_err(dev, "failed to get battery detection GPIO\n"); 1124 return PTR_ERR(data->gpiod); 1125 } 1126 1127 ret = gpiod_get_value_cansleep(data->gpiod); 1128 if (ret < 0) { 1129 dev_err(dev, "failed to get gpio state\n"); 1130 return ret; 1131 } 1132 1133 data->bat_present = !!ret; 1134 mutex_init(&data->lock); 1135 data->dev = dev; 1136 platform_set_drvdata(pdev, data); 1137 1138 fgu_cfg.drv_data = data; 1139 fgu_cfg.of_node = np; 1140 data->battery = devm_power_supply_register(dev, &sc27xx_fgu_desc, 1141 &fgu_cfg); 1142 if (IS_ERR(data->battery)) { 1143 dev_err(dev, "failed to register power supply\n"); 1144 return PTR_ERR(data->battery); 1145 } 1146 1147 ret = sc27xx_fgu_hw_init(data); 1148 if (ret) { 1149 dev_err(dev, "failed to initialize fgu hardware\n"); 1150 return ret; 1151 } 1152 1153 ret = devm_add_action_or_reset(dev, sc27xx_fgu_disable, data); 1154 if (ret) { 1155 dev_err(dev, "failed to add fgu disable action\n"); 1156 return ret; 1157 } 1158 1159 irq = platform_get_irq(pdev, 0); 1160 if (irq < 0) { 1161 dev_err(dev, "no irq resource specified\n"); 1162 return irq; 1163 } 1164 1165 ret = devm_request_threaded_irq(data->dev, irq, NULL, 1166 sc27xx_fgu_interrupt, 1167 IRQF_NO_SUSPEND | IRQF_ONESHOT, 1168 pdev->name, data); 1169 if (ret) { 1170 dev_err(data->dev, "failed to request fgu IRQ\n"); 1171 return ret; 1172 } 1173 1174 irq = gpiod_to_irq(data->gpiod); 1175 if (irq < 0) { 1176 dev_err(dev, "failed to translate GPIO to IRQ\n"); 1177 return irq; 1178 } 1179 1180 ret = devm_request_threaded_irq(dev, irq, NULL, 1181 sc27xx_fgu_bat_detection, 1182 IRQF_ONESHOT | IRQF_TRIGGER_RISING | 1183 IRQF_TRIGGER_FALLING, 1184 pdev->name, data); 1185 if (ret) { 1186 dev_err(dev, "failed to request IRQ\n"); 1187 return ret; 1188 } 1189 1190 return 0; 1191 } 1192 1193 #ifdef CONFIG_PM_SLEEP 1194 static int sc27xx_fgu_resume(struct device *dev) 1195 { 1196 struct sc27xx_fgu_data *data = dev_get_drvdata(dev); 1197 int ret; 1198 1199 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN, 1200 SC27XX_FGU_LOW_OVERLOAD_INT | 1201 SC27XX_FGU_CLBCNT_DELTA_INT, 0); 1202 if (ret) { 1203 dev_err(data->dev, "failed to disable fgu interrupts\n"); 1204 return ret; 1205 } 1206 1207 return 0; 1208 } 1209 1210 static int sc27xx_fgu_suspend(struct device *dev) 1211 { 1212 struct sc27xx_fgu_data *data = dev_get_drvdata(dev); 1213 int ret, status, ocv; 1214 1215 ret = sc27xx_fgu_get_status(data, &status); 1216 if (ret) 1217 return ret; 1218 1219 /* 1220 * If we are charging, then no need to enable the FGU interrupts to 1221 * adjust the battery capacity. 1222 */ 1223 if (status != POWER_SUPPLY_STATUS_NOT_CHARGING && 1224 status != POWER_SUPPLY_STATUS_DISCHARGING) 1225 return 0; 1226 1227 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN, 1228 SC27XX_FGU_LOW_OVERLOAD_INT, 1229 SC27XX_FGU_LOW_OVERLOAD_INT); 1230 if (ret) { 1231 dev_err(data->dev, "failed to enable low voltage interrupt\n"); 1232 return ret; 1233 } 1234 1235 ret = sc27xx_fgu_get_vbat_ocv(data, &ocv); 1236 if (ret) 1237 goto disable_int; 1238 1239 /* 1240 * If current OCV is less than the minimum voltage, we should enable the 1241 * coulomb counter threshold interrupt to notify events to adjust the 1242 * battery capacity. 1243 */ 1244 if (ocv < data->min_volt) { 1245 ret = regmap_update_bits(data->regmap, 1246 data->base + SC27XX_FGU_INT_EN, 1247 SC27XX_FGU_CLBCNT_DELTA_INT, 1248 SC27XX_FGU_CLBCNT_DELTA_INT); 1249 if (ret) { 1250 dev_err(data->dev, 1251 "failed to enable coulomb threshold int\n"); 1252 goto disable_int; 1253 } 1254 } 1255 1256 return 0; 1257 1258 disable_int: 1259 regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN, 1260 SC27XX_FGU_LOW_OVERLOAD_INT, 0); 1261 return ret; 1262 } 1263 #endif 1264 1265 static const struct dev_pm_ops sc27xx_fgu_pm_ops = { 1266 SET_SYSTEM_SLEEP_PM_OPS(sc27xx_fgu_suspend, sc27xx_fgu_resume) 1267 }; 1268 1269 static const struct of_device_id sc27xx_fgu_of_match[] = { 1270 { .compatible = "sprd,sc2731-fgu", }, 1271 { } 1272 }; 1273 1274 static struct platform_driver sc27xx_fgu_driver = { 1275 .probe = sc27xx_fgu_probe, 1276 .driver = { 1277 .name = "sc27xx-fgu", 1278 .of_match_table = sc27xx_fgu_of_match, 1279 .pm = &sc27xx_fgu_pm_ops, 1280 } 1281 }; 1282 1283 module_platform_driver(sc27xx_fgu_driver); 1284 1285 MODULE_DESCRIPTION("Spreadtrum SC27XX PMICs Fual Gauge Unit Driver"); 1286 MODULE_LICENSE("GPL v2"); 1287