drivers/power/supply/ab8500_fg.c

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