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