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