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