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