OSCL-LXR linux-6.0.1/​drivers/​power/​supply/​ab8500_fg.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright (C) ST-Ericsson AB 2012
  *
  * Main and Back-up battery management driver.
  *
  * Note: Backup battery management is required in case of Li-Ion battery and not
  * for capacitive battery. HREF boards have capacitive battery and hence backup
  * battery management is not used and the supported code is available in this
  * driver.
  *
  * Author:
  *  Johan Palsson <johan.palsson@stericsson.com>
  *  Karl Komierowski <karl.komierowski@stericsson.com>
  *  Arun R Murthy <arun.murthy@stericsson.com>
  */
 
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/component.h>
 #include <linux/device.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <linux/power_supply.h>
 #include <linux/kobject.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/time.h>
 #include <linux/time64.h>
 #include <linux/of.h>
 #include <linux/completion.h>
 #include <linux/mfd/core.h>
 #include <linux/mfd/abx500.h>
 #include <linux/mfd/abx500/ab8500.h>
 #include <linux/iio/consumer.h>
 #include <linux/kernel.h>
 #include <linux/fixp-arith.h>
 
 #include "ab8500-bm.h"
 
 #define FG_LSB_IN_MA            1627
 #define QLSB_NANO_AMP_HOURS_X10     1071
 #define INS_CURR_TIMEOUT        (3 * HZ)
 
 #define SEC_TO_SAMPLE(S)        (S * 4)
 
 #define NBR_AVG_SAMPLES         20
 #define WAIT_FOR_INST_CURRENT_MAX   70
 /* Currents higher than -500mA (dissipating) will make compensation unstable */
 #define IGNORE_VBAT_HIGHCUR     -500000
 
 #define LOW_BAT_CHECK_INTERVAL      (HZ / 16) /* 62.5 ms */
 
 #define VALID_CAPACITY_SEC      (45 * 60) /* 45 minutes */
 #define BATT_OK_MIN         2360 /* mV */
 #define BATT_OK_INCREMENT       50 /* mV */
 #define BATT_OK_MAX_NR_INCREMENTS   0xE
 
 /* FG constants */
 #define BATT_OVV            0x01
 
 /**
  * struct ab8500_fg_interrupts - ab8500 fg interrupts
  * @name:   name of the interrupt
  * @isr     function pointer to the isr
  */
 struct ab8500_fg_interrupts {
     char *name;
     irqreturn_t (*isr)(int irq, void *data);
 };
 
 enum ab8500_fg_discharge_state {
     AB8500_FG_DISCHARGE_INIT,
     AB8500_FG_DISCHARGE_INITMEASURING,
     AB8500_FG_DISCHARGE_INIT_RECOVERY,
     AB8500_FG_DISCHARGE_RECOVERY,
     AB8500_FG_DISCHARGE_READOUT_INIT,
     AB8500_FG_DISCHARGE_READOUT,
     AB8500_FG_DISCHARGE_WAKEUP,
 };
 
 static char *discharge_state[] = {
     "DISCHARGE_INIT",
     "DISCHARGE_INITMEASURING",
     "DISCHARGE_INIT_RECOVERY",
     "DISCHARGE_RECOVERY",
     "DISCHARGE_READOUT_INIT",
     "DISCHARGE_READOUT",
     "DISCHARGE_WAKEUP",
 };
 
 enum ab8500_fg_charge_state {
     AB8500_FG_CHARGE_INIT,
     AB8500_FG_CHARGE_READOUT,
 };
 
 static char *charge_state[] = {
     "CHARGE_INIT",
     "CHARGE_READOUT",
 };
 
 enum ab8500_fg_calibration_state {
     AB8500_FG_CALIB_INIT,
     AB8500_FG_CALIB_WAIT,
     AB8500_FG_CALIB_END,
 };
 
 struct ab8500_fg_avg_cap {
     int avg;
     int samples[NBR_AVG_SAMPLES];
     time64_t time_stamps[NBR_AVG_SAMPLES];
     int pos;
     int nbr_samples;
     int sum;
 };
 
 struct ab8500_fg_cap_scaling {
     bool enable;
     int cap_to_scale[2];
     int disable_cap_level;
     int scaled_cap;
 };
 
 struct ab8500_fg_battery_capacity {
     int max_mah_design;
     int max_mah;
     int mah;
     int permille;
     int level;
     int prev_mah;
     int prev_percent;
     int prev_level;
     int user_mah;
     struct ab8500_fg_cap_scaling cap_scale;
 };
 
 struct ab8500_fg_flags {
     bool fg_enabled;
     bool conv_done;
     bool charging;
     bool fully_charged;
     bool force_full;
     bool low_bat_delay;
     bool low_bat;
     bool bat_ovv;
     bool batt_unknown;
     bool calibrate;
     bool user_cap;
     bool batt_id_received;
 };
 
 struct inst_curr_result_list {
     struct list_head list;
     int *result;
 };
 
 /**
  * struct ab8500_fg - ab8500 FG device information
  * @dev:        Pointer to the structure device
  * @node:       a list of AB8500 FGs, hence prepared for reentrance
  * @irq         holds the CCEOC interrupt number
  * @vbat_uv:        Battery voltage in uV
  * @vbat_nom_uv:    Nominal battery voltage in uV
  * @inst_curr_ua:   Instantenous battery current in uA
  * @avg_curr_ua:    Average battery current in uA
  * @bat_temp        battery temperature
  * @fg_samples:     Number of samples used in the FG accumulation
  * @accu_charge:    Accumulated charge from the last conversion
  * @recovery_cnt:   Counter for recovery mode
  * @high_curr_cnt:  Counter for high current mode
  * @init_cnt:       Counter for init mode
  * @low_bat_cnt     Counter for number of consecutive low battery measures
  * @nbr_cceoc_irq_cnt   Counter for number of CCEOC irqs received since enabled
  * @recovery_needed:    Indicate if recovery is needed
  * @high_curr_mode: Indicate if we're in high current mode
  * @init_capacity:  Indicate if initial capacity measuring should be done
  * @turn_off_fg:    True if fg was off before current measurement
  * @calib_state     State during offset calibration
  * @discharge_state:    Current discharge state
  * @charge_state:   Current charge state
  * @ab8500_fg_started   Completion struct used for the instant current start
  * @ab8500_fg_complete  Completion struct used for the instant current reading
  * @flags:      Structure for information about events triggered
  * @bat_cap:        Structure for battery capacity specific parameters
  * @avg_cap:        Average capacity filter
  * @parent:     Pointer to the struct ab8500
  * @main_bat_v:     ADC channel for the main battery voltage
  * @bm:             Platform specific battery management information
  * @fg_psy:     Structure that holds the FG specific battery properties
  * @fg_wq:      Work queue for running the FG algorithm
  * @fg_periodic_work:   Work to run the FG algorithm periodically
  * @fg_low_bat_work:    Work to check low bat condition
  * @fg_reinit_work  Work used to reset and reinitialise the FG algorithm
  * @fg_work:        Work to run the FG algorithm instantly
  * @fg_acc_cur_work:    Work to read the FG accumulator
  * @fg_check_hw_failure_work:   Work for checking HW state
  * @cc_lock:        Mutex for locking the CC
  * @fg_kobject:     Structure of type kobject
  */
 struct ab8500_fg {
     struct device *dev;
     struct list_head node;
     int irq;
     int vbat_uv;
     int vbat_nom_uv;
     int inst_curr_ua;
     int avg_curr_ua;
     int bat_temp;
     int fg_samples;
     int accu_charge;
     int recovery_cnt;
     int high_curr_cnt;
     int init_cnt;
     int low_bat_cnt;
     int nbr_cceoc_irq_cnt;
     u32 line_impedance_uohm;
     bool recovery_needed;
     bool high_curr_mode;
     bool init_capacity;
     bool turn_off_fg;
     enum ab8500_fg_calibration_state calib_state;
     enum ab8500_fg_discharge_state discharge_state;
     enum ab8500_fg_charge_state charge_state;
     struct completion ab8500_fg_started;
     struct completion ab8500_fg_complete;
     struct ab8500_fg_flags flags;
     struct ab8500_fg_battery_capacity bat_cap;
     struct ab8500_fg_avg_cap avg_cap;
     struct ab8500 *parent;
     struct iio_channel *main_bat_v;
     struct ab8500_bm_data *bm;
     struct power_supply *fg_psy;
     struct workqueue_struct *fg_wq;
     struct delayed_work fg_periodic_work;
     struct delayed_work fg_low_bat_work;
     struct delayed_work fg_reinit_work;
     struct work_struct fg_work;
     struct work_struct fg_acc_cur_work;
     struct delayed_work fg_check_hw_failure_work;
     struct mutex cc_lock;
     struct kobject fg_kobject;
 };
 static LIST_HEAD(ab8500_fg_list);
 
 /**
  * ab8500_fg_get() - returns a reference to the primary AB8500 fuel gauge
  * (i.e. the first fuel gauge in the instance list)
  */
 struct ab8500_fg *ab8500_fg_get(void)
 {
     return list_first_entry_or_null(&ab8500_fg_list, struct ab8500_fg,
                     node);
 }
 
 /* Main battery properties */
 static enum power_supply_property ab8500_fg_props[] = {
     POWER_SUPPLY_PROP_VOLTAGE_NOW,
     POWER_SUPPLY_PROP_CURRENT_NOW,
     POWER_SUPPLY_PROP_CURRENT_AVG,
     POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
     POWER_SUPPLY_PROP_ENERGY_FULL,
     POWER_SUPPLY_PROP_ENERGY_NOW,
     POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
     POWER_SUPPLY_PROP_CHARGE_FULL,
     POWER_SUPPLY_PROP_CHARGE_NOW,
     POWER_SUPPLY_PROP_CAPACITY,
     POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 };
 
 /*
  * This array maps the raw hex value to lowbat voltage used by the AB8500
  * Values taken from the UM0836, in microvolts.
  */
 static int ab8500_fg_lowbat_voltage_map[] = {
     2300000,
     2325000,
     2350000,
     2375000,
     2400000,
     2425000,
     2450000,
     2475000,
     2500000,
     2525000,
     2550000,
     2575000,
     2600000,
     2625000,
     2650000,
     2675000,
     2700000,
     2725000,
     2750000,
     2775000,
     2800000,
     2825000,
     2850000,
     2875000,
     2900000,
     2925000,
     2950000,
     2975000,
     3000000,
     3025000,
     3050000,
     3075000,
     3100000,
     3125000,
     3150000,
     3175000,
     3200000,
     3225000,
     3250000,
     3275000,
     3300000,
     3325000,
     3350000,
     3375000,
     3400000,
     3425000,
     3450000,
     3475000,
     3500000,
     3525000,
     3550000,
     3575000,
     3600000,
     3625000,
     3650000,
     3675000,
     3700000,
     3725000,
     3750000,
     3775000,
     3800000,
     3825000,
     3850000,
     3850000,
 };
 
 static u8 ab8500_volt_to_regval(int voltage_uv)
 {
     int i;
 
     if (voltage_uv < ab8500_fg_lowbat_voltage_map[0])
         return 0;
 
     for (i = 0; i < ARRAY_SIZE(ab8500_fg_lowbat_voltage_map); i++) {
         if (voltage_uv < ab8500_fg_lowbat_voltage_map[i])
             return (u8) i - 1;
     }
 
     /* If not captured above, return index of last element */
     return (u8) ARRAY_SIZE(ab8500_fg_lowbat_voltage_map) - 1;
 }
 
 /**
  * ab8500_fg_is_low_curr() - Low or high current mode
  * @di:     pointer to the ab8500_fg structure
  * @curr_ua:    the current to base or our decision on in microampere
  *
  * Low current mode if the current consumption is below a certain threshold
  */
 static int ab8500_fg_is_low_curr(struct ab8500_fg *di, int curr_ua)
 {
     /*
      * We want to know if we're in low current mode
      */
     if (curr_ua > -di->bm->fg_params->high_curr_threshold_ua)
         return true;
     else
         return false;
 }
 
 /**
  * ab8500_fg_add_cap_sample() - Add capacity to average filter
  * @di:     pointer to the ab8500_fg structure
  * @sample: the capacity in mAh to add to the filter
  *
  * A capacity is added to the filter and a new mean capacity is calculated and
  * returned
  */
 static int ab8500_fg_add_cap_sample(struct ab8500_fg *di, int sample)
 {
     time64_t now = ktime_get_boottime_seconds();
     struct ab8500_fg_avg_cap *avg = &di->avg_cap;
 
     do {
         avg->sum += sample - avg->samples[avg->pos];
         avg->samples[avg->pos] = sample;
         avg->time_stamps[avg->pos] = now;
         avg->pos++;
 
         if (avg->pos == NBR_AVG_SAMPLES)
             avg->pos = 0;
 
         if (avg->nbr_samples < NBR_AVG_SAMPLES)
             avg->nbr_samples++;
 
         /*
          * Check the time stamp for each sample. If too old,
          * replace with latest sample
          */
     } while (now - VALID_CAPACITY_SEC > avg->time_stamps[avg->pos]);
 
     avg->avg = avg->sum / avg->nbr_samples;
 
     return avg->avg;
 }
 
 /**
  * ab8500_fg_clear_cap_samples() - Clear average filter
  * @di:     pointer to the ab8500_fg structure
  *
  * The capacity filter is reset to zero.
  */
 static void ab8500_fg_clear_cap_samples(struct ab8500_fg *di)
 {
     int i;
     struct ab8500_fg_avg_cap *avg = &di->avg_cap;
 
     avg->pos = 0;
     avg->nbr_samples = 0;
     avg->sum = 0;
     avg->avg = 0;
 
     for (i = 0; i < NBR_AVG_SAMPLES; i++) {
         avg->samples[i] = 0;
         avg->time_stamps[i] = 0;
     }
 }
 
 /**
  * ab8500_fg_fill_cap_sample() - Fill average filter
  * @di:     pointer to the ab8500_fg structure
  * @sample: the capacity in mAh to fill the filter with
  *
  * The capacity filter is filled with a capacity in mAh
  */
 static void ab8500_fg_fill_cap_sample(struct ab8500_fg *di, int sample)
 {
     int i;
     time64_t now;
     struct ab8500_fg_avg_cap *avg = &di->avg_cap;
 
     now = ktime_get_boottime_seconds();
 
     for (i = 0; i < NBR_AVG_SAMPLES; i++) {
         avg->samples[i] = sample;
         avg->time_stamps[i] = now;
     }
 
     avg->pos = 0;
     avg->nbr_samples = NBR_AVG_SAMPLES;
     avg->sum = sample * NBR_AVG_SAMPLES;
     avg->avg = sample;
 }
 
 /**
  * ab8500_fg_coulomb_counter() - enable coulomb counter
  * @di:     pointer to the ab8500_fg structure
  * @enable: enable/disable
  *
  * Enable/Disable coulomb counter.
  * On failure returns negative value.
  */
 static int ab8500_fg_coulomb_counter(struct ab8500_fg *di, bool enable)
 {
     int ret = 0;
     mutex_lock(&di->cc_lock);
     if (enable) {
         /* To be able to reprogram the number of samples, we have to
          * first stop the CC and then enable it again */
         ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
             AB8500_RTC_CC_CONF_REG, 0x00);
         if (ret)
             goto cc_err;
 
         /* Program the samples */
         ret = abx500_set_register_interruptible(di->dev,
             AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU,
             di->fg_samples);
         if (ret)
             goto cc_err;
 
         /* Start the CC */
         ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
             AB8500_RTC_CC_CONF_REG,
             (CC_DEEP_SLEEP_ENA | CC_PWR_UP_ENA));
         if (ret)
             goto cc_err;
 
         di->flags.fg_enabled = true;
     } else {
         /* Clear any pending read requests */
         ret = abx500_mask_and_set_register_interruptible(di->dev,
             AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
             (RESET_ACCU | READ_REQ), 0);
         if (ret)
             goto cc_err;
 
         ret = abx500_set_register_interruptible(di->dev,
             AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU_CTRL, 0);
         if (ret)
             goto cc_err;
 
         /* Stop the CC */
         ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
             AB8500_RTC_CC_CONF_REG, 0);
         if (ret)
             goto cc_err;
 
         di->flags.fg_enabled = false;
 
     }
     dev_dbg(di->dev, " CC enabled: %d Samples: %d\n",
         enable, di->fg_samples);
 
     mutex_unlock(&di->cc_lock);
 
     return ret;
 cc_err:
     dev_err(di->dev, "%s Enabling coulomb counter failed\n", __func__);
     mutex_unlock(&di->cc_lock);
     return ret;
 }
 
 /**
  * ab8500_fg_inst_curr_start() - start battery instantaneous current
  * @di:         pointer to the ab8500_fg structure
  *
  * Returns 0 or error code
  * Note: This is part "one" and has to be called before
  * ab8500_fg_inst_curr_finalize()
  */
 int ab8500_fg_inst_curr_start(struct ab8500_fg *di)
 {
     u8 reg_val;
     int ret;
 
     mutex_lock(&di->cc_lock);
 
     di->nbr_cceoc_irq_cnt = 0;
     ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
         AB8500_RTC_CC_CONF_REG, &reg_val);
     if (ret < 0)
         goto fail;
 
     if (!(reg_val & CC_PWR_UP_ENA)) {
         dev_dbg(di->dev, "%s Enable FG\n", __func__);
         di->turn_off_fg = true;
 
         /* Program the samples */
         ret = abx500_set_register_interruptible(di->dev,
             AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU,
             SEC_TO_SAMPLE(10));
         if (ret)
             goto fail;
 
         /* Start the CC */
         ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
             AB8500_RTC_CC_CONF_REG,
             (CC_DEEP_SLEEP_ENA | CC_PWR_UP_ENA));
         if (ret)
             goto fail;
     } else {
         di->turn_off_fg = false;
     }
 
     /* Return and WFI */
     reinit_completion(&di->ab8500_fg_started);
     reinit_completion(&di->ab8500_fg_complete);
     enable_irq(di->irq);
 
     /* Note: cc_lock is still locked */
     return 0;
 fail:
     mutex_unlock(&di->cc_lock);
     return ret;
 }
 
 /**
  * ab8500_fg_inst_curr_started() - check if fg conversion has started
  * @di:         pointer to the ab8500_fg structure
  *
  * Returns 1 if conversion started, 0 if still waiting
  */
 int ab8500_fg_inst_curr_started(struct ab8500_fg *di)
 {
     return completion_done(&di->ab8500_fg_started);
 }
 
 /**
  * ab8500_fg_inst_curr_done() - check if fg conversion is done
  * @di:         pointer to the ab8500_fg structure
  *
  * Returns 1 if conversion done, 0 if still waiting
  */
 int ab8500_fg_inst_curr_done(struct ab8500_fg *di)
 {
     return completion_done(&di->ab8500_fg_complete);
 }
 
 /**
  * ab8500_fg_inst_curr_finalize() - battery instantaneous current
  * @di:         pointer to the ab8500_fg structure
  * @curr_ua:    battery instantenous current in microampere (on success)
  *
  * Returns 0 or an error code
  * Note: This is part "two" and has to be called at earliest 250 ms
  * after ab8500_fg_inst_curr_start()
  */
 int ab8500_fg_inst_curr_finalize(struct ab8500_fg *di, int *curr_ua)
 {
     u8 low, high;
     int val;
     int ret;
     unsigned long timeout;
 
     if (!completion_done(&di->ab8500_fg_complete)) {
         timeout = wait_for_completion_timeout(
             &di->ab8500_fg_complete,
             INS_CURR_TIMEOUT);
         dev_dbg(di->dev, "Finalize time: %d ms\n",
             jiffies_to_msecs(INS_CURR_TIMEOUT - timeout));
         if (!timeout) {
             ret = -ETIME;
             disable_irq(di->irq);
             di->nbr_cceoc_irq_cnt = 0;
             dev_err(di->dev, "completion timed out [%d]\n",
                 __LINE__);
             goto fail;
         }
     }
 
     disable_irq(di->irq);
     di->nbr_cceoc_irq_cnt = 0;
 
     ret = abx500_mask_and_set_register_interruptible(di->dev,
             AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
             READ_REQ, READ_REQ);
 
     /* 100uS between read request and read is needed */
     usleep_range(100, 100);
 
     /* Read CC Sample conversion value Low and high */
     ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
         AB8500_GASG_CC_SMPL_CNVL_REG,  &low);
     if (ret < 0)
         goto fail;
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
         AB8500_GASG_CC_SMPL_CNVH_REG,  &high);
     if (ret < 0)
         goto fail;
 
     /*
      * negative value for Discharging
      * convert 2's complement into decimal
      */
     if (high & 0x10)
         val = (low | (high << 8) | 0xFFFFE000);
     else
         val = (low | (high << 8));
 
     /*
      * Convert to unit value in mA
      * Full scale input voltage is
      * 63.160mV => LSB = 63.160mV/(4096*res) = 1.542.000 uA
      * Given a 250ms conversion cycle time the LSB corresponds
      * to 107.1 nAh. Convert to current by dividing by the conversion
      * time in hours (250ms = 1 / (3600 * 4)h)
      * 107.1nAh assumes 10mOhm, but fg_res is in 0.1mOhm
      */
     val = (val * QLSB_NANO_AMP_HOURS_X10 * 36 * 4) / di->bm->fg_res;
 
     if (di->turn_off_fg) {
         dev_dbg(di->dev, "%s Disable FG\n", __func__);
 
         /* Clear any pending read requests */
         ret = abx500_set_register_interruptible(di->dev,
             AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG, 0);
         if (ret)
             goto fail;
 
         /* Stop the CC */
         ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
             AB8500_RTC_CC_CONF_REG, 0);
         if (ret)
             goto fail;
     }
     mutex_unlock(&di->cc_lock);
     *curr_ua = val;
 
     return 0;
 fail:
     mutex_unlock(&di->cc_lock);
     return ret;
 }
 
 /**
  * ab8500_fg_inst_curr_blocking() - battery instantaneous current
  * @di:         pointer to the ab8500_fg structure
  *
  * Returns battery instantenous current in microampere (on success)
  * else error code
  */
 int ab8500_fg_inst_curr_blocking(struct ab8500_fg *di)
 {
     int ret;
     unsigned long timeout;
     int curr_ua = 0;
 
     ret = ab8500_fg_inst_curr_start(di);
     if (ret) {
         dev_err(di->dev, "Failed to initialize fg_inst\n");
         return 0;
     }
 
     /* Wait for CC to actually start */
     if (!completion_done(&di->ab8500_fg_started)) {
         timeout = wait_for_completion_timeout(
             &di->ab8500_fg_started,
             INS_CURR_TIMEOUT);
         dev_dbg(di->dev, "Start time: %d ms\n",
             jiffies_to_msecs(INS_CURR_TIMEOUT - timeout));
         if (!timeout) {
             ret = -ETIME;
             dev_err(di->dev, "completion timed out [%d]\n",
                 __LINE__);
             goto fail;
         }
     }
 
     ret = ab8500_fg_inst_curr_finalize(di, &curr_ua);
     if (ret) {
         dev_err(di->dev, "Failed to finalize fg_inst\n");
         return 0;
     }
 
     dev_dbg(di->dev, "%s instant current: %d uA", __func__, curr_ua);
     return curr_ua;
 fail:
     disable_irq(di->irq);
     mutex_unlock(&di->cc_lock);
     return ret;
 }
 
 /**
  * ab8500_fg_acc_cur_work() - average battery current
  * @work:   pointer to the work_struct structure
  *
  * Updated the average battery current obtained from the
  * coulomb counter.
  */
 static void ab8500_fg_acc_cur_work(struct work_struct *work)
 {
     int val;
     int ret;
     u8 low, med, high;
 
     struct ab8500_fg *di = container_of(work,
         struct ab8500_fg, fg_acc_cur_work);
 
     mutex_lock(&di->cc_lock);
     ret = abx500_set_register_interruptible(di->dev, AB8500_GAS_GAUGE,
         AB8500_GASG_CC_NCOV_ACCU_CTRL, RD_NCONV_ACCU_REQ);
     if (ret)
         goto exit;
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
         AB8500_GASG_CC_NCOV_ACCU_LOW,  &low);
     if (ret < 0)
         goto exit;
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
         AB8500_GASG_CC_NCOV_ACCU_MED,  &med);
     if (ret < 0)
         goto exit;
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
         AB8500_GASG_CC_NCOV_ACCU_HIGH, &high);
     if (ret < 0)
         goto exit;
 
     /* Check for sign bit in case of negative value, 2's complement */
     if (high & 0x10)
         val = (low | (med << 8) | (high << 16) | 0xFFE00000);
     else
         val = (low | (med << 8) | (high << 16));
 
     /*
      * Convert to uAh
      * Given a 250ms conversion cycle time the LSB corresponds
      * to 112.9 nAh.
      * 112.9nAh assumes 10mOhm, but fg_res is in 0.1mOhm
      */
     di->accu_charge = (val * QLSB_NANO_AMP_HOURS_X10) /
         (100 * di->bm->fg_res);
 
     /*
      * Convert to unit value in uA
      * by dividing by the conversion
      * time in hours (= samples / (3600 * 4)h)
      */
     di->avg_curr_ua = (val * QLSB_NANO_AMP_HOURS_X10 * 36) /
         (di->bm->fg_res * (di->fg_samples / 4));
 
     di->flags.conv_done = true;
 
     mutex_unlock(&di->cc_lock);
 
     queue_work(di->fg_wq, &di->fg_work);
 
     dev_dbg(di->dev, "fg_res: %d, fg_samples: %d, gasg: %d, accu_charge: %d \n",
                 di->bm->fg_res, di->fg_samples, val, di->accu_charge);
     return;
 exit:
     dev_err(di->dev,
         "Failed to read or write gas gauge registers\n");
     mutex_unlock(&di->cc_lock);
     queue_work(di->fg_wq, &di->fg_work);
 }
 
 /**
  * ab8500_fg_bat_voltage() - get battery voltage
  * @di:     pointer to the ab8500_fg structure
  *
  * Returns battery voltage in microvolts (on success) else error code
  */
 static int ab8500_fg_bat_voltage(struct ab8500_fg *di)
 {
     int vbat, ret;
     static int prev;
 
     ret = iio_read_channel_processed(di->main_bat_v, &vbat);
     if (ret < 0) {
         dev_err(di->dev,
             "%s ADC conversion failed, using previous value\n",
             __func__);
         return prev;
     }
 
     /* IIO returns millivolts but we want microvolts */
     vbat *= 1000;
     prev = vbat;
     return vbat;
 }
 
 /**
  * ab8500_fg_volt_to_capacity() - Voltage based capacity
  * @di:     pointer to the ab8500_fg structure
  * @voltage_uv: The voltage to convert to a capacity in microvolt
  *
  * Returns battery capacity in per mille based on voltage
  */
 static int ab8500_fg_volt_to_capacity(struct ab8500_fg *di, int voltage_uv)
 {
     struct power_supply_battery_info *bi = di->bm->bi;
 
     /* Multiply by 10 because the capacity is tracked in per mille */
     return power_supply_batinfo_ocv2cap(bi, voltage_uv, di->bat_temp) *  10;
 }
 
 /**
  * ab8500_fg_uncomp_volt_to_capacity() - Uncompensated voltage based capacity
  * @di:     pointer to the ab8500_fg structure
  *
  * Returns battery capacity based on battery voltage that is not compensated
  * for the voltage drop due to the load
  */
 static int ab8500_fg_uncomp_volt_to_capacity(struct ab8500_fg *di)
 {
     di->vbat_uv = ab8500_fg_bat_voltage(di);
     return ab8500_fg_volt_to_capacity(di, di->vbat_uv);
 }
 
 /**
  * ab8500_fg_battery_resistance() - Returns the battery inner resistance
  * @di:     pointer to the ab8500_fg structure
  * @vbat_uncomp_uv: Uncompensated VBAT voltage
  *
  * Returns battery inner resistance added with the fuel gauge resistor value
  * to get the total resistance in the whole link from gnd to bat+ node
  * in milliohm.
  */
 static int ab8500_fg_battery_resistance(struct ab8500_fg *di, int vbat_uncomp_uv)
 {
     struct power_supply_battery_info *bi = di->bm->bi;
     int resistance_percent = 0;
     int resistance;
 
     /*
      * Determine the resistance at this voltage. First try VBAT-to-Ri else
      * just infer it from the surrounding temperature, if nothing works just
      * use the internal resistance.
      */
     if (power_supply_supports_vbat2ri(bi)) {
         resistance = power_supply_vbat2ri(bi, vbat_uncomp_uv, di->flags.charging);
         /* Convert to milliohm */
         resistance = resistance / 1000;
     } else if (power_supply_supports_temp2ri(bi)) {
         resistance_percent = power_supply_temp2resist_simple(bi->resist_table,
                                      bi->resist_table_size,
                                      di->bat_temp / 10);
         /* Convert to milliohm */
         resistance = bi->factory_internal_resistance_uohm / 1000;
         resistance = resistance * resistance_percent / 100;
     } else {
         /* Last fallback */
         resistance = bi->factory_internal_resistance_uohm / 1000;
     }
 
     /* Compensate for line impedance */
     resistance += (di->line_impedance_uohm / 1000);
 
     dev_dbg(di->dev, "%s Temp: %d battery internal resistance: %d"
         " fg resistance %d, total: %d (mOhm)\n",
         __func__, di->bat_temp, resistance, di->bm->fg_res / 10,
         (di->bm->fg_res / 10) + resistance);
 
     /* fg_res variable is in 0.1mOhm */
     resistance += di->bm->fg_res / 10;
 
     return resistance;
 }
 
 /**
  * ab8500_load_comp_fg_bat_voltage() - get load compensated battery voltage
  * @di:     pointer to the ab8500_fg structure
  * @always: always return a voltage, also uncompensated
  *
  * Returns compensated battery voltage (on success) else error code.
  * If always is specified, we always return a voltage but it may be
  * uncompensated.
  */
 static int ab8500_load_comp_fg_bat_voltage(struct ab8500_fg *di, bool always)
 {
     int i = 0;
     int vbat_uv = 0;
     int rcomp;
 
     /* Average the instant current to get a stable current measurement */
     ab8500_fg_inst_curr_start(di);
 
     do {
         vbat_uv += ab8500_fg_bat_voltage(di);
         i++;
         usleep_range(5000, 6000);
     } while (!ab8500_fg_inst_curr_done(di) &&
          i <= WAIT_FOR_INST_CURRENT_MAX);
 
     if (i > WAIT_FOR_INST_CURRENT_MAX) {
         dev_err(di->dev,
             "TIMEOUT: return uncompensated measurement of VBAT\n");
         di->vbat_uv = vbat_uv / i;
         return di->vbat_uv;
     }
 
     ab8500_fg_inst_curr_finalize(di, &di->inst_curr_ua);
 
     /*
      * If there is too high current dissipation, the compensation cannot be
      * trusted so return an error unless we must return something here, as
      * enforced by the "always" parameter.
      */
     if (!always && di->inst_curr_ua < IGNORE_VBAT_HIGHCUR)
         return -EINVAL;
 
     vbat_uv = vbat_uv / i;
 
     /* Next we apply voltage compensation from internal resistance */
     rcomp = ab8500_fg_battery_resistance(di, vbat_uv);
     vbat_uv = vbat_uv - (di->inst_curr_ua * rcomp) / 1000;
 
     /* Always keep this state at latest measurement */
     di->vbat_uv = vbat_uv;
 
     return vbat_uv;
 }
 
 /**
  * ab8500_fg_load_comp_volt_to_capacity() - Load compensated voltage based capacity
  * @di:     pointer to the ab8500_fg structure
  *
  * Returns battery capacity based on battery voltage that is load compensated
  * for the voltage drop
  */
 static int ab8500_fg_load_comp_volt_to_capacity(struct ab8500_fg *di)
 {
     int vbat_comp_uv;
 
     vbat_comp_uv = ab8500_load_comp_fg_bat_voltage(di, true);
 
     return ab8500_fg_volt_to_capacity(di, vbat_comp_uv);
 }
 
 /**
  * ab8500_fg_convert_mah_to_permille() - Capacity in mAh to permille
  * @di:     pointer to the ab8500_fg structure
  * @cap_mah:    capacity in mAh
  *
  * Converts capacity in mAh to capacity in permille
  */
 static int ab8500_fg_convert_mah_to_permille(struct ab8500_fg *di, int cap_mah)
 {
     return (cap_mah * 1000) / di->bat_cap.max_mah_design;
 }
 
 /**
  * ab8500_fg_convert_permille_to_mah() - Capacity in permille to mAh
  * @di:     pointer to the ab8500_fg structure
  * @cap_pm: capacity in permille
  *
  * Converts capacity in permille to capacity in mAh
  */
 static int ab8500_fg_convert_permille_to_mah(struct ab8500_fg *di, int cap_pm)
 {
     return cap_pm * di->bat_cap.max_mah_design / 1000;
 }
 
 /**
  * ab8500_fg_convert_mah_to_uwh() - Capacity in mAh to uWh
  * @di:     pointer to the ab8500_fg structure
  * @cap_mah:    capacity in mAh
  *
  * Converts capacity in mAh to capacity in uWh
  */
 static int ab8500_fg_convert_mah_to_uwh(struct ab8500_fg *di, int cap_mah)
 {
     u64 div_res;
     u32 div_rem;
 
     /*
      * Capacity is in milli ampere hours (10^-3)Ah
      * Nominal voltage is in microvolts (10^-6)V
      * divide by 1000000 after multiplication to get to mWh
      */
     div_res = ((u64) cap_mah) * ((u64) di->vbat_nom_uv);
     div_rem = do_div(div_res, 1000000);
 
     /* Make sure to round upwards if necessary */
     if (div_rem >= 1000000 / 2)
         div_res++;
 
     return (int) div_res;
 }
 
 /**
  * ab8500_fg_calc_cap_charging() - Calculate remaining capacity while charging
  * @di:     pointer to the ab8500_fg structure
  *
  * Return the capacity in mAh based on previous calculated capcity and the FG
  * accumulator register value. The filter is filled with this capacity
  */
 static int ab8500_fg_calc_cap_charging(struct ab8500_fg *di)
 {
     dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
         __func__,
         di->bat_cap.mah,
         di->accu_charge);
 
     /* Capacity should not be less than 0 */
     if (di->bat_cap.mah + di->accu_charge > 0)
         di->bat_cap.mah += di->accu_charge;
     else
         di->bat_cap.mah = 0;
     /*
      * We force capacity to 100% once when the algorithm
      * reports that it's full.
      */
     if (di->bat_cap.mah >= di->bat_cap.max_mah_design ||
         di->flags.force_full) {
         di->bat_cap.mah = di->bat_cap.max_mah_design;
     }
 
     ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
     di->bat_cap.permille =
         ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
 
     /* We need to update battery voltage and inst current when charging */
     di->vbat_uv = ab8500_fg_bat_voltage(di);
     di->inst_curr_ua = ab8500_fg_inst_curr_blocking(di);
 
     return di->bat_cap.mah;
 }
 
 /**
  * ab8500_fg_calc_cap_discharge_voltage() - Capacity in discharge with voltage
  * @di:     pointer to the ab8500_fg structure
  *
  * Return the capacity in mAh based on the load compensated battery voltage.
  * This value is added to the filter and a new mean value is calculated and
  * returned.
  */
 static int ab8500_fg_calc_cap_discharge_voltage(struct ab8500_fg *di)
 {
     int permille, mah;
 
     permille = ab8500_fg_load_comp_volt_to_capacity(di);
 
     mah = ab8500_fg_convert_permille_to_mah(di, permille);
 
     di->bat_cap.mah = ab8500_fg_add_cap_sample(di, mah);
     di->bat_cap.permille =
         ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
 
     return di->bat_cap.mah;
 }
 
 /**
  * ab8500_fg_calc_cap_discharge_fg() - Capacity in discharge with FG
  * @di:     pointer to the ab8500_fg structure
  *
  * Return the capacity in mAh based on previous calculated capcity and the FG
  * accumulator register value. This value is added to the filter and a
  * new mean value is calculated and returned.
  */
 static int ab8500_fg_calc_cap_discharge_fg(struct ab8500_fg *di)
 {
     int permille_volt, permille;
 
     dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
         __func__,
         di->bat_cap.mah,
         di->accu_charge);
 
     /* Capacity should not be less than 0 */
     if (di->bat_cap.mah + di->accu_charge > 0)
         di->bat_cap.mah += di->accu_charge;
     else
         di->bat_cap.mah = 0;
 
     if (di->bat_cap.mah >= di->bat_cap.max_mah_design)
         di->bat_cap.mah = di->bat_cap.max_mah_design;
 
     /*
      * Check against voltage based capacity. It can not be lower
      * than what the uncompensated voltage says
      */
     permille = ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
     permille_volt = ab8500_fg_uncomp_volt_to_capacity(di);
 
     if (permille < permille_volt) {
         di->bat_cap.permille = permille_volt;
         di->bat_cap.mah = ab8500_fg_convert_permille_to_mah(di,
             di->bat_cap.permille);
 
         dev_dbg(di->dev, "%s voltage based: perm %d perm_volt %d\n",
             __func__,
             permille,
             permille_volt);
 
         ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
     } else {
         ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
         di->bat_cap.permille =
             ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
     }
 
     return di->bat_cap.mah;
 }
 
 /**
  * ab8500_fg_capacity_level() - Get the battery capacity level
  * @di:     pointer to the ab8500_fg structure
  *
  * Get the battery capacity level based on the capacity in percent
  */
 static int ab8500_fg_capacity_level(struct ab8500_fg *di)
 {
     int ret, percent;
 
     percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
 
     if (percent <= di->bm->cap_levels->critical ||
         di->flags.low_bat)
         ret = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
     else if (percent <= di->bm->cap_levels->low)
         ret = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
     else if (percent <= di->bm->cap_levels->normal)
         ret = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
     else if (percent <= di->bm->cap_levels->high)
         ret = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
     else
         ret = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
 
     return ret;
 }
 
 /**
  * ab8500_fg_calculate_scaled_capacity() - Capacity scaling
  * @di:     pointer to the ab8500_fg structure
  *
  * Calculates the capacity to be shown to upper layers. Scales the capacity
  * to have 100% as a reference from the actual capacity upon removal of charger
  * when charging is in maintenance mode.
  */
 static int ab8500_fg_calculate_scaled_capacity(struct ab8500_fg *di)
 {
     struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
     int capacity = di->bat_cap.prev_percent;
 
     if (!cs->enable)
         return capacity;
 
     /*
      * As long as we are in fully charge mode scale the capacity
      * to show 100%.
      */
     if (di->flags.fully_charged) {
         cs->cap_to_scale[0] = 100;
         cs->cap_to_scale[1] =
             max(capacity, di->bm->fg_params->maint_thres);
         dev_dbg(di->dev, "Scale cap with %d/%d\n",
              cs->cap_to_scale[0], cs->cap_to_scale[1]);
     }
 
     /* Calculates the scaled capacity. */
     if ((cs->cap_to_scale[0] != cs->cap_to_scale[1])
                     && (cs->cap_to_scale[1] > 0))
         capacity = min(100,
                  DIV_ROUND_CLOSEST(di->bat_cap.prev_percent *
                          cs->cap_to_scale[0],
                          cs->cap_to_scale[1]));
 
     if (di->flags.charging) {
         if (capacity < cs->disable_cap_level) {
             cs->disable_cap_level = capacity;
             dev_dbg(di->dev, "Cap to stop scale lowered %d%%\n",
                 cs->disable_cap_level);
         } else if (!di->flags.fully_charged) {
             if (di->bat_cap.prev_percent >=
                 cs->disable_cap_level) {
                 dev_dbg(di->dev, "Disabling scaled capacity\n");
                 cs->enable = false;
                 capacity = di->bat_cap.prev_percent;
             } else {
                 dev_dbg(di->dev,
                     "Waiting in cap to level %d%%\n",
                     cs->disable_cap_level);
                 capacity = cs->disable_cap_level;
             }
         }
     }
 
     return capacity;
 }
 
 /**
  * ab8500_fg_update_cap_scalers() - Capacity scaling
  * @di:     pointer to the ab8500_fg structure
  *
  * To be called when state change from charge<->discharge to update
  * the capacity scalers.
  */
 static void ab8500_fg_update_cap_scalers(struct ab8500_fg *di)
 {
     struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
 
     if (!cs->enable)
         return;
     if (di->flags.charging) {
         di->bat_cap.cap_scale.disable_cap_level =
             di->bat_cap.cap_scale.scaled_cap;
         dev_dbg(di->dev, "Cap to stop scale at charge %d%%\n",
                 di->bat_cap.cap_scale.disable_cap_level);
     } else {
         if (cs->scaled_cap != 100) {
             cs->cap_to_scale[0] = cs->scaled_cap;
             cs->cap_to_scale[1] = di->bat_cap.prev_percent;
         } else {
             cs->cap_to_scale[0] = 100;
             cs->cap_to_scale[1] =
                 max(di->bat_cap.prev_percent,
                     di->bm->fg_params->maint_thres);
         }
 
         dev_dbg(di->dev, "Cap to scale at discharge %d/%d\n",
                 cs->cap_to_scale[0], cs->cap_to_scale[1]);
     }
 }
 
 /**
  * ab8500_fg_check_capacity_limits() - Check if capacity has changed
  * @di:     pointer to the ab8500_fg structure
  * @init:   capacity is allowed to go up in init mode
  *
  * Check if capacity or capacity limit has changed and notify the system
  * about it using the power_supply framework
  */
 static void ab8500_fg_check_capacity_limits(struct ab8500_fg *di, bool init)
 {
     bool changed = false;
     int percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
 
     di->bat_cap.level = ab8500_fg_capacity_level(di);
 
     if (di->bat_cap.level != di->bat_cap.prev_level) {
         /*
          * We do not allow reported capacity level to go up
          * unless we're charging or if we're in init
          */
         if (!(!di->flags.charging && di->bat_cap.level >
             di->bat_cap.prev_level) || init) {
             dev_dbg(di->dev, "level changed from %d to %d\n",
                 di->bat_cap.prev_level,
                 di->bat_cap.level);
             di->bat_cap.prev_level = di->bat_cap.level;
             changed = true;
         } else {
             dev_dbg(di->dev, "level not allowed to go up "
                 "since no charger is connected: %d to %d\n",
                 di->bat_cap.prev_level,
                 di->bat_cap.level);
         }
     }
 
     /*
      * If we have received the LOW_BAT IRQ, set capacity to 0 to initiate
      * shutdown
      */
     if (di->flags.low_bat) {
         dev_dbg(di->dev, "Battery low, set capacity to 0\n");
         di->bat_cap.prev_percent = 0;
         di->bat_cap.permille = 0;
         percent = 0;
         di->bat_cap.prev_mah = 0;
         di->bat_cap.mah = 0;
         changed = true;
     } else if (di->flags.fully_charged) {
         /*
          * We report 100% if algorithm reported fully charged
          * and show 100% during maintenance charging (scaling).
          */
         if (di->flags.force_full) {
             di->bat_cap.prev_percent = percent;
             di->bat_cap.prev_mah = di->bat_cap.mah;
 
             changed = true;
 
             if (!di->bat_cap.cap_scale.enable &&
                         di->bm->capacity_scaling) {
                 di->bat_cap.cap_scale.enable = true;
                 di->bat_cap.cap_scale.cap_to_scale[0] = 100;
                 di->bat_cap.cap_scale.cap_to_scale[1] =
                         di->bat_cap.prev_percent;
                 di->bat_cap.cap_scale.disable_cap_level = 100;
             }
         } else if (di->bat_cap.prev_percent != percent) {
             dev_dbg(di->dev,
                 "battery reported full "
                 "but capacity dropping: %d\n",
                 percent);
             di->bat_cap.prev_percent = percent;
             di->bat_cap.prev_mah = di->bat_cap.mah;
 
             changed = true;
         }
     } else if (di->bat_cap.prev_percent != percent) {
         if (percent == 0) {
             /*
              * We will not report 0% unless we've got
              * the LOW_BAT IRQ, no matter what the FG
              * algorithm says.
              */
             di->bat_cap.prev_percent = 1;
             percent = 1;
 
             changed = true;
         } else if (!(!di->flags.charging &&
             percent > di->bat_cap.prev_percent) || init) {
             /*
              * We do not allow reported capacity to go up
              * unless we're charging or if we're in init
              */
             dev_dbg(di->dev,
                 "capacity changed from %d to %d (%d)\n",
                 di->bat_cap.prev_percent,
                 percent,
                 di->bat_cap.permille);
             di->bat_cap.prev_percent = percent;
             di->bat_cap.prev_mah = di->bat_cap.mah;
 
             changed = true;
         } else {
             dev_dbg(di->dev, "capacity not allowed to go up since "
                 "no charger is connected: %d to %d (%d)\n",
                 di->bat_cap.prev_percent,
                 percent,
                 di->bat_cap.permille);
         }
     }
 
     if (changed) {
         if (di->bm->capacity_scaling) {
             di->bat_cap.cap_scale.scaled_cap =
                 ab8500_fg_calculate_scaled_capacity(di);
 
             dev_info(di->dev, "capacity=%d (%d)\n",
                 di->bat_cap.prev_percent,
                 di->bat_cap.cap_scale.scaled_cap);
         }
         power_supply_changed(di->fg_psy);
         if (di->flags.fully_charged && di->flags.force_full) {
             dev_dbg(di->dev, "Battery full, notifying.\n");
             di->flags.force_full = false;
             sysfs_notify(&di->fg_kobject, NULL, "charge_full");
         }
         sysfs_notify(&di->fg_kobject, NULL, "charge_now");
     }
 }
 
 static void ab8500_fg_charge_state_to(struct ab8500_fg *di,
     enum ab8500_fg_charge_state new_state)
 {
     dev_dbg(di->dev, "Charge state from %d [%s] to %d [%s]\n",
         di->charge_state,
         charge_state[di->charge_state],
         new_state,
         charge_state[new_state]);
 
     di->charge_state = new_state;
 }
 
 static void ab8500_fg_discharge_state_to(struct ab8500_fg *di,
     enum ab8500_fg_discharge_state new_state)
 {
     dev_dbg(di->dev, "Discharge state from %d [%s] to %d [%s]\n",
         di->discharge_state,
         discharge_state[di->discharge_state],
         new_state,
         discharge_state[new_state]);
 
     di->discharge_state = new_state;
 }
 
 /**
  * ab8500_fg_algorithm_charging() - FG algorithm for when charging
  * @di:     pointer to the ab8500_fg structure
  *
  * Battery capacity calculation state machine for when we're charging
  */
 static void ab8500_fg_algorithm_charging(struct ab8500_fg *di)
 {
     /*
      * If we change to discharge mode
      * we should start with recovery
      */
     if (di->discharge_state != AB8500_FG_DISCHARGE_INIT_RECOVERY)
         ab8500_fg_discharge_state_to(di,
             AB8500_FG_DISCHARGE_INIT_RECOVERY);
 
     switch (di->charge_state) {
     case AB8500_FG_CHARGE_INIT:
         di->fg_samples = SEC_TO_SAMPLE(
             di->bm->fg_params->accu_charging);
 
         ab8500_fg_coulomb_counter(di, true);
         ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_READOUT);
 
         break;
 
     case AB8500_FG_CHARGE_READOUT:
         /*
          * Read the FG and calculate the new capacity
          */
         mutex_lock(&di->cc_lock);
         if (!di->flags.conv_done && !di->flags.force_full) {
             /* Wasn't the CC IRQ that got us here */
             mutex_unlock(&di->cc_lock);
             dev_dbg(di->dev, "%s CC conv not done\n",
                 __func__);
 
             break;
         }
         di->flags.conv_done = false;
         mutex_unlock(&di->cc_lock);
 
         ab8500_fg_calc_cap_charging(di);
 
         break;
 
     default:
         break;
     }
 
     /* Check capacity limits */
     ab8500_fg_check_capacity_limits(di, false);
 }
 
 static void force_capacity(struct ab8500_fg *di)
 {
     int cap;
 
     ab8500_fg_clear_cap_samples(di);
     cap = di->bat_cap.user_mah;
     if (cap > di->bat_cap.max_mah_design) {
         dev_dbg(di->dev, "Remaining cap %d can't be bigger than total"
             " %d\n", cap, di->bat_cap.max_mah_design);
         cap = di->bat_cap.max_mah_design;
     }
     ab8500_fg_fill_cap_sample(di, di->bat_cap.user_mah);
     di->bat_cap.permille = ab8500_fg_convert_mah_to_permille(di, cap);
     di->bat_cap.mah = cap;
     ab8500_fg_check_capacity_limits(di, true);
 }
 
 static bool check_sysfs_capacity(struct ab8500_fg *di)
 {
     int cap, lower, upper;
     int cap_permille;
 
     cap = di->bat_cap.user_mah;
 
     cap_permille = ab8500_fg_convert_mah_to_permille(di,
         di->bat_cap.user_mah);
 
     lower = di->bat_cap.permille - di->bm->fg_params->user_cap_limit * 10;
     upper = di->bat_cap.permille + di->bm->fg_params->user_cap_limit * 10;
 
     if (lower < 0)
         lower = 0;
     /* 1000 is permille, -> 100 percent */
     if (upper > 1000)
         upper = 1000;
 
     dev_dbg(di->dev, "Capacity limits:"
         " (Lower: %d User: %d Upper: %d) [user: %d, was: %d]\n",
         lower, cap_permille, upper, cap, di->bat_cap.mah);
 
     /* If within limits, use the saved capacity and exit estimation...*/
     if (cap_permille > lower && cap_permille < upper) {
         dev_dbg(di->dev, "OK! Using users cap %d uAh now\n", cap);
         force_capacity(di);
         return true;
     }
     dev_dbg(di->dev, "Capacity from user out of limits, ignoring");
     return false;
 }
 
 /**
  * ab8500_fg_algorithm_discharging() - FG algorithm for when discharging
  * @di:     pointer to the ab8500_fg structure
  *
  * Battery capacity calculation state machine for when we're discharging
  */
 static void ab8500_fg_algorithm_discharging(struct ab8500_fg *di)
 {
     int sleep_time;
 
     /* If we change to charge mode we should start with init */
     if (di->charge_state != AB8500_FG_CHARGE_INIT)
         ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
 
     switch (di->discharge_state) {
     case AB8500_FG_DISCHARGE_INIT:
         /* We use the FG IRQ to work on */
         di->init_cnt = 0;
         di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
         ab8500_fg_coulomb_counter(di, true);
         ab8500_fg_discharge_state_to(di,
             AB8500_FG_DISCHARGE_INITMEASURING);
 
         fallthrough;
     case AB8500_FG_DISCHARGE_INITMEASURING:
         /*
          * Discard a number of samples during startup.
          * After that, use compensated voltage for a few
          * samples to get an initial capacity.
          * Then go to READOUT
          */
         sleep_time = di->bm->fg_params->init_timer;
 
         /* Discard the first [x] seconds */
         if (di->init_cnt > di->bm->fg_params->init_discard_time) {
             ab8500_fg_calc_cap_discharge_voltage(di);
 
             ab8500_fg_check_capacity_limits(di, true);
         }
 
         di->init_cnt += sleep_time;
         if (di->init_cnt > di->bm->fg_params->init_total_time)
             ab8500_fg_discharge_state_to(di,
                 AB8500_FG_DISCHARGE_READOUT_INIT);
 
         break;
 
     case AB8500_FG_DISCHARGE_INIT_RECOVERY:
         di->recovery_cnt = 0;
         di->recovery_needed = true;
         ab8500_fg_discharge_state_to(di,
             AB8500_FG_DISCHARGE_RECOVERY);
 
         fallthrough;
 
     case AB8500_FG_DISCHARGE_RECOVERY:
         sleep_time = di->bm->fg_params->recovery_sleep_timer;
 
         /*
          * We should check the power consumption
          * If low, go to READOUT (after x min) or
          * RECOVERY_SLEEP if time left.
          * If high, go to READOUT
          */
         di->inst_curr_ua = ab8500_fg_inst_curr_blocking(di);
 
         if (ab8500_fg_is_low_curr(di, di->inst_curr_ua)) {
             if (di->recovery_cnt >
                 di->bm->fg_params->recovery_total_time) {
                 di->fg_samples = SEC_TO_SAMPLE(
                     di->bm->fg_params->accu_high_curr);
                 ab8500_fg_coulomb_counter(di, true);
                 ab8500_fg_discharge_state_to(di,
                     AB8500_FG_DISCHARGE_READOUT);
                 di->recovery_needed = false;
             } else {
                 queue_delayed_work(di->fg_wq,
                     &di->fg_periodic_work,
                     sleep_time * HZ);
             }
             di->recovery_cnt += sleep_time;
         } else {
             di->fg_samples = SEC_TO_SAMPLE(
                 di->bm->fg_params->accu_high_curr);
             ab8500_fg_coulomb_counter(di, true);
             ab8500_fg_discharge_state_to(di,
                 AB8500_FG_DISCHARGE_READOUT);
         }
         break;
 
     case AB8500_FG_DISCHARGE_READOUT_INIT:
         di->fg_samples = SEC_TO_SAMPLE(
             di->bm->fg_params->accu_high_curr);
         ab8500_fg_coulomb_counter(di, true);
         ab8500_fg_discharge_state_to(di,
                 AB8500_FG_DISCHARGE_READOUT);
         break;
 
     case AB8500_FG_DISCHARGE_READOUT:
         di->inst_curr_ua = ab8500_fg_inst_curr_blocking(di);
 
         if (ab8500_fg_is_low_curr(di, di->inst_curr_ua)) {
             /* Detect mode change */
             if (di->high_curr_mode) {
                 di->high_curr_mode = false;
                 di->high_curr_cnt = 0;
             }
 
             if (di->recovery_needed) {
                 ab8500_fg_discharge_state_to(di,
                     AB8500_FG_DISCHARGE_INIT_RECOVERY);
 
                 queue_delayed_work(di->fg_wq,
                     &di->fg_periodic_work, 0);
 
                 break;
             }
 
             ab8500_fg_calc_cap_discharge_voltage(di);
         } else {
             mutex_lock(&di->cc_lock);
             if (!di->flags.conv_done) {
                 /* Wasn't the CC IRQ that got us here */
                 mutex_unlock(&di->cc_lock);
                 dev_dbg(di->dev, "%s CC conv not done\n",
                     __func__);
 
                 break;
             }
             di->flags.conv_done = false;
             mutex_unlock(&di->cc_lock);
 
             /* Detect mode change */
             if (!di->high_curr_mode) {
                 di->high_curr_mode = true;
                 di->high_curr_cnt = 0;
             }
 
             di->high_curr_cnt +=
                 di->bm->fg_params->accu_high_curr;
             if (di->high_curr_cnt >
                 di->bm->fg_params->high_curr_time)
                 di->recovery_needed = true;
 
             ab8500_fg_calc_cap_discharge_fg(di);
         }
 
         ab8500_fg_check_capacity_limits(di, false);
 
         break;
 
     case AB8500_FG_DISCHARGE_WAKEUP:
         ab8500_fg_calc_cap_discharge_voltage(di);
 
         di->fg_samples = SEC_TO_SAMPLE(
             di->bm->fg_params->accu_high_curr);
         ab8500_fg_coulomb_counter(di, true);
         ab8500_fg_discharge_state_to(di,
                 AB8500_FG_DISCHARGE_READOUT);
 
         ab8500_fg_check_capacity_limits(di, false);
 
         break;
 
     default:
         break;
     }
 }
 
 /**
  * ab8500_fg_algorithm_calibrate() - Internal columb counter offset calibration
  * @di:     pointer to the ab8500_fg structure
  *
  */
 static void ab8500_fg_algorithm_calibrate(struct ab8500_fg *di)
 {
     int ret;
 
     switch (di->calib_state) {
     case AB8500_FG_CALIB_INIT:
         dev_dbg(di->dev, "Calibration ongoing...\n");
 
         ret = abx500_mask_and_set_register_interruptible(di->dev,
             AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
             CC_INT_CAL_N_AVG_MASK, CC_INT_CAL_SAMPLES_8);
         if (ret < 0)
             goto err;
 
         ret = abx500_mask_and_set_register_interruptible(di->dev,
             AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
             CC_INTAVGOFFSET_ENA, CC_INTAVGOFFSET_ENA);
         if (ret < 0)
             goto err;
         di->calib_state = AB8500_FG_CALIB_WAIT;
         break;
     case AB8500_FG_CALIB_END:
         ret = abx500_mask_and_set_register_interruptible(di->dev,
             AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
             CC_MUXOFFSET, CC_MUXOFFSET);
         if (ret < 0)
             goto err;
         di->flags.calibrate = false;
         dev_dbg(di->dev, "Calibration done...\n");
         queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
         break;
     case AB8500_FG_CALIB_WAIT:
         dev_dbg(di->dev, "Calibration WFI\n");
         break;
     default:
         break;
     }
     return;
 err:
     /* Something went wrong, don't calibrate then */
     dev_err(di->dev, "failed to calibrate the CC\n");
     di->flags.calibrate = false;
     di->calib_state = AB8500_FG_CALIB_INIT;
     queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
 }
 
 /**
  * ab8500_fg_algorithm() - Entry point for the FG algorithm
  * @di:     pointer to the ab8500_fg structure
  *
  * Entry point for the battery capacity calculation state machine
  */
 static void ab8500_fg_algorithm(struct ab8500_fg *di)
 {
     if (di->flags.calibrate)
         ab8500_fg_algorithm_calibrate(di);
     else {
         if (di->flags.charging)
             ab8500_fg_algorithm_charging(di);
         else
             ab8500_fg_algorithm_discharging(di);
     }
 
     dev_dbg(di->dev, "[FG_DATA] %d %d %d %d %d %d %d %d %d %d "
         "%d %d %d %d %d %d %d\n",
         di->bat_cap.max_mah_design,
         di->bat_cap.max_mah,
         di->bat_cap.mah,
         di->bat_cap.permille,
         di->bat_cap.level,
         di->bat_cap.prev_mah,
         di->bat_cap.prev_percent,
         di->bat_cap.prev_level,
         di->vbat_uv,
         di->inst_curr_ua,
         di->avg_curr_ua,
         di->accu_charge,
         di->flags.charging,
         di->charge_state,
         di->discharge_state,
         di->high_curr_mode,
         di->recovery_needed);
 }
 
 /**
  * ab8500_fg_periodic_work() - Run the FG state machine periodically
  * @work:   pointer to the work_struct structure
  *
  * Work queue function for periodic work
  */
 static void ab8500_fg_periodic_work(struct work_struct *work)
 {
     struct ab8500_fg *di = container_of(work, struct ab8500_fg,
         fg_periodic_work.work);
 
     if (di->init_capacity) {
         /* Get an initial capacity calculation */
         ab8500_fg_calc_cap_discharge_voltage(di);
         ab8500_fg_check_capacity_limits(di, true);
         di->init_capacity = false;
 
         queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
     } else if (di->flags.user_cap) {
         if (check_sysfs_capacity(di)) {
             ab8500_fg_check_capacity_limits(di, true);
             if (di->flags.charging)
                 ab8500_fg_charge_state_to(di,
                     AB8500_FG_CHARGE_INIT);
             else
                 ab8500_fg_discharge_state_to(di,
                     AB8500_FG_DISCHARGE_READOUT_INIT);
         }
         di->flags.user_cap = false;
         queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
     } else
         ab8500_fg_algorithm(di);
 
 }
 
 /**
  * ab8500_fg_check_hw_failure_work() - Check OVV_BAT condition
  * @work:   pointer to the work_struct structure
  *
  * Work queue function for checking the OVV_BAT condition
  */
 static void ab8500_fg_check_hw_failure_work(struct work_struct *work)
 {
     int ret;
     u8 reg_value;
 
     struct ab8500_fg *di = container_of(work, struct ab8500_fg,
         fg_check_hw_failure_work.work);
 
     /*
      * If we have had a battery over-voltage situation,
      * check ovv-bit to see if it should be reset.
      */
     ret = abx500_get_register_interruptible(di->dev,
         AB8500_CHARGER, AB8500_CH_STAT_REG,
         &reg_value);
     if (ret < 0) {
         dev_err(di->dev, "%s ab8500 read failed\n", __func__);
         return;
     }
     if ((reg_value & BATT_OVV) == BATT_OVV) {
         if (!di->flags.bat_ovv) {
             dev_dbg(di->dev, "Battery OVV\n");
             di->flags.bat_ovv = true;
             power_supply_changed(di->fg_psy);
         }
         /* Not yet recovered from ovv, reschedule this test */
         queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work,
                    HZ);
         } else {
             dev_dbg(di->dev, "Battery recovered from OVV\n");
             di->flags.bat_ovv = false;
             power_supply_changed(di->fg_psy);
     }
 }
 
 /**
  * ab8500_fg_low_bat_work() - Check LOW_BAT condition
  * @work:   pointer to the work_struct structure
  *
  * Work queue function for checking the LOW_BAT condition
  */
 static void ab8500_fg_low_bat_work(struct work_struct *work)
 {
     int vbat_uv;
 
     struct ab8500_fg *di = container_of(work, struct ab8500_fg,
         fg_low_bat_work.work);
 
     vbat_uv = ab8500_fg_bat_voltage(di);
 
     /* Check if LOW_BAT still fulfilled */
     if (vbat_uv < di->bm->fg_params->lowbat_threshold_uv) {
         /* Is it time to shut down? */
         if (di->low_bat_cnt < 1) {
             di->flags.low_bat = true;
             dev_warn(di->dev, "Shut down pending...\n");
         } else {
             /*
             * Else we need to re-schedule this check to be able to detect
             * if the voltage increases again during charging or
             * due to decreasing load.
             */
             di->low_bat_cnt--;
             dev_warn(di->dev, "Battery voltage still LOW\n");
             queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
                 round_jiffies(LOW_BAT_CHECK_INTERVAL));
         }
     } else {
         di->flags.low_bat_delay = false;
         di->low_bat_cnt = 10;
         dev_warn(di->dev, "Battery voltage OK again\n");
     }
 
     /* This is needed to dispatch LOW_BAT */
     ab8500_fg_check_capacity_limits(di, false);
 }
 
 /**
  * ab8500_fg_battok_calc - calculate the bit pattern corresponding
  * to the target voltage.
  * @di:       pointer to the ab8500_fg structure
  * @target:   target voltage
  *
  * Returns bit pattern closest to the target voltage
  * valid return values are 0-14. (0-BATT_OK_MAX_NR_INCREMENTS)
  */
 
 static int ab8500_fg_battok_calc(struct ab8500_fg *di, int target)
 {
     if (target > BATT_OK_MIN +
         (BATT_OK_INCREMENT * BATT_OK_MAX_NR_INCREMENTS))
         return BATT_OK_MAX_NR_INCREMENTS;
     if (target < BATT_OK_MIN)
         return 0;
     return (target - BATT_OK_MIN) / BATT_OK_INCREMENT;
 }
 
 /**
  * ab8500_fg_battok_init_hw_register - init battok levels
  * @di:       pointer to the ab8500_fg structure
  *
  */
 
 static int ab8500_fg_battok_init_hw_register(struct ab8500_fg *di)
 {
     int selected;
     int sel0;
     int sel1;
     int cbp_sel0;
     int cbp_sel1;
     int ret;
     int new_val;
 
     sel0 = di->bm->fg_params->battok_falling_th_sel0;
     sel1 = di->bm->fg_params->battok_raising_th_sel1;
 
     cbp_sel0 = ab8500_fg_battok_calc(di, sel0);
     cbp_sel1 = ab8500_fg_battok_calc(di, sel1);
 
     selected = BATT_OK_MIN + cbp_sel0 * BATT_OK_INCREMENT;
 
     if (selected != sel0)
         dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
             sel0, selected, cbp_sel0);
 
     selected = BATT_OK_MIN + cbp_sel1 * BATT_OK_INCREMENT;
 
     if (selected != sel1)
         dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
             sel1, selected, cbp_sel1);
 
     new_val = cbp_sel0 | (cbp_sel1 << 4);
 
     dev_dbg(di->dev, "using: %x %d %d\n", new_val, cbp_sel0, cbp_sel1);
     ret = abx500_set_register_interruptible(di->dev, AB8500_SYS_CTRL2_BLOCK,
         AB8500_BATT_OK_REG, new_val);
     return ret;
 }
 
 /**
  * ab8500_fg_instant_work() - Run the FG state machine instantly
  * @work:   pointer to the work_struct structure
  *
  * Work queue function for instant work
  */
 static void ab8500_fg_instant_work(struct work_struct *work)
 {
     struct ab8500_fg *di = container_of(work, struct ab8500_fg, fg_work);
 
     ab8500_fg_algorithm(di);
 }
 
 /**
  * ab8500_fg_cc_data_end_handler() - end of data conversion isr.
  * @irq:       interrupt number
  * @_di:       pointer to the ab8500_fg structure
  *
  * Returns IRQ status(IRQ_HANDLED)
  */
 static irqreturn_t ab8500_fg_cc_data_end_handler(int irq, void *_di)
 {
     struct ab8500_fg *di = _di;
     if (!di->nbr_cceoc_irq_cnt) {
         di->nbr_cceoc_irq_cnt++;
         complete(&di->ab8500_fg_started);
     } else {
         di->nbr_cceoc_irq_cnt = 0;
         complete(&di->ab8500_fg_complete);
     }
     return IRQ_HANDLED;
 }
 
 /**
  * ab8500_fg_cc_int_calib_handler () - end of calibration isr.
  * @irq:       interrupt number
  * @_di:       pointer to the ab8500_fg structure
  *
  * Returns IRQ status(IRQ_HANDLED)
  */
 static irqreturn_t ab8500_fg_cc_int_calib_handler(int irq, void *_di)
 {
     struct ab8500_fg *di = _di;
     di->calib_state = AB8500_FG_CALIB_END;
     queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
     return IRQ_HANDLED;
 }
 
 /**
  * ab8500_fg_cc_convend_handler() - isr to get battery avg current.
  * @irq:       interrupt number
  * @_di:       pointer to the ab8500_fg structure
  *
  * Returns IRQ status(IRQ_HANDLED)
  */
 static irqreturn_t ab8500_fg_cc_convend_handler(int irq, void *_di)
 {
     struct ab8500_fg *di = _di;
 
     queue_work(di->fg_wq, &di->fg_acc_cur_work);
 
     return IRQ_HANDLED;
 }
 
 /**
  * ab8500_fg_batt_ovv_handler() - Battery OVV occured
  * @irq:       interrupt number
  * @_di:       pointer to the ab8500_fg structure
  *
  * Returns IRQ status(IRQ_HANDLED)
  */
 static irqreturn_t ab8500_fg_batt_ovv_handler(int irq, void *_di)
 {
     struct ab8500_fg *di = _di;
 
     dev_dbg(di->dev, "Battery OVV\n");
 
     /* Schedule a new HW failure check */
     queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work, 0);
 
     return IRQ_HANDLED;
 }
 
 /**
  * ab8500_fg_lowbatf_handler() - Battery voltage is below LOW threshold
  * @irq:       interrupt number
  * @_di:       pointer to the ab8500_fg structure
  *
  * Returns IRQ status(IRQ_HANDLED)
  */
 static irqreturn_t ab8500_fg_lowbatf_handler(int irq, void *_di)
 {
     struct ab8500_fg *di = _di;
 
     /* Initiate handling in ab8500_fg_low_bat_work() if not already initiated. */
     if (!di->flags.low_bat_delay) {
         dev_warn(di->dev, "Battery voltage is below LOW threshold\n");
         di->flags.low_bat_delay = true;
         /*
          * Start a timer to check LOW_BAT again after some time
          * This is done to avoid shutdown on single voltage dips
          */
         queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
             round_jiffies(LOW_BAT_CHECK_INTERVAL));
     }
     return IRQ_HANDLED;
 }
 
 /**
  * ab8500_fg_get_property() - get the fg properties
  * @psy:    pointer to the power_supply structure
  * @psp:    pointer to the power_supply_property structure
  * @val:    pointer to the power_supply_propval union
  *
  * This function gets called when an application tries to get the
  * fg properties by reading the sysfs files.
  * voltage_now:     battery voltage
  * current_now:     battery instant current
  * current_avg:     battery average current
  * charge_full_design:  capacity where battery is considered full
  * charge_now:      battery capacity in nAh
  * capacity:        capacity in percent
  * capacity_level:  capacity level
  *
  * Returns error code in case of failure else 0 on success
  */
 static int ab8500_fg_get_property(struct power_supply *psy,
     enum power_supply_property psp,
     union power_supply_propval *val)
 {
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     /*
      * If battery is identified as unknown and charging of unknown
      * batteries is disabled, we always report 100% capacity and
      * capacity level UNKNOWN, since we can't calculate
      * remaining capacity
      */
 
     switch (psp) {
     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
         if (di->flags.bat_ovv)
             val->intval = BATT_OVV_VALUE;
         else
             val->intval = di->vbat_uv;
         break;
     case POWER_SUPPLY_PROP_CURRENT_NOW:
         val->intval = di->inst_curr_ua;
         break;
     case POWER_SUPPLY_PROP_CURRENT_AVG:
         val->intval = di->avg_curr_ua;
         break;
     case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
         val->intval = ab8500_fg_convert_mah_to_uwh(di,
                 di->bat_cap.max_mah_design);
         break;
     case POWER_SUPPLY_PROP_ENERGY_FULL:
         val->intval = ab8500_fg_convert_mah_to_uwh(di,
                 di->bat_cap.max_mah);
         break;
     case POWER_SUPPLY_PROP_ENERGY_NOW:
         if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
                 di->flags.batt_id_received)
             val->intval = ab8500_fg_convert_mah_to_uwh(di,
                     di->bat_cap.max_mah);
         else
             val->intval = ab8500_fg_convert_mah_to_uwh(di,
                     di->bat_cap.prev_mah);
         break;
     case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
         val->intval = di->bat_cap.max_mah_design;
         break;
     case POWER_SUPPLY_PROP_CHARGE_FULL:
         val->intval = di->bat_cap.max_mah;
         break;
     case POWER_SUPPLY_PROP_CHARGE_NOW:
         if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
                 di->flags.batt_id_received)
             val->intval = di->bat_cap.max_mah;
         else
             val->intval = di->bat_cap.prev_mah;
         break;
     case POWER_SUPPLY_PROP_CAPACITY:
         if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
                 di->flags.batt_id_received)
             val->intval = 100;
         else
             val->intval = di->bat_cap.prev_percent;
         break;
     case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
         if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
                 di->flags.batt_id_received)
             val->intval = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
         else
             val->intval = di->bat_cap.prev_level;
         break;
     default:
         return -EINVAL;
     }
     return 0;
 }
 
 static int ab8500_fg_get_ext_psy_data(struct device *dev, void *data)
 {
     struct power_supply *psy;
     struct power_supply *ext = dev_get_drvdata(dev);
     const char **supplicants = (const char **)ext->supplied_to;
     struct ab8500_fg *di;
     struct power_supply_battery_info *bi;
     union power_supply_propval ret;
     int j;
 
     psy = (struct power_supply *)data;
     di = power_supply_get_drvdata(psy);
     bi = di->bm->bi;
 
     /*
      * For all psy where the name of your driver
      * appears in any supplied_to
      */
     j = match_string(supplicants, ext->num_supplicants, psy->desc->name);
     if (j < 0)
         return 0;
 
     /* Go through all properties for the psy */
     for (j = 0; j < ext->desc->num_properties; j++) {
         enum power_supply_property prop;
         prop = ext->desc->properties[j];
 
         if (power_supply_get_property(ext, prop, &ret))
             continue;
 
         switch (prop) {
         case POWER_SUPPLY_PROP_STATUS:
             switch (ext->desc->type) {
             case POWER_SUPPLY_TYPE_BATTERY:
                 switch (ret.intval) {
                 case POWER_SUPPLY_STATUS_UNKNOWN:
                 case POWER_SUPPLY_STATUS_DISCHARGING:
                 case POWER_SUPPLY_STATUS_NOT_CHARGING:
                     if (!di->flags.charging)
                         break;
                     di->flags.charging = false;
                     di->flags.fully_charged = false;
                     if (di->bm->capacity_scaling)
                         ab8500_fg_update_cap_scalers(di);
                     queue_work(di->fg_wq, &di->fg_work);
                     break;
                 case POWER_SUPPLY_STATUS_FULL:
                     if (di->flags.fully_charged)
                         break;
                     di->flags.fully_charged = true;
                     di->flags.force_full = true;
                     /* Save current capacity as maximum */
                     di->bat_cap.max_mah = di->bat_cap.mah;
                     queue_work(di->fg_wq, &di->fg_work);
                     break;
                 case POWER_SUPPLY_STATUS_CHARGING:
                     if (di->flags.charging &&
                         !di->flags.fully_charged)
                         break;
                     di->flags.charging = true;
                     di->flags.fully_charged = false;
                     if (di->bm->capacity_scaling)
                         ab8500_fg_update_cap_scalers(di);
                     queue_work(di->fg_wq, &di->fg_work);
                     break;
                 }
                 break;
             default:
                 break;
             }
             break;
         case POWER_SUPPLY_PROP_TECHNOLOGY:
             switch (ext->desc->type) {
             case POWER_SUPPLY_TYPE_BATTERY:
                 if (!di->flags.batt_id_received &&
                     (bi && (bi->technology !=
                         POWER_SUPPLY_TECHNOLOGY_UNKNOWN))) {
                     di->flags.batt_id_received = true;
 
                     di->bat_cap.max_mah_design =
                         di->bm->bi->charge_full_design_uah;
 
                     di->bat_cap.max_mah =
                         di->bat_cap.max_mah_design;
 
                     di->vbat_nom_uv =
                         di->bm->bi->voltage_max_design_uv;
                 }
 
                 if (ret.intval)
                     di->flags.batt_unknown = false;
                 else
                     di->flags.batt_unknown = true;
                 break;
             default:
                 break;
             }
             break;
         case POWER_SUPPLY_PROP_TEMP:
             switch (ext->desc->type) {
             case POWER_SUPPLY_TYPE_BATTERY:
                 if (di->flags.batt_id_received)
                     di->bat_temp = ret.intval;
                 break;
             default:
                 break;
             }
             break;
         default:
             break;
         }
     }
     return 0;
 }
 
 /**
  * ab8500_fg_init_hw_registers() - Set up FG related registers
  * @di:     pointer to the ab8500_fg structure
  *
  * Set up battery OVV, low battery voltage registers
  */
 static int ab8500_fg_init_hw_registers(struct ab8500_fg *di)
 {
     int ret;
 
     /*
      * Set VBAT OVV (overvoltage) threshold to 4.75V (typ) this is what
      * the hardware supports, nothing else can be configured in hardware.
      * See this as an "outer limit" where the charger will certainly
      * shut down. Other (lower) overvoltage levels need to be implemented
      * in software.
      */
     ret = abx500_mask_and_set_register_interruptible(di->dev,
         AB8500_CHARGER,
         AB8500_BATT_OVV,
         BATT_OVV_TH_4P75,
         BATT_OVV_TH_4P75);
     if (ret) {
         dev_err(di->dev, "failed to set BATT_OVV\n");
         goto out;
     }
 
     /* Enable VBAT OVV detection */
     ret = abx500_mask_and_set_register_interruptible(di->dev,
         AB8500_CHARGER,
         AB8500_BATT_OVV,
         BATT_OVV_ENA,
         BATT_OVV_ENA);
     if (ret) {
         dev_err(di->dev, "failed to enable BATT_OVV\n");
         goto out;
     }
 
     /* Low Battery Voltage */
     ret = abx500_set_register_interruptible(di->dev,
         AB8500_SYS_CTRL2_BLOCK,
         AB8500_LOW_BAT_REG,
         ab8500_volt_to_regval(
             di->bm->fg_params->lowbat_threshold_uv) << 1 |
         LOW_BAT_ENABLE);
     if (ret) {
         dev_err(di->dev, "%s write failed\n", __func__);
         goto out;
     }
 
     /* Battery OK threshold */
     ret = ab8500_fg_battok_init_hw_register(di);
     if (ret) {
         dev_err(di->dev, "BattOk init write failed.\n");
         goto out;
     }
 
     if (is_ab8505(di->parent)) {
         ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
             AB8505_RTC_PCUT_MAX_TIME_REG, di->bm->fg_params->pcut_max_time);
 
         if (ret) {
             dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_MAX_TIME_REG\n", __func__);
             goto out;
         }
 
         ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
             AB8505_RTC_PCUT_FLAG_TIME_REG, di->bm->fg_params->pcut_flag_time);
 
         if (ret) {
             dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_FLAG_TIME_REG\n", __func__);
             goto out;
         }
 
         ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
             AB8505_RTC_PCUT_RESTART_REG, di->bm->fg_params->pcut_max_restart);
 
         if (ret) {
             dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_RESTART_REG\n", __func__);
             goto out;
         }
 
         ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
             AB8505_RTC_PCUT_DEBOUNCE_REG, di->bm->fg_params->pcut_debounce_time);
 
         if (ret) {
             dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_DEBOUNCE_REG\n", __func__);
             goto out;
         }
 
         ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
             AB8505_RTC_PCUT_CTL_STATUS_REG, di->bm->fg_params->pcut_enable);
 
         if (ret) {
             dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_CTL_STATUS_REG\n", __func__);
             goto out;
         }
     }
 out:
     return ret;
 }
 
 /**
  * ab8500_fg_external_power_changed() - callback for power supply changes
  * @psy:       pointer to the structure power_supply
  *
  * This function is the entry point of the pointer external_power_changed
  * of the structure power_supply.
  * This function gets executed when there is a change in any external power
  * supply that this driver needs to be notified of.
  */
 static void ab8500_fg_external_power_changed(struct power_supply *psy)
 {
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     class_for_each_device(power_supply_class, NULL,
         di->fg_psy, ab8500_fg_get_ext_psy_data);
 }
 
 /**
  * ab8500_fg_reinit_work() - work to reset the FG algorithm
  * @work:   pointer to the work_struct structure
  *
  * Used to reset the current battery capacity to be able to
  * retrigger a new voltage base capacity calculation. For
  * test and verification purpose.
  */
 static void ab8500_fg_reinit_work(struct work_struct *work)
 {
     struct ab8500_fg *di = container_of(work, struct ab8500_fg,
         fg_reinit_work.work);
 
     if (!di->flags.calibrate) {
         dev_dbg(di->dev, "Resetting FG state machine to init.\n");
         ab8500_fg_clear_cap_samples(di);
         ab8500_fg_calc_cap_discharge_voltage(di);
         ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
         ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
         queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
 
     } else {
         dev_err(di->dev, "Residual offset calibration ongoing "
             "retrying..\n");
         /* Wait one second until next try*/
         queue_delayed_work(di->fg_wq, &di->fg_reinit_work,
             round_jiffies(1));
     }
 }
 
 /* Exposure to the sysfs interface */
 
 struct ab8500_fg_sysfs_entry {
     struct attribute attr;
     ssize_t (*show)(struct ab8500_fg *, char *);
     ssize_t (*store)(struct ab8500_fg *, const char *, size_t);
 };
 
 static ssize_t charge_full_show(struct ab8500_fg *di, char *buf)
 {
     return sprintf(buf, "%d\n", di->bat_cap.max_mah);
 }
 
 static ssize_t charge_full_store(struct ab8500_fg *di, const char *buf,
                  size_t count)
 {
     unsigned long charge_full;
     int ret;
 
     ret = kstrtoul(buf, 10, &charge_full);
     if (ret)
         return ret;
 
     di->bat_cap.max_mah = (int) charge_full;
     return count;
 }
 
 static ssize_t charge_now_show(struct ab8500_fg *di, char *buf)
 {
     return sprintf(buf, "%d\n", di->bat_cap.prev_mah);
 }
 
 static ssize_t charge_now_store(struct ab8500_fg *di, const char *buf,
                  size_t count)
 {
     unsigned long charge_now;
     int ret;
 
     ret = kstrtoul(buf, 10, &charge_now);
     if (ret)
         return ret;
 
     di->bat_cap.user_mah = (int) charge_now;
     di->flags.user_cap = true;
     queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
     return count;
 }
 
 static struct ab8500_fg_sysfs_entry charge_full_attr =
     __ATTR(charge_full, 0644, charge_full_show, charge_full_store);
 
 static struct ab8500_fg_sysfs_entry charge_now_attr =
     __ATTR(charge_now, 0644, charge_now_show, charge_now_store);
 
 static ssize_t
 ab8500_fg_show(struct kobject *kobj, struct attribute *attr, char *buf)
 {
     struct ab8500_fg_sysfs_entry *entry;
     struct ab8500_fg *di;
 
     entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr);
     di = container_of(kobj, struct ab8500_fg, fg_kobject);
 
     if (!entry->show)
         return -EIO;
 
     return entry->show(di, buf);
 }
 static ssize_t
 ab8500_fg_store(struct kobject *kobj, struct attribute *attr, const char *buf,
         size_t count)
 {
     struct ab8500_fg_sysfs_entry *entry;
     struct ab8500_fg *di;
 
     entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr);
     di = container_of(kobj, struct ab8500_fg, fg_kobject);
 
     if (!entry->store)
         return -EIO;
 
     return entry->store(di, buf, count);
 }
 
 static const struct sysfs_ops ab8500_fg_sysfs_ops = {
     .show = ab8500_fg_show,
     .store = ab8500_fg_store,
 };
 
 static struct attribute *ab8500_fg_attrs[] = {
     &charge_full_attr.attr,
     &charge_now_attr.attr,
     NULL,
 };
 ATTRIBUTE_GROUPS(ab8500_fg);
 
 static struct kobj_type ab8500_fg_ktype = {
     .sysfs_ops = &ab8500_fg_sysfs_ops,
     .default_groups = ab8500_fg_groups,
 };
 
 /**
  * ab8500_fg_sysfs_exit() - de-init of sysfs entry
  * @di:                pointer to the struct ab8500_chargalg
  *
  * This function removes the entry in sysfs.
  */
 static void ab8500_fg_sysfs_exit(struct ab8500_fg *di)
 {
     kobject_del(&di->fg_kobject);
 }
 
 /**
  * ab8500_fg_sysfs_init() - init of sysfs entry
  * @di:                pointer to the struct ab8500_chargalg
  *
  * This function adds an entry in sysfs.
  * Returns error code in case of failure else 0(on success)
  */
 static int ab8500_fg_sysfs_init(struct ab8500_fg *di)
 {
     int ret = 0;
 
     ret = kobject_init_and_add(&di->fg_kobject,
         &ab8500_fg_ktype,
         NULL, "battery");
     if (ret < 0) {
         kobject_put(&di->fg_kobject);
         dev_err(di->dev, "failed to create sysfs entry\n");
     }
 
     return ret;
 }
 
 static ssize_t ab8505_powercut_flagtime_read(struct device *dev,
                  struct device_attribute *attr,
                  char *buf)
 {
     int ret;
     u8 reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
         AB8505_RTC_PCUT_FLAG_TIME_REG, &reg_value);
 
     if (ret < 0) {
         dev_err(dev, "Failed to read AB8505_RTC_PCUT_FLAG_TIME_REG\n");
         goto fail;
     }
 
     return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
 
 fail:
     return ret;
 }
 
 static ssize_t ab8505_powercut_flagtime_write(struct device *dev,
                   struct device_attribute *attr,
                   const char *buf, size_t count)
 {
     int ret;
     int reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     if (kstrtoint(buf, 10, &reg_value))
         goto fail;
 
     if (reg_value > 0x7F) {
         dev_err(dev, "Incorrect parameter, echo 0 (1.98s) - 127 (15.625ms) for flagtime\n");
         goto fail;
     }
 
     ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
         AB8505_RTC_PCUT_FLAG_TIME_REG, (u8)reg_value);
 
     if (ret < 0)
         dev_err(dev, "Failed to set AB8505_RTC_PCUT_FLAG_TIME_REG\n");
 
 fail:
     return count;
 }
 
 static ssize_t ab8505_powercut_maxtime_read(struct device *dev,
                  struct device_attribute *attr,
                  char *buf)
 {
     int ret;
     u8 reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
         AB8505_RTC_PCUT_MAX_TIME_REG, &reg_value);
 
     if (ret < 0) {
         dev_err(dev, "Failed to read AB8505_RTC_PCUT_MAX_TIME_REG\n");
         goto fail;
     }
 
     return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
 
 fail:
     return ret;
 
 }
 
 static ssize_t ab8505_powercut_maxtime_write(struct device *dev,
                   struct device_attribute *attr,
                   const char *buf, size_t count)
 {
     int ret;
     int reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     if (kstrtoint(buf, 10, &reg_value))
         goto fail;
 
     if (reg_value > 0x7F) {
         dev_err(dev, "Incorrect parameter, echo 0 (0.0s) - 127 (1.98s) for maxtime\n");
         goto fail;
     }
 
     ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
         AB8505_RTC_PCUT_MAX_TIME_REG, (u8)reg_value);
 
     if (ret < 0)
         dev_err(dev, "Failed to set AB8505_RTC_PCUT_MAX_TIME_REG\n");
 
 fail:
     return count;
 }
 
 static ssize_t ab8505_powercut_restart_read(struct device *dev,
                  struct device_attribute *attr,
                  char *buf)
 {
     int ret;
     u8 reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
         AB8505_RTC_PCUT_RESTART_REG, &reg_value);
 
     if (ret < 0) {
         dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n");
         goto fail;
     }
 
     return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF));
 
 fail:
     return ret;
 }
 
 static ssize_t ab8505_powercut_restart_write(struct device *dev,
                          struct device_attribute *attr,
                          const char *buf, size_t count)
 {
     int ret;
     int reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     if (kstrtoint(buf, 10, &reg_value))
         goto fail;
 
     if (reg_value > 0xF) {
         dev_err(dev, "Incorrect parameter, echo 0 - 15 for number of restart\n");
         goto fail;
     }
 
     ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
                         AB8505_RTC_PCUT_RESTART_REG, (u8)reg_value);
 
     if (ret < 0)
         dev_err(dev, "Failed to set AB8505_RTC_PCUT_RESTART_REG\n");
 
 fail:
     return count;
 
 }
 
 static ssize_t ab8505_powercut_timer_read(struct device *dev,
                       struct device_attribute *attr,
                       char *buf)
 {
     int ret;
     u8 reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
                         AB8505_RTC_PCUT_TIME_REG, &reg_value);
 
     if (ret < 0) {
         dev_err(dev, "Failed to read AB8505_RTC_PCUT_TIME_REG\n");
         goto fail;
     }
 
     return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
 
 fail:
     return ret;
 }
 
 static ssize_t ab8505_powercut_restart_counter_read(struct device *dev,
                             struct device_attribute *attr,
                             char *buf)
 {
     int ret;
     u8 reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
                         AB8505_RTC_PCUT_RESTART_REG, &reg_value);
 
     if (ret < 0) {
         dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n");
         goto fail;
     }
 
     return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF0) >> 4);
 
 fail:
     return ret;
 }
 
 static ssize_t ab8505_powercut_read(struct device *dev,
                     struct device_attribute *attr,
                     char *buf)
 {
     int ret;
     u8 reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
                         AB8505_RTC_PCUT_CTL_STATUS_REG, &reg_value);
 
     if (ret < 0)
         goto fail;
 
     return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x1));
 
 fail:
     return ret;
 }
 
 static ssize_t ab8505_powercut_write(struct device *dev,
                      struct device_attribute *attr,
                      const char *buf, size_t count)
 {
     int ret;
     int reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     if (kstrtoint(buf, 10, &reg_value))
         goto fail;
 
     if (reg_value > 0x1) {
         dev_err(dev, "Incorrect parameter, echo 0/1 to disable/enable Pcut feature\n");
         goto fail;
     }
 
     ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
                         AB8505_RTC_PCUT_CTL_STATUS_REG, (u8)reg_value);
 
     if (ret < 0)
         dev_err(dev, "Failed to set AB8505_RTC_PCUT_CTL_STATUS_REG\n");
 
 fail:
     return count;
 }
 
 static ssize_t ab8505_powercut_flag_read(struct device *dev,
                      struct device_attribute *attr,
                      char *buf)
 {
 
     int ret;
     u8 reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
                         AB8505_RTC_PCUT_CTL_STATUS_REG,  &reg_value);
 
     if (ret < 0) {
         dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n");
         goto fail;
     }
 
     return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x10) >> 4));
 
 fail:
     return ret;
 }
 
 static ssize_t ab8505_powercut_debounce_read(struct device *dev,
                          struct device_attribute *attr,
                          char *buf)
 {
     int ret;
     u8 reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
                         AB8505_RTC_PCUT_DEBOUNCE_REG,  &reg_value);
 
     if (ret < 0) {
         dev_err(dev, "Failed to read AB8505_RTC_PCUT_DEBOUNCE_REG\n");
         goto fail;
     }
 
     return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7));
 
 fail:
     return ret;
 }
 
 static ssize_t ab8505_powercut_debounce_write(struct device *dev,
                           struct device_attribute *attr,
                           const char *buf, size_t count)
 {
     int ret;
     int reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     if (kstrtoint(buf, 10, &reg_value))
         goto fail;
 
     if (reg_value > 0x7) {
         dev_err(dev, "Incorrect parameter, echo 0 to 7 for debounce setting\n");
         goto fail;
     }
 
     ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
                         AB8505_RTC_PCUT_DEBOUNCE_REG, (u8)reg_value);
 
     if (ret < 0)
         dev_err(dev, "Failed to set AB8505_RTC_PCUT_DEBOUNCE_REG\n");
 
 fail:
     return count;
 }
 
 static ssize_t ab8505_powercut_enable_status_read(struct device *dev,
                           struct device_attribute *attr,
                           char *buf)
 {
     int ret;
     u8 reg_value;
     struct power_supply *psy = dev_get_drvdata(dev);
     struct ab8500_fg *di = power_supply_get_drvdata(psy);
 
     ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
                         AB8505_RTC_PCUT_CTL_STATUS_REG, &reg_value);
 
     if (ret < 0) {
         dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n");
         goto fail;
     }
 
     return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x20) >> 5));
 
 fail:
     return ret;
 }
 
 static struct device_attribute ab8505_fg_sysfs_psy_attrs[] = {
     __ATTR(powercut_flagtime, (S_IRUGO | S_IWUSR | S_IWGRP),
         ab8505_powercut_flagtime_read, ab8505_powercut_flagtime_write),
     __ATTR(powercut_maxtime, (S_IRUGO | S_IWUSR | S_IWGRP),
         ab8505_powercut_maxtime_read, ab8505_powercut_maxtime_write),
     __ATTR(powercut_restart_max, (S_IRUGO | S_IWUSR | S_IWGRP),
         ab8505_powercut_restart_read, ab8505_powercut_restart_write),
     __ATTR(powercut_timer, S_IRUGO, ab8505_powercut_timer_read, NULL),
     __ATTR(powercut_restart_counter, S_IRUGO,
         ab8505_powercut_restart_counter_read, NULL),
     __ATTR(powercut_enable, (S_IRUGO | S_IWUSR | S_IWGRP),
         ab8505_powercut_read, ab8505_powercut_write),
     __ATTR(powercut_flag, S_IRUGO, ab8505_powercut_flag_read, NULL),
     __ATTR(powercut_debounce_time, (S_IRUGO | S_IWUSR | S_IWGRP),
         ab8505_powercut_debounce_read, ab8505_powercut_debounce_write),
     __ATTR(powercut_enable_status, S_IRUGO,
         ab8505_powercut_enable_status_read, NULL),
 };
 
 static int ab8500_fg_sysfs_psy_create_attrs(struct ab8500_fg *di)
 {
     unsigned int i;
 
     if (is_ab8505(di->parent)) {
         for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++)
             if (device_create_file(&di->fg_psy->dev,
                            &ab8505_fg_sysfs_psy_attrs[i]))
                 goto sysfs_psy_create_attrs_failed_ab8505;
     }
     return 0;
 sysfs_psy_create_attrs_failed_ab8505:
     dev_err(&di->fg_psy->dev, "Failed creating sysfs psy attrs for ab8505.\n");
     while (i--)
         device_remove_file(&di->fg_psy->dev,
                    &ab8505_fg_sysfs_psy_attrs[i]);
 
     return -EIO;
 }
 
 static void ab8500_fg_sysfs_psy_remove_attrs(struct ab8500_fg *di)
 {
     unsigned int i;
 
     if (is_ab8505(di->parent)) {
         for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++)
             (void)device_remove_file(&di->fg_psy->dev,
                          &ab8505_fg_sysfs_psy_attrs[i]);
     }
 }
 
 /* Exposure to the sysfs interface <<END>> */
 
 static int __maybe_unused ab8500_fg_resume(struct device *dev)
 {
     struct ab8500_fg *di = dev_get_drvdata(dev);
 
     /*
      * Change state if we're not charging. If we're charging we will wake
      * up on the FG IRQ
      */
     if (!di->flags.charging) {
         ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_WAKEUP);
         queue_work(di->fg_wq, &di->fg_work);
     }
 
     return 0;
 }
 
 static int __maybe_unused ab8500_fg_suspend(struct device *dev)
 {
     struct ab8500_fg *di = dev_get_drvdata(dev);
 
     flush_delayed_work(&di->fg_periodic_work);
     flush_work(&di->fg_work);
     flush_work(&di->fg_acc_cur_work);
     flush_delayed_work(&di->fg_reinit_work);
     flush_delayed_work(&di->fg_low_bat_work);
     flush_delayed_work(&di->fg_check_hw_failure_work);
 
     /*
      * If the FG is enabled we will disable it before going to suspend
      * only if we're not charging
      */
     if (di->flags.fg_enabled && !di->flags.charging)
         ab8500_fg_coulomb_counter(di, false);
 
     return 0;
 }
 
 /* ab8500 fg driver interrupts and their respective isr */
 static struct ab8500_fg_interrupts ab8500_fg_irq[] = {
     {"NCONV_ACCU", ab8500_fg_cc_convend_handler},
     {"BATT_OVV", ab8500_fg_batt_ovv_handler},
     {"LOW_BAT_F", ab8500_fg_lowbatf_handler},
     {"CC_INT_CALIB", ab8500_fg_cc_int_calib_handler},
     {"CCEOC", ab8500_fg_cc_data_end_handler},
 };
 
 static char *supply_interface[] = {
     "ab8500_chargalg",
     "ab8500_usb",
 };
 
 static const struct power_supply_desc ab8500_fg_desc = {
     .name           = "ab8500_fg",
     .type           = POWER_SUPPLY_TYPE_BATTERY,
     .properties     = ab8500_fg_props,
     .num_properties     = ARRAY_SIZE(ab8500_fg_props),
     .get_property       = ab8500_fg_get_property,
     .external_power_changed = ab8500_fg_external_power_changed,
 };
 
 static int ab8500_fg_bind(struct device *dev, struct device *master,
               void *data)
 {
     struct ab8500_fg *di = dev_get_drvdata(dev);
 
     di->bat_cap.max_mah_design = di->bm->bi->charge_full_design_uah;
     di->bat_cap.max_mah = di->bat_cap.max_mah_design;
     di->vbat_nom_uv = di->bm->bi->voltage_max_design_uv;
 
     /* Start the coulomb counter */
     ab8500_fg_coulomb_counter(di, true);
     /* Run the FG algorithm */
     queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
 
     return 0;
 }
 
 static void ab8500_fg_unbind(struct device *dev, struct device *master,
                  void *data)
 {
     struct ab8500_fg *di = dev_get_drvdata(dev);
     int ret;
 
     /* Disable coulomb counter */
     ret = ab8500_fg_coulomb_counter(di, false);
     if (ret)
         dev_err(dev, "failed to disable coulomb counter\n");
 
     flush_workqueue(di->fg_wq);
 }
 
 static const struct component_ops ab8500_fg_component_ops = {
     .bind = ab8500_fg_bind,
     .unbind = ab8500_fg_unbind,
 };
 
 static int ab8500_fg_probe(struct platform_device *pdev)
 {
     struct device *dev = &pdev->dev;
     struct power_supply_config psy_cfg = {};
     struct ab8500_fg *di;
     int i, irq;
     int ret = 0;
 
     di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
     if (!di)
         return -ENOMEM;
 
     di->bm = &ab8500_bm_data;
 
     mutex_init(&di->cc_lock);
 
     /* get parent data */
     di->dev = dev;
     di->parent = dev_get_drvdata(pdev->dev.parent);
 
     di->main_bat_v = devm_iio_channel_get(dev, "main_bat_v");
     if (IS_ERR(di->main_bat_v)) {
         ret = dev_err_probe(dev, PTR_ERR(di->main_bat_v),
                     "failed to get main battery ADC channel\n");
         return ret;
     }
 
     if (!of_property_read_u32(dev->of_node, "line-impedance-micro-ohms",
                   &di->line_impedance_uohm))
         dev_info(dev, "line impedance: %u uOhm\n",
              di->line_impedance_uohm);
 
     psy_cfg.supplied_to = supply_interface;
     psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
     psy_cfg.drv_data = di;
 
     di->init_capacity = true;
 
     ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
     ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
 
     /* Create a work queue for running the FG algorithm */
     di->fg_wq = alloc_ordered_workqueue("ab8500_fg_wq", WQ_MEM_RECLAIM);
     if (di->fg_wq == NULL) {
         dev_err(dev, "failed to create work queue\n");
         return -ENOMEM;
     }
 
     /* Init work for running the fg algorithm instantly */
     INIT_WORK(&di->fg_work, ab8500_fg_instant_work);
 
     /* Init work for getting the battery accumulated current */
     INIT_WORK(&di->fg_acc_cur_work, ab8500_fg_acc_cur_work);
 
     /* Init work for reinitialising the fg algorithm */
     INIT_DEFERRABLE_WORK(&di->fg_reinit_work,
         ab8500_fg_reinit_work);
 
     /* Work delayed Queue to run the state machine */
     INIT_DEFERRABLE_WORK(&di->fg_periodic_work,
         ab8500_fg_periodic_work);
 
     /* Work to check low battery condition */
     INIT_DEFERRABLE_WORK(&di->fg_low_bat_work,
         ab8500_fg_low_bat_work);
 
     /* Init work for HW failure check */
     INIT_DEFERRABLE_WORK(&di->fg_check_hw_failure_work,
         ab8500_fg_check_hw_failure_work);
 
     /* Reset battery low voltage flag */
     di->flags.low_bat = false;
 
     /* Initialize low battery counter */
     di->low_bat_cnt = 10;
 
     /* Initialize OVV, and other registers */
     ret = ab8500_fg_init_hw_registers(di);
     if (ret) {
         dev_err(dev, "failed to initialize registers\n");
         destroy_workqueue(di->fg_wq);
         return ret;
     }
 
     /* Consider battery unknown until we're informed otherwise */
     di->flags.batt_unknown = true;
     di->flags.batt_id_received = false;
 
     /* Register FG power supply class */
     di->fg_psy = devm_power_supply_register(dev, &ab8500_fg_desc, &psy_cfg);
     if (IS_ERR(di->fg_psy)) {
         dev_err(dev, "failed to register FG psy\n");
         destroy_workqueue(di->fg_wq);
         return PTR_ERR(di->fg_psy);
     }
 
     di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
 
     /*
      * Initialize completion used to notify completion and start
      * of inst current
      */
     init_completion(&di->ab8500_fg_started);
     init_completion(&di->ab8500_fg_complete);
 
     /* Register primary interrupt handlers */
     for (i = 0; i < ARRAY_SIZE(ab8500_fg_irq); i++) {
         irq = platform_get_irq_byname(pdev, ab8500_fg_irq[i].name);
         if (irq < 0) {
             destroy_workqueue(di->fg_wq);
             return irq;
         }
 
         ret = devm_request_threaded_irq(dev, irq, NULL,
                   ab8500_fg_irq[i].isr,
                   IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
                   ab8500_fg_irq[i].name, di);
 
         if (ret != 0) {
             dev_err(dev, "failed to request %s IRQ %d: %d\n",
                 ab8500_fg_irq[i].name, irq, ret);
             destroy_workqueue(di->fg_wq);
             return ret;
         }
         dev_dbg(dev, "Requested %s IRQ %d: %d\n",
             ab8500_fg_irq[i].name, irq, ret);
     }
 
     di->irq = platform_get_irq_byname(pdev, "CCEOC");
     disable_irq(di->irq);
     di->nbr_cceoc_irq_cnt = 0;
 
     platform_set_drvdata(pdev, di);
 
     ret = ab8500_fg_sysfs_init(di);
     if (ret) {
         dev_err(dev, "failed to create sysfs entry\n");
         destroy_workqueue(di->fg_wq);
         return ret;
     }
 
     ret = ab8500_fg_sysfs_psy_create_attrs(di);
     if (ret) {
         dev_err(dev, "failed to create FG psy\n");
         ab8500_fg_sysfs_exit(di);
         destroy_workqueue(di->fg_wq);
         return ret;
     }
 
     /* Calibrate the fg first time */
     di->flags.calibrate = true;
     di->calib_state = AB8500_FG_CALIB_INIT;
 
     /* Use room temp as default value until we get an update from driver. */
     di->bat_temp = 210;
 
     list_add_tail(&di->node, &ab8500_fg_list);
 
     return component_add(dev, &ab8500_fg_component_ops);
 }
 
 static int ab8500_fg_remove(struct platform_device *pdev)
 {
     struct ab8500_fg *di = platform_get_drvdata(pdev);
 
     destroy_workqueue(di->fg_wq);
     component_del(&pdev->dev, &ab8500_fg_component_ops);
     list_del(&di->node);
     ab8500_fg_sysfs_exit(di);
     ab8500_fg_sysfs_psy_remove_attrs(di);
 
     return 0;
 }
 
 static SIMPLE_DEV_PM_OPS(ab8500_fg_pm_ops, ab8500_fg_suspend, ab8500_fg_resume);
 
 static const struct of_device_id ab8500_fg_match[] = {
     { .compatible = "stericsson,ab8500-fg", },
     { },
 };
 MODULE_DEVICE_TABLE(of, ab8500_fg_match);
 
 struct platform_driver ab8500_fg_driver = {
     .probe = ab8500_fg_probe,
     .remove = ab8500_fg_remove,
     .driver = {
         .name = "ab8500-fg",
         .of_match_table = ab8500_fg_match,
         .pm = &ab8500_fg_pm_ops,
     },
 };
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Johan Palsson, Karl Komierowski");
 MODULE_ALIAS("platform:ab8500-fg");
 MODULE_DESCRIPTION("AB8500 Fuel Gauge driver");