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