1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) ST-Ericsson AB 2012 4 * 5 * Main and Back-up battery management driver. 6 * 7 * Note: Backup battery management is required in case of Li-Ion battery and not 8 * for capacitive battery. HREF boards have capacitive battery and hence backup 9 * battery management is not used and the supported code is available in this 10 * driver. 11 * 12 * Author: 13 * Johan Palsson <johan.palsson@stericsson.com> 14 * Karl Komierowski <karl.komierowski@stericsson.com> 15 * Arun R Murthy <arun.murthy@stericsson.com> 16 */ 17 18 #include <linux/init.h> 19 #include <linux/module.h> 20 #include <linux/component.h> 21 #include <linux/device.h> 22 #include <linux/interrupt.h> 23 #include <linux/platform_device.h> 24 #include <linux/power_supply.h> 25 #include <linux/kobject.h> 26 #include <linux/slab.h> 27 #include <linux/delay.h> 28 #include <linux/time.h> 29 #include <linux/time64.h> 30 #include <linux/of.h> 31 #include <linux/completion.h> 32 #include <linux/mfd/core.h> 33 #include <linux/mfd/abx500.h> 34 #include <linux/mfd/abx500/ab8500.h> 35 #include <linux/iio/consumer.h> 36 #include <linux/kernel.h> 37 #include <linux/fixp-arith.h> 38 39 #include "ab8500-bm.h" 40 41 #define FG_LSB_IN_MA 1627 42 #define QLSB_NANO_AMP_HOURS_X10 1071 43 #define INS_CURR_TIMEOUT (3 * HZ) 44 45 #define SEC_TO_SAMPLE(S) (S * 4) 46 47 #define NBR_AVG_SAMPLES 20 48 #define WAIT_FOR_INST_CURRENT_MAX 70 49 50 #define LOW_BAT_CHECK_INTERVAL (HZ / 16) /* 62.5 ms */ 51 52 #define VALID_CAPACITY_SEC (45 * 60) /* 45 minutes */ 53 #define BATT_OK_MIN 2360 /* mV */ 54 #define BATT_OK_INCREMENT 50 /* mV */ 55 #define BATT_OK_MAX_NR_INCREMENTS 0xE 56 57 /* FG constants */ 58 #define BATT_OVV 0x01 59 60 /** 61 * struct ab8500_fg_interrupts - ab8500 fg interrupts 62 * @name: name of the interrupt 63 * @isr function pointer to the isr 64 */ 65 struct ab8500_fg_interrupts { 66 char *name; 67 irqreturn_t (*isr)(int irq, void *data); 68 }; 69 70 enum ab8500_fg_discharge_state { 71 AB8500_FG_DISCHARGE_INIT, 72 AB8500_FG_DISCHARGE_INITMEASURING, 73 AB8500_FG_DISCHARGE_INIT_RECOVERY, 74 AB8500_FG_DISCHARGE_RECOVERY, 75 AB8500_FG_DISCHARGE_READOUT_INIT, 76 AB8500_FG_DISCHARGE_READOUT, 77 AB8500_FG_DISCHARGE_WAKEUP, 78 }; 79 80 static char *discharge_state[] = { 81 "DISCHARGE_INIT", 82 "DISCHARGE_INITMEASURING", 83 "DISCHARGE_INIT_RECOVERY", 84 "DISCHARGE_RECOVERY", 85 "DISCHARGE_READOUT_INIT", 86 "DISCHARGE_READOUT", 87 "DISCHARGE_WAKEUP", 88 }; 89 90 enum ab8500_fg_charge_state { 91 AB8500_FG_CHARGE_INIT, 92 AB8500_FG_CHARGE_READOUT, 93 }; 94 95 static char *charge_state[] = { 96 "CHARGE_INIT", 97 "CHARGE_READOUT", 98 }; 99 100 enum ab8500_fg_calibration_state { 101 AB8500_FG_CALIB_INIT, 102 AB8500_FG_CALIB_WAIT, 103 AB8500_FG_CALIB_END, 104 }; 105 106 struct ab8500_fg_avg_cap { 107 int avg; 108 int samples[NBR_AVG_SAMPLES]; 109 time64_t time_stamps[NBR_AVG_SAMPLES]; 110 int pos; 111 int nbr_samples; 112 int sum; 113 }; 114 115 struct ab8500_fg_cap_scaling { 116 bool enable; 117 int cap_to_scale[2]; 118 int disable_cap_level; 119 int scaled_cap; 120 }; 121 122 struct ab8500_fg_battery_capacity { 123 int max_mah_design; 124 int max_mah; 125 int mah; 126 int permille; 127 int level; 128 int prev_mah; 129 int prev_percent; 130 int prev_level; 131 int user_mah; 132 struct ab8500_fg_cap_scaling cap_scale; 133 }; 134 135 struct ab8500_fg_flags { 136 bool fg_enabled; 137 bool conv_done; 138 bool charging; 139 bool fully_charged; 140 bool force_full; 141 bool low_bat_delay; 142 bool low_bat; 143 bool bat_ovv; 144 bool batt_unknown; 145 bool calibrate; 146 bool user_cap; 147 bool batt_id_received; 148 }; 149 150 struct inst_curr_result_list { 151 struct list_head list; 152 int *result; 153 }; 154 155 /** 156 * struct ab8500_fg - ab8500 FG device information 157 * @dev: Pointer to the structure device 158 * @node: a list of AB8500 FGs, hence prepared for reentrance 159 * @irq holds the CCEOC interrupt number 160 * @vbat_uv: Battery voltage in uV 161 * @vbat_nom_uv: Nominal battery voltage in uV 162 * @inst_curr_ua: Instantenous battery current in uA 163 * @avg_curr_ua: Average battery current in uA 164 * @bat_temp battery temperature 165 * @fg_samples: Number of samples used in the FG accumulation 166 * @accu_charge: Accumulated charge from the last conversion 167 * @recovery_cnt: Counter for recovery mode 168 * @high_curr_cnt: Counter for high current mode 169 * @init_cnt: Counter for init mode 170 * @low_bat_cnt Counter for number of consecutive low battery measures 171 * @nbr_cceoc_irq_cnt Counter for number of CCEOC irqs received since enabled 172 * @recovery_needed: Indicate if recovery is needed 173 * @high_curr_mode: Indicate if we're in high current mode 174 * @init_capacity: Indicate if initial capacity measuring should be done 175 * @turn_off_fg: True if fg was off before current measurement 176 * @calib_state State during offset calibration 177 * @discharge_state: Current discharge state 178 * @charge_state: Current charge state 179 * @ab8500_fg_started Completion struct used for the instant current start 180 * @ab8500_fg_complete Completion struct used for the instant current reading 181 * @flags: Structure for information about events triggered 182 * @bat_cap: Structure for battery capacity specific parameters 183 * @avg_cap: Average capacity filter 184 * @parent: Pointer to the struct ab8500 185 * @main_bat_v: ADC channel for the main battery voltage 186 * @bm: Platform specific battery management information 187 * @fg_psy: Structure that holds the FG specific battery properties 188 * @fg_wq: Work queue for running the FG algorithm 189 * @fg_periodic_work: Work to run the FG algorithm periodically 190 * @fg_low_bat_work: Work to check low bat condition 191 * @fg_reinit_work Work used to reset and reinitialise the FG algorithm 192 * @fg_work: Work to run the FG algorithm instantly 193 * @fg_acc_cur_work: Work to read the FG accumulator 194 * @fg_check_hw_failure_work: Work for checking HW state 195 * @cc_lock: Mutex for locking the CC 196 * @fg_kobject: Structure of type kobject 197 */ 198 struct ab8500_fg { 199 struct device *dev; 200 struct list_head node; 201 int irq; 202 int vbat_uv; 203 int vbat_nom_uv; 204 int inst_curr_ua; 205 int avg_curr_ua; 206 int bat_temp; 207 int fg_samples; 208 int accu_charge; 209 int recovery_cnt; 210 int high_curr_cnt; 211 int init_cnt; 212 int low_bat_cnt; 213 int nbr_cceoc_irq_cnt; 214 bool recovery_needed; 215 bool high_curr_mode; 216 bool init_capacity; 217 bool turn_off_fg; 218 enum ab8500_fg_calibration_state calib_state; 219 enum ab8500_fg_discharge_state discharge_state; 220 enum ab8500_fg_charge_state charge_state; 221 struct completion ab8500_fg_started; 222 struct completion ab8500_fg_complete; 223 struct ab8500_fg_flags flags; 224 struct ab8500_fg_battery_capacity bat_cap; 225 struct ab8500_fg_avg_cap avg_cap; 226 struct ab8500 *parent; 227 struct iio_channel *main_bat_v; 228 struct ab8500_bm_data *bm; 229 struct power_supply *fg_psy; 230 struct workqueue_struct *fg_wq; 231 struct delayed_work fg_periodic_work; 232 struct delayed_work fg_low_bat_work; 233 struct delayed_work fg_reinit_work; 234 struct work_struct fg_work; 235 struct work_struct fg_acc_cur_work; 236 struct delayed_work fg_check_hw_failure_work; 237 struct mutex cc_lock; 238 struct kobject fg_kobject; 239 }; 240 static LIST_HEAD(ab8500_fg_list); 241 242 /** 243 * ab8500_fg_get() - returns a reference to the primary AB8500 fuel gauge 244 * (i.e. the first fuel gauge in the instance list) 245 */ 246 struct ab8500_fg *ab8500_fg_get(void) 247 { 248 return list_first_entry_or_null(&ab8500_fg_list, struct ab8500_fg, 249 node); 250 } 251 252 /* Main battery properties */ 253 static enum power_supply_property ab8500_fg_props[] = { 254 POWER_SUPPLY_PROP_VOLTAGE_NOW, 255 POWER_SUPPLY_PROP_CURRENT_NOW, 256 POWER_SUPPLY_PROP_CURRENT_AVG, 257 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 258 POWER_SUPPLY_PROP_ENERGY_FULL, 259 POWER_SUPPLY_PROP_ENERGY_NOW, 260 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 261 POWER_SUPPLY_PROP_CHARGE_FULL, 262 POWER_SUPPLY_PROP_CHARGE_NOW, 263 POWER_SUPPLY_PROP_CAPACITY, 264 POWER_SUPPLY_PROP_CAPACITY_LEVEL, 265 }; 266 267 /* 268 * This array maps the raw hex value to lowbat voltage used by the AB8500 269 * Values taken from the UM0836, in microvolts. 270 */ 271 static int ab8500_fg_lowbat_voltage_map[] = { 272 2300000, 273 2325000, 274 2350000, 275 2375000, 276 2400000, 277 2425000, 278 2450000, 279 2475000, 280 2500000, 281 2525000, 282 2550000, 283 2575000, 284 2600000, 285 2625000, 286 2650000, 287 2675000, 288 2700000, 289 2725000, 290 2750000, 291 2775000, 292 2800000, 293 2825000, 294 2850000, 295 2875000, 296 2900000, 297 2925000, 298 2950000, 299 2975000, 300 3000000, 301 3025000, 302 3050000, 303 3075000, 304 3100000, 305 3125000, 306 3150000, 307 3175000, 308 3200000, 309 3225000, 310 3250000, 311 3275000, 312 3300000, 313 3325000, 314 3350000, 315 3375000, 316 3400000, 317 3425000, 318 3450000, 319 3475000, 320 3500000, 321 3525000, 322 3550000, 323 3575000, 324 3600000, 325 3625000, 326 3650000, 327 3675000, 328 3700000, 329 3725000, 330 3750000, 331 3775000, 332 3800000, 333 3825000, 334 3850000, 335 3850000, 336 }; 337 338 static u8 ab8500_volt_to_regval(int voltage_uv) 339 { 340 int i; 341 342 if (voltage_uv < ab8500_fg_lowbat_voltage_map[0]) 343 return 0; 344 345 for (i = 0; i < ARRAY_SIZE(ab8500_fg_lowbat_voltage_map); i++) { 346 if (voltage_uv < ab8500_fg_lowbat_voltage_map[i]) 347 return (u8) i - 1; 348 } 349 350 /* If not captured above, return index of last element */ 351 return (u8) ARRAY_SIZE(ab8500_fg_lowbat_voltage_map) - 1; 352 } 353 354 /** 355 * ab8500_fg_is_low_curr() - Low or high current mode 356 * @di: pointer to the ab8500_fg structure 357 * @curr_ua: the current to base or our decision on in microampere 358 * 359 * Low current mode if the current consumption is below a certain threshold 360 */ 361 static int ab8500_fg_is_low_curr(struct ab8500_fg *di, int curr_ua) 362 { 363 /* 364 * We want to know if we're in low current mode 365 */ 366 if (curr_ua > -di->bm->fg_params->high_curr_threshold_ua) 367 return true; 368 else 369 return false; 370 } 371 372 /** 373 * ab8500_fg_add_cap_sample() - Add capacity to average filter 374 * @di: pointer to the ab8500_fg structure 375 * @sample: the capacity in mAh to add to the filter 376 * 377 * A capacity is added to the filter and a new mean capacity is calculated and 378 * returned 379 */ 380 static int ab8500_fg_add_cap_sample(struct ab8500_fg *di, int sample) 381 { 382 time64_t now = ktime_get_boottime_seconds(); 383 struct ab8500_fg_avg_cap *avg = &di->avg_cap; 384 385 do { 386 avg->sum += sample - avg->samples[avg->pos]; 387 avg->samples[avg->pos] = sample; 388 avg->time_stamps[avg->pos] = now; 389 avg->pos++; 390 391 if (avg->pos == NBR_AVG_SAMPLES) 392 avg->pos = 0; 393 394 if (avg->nbr_samples < NBR_AVG_SAMPLES) 395 avg->nbr_samples++; 396 397 /* 398 * Check the time stamp for each sample. If too old, 399 * replace with latest sample 400 */ 401 } while (now - VALID_CAPACITY_SEC > avg->time_stamps[avg->pos]); 402 403 avg->avg = avg->sum / avg->nbr_samples; 404 405 return avg->avg; 406 } 407 408 /** 409 * ab8500_fg_clear_cap_samples() - Clear average filter 410 * @di: pointer to the ab8500_fg structure 411 * 412 * The capacity filter is is reset to zero. 413 */ 414 static void ab8500_fg_clear_cap_samples(struct ab8500_fg *di) 415 { 416 int i; 417 struct ab8500_fg_avg_cap *avg = &di->avg_cap; 418 419 avg->pos = 0; 420 avg->nbr_samples = 0; 421 avg->sum = 0; 422 avg->avg = 0; 423 424 for (i = 0; i < NBR_AVG_SAMPLES; i++) { 425 avg->samples[i] = 0; 426 avg->time_stamps[i] = 0; 427 } 428 } 429 430 /** 431 * ab8500_fg_fill_cap_sample() - Fill average filter 432 * @di: pointer to the ab8500_fg structure 433 * @sample: the capacity in mAh to fill the filter with 434 * 435 * The capacity filter is filled with a capacity in mAh 436 */ 437 static void ab8500_fg_fill_cap_sample(struct ab8500_fg *di, int sample) 438 { 439 int i; 440 time64_t now; 441 struct ab8500_fg_avg_cap *avg = &di->avg_cap; 442 443 now = ktime_get_boottime_seconds(); 444 445 for (i = 0; i < NBR_AVG_SAMPLES; i++) { 446 avg->samples[i] = sample; 447 avg->time_stamps[i] = now; 448 } 449 450 avg->pos = 0; 451 avg->nbr_samples = NBR_AVG_SAMPLES; 452 avg->sum = sample * NBR_AVG_SAMPLES; 453 avg->avg = sample; 454 } 455 456 /** 457 * ab8500_fg_coulomb_counter() - enable coulomb counter 458 * @di: pointer to the ab8500_fg structure 459 * @enable: enable/disable 460 * 461 * Enable/Disable coulomb counter. 462 * On failure returns negative value. 463 */ 464 static int ab8500_fg_coulomb_counter(struct ab8500_fg *di, bool enable) 465 { 466 int ret = 0; 467 mutex_lock(&di->cc_lock); 468 if (enable) { 469 /* To be able to reprogram the number of samples, we have to 470 * first stop the CC and then enable it again */ 471 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 472 AB8500_RTC_CC_CONF_REG, 0x00); 473 if (ret) 474 goto cc_err; 475 476 /* Program the samples */ 477 ret = abx500_set_register_interruptible(di->dev, 478 AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU, 479 di->fg_samples); 480 if (ret) 481 goto cc_err; 482 483 /* Start the CC */ 484 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 485 AB8500_RTC_CC_CONF_REG, 486 (CC_DEEP_SLEEP_ENA | CC_PWR_UP_ENA)); 487 if (ret) 488 goto cc_err; 489 490 di->flags.fg_enabled = true; 491 } else { 492 /* Clear any pending read requests */ 493 ret = abx500_mask_and_set_register_interruptible(di->dev, 494 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG, 495 (RESET_ACCU | READ_REQ), 0); 496 if (ret) 497 goto cc_err; 498 499 ret = abx500_set_register_interruptible(di->dev, 500 AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU_CTRL, 0); 501 if (ret) 502 goto cc_err; 503 504 /* Stop the CC */ 505 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 506 AB8500_RTC_CC_CONF_REG, 0); 507 if (ret) 508 goto cc_err; 509 510 di->flags.fg_enabled = false; 511 512 } 513 dev_dbg(di->dev, " CC enabled: %d Samples: %d\n", 514 enable, di->fg_samples); 515 516 mutex_unlock(&di->cc_lock); 517 518 return ret; 519 cc_err: 520 dev_err(di->dev, "%s Enabling coulomb counter failed\n", __func__); 521 mutex_unlock(&di->cc_lock); 522 return ret; 523 } 524 525 /** 526 * ab8500_fg_inst_curr_start() - start battery instantaneous current 527 * @di: pointer to the ab8500_fg structure 528 * 529 * Returns 0 or error code 530 * Note: This is part "one" and has to be called before 531 * ab8500_fg_inst_curr_finalize() 532 */ 533 int ab8500_fg_inst_curr_start(struct ab8500_fg *di) 534 { 535 u8 reg_val; 536 int ret; 537 538 mutex_lock(&di->cc_lock); 539 540 di->nbr_cceoc_irq_cnt = 0; 541 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 542 AB8500_RTC_CC_CONF_REG, ®_val); 543 if (ret < 0) 544 goto fail; 545 546 if (!(reg_val & CC_PWR_UP_ENA)) { 547 dev_dbg(di->dev, "%s Enable FG\n", __func__); 548 di->turn_off_fg = true; 549 550 /* Program the samples */ 551 ret = abx500_set_register_interruptible(di->dev, 552 AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU, 553 SEC_TO_SAMPLE(10)); 554 if (ret) 555 goto fail; 556 557 /* Start the CC */ 558 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 559 AB8500_RTC_CC_CONF_REG, 560 (CC_DEEP_SLEEP_ENA | CC_PWR_UP_ENA)); 561 if (ret) 562 goto fail; 563 } else { 564 di->turn_off_fg = false; 565 } 566 567 /* Return and WFI */ 568 reinit_completion(&di->ab8500_fg_started); 569 reinit_completion(&di->ab8500_fg_complete); 570 enable_irq(di->irq); 571 572 /* Note: cc_lock is still locked */ 573 return 0; 574 fail: 575 mutex_unlock(&di->cc_lock); 576 return ret; 577 } 578 579 /** 580 * ab8500_fg_inst_curr_started() - check if fg conversion has started 581 * @di: pointer to the ab8500_fg structure 582 * 583 * Returns 1 if conversion started, 0 if still waiting 584 */ 585 int ab8500_fg_inst_curr_started(struct ab8500_fg *di) 586 { 587 return completion_done(&di->ab8500_fg_started); 588 } 589 590 /** 591 * ab8500_fg_inst_curr_done() - check if fg conversion is done 592 * @di: pointer to the ab8500_fg structure 593 * 594 * Returns 1 if conversion done, 0 if still waiting 595 */ 596 int ab8500_fg_inst_curr_done(struct ab8500_fg *di) 597 { 598 return completion_done(&di->ab8500_fg_complete); 599 } 600 601 /** 602 * ab8500_fg_inst_curr_finalize() - battery instantaneous current 603 * @di: pointer to the ab8500_fg structure 604 * @curr_ua: battery instantenous current in microampere (on success) 605 * 606 * Returns 0 or an error code 607 * Note: This is part "two" and has to be called at earliest 250 ms 608 * after ab8500_fg_inst_curr_start() 609 */ 610 int ab8500_fg_inst_curr_finalize(struct ab8500_fg *di, int *curr_ua) 611 { 612 u8 low, high; 613 int val; 614 int ret; 615 unsigned long timeout; 616 617 if (!completion_done(&di->ab8500_fg_complete)) { 618 timeout = wait_for_completion_timeout( 619 &di->ab8500_fg_complete, 620 INS_CURR_TIMEOUT); 621 dev_dbg(di->dev, "Finalize time: %d ms\n", 622 jiffies_to_msecs(INS_CURR_TIMEOUT - timeout)); 623 if (!timeout) { 624 ret = -ETIME; 625 disable_irq(di->irq); 626 di->nbr_cceoc_irq_cnt = 0; 627 dev_err(di->dev, "completion timed out [%d]\n", 628 __LINE__); 629 goto fail; 630 } 631 } 632 633 disable_irq(di->irq); 634 di->nbr_cceoc_irq_cnt = 0; 635 636 ret = abx500_mask_and_set_register_interruptible(di->dev, 637 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG, 638 READ_REQ, READ_REQ); 639 640 /* 100uS between read request and read is needed */ 641 usleep_range(100, 100); 642 643 /* Read CC Sample conversion value Low and high */ 644 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE, 645 AB8500_GASG_CC_SMPL_CNVL_REG, &low); 646 if (ret < 0) 647 goto fail; 648 649 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE, 650 AB8500_GASG_CC_SMPL_CNVH_REG, &high); 651 if (ret < 0) 652 goto fail; 653 654 /* 655 * negative value for Discharging 656 * convert 2's complement into decimal 657 */ 658 if (high & 0x10) 659 val = (low | (high << 8) | 0xFFFFE000); 660 else 661 val = (low | (high << 8)); 662 663 /* 664 * Convert to unit value in mA 665 * Full scale input voltage is 666 * 63.160mV => LSB = 63.160mV/(4096*res) = 1.542.000 uA 667 * Given a 250ms conversion cycle time the LSB corresponds 668 * to 107.1 nAh. Convert to current by dividing by the conversion 669 * time in hours (250ms = 1 / (3600 * 4)h) 670 * 107.1nAh assumes 10mOhm, but fg_res is in 0.1mOhm 671 */ 672 val = (val * QLSB_NANO_AMP_HOURS_X10 * 36 * 4) / di->bm->fg_res; 673 674 if (di->turn_off_fg) { 675 dev_dbg(di->dev, "%s Disable FG\n", __func__); 676 677 /* Clear any pending read requests */ 678 ret = abx500_set_register_interruptible(di->dev, 679 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG, 0); 680 if (ret) 681 goto fail; 682 683 /* Stop the CC */ 684 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 685 AB8500_RTC_CC_CONF_REG, 0); 686 if (ret) 687 goto fail; 688 } 689 mutex_unlock(&di->cc_lock); 690 *curr_ua = val; 691 692 return 0; 693 fail: 694 mutex_unlock(&di->cc_lock); 695 return ret; 696 } 697 698 /** 699 * ab8500_fg_inst_curr_blocking() - battery instantaneous current 700 * @di: pointer to the ab8500_fg structure 701 * 702 * Returns battery instantenous current in microampere (on success) 703 * else error code 704 */ 705 int ab8500_fg_inst_curr_blocking(struct ab8500_fg *di) 706 { 707 int ret; 708 unsigned long timeout; 709 int curr_ua = 0; 710 711 ret = ab8500_fg_inst_curr_start(di); 712 if (ret) { 713 dev_err(di->dev, "Failed to initialize fg_inst\n"); 714 return 0; 715 } 716 717 /* Wait for CC to actually start */ 718 if (!completion_done(&di->ab8500_fg_started)) { 719 timeout = wait_for_completion_timeout( 720 &di->ab8500_fg_started, 721 INS_CURR_TIMEOUT); 722 dev_dbg(di->dev, "Start time: %d ms\n", 723 jiffies_to_msecs(INS_CURR_TIMEOUT - timeout)); 724 if (!timeout) { 725 ret = -ETIME; 726 dev_err(di->dev, "completion timed out [%d]\n", 727 __LINE__); 728 goto fail; 729 } 730 } 731 732 ret = ab8500_fg_inst_curr_finalize(di, &curr_ua); 733 if (ret) { 734 dev_err(di->dev, "Failed to finalize fg_inst\n"); 735 return 0; 736 } 737 738 dev_dbg(di->dev, "%s instant current: %d uA", __func__, curr_ua); 739 return curr_ua; 740 fail: 741 disable_irq(di->irq); 742 mutex_unlock(&di->cc_lock); 743 return ret; 744 } 745 746 /** 747 * ab8500_fg_acc_cur_work() - average battery current 748 * @work: pointer to the work_struct structure 749 * 750 * Updated the average battery current obtained from the 751 * coulomb counter. 752 */ 753 static void ab8500_fg_acc_cur_work(struct work_struct *work) 754 { 755 int val; 756 int ret; 757 u8 low, med, high; 758 759 struct ab8500_fg *di = container_of(work, 760 struct ab8500_fg, fg_acc_cur_work); 761 762 mutex_lock(&di->cc_lock); 763 ret = abx500_set_register_interruptible(di->dev, AB8500_GAS_GAUGE, 764 AB8500_GASG_CC_NCOV_ACCU_CTRL, RD_NCONV_ACCU_REQ); 765 if (ret) 766 goto exit; 767 768 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE, 769 AB8500_GASG_CC_NCOV_ACCU_LOW, &low); 770 if (ret < 0) 771 goto exit; 772 773 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE, 774 AB8500_GASG_CC_NCOV_ACCU_MED, &med); 775 if (ret < 0) 776 goto exit; 777 778 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE, 779 AB8500_GASG_CC_NCOV_ACCU_HIGH, &high); 780 if (ret < 0) 781 goto exit; 782 783 /* Check for sign bit in case of negative value, 2's complement */ 784 if (high & 0x10) 785 val = (low | (med << 8) | (high << 16) | 0xFFE00000); 786 else 787 val = (low | (med << 8) | (high << 16)); 788 789 /* 790 * Convert to uAh 791 * Given a 250ms conversion cycle time the LSB corresponds 792 * to 112.9 nAh. 793 * 112.9nAh assumes 10mOhm, but fg_res is in 0.1mOhm 794 */ 795 di->accu_charge = (val * QLSB_NANO_AMP_HOURS_X10) / 796 (100 * di->bm->fg_res); 797 798 /* 799 * Convert to unit value in uA 800 * by dividing by the conversion 801 * time in hours (= samples / (3600 * 4)h) 802 */ 803 di->avg_curr_ua = (val * QLSB_NANO_AMP_HOURS_X10 * 36) / 804 (di->bm->fg_res * (di->fg_samples / 4)); 805 806 di->flags.conv_done = true; 807 808 mutex_unlock(&di->cc_lock); 809 810 queue_work(di->fg_wq, &di->fg_work); 811 812 dev_dbg(di->dev, "fg_res: %d, fg_samples: %d, gasg: %d, accu_charge: %d \n", 813 di->bm->fg_res, di->fg_samples, val, di->accu_charge); 814 return; 815 exit: 816 dev_err(di->dev, 817 "Failed to read or write gas gauge registers\n"); 818 mutex_unlock(&di->cc_lock); 819 queue_work(di->fg_wq, &di->fg_work); 820 } 821 822 /** 823 * ab8500_fg_bat_voltage() - get battery voltage 824 * @di: pointer to the ab8500_fg structure 825 * 826 * Returns battery voltage in microvolts (on success) else error code 827 */ 828 static int ab8500_fg_bat_voltage(struct ab8500_fg *di) 829 { 830 int vbat, ret; 831 static int prev; 832 833 ret = iio_read_channel_processed(di->main_bat_v, &vbat); 834 if (ret < 0) { 835 dev_err(di->dev, 836 "%s ADC conversion failed, using previous value\n", 837 __func__); 838 return prev; 839 } 840 841 /* IIO returns millivolts but we want microvolts */ 842 vbat *= 1000; 843 prev = vbat; 844 return vbat; 845 } 846 847 /** 848 * ab8500_fg_volt_to_capacity() - Voltage based capacity 849 * @di: pointer to the ab8500_fg structure 850 * @voltage_uv: The voltage to convert to a capacity in microvolt 851 * 852 * Returns battery capacity in per mille based on voltage 853 */ 854 static int ab8500_fg_volt_to_capacity(struct ab8500_fg *di, int voltage_uv) 855 { 856 struct power_supply_battery_info *bi = di->bm->bi; 857 858 /* Multiply by 10 because the capacity is tracked in per mille */ 859 return power_supply_batinfo_ocv2cap(bi, voltage_uv, di->bat_temp) * 10; 860 } 861 862 /** 863 * ab8500_fg_uncomp_volt_to_capacity() - Uncompensated voltage based capacity 864 * @di: pointer to the ab8500_fg structure 865 * 866 * Returns battery capacity based on battery voltage that is not compensated 867 * for the voltage drop due to the load 868 */ 869 static int ab8500_fg_uncomp_volt_to_capacity(struct ab8500_fg *di) 870 { 871 di->vbat_uv = ab8500_fg_bat_voltage(di); 872 return ab8500_fg_volt_to_capacity(di, di->vbat_uv); 873 } 874 875 /** 876 * ab8500_fg_battery_resistance() - Returns the battery inner resistance 877 * @di: pointer to the ab8500_fg structure 878 * 879 * Returns battery inner resistance added with the fuel gauge resistor value 880 * to get the total resistance in the whole link from gnd to bat+ node 881 * in milliohm. 882 */ 883 static int ab8500_fg_battery_resistance(struct ab8500_fg *di) 884 { 885 struct power_supply_battery_info *bi = di->bm->bi; 886 int resistance_percent = 0; 887 int resistance; 888 889 resistance_percent = power_supply_temp2resist_simple(bi->resist_table, 890 bi->resist_table_size, 891 di->bat_temp / 10); 892 /* 893 * We get a percentage of factory resistance here so first get 894 * the factory resistance in milliohms then calculate how much 895 * resistance we have at this temperature. 896 */ 897 resistance = (bi->factory_internal_resistance_uohm / 1000); 898 resistance = resistance * resistance_percent / 100; 899 900 dev_dbg(di->dev, "%s Temp: %d battery internal resistance: %d" 901 " fg resistance %d, total: %d (mOhm)\n", 902 __func__, di->bat_temp, resistance, di->bm->fg_res / 10, 903 (di->bm->fg_res / 10) + resistance); 904 905 /* fg_res variable is in 0.1mOhm */ 906 resistance += di->bm->fg_res / 10; 907 908 return resistance; 909 } 910 911 /** 912 * ab8500_load_comp_fg_bat_voltage() - get load compensated battery voltage 913 * @di: pointer to the ab8500_fg structure 914 * 915 * Returns compensated battery voltage (on success) else error code. 916 * If always is specified, we always return a voltage but it may be 917 * uncompensated. 918 */ 919 static int ab8500_load_comp_fg_bat_voltage(struct ab8500_fg *di) 920 { 921 int i = 0; 922 int vbat_uv = 0; 923 int rcomp; 924 925 /* Average the instant current to get a stable current measurement */ 926 ab8500_fg_inst_curr_start(di); 927 928 do { 929 vbat_uv += ab8500_fg_bat_voltage(di); 930 i++; 931 usleep_range(5000, 6000); 932 } while (!ab8500_fg_inst_curr_done(di) && 933 i <= WAIT_FOR_INST_CURRENT_MAX); 934 935 if (i > WAIT_FOR_INST_CURRENT_MAX) { 936 dev_err(di->dev, 937 "TIMEOUT: return uncompensated measurement of VBAT\n"); 938 di->vbat_uv = vbat_uv / i; 939 return di->vbat_uv; 940 } 941 942 ab8500_fg_inst_curr_finalize(di, &di->inst_curr_ua); 943 944 vbat_uv = vbat_uv / i; 945 946 /* Next we apply voltage compensation from internal resistance */ 947 rcomp = ab8500_fg_battery_resistance(di); 948 vbat_uv = vbat_uv - (di->inst_curr_ua * rcomp) / 1000; 949 950 /* Always keep this state at latest measurement */ 951 di->vbat_uv = vbat_uv; 952 953 return vbat_uv; 954 } 955 956 /** 957 * ab8500_fg_load_comp_volt_to_capacity() - Load compensated voltage based capacity 958 * @di: pointer to the ab8500_fg structure 959 * 960 * Returns battery capacity based on battery voltage that is load compensated 961 * for the voltage drop 962 */ 963 static int ab8500_fg_load_comp_volt_to_capacity(struct ab8500_fg *di) 964 { 965 int vbat_comp_uv; 966 967 vbat_comp_uv = ab8500_load_comp_fg_bat_voltage(di); 968 969 return ab8500_fg_volt_to_capacity(di, vbat_comp_uv); 970 } 971 972 /** 973 * ab8500_fg_convert_mah_to_permille() - Capacity in mAh to permille 974 * @di: pointer to the ab8500_fg structure 975 * @cap_mah: capacity in mAh 976 * 977 * Converts capacity in mAh to capacity in permille 978 */ 979 static int ab8500_fg_convert_mah_to_permille(struct ab8500_fg *di, int cap_mah) 980 { 981 return (cap_mah * 1000) / di->bat_cap.max_mah_design; 982 } 983 984 /** 985 * ab8500_fg_convert_permille_to_mah() - Capacity in permille to mAh 986 * @di: pointer to the ab8500_fg structure 987 * @cap_pm: capacity in permille 988 * 989 * Converts capacity in permille to capacity in mAh 990 */ 991 static int ab8500_fg_convert_permille_to_mah(struct ab8500_fg *di, int cap_pm) 992 { 993 return cap_pm * di->bat_cap.max_mah_design / 1000; 994 } 995 996 /** 997 * ab8500_fg_convert_mah_to_uwh() - Capacity in mAh to uWh 998 * @di: pointer to the ab8500_fg structure 999 * @cap_mah: capacity in mAh 1000 * 1001 * Converts capacity in mAh to capacity in uWh 1002 */ 1003 static int ab8500_fg_convert_mah_to_uwh(struct ab8500_fg *di, int cap_mah) 1004 { 1005 u64 div_res; 1006 u32 div_rem; 1007 1008 /* 1009 * Capacity is in milli ampere hours (10^-3)Ah 1010 * Nominal voltage is in microvolts (10^-6)V 1011 * divide by 1000000 after multiplication to get to mWh 1012 */ 1013 div_res = ((u64) cap_mah) * ((u64) di->vbat_nom_uv); 1014 div_rem = do_div(div_res, 1000000); 1015 1016 /* Make sure to round upwards if necessary */ 1017 if (div_rem >= 1000000 / 2) 1018 div_res++; 1019 1020 return (int) div_res; 1021 } 1022 1023 /** 1024 * ab8500_fg_calc_cap_charging() - Calculate remaining capacity while charging 1025 * @di: pointer to the ab8500_fg structure 1026 * 1027 * Return the capacity in mAh based on previous calculated capcity and the FG 1028 * accumulator register value. The filter is filled with this capacity 1029 */ 1030 static int ab8500_fg_calc_cap_charging(struct ab8500_fg *di) 1031 { 1032 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n", 1033 __func__, 1034 di->bat_cap.mah, 1035 di->accu_charge); 1036 1037 /* Capacity should not be less than 0 */ 1038 if (di->bat_cap.mah + di->accu_charge > 0) 1039 di->bat_cap.mah += di->accu_charge; 1040 else 1041 di->bat_cap.mah = 0; 1042 /* 1043 * We force capacity to 100% once when the algorithm 1044 * reports that it's full. 1045 */ 1046 if (di->bat_cap.mah >= di->bat_cap.max_mah_design || 1047 di->flags.force_full) { 1048 di->bat_cap.mah = di->bat_cap.max_mah_design; 1049 } 1050 1051 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah); 1052 di->bat_cap.permille = 1053 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah); 1054 1055 /* We need to update battery voltage and inst current when charging */ 1056 di->vbat_uv = ab8500_fg_bat_voltage(di); 1057 di->inst_curr_ua = ab8500_fg_inst_curr_blocking(di); 1058 1059 return di->bat_cap.mah; 1060 } 1061 1062 /** 1063 * ab8500_fg_calc_cap_discharge_voltage() - Capacity in discharge with voltage 1064 * @di: pointer to the ab8500_fg structure 1065 * @comp: if voltage should be load compensated before capacity calc 1066 * 1067 * Return the capacity in mAh based on the battery voltage. The voltage can 1068 * either be load compensated or not. This value is added to the filter and a 1069 * new mean value is calculated and returned. 1070 */ 1071 static int ab8500_fg_calc_cap_discharge_voltage(struct ab8500_fg *di, bool comp) 1072 { 1073 int permille, mah; 1074 1075 if (comp) 1076 permille = ab8500_fg_load_comp_volt_to_capacity(di); 1077 else 1078 permille = ab8500_fg_uncomp_volt_to_capacity(di); 1079 1080 mah = ab8500_fg_convert_permille_to_mah(di, permille); 1081 1082 di->bat_cap.mah = ab8500_fg_add_cap_sample(di, mah); 1083 di->bat_cap.permille = 1084 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah); 1085 1086 return di->bat_cap.mah; 1087 } 1088 1089 /** 1090 * ab8500_fg_calc_cap_discharge_fg() - Capacity in discharge with FG 1091 * @di: pointer to the ab8500_fg structure 1092 * 1093 * Return the capacity in mAh based on previous calculated capcity and the FG 1094 * accumulator register value. This value is added to the filter and a 1095 * new mean value is calculated and returned. 1096 */ 1097 static int ab8500_fg_calc_cap_discharge_fg(struct ab8500_fg *di) 1098 { 1099 int permille_volt, permille; 1100 1101 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n", 1102 __func__, 1103 di->bat_cap.mah, 1104 di->accu_charge); 1105 1106 /* Capacity should not be less than 0 */ 1107 if (di->bat_cap.mah + di->accu_charge > 0) 1108 di->bat_cap.mah += di->accu_charge; 1109 else 1110 di->bat_cap.mah = 0; 1111 1112 if (di->bat_cap.mah >= di->bat_cap.max_mah_design) 1113 di->bat_cap.mah = di->bat_cap.max_mah_design; 1114 1115 /* 1116 * Check against voltage based capacity. It can not be lower 1117 * than what the uncompensated voltage says 1118 */ 1119 permille = ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah); 1120 permille_volt = ab8500_fg_uncomp_volt_to_capacity(di); 1121 1122 if (permille < permille_volt) { 1123 di->bat_cap.permille = permille_volt; 1124 di->bat_cap.mah = ab8500_fg_convert_permille_to_mah(di, 1125 di->bat_cap.permille); 1126 1127 dev_dbg(di->dev, "%s voltage based: perm %d perm_volt %d\n", 1128 __func__, 1129 permille, 1130 permille_volt); 1131 1132 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah); 1133 } else { 1134 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah); 1135 di->bat_cap.permille = 1136 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah); 1137 } 1138 1139 return di->bat_cap.mah; 1140 } 1141 1142 /** 1143 * ab8500_fg_capacity_level() - Get the battery capacity level 1144 * @di: pointer to the ab8500_fg structure 1145 * 1146 * Get the battery capacity level based on the capacity in percent 1147 */ 1148 static int ab8500_fg_capacity_level(struct ab8500_fg *di) 1149 { 1150 int ret, percent; 1151 1152 percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10); 1153 1154 if (percent <= di->bm->cap_levels->critical || 1155 di->flags.low_bat) 1156 ret = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; 1157 else if (percent <= di->bm->cap_levels->low) 1158 ret = POWER_SUPPLY_CAPACITY_LEVEL_LOW; 1159 else if (percent <= di->bm->cap_levels->normal) 1160 ret = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; 1161 else if (percent <= di->bm->cap_levels->high) 1162 ret = POWER_SUPPLY_CAPACITY_LEVEL_HIGH; 1163 else 1164 ret = POWER_SUPPLY_CAPACITY_LEVEL_FULL; 1165 1166 return ret; 1167 } 1168 1169 /** 1170 * ab8500_fg_calculate_scaled_capacity() - Capacity scaling 1171 * @di: pointer to the ab8500_fg structure 1172 * 1173 * Calculates the capacity to be shown to upper layers. Scales the capacity 1174 * to have 100% as a reference from the actual capacity upon removal of charger 1175 * when charging is in maintenance mode. 1176 */ 1177 static int ab8500_fg_calculate_scaled_capacity(struct ab8500_fg *di) 1178 { 1179 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale; 1180 int capacity = di->bat_cap.prev_percent; 1181 1182 if (!cs->enable) 1183 return capacity; 1184 1185 /* 1186 * As long as we are in fully charge mode scale the capacity 1187 * to show 100%. 1188 */ 1189 if (di->flags.fully_charged) { 1190 cs->cap_to_scale[0] = 100; 1191 cs->cap_to_scale[1] = 1192 max(capacity, di->bm->fg_params->maint_thres); 1193 dev_dbg(di->dev, "Scale cap with %d/%d\n", 1194 cs->cap_to_scale[0], cs->cap_to_scale[1]); 1195 } 1196 1197 /* Calculates the scaled capacity. */ 1198 if ((cs->cap_to_scale[0] != cs->cap_to_scale[1]) 1199 && (cs->cap_to_scale[1] > 0)) 1200 capacity = min(100, 1201 DIV_ROUND_CLOSEST(di->bat_cap.prev_percent * 1202 cs->cap_to_scale[0], 1203 cs->cap_to_scale[1])); 1204 1205 if (di->flags.charging) { 1206 if (capacity < cs->disable_cap_level) { 1207 cs->disable_cap_level = capacity; 1208 dev_dbg(di->dev, "Cap to stop scale lowered %d%%\n", 1209 cs->disable_cap_level); 1210 } else if (!di->flags.fully_charged) { 1211 if (di->bat_cap.prev_percent >= 1212 cs->disable_cap_level) { 1213 dev_dbg(di->dev, "Disabling scaled capacity\n"); 1214 cs->enable = false; 1215 capacity = di->bat_cap.prev_percent; 1216 } else { 1217 dev_dbg(di->dev, 1218 "Waiting in cap to level %d%%\n", 1219 cs->disable_cap_level); 1220 capacity = cs->disable_cap_level; 1221 } 1222 } 1223 } 1224 1225 return capacity; 1226 } 1227 1228 /** 1229 * ab8500_fg_update_cap_scalers() - Capacity scaling 1230 * @di: pointer to the ab8500_fg structure 1231 * 1232 * To be called when state change from charge<->discharge to update 1233 * the capacity scalers. 1234 */ 1235 static void ab8500_fg_update_cap_scalers(struct ab8500_fg *di) 1236 { 1237 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale; 1238 1239 if (!cs->enable) 1240 return; 1241 if (di->flags.charging) { 1242 di->bat_cap.cap_scale.disable_cap_level = 1243 di->bat_cap.cap_scale.scaled_cap; 1244 dev_dbg(di->dev, "Cap to stop scale at charge %d%%\n", 1245 di->bat_cap.cap_scale.disable_cap_level); 1246 } else { 1247 if (cs->scaled_cap != 100) { 1248 cs->cap_to_scale[0] = cs->scaled_cap; 1249 cs->cap_to_scale[1] = di->bat_cap.prev_percent; 1250 } else { 1251 cs->cap_to_scale[0] = 100; 1252 cs->cap_to_scale[1] = 1253 max(di->bat_cap.prev_percent, 1254 di->bm->fg_params->maint_thres); 1255 } 1256 1257 dev_dbg(di->dev, "Cap to scale at discharge %d/%d\n", 1258 cs->cap_to_scale[0], cs->cap_to_scale[1]); 1259 } 1260 } 1261 1262 /** 1263 * ab8500_fg_check_capacity_limits() - Check if capacity has changed 1264 * @di: pointer to the ab8500_fg structure 1265 * @init: capacity is allowed to go up in init mode 1266 * 1267 * Check if capacity or capacity limit has changed and notify the system 1268 * about it using the power_supply framework 1269 */ 1270 static void ab8500_fg_check_capacity_limits(struct ab8500_fg *di, bool init) 1271 { 1272 bool changed = false; 1273 int percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10); 1274 1275 di->bat_cap.level = ab8500_fg_capacity_level(di); 1276 1277 if (di->bat_cap.level != di->bat_cap.prev_level) { 1278 /* 1279 * We do not allow reported capacity level to go up 1280 * unless we're charging or if we're in init 1281 */ 1282 if (!(!di->flags.charging && di->bat_cap.level > 1283 di->bat_cap.prev_level) || init) { 1284 dev_dbg(di->dev, "level changed from %d to %d\n", 1285 di->bat_cap.prev_level, 1286 di->bat_cap.level); 1287 di->bat_cap.prev_level = di->bat_cap.level; 1288 changed = true; 1289 } else { 1290 dev_dbg(di->dev, "level not allowed to go up " 1291 "since no charger is connected: %d to %d\n", 1292 di->bat_cap.prev_level, 1293 di->bat_cap.level); 1294 } 1295 } 1296 1297 /* 1298 * If we have received the LOW_BAT IRQ, set capacity to 0 to initiate 1299 * shutdown 1300 */ 1301 if (di->flags.low_bat) { 1302 dev_dbg(di->dev, "Battery low, set capacity to 0\n"); 1303 di->bat_cap.prev_percent = 0; 1304 di->bat_cap.permille = 0; 1305 percent = 0; 1306 di->bat_cap.prev_mah = 0; 1307 di->bat_cap.mah = 0; 1308 changed = true; 1309 } else if (di->flags.fully_charged) { 1310 /* 1311 * We report 100% if algorithm reported fully charged 1312 * and show 100% during maintenance charging (scaling). 1313 */ 1314 if (di->flags.force_full) { 1315 di->bat_cap.prev_percent = percent; 1316 di->bat_cap.prev_mah = di->bat_cap.mah; 1317 1318 changed = true; 1319 1320 if (!di->bat_cap.cap_scale.enable && 1321 di->bm->capacity_scaling) { 1322 di->bat_cap.cap_scale.enable = true; 1323 di->bat_cap.cap_scale.cap_to_scale[0] = 100; 1324 di->bat_cap.cap_scale.cap_to_scale[1] = 1325 di->bat_cap.prev_percent; 1326 di->bat_cap.cap_scale.disable_cap_level = 100; 1327 } 1328 } else if (di->bat_cap.prev_percent != percent) { 1329 dev_dbg(di->dev, 1330 "battery reported full " 1331 "but capacity dropping: %d\n", 1332 percent); 1333 di->bat_cap.prev_percent = percent; 1334 di->bat_cap.prev_mah = di->bat_cap.mah; 1335 1336 changed = true; 1337 } 1338 } else if (di->bat_cap.prev_percent != percent) { 1339 if (percent == 0) { 1340 /* 1341 * We will not report 0% unless we've got 1342 * the LOW_BAT IRQ, no matter what the FG 1343 * algorithm says. 1344 */ 1345 di->bat_cap.prev_percent = 1; 1346 percent = 1; 1347 1348 changed = true; 1349 } else if (!(!di->flags.charging && 1350 percent > di->bat_cap.prev_percent) || init) { 1351 /* 1352 * We do not allow reported capacity to go up 1353 * unless we're charging or if we're in init 1354 */ 1355 dev_dbg(di->dev, 1356 "capacity changed from %d to %d (%d)\n", 1357 di->bat_cap.prev_percent, 1358 percent, 1359 di->bat_cap.permille); 1360 di->bat_cap.prev_percent = percent; 1361 di->bat_cap.prev_mah = di->bat_cap.mah; 1362 1363 changed = true; 1364 } else { 1365 dev_dbg(di->dev, "capacity not allowed to go up since " 1366 "no charger is connected: %d to %d (%d)\n", 1367 di->bat_cap.prev_percent, 1368 percent, 1369 di->bat_cap.permille); 1370 } 1371 } 1372 1373 if (changed) { 1374 if (di->bm->capacity_scaling) { 1375 di->bat_cap.cap_scale.scaled_cap = 1376 ab8500_fg_calculate_scaled_capacity(di); 1377 1378 dev_info(di->dev, "capacity=%d (%d)\n", 1379 di->bat_cap.prev_percent, 1380 di->bat_cap.cap_scale.scaled_cap); 1381 } 1382 power_supply_changed(di->fg_psy); 1383 if (di->flags.fully_charged && di->flags.force_full) { 1384 dev_dbg(di->dev, "Battery full, notifying.\n"); 1385 di->flags.force_full = false; 1386 sysfs_notify(&di->fg_kobject, NULL, "charge_full"); 1387 } 1388 sysfs_notify(&di->fg_kobject, NULL, "charge_now"); 1389 } 1390 } 1391 1392 static void ab8500_fg_charge_state_to(struct ab8500_fg *di, 1393 enum ab8500_fg_charge_state new_state) 1394 { 1395 dev_dbg(di->dev, "Charge state from %d [%s] to %d [%s]\n", 1396 di->charge_state, 1397 charge_state[di->charge_state], 1398 new_state, 1399 charge_state[new_state]); 1400 1401 di->charge_state = new_state; 1402 } 1403 1404 static void ab8500_fg_discharge_state_to(struct ab8500_fg *di, 1405 enum ab8500_fg_discharge_state new_state) 1406 { 1407 dev_dbg(di->dev, "Discharge state from %d [%s] to %d [%s]\n", 1408 di->discharge_state, 1409 discharge_state[di->discharge_state], 1410 new_state, 1411 discharge_state[new_state]); 1412 1413 di->discharge_state = new_state; 1414 } 1415 1416 /** 1417 * ab8500_fg_algorithm_charging() - FG algorithm for when charging 1418 * @di: pointer to the ab8500_fg structure 1419 * 1420 * Battery capacity calculation state machine for when we're charging 1421 */ 1422 static void ab8500_fg_algorithm_charging(struct ab8500_fg *di) 1423 { 1424 /* 1425 * If we change to discharge mode 1426 * we should start with recovery 1427 */ 1428 if (di->discharge_state != AB8500_FG_DISCHARGE_INIT_RECOVERY) 1429 ab8500_fg_discharge_state_to(di, 1430 AB8500_FG_DISCHARGE_INIT_RECOVERY); 1431 1432 switch (di->charge_state) { 1433 case AB8500_FG_CHARGE_INIT: 1434 di->fg_samples = SEC_TO_SAMPLE( 1435 di->bm->fg_params->accu_charging); 1436 1437 ab8500_fg_coulomb_counter(di, true); 1438 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_READOUT); 1439 1440 break; 1441 1442 case AB8500_FG_CHARGE_READOUT: 1443 /* 1444 * Read the FG and calculate the new capacity 1445 */ 1446 mutex_lock(&di->cc_lock); 1447 if (!di->flags.conv_done && !di->flags.force_full) { 1448 /* Wasn't the CC IRQ that got us here */ 1449 mutex_unlock(&di->cc_lock); 1450 dev_dbg(di->dev, "%s CC conv not done\n", 1451 __func__); 1452 1453 break; 1454 } 1455 di->flags.conv_done = false; 1456 mutex_unlock(&di->cc_lock); 1457 1458 ab8500_fg_calc_cap_charging(di); 1459 1460 break; 1461 1462 default: 1463 break; 1464 } 1465 1466 /* Check capacity limits */ 1467 ab8500_fg_check_capacity_limits(di, false); 1468 } 1469 1470 static void force_capacity(struct ab8500_fg *di) 1471 { 1472 int cap; 1473 1474 ab8500_fg_clear_cap_samples(di); 1475 cap = di->bat_cap.user_mah; 1476 if (cap > di->bat_cap.max_mah_design) { 1477 dev_dbg(di->dev, "Remaining cap %d can't be bigger than total" 1478 " %d\n", cap, di->bat_cap.max_mah_design); 1479 cap = di->bat_cap.max_mah_design; 1480 } 1481 ab8500_fg_fill_cap_sample(di, di->bat_cap.user_mah); 1482 di->bat_cap.permille = ab8500_fg_convert_mah_to_permille(di, cap); 1483 di->bat_cap.mah = cap; 1484 ab8500_fg_check_capacity_limits(di, true); 1485 } 1486 1487 static bool check_sysfs_capacity(struct ab8500_fg *di) 1488 { 1489 int cap, lower, upper; 1490 int cap_permille; 1491 1492 cap = di->bat_cap.user_mah; 1493 1494 cap_permille = ab8500_fg_convert_mah_to_permille(di, 1495 di->bat_cap.user_mah); 1496 1497 lower = di->bat_cap.permille - di->bm->fg_params->user_cap_limit * 10; 1498 upper = di->bat_cap.permille + di->bm->fg_params->user_cap_limit * 10; 1499 1500 if (lower < 0) 1501 lower = 0; 1502 /* 1000 is permille, -> 100 percent */ 1503 if (upper > 1000) 1504 upper = 1000; 1505 1506 dev_dbg(di->dev, "Capacity limits:" 1507 " (Lower: %d User: %d Upper: %d) [user: %d, was: %d]\n", 1508 lower, cap_permille, upper, cap, di->bat_cap.mah); 1509 1510 /* If within limits, use the saved capacity and exit estimation...*/ 1511 if (cap_permille > lower && cap_permille < upper) { 1512 dev_dbg(di->dev, "OK! Using users cap %d uAh now\n", cap); 1513 force_capacity(di); 1514 return true; 1515 } 1516 dev_dbg(di->dev, "Capacity from user out of limits, ignoring"); 1517 return false; 1518 } 1519 1520 /** 1521 * ab8500_fg_algorithm_discharging() - FG algorithm for when discharging 1522 * @di: pointer to the ab8500_fg structure 1523 * 1524 * Battery capacity calculation state machine for when we're discharging 1525 */ 1526 static void ab8500_fg_algorithm_discharging(struct ab8500_fg *di) 1527 { 1528 int sleep_time; 1529 1530 /* If we change to charge mode we should start with init */ 1531 if (di->charge_state != AB8500_FG_CHARGE_INIT) 1532 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT); 1533 1534 switch (di->discharge_state) { 1535 case AB8500_FG_DISCHARGE_INIT: 1536 /* We use the FG IRQ to work on */ 1537 di->init_cnt = 0; 1538 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer); 1539 ab8500_fg_coulomb_counter(di, true); 1540 ab8500_fg_discharge_state_to(di, 1541 AB8500_FG_DISCHARGE_INITMEASURING); 1542 1543 fallthrough; 1544 case AB8500_FG_DISCHARGE_INITMEASURING: 1545 /* 1546 * Discard a number of samples during startup. 1547 * After that, use compensated voltage for a few 1548 * samples to get an initial capacity. 1549 * Then go to READOUT 1550 */ 1551 sleep_time = di->bm->fg_params->init_timer; 1552 1553 /* Discard the first [x] seconds */ 1554 if (di->init_cnt > di->bm->fg_params->init_discard_time) { 1555 ab8500_fg_calc_cap_discharge_voltage(di, true); 1556 1557 ab8500_fg_check_capacity_limits(di, true); 1558 } 1559 1560 di->init_cnt += sleep_time; 1561 if (di->init_cnt > di->bm->fg_params->init_total_time) 1562 ab8500_fg_discharge_state_to(di, 1563 AB8500_FG_DISCHARGE_READOUT_INIT); 1564 1565 break; 1566 1567 case AB8500_FG_DISCHARGE_INIT_RECOVERY: 1568 di->recovery_cnt = 0; 1569 di->recovery_needed = true; 1570 ab8500_fg_discharge_state_to(di, 1571 AB8500_FG_DISCHARGE_RECOVERY); 1572 1573 fallthrough; 1574 1575 case AB8500_FG_DISCHARGE_RECOVERY: 1576 sleep_time = di->bm->fg_params->recovery_sleep_timer; 1577 1578 /* 1579 * We should check the power consumption 1580 * If low, go to READOUT (after x min) or 1581 * RECOVERY_SLEEP if time left. 1582 * If high, go to READOUT 1583 */ 1584 di->inst_curr_ua = ab8500_fg_inst_curr_blocking(di); 1585 1586 if (ab8500_fg_is_low_curr(di, di->inst_curr_ua)) { 1587 if (di->recovery_cnt > 1588 di->bm->fg_params->recovery_total_time) { 1589 di->fg_samples = SEC_TO_SAMPLE( 1590 di->bm->fg_params->accu_high_curr); 1591 ab8500_fg_coulomb_counter(di, true); 1592 ab8500_fg_discharge_state_to(di, 1593 AB8500_FG_DISCHARGE_READOUT); 1594 di->recovery_needed = false; 1595 } else { 1596 queue_delayed_work(di->fg_wq, 1597 &di->fg_periodic_work, 1598 sleep_time * HZ); 1599 } 1600 di->recovery_cnt += sleep_time; 1601 } else { 1602 di->fg_samples = SEC_TO_SAMPLE( 1603 di->bm->fg_params->accu_high_curr); 1604 ab8500_fg_coulomb_counter(di, true); 1605 ab8500_fg_discharge_state_to(di, 1606 AB8500_FG_DISCHARGE_READOUT); 1607 } 1608 break; 1609 1610 case AB8500_FG_DISCHARGE_READOUT_INIT: 1611 di->fg_samples = SEC_TO_SAMPLE( 1612 di->bm->fg_params->accu_high_curr); 1613 ab8500_fg_coulomb_counter(di, true); 1614 ab8500_fg_discharge_state_to(di, 1615 AB8500_FG_DISCHARGE_READOUT); 1616 break; 1617 1618 case AB8500_FG_DISCHARGE_READOUT: 1619 di->inst_curr_ua = ab8500_fg_inst_curr_blocking(di); 1620 1621 if (ab8500_fg_is_low_curr(di, di->inst_curr_ua)) { 1622 /* Detect mode change */ 1623 if (di->high_curr_mode) { 1624 di->high_curr_mode = false; 1625 di->high_curr_cnt = 0; 1626 } 1627 1628 if (di->recovery_needed) { 1629 ab8500_fg_discharge_state_to(di, 1630 AB8500_FG_DISCHARGE_INIT_RECOVERY); 1631 1632 queue_delayed_work(di->fg_wq, 1633 &di->fg_periodic_work, 0); 1634 1635 break; 1636 } 1637 1638 ab8500_fg_calc_cap_discharge_voltage(di, true); 1639 } else { 1640 mutex_lock(&di->cc_lock); 1641 if (!di->flags.conv_done) { 1642 /* Wasn't the CC IRQ that got us here */ 1643 mutex_unlock(&di->cc_lock); 1644 dev_dbg(di->dev, "%s CC conv not done\n", 1645 __func__); 1646 1647 break; 1648 } 1649 di->flags.conv_done = false; 1650 mutex_unlock(&di->cc_lock); 1651 1652 /* Detect mode change */ 1653 if (!di->high_curr_mode) { 1654 di->high_curr_mode = true; 1655 di->high_curr_cnt = 0; 1656 } 1657 1658 di->high_curr_cnt += 1659 di->bm->fg_params->accu_high_curr; 1660 if (di->high_curr_cnt > 1661 di->bm->fg_params->high_curr_time) 1662 di->recovery_needed = true; 1663 1664 ab8500_fg_calc_cap_discharge_fg(di); 1665 } 1666 1667 ab8500_fg_check_capacity_limits(di, false); 1668 1669 break; 1670 1671 case AB8500_FG_DISCHARGE_WAKEUP: 1672 ab8500_fg_calc_cap_discharge_voltage(di, true); 1673 1674 di->fg_samples = SEC_TO_SAMPLE( 1675 di->bm->fg_params->accu_high_curr); 1676 ab8500_fg_coulomb_counter(di, true); 1677 ab8500_fg_discharge_state_to(di, 1678 AB8500_FG_DISCHARGE_READOUT); 1679 1680 ab8500_fg_check_capacity_limits(di, false); 1681 1682 break; 1683 1684 default: 1685 break; 1686 } 1687 } 1688 1689 /** 1690 * ab8500_fg_algorithm_calibrate() - Internal columb counter offset calibration 1691 * @di: pointer to the ab8500_fg structure 1692 * 1693 */ 1694 static void ab8500_fg_algorithm_calibrate(struct ab8500_fg *di) 1695 { 1696 int ret; 1697 1698 switch (di->calib_state) { 1699 case AB8500_FG_CALIB_INIT: 1700 dev_dbg(di->dev, "Calibration ongoing...\n"); 1701 1702 ret = abx500_mask_and_set_register_interruptible(di->dev, 1703 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG, 1704 CC_INT_CAL_N_AVG_MASK, CC_INT_CAL_SAMPLES_8); 1705 if (ret < 0) 1706 goto err; 1707 1708 ret = abx500_mask_and_set_register_interruptible(di->dev, 1709 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG, 1710 CC_INTAVGOFFSET_ENA, CC_INTAVGOFFSET_ENA); 1711 if (ret < 0) 1712 goto err; 1713 di->calib_state = AB8500_FG_CALIB_WAIT; 1714 break; 1715 case AB8500_FG_CALIB_END: 1716 ret = abx500_mask_and_set_register_interruptible(di->dev, 1717 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG, 1718 CC_MUXOFFSET, CC_MUXOFFSET); 1719 if (ret < 0) 1720 goto err; 1721 di->flags.calibrate = false; 1722 dev_dbg(di->dev, "Calibration done...\n"); 1723 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); 1724 break; 1725 case AB8500_FG_CALIB_WAIT: 1726 dev_dbg(di->dev, "Calibration WFI\n"); 1727 break; 1728 default: 1729 break; 1730 } 1731 return; 1732 err: 1733 /* Something went wrong, don't calibrate then */ 1734 dev_err(di->dev, "failed to calibrate the CC\n"); 1735 di->flags.calibrate = false; 1736 di->calib_state = AB8500_FG_CALIB_INIT; 1737 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); 1738 } 1739 1740 /** 1741 * ab8500_fg_algorithm() - Entry point for the FG algorithm 1742 * @di: pointer to the ab8500_fg structure 1743 * 1744 * Entry point for the battery capacity calculation state machine 1745 */ 1746 static void ab8500_fg_algorithm(struct ab8500_fg *di) 1747 { 1748 if (di->flags.calibrate) 1749 ab8500_fg_algorithm_calibrate(di); 1750 else { 1751 if (di->flags.charging) 1752 ab8500_fg_algorithm_charging(di); 1753 else 1754 ab8500_fg_algorithm_discharging(di); 1755 } 1756 1757 dev_dbg(di->dev, "[FG_DATA] %d %d %d %d %d %d %d %d %d %d " 1758 "%d %d %d %d %d %d %d\n", 1759 di->bat_cap.max_mah_design, 1760 di->bat_cap.max_mah, 1761 di->bat_cap.mah, 1762 di->bat_cap.permille, 1763 di->bat_cap.level, 1764 di->bat_cap.prev_mah, 1765 di->bat_cap.prev_percent, 1766 di->bat_cap.prev_level, 1767 di->vbat_uv, 1768 di->inst_curr_ua, 1769 di->avg_curr_ua, 1770 di->accu_charge, 1771 di->flags.charging, 1772 di->charge_state, 1773 di->discharge_state, 1774 di->high_curr_mode, 1775 di->recovery_needed); 1776 } 1777 1778 /** 1779 * ab8500_fg_periodic_work() - Run the FG state machine periodically 1780 * @work: pointer to the work_struct structure 1781 * 1782 * Work queue function for periodic work 1783 */ 1784 static void ab8500_fg_periodic_work(struct work_struct *work) 1785 { 1786 struct ab8500_fg *di = container_of(work, struct ab8500_fg, 1787 fg_periodic_work.work); 1788 1789 if (di->init_capacity) { 1790 /* Get an initial capacity calculation */ 1791 ab8500_fg_calc_cap_discharge_voltage(di, true); 1792 ab8500_fg_check_capacity_limits(di, true); 1793 di->init_capacity = false; 1794 1795 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); 1796 } else if (di->flags.user_cap) { 1797 if (check_sysfs_capacity(di)) { 1798 ab8500_fg_check_capacity_limits(di, true); 1799 if (di->flags.charging) 1800 ab8500_fg_charge_state_to(di, 1801 AB8500_FG_CHARGE_INIT); 1802 else 1803 ab8500_fg_discharge_state_to(di, 1804 AB8500_FG_DISCHARGE_READOUT_INIT); 1805 } 1806 di->flags.user_cap = false; 1807 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); 1808 } else 1809 ab8500_fg_algorithm(di); 1810 1811 } 1812 1813 /** 1814 * ab8500_fg_check_hw_failure_work() - Check OVV_BAT condition 1815 * @work: pointer to the work_struct structure 1816 * 1817 * Work queue function for checking the OVV_BAT condition 1818 */ 1819 static void ab8500_fg_check_hw_failure_work(struct work_struct *work) 1820 { 1821 int ret; 1822 u8 reg_value; 1823 1824 struct ab8500_fg *di = container_of(work, struct ab8500_fg, 1825 fg_check_hw_failure_work.work); 1826 1827 /* 1828 * If we have had a battery over-voltage situation, 1829 * check ovv-bit to see if it should be reset. 1830 */ 1831 ret = abx500_get_register_interruptible(di->dev, 1832 AB8500_CHARGER, AB8500_CH_STAT_REG, 1833 ®_value); 1834 if (ret < 0) { 1835 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 1836 return; 1837 } 1838 if ((reg_value & BATT_OVV) == BATT_OVV) { 1839 if (!di->flags.bat_ovv) { 1840 dev_dbg(di->dev, "Battery OVV\n"); 1841 di->flags.bat_ovv = true; 1842 power_supply_changed(di->fg_psy); 1843 } 1844 /* Not yet recovered from ovv, reschedule this test */ 1845 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work, 1846 HZ); 1847 } else { 1848 dev_dbg(di->dev, "Battery recovered from OVV\n"); 1849 di->flags.bat_ovv = false; 1850 power_supply_changed(di->fg_psy); 1851 } 1852 } 1853 1854 /** 1855 * ab8500_fg_low_bat_work() - Check LOW_BAT condition 1856 * @work: pointer to the work_struct structure 1857 * 1858 * Work queue function for checking the LOW_BAT condition 1859 */ 1860 static void ab8500_fg_low_bat_work(struct work_struct *work) 1861 { 1862 int vbat_uv; 1863 1864 struct ab8500_fg *di = container_of(work, struct ab8500_fg, 1865 fg_low_bat_work.work); 1866 1867 vbat_uv = ab8500_fg_bat_voltage(di); 1868 1869 /* Check if LOW_BAT still fulfilled */ 1870 if (vbat_uv < di->bm->fg_params->lowbat_threshold_uv) { 1871 /* Is it time to shut down? */ 1872 if (di->low_bat_cnt < 1) { 1873 di->flags.low_bat = true; 1874 dev_warn(di->dev, "Shut down pending...\n"); 1875 } else { 1876 /* 1877 * Else we need to re-schedule this check to be able to detect 1878 * if the voltage increases again during charging or 1879 * due to decreasing load. 1880 */ 1881 di->low_bat_cnt--; 1882 dev_warn(di->dev, "Battery voltage still LOW\n"); 1883 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work, 1884 round_jiffies(LOW_BAT_CHECK_INTERVAL)); 1885 } 1886 } else { 1887 di->flags.low_bat_delay = false; 1888 di->low_bat_cnt = 10; 1889 dev_warn(di->dev, "Battery voltage OK again\n"); 1890 } 1891 1892 /* This is needed to dispatch LOW_BAT */ 1893 ab8500_fg_check_capacity_limits(di, false); 1894 } 1895 1896 /** 1897 * ab8500_fg_battok_calc - calculate the bit pattern corresponding 1898 * to the target voltage. 1899 * @di: pointer to the ab8500_fg structure 1900 * @target: target voltage 1901 * 1902 * Returns bit pattern closest to the target voltage 1903 * valid return values are 0-14. (0-BATT_OK_MAX_NR_INCREMENTS) 1904 */ 1905 1906 static int ab8500_fg_battok_calc(struct ab8500_fg *di, int target) 1907 { 1908 if (target > BATT_OK_MIN + 1909 (BATT_OK_INCREMENT * BATT_OK_MAX_NR_INCREMENTS)) 1910 return BATT_OK_MAX_NR_INCREMENTS; 1911 if (target < BATT_OK_MIN) 1912 return 0; 1913 return (target - BATT_OK_MIN) / BATT_OK_INCREMENT; 1914 } 1915 1916 /** 1917 * ab8500_fg_battok_init_hw_register - init battok levels 1918 * @di: pointer to the ab8500_fg structure 1919 * 1920 */ 1921 1922 static int ab8500_fg_battok_init_hw_register(struct ab8500_fg *di) 1923 { 1924 int selected; 1925 int sel0; 1926 int sel1; 1927 int cbp_sel0; 1928 int cbp_sel1; 1929 int ret; 1930 int new_val; 1931 1932 sel0 = di->bm->fg_params->battok_falling_th_sel0; 1933 sel1 = di->bm->fg_params->battok_raising_th_sel1; 1934 1935 cbp_sel0 = ab8500_fg_battok_calc(di, sel0); 1936 cbp_sel1 = ab8500_fg_battok_calc(di, sel1); 1937 1938 selected = BATT_OK_MIN + cbp_sel0 * BATT_OK_INCREMENT; 1939 1940 if (selected != sel0) 1941 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n", 1942 sel0, selected, cbp_sel0); 1943 1944 selected = BATT_OK_MIN + cbp_sel1 * BATT_OK_INCREMENT; 1945 1946 if (selected != sel1) 1947 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n", 1948 sel1, selected, cbp_sel1); 1949 1950 new_val = cbp_sel0 | (cbp_sel1 << 4); 1951 1952 dev_dbg(di->dev, "using: %x %d %d\n", new_val, cbp_sel0, cbp_sel1); 1953 ret = abx500_set_register_interruptible(di->dev, AB8500_SYS_CTRL2_BLOCK, 1954 AB8500_BATT_OK_REG, new_val); 1955 return ret; 1956 } 1957 1958 /** 1959 * ab8500_fg_instant_work() - Run the FG state machine instantly 1960 * @work: pointer to the work_struct structure 1961 * 1962 * Work queue function for instant work 1963 */ 1964 static void ab8500_fg_instant_work(struct work_struct *work) 1965 { 1966 struct ab8500_fg *di = container_of(work, struct ab8500_fg, fg_work); 1967 1968 ab8500_fg_algorithm(di); 1969 } 1970 1971 /** 1972 * ab8500_fg_cc_data_end_handler() - end of data conversion isr. 1973 * @irq: interrupt number 1974 * @_di: pointer to the ab8500_fg structure 1975 * 1976 * Returns IRQ status(IRQ_HANDLED) 1977 */ 1978 static irqreturn_t ab8500_fg_cc_data_end_handler(int irq, void *_di) 1979 { 1980 struct ab8500_fg *di = _di; 1981 if (!di->nbr_cceoc_irq_cnt) { 1982 di->nbr_cceoc_irq_cnt++; 1983 complete(&di->ab8500_fg_started); 1984 } else { 1985 di->nbr_cceoc_irq_cnt = 0; 1986 complete(&di->ab8500_fg_complete); 1987 } 1988 return IRQ_HANDLED; 1989 } 1990 1991 /** 1992 * ab8500_fg_cc_int_calib_handler () - end of calibration isr. 1993 * @irq: interrupt number 1994 * @_di: pointer to the ab8500_fg structure 1995 * 1996 * Returns IRQ status(IRQ_HANDLED) 1997 */ 1998 static irqreturn_t ab8500_fg_cc_int_calib_handler(int irq, void *_di) 1999 { 2000 struct ab8500_fg *di = _di; 2001 di->calib_state = AB8500_FG_CALIB_END; 2002 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); 2003 return IRQ_HANDLED; 2004 } 2005 2006 /** 2007 * ab8500_fg_cc_convend_handler() - isr to get battery avg current. 2008 * @irq: interrupt number 2009 * @_di: pointer to the ab8500_fg structure 2010 * 2011 * Returns IRQ status(IRQ_HANDLED) 2012 */ 2013 static irqreturn_t ab8500_fg_cc_convend_handler(int irq, void *_di) 2014 { 2015 struct ab8500_fg *di = _di; 2016 2017 queue_work(di->fg_wq, &di->fg_acc_cur_work); 2018 2019 return IRQ_HANDLED; 2020 } 2021 2022 /** 2023 * ab8500_fg_batt_ovv_handler() - Battery OVV occured 2024 * @irq: interrupt number 2025 * @_di: pointer to the ab8500_fg structure 2026 * 2027 * Returns IRQ status(IRQ_HANDLED) 2028 */ 2029 static irqreturn_t ab8500_fg_batt_ovv_handler(int irq, void *_di) 2030 { 2031 struct ab8500_fg *di = _di; 2032 2033 dev_dbg(di->dev, "Battery OVV\n"); 2034 2035 /* Schedule a new HW failure check */ 2036 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work, 0); 2037 2038 return IRQ_HANDLED; 2039 } 2040 2041 /** 2042 * ab8500_fg_lowbatf_handler() - Battery voltage is below LOW threshold 2043 * @irq: interrupt number 2044 * @_di: pointer to the ab8500_fg structure 2045 * 2046 * Returns IRQ status(IRQ_HANDLED) 2047 */ 2048 static irqreturn_t ab8500_fg_lowbatf_handler(int irq, void *_di) 2049 { 2050 struct ab8500_fg *di = _di; 2051 2052 /* Initiate handling in ab8500_fg_low_bat_work() if not already initiated. */ 2053 if (!di->flags.low_bat_delay) { 2054 dev_warn(di->dev, "Battery voltage is below LOW threshold\n"); 2055 di->flags.low_bat_delay = true; 2056 /* 2057 * Start a timer to check LOW_BAT again after some time 2058 * This is done to avoid shutdown on single voltage dips 2059 */ 2060 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work, 2061 round_jiffies(LOW_BAT_CHECK_INTERVAL)); 2062 } 2063 return IRQ_HANDLED; 2064 } 2065 2066 /** 2067 * ab8500_fg_get_property() - get the fg properties 2068 * @psy: pointer to the power_supply structure 2069 * @psp: pointer to the power_supply_property structure 2070 * @val: pointer to the power_supply_propval union 2071 * 2072 * This function gets called when an application tries to get the 2073 * fg properties by reading the sysfs files. 2074 * voltage_now: battery voltage 2075 * current_now: battery instant current 2076 * current_avg: battery average current 2077 * charge_full_design: capacity where battery is considered full 2078 * charge_now: battery capacity in nAh 2079 * capacity: capacity in percent 2080 * capacity_level: capacity level 2081 * 2082 * Returns error code in case of failure else 0 on success 2083 */ 2084 static int ab8500_fg_get_property(struct power_supply *psy, 2085 enum power_supply_property psp, 2086 union power_supply_propval *val) 2087 { 2088 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2089 2090 /* 2091 * If battery is identified as unknown and charging of unknown 2092 * batteries is disabled, we always report 100% capacity and 2093 * capacity level UNKNOWN, since we can't calculate 2094 * remaining capacity 2095 */ 2096 2097 switch (psp) { 2098 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 2099 if (di->flags.bat_ovv) 2100 val->intval = BATT_OVV_VALUE; 2101 else 2102 val->intval = di->vbat_uv; 2103 break; 2104 case POWER_SUPPLY_PROP_CURRENT_NOW: 2105 val->intval = di->inst_curr_ua; 2106 break; 2107 case POWER_SUPPLY_PROP_CURRENT_AVG: 2108 val->intval = di->avg_curr_ua; 2109 break; 2110 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 2111 val->intval = ab8500_fg_convert_mah_to_uwh(di, 2112 di->bat_cap.max_mah_design); 2113 break; 2114 case POWER_SUPPLY_PROP_ENERGY_FULL: 2115 val->intval = ab8500_fg_convert_mah_to_uwh(di, 2116 di->bat_cap.max_mah); 2117 break; 2118 case POWER_SUPPLY_PROP_ENERGY_NOW: 2119 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat && 2120 di->flags.batt_id_received) 2121 val->intval = ab8500_fg_convert_mah_to_uwh(di, 2122 di->bat_cap.max_mah); 2123 else 2124 val->intval = ab8500_fg_convert_mah_to_uwh(di, 2125 di->bat_cap.prev_mah); 2126 break; 2127 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 2128 val->intval = di->bat_cap.max_mah_design; 2129 break; 2130 case POWER_SUPPLY_PROP_CHARGE_FULL: 2131 val->intval = di->bat_cap.max_mah; 2132 break; 2133 case POWER_SUPPLY_PROP_CHARGE_NOW: 2134 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat && 2135 di->flags.batt_id_received) 2136 val->intval = di->bat_cap.max_mah; 2137 else 2138 val->intval = di->bat_cap.prev_mah; 2139 break; 2140 case POWER_SUPPLY_PROP_CAPACITY: 2141 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat && 2142 di->flags.batt_id_received) 2143 val->intval = 100; 2144 else 2145 val->intval = di->bat_cap.prev_percent; 2146 break; 2147 case POWER_SUPPLY_PROP_CAPACITY_LEVEL: 2148 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat && 2149 di->flags.batt_id_received) 2150 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN; 2151 else 2152 val->intval = di->bat_cap.prev_level; 2153 break; 2154 default: 2155 return -EINVAL; 2156 } 2157 return 0; 2158 } 2159 2160 static int ab8500_fg_get_ext_psy_data(struct device *dev, void *data) 2161 { 2162 struct power_supply *psy; 2163 struct power_supply *ext = dev_get_drvdata(dev); 2164 const char **supplicants = (const char **)ext->supplied_to; 2165 struct ab8500_fg *di; 2166 struct power_supply_battery_info *bi; 2167 union power_supply_propval ret; 2168 int j; 2169 2170 psy = (struct power_supply *)data; 2171 di = power_supply_get_drvdata(psy); 2172 bi = di->bm->bi; 2173 2174 /* 2175 * For all psy where the name of your driver 2176 * appears in any supplied_to 2177 */ 2178 j = match_string(supplicants, ext->num_supplicants, psy->desc->name); 2179 if (j < 0) 2180 return 0; 2181 2182 /* Go through all properties for the psy */ 2183 for (j = 0; j < ext->desc->num_properties; j++) { 2184 enum power_supply_property prop; 2185 prop = ext->desc->properties[j]; 2186 2187 if (power_supply_get_property(ext, prop, &ret)) 2188 continue; 2189 2190 switch (prop) { 2191 case POWER_SUPPLY_PROP_STATUS: 2192 switch (ext->desc->type) { 2193 case POWER_SUPPLY_TYPE_BATTERY: 2194 switch (ret.intval) { 2195 case POWER_SUPPLY_STATUS_UNKNOWN: 2196 case POWER_SUPPLY_STATUS_DISCHARGING: 2197 case POWER_SUPPLY_STATUS_NOT_CHARGING: 2198 if (!di->flags.charging) 2199 break; 2200 di->flags.charging = false; 2201 di->flags.fully_charged = false; 2202 if (di->bm->capacity_scaling) 2203 ab8500_fg_update_cap_scalers(di); 2204 queue_work(di->fg_wq, &di->fg_work); 2205 break; 2206 case POWER_SUPPLY_STATUS_FULL: 2207 if (di->flags.fully_charged) 2208 break; 2209 di->flags.fully_charged = true; 2210 di->flags.force_full = true; 2211 /* Save current capacity as maximum */ 2212 di->bat_cap.max_mah = di->bat_cap.mah; 2213 queue_work(di->fg_wq, &di->fg_work); 2214 break; 2215 case POWER_SUPPLY_STATUS_CHARGING: 2216 if (di->flags.charging && 2217 !di->flags.fully_charged) 2218 break; 2219 di->flags.charging = true; 2220 di->flags.fully_charged = false; 2221 if (di->bm->capacity_scaling) 2222 ab8500_fg_update_cap_scalers(di); 2223 queue_work(di->fg_wq, &di->fg_work); 2224 break; 2225 } 2226 break; 2227 default: 2228 break; 2229 } 2230 break; 2231 case POWER_SUPPLY_PROP_TECHNOLOGY: 2232 switch (ext->desc->type) { 2233 case POWER_SUPPLY_TYPE_BATTERY: 2234 if (!di->flags.batt_id_received && 2235 (bi && (bi->technology != 2236 POWER_SUPPLY_TECHNOLOGY_UNKNOWN))) { 2237 const struct ab8500_battery_type *b; 2238 2239 b = di->bm->bat_type; 2240 2241 di->flags.batt_id_received = true; 2242 2243 di->bat_cap.max_mah_design = 2244 di->bm->bi->charge_full_design_uah; 2245 2246 di->bat_cap.max_mah = 2247 di->bat_cap.max_mah_design; 2248 2249 di->vbat_nom_uv = 2250 di->bm->bi->voltage_max_design_uv; 2251 } 2252 2253 if (ret.intval) 2254 di->flags.batt_unknown = false; 2255 else 2256 di->flags.batt_unknown = true; 2257 break; 2258 default: 2259 break; 2260 } 2261 break; 2262 case POWER_SUPPLY_PROP_TEMP: 2263 switch (ext->desc->type) { 2264 case POWER_SUPPLY_TYPE_BATTERY: 2265 if (di->flags.batt_id_received) 2266 di->bat_temp = ret.intval; 2267 break; 2268 default: 2269 break; 2270 } 2271 break; 2272 default: 2273 break; 2274 } 2275 } 2276 return 0; 2277 } 2278 2279 /** 2280 * ab8500_fg_init_hw_registers() - Set up FG related registers 2281 * @di: pointer to the ab8500_fg structure 2282 * 2283 * Set up battery OVV, low battery voltage registers 2284 */ 2285 static int ab8500_fg_init_hw_registers(struct ab8500_fg *di) 2286 { 2287 int ret; 2288 2289 /* 2290 * Set VBAT OVV (overvoltage) threshold to 4.75V (typ) this is what 2291 * the hardware supports, nothing else can be configured in hardware. 2292 * See this as an "outer limit" where the charger will certainly 2293 * shut down. Other (lower) overvoltage levels need to be implemented 2294 * in software. 2295 */ 2296 ret = abx500_mask_and_set_register_interruptible(di->dev, 2297 AB8500_CHARGER, 2298 AB8500_BATT_OVV, 2299 BATT_OVV_TH_4P75, 2300 BATT_OVV_TH_4P75); 2301 if (ret) { 2302 dev_err(di->dev, "failed to set BATT_OVV\n"); 2303 goto out; 2304 } 2305 2306 /* Enable VBAT OVV detection */ 2307 ret = abx500_mask_and_set_register_interruptible(di->dev, 2308 AB8500_CHARGER, 2309 AB8500_BATT_OVV, 2310 BATT_OVV_ENA, 2311 BATT_OVV_ENA); 2312 if (ret) { 2313 dev_err(di->dev, "failed to enable BATT_OVV\n"); 2314 goto out; 2315 } 2316 2317 /* Low Battery Voltage */ 2318 ret = abx500_set_register_interruptible(di->dev, 2319 AB8500_SYS_CTRL2_BLOCK, 2320 AB8500_LOW_BAT_REG, 2321 ab8500_volt_to_regval( 2322 di->bm->fg_params->lowbat_threshold_uv) << 1 | 2323 LOW_BAT_ENABLE); 2324 if (ret) { 2325 dev_err(di->dev, "%s write failed\n", __func__); 2326 goto out; 2327 } 2328 2329 /* Battery OK threshold */ 2330 ret = ab8500_fg_battok_init_hw_register(di); 2331 if (ret) { 2332 dev_err(di->dev, "BattOk init write failed.\n"); 2333 goto out; 2334 } 2335 2336 if (is_ab8505(di->parent)) { 2337 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2338 AB8505_RTC_PCUT_MAX_TIME_REG, di->bm->fg_params->pcut_max_time); 2339 2340 if (ret) { 2341 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_MAX_TIME_REG\n", __func__); 2342 goto out; 2343 } 2344 2345 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2346 AB8505_RTC_PCUT_FLAG_TIME_REG, di->bm->fg_params->pcut_flag_time); 2347 2348 if (ret) { 2349 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_FLAG_TIME_REG\n", __func__); 2350 goto out; 2351 } 2352 2353 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2354 AB8505_RTC_PCUT_RESTART_REG, di->bm->fg_params->pcut_max_restart); 2355 2356 if (ret) { 2357 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_RESTART_REG\n", __func__); 2358 goto out; 2359 } 2360 2361 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2362 AB8505_RTC_PCUT_DEBOUNCE_REG, di->bm->fg_params->pcut_debounce_time); 2363 2364 if (ret) { 2365 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_DEBOUNCE_REG\n", __func__); 2366 goto out; 2367 } 2368 2369 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2370 AB8505_RTC_PCUT_CTL_STATUS_REG, di->bm->fg_params->pcut_enable); 2371 2372 if (ret) { 2373 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_CTL_STATUS_REG\n", __func__); 2374 goto out; 2375 } 2376 } 2377 out: 2378 return ret; 2379 } 2380 2381 /** 2382 * ab8500_fg_external_power_changed() - callback for power supply changes 2383 * @psy: pointer to the structure power_supply 2384 * 2385 * This function is the entry point of the pointer external_power_changed 2386 * of the structure power_supply. 2387 * This function gets executed when there is a change in any external power 2388 * supply that this driver needs to be notified of. 2389 */ 2390 static void ab8500_fg_external_power_changed(struct power_supply *psy) 2391 { 2392 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2393 2394 class_for_each_device(power_supply_class, NULL, 2395 di->fg_psy, ab8500_fg_get_ext_psy_data); 2396 } 2397 2398 /** 2399 * ab8500_fg_reinit_work() - work to reset the FG algorithm 2400 * @work: pointer to the work_struct structure 2401 * 2402 * Used to reset the current battery capacity to be able to 2403 * retrigger a new voltage base capacity calculation. For 2404 * test and verification purpose. 2405 */ 2406 static void ab8500_fg_reinit_work(struct work_struct *work) 2407 { 2408 struct ab8500_fg *di = container_of(work, struct ab8500_fg, 2409 fg_reinit_work.work); 2410 2411 if (!di->flags.calibrate) { 2412 dev_dbg(di->dev, "Resetting FG state machine to init.\n"); 2413 ab8500_fg_clear_cap_samples(di); 2414 ab8500_fg_calc_cap_discharge_voltage(di, true); 2415 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT); 2416 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT); 2417 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); 2418 2419 } else { 2420 dev_err(di->dev, "Residual offset calibration ongoing " 2421 "retrying..\n"); 2422 /* Wait one second until next try*/ 2423 queue_delayed_work(di->fg_wq, &di->fg_reinit_work, 2424 round_jiffies(1)); 2425 } 2426 } 2427 2428 /* Exposure to the sysfs interface */ 2429 2430 struct ab8500_fg_sysfs_entry { 2431 struct attribute attr; 2432 ssize_t (*show)(struct ab8500_fg *, char *); 2433 ssize_t (*store)(struct ab8500_fg *, const char *, size_t); 2434 }; 2435 2436 static ssize_t charge_full_show(struct ab8500_fg *di, char *buf) 2437 { 2438 return sprintf(buf, "%d\n", di->bat_cap.max_mah); 2439 } 2440 2441 static ssize_t charge_full_store(struct ab8500_fg *di, const char *buf, 2442 size_t count) 2443 { 2444 unsigned long charge_full; 2445 int ret; 2446 2447 ret = kstrtoul(buf, 10, &charge_full); 2448 if (ret) 2449 return ret; 2450 2451 di->bat_cap.max_mah = (int) charge_full; 2452 return count; 2453 } 2454 2455 static ssize_t charge_now_show(struct ab8500_fg *di, char *buf) 2456 { 2457 return sprintf(buf, "%d\n", di->bat_cap.prev_mah); 2458 } 2459 2460 static ssize_t charge_now_store(struct ab8500_fg *di, const char *buf, 2461 size_t count) 2462 { 2463 unsigned long charge_now; 2464 int ret; 2465 2466 ret = kstrtoul(buf, 10, &charge_now); 2467 if (ret) 2468 return ret; 2469 2470 di->bat_cap.user_mah = (int) charge_now; 2471 di->flags.user_cap = true; 2472 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); 2473 return count; 2474 } 2475 2476 static struct ab8500_fg_sysfs_entry charge_full_attr = 2477 __ATTR(charge_full, 0644, charge_full_show, charge_full_store); 2478 2479 static struct ab8500_fg_sysfs_entry charge_now_attr = 2480 __ATTR(charge_now, 0644, charge_now_show, charge_now_store); 2481 2482 static ssize_t 2483 ab8500_fg_show(struct kobject *kobj, struct attribute *attr, char *buf) 2484 { 2485 struct ab8500_fg_sysfs_entry *entry; 2486 struct ab8500_fg *di; 2487 2488 entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr); 2489 di = container_of(kobj, struct ab8500_fg, fg_kobject); 2490 2491 if (!entry->show) 2492 return -EIO; 2493 2494 return entry->show(di, buf); 2495 } 2496 static ssize_t 2497 ab8500_fg_store(struct kobject *kobj, struct attribute *attr, const char *buf, 2498 size_t count) 2499 { 2500 struct ab8500_fg_sysfs_entry *entry; 2501 struct ab8500_fg *di; 2502 2503 entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr); 2504 di = container_of(kobj, struct ab8500_fg, fg_kobject); 2505 2506 if (!entry->store) 2507 return -EIO; 2508 2509 return entry->store(di, buf, count); 2510 } 2511 2512 static const struct sysfs_ops ab8500_fg_sysfs_ops = { 2513 .show = ab8500_fg_show, 2514 .store = ab8500_fg_store, 2515 }; 2516 2517 static struct attribute *ab8500_fg_attrs[] = { 2518 &charge_full_attr.attr, 2519 &charge_now_attr.attr, 2520 NULL, 2521 }; 2522 2523 static struct kobj_type ab8500_fg_ktype = { 2524 .sysfs_ops = &ab8500_fg_sysfs_ops, 2525 .default_attrs = ab8500_fg_attrs, 2526 }; 2527 2528 /** 2529 * ab8500_fg_sysfs_exit() - de-init of sysfs entry 2530 * @di: pointer to the struct ab8500_chargalg 2531 * 2532 * This function removes the entry in sysfs. 2533 */ 2534 static void ab8500_fg_sysfs_exit(struct ab8500_fg *di) 2535 { 2536 kobject_del(&di->fg_kobject); 2537 } 2538 2539 /** 2540 * ab8500_fg_sysfs_init() - init of sysfs entry 2541 * @di: pointer to the struct ab8500_chargalg 2542 * 2543 * This function adds an entry in sysfs. 2544 * Returns error code in case of failure else 0(on success) 2545 */ 2546 static int ab8500_fg_sysfs_init(struct ab8500_fg *di) 2547 { 2548 int ret = 0; 2549 2550 ret = kobject_init_and_add(&di->fg_kobject, 2551 &ab8500_fg_ktype, 2552 NULL, "battery"); 2553 if (ret < 0) 2554 dev_err(di->dev, "failed to create sysfs entry\n"); 2555 2556 return ret; 2557 } 2558 2559 static ssize_t ab8505_powercut_flagtime_read(struct device *dev, 2560 struct device_attribute *attr, 2561 char *buf) 2562 { 2563 int ret; 2564 u8 reg_value; 2565 struct power_supply *psy = dev_get_drvdata(dev); 2566 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2567 2568 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2569 AB8505_RTC_PCUT_FLAG_TIME_REG, ®_value); 2570 2571 if (ret < 0) { 2572 dev_err(dev, "Failed to read AB8505_RTC_PCUT_FLAG_TIME_REG\n"); 2573 goto fail; 2574 } 2575 2576 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F)); 2577 2578 fail: 2579 return ret; 2580 } 2581 2582 static ssize_t ab8505_powercut_flagtime_write(struct device *dev, 2583 struct device_attribute *attr, 2584 const char *buf, size_t count) 2585 { 2586 int ret; 2587 int reg_value; 2588 struct power_supply *psy = dev_get_drvdata(dev); 2589 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2590 2591 if (kstrtoint(buf, 10, ®_value)) 2592 goto fail; 2593 2594 if (reg_value > 0x7F) { 2595 dev_err(dev, "Incorrect parameter, echo 0 (1.98s) - 127 (15.625ms) for flagtime\n"); 2596 goto fail; 2597 } 2598 2599 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2600 AB8505_RTC_PCUT_FLAG_TIME_REG, (u8)reg_value); 2601 2602 if (ret < 0) 2603 dev_err(dev, "Failed to set AB8505_RTC_PCUT_FLAG_TIME_REG\n"); 2604 2605 fail: 2606 return count; 2607 } 2608 2609 static ssize_t ab8505_powercut_maxtime_read(struct device *dev, 2610 struct device_attribute *attr, 2611 char *buf) 2612 { 2613 int ret; 2614 u8 reg_value; 2615 struct power_supply *psy = dev_get_drvdata(dev); 2616 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2617 2618 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2619 AB8505_RTC_PCUT_MAX_TIME_REG, ®_value); 2620 2621 if (ret < 0) { 2622 dev_err(dev, "Failed to read AB8505_RTC_PCUT_MAX_TIME_REG\n"); 2623 goto fail; 2624 } 2625 2626 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F)); 2627 2628 fail: 2629 return ret; 2630 2631 } 2632 2633 static ssize_t ab8505_powercut_maxtime_write(struct device *dev, 2634 struct device_attribute *attr, 2635 const char *buf, size_t count) 2636 { 2637 int ret; 2638 int reg_value; 2639 struct power_supply *psy = dev_get_drvdata(dev); 2640 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2641 2642 if (kstrtoint(buf, 10, ®_value)) 2643 goto fail; 2644 2645 if (reg_value > 0x7F) { 2646 dev_err(dev, "Incorrect parameter, echo 0 (0.0s) - 127 (1.98s) for maxtime\n"); 2647 goto fail; 2648 } 2649 2650 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2651 AB8505_RTC_PCUT_MAX_TIME_REG, (u8)reg_value); 2652 2653 if (ret < 0) 2654 dev_err(dev, "Failed to set AB8505_RTC_PCUT_MAX_TIME_REG\n"); 2655 2656 fail: 2657 return count; 2658 } 2659 2660 static ssize_t ab8505_powercut_restart_read(struct device *dev, 2661 struct device_attribute *attr, 2662 char *buf) 2663 { 2664 int ret; 2665 u8 reg_value; 2666 struct power_supply *psy = dev_get_drvdata(dev); 2667 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2668 2669 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2670 AB8505_RTC_PCUT_RESTART_REG, ®_value); 2671 2672 if (ret < 0) { 2673 dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n"); 2674 goto fail; 2675 } 2676 2677 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF)); 2678 2679 fail: 2680 return ret; 2681 } 2682 2683 static ssize_t ab8505_powercut_restart_write(struct device *dev, 2684 struct device_attribute *attr, 2685 const char *buf, size_t count) 2686 { 2687 int ret; 2688 int reg_value; 2689 struct power_supply *psy = dev_get_drvdata(dev); 2690 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2691 2692 if (kstrtoint(buf, 10, ®_value)) 2693 goto fail; 2694 2695 if (reg_value > 0xF) { 2696 dev_err(dev, "Incorrect parameter, echo 0 - 15 for number of restart\n"); 2697 goto fail; 2698 } 2699 2700 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2701 AB8505_RTC_PCUT_RESTART_REG, (u8)reg_value); 2702 2703 if (ret < 0) 2704 dev_err(dev, "Failed to set AB8505_RTC_PCUT_RESTART_REG\n"); 2705 2706 fail: 2707 return count; 2708 2709 } 2710 2711 static ssize_t ab8505_powercut_timer_read(struct device *dev, 2712 struct device_attribute *attr, 2713 char *buf) 2714 { 2715 int ret; 2716 u8 reg_value; 2717 struct power_supply *psy = dev_get_drvdata(dev); 2718 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2719 2720 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2721 AB8505_RTC_PCUT_TIME_REG, ®_value); 2722 2723 if (ret < 0) { 2724 dev_err(dev, "Failed to read AB8505_RTC_PCUT_TIME_REG\n"); 2725 goto fail; 2726 } 2727 2728 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F)); 2729 2730 fail: 2731 return ret; 2732 } 2733 2734 static ssize_t ab8505_powercut_restart_counter_read(struct device *dev, 2735 struct device_attribute *attr, 2736 char *buf) 2737 { 2738 int ret; 2739 u8 reg_value; 2740 struct power_supply *psy = dev_get_drvdata(dev); 2741 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2742 2743 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2744 AB8505_RTC_PCUT_RESTART_REG, ®_value); 2745 2746 if (ret < 0) { 2747 dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n"); 2748 goto fail; 2749 } 2750 2751 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF0) >> 4); 2752 2753 fail: 2754 return ret; 2755 } 2756 2757 static ssize_t ab8505_powercut_read(struct device *dev, 2758 struct device_attribute *attr, 2759 char *buf) 2760 { 2761 int ret; 2762 u8 reg_value; 2763 struct power_supply *psy = dev_get_drvdata(dev); 2764 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2765 2766 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2767 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value); 2768 2769 if (ret < 0) 2770 goto fail; 2771 2772 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x1)); 2773 2774 fail: 2775 return ret; 2776 } 2777 2778 static ssize_t ab8505_powercut_write(struct device *dev, 2779 struct device_attribute *attr, 2780 const char *buf, size_t count) 2781 { 2782 int ret; 2783 int reg_value; 2784 struct power_supply *psy = dev_get_drvdata(dev); 2785 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2786 2787 if (kstrtoint(buf, 10, ®_value)) 2788 goto fail; 2789 2790 if (reg_value > 0x1) { 2791 dev_err(dev, "Incorrect parameter, echo 0/1 to disable/enable Pcut feature\n"); 2792 goto fail; 2793 } 2794 2795 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2796 AB8505_RTC_PCUT_CTL_STATUS_REG, (u8)reg_value); 2797 2798 if (ret < 0) 2799 dev_err(dev, "Failed to set AB8505_RTC_PCUT_CTL_STATUS_REG\n"); 2800 2801 fail: 2802 return count; 2803 } 2804 2805 static ssize_t ab8505_powercut_flag_read(struct device *dev, 2806 struct device_attribute *attr, 2807 char *buf) 2808 { 2809 2810 int ret; 2811 u8 reg_value; 2812 struct power_supply *psy = dev_get_drvdata(dev); 2813 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2814 2815 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2816 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value); 2817 2818 if (ret < 0) { 2819 dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n"); 2820 goto fail; 2821 } 2822 2823 return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x10) >> 4)); 2824 2825 fail: 2826 return ret; 2827 } 2828 2829 static ssize_t ab8505_powercut_debounce_read(struct device *dev, 2830 struct device_attribute *attr, 2831 char *buf) 2832 { 2833 int ret; 2834 u8 reg_value; 2835 struct power_supply *psy = dev_get_drvdata(dev); 2836 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2837 2838 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2839 AB8505_RTC_PCUT_DEBOUNCE_REG, ®_value); 2840 2841 if (ret < 0) { 2842 dev_err(dev, "Failed to read AB8505_RTC_PCUT_DEBOUNCE_REG\n"); 2843 goto fail; 2844 } 2845 2846 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7)); 2847 2848 fail: 2849 return ret; 2850 } 2851 2852 static ssize_t ab8505_powercut_debounce_write(struct device *dev, 2853 struct device_attribute *attr, 2854 const char *buf, size_t count) 2855 { 2856 int ret; 2857 int reg_value; 2858 struct power_supply *psy = dev_get_drvdata(dev); 2859 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2860 2861 if (kstrtoint(buf, 10, ®_value)) 2862 goto fail; 2863 2864 if (reg_value > 0x7) { 2865 dev_err(dev, "Incorrect parameter, echo 0 to 7 for debounce setting\n"); 2866 goto fail; 2867 } 2868 2869 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2870 AB8505_RTC_PCUT_DEBOUNCE_REG, (u8)reg_value); 2871 2872 if (ret < 0) 2873 dev_err(dev, "Failed to set AB8505_RTC_PCUT_DEBOUNCE_REG\n"); 2874 2875 fail: 2876 return count; 2877 } 2878 2879 static ssize_t ab8505_powercut_enable_status_read(struct device *dev, 2880 struct device_attribute *attr, 2881 char *buf) 2882 { 2883 int ret; 2884 u8 reg_value; 2885 struct power_supply *psy = dev_get_drvdata(dev); 2886 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2887 2888 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2889 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value); 2890 2891 if (ret < 0) { 2892 dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n"); 2893 goto fail; 2894 } 2895 2896 return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x20) >> 5)); 2897 2898 fail: 2899 return ret; 2900 } 2901 2902 static struct device_attribute ab8505_fg_sysfs_psy_attrs[] = { 2903 __ATTR(powercut_flagtime, (S_IRUGO | S_IWUSR | S_IWGRP), 2904 ab8505_powercut_flagtime_read, ab8505_powercut_flagtime_write), 2905 __ATTR(powercut_maxtime, (S_IRUGO | S_IWUSR | S_IWGRP), 2906 ab8505_powercut_maxtime_read, ab8505_powercut_maxtime_write), 2907 __ATTR(powercut_restart_max, (S_IRUGO | S_IWUSR | S_IWGRP), 2908 ab8505_powercut_restart_read, ab8505_powercut_restart_write), 2909 __ATTR(powercut_timer, S_IRUGO, ab8505_powercut_timer_read, NULL), 2910 __ATTR(powercut_restart_counter, S_IRUGO, 2911 ab8505_powercut_restart_counter_read, NULL), 2912 __ATTR(powercut_enable, (S_IRUGO | S_IWUSR | S_IWGRP), 2913 ab8505_powercut_read, ab8505_powercut_write), 2914 __ATTR(powercut_flag, S_IRUGO, ab8505_powercut_flag_read, NULL), 2915 __ATTR(powercut_debounce_time, (S_IRUGO | S_IWUSR | S_IWGRP), 2916 ab8505_powercut_debounce_read, ab8505_powercut_debounce_write), 2917 __ATTR(powercut_enable_status, S_IRUGO, 2918 ab8505_powercut_enable_status_read, NULL), 2919 }; 2920 2921 static int ab8500_fg_sysfs_psy_create_attrs(struct ab8500_fg *di) 2922 { 2923 unsigned int i; 2924 2925 if (is_ab8505(di->parent)) { 2926 for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++) 2927 if (device_create_file(&di->fg_psy->dev, 2928 &ab8505_fg_sysfs_psy_attrs[i])) 2929 goto sysfs_psy_create_attrs_failed_ab8505; 2930 } 2931 return 0; 2932 sysfs_psy_create_attrs_failed_ab8505: 2933 dev_err(&di->fg_psy->dev, "Failed creating sysfs psy attrs for ab8505.\n"); 2934 while (i--) 2935 device_remove_file(&di->fg_psy->dev, 2936 &ab8505_fg_sysfs_psy_attrs[i]); 2937 2938 return -EIO; 2939 } 2940 2941 static void ab8500_fg_sysfs_psy_remove_attrs(struct ab8500_fg *di) 2942 { 2943 unsigned int i; 2944 2945 if (is_ab8505(di->parent)) { 2946 for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++) 2947 (void)device_remove_file(&di->fg_psy->dev, 2948 &ab8505_fg_sysfs_psy_attrs[i]); 2949 } 2950 } 2951 2952 /* Exposure to the sysfs interface <<END>> */ 2953 2954 static int __maybe_unused ab8500_fg_resume(struct device *dev) 2955 { 2956 struct ab8500_fg *di = dev_get_drvdata(dev); 2957 2958 /* 2959 * Change state if we're not charging. If we're charging we will wake 2960 * up on the FG IRQ 2961 */ 2962 if (!di->flags.charging) { 2963 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_WAKEUP); 2964 queue_work(di->fg_wq, &di->fg_work); 2965 } 2966 2967 return 0; 2968 } 2969 2970 static int __maybe_unused ab8500_fg_suspend(struct device *dev) 2971 { 2972 struct ab8500_fg *di = dev_get_drvdata(dev); 2973 2974 flush_delayed_work(&di->fg_periodic_work); 2975 flush_work(&di->fg_work); 2976 flush_work(&di->fg_acc_cur_work); 2977 flush_delayed_work(&di->fg_reinit_work); 2978 flush_delayed_work(&di->fg_low_bat_work); 2979 flush_delayed_work(&di->fg_check_hw_failure_work); 2980 2981 /* 2982 * If the FG is enabled we will disable it before going to suspend 2983 * only if we're not charging 2984 */ 2985 if (di->flags.fg_enabled && !di->flags.charging) 2986 ab8500_fg_coulomb_counter(di, false); 2987 2988 return 0; 2989 } 2990 2991 /* ab8500 fg driver interrupts and their respective isr */ 2992 static struct ab8500_fg_interrupts ab8500_fg_irq[] = { 2993 {"NCONV_ACCU", ab8500_fg_cc_convend_handler}, 2994 {"BATT_OVV", ab8500_fg_batt_ovv_handler}, 2995 {"LOW_BAT_F", ab8500_fg_lowbatf_handler}, 2996 {"CC_INT_CALIB", ab8500_fg_cc_int_calib_handler}, 2997 {"CCEOC", ab8500_fg_cc_data_end_handler}, 2998 }; 2999 3000 static char *supply_interface[] = { 3001 "ab8500_chargalg", 3002 "ab8500_usb", 3003 }; 3004 3005 static const struct power_supply_desc ab8500_fg_desc = { 3006 .name = "ab8500_fg", 3007 .type = POWER_SUPPLY_TYPE_BATTERY, 3008 .properties = ab8500_fg_props, 3009 .num_properties = ARRAY_SIZE(ab8500_fg_props), 3010 .get_property = ab8500_fg_get_property, 3011 .external_power_changed = ab8500_fg_external_power_changed, 3012 }; 3013 3014 static int ab8500_fg_bind(struct device *dev, struct device *master, 3015 void *data) 3016 { 3017 struct ab8500_fg *di = dev_get_drvdata(dev); 3018 3019 /* Create a work queue for running the FG algorithm */ 3020 di->fg_wq = alloc_ordered_workqueue("ab8500_fg_wq", WQ_MEM_RECLAIM); 3021 if (di->fg_wq == NULL) { 3022 dev_err(dev, "failed to create work queue\n"); 3023 return -ENOMEM; 3024 } 3025 3026 di->bat_cap.max_mah_design = di->bm->bi->charge_full_design_uah; 3027 di->bat_cap.max_mah = di->bat_cap.max_mah_design; 3028 di->vbat_nom_uv = di->bm->bi->voltage_max_design_uv; 3029 3030 /* Start the coulomb counter */ 3031 ab8500_fg_coulomb_counter(di, true); 3032 /* Run the FG algorithm */ 3033 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); 3034 3035 return 0; 3036 } 3037 3038 static void ab8500_fg_unbind(struct device *dev, struct device *master, 3039 void *data) 3040 { 3041 struct ab8500_fg *di = dev_get_drvdata(dev); 3042 int ret; 3043 3044 /* Disable coulomb counter */ 3045 ret = ab8500_fg_coulomb_counter(di, false); 3046 if (ret) 3047 dev_err(dev, "failed to disable coulomb counter\n"); 3048 3049 destroy_workqueue(di->fg_wq); 3050 flush_scheduled_work(); 3051 } 3052 3053 static const struct component_ops ab8500_fg_component_ops = { 3054 .bind = ab8500_fg_bind, 3055 .unbind = ab8500_fg_unbind, 3056 }; 3057 3058 static int ab8500_fg_probe(struct platform_device *pdev) 3059 { 3060 struct device *dev = &pdev->dev; 3061 struct power_supply_config psy_cfg = {}; 3062 struct ab8500_fg *di; 3063 int i, irq; 3064 int ret = 0; 3065 3066 di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL); 3067 if (!di) 3068 return -ENOMEM; 3069 3070 di->bm = &ab8500_bm_data; 3071 3072 mutex_init(&di->cc_lock); 3073 3074 /* get parent data */ 3075 di->dev = dev; 3076 di->parent = dev_get_drvdata(pdev->dev.parent); 3077 3078 di->main_bat_v = devm_iio_channel_get(dev, "main_bat_v"); 3079 if (IS_ERR(di->main_bat_v)) { 3080 ret = dev_err_probe(dev, PTR_ERR(di->main_bat_v), 3081 "failed to get main battery ADC channel\n"); 3082 return ret; 3083 } 3084 3085 psy_cfg.supplied_to = supply_interface; 3086 psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface); 3087 psy_cfg.drv_data = di; 3088 3089 di->init_capacity = true; 3090 3091 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT); 3092 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT); 3093 3094 /* Init work for running the fg algorithm instantly */ 3095 INIT_WORK(&di->fg_work, ab8500_fg_instant_work); 3096 3097 /* Init work for getting the battery accumulated current */ 3098 INIT_WORK(&di->fg_acc_cur_work, ab8500_fg_acc_cur_work); 3099 3100 /* Init work for reinitialising the fg algorithm */ 3101 INIT_DEFERRABLE_WORK(&di->fg_reinit_work, 3102 ab8500_fg_reinit_work); 3103 3104 /* Work delayed Queue to run the state machine */ 3105 INIT_DEFERRABLE_WORK(&di->fg_periodic_work, 3106 ab8500_fg_periodic_work); 3107 3108 /* Work to check low battery condition */ 3109 INIT_DEFERRABLE_WORK(&di->fg_low_bat_work, 3110 ab8500_fg_low_bat_work); 3111 3112 /* Init work for HW failure check */ 3113 INIT_DEFERRABLE_WORK(&di->fg_check_hw_failure_work, 3114 ab8500_fg_check_hw_failure_work); 3115 3116 /* Reset battery low voltage flag */ 3117 di->flags.low_bat = false; 3118 3119 /* Initialize low battery counter */ 3120 di->low_bat_cnt = 10; 3121 3122 /* Initialize OVV, and other registers */ 3123 ret = ab8500_fg_init_hw_registers(di); 3124 if (ret) { 3125 dev_err(dev, "failed to initialize registers\n"); 3126 return ret; 3127 } 3128 3129 /* Consider battery unknown until we're informed otherwise */ 3130 di->flags.batt_unknown = true; 3131 di->flags.batt_id_received = false; 3132 3133 /* Register FG power supply class */ 3134 di->fg_psy = devm_power_supply_register(dev, &ab8500_fg_desc, &psy_cfg); 3135 if (IS_ERR(di->fg_psy)) { 3136 dev_err(dev, "failed to register FG psy\n"); 3137 return PTR_ERR(di->fg_psy); 3138 } 3139 3140 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer); 3141 3142 /* 3143 * Initialize completion used to notify completion and start 3144 * of inst current 3145 */ 3146 init_completion(&di->ab8500_fg_started); 3147 init_completion(&di->ab8500_fg_complete); 3148 3149 /* Register primary interrupt handlers */ 3150 for (i = 0; i < ARRAY_SIZE(ab8500_fg_irq); i++) { 3151 irq = platform_get_irq_byname(pdev, ab8500_fg_irq[i].name); 3152 if (irq < 0) 3153 return irq; 3154 3155 ret = devm_request_threaded_irq(dev, irq, NULL, 3156 ab8500_fg_irq[i].isr, 3157 IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT, 3158 ab8500_fg_irq[i].name, di); 3159 3160 if (ret != 0) { 3161 dev_err(dev, "failed to request %s IRQ %d: %d\n", 3162 ab8500_fg_irq[i].name, irq, ret); 3163 return ret; 3164 } 3165 dev_dbg(dev, "Requested %s IRQ %d: %d\n", 3166 ab8500_fg_irq[i].name, irq, ret); 3167 } 3168 3169 di->irq = platform_get_irq_byname(pdev, "CCEOC"); 3170 disable_irq(di->irq); 3171 di->nbr_cceoc_irq_cnt = 0; 3172 3173 platform_set_drvdata(pdev, di); 3174 3175 ret = ab8500_fg_sysfs_init(di); 3176 if (ret) { 3177 dev_err(dev, "failed to create sysfs entry\n"); 3178 return ret; 3179 } 3180 3181 ret = ab8500_fg_sysfs_psy_create_attrs(di); 3182 if (ret) { 3183 dev_err(dev, "failed to create FG psy\n"); 3184 ab8500_fg_sysfs_exit(di); 3185 return ret; 3186 } 3187 3188 /* Calibrate the fg first time */ 3189 di->flags.calibrate = true; 3190 di->calib_state = AB8500_FG_CALIB_INIT; 3191 3192 /* Use room temp as default value until we get an update from driver. */ 3193 di->bat_temp = 210; 3194 3195 list_add_tail(&di->node, &ab8500_fg_list); 3196 3197 return component_add(dev, &ab8500_fg_component_ops); 3198 } 3199 3200 static int ab8500_fg_remove(struct platform_device *pdev) 3201 { 3202 int ret = 0; 3203 struct ab8500_fg *di = platform_get_drvdata(pdev); 3204 3205 component_del(&pdev->dev, &ab8500_fg_component_ops); 3206 list_del(&di->node); 3207 ab8500_fg_sysfs_exit(di); 3208 ab8500_fg_sysfs_psy_remove_attrs(di); 3209 3210 return ret; 3211 } 3212 3213 static SIMPLE_DEV_PM_OPS(ab8500_fg_pm_ops, ab8500_fg_suspend, ab8500_fg_resume); 3214 3215 static const struct of_device_id ab8500_fg_match[] = { 3216 { .compatible = "stericsson,ab8500-fg", }, 3217 { }, 3218 }; 3219 MODULE_DEVICE_TABLE(of, ab8500_fg_match); 3220 3221 struct platform_driver ab8500_fg_driver = { 3222 .probe = ab8500_fg_probe, 3223 .remove = ab8500_fg_remove, 3224 .driver = { 3225 .name = "ab8500-fg", 3226 .of_match_table = ab8500_fg_match, 3227 .pm = &ab8500_fg_pm_ops, 3228 }, 3229 }; 3230 MODULE_LICENSE("GPL v2"); 3231 MODULE_AUTHOR("Johan Palsson, Karl Komierowski"); 3232 MODULE_ALIAS("platform:ab8500-fg"); 3233 MODULE_DESCRIPTION("AB8500 Fuel Gauge driver"); 3234