drivers/power/supply/ab8500_fg.c

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