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