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 union power_supply_propval ret; 2144 int j; 2145 2146 psy = (struct power_supply *)data; 2147 di = power_supply_get_drvdata(psy); 2148 2149 /* 2150 * For all psy where the name of your driver 2151 * appears in any supplied_to 2152 */ 2153 j = match_string(supplicants, ext->num_supplicants, psy->desc->name); 2154 if (j < 0) 2155 return 0; 2156 2157 /* Go through all properties for the psy */ 2158 for (j = 0; j < ext->desc->num_properties; j++) { 2159 enum power_supply_property prop; 2160 prop = ext->desc->properties[j]; 2161 2162 if (power_supply_get_property(ext, prop, &ret)) 2163 continue; 2164 2165 switch (prop) { 2166 case POWER_SUPPLY_PROP_STATUS: 2167 switch (ext->desc->type) { 2168 case POWER_SUPPLY_TYPE_BATTERY: 2169 switch (ret.intval) { 2170 case POWER_SUPPLY_STATUS_UNKNOWN: 2171 case POWER_SUPPLY_STATUS_DISCHARGING: 2172 case POWER_SUPPLY_STATUS_NOT_CHARGING: 2173 if (!di->flags.charging) 2174 break; 2175 di->flags.charging = false; 2176 di->flags.fully_charged = false; 2177 if (di->bm->capacity_scaling) 2178 ab8500_fg_update_cap_scalers(di); 2179 queue_work(di->fg_wq, &di->fg_work); 2180 break; 2181 case POWER_SUPPLY_STATUS_FULL: 2182 if (di->flags.fully_charged) 2183 break; 2184 di->flags.fully_charged = true; 2185 di->flags.force_full = true; 2186 /* Save current capacity as maximum */ 2187 di->bat_cap.max_mah = di->bat_cap.mah; 2188 queue_work(di->fg_wq, &di->fg_work); 2189 break; 2190 case POWER_SUPPLY_STATUS_CHARGING: 2191 if (di->flags.charging && 2192 !di->flags.fully_charged) 2193 break; 2194 di->flags.charging = true; 2195 di->flags.fully_charged = false; 2196 if (di->bm->capacity_scaling) 2197 ab8500_fg_update_cap_scalers(di); 2198 queue_work(di->fg_wq, &di->fg_work); 2199 break; 2200 } 2201 break; 2202 default: 2203 break; 2204 } 2205 break; 2206 case POWER_SUPPLY_PROP_TECHNOLOGY: 2207 switch (ext->desc->type) { 2208 case POWER_SUPPLY_TYPE_BATTERY: 2209 if (!di->flags.batt_id_received && 2210 (di->bm->bi.technology != 2211 POWER_SUPPLY_TECHNOLOGY_UNKNOWN)) { 2212 const struct ab8500_battery_type *b; 2213 2214 b = di->bm->bat_type; 2215 2216 di->flags.batt_id_received = true; 2217 2218 di->bat_cap.max_mah_design = 2219 di->bm->bi.charge_full_design_uah; 2220 2221 di->bat_cap.max_mah = 2222 di->bat_cap.max_mah_design; 2223 2224 di->vbat_nom_uv = 2225 di->bm->bi.voltage_max_design_uv; 2226 } 2227 2228 if (ret.intval) 2229 di->flags.batt_unknown = false; 2230 else 2231 di->flags.batt_unknown = true; 2232 break; 2233 default: 2234 break; 2235 } 2236 break; 2237 case POWER_SUPPLY_PROP_TEMP: 2238 switch (ext->desc->type) { 2239 case POWER_SUPPLY_TYPE_BATTERY: 2240 if (di->flags.batt_id_received) 2241 di->bat_temp = ret.intval; 2242 break; 2243 default: 2244 break; 2245 } 2246 break; 2247 default: 2248 break; 2249 } 2250 } 2251 return 0; 2252 } 2253 2254 /** 2255 * ab8500_fg_init_hw_registers() - Set up FG related registers 2256 * @di: pointer to the ab8500_fg structure 2257 * 2258 * Set up battery OVV, low battery voltage registers 2259 */ 2260 static int ab8500_fg_init_hw_registers(struct ab8500_fg *di) 2261 { 2262 int ret; 2263 2264 /* Set VBAT OVV threshold */ 2265 ret = abx500_mask_and_set_register_interruptible(di->dev, 2266 AB8500_CHARGER, 2267 AB8500_BATT_OVV, 2268 BATT_OVV_TH_4P75, 2269 BATT_OVV_TH_4P75); 2270 if (ret) { 2271 dev_err(di->dev, "failed to set BATT_OVV\n"); 2272 goto out; 2273 } 2274 2275 /* Enable VBAT OVV detection */ 2276 ret = abx500_mask_and_set_register_interruptible(di->dev, 2277 AB8500_CHARGER, 2278 AB8500_BATT_OVV, 2279 BATT_OVV_ENA, 2280 BATT_OVV_ENA); 2281 if (ret) { 2282 dev_err(di->dev, "failed to enable BATT_OVV\n"); 2283 goto out; 2284 } 2285 2286 /* Low Battery Voltage */ 2287 ret = abx500_set_register_interruptible(di->dev, 2288 AB8500_SYS_CTRL2_BLOCK, 2289 AB8500_LOW_BAT_REG, 2290 ab8500_volt_to_regval( 2291 di->bm->fg_params->lowbat_threshold_uv) << 1 | 2292 LOW_BAT_ENABLE); 2293 if (ret) { 2294 dev_err(di->dev, "%s write failed\n", __func__); 2295 goto out; 2296 } 2297 2298 /* Battery OK threshold */ 2299 ret = ab8500_fg_battok_init_hw_register(di); 2300 if (ret) { 2301 dev_err(di->dev, "BattOk init write failed.\n"); 2302 goto out; 2303 } 2304 2305 if (is_ab8505(di->parent)) { 2306 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2307 AB8505_RTC_PCUT_MAX_TIME_REG, di->bm->fg_params->pcut_max_time); 2308 2309 if (ret) { 2310 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_MAX_TIME_REG\n", __func__); 2311 goto out; 2312 } 2313 2314 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2315 AB8505_RTC_PCUT_FLAG_TIME_REG, di->bm->fg_params->pcut_flag_time); 2316 2317 if (ret) { 2318 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_FLAG_TIME_REG\n", __func__); 2319 goto out; 2320 } 2321 2322 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2323 AB8505_RTC_PCUT_RESTART_REG, di->bm->fg_params->pcut_max_restart); 2324 2325 if (ret) { 2326 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_RESTART_REG\n", __func__); 2327 goto out; 2328 } 2329 2330 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2331 AB8505_RTC_PCUT_DEBOUNCE_REG, di->bm->fg_params->pcut_debounce_time); 2332 2333 if (ret) { 2334 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_DEBOUNCE_REG\n", __func__); 2335 goto out; 2336 } 2337 2338 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2339 AB8505_RTC_PCUT_CTL_STATUS_REG, di->bm->fg_params->pcut_enable); 2340 2341 if (ret) { 2342 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_CTL_STATUS_REG\n", __func__); 2343 goto out; 2344 } 2345 } 2346 out: 2347 return ret; 2348 } 2349 2350 /** 2351 * ab8500_fg_external_power_changed() - callback for power supply changes 2352 * @psy: pointer to the structure power_supply 2353 * 2354 * This function is the entry point of the pointer external_power_changed 2355 * of the structure power_supply. 2356 * This function gets executed when there is a change in any external power 2357 * supply that this driver needs to be notified of. 2358 */ 2359 static void ab8500_fg_external_power_changed(struct power_supply *psy) 2360 { 2361 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2362 2363 class_for_each_device(power_supply_class, NULL, 2364 di->fg_psy, ab8500_fg_get_ext_psy_data); 2365 } 2366 2367 /** 2368 * ab8500_fg_reinit_work() - work to reset the FG algorithm 2369 * @work: pointer to the work_struct structure 2370 * 2371 * Used to reset the current battery capacity to be able to 2372 * retrigger a new voltage base capacity calculation. For 2373 * test and verification purpose. 2374 */ 2375 static void ab8500_fg_reinit_work(struct work_struct *work) 2376 { 2377 struct ab8500_fg *di = container_of(work, struct ab8500_fg, 2378 fg_reinit_work.work); 2379 2380 if (!di->flags.calibrate) { 2381 dev_dbg(di->dev, "Resetting FG state machine to init.\n"); 2382 ab8500_fg_clear_cap_samples(di); 2383 ab8500_fg_calc_cap_discharge_voltage(di, true); 2384 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT); 2385 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT); 2386 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); 2387 2388 } else { 2389 dev_err(di->dev, "Residual offset calibration ongoing " 2390 "retrying..\n"); 2391 /* Wait one second until next try*/ 2392 queue_delayed_work(di->fg_wq, &di->fg_reinit_work, 2393 round_jiffies(1)); 2394 } 2395 } 2396 2397 /* Exposure to the sysfs interface */ 2398 2399 struct ab8500_fg_sysfs_entry { 2400 struct attribute attr; 2401 ssize_t (*show)(struct ab8500_fg *, char *); 2402 ssize_t (*store)(struct ab8500_fg *, const char *, size_t); 2403 }; 2404 2405 static ssize_t charge_full_show(struct ab8500_fg *di, char *buf) 2406 { 2407 return sprintf(buf, "%d\n", di->bat_cap.max_mah); 2408 } 2409 2410 static ssize_t charge_full_store(struct ab8500_fg *di, const char *buf, 2411 size_t count) 2412 { 2413 unsigned long charge_full; 2414 int ret; 2415 2416 ret = kstrtoul(buf, 10, &charge_full); 2417 if (ret) 2418 return ret; 2419 2420 di->bat_cap.max_mah = (int) charge_full; 2421 return count; 2422 } 2423 2424 static ssize_t charge_now_show(struct ab8500_fg *di, char *buf) 2425 { 2426 return sprintf(buf, "%d\n", di->bat_cap.prev_mah); 2427 } 2428 2429 static ssize_t charge_now_store(struct ab8500_fg *di, const char *buf, 2430 size_t count) 2431 { 2432 unsigned long charge_now; 2433 int ret; 2434 2435 ret = kstrtoul(buf, 10, &charge_now); 2436 if (ret) 2437 return ret; 2438 2439 di->bat_cap.user_mah = (int) charge_now; 2440 di->flags.user_cap = true; 2441 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); 2442 return count; 2443 } 2444 2445 static struct ab8500_fg_sysfs_entry charge_full_attr = 2446 __ATTR(charge_full, 0644, charge_full_show, charge_full_store); 2447 2448 static struct ab8500_fg_sysfs_entry charge_now_attr = 2449 __ATTR(charge_now, 0644, charge_now_show, charge_now_store); 2450 2451 static ssize_t 2452 ab8500_fg_show(struct kobject *kobj, struct attribute *attr, char *buf) 2453 { 2454 struct ab8500_fg_sysfs_entry *entry; 2455 struct ab8500_fg *di; 2456 2457 entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr); 2458 di = container_of(kobj, struct ab8500_fg, fg_kobject); 2459 2460 if (!entry->show) 2461 return -EIO; 2462 2463 return entry->show(di, buf); 2464 } 2465 static ssize_t 2466 ab8500_fg_store(struct kobject *kobj, struct attribute *attr, const char *buf, 2467 size_t count) 2468 { 2469 struct ab8500_fg_sysfs_entry *entry; 2470 struct ab8500_fg *di; 2471 2472 entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr); 2473 di = container_of(kobj, struct ab8500_fg, fg_kobject); 2474 2475 if (!entry->store) 2476 return -EIO; 2477 2478 return entry->store(di, buf, count); 2479 } 2480 2481 static const struct sysfs_ops ab8500_fg_sysfs_ops = { 2482 .show = ab8500_fg_show, 2483 .store = ab8500_fg_store, 2484 }; 2485 2486 static struct attribute *ab8500_fg_attrs[] = { 2487 &charge_full_attr.attr, 2488 &charge_now_attr.attr, 2489 NULL, 2490 }; 2491 2492 static struct kobj_type ab8500_fg_ktype = { 2493 .sysfs_ops = &ab8500_fg_sysfs_ops, 2494 .default_attrs = ab8500_fg_attrs, 2495 }; 2496 2497 /** 2498 * ab8500_fg_sysfs_exit() - de-init of sysfs entry 2499 * @di: pointer to the struct ab8500_chargalg 2500 * 2501 * This function removes the entry in sysfs. 2502 */ 2503 static void ab8500_fg_sysfs_exit(struct ab8500_fg *di) 2504 { 2505 kobject_del(&di->fg_kobject); 2506 } 2507 2508 /** 2509 * ab8500_fg_sysfs_init() - init of sysfs entry 2510 * @di: pointer to the struct ab8500_chargalg 2511 * 2512 * This function adds an entry in sysfs. 2513 * Returns error code in case of failure else 0(on success) 2514 */ 2515 static int ab8500_fg_sysfs_init(struct ab8500_fg *di) 2516 { 2517 int ret = 0; 2518 2519 ret = kobject_init_and_add(&di->fg_kobject, 2520 &ab8500_fg_ktype, 2521 NULL, "battery"); 2522 if (ret < 0) 2523 dev_err(di->dev, "failed to create sysfs entry\n"); 2524 2525 return ret; 2526 } 2527 2528 static ssize_t ab8505_powercut_flagtime_read(struct device *dev, 2529 struct device_attribute *attr, 2530 char *buf) 2531 { 2532 int ret; 2533 u8 reg_value; 2534 struct power_supply *psy = dev_get_drvdata(dev); 2535 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2536 2537 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2538 AB8505_RTC_PCUT_FLAG_TIME_REG, ®_value); 2539 2540 if (ret < 0) { 2541 dev_err(dev, "Failed to read AB8505_RTC_PCUT_FLAG_TIME_REG\n"); 2542 goto fail; 2543 } 2544 2545 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F)); 2546 2547 fail: 2548 return ret; 2549 } 2550 2551 static ssize_t ab8505_powercut_flagtime_write(struct device *dev, 2552 struct device_attribute *attr, 2553 const char *buf, size_t count) 2554 { 2555 int ret; 2556 int reg_value; 2557 struct power_supply *psy = dev_get_drvdata(dev); 2558 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2559 2560 if (kstrtoint(buf, 10, ®_value)) 2561 goto fail; 2562 2563 if (reg_value > 0x7F) { 2564 dev_err(dev, "Incorrect parameter, echo 0 (1.98s) - 127 (15.625ms) for flagtime\n"); 2565 goto fail; 2566 } 2567 2568 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2569 AB8505_RTC_PCUT_FLAG_TIME_REG, (u8)reg_value); 2570 2571 if (ret < 0) 2572 dev_err(dev, "Failed to set AB8505_RTC_PCUT_FLAG_TIME_REG\n"); 2573 2574 fail: 2575 return count; 2576 } 2577 2578 static ssize_t ab8505_powercut_maxtime_read(struct device *dev, 2579 struct device_attribute *attr, 2580 char *buf) 2581 { 2582 int ret; 2583 u8 reg_value; 2584 struct power_supply *psy = dev_get_drvdata(dev); 2585 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2586 2587 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2588 AB8505_RTC_PCUT_MAX_TIME_REG, ®_value); 2589 2590 if (ret < 0) { 2591 dev_err(dev, "Failed to read AB8505_RTC_PCUT_MAX_TIME_REG\n"); 2592 goto fail; 2593 } 2594 2595 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F)); 2596 2597 fail: 2598 return ret; 2599 2600 } 2601 2602 static ssize_t ab8505_powercut_maxtime_write(struct device *dev, 2603 struct device_attribute *attr, 2604 const char *buf, size_t count) 2605 { 2606 int ret; 2607 int reg_value; 2608 struct power_supply *psy = dev_get_drvdata(dev); 2609 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2610 2611 if (kstrtoint(buf, 10, ®_value)) 2612 goto fail; 2613 2614 if (reg_value > 0x7F) { 2615 dev_err(dev, "Incorrect parameter, echo 0 (0.0s) - 127 (1.98s) for maxtime\n"); 2616 goto fail; 2617 } 2618 2619 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2620 AB8505_RTC_PCUT_MAX_TIME_REG, (u8)reg_value); 2621 2622 if (ret < 0) 2623 dev_err(dev, "Failed to set AB8505_RTC_PCUT_MAX_TIME_REG\n"); 2624 2625 fail: 2626 return count; 2627 } 2628 2629 static ssize_t ab8505_powercut_restart_read(struct device *dev, 2630 struct device_attribute *attr, 2631 char *buf) 2632 { 2633 int ret; 2634 u8 reg_value; 2635 struct power_supply *psy = dev_get_drvdata(dev); 2636 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2637 2638 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2639 AB8505_RTC_PCUT_RESTART_REG, ®_value); 2640 2641 if (ret < 0) { 2642 dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n"); 2643 goto fail; 2644 } 2645 2646 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF)); 2647 2648 fail: 2649 return ret; 2650 } 2651 2652 static ssize_t ab8505_powercut_restart_write(struct device *dev, 2653 struct device_attribute *attr, 2654 const char *buf, size_t count) 2655 { 2656 int ret; 2657 int reg_value; 2658 struct power_supply *psy = dev_get_drvdata(dev); 2659 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2660 2661 if (kstrtoint(buf, 10, ®_value)) 2662 goto fail; 2663 2664 if (reg_value > 0xF) { 2665 dev_err(dev, "Incorrect parameter, echo 0 - 15 for number of restart\n"); 2666 goto fail; 2667 } 2668 2669 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2670 AB8505_RTC_PCUT_RESTART_REG, (u8)reg_value); 2671 2672 if (ret < 0) 2673 dev_err(dev, "Failed to set AB8505_RTC_PCUT_RESTART_REG\n"); 2674 2675 fail: 2676 return count; 2677 2678 } 2679 2680 static ssize_t ab8505_powercut_timer_read(struct device *dev, 2681 struct device_attribute *attr, 2682 char *buf) 2683 { 2684 int ret; 2685 u8 reg_value; 2686 struct power_supply *psy = dev_get_drvdata(dev); 2687 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2688 2689 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2690 AB8505_RTC_PCUT_TIME_REG, ®_value); 2691 2692 if (ret < 0) { 2693 dev_err(dev, "Failed to read AB8505_RTC_PCUT_TIME_REG\n"); 2694 goto fail; 2695 } 2696 2697 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F)); 2698 2699 fail: 2700 return ret; 2701 } 2702 2703 static ssize_t ab8505_powercut_restart_counter_read(struct device *dev, 2704 struct device_attribute *attr, 2705 char *buf) 2706 { 2707 int ret; 2708 u8 reg_value; 2709 struct power_supply *psy = dev_get_drvdata(dev); 2710 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2711 2712 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2713 AB8505_RTC_PCUT_RESTART_REG, ®_value); 2714 2715 if (ret < 0) { 2716 dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n"); 2717 goto fail; 2718 } 2719 2720 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF0) >> 4); 2721 2722 fail: 2723 return ret; 2724 } 2725 2726 static ssize_t ab8505_powercut_read(struct device *dev, 2727 struct device_attribute *attr, 2728 char *buf) 2729 { 2730 int ret; 2731 u8 reg_value; 2732 struct power_supply *psy = dev_get_drvdata(dev); 2733 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2734 2735 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2736 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value); 2737 2738 if (ret < 0) 2739 goto fail; 2740 2741 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x1)); 2742 2743 fail: 2744 return ret; 2745 } 2746 2747 static ssize_t ab8505_powercut_write(struct device *dev, 2748 struct device_attribute *attr, 2749 const char *buf, size_t count) 2750 { 2751 int ret; 2752 int reg_value; 2753 struct power_supply *psy = dev_get_drvdata(dev); 2754 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2755 2756 if (kstrtoint(buf, 10, ®_value)) 2757 goto fail; 2758 2759 if (reg_value > 0x1) { 2760 dev_err(dev, "Incorrect parameter, echo 0/1 to disable/enable Pcut feature\n"); 2761 goto fail; 2762 } 2763 2764 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2765 AB8505_RTC_PCUT_CTL_STATUS_REG, (u8)reg_value); 2766 2767 if (ret < 0) 2768 dev_err(dev, "Failed to set AB8505_RTC_PCUT_CTL_STATUS_REG\n"); 2769 2770 fail: 2771 return count; 2772 } 2773 2774 static ssize_t ab8505_powercut_flag_read(struct device *dev, 2775 struct device_attribute *attr, 2776 char *buf) 2777 { 2778 2779 int ret; 2780 u8 reg_value; 2781 struct power_supply *psy = dev_get_drvdata(dev); 2782 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2783 2784 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2785 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value); 2786 2787 if (ret < 0) { 2788 dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n"); 2789 goto fail; 2790 } 2791 2792 return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x10) >> 4)); 2793 2794 fail: 2795 return ret; 2796 } 2797 2798 static ssize_t ab8505_powercut_debounce_read(struct device *dev, 2799 struct device_attribute *attr, 2800 char *buf) 2801 { 2802 int ret; 2803 u8 reg_value; 2804 struct power_supply *psy = dev_get_drvdata(dev); 2805 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2806 2807 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2808 AB8505_RTC_PCUT_DEBOUNCE_REG, ®_value); 2809 2810 if (ret < 0) { 2811 dev_err(dev, "Failed to read AB8505_RTC_PCUT_DEBOUNCE_REG\n"); 2812 goto fail; 2813 } 2814 2815 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7)); 2816 2817 fail: 2818 return ret; 2819 } 2820 2821 static ssize_t ab8505_powercut_debounce_write(struct device *dev, 2822 struct device_attribute *attr, 2823 const char *buf, size_t count) 2824 { 2825 int ret; 2826 int reg_value; 2827 struct power_supply *psy = dev_get_drvdata(dev); 2828 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2829 2830 if (kstrtoint(buf, 10, ®_value)) 2831 goto fail; 2832 2833 if (reg_value > 0x7) { 2834 dev_err(dev, "Incorrect parameter, echo 0 to 7 for debounce setting\n"); 2835 goto fail; 2836 } 2837 2838 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC, 2839 AB8505_RTC_PCUT_DEBOUNCE_REG, (u8)reg_value); 2840 2841 if (ret < 0) 2842 dev_err(dev, "Failed to set AB8505_RTC_PCUT_DEBOUNCE_REG\n"); 2843 2844 fail: 2845 return count; 2846 } 2847 2848 static ssize_t ab8505_powercut_enable_status_read(struct device *dev, 2849 struct device_attribute *attr, 2850 char *buf) 2851 { 2852 int ret; 2853 u8 reg_value; 2854 struct power_supply *psy = dev_get_drvdata(dev); 2855 struct ab8500_fg *di = power_supply_get_drvdata(psy); 2856 2857 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC, 2858 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value); 2859 2860 if (ret < 0) { 2861 dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n"); 2862 goto fail; 2863 } 2864 2865 return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x20) >> 5)); 2866 2867 fail: 2868 return ret; 2869 } 2870 2871 static struct device_attribute ab8505_fg_sysfs_psy_attrs[] = { 2872 __ATTR(powercut_flagtime, (S_IRUGO | S_IWUSR | S_IWGRP), 2873 ab8505_powercut_flagtime_read, ab8505_powercut_flagtime_write), 2874 __ATTR(powercut_maxtime, (S_IRUGO | S_IWUSR | S_IWGRP), 2875 ab8505_powercut_maxtime_read, ab8505_powercut_maxtime_write), 2876 __ATTR(powercut_restart_max, (S_IRUGO | S_IWUSR | S_IWGRP), 2877 ab8505_powercut_restart_read, ab8505_powercut_restart_write), 2878 __ATTR(powercut_timer, S_IRUGO, ab8505_powercut_timer_read, NULL), 2879 __ATTR(powercut_restart_counter, S_IRUGO, 2880 ab8505_powercut_restart_counter_read, NULL), 2881 __ATTR(powercut_enable, (S_IRUGO | S_IWUSR | S_IWGRP), 2882 ab8505_powercut_read, ab8505_powercut_write), 2883 __ATTR(powercut_flag, S_IRUGO, ab8505_powercut_flag_read, NULL), 2884 __ATTR(powercut_debounce_time, (S_IRUGO | S_IWUSR | S_IWGRP), 2885 ab8505_powercut_debounce_read, ab8505_powercut_debounce_write), 2886 __ATTR(powercut_enable_status, S_IRUGO, 2887 ab8505_powercut_enable_status_read, NULL), 2888 }; 2889 2890 static int ab8500_fg_sysfs_psy_create_attrs(struct ab8500_fg *di) 2891 { 2892 unsigned int i; 2893 2894 if (is_ab8505(di->parent)) { 2895 for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++) 2896 if (device_create_file(&di->fg_psy->dev, 2897 &ab8505_fg_sysfs_psy_attrs[i])) 2898 goto sysfs_psy_create_attrs_failed_ab8505; 2899 } 2900 return 0; 2901 sysfs_psy_create_attrs_failed_ab8505: 2902 dev_err(&di->fg_psy->dev, "Failed creating sysfs psy attrs for ab8505.\n"); 2903 while (i--) 2904 device_remove_file(&di->fg_psy->dev, 2905 &ab8505_fg_sysfs_psy_attrs[i]); 2906 2907 return -EIO; 2908 } 2909 2910 static void ab8500_fg_sysfs_psy_remove_attrs(struct ab8500_fg *di) 2911 { 2912 unsigned int i; 2913 2914 if (is_ab8505(di->parent)) { 2915 for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++) 2916 (void)device_remove_file(&di->fg_psy->dev, 2917 &ab8505_fg_sysfs_psy_attrs[i]); 2918 } 2919 } 2920 2921 /* Exposure to the sysfs interface <<END>> */ 2922 2923 static int __maybe_unused ab8500_fg_resume(struct device *dev) 2924 { 2925 struct ab8500_fg *di = dev_get_drvdata(dev); 2926 2927 /* 2928 * Change state if we're not charging. If we're charging we will wake 2929 * up on the FG IRQ 2930 */ 2931 if (!di->flags.charging) { 2932 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_WAKEUP); 2933 queue_work(di->fg_wq, &di->fg_work); 2934 } 2935 2936 return 0; 2937 } 2938 2939 static int __maybe_unused ab8500_fg_suspend(struct device *dev) 2940 { 2941 struct ab8500_fg *di = dev_get_drvdata(dev); 2942 2943 flush_delayed_work(&di->fg_periodic_work); 2944 flush_work(&di->fg_work); 2945 flush_work(&di->fg_acc_cur_work); 2946 flush_delayed_work(&di->fg_reinit_work); 2947 flush_delayed_work(&di->fg_low_bat_work); 2948 flush_delayed_work(&di->fg_check_hw_failure_work); 2949 2950 /* 2951 * If the FG is enabled we will disable it before going to suspend 2952 * only if we're not charging 2953 */ 2954 if (di->flags.fg_enabled && !di->flags.charging) 2955 ab8500_fg_coulomb_counter(di, false); 2956 2957 return 0; 2958 } 2959 2960 /* ab8500 fg driver interrupts and their respective isr */ 2961 static struct ab8500_fg_interrupts ab8500_fg_irq[] = { 2962 {"NCONV_ACCU", ab8500_fg_cc_convend_handler}, 2963 {"BATT_OVV", ab8500_fg_batt_ovv_handler}, 2964 {"LOW_BAT_F", ab8500_fg_lowbatf_handler}, 2965 {"CC_INT_CALIB", ab8500_fg_cc_int_calib_handler}, 2966 {"CCEOC", ab8500_fg_cc_data_end_handler}, 2967 }; 2968 2969 static char *supply_interface[] = { 2970 "ab8500_chargalg", 2971 "ab8500_usb", 2972 }; 2973 2974 static const struct power_supply_desc ab8500_fg_desc = { 2975 .name = "ab8500_fg", 2976 .type = POWER_SUPPLY_TYPE_BATTERY, 2977 .properties = ab8500_fg_props, 2978 .num_properties = ARRAY_SIZE(ab8500_fg_props), 2979 .get_property = ab8500_fg_get_property, 2980 .external_power_changed = ab8500_fg_external_power_changed, 2981 }; 2982 2983 static int ab8500_fg_bind(struct device *dev, struct device *master, 2984 void *data) 2985 { 2986 struct ab8500_fg *di = dev_get_drvdata(dev); 2987 2988 /* Create a work queue for running the FG algorithm */ 2989 di->fg_wq = alloc_ordered_workqueue("ab8500_fg_wq", WQ_MEM_RECLAIM); 2990 if (di->fg_wq == NULL) { 2991 dev_err(dev, "failed to create work queue\n"); 2992 return -ENOMEM; 2993 } 2994 2995 di->bat_cap.max_mah_design = di->bm->bi.charge_full_design_uah; 2996 di->bat_cap.max_mah = di->bat_cap.max_mah_design; 2997 di->vbat_nom_uv = di->bm->bi.voltage_max_design_uv; 2998 2999 /* Start the coulomb counter */ 3000 ab8500_fg_coulomb_counter(di, true); 3001 /* Run the FG algorithm */ 3002 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); 3003 3004 return 0; 3005 } 3006 3007 static void ab8500_fg_unbind(struct device *dev, struct device *master, 3008 void *data) 3009 { 3010 struct ab8500_fg *di = dev_get_drvdata(dev); 3011 int ret; 3012 3013 /* Disable coulomb counter */ 3014 ret = ab8500_fg_coulomb_counter(di, false); 3015 if (ret) 3016 dev_err(dev, "failed to disable coulomb counter\n"); 3017 3018 destroy_workqueue(di->fg_wq); 3019 flush_scheduled_work(); 3020 } 3021 3022 static const struct component_ops ab8500_fg_component_ops = { 3023 .bind = ab8500_fg_bind, 3024 .unbind = ab8500_fg_unbind, 3025 }; 3026 3027 static int ab8500_fg_probe(struct platform_device *pdev) 3028 { 3029 struct device *dev = &pdev->dev; 3030 struct power_supply_config psy_cfg = {}; 3031 struct ab8500_fg *di; 3032 int i, irq; 3033 int ret = 0; 3034 3035 di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL); 3036 if (!di) 3037 return -ENOMEM; 3038 3039 di->bm = &ab8500_bm_data; 3040 3041 mutex_init(&di->cc_lock); 3042 3043 /* get parent data */ 3044 di->dev = dev; 3045 di->parent = dev_get_drvdata(pdev->dev.parent); 3046 3047 di->main_bat_v = devm_iio_channel_get(dev, "main_bat_v"); 3048 if (IS_ERR(di->main_bat_v)) { 3049 ret = dev_err_probe(dev, PTR_ERR(di->main_bat_v), 3050 "failed to get main battery ADC channel\n"); 3051 return ret; 3052 } 3053 3054 psy_cfg.supplied_to = supply_interface; 3055 psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface); 3056 psy_cfg.drv_data = di; 3057 3058 di->init_capacity = true; 3059 3060 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT); 3061 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT); 3062 3063 /* Init work for running the fg algorithm instantly */ 3064 INIT_WORK(&di->fg_work, ab8500_fg_instant_work); 3065 3066 /* Init work for getting the battery accumulated current */ 3067 INIT_WORK(&di->fg_acc_cur_work, ab8500_fg_acc_cur_work); 3068 3069 /* Init work for reinitialising the fg algorithm */ 3070 INIT_DEFERRABLE_WORK(&di->fg_reinit_work, 3071 ab8500_fg_reinit_work); 3072 3073 /* Work delayed Queue to run the state machine */ 3074 INIT_DEFERRABLE_WORK(&di->fg_periodic_work, 3075 ab8500_fg_periodic_work); 3076 3077 /* Work to check low battery condition */ 3078 INIT_DEFERRABLE_WORK(&di->fg_low_bat_work, 3079 ab8500_fg_low_bat_work); 3080 3081 /* Init work for HW failure check */ 3082 INIT_DEFERRABLE_WORK(&di->fg_check_hw_failure_work, 3083 ab8500_fg_check_hw_failure_work); 3084 3085 /* Reset battery low voltage flag */ 3086 di->flags.low_bat = false; 3087 3088 /* Initialize low battery counter */ 3089 di->low_bat_cnt = 10; 3090 3091 /* Initialize OVV, and other registers */ 3092 ret = ab8500_fg_init_hw_registers(di); 3093 if (ret) { 3094 dev_err(dev, "failed to initialize registers\n"); 3095 return ret; 3096 } 3097 3098 /* Consider battery unknown until we're informed otherwise */ 3099 di->flags.batt_unknown = true; 3100 di->flags.batt_id_received = false; 3101 3102 /* Register FG power supply class */ 3103 di->fg_psy = devm_power_supply_register(dev, &ab8500_fg_desc, &psy_cfg); 3104 if (IS_ERR(di->fg_psy)) { 3105 dev_err(dev, "failed to register FG psy\n"); 3106 return PTR_ERR(di->fg_psy); 3107 } 3108 3109 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer); 3110 3111 /* 3112 * Initialize completion used to notify completion and start 3113 * of inst current 3114 */ 3115 init_completion(&di->ab8500_fg_started); 3116 init_completion(&di->ab8500_fg_complete); 3117 3118 /* Register primary interrupt handlers */ 3119 for (i = 0; i < ARRAY_SIZE(ab8500_fg_irq); i++) { 3120 irq = platform_get_irq_byname(pdev, ab8500_fg_irq[i].name); 3121 if (irq < 0) 3122 return irq; 3123 3124 ret = devm_request_threaded_irq(dev, irq, NULL, 3125 ab8500_fg_irq[i].isr, 3126 IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT, 3127 ab8500_fg_irq[i].name, di); 3128 3129 if (ret != 0) { 3130 dev_err(dev, "failed to request %s IRQ %d: %d\n", 3131 ab8500_fg_irq[i].name, irq, ret); 3132 return ret; 3133 } 3134 dev_dbg(dev, "Requested %s IRQ %d: %d\n", 3135 ab8500_fg_irq[i].name, irq, ret); 3136 } 3137 3138 di->irq = platform_get_irq_byname(pdev, "CCEOC"); 3139 disable_irq(di->irq); 3140 di->nbr_cceoc_irq_cnt = 0; 3141 3142 platform_set_drvdata(pdev, di); 3143 3144 ret = ab8500_fg_sysfs_init(di); 3145 if (ret) { 3146 dev_err(dev, "failed to create sysfs entry\n"); 3147 return ret; 3148 } 3149 3150 ret = ab8500_fg_sysfs_psy_create_attrs(di); 3151 if (ret) { 3152 dev_err(dev, "failed to create FG psy\n"); 3153 ab8500_fg_sysfs_exit(di); 3154 return ret; 3155 } 3156 3157 /* Calibrate the fg first time */ 3158 di->flags.calibrate = true; 3159 di->calib_state = AB8500_FG_CALIB_INIT; 3160 3161 /* Use room temp as default value until we get an update from driver. */ 3162 di->bat_temp = 210; 3163 3164 list_add_tail(&di->node, &ab8500_fg_list); 3165 3166 return component_add(dev, &ab8500_fg_component_ops); 3167 } 3168 3169 static int ab8500_fg_remove(struct platform_device *pdev) 3170 { 3171 int ret = 0; 3172 struct ab8500_fg *di = platform_get_drvdata(pdev); 3173 3174 component_del(&pdev->dev, &ab8500_fg_component_ops); 3175 list_del(&di->node); 3176 ab8500_fg_sysfs_exit(di); 3177 ab8500_fg_sysfs_psy_remove_attrs(di); 3178 3179 return ret; 3180 } 3181 3182 static SIMPLE_DEV_PM_OPS(ab8500_fg_pm_ops, ab8500_fg_suspend, ab8500_fg_resume); 3183 3184 static const struct of_device_id ab8500_fg_match[] = { 3185 { .compatible = "stericsson,ab8500-fg", }, 3186 { }, 3187 }; 3188 MODULE_DEVICE_TABLE(of, ab8500_fg_match); 3189 3190 struct platform_driver ab8500_fg_driver = { 3191 .probe = ab8500_fg_probe, 3192 .remove = ab8500_fg_remove, 3193 .driver = { 3194 .name = "ab8500-fg", 3195 .of_match_table = ab8500_fg_match, 3196 .pm = &ab8500_fg_pm_ops, 3197 }, 3198 }; 3199 MODULE_LICENSE("GPL v2"); 3200 MODULE_AUTHOR("Johan Palsson, Karl Komierowski"); 3201 MODULE_ALIAS("platform:ab8500-fg"); 3202 MODULE_DESCRIPTION("AB8500 Fuel Gauge driver"); 3203