drivers/power/supply/ab8500_fg.c

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