/*
   *  max77823_fuelgauge.c
   *  Samsung MAX77823 Fuel Gauge Driver
   *
   *  Copyright (C) 2012 Samsung Electronics
   *
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License version 2 as
   * published by the Free Software Foundation.
   */
  
  #include <linux/mfd/max77823.h>
  #include <linux/mfd/max77823-private.h>
  #include <linux/of_gpio.h>
  #include <linux/debugfs.h>
  #include <linux/seq_file.h>
  #include <linux/battery/fuelgauge/max77823_fuelgauge.h>
  #include <linux/math64.h>
  
  #define MV_TO_UV(mv) (mv * 1000)
  
  extern void board_fuelgauge_init(void *data);
  
  static enum power_supply_property max77823_fuelgauge_props[] = {
  	POWER_SUPPLY_PROP_STATUS,
  	POWER_SUPPLY_PROP_ONLINE,
  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
  	POWER_SUPPLY_PROP_VOLTAGE_AVG,
  	POWER_SUPPLY_PROP_CURRENT_NOW,
  	POWER_SUPPLY_PROP_CURRENT_AVG,
  	POWER_SUPPLY_PROP_CHARGE_FULL,
  	POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
  	POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN,
  	POWER_SUPPLY_PROP_ENERGY_FULL,
  	POWER_SUPPLY_PROP_ENERGY_EMPTY,
  	POWER_SUPPLY_PROP_ENERGY_NOW,
  	POWER_SUPPLY_PROP_ENERGY_AVG,
  	POWER_SUPPLY_PROP_CAPACITY,
  	POWER_SUPPLY_PROP_TEMP,
  	POWER_SUPPLY_PROP_TEMP_AMBIENT,
  };
  
  static const char* const psy_names[] = {
  [PS_BATT] = "battery",
  };
  
  static int psy_get_prop(struct max77823_fuelgauge_data *fuelgauge, enum ps_id id, enum power_supply_property property, union power_supply_propval *value)
  {
  	struct power_supply *psy = fuelgauge->psy_ref[id];
  	int ret = -EINVAL;
  
  	value->intval = 0;
  	if (!psy) {
  		unsigned long timeout = jiffies + msecs_to_jiffies(500);
  		do {
  			psy = power_supply_get_by_name(psy_names[id]);
  			if (psy) {
  				fuelgauge->psy_ref[id] = psy;
  				break;
  			}
  			if (time_after(jiffies, timeout)) {
  				pr_err("%s: fuel Failed %s(%d)
  ",  __func__, psy_names[id], property);
  				return -ENODEV;
  			}
  			msleep(1);
  		} while (1);
  	}
  	if (psy->get_property) {
  		ret = psy->get_property(psy, property, value);
  		if (ret < 0)
  			pr_err("%s: fuel Fail to get %s(%d=>%d)
  ", __func__, psy_names[id], property, ret);
  	}
  	return ret;
  }
  
  static int psy_set_prop(struct max77823_fuelgauge_data *fuelgauge, enum ps_id id, enum power_supply_property property, union power_supply_propval *value)
  {
  	struct power_supply *psy = fuelgauge->psy_ref[id];
  	int ret = -EINVAL;
  
  	if (!psy) {
  		unsigned long timeout = jiffies + msecs_to_jiffies(500);
  		do {
  			psy = power_supply_get_by_name(psy_names[id]);
  			if (psy) {
  				fuelgauge->psy_ref[id] = psy;
  				break;
  			}
  			if (time_after(jiffies, timeout)) {
  				pr_err("%s: fuel Failed %s
  ",  __func__, psy_names[id]);
  				return -ENODEV;
  			}
  			msleep(1);
  		} while (1);
  	}
  	if (psy->set_property) {
  		ret = psy->set_property(psy, property, value);
  		if (ret < 0)
  			pr_err("%s: fuel Fail to set %s(%d=>%d)
  ", __func__, psy_names[id], property, ret);
  	}
  	return ret;
  }
  
  static int max77823_get_v(struct max77823_fuelgauge_data *fuelgauge, int reg)
  {
  	u32 v = 0;
  	int ret;
  
  	ret = max77823_read_word(fuelgauge->i2c, reg);
  	if (ret < 0)
  		return ret;
  
  	pr_debug("%s: reg 0x%x=(%d)
  ", __func__, reg, ret);
  	v = (ret >> 3) * 625;
  	return v;
  }
  
  static int max77823_get_vfocv(struct max77823_fuelgauge_data *fuelgauge)
  {
  	return max77823_get_v(fuelgauge, MAX77823_REG_VFOCV);
  }
  
  static int max77823_get_vcell(struct max77823_fuelgauge_data *fuelgauge)
  {
  	return max77823_get_v(fuelgauge, MAX77823_REG_VCELL);
  }
  
  static int max77823_get_avgvcell(struct max77823_fuelgauge_data *fuelgauge)
  {
  	return max77823_get_v(fuelgauge, MAX77823_REG_AVGVCELL);
  }
  
  static int max77823_get_status(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int ret;
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_STATUS);
  	if (ret < 0)
  		return ret;
  
  	pr_debug("%s: reg 0x%x=(0x%x)
  ", __func__, MAX77823_REG_STATUS, ret);
  	if (ret & (1 << 3)) {
  		/* battery is absent */
  		return POWER_SUPPLY_STATUS_NOT_CHARGING;
  	}
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_STATUS2);
  	if (ret < 0)
  		return ret;
  	pr_debug("%s: reg 0x%x=(0x%x)
  ", __func__, MAX77823_REG_STATUS2, ret);
  	if (ret & (1 << 5)) {
  		return POWER_SUPPLY_STATUS_FULL;
  	}
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_MAXMIN);
  	if (ret < 0)
  		return ret;
  	pr_debug("%s: reg 0x%x=(0x%x)
  ", __func__, MAX77823_REG_MAXMIN, ret);
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_MAXMIN, 0x807f);
  	if (ret == 0x807f)
  		ret = fuelgauge->prev_status;
  	else
  		fuelgauge->prev_status = ret;
  	ret <<= 16;	/* sign extend */
  	ret >>= 16;
  	if (ret > 0)
  		return POWER_SUPPLY_STATUS_CHARGING;
  	ret <<= 24;	/* sign extend */
  	ret >>= 24;
  	if (ret < 0)
  		return POWER_SUPPLY_STATUS_DISCHARGING;
  	return POWER_SUPPLY_STATUS_NOT_CHARGING;
  }
  
  #ifdef CONFIG_FUELGAUGE_MAX77823_VOLTAGE_TRACKING
  static void max77823_init_regs(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int ret;
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_FILTERCFG);
  	if (ret < 0)
  		return;
  
  	/* Clear average vcell (12 sec) */
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_FILTERCFG, ret & 0xff8f);
  }
  
  static void max77823_get_version(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int ret;
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_VERSION);
  	if (ret < 0)
  		return;
  	pr_debug("MAX77823 Fuel-Gauge Ver 0x%x
  ", ret);
  }
  
  static void max77823_alert_init(struct max77823_fuelgauge_data *fuelgauge)
  {
  	/* SALRT Threshold setting */
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_SALRT_TH,
  			0xff00 | fuelgauge->pdata->fuel_alert_soc);
  
  	/* VALRT Threshold setting */
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_VALRT_TH, 0xff00);
  
  	/* TALRT Threshold setting */
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_TALRT_TH, 0x7f80);
  }
  
  static bool max77823_check_status(struct max77823_fuelgauge_data *fuelgauge)
  {
  	bool ret = false;
  
  	/* check if Smn was generated */
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_STATUS);
  	if (ret < 0)
  		return ret;
  
  	pr_info("%s: status_reg(%x)
  ", __func__, ret);
  
  	/* minimum SOC threshold exceeded. */
  	if (ret & (0x1 << 10))
  		ret = true;
  
  	/* clear status reg */
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_STATUS, ret & 0xff);
  	msleep(200);
  	return ret;
  }
  
  static int max77823_set_temperature(struct max77823_fuelgauge_data *fuelgauge,
  				    int temperature)
  {
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_TEMPERATURE, temperature << 8);
  	pr_debug("%s: temperature to (%d)
  ", __func__, temperature);
  	return temperature;
  }
  /* return units of 1/10 C */
  static int max77823_get_temperature(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int ret;
  
  	if (fuelgauge->pdata->temp_disabled)
  		return 200;
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_TEMPERATURE);
  	if (ret < 0)
  		return -ERANGE;
  
  	/* data[] store 2's compliment format number */
  	ret <<= 16;
  	ret >>= 16;	/* extent sign bit */
  	ret = (ret * 10) >> 8;
  	pr_debug("%s: temperature (%d)
  ", __func__, ret);
  	return ret;
  }
  
  /* soc should be 0.01% unit */
  static int max77823_get_soc(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int soc;
  	int ret;
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_SOC_VF);
  	if (ret < 0)
  		return ret;
  
  	soc = (ret * 100) >> 8;
  	pr_debug("%s: raw capacity (%d)
  ", __func__, soc);
  	return min(soc, 10000);
  }
  
  bool max77823_fg_init(struct max77823_fuelgauge_data *fuelgauge)
  {
  	/* initialize fuel gauge registers */
  	max77823_init_regs(fuelgauge);
  
  	max77823_get_version(fuelgauge);
  
  	return true;
  }
  
  bool max77823_fg_fuelalert_init(struct max77823_fuelgauge_data *fuelgauge,
  				int soc)
  {
  	int ret;
  
  	/* 1. Set max77823 alert configuration. */
  	max77823_alert_init(fuelgauge);
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_CONFIG);
  	if (ret < 0)
  		return ret;
  
  	/*Enable Alert (Aen = 1) */
  	ret |= (1 << 2);
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_CONFIG, ret);
  
  	pr_debug("%s: config_reg(%x) irq(%d)
  ", __func__, ret,
  			fuelgauge->pdata->fg_irq);
  	return true;
  }
  
  bool max77823_fg_is_fuelalerted(struct max77823_fuelgauge_data *fuelgauge)
  {
  	return max77823_check_status(fuelgauge);
  }
  
  bool max77823_fg_fuelalert_process(void *irq_data, bool is_fuel_alerted)
  {
  	struct max77823_fuelgauge_data *fuelgauge = irq_data;
  	int ret;
  
  	/* update SOC */
  	/* max77823_get_soc(fuelgauge); */
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_CONFIG);
  	if (ret < 0)
  		return false;
  	if (is_fuel_alerted) {
  		ret |= (1 << 11);
  		pr_info("%s: Fuel-alert Alerted!! (%x)
  ", __func__, ret);
  	} else {
  		ret &= ~(1 << 11);
  		pr_info("%s: Fuel-alert Released!! (%x)
  ", __func__, ret);
  	}
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_CONFIG, ret);
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_VCELL);
  	pr_debug("%s: MAX77823_REG_VCELL(%x)
  ", __func__, ret);
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_TEMPERATURE);
  	pr_debug("%s: MAX77823_REG_TEMPERATURE(%x)
  ", __func__, ret);
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_CONFIG);
  	pr_debug("%s: MAX77823_REG_CONFIG(%x)
  ", __func__, ret);
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_VFOCV);
  	pr_debug("%s: MAX77823_REG_VFOCV(%x)
  ", __func__, ret);
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_SOC_VF);
  	pr_debug("%s: MAX77823_REG_SOC_VF(%x)
  ", __func__, ret);
  
  	pr_debug("%s: FUEL GAUGE IRQ (%d)
  ",
  		 __func__, gpio_get_value(fuelgauge->pdata->fg_irq));
  
  	return true;
  }
  
  bool max77823_fg_full_charged(struct max77823_fuelgauge_data *fuelgauge)
  {
  	return true;
  }
  #endif
  
  static void fg_test_print(struct max77823_fuelgauge_data *fuelgauge)
  {
  #ifdef DEBUG
  	u32 average_vcell;
  	u32 temp;
  	u32 temp2;
  	u16 reg_data;
  	int ret;
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_AVGVCELL);
  	if (ret < 0) {
  		pr_err("%s: Failed to read VCELL
  ", __func__);
  		return;
  	}
  
  	temp = (ret & 0xFFF) * 78125;
  	average_vcell = temp / 1000000;
  
  	temp = ((ret & 0xF000) >> 4) * 78125;
  	temp2 = temp / 1000000;
  	average_vcell += (temp2 << 4);
  
  	pr_info("%s: AVG_VCELL(%d), data(0x%04x)
  ", __func__,
  		average_vcell, ret);
  
  	reg_data = max77823_read_word(fuelgauge->i2c, FULLCAPREP_REG);
  	pr_info("%s: FULLCAP(%d), data(0x%04x)
  ", __func__,
  		reg_data/2, reg_data);
  
  	reg_data = max77823_read_word(fuelgauge->i2c, REMCAP_REP_REG);
  	pr_info("%s: REMCAP_REP(%d), data(0x%04x)
  ", __func__,
  		reg_data/2, reg_data);
  
  	reg_data = max77823_read_word(fuelgauge->i2c, REMCAP_MIX_REG);
  	pr_info("%s: REMCAP_MIX(%d), data(0x%04x)
  ", __func__,
  		reg_data/2, reg_data);
  
  	reg_data = max77823_read_word(fuelgauge->i2c, REMCAP_AV_REG);
  	pr_info("%s: REMCAP_AV(%d), data(0x%04x)
  ", __func__,
  		reg_data/2, reg_data);
  
  	reg_data = max77823_read_word(fuelgauge->i2c, MAX77823_REG_CONFIG);
  	pr_info("%s: CONFIG(0x%02x), data(0x%04x)
  ", __func__,
  		MAX77823_REG_CONFIG, reg_data);
  #endif
  }
  
  static void fg_periodic_read(struct max77823_fuelgauge_data *fuelgauge)
  {
  #ifdef DEBUG
  	u8 reg;
  	int i;
  	int data[0x10];
  	char *str = NULL;
  
  	str = kzalloc(sizeof(char)*1024, GFP_KERNEL);
  	if (!str)
  		return;
  
  	for (i = 0; i < 16; i++) {
  		for (reg = 0; reg < 0x10; reg++)
  			data[reg] = max77823_read_word(fuelgauge->i2c, reg + i * 0x10);
  
  		sprintf(str+strlen(str),
  			"%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,",
  			data[0x00], data[0x01], data[0x02], data[0x03],
  			data[0x04], data[0x05], data[0x06], data[0x07]);
  		sprintf(str+strlen(str),
  			"%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,",
  			data[0x08], data[0x09], data[0x0a], data[0x0b],
  			data[0x0c], data[0x0d], data[0x0e], data[0x0f]);
  		if (i == 4)
  			i = 13;
  	}
  
  	pr_info("%s", str);
  
  	kfree(str);
  #endif
  }
  
  #ifdef CONFIG_FUELGAUGE_MAX77823_COULOMB_COUNTING
  static int fg_check_battery_present(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int ret;
  
  	/* 1. Check Bst bit */
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_STATUS);
  	if (ret < 0) {
  		pr_err("%s: Failed to read STATUS
  ", __func__);
  		return 0;
  	}
  
  	if (ret & (0x1 << 3)) {
  		pr_info("%s: status(0x%x)
  ", __func__, ret);
  		pr_info("%s: battery is absent!!
  ", __func__);
  		return 0;
  	}
  	return 1;
  }
  
  static int fg_write_temp(struct max77823_fuelgauge_data *fuelgauge,
  			 int temperature)
  {
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_TEMPERATURE, (temperature * 256) / 10);
  	pr_debug("%s: temperature to %d
  ", __func__, temperature);
  	return temperature;
  }
  
  static int fg_read_temp(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int temper = 200;	/* 20.0 C */
  	int ret;
  
  	if (fuelgauge->pdata->temp_disabled)
  		return 200;
  	if (fg_check_battery_present(fuelgauge)) {
  		ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_TEMPERATURE);
  		if (ret < 0) {
  			pr_err("%s: Failed to read TEMPERATURE
  ", __func__);
  			return temper;
  		}
  
  		ret <<= 16;	/* sign extend value */
  		ret >>= 16;
  		temper = (ret * 10) >> 8;
  	}
  
  	if (!(fuelgauge->info.pr_cnt % PRINT_COUNT))
  		pr_info("%s: TEMPERATURE(%d)
  ",
  			__func__, temper);
  	return temper;
  }
  #endif
  
  /* soc should be 0.1% unit */
  static int fg_read_percent(struct max77823_fuelgauge_data *fuelgauge, int reg)
  {
  	int soc;
  	int ret;
  
  	ret = max77823_read_word(fuelgauge->i2c, reg);
  	if (ret < 0) {
  		pr_err("%s: Failed to read 0x%x
  ", __func__, reg);
  		return ret;
  	}
  	soc = (ret * 10) >> 8;
  	return min(soc, 1000);
  }
  
  static int fg_read_vfsoc(struct max77823_fuelgauge_data *fuelgauge)
  {
  	return fg_read_percent(fuelgauge, MAX77823_REG_SOC_VF);
  }
  
  #ifdef CONFIG_FUELGAUGE_MAX77823_COULOMB_COUNTING
  static int fg_read_power(struct max77823_fuelgauge_data *fuelgauge, int reg)
  {
  
  	int ret;
  
  	ret = max77823_read_word(fuelgauge->i2c, reg);
  	if (ret < 0)
  		pr_err("%s: Failed to read 0x%x(%d)
  ", __func__, reg, ret);
  	/*
  	 * convert from uVh to uWh, with a 10 mOhm sense resistor
  	 *  uVh/(.010 Ohms) =  uVh * 100/Ohms =  100uAh
  	 *  uAh * V = uWh
  	 */
  	return ret * 370 ;	/* 3.7 Volts nominal */
  }
  #endif
  
  static int fg_read_current(struct max77823_fuelgauge_data *fuelgauge)
  {
  	u32 temp;
  	s32 i_current;
  	s32 avg_current;
  	int ret;
  
  	ret = max77823_read_word(fuelgauge->i2c, CURRENT_REG);
  	if (ret < 0) {
  		pr_err("%s: Failed to read CURRENT
  ", __func__);
  		return ret;
  	}
  	temp = ret << 15;	/* extend sign bit */
  	temp >>= 15;
  
  	/* 1.5625uV / 0.01Ohm(Rsense) = 156.25uA */
  	i_current = temp * 15625;
  	i_current /= 100;
  
  	ret = max77823_read_word(fuelgauge->i2c, AVG_CURRENT_REG);
  	if (ret < 0) {
  		pr_err("%s: Failed to read AVERAGE CURRENT
  ", __func__);
  		return ret;
  	}
  
  	temp = ret << 15;	/* extend sign bit */
  	temp >>= 15;
  
  	/* 1.5625uV/0.01Ohm(Rsense) = 156.25uA */
  	avg_current = (temp * 15625) / 100000;
  
  	if (!(fuelgauge->info.pr_cnt++ % PRINT_COUNT)) {
  #ifdef DEBUG
  		fg_test_print(fuelgauge);
  		pr_debug("%s: CURRENT(%dmA), AVG_CURRENT(%dmA)
  ", __func__,
  				i_current, avg_current);
  		/* Read max77823's all registers every 5 minute. */
  		fg_periodic_read(fuelgauge);
  #endif
  		fuelgauge->info.pr_cnt = 1;
  	}
  
  	return i_current;
  }
  
  static int fg_read_avg_current(struct max77823_fuelgauge_data *fuelgauge)
  {
  	u32 temp;
  	s32 avg_current;
  	int ret;
  
  	ret = max77823_read_word(fuelgauge->i2c, AVG_CURRENT_REG);
  	if (ret < 0) {
  		pr_err("%s: Failed to read AVERAGE CURRENT
  ",
  		       __func__);
  		return 0;
  	}
  
  	temp = ret << 15;	/* extend sign bit */
  	temp >>= 15;
  	/* 1.5625uV/0.01Ohm(Rsense) = 156.25uA */
  	avg_current = temp * 15625;
  	avg_current /= 100;
  	return avg_current;
  }
  
  int fg_reset_soc(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int vfocv, fullcap;
  	int ret;
  
  	/* delay for current stablization */
  	msleep(500);
  
  	pr_info("%s: Before quick-start - VCELL(%d), VFOCV(%d), VfSOC(%d), RepSOC(%d)
  ",
  		__func__, max77823_get_vcell(fuelgauge), max77823_get_vfocv(fuelgauge),
  		fg_read_vfsoc(fuelgauge), fg_read_percent(fuelgauge, SOCREP_REG));
  	pr_info("%s: Before quick-start - current(%d), avg current(%d)
  ",
  		__func__, fg_read_current(fuelgauge),
  		fg_read_avg_current(fuelgauge));
  
  	if (fuelgauge->pdata->check_jig_status ||
  	    !fuelgauge->pdata->check_jig_status()) {
  		pr_info("%s : Return by No JIG_ON signal
  ", __func__);
  		return 0;
  	}
  
  	max77823_write_word(fuelgauge->i2c, CYCLES_REG, 0);
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_MISCCFG);
  	if (ret < 0) {
  		pr_err("%s: Failed to read MiscCFG
  ", __func__);
  		return ret;
  	}
  
  	ret |= (0x1 << 10);
  	ret = max77823_write_word(fuelgauge->i2c, MAX77823_REG_MISCCFG, ret);
  	if (ret < 0) {
  		pr_err("%s: Failed to write MiscCFG
  ", __func__);
  		return ret;
  	}
  
  	msleep(250);
  	max77823_write_word(fuelgauge->i2c, FULLCAPREP_REG,
  			    fuelgauge->battery_data->Capacity);
  	msleep(500);
  
  	pr_info("%s: After quick-start - VCELL(%d), VFOCV(%d), VfSOC(%d), RepSOC(%d)
  ",
  		__func__, max77823_get_vcell(fuelgauge), max77823_get_vfocv(fuelgauge),
  		fg_read_vfsoc(fuelgauge), fg_read_percent(fuelgauge, SOCREP_REG));
  	pr_info("%s: After quick-start - current(%d), avg current(%d)
  ",
  		__func__, fg_read_current(fuelgauge),
  		fg_read_avg_current(fuelgauge));
  
  	max77823_write_word(fuelgauge->i2c, CYCLES_REG, 0x00a0);
  
  /* P8 is not turned off by Quickstart @3.4V
   * (It's not a problem, depend on mode data)
   * Power off for factory test(File system, etc..) */
  	vfocv = max77823_get_vfocv(fuelgauge);
  	if (vfocv < POWER_OFF_VOLTAGE_LOW_MARGIN) {
  		pr_info("%s: Power off condition(%d)
  ", __func__, vfocv);
  
  		fullcap = max77823_read_word(fuelgauge->i2c, FULLCAPREP_REG);
  
  		/* FullCAP * 0.009 */
  		max77823_write_word(fuelgauge->i2c, REMCAP_REP_REG,
  				    (u16)(fullcap * 9 / 1000));
  		msleep(200);
  		pr_info("%s: new soc=%d, vfocv=%d
  ", __func__,
  			fg_read_percent(fuelgauge, SOCREP_REG), vfocv);
  	}
  
  	pr_info("%s: Additional step - VfOCV(%d), VfSOC(%d), RepSOC(%d)
  ",
  		__func__, max77823_get_vfocv(fuelgauge),
  		fg_read_vfsoc(fuelgauge), fg_read_percent(fuelgauge, SOCREP_REG));
  
  	return 0;
  }
  #ifdef CONFIG_FUELGAUGE_MAX77823_COULOMB_COUNTING
  
  int fg_reset_capacity_by_jig_connection(struct max77823_fuelgauge_data *fuelgauge)
  {
  
  	pr_info("%s: DesignCap = Capacity - 1 (Jig Connection)
  ", __func__);
  
  	return max77823_write_word(fuelgauge->i2c, DESIGNCAP_REG,
  				   fuelgauge->battery_data->Capacity-1);
  }
  
  int fg_adjust_capacity(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int ret;
  
  	/* 1. Write RemCapREP(05h)=0; */
  	ret = max77823_write_word(fuelgauge->i2c, REMCAP_REP_REG, 0);
  	if (ret < 0) {
  		pr_err("%s: Failed to write RemCap_REP
  ", __func__);
  		return ret;
  	}
  	msleep(200);
  
  	pr_info("%s: After adjust - RepSOC(%d)
  ", __func__,
  		fg_read_percent(fuelgauge, SOCREP_REG));
  
  	return 0;
  }
  
  void fg_low_batt_compensation(struct max77823_fuelgauge_data *fuelgauge,
  			      u32 level)
  {
  	int read_val;
  	u32 temp;
  
  	pr_info("%s: Adjust SOCrep to %d!!
  ", __func__, level);
  
  	read_val = max77823_read_word(fuelgauge->i2c, FULLCAPREP_REG);
  	/* RemCapREP (05h) = FullCap(10h) x 0.0090 */
  	temp = read_val * (level*90) / 10000;
  	max77823_write_word(fuelgauge->i2c, REMCAP_REP_REG,
  			    (u16)temp);
  }
  
  static int fg_check_status_reg(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int ret;
  	int status;
  
  	/* 1. Check Smn was generated read */
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_STATUS);
  	if (ret < 0) {
  		pr_err("%s: Failed to read STATUS
  ", __func__);
  		return ret;
  	}
  	status = ret;
  	pr_info("%s: addr(0x00), data(0x%x)
  ", __func__, status);
  
  	/* 2. clear Status reg */
  	ret = max77823_write_word(fuelgauge->i2c, MAX77823_REG_STATUS, status & 0xff);
  	if (ret < 0) {
  		pr_info("%s: Failed to write STATUS
  ", __func__);
  		return ret;
  	}
  	return (status >> 10) & 1;
  }
  
  int fg_alert_init(struct max77823_fuelgauge_data *fuelgauge, int soc)
  {
  	int ret;
  
  	/* Using RepSOC */
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_MISCCFG);
  	if (ret < 0) {
  		pr_err("%s: Failed to read MISCCFG
  ", __func__);
  		return ret;
  	}
  
  	ret = max77823_write_word(fuelgauge->i2c, MAX77823_REG_MISCCFG, ret & ~3);
  	if (ret < 0) {
  		pr_info("%s: Failed to write MISCCFG
  ", __func__);
  		return ret;
  	}
  
  	/* SALRT Threshold setting */
  	ret = max77823_write_word(fuelgauge->i2c, MAX77823_REG_SALRT_TH, 0xff00 | soc);
  	if (ret < 0) {
  		pr_info("%s: Failed to write SALRT
  ", __func__);
  		return -1;
  	}
  
  	/* Reset VALRT Threshold setting (disable) */
  	ret = max77823_write_word(fuelgauge->i2c, MAX77823_REG_VALRT_TH, 0xff00);
  	if (ret < 0) {
  		pr_info("%s: Failed to write VALRT
  ", __func__);
  		return ret;
  	}
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_VALRT_TH);
  	if (ret != 0xff00)
  		pr_err("%s: VALRT is not valid (0x%x)
  ", __func__, ret);
  
  	/* Reset TALRT Threshold setting (disable) */
  	ret = max77823_write_word(fuelgauge->i2c, MAX77823_REG_TALRT_TH, 0x7f80);
  	if (ret < 0) {
  		pr_info("%s: Failed to write TALRT
  ", __func__);
  		return ret;
  	}
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_TALRT_TH);
  	if (ret != 0x7f80)
  		pr_err("%s: TALRT is not valid (0x%x)
  ", __func__, ret);
  
  	/*mdelay(100);*/
  
  	/* Enable SOC alerts */
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_CONFIG);
  	if (ret < 0) {
  		pr_err("%s: Failed to read CONFIG
  ", __func__);
  		return ret;
  	}
  
  	ret = max77823_write_word(fuelgauge->i2c, MAX77823_REG_CONFIG, ret | (1 << 2));
  	if (ret < 0) {
  		pr_info("%s: Failed to write CONFIG
  ", __func__);
  		return ret;
  	}
  	return 1;
  }
  
  void fg_fullcharged_compensation(struct max77823_fuelgauge_data *fuelgauge,
  		u32 is_recharging, bool pre_update)
  {
  	static int new_fullcap_data;
  
  	pr_info("%s: is_recharging(%d), pre_update(%d)
  ",
  		__func__, is_recharging, pre_update);
  
  	new_fullcap_data =
  		max77823_read_word(fuelgauge->i2c, FULLCAPREP_REG);
  	if (new_fullcap_data < 0)
  		new_fullcap_data = fuelgauge->battery_data->Capacity;
  
  	/* compare with initial capacity */
  	if (new_fullcap_data >
  		(fuelgauge->battery_data->Capacity * 110 / 100)) {
  		pr_info("%s: [Case 1] capacity = 0x%04x, NewFullCap = 0x%04x
  ",
  			__func__, fuelgauge->battery_data->Capacity,
  			new_fullcap_data);
  
  		new_fullcap_data =
  			(fuelgauge->battery_data->Capacity * 110) / 100;
  
  		max77823_write_word(fuelgauge->i2c, REMCAP_REP_REG,
  				    (u16)(new_fullcap_data));
  		max77823_write_word(fuelgauge->i2c, FULLCAPREP_REG,
  				    (u16)(new_fullcap_data));
  	} else if (new_fullcap_data <
  		(fuelgauge->battery_data->Capacity * 50 / 100)) {
  		pr_info("%s: [Case 5] capacity = 0x%04x, NewFullCap = 0x%04x
  ",
  			__func__, fuelgauge->battery_data->Capacity,
  			new_fullcap_data);
  
  		new_fullcap_data =
  			(fuelgauge->battery_data->Capacity * 50) / 100;
  
  		max77823_write_word(fuelgauge->i2c, REMCAP_REP_REG,
  				    (u16)(new_fullcap_data));
  		max77823_write_word(fuelgauge->i2c, FULLCAPREP_REG,
  				    (u16)(new_fullcap_data));
  	} else {
  	/* compare with previous capacity */
  		if (new_fullcap_data >
  			(fuelgauge->info.previous_fullcap * 110 / 100)) {
  			pr_info("%s: [Case 2] previous_fullcap = 0x%04x, NewFullCap = 0x%04x
  ",
  				__func__, fuelgauge->info.previous_fullcap,
  				new_fullcap_data);
  
  			new_fullcap_data =
  				(fuelgauge->info.previous_fullcap * 110) / 100;
  
  			max77823_write_word(fuelgauge->i2c, REMCAP_REP_REG,
  					    (u16)(new_fullcap_data));
  			max77823_write_word(fuelgauge->i2c, FULLCAPREP_REG,
  					    (u16)(new_fullcap_data));
  		} else if (new_fullcap_data <
  			(fuelgauge->info.previous_fullcap * 90 / 100)) {
  			pr_info("%s: [Case 3] previous_fullcap = 0x%04x, NewFullCap = 0x%04x
  ",
  				__func__, fuelgauge->info.previous_fullcap,
  				new_fullcap_data);
  
  			new_fullcap_data =
  				(fuelgauge->info.previous_fullcap * 90) / 100;
  
  			max77823_write_word(fuelgauge->i2c, REMCAP_REP_REG,
  					    (u16)(new_fullcap_data));
  			max77823_write_word(fuelgauge->i2c, FULLCAPREP_REG,
  					    (u16)(new_fullcap_data));
  		} else {
  			pr_info("%s: [Case 4] previous_fullcap = 0x%04x, NewFullCap = 0x%04x
  ",
  				__func__, fuelgauge->info.previous_fullcap,
  				new_fullcap_data);
  		}
  	}
  
  	/* 4. Write RepSOC(06h)=100%; */
  	max77823_write_word(fuelgauge->i2c, SOCREP_REG, (u16)(0x64 << 8));
  
  	/* 5. Write MixSOC(0Dh)=100%; */
  	max77823_write_word(fuelgauge->i2c, SOCMIX_REG, (u16)(0x64 << 8));
  
  	/* 6. Write AVSOC(0Eh)=100%; */
  	max77823_write_word(fuelgauge->i2c, SOCAV_REG, (u16)(0x64 << 8));
  
  	/* if pre_update case, skip updating PrevFullCAP value. */
  	if (!pre_update)
  		fuelgauge->info.previous_fullcap =
  			max77823_read_word(fuelgauge->i2c, FULLCAPREP_REG);
  
  	pr_debug("%s: (A) FullCap = 0x%04x, RemCap = 0x%04x
  ", __func__,
  		max77823_read_word(fuelgauge->i2c, FULLCAPREP_REG),
  		max77823_read_word(fuelgauge->i2c, REMCAP_REP_REG));
  
  	fg_periodic_read(fuelgauge);
  }
  
  void fg_check_vf_fullcap_range(struct max77823_fuelgauge_data *fuelgauge)
  {
  	static int new_vffullcap;
  	bool is_vffullcap_changed = true;
  
  	if (fuelgauge->pdata->check_jig_status &&
  	    fuelgauge->pdata->check_jig_status())
  		fg_reset_capacity_by_jig_connection(fuelgauge);
  
  	new_vffullcap = max77823_read_word(fuelgauge->i2c, FULLCAP_NOM_REG);
  	if (new_vffullcap < 0)
  		new_vffullcap = fuelgauge->battery_data->Capacity;
  
  	/* compare with initial capacity */
  	if (new_vffullcap >
  		(fuelgauge->battery_data->Capacity * 110 / 100)) {
  		pr_debug("%s: [Case 1] capacity = 0x%04x, NewVfFullCap = 0x%04x
  ",
  			__func__, fuelgauge->battery_data->Capacity,
  			new_vffullcap);
  
  		new_vffullcap =
  			(fuelgauge->battery_data->Capacity * 110) / 100;
  
  		max77823_write_word(fuelgauge->i2c, DQACC_REG,
  				    (u16)(new_vffullcap / 4));
  		max77823_write_word(fuelgauge->i2c, DPACC_REG, (u16)0x3200);
  	} else if (new_vffullcap <
  		(fuelgauge->battery_data->Capacity * 50 / 100)) {
  		pr_debug("%s: [Case 5] capacity = 0x%04x, NewVfFullCap = 0x%04x
  ",
  			__func__, fuelgauge->battery_data->Capacity,
  			new_vffullcap);
  
  		new_vffullcap =
  			(fuelgauge->battery_data->Capacity * 50) / 100;
  
  		max77823_write_word(fuelgauge->i2c, DQACC_REG,
  				    (u16)(new_vffullcap / 4));
  		max77823_write_word(fuelgauge->i2c, DPACC_REG,
  				    (u16)0x3200);
  	} else {
  	/* compare with previous capacity */
  		if (new_vffullcap >
  			(fuelgauge->info.previous_vffullcap * 110 / 100)) {
  			pr_debug("%s: [Case 2] previous_vffullcap = 0x%04x, NewVfFullCap = 0x%04x
  ",
  				__func__, fuelgauge->info.previous_vffullcap,
  				new_vffullcap);
  
  			new_vffullcap =
  				(fuelgauge->info.previous_vffullcap * 110) /
  				100;
  
  			max77823_write_word(fuelgauge->i2c, DQACC_REG,
  					    (u16)(new_vffullcap / 4));
  			max77823_write_word(fuelgauge->i2c, DPACC_REG,
  					    (u16)0x3200);
  		} else if (new_vffullcap <
  			(fuelgauge->info.previous_vffullcap * 90 / 100)) {
  			pr_debug("%s: [Case 3] previous_vffullcap = 0x%04x, NewVfFullCap = 0x%04x
  ",
  				__func__, fuelgauge->info.previous_vffullcap,
  				new_vffullcap);
  
  			new_vffullcap =
  				(fuelgauge->info.previous_vffullcap * 90) / 100;
  
  			max77823_write_word(fuelgauge->i2c, DQACC_REG,
  					    (u16)(new_vffullcap / 4));
  			max77823_write_word(fuelgauge->i2c, DPACC_REG,
  					    (u16)0x3200);
  		} else {
  			pr_debug("%s: [Case 4] previous_vffullcap = 0x%04x, NewVfFullCap = 0x%04x
  ",
  				__func__, fuelgauge->info.previous_vffullcap,
  				new_vffullcap);
  			is_vffullcap_changed = false;
  		}
  	}
  
  	/* delay for register setting (dQacc, dPacc) */
  	if (is_vffullcap_changed)
  		msleep(300);
  
  	fuelgauge->info.previous_vffullcap =
  		max77823_read_word(fuelgauge->i2c, FULLCAP_NOM_REG);
  
  	if (is_vffullcap_changed)
  		pr_debug("%s : VfFullCap(0x%04x), dQacc(0x%04x), dPacc(0x%04x)
  ",
  			__func__,
  			max77823_read_word(fuelgauge->i2c, FULLCAP_NOM_REG),
  			max77823_read_word(fuelgauge->i2c, DQACC_REG),
  			max77823_read_word(fuelgauge->i2c, DPACC_REG));
  
  }
  
  void fg_set_full_charged(struct max77823_fuelgauge_data *fuelgauge)
  {
  	pr_info("[FG_Set_Full] (B) FullCAP(%d), RemCAP(%d)
  ",
  		(max77823_read_word(fuelgauge->i2c, FULLCAPREP_REG)/2),
  		(max77823_read_word(fuelgauge->i2c, REMCAP_REP_REG)/2));
  
  	max77823_write_word(fuelgauge->i2c, FULLCAPREP_REG,
  		(u16)max77823_read_word(fuelgauge->i2c, REMCAP_REP_REG));
  
  	pr_info("[FG_Set_Full] (A) FullCAP(%d), RemCAP(%d)
  ",
  		(max77823_read_word(fuelgauge->i2c, FULLCAPREP_REG)/2),
  		(max77823_read_word(fuelgauge->i2c, REMCAP_REP_REG)/2));
  }
  
  static void display_low_batt_comp_cnt(struct max77823_fuelgauge_data *fuelgauge)
  {
  	pr_info("Check Array(%s): [%d, %d], [%d, %d], ",
  			fuelgauge->battery_data->type_str,
  			fuelgauge->info.low_batt_comp_cnt[0][0],
  			fuelgauge->info.low_batt_comp_cnt[0][1],
  			fuelgauge->info.low_batt_comp_cnt[1][0],
  			fuelgauge->info.low_batt_comp_cnt[1][1]);
  	pr_info("[%d, %d], [%d, %d], [%d, %d]
  ",
  			fuelgauge->info.low_batt_comp_cnt[2][0],
  			fuelgauge->info.low_batt_comp_cnt[2][1],
  			fuelgauge->info.low_batt_comp_cnt[3][0],
  			fuelgauge->info.low_batt_comp_cnt[3][1],
  			fuelgauge->info.low_batt_comp_cnt[4][0],
  			fuelgauge->info.low_batt_comp_cnt[4][1]);
  }
  
  static void add_low_batt_comp_cnt(struct max77823_fuelgauge_data *fuelgauge,
  				int range, int level)
  {
  	int i;
  	int j;
  
  	/* Increase the requested count value, and reset others. */
  	fuelgauge->info.low_batt_comp_cnt[range-1][level/2]++;
  
  	for (i = 0; i < LOW_BATT_COMP_RANGE_NUM; i++) {
  		for (j = 0; j < LOW_BATT_COMP_LEVEL_NUM; j++) {
  			if (i == range-1 && j == level/2)
  				continue;
  			else
  				fuelgauge->info.low_batt_comp_cnt[i][j] = 0;
  		}
  	}
  }
  
  void prevent_early_poweroff(struct max77823_fuelgauge_data *fuelgauge,
  	int vcell, int *fg_soc)
  {
  	int soc = 0;
  	int read_val;
  
  	soc = fg_read_percent(fuelgauge, SOCREP_REG);
  
  	/* No need to write REMCAP_REP in below normal cases */
  	if (soc > POWER_OFF_SOC_HIGH_MARGIN || vcell > fuelgauge->battery_data->low_battery_comp_voltage)
  		return;
  
  	pr_info("%s: soc=%d, vcell=%d
  ", __func__, soc, vcell);
  
  	if (vcell > POWER_OFF_VOLTAGE_HIGH_MARGIN) {
  		read_val = max77823_read_word(fuelgauge->i2c, FULLCAPREP_REG);
  		/* FullCAP * 0.013 */
  		max77823_write_word(fuelgauge->i2c, REMCAP_REP_REG,
  		(u16)(read_val * 13 / 1000));
  		msleep(200);
  		*fg_soc = fg_read_percent(fuelgauge, SOCREP_REG);
  		pr_info("%s: new soc=%d, vcell=%d
  ", __func__, *fg_soc, vcell);
  	}
  }
  
  void reset_low_batt_comp_cnt(struct max77823_fuelgauge_data *fuelgauge)
  {
  	memset(fuelgauge->info.low_batt_comp_cnt, 0,
  		sizeof(fuelgauge->info.low_batt_comp_cnt));
  }
  
  static int check_low_batt_comp_condition(
  	struct max77823_fuelgauge_data *fuelgauge,
  	int *nLevel)
  {
  	int i;
  	int j;
  	int ret = 0;
  
  	for (i = 0; i < LOW_BATT_COMP_RANGE_NUM; i++) {
  		for (j = 0; j < LOW_BATT_COMP_LEVEL_NUM; j++) {
  			if (fuelgauge->info.low_batt_comp_cnt[i][j] >=
  				MAX_LOW_BATT_CHECK_CNT) {
  				display_low_batt_comp_cnt(fuelgauge);
  				ret = 1;
  				*nLevel = j*2 + 1;
  				break;
  			}
  		}
  	}
  
  	return ret;
  }
  
  static int get_low_batt_threshold(struct max77823_fuelgauge_data *fuelgauge,
  				int range, int nCurrent, int level)
  {
  	int ret = 0;
  
  	ret = fuelgauge->battery_data->low_battery_table[range][OFFSET] +
  		(nCurrent *
  		fuelgauge->battery_data->low_battery_table[range][SLOPE]);
  
  	return ret;
  }
  
  int low_batt_compensation(struct max77823_fuelgauge_data *fuelgauge,
  		int fg_soc, int fg_vcell, int fg_current)
  {
  	int fg_avg_current = 0;
  	int fg_min_current = 0;
  	int new_level = 0;
  	int i, table_size;
  
  	/* Not charging, Under low battery comp voltage */
  	if (fg_vcell <= fuelgauge->battery_data->low_battery_comp_voltage) {
  		fg_avg_current = fg_read_avg_current(fuelgauge) / 1000;
  		fg_min_current = min(fg_avg_current, fg_current);
  
  		table_size =
  			sizeof(fuelgauge->battery_data->low_battery_table) /
  			(sizeof(s16)*TABLE_MAX);
  
  		for (i = 1; i < CURRENT_RANGE_MAX_NUM; i++) {
  			if ((fg_min_current >= fuelgauge->battery_data->
  				low_battery_table[i-1][RANGE]) &&
  				(fg_min_current < fuelgauge->battery_data->
  				low_battery_table[i][RANGE])) {
  				if (fg_soc >= 10 && fg_vcell <
  					get_low_batt_threshold(fuelgauge,
  					i, fg_min_current, 1)) {
  					add_low_batt_comp_cnt(
  						fuelgauge, i, 1);
  				} else {
  					reset_low_batt_comp_cnt(fuelgauge);
  				}
  			}
  		}
  
  		if (check_low_batt_comp_condition(fuelgauge, &new_level)) {
  			fg_low_batt_compensation(fuelgauge, new_level);
  			reset_low_batt_comp_cnt(fuelgauge);
  
  			/* Do not update soc right after
  			 * low battery compensation
  			 * to prevent from powering-off suddenly
  			 */
  			pr_info("%s: SOC is set to %d by low compensation!!
  ",
  				__func__, fg_read_percent(fuelgauge, SOCREP_REG));
  		}
  	}
  
  	/* Prevent power off over 3500mV */
  	prevent_early_poweroff(fuelgauge, fg_vcell, &fg_soc);
  
  	return fg_soc;
  }
  
  static bool is_booted_in_low_battery(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int fg_vcell = max77823_get_vcell(fuelgauge);
  	int fg_current = fg_read_current(fuelgauge)/1000;
  	int threshold = 0;
  
  	threshold = 3300000 + (fg_current * 170);
  
  	if (fg_vcell <= threshold)
  		return true;
  	else
  		return false;
  }
  
  static bool fuelgauge_recovery_handler(struct max77823_fuelgauge_data *fuelgauge)
  {
  	int current_soc;
  	int avsoc;
  	int temperature;
  
  	if (fuelgauge->info.soc >= LOW_BATTERY_SOC_REDUCE_UNIT) {
  		pr_err("%s: Reduce the Reported SOC by 1%%
  ",
  			__func__);
  		current_soc = fg_read_percent(fuelgauge, SOCREP_REG) / 10;
  
  		if (current_soc) {
  			pr_info("%s: Returning to Normal discharge path
  ",
  				__func__);
  			pr_info("%s: Actual SOC(%d) non-zero
  ",
  				__func__, current_soc);
  			fuelgauge->info.is_low_batt_alarm = false;
  		} else {
  			temperature = fg_read_temp(fuelgauge);
  			avsoc = fg_read_percent(fuelgauge, SOCAV_REG);
  
  			if ((fuelgauge->info.soc > avsoc) ||
  				(temperature < 0)) {
  				fuelgauge->info.soc -=
  					LOW_BATTERY_SOC_REDUCE_UNIT;
  				pr_err("%s: New Reduced RepSOC (%d)
  ",
  					__func__, fuelgauge->info.soc);
  			} else
  				pr_info("%s: Waiting for recovery (AvSOC:%d)
  ",
  					__func__, avsoc);
  		}
  	}
  
  	return fuelgauge->info.is_low_batt_alarm;
  }
  
  static int get_fuelgauge_soc(struct max77823_fuelgauge_data *fuelgauge)
  {
  	union power_supply_propval value;
  	int fg_soc = 0;
  	int fg_vfsoc;
  	int fg_vcell;
  	int fg_current;
  	int avg_current;
  	ktime_t	current_time;
  	struct timespec ts;
  	int fullcap_check_interval;
  
  	if (fuelgauge->info.is_low_batt_alarm)
  		if (fuelgauge_recovery_handler(fuelgauge)) {
  			fg_soc = fuelgauge->info.soc;
  			goto return_soc;
  		}
  
  #if defined(ANDROID_ALARM_ACTIVATED)
  	current_time = alarm_get_elapsed_realtime();
  	ts = ktime_to_timespec(current_time);
  #else
  	current_time = ktime_get_boottime();
  	ts = ktime_to_timespec(current_time);
  #endif
  
  	/* check fullcap range */
  	fullcap_check_interval =
  		(ts.tv_sec - fuelgauge->info.fullcap_check_interval);
  	if (fullcap_check_interval >
  		VFFULLCAP_CHECK_INTERVAL) {
  		pr_debug("%s: check fullcap range (interval:%d)
  ",
  			__func__, fullcap_check_interval);
  		fg_check_vf_fullcap_range(fuelgauge);
  		fuelgauge->info.fullcap_check_interval = ts.tv_sec;
  	}
  
  	fg_soc = fg_read_percent(fuelgauge, SOCREP_REG);
  	if (fg_soc < 0) {
  		pr_info("Can't read soc!!!");
  		fg_soc = fuelgauge->info.soc;
  	}
  
  	if (fuelgauge->info.low_batt_boot_flag) {
  		fg_soc = 0;
  
  		if (fuelgauge->pdata->check_cable_callback &&
  		    fuelgauge->pdata->check_cable_callback() !=
  			POWER_SUPPLY_TYPE_BATTERY &&
  			!is_booted_in_low_battery(fuelgauge)) {
  			fg_adjust_capacity(fuelgauge);
  			fuelgauge->info.low_batt_boot_flag = 0;
  		}
  
  		if (fuelgauge->pdata->check_cable_callback &&
  		    fuelgauge->pdata->check_cable_callback() ==
  			POWER_SUPPLY_TYPE_BATTERY)
  			fuelgauge->info.low_batt_boot_flag = 0;
  	}
  
  	fg_vcell = max77823_get_vcell(fuelgauge);
  	fg_current = fg_read_current(fuelgauge)/1000;
  	avg_current = fg_read_avg_current(fuelgauge)/1000;
  	fg_vfsoc = fg_read_vfsoc(fuelgauge);
  
  	value.intval = max77823_get_status(fuelgauge);
  
  	/* Algorithm for reducing time to fully charged (from MAXIM) */
  	if (value.intval != POWER_SUPPLY_STATUS_DISCHARGING &&
  		value.intval != POWER_SUPPLY_STATUS_FULL &&
  		fuelgauge->cable_type != POWER_SUPPLY_TYPE_USB &&
  		/* Skip when first check after boot up */
  		!fuelgauge->info.is_first_check &&
  		(fg_vfsoc > VFSOC_FOR_FULLCAP_LEARNING &&
  		(fg_current > LOW_CURRENT_FOR_FULLCAP_LEARNING &&
  		fg_current < HIGH_CURRENT_FOR_FULLCAP_LEARNING) &&
  		(avg_current > LOW_AVGCURRENT_FOR_FULLCAP_LEARNING &&
  		avg_current < HIGH_AVGCURRENT_FOR_FULLCAP_LEARNING))) {
  
  		if (fuelgauge->info.full_check_flag == 2) {
  			pr_info("%s: force fully charged SOC !! (%d)",
  				__func__, fuelgauge->info.full_check_flag);
  			fg_set_full_charged(fuelgauge);
  			fg_soc = fg_read_percent(fuelgauge, SOCREP_REG);
  		} else if (fuelgauge->info.full_check_flag < 2)
  			pr_info("%s: full_check_flag (%d)",
  				__func__, fuelgauge->info.full_check_flag);
  
  		/* prevent overflow */
  		if (fuelgauge->info.full_check_flag++ > 10000)
  			fuelgauge->info.full_check_flag = 3;
  	} else
  		fuelgauge->info.full_check_flag = 0;
  
  	/*  Checks vcell level and tries to compensate SOC if needed.*/
  	/*  If jig cable is connected, then skip low batt compensation check. */
  	if (fuelgauge->pdata->check_jig_status &&
  	    !fuelgauge->pdata->check_jig_status() &&
  		value.intval == POWER_SUPPLY_STATUS_DISCHARGING)
  		fg_soc = low_batt_compensation(
  			fuelgauge, fg_soc, fg_vcell, fg_current);
  
  	if (fuelgauge->info.is_first_check)
  		fuelgauge->info.is_first_check = false;
  
  	fuelgauge->info.soc = fg_soc;
  
  return_soc:
  	pr_debug("%s: soc(%d), low_batt_alarm(%d)
  ",
  		__func__, fuelgauge->info.soc,
  		fuelgauge->info.is_low_batt_alarm);
  
  	return fg_soc;
  }
  
  static void full_comp_work_handler(struct work_struct *work)
  {
  	struct max77823_fuelgauge_info *fg_info =
  		container_of(work, struct max77823_fuelgauge_info, full_comp_work.work);
  	struct max77823_fuelgauge_data *fuelgauge =
  		container_of(fg_info, struct max77823_fuelgauge_data, info);
  	int avg_current;
  	union power_supply_propval value;
  
  	avg_current = fg_read_avg_current(fuelgauge)/1000;
  	psy_get_prop(fuelgauge, PS_BATT, POWER_SUPPLY_PROP_STATUS, &value);
  
  	if (avg_current >= 25) {
  		cancel_delayed_work(&fuelgauge->info.full_comp_work);
  		schedule_delayed_work(&fuelgauge->info.full_comp_work, 100);
  	} else {
  		pr_info("%s: full charge compensation start (avg_current %d)
  ",
  			__func__, avg_current);
  		fg_fullcharged_compensation(fuelgauge,
  			(int)(value.intval ==
  			POWER_SUPPLY_STATUS_FULL), false);
  	}
  }
  
  static irqreturn_t max77823_jig_irq_thread(int irq, void *irq_data)
  {
  	struct max77823_fuelgauge_data *fuelgauge = irq_data;
  
  	if (fuelgauge->pdata->check_jig_status &&
  	    fuelgauge->pdata->check_jig_status())
  		fg_reset_capacity_by_jig_connection(fuelgauge);
  	else
  		pr_info("%s: jig removed
  ", __func__);
  	return IRQ_HANDLED;
  }
  
  bool max77823_fg_init(struct max77823_fuelgauge_data *fuelgauge)
  {
  	ktime_t	current_time;
  	struct timespec ts;
  	int ret;
  	int vempty;
  
  #if defined(ANDROID_ALARM_ACTIVATED)
  	current_time = alarm_get_elapsed_realtime();
  	ts = ktime_to_timespec(current_time);
  #else
  	current_time = ktime_get_boottime();
  	ts = ktime_to_timespec(current_time);
  #endif
  
  	fuelgauge->info.fullcap_check_interval = ts.tv_sec;
  
  	fuelgauge->info.is_low_batt_alarm = false;
  	fuelgauge->info.is_first_check = true;
  
  	/* Init parameters to prevent wrong compensation. */
  	fuelgauge->info.previous_fullcap =
  		max77823_read_word(fuelgauge->i2c, FULLCAPREP_REG);
  	fuelgauge->info.previous_vffullcap =
  		max77823_read_word(fuelgauge->i2c, FULLCAP_NOM_REG);
  
  	if (fuelgauge->pdata->check_cable_callback &&
  	    (fuelgauge->pdata->check_cable_callback() !=
  	     POWER_SUPPLY_TYPE_BATTERY) &&
  	    is_booted_in_low_battery(fuelgauge))
  		fuelgauge->info.low_batt_boot_flag = 1;
  
  	if (fuelgauge->pdata->check_jig_status &&
  	    fuelgauge->pdata->check_jig_status())
  		fg_reset_capacity_by_jig_connection(fuelgauge);
  	else {
  		if (fuelgauge->pdata->jig_irq) {
  			int ret;
  			ret = request_threaded_irq(fuelgauge->pdata->jig_irq,
  					NULL, max77823_jig_irq_thread,
  					fuelgauge->pdata->jig_irq_attr,
  					"jig-irq", fuelgauge);
  			if (ret) {
  				pr_info("%s: Failed to Request IRQ
  ",
  					__func__);
  			}
  		}
  	}
  
  	INIT_DELAYED_WORK(&fuelgauge->info.full_comp_work,
  		full_comp_work_handler);
  
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_CONFIG,
  		(fuelgauge->pdata->thermal_source != SEC_BATTERY_THERMAL_SOURCE_FG) ? 0x2154 : 0x2254);
  
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_TGAIN, (u16)fuelgauge->pdata->tgain);
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_TOFF, (u16)fuelgauge->pdata->toff);
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_TCURVE, (u16)fuelgauge->pdata->tcurve);
  
  	ret = max77823_read_word(fuelgauge->i2c, MAX77823_REG_STATUS);
  	if ((ret < 0) || !(ret & 2))
  		return true;
  
  	/* Power on reset initialization needed */
  	fg_reset_capacity_by_jig_connection(fuelgauge);
  	vempty = fuelgauge->pdata->empty_detect_voltage / 10;
  	vempty <<= 7;
  	vempty |= (fuelgauge->pdata->empty_recovery_voltage / 40) & 0x7f;
  	max77823_write_word(fuelgauge->i2c, MAX77823_V_EMPTY, vempty);
  
  	/* Clear POR condition */
  	max77823_write_word(fuelgauge->i2c, MAX77823_REG_STATUS, ret & ~2);
  	return true;
  }
  
  bool max77823_fg_fuelalert_init(struct max77823_fuelgauge_data *fuelgauge,
  				int soc)
  {
  	if (fg_alert_init(fuelgauge, soc) >= 0)
  		return true;
  	else
  		return false;
  }
  
  bool max77823_fg_is_fuelalerted(struct max77823_fuelgauge_data *fuelgauge)
  {
  	if (fg_check_status_reg(fuelgauge) > 0)
  		return true;
  	else
  		return false;
  }
  
  bool max77823_fg_fuelalert_process(void *irq_data, bool is_fuel_alerted)
  {
  	struct max77823_fuelgauge_data *fuelgauge =
  		(struct max77823_fuelgauge_data *)irq_data;
  	union power_supply_propval value;
  	int overcurrent_limit_in_soc;
  	int current_soc = fg_read_percent(fuelgauge, SOCREP_REG);
  
  	psy_get_prop(fuelgauge, PS_BATT, POWER_SUPPLY_PROP_STATUS, &value);
  	if (value.intval == POWER_SUPPLY_STATUS_CHARGING)
  		return true;
  
  	if (fuelgauge->info.soc <= STABLE_LOW_BATTERY_DIFF)
  		overcurrent_limit_in_soc = STABLE_LOW_BATTERY_DIFF_LOWBATT;
  	else
  		overcurrent_limit_in_soc = STABLE_LOW_BATTERY_DIFF;
  
  	if (((int)fuelgauge->info.soc - current_soc) >
  		overcurrent_limit_in_soc) {
  		pr_info("%s: Abnormal Current Consumption jump by %d units
  ",
  			__func__, (((int)fuelgauge->info.soc - current_soc)));
  		pr_info("%s: Last Reported SOC (%d).
  ",
  			__func__, fuelgauge->info.soc);
  
  		fuelgauge->info.is_low_batt_alarm = true;
  
  		if (fuelgauge->info.soc >=
  			LOW_BATTERY_SOC_REDUCE_UNIT)
  			return true;
  	}
  
  	if (value.intval ==
  			POWER_SUPPLY_STATUS_DISCHARGING) {
  		pr_err("Set battery level as 0, power off.
  ");
  		fuelgauge->info.soc = 0;
  		value.intval = 0;
  		psy_set_prop(fuelgauge, PS_BATT, POWER_SUPPLY_PROP_CAPACITY,
  				&value);
  	}
  
  	return true;
  }
  
  bool max77823_fg_full_charged(struct max77823_fuelgauge_data *fuelgauge)
  {
  	union power_supply_propval value;
  
  	psy_get_prop(fuelgauge, PS_BATT, POWER_SUPPLY_PROP_STATUS, &value);
  
  	/* full charge compensation algorithm by MAXIM */
  	fg_fullcharged_compensation(fuelgauge,
  		(int)(value.intval == POWER_SUPPLY_STATUS_FULL), true);
  
  	cancel_delayed_work(&fuelgauge->info.full_comp_work);
  	schedule_delayed_work(&fuelgauge->info.full_comp_work, 100);
  
  	return false;
  }
  #endif
  
  bool max77823_fg_reset(struct max77823_fuelgauge_data *fuelgauge)
  {
  	if (!fg_reset_soc(fuelgauge))
  		return true;
  	else
  		return false;
  }
  
  static void max77823_fg_get_scaled_capacity(
  	struct max77823_fuelgauge_data *fuelgauge,
  	union power_supply_propval *val)
  {
  	val->intval = (val->intval < fuelgauge->pdata->capacity_min) ?
  		0 : ((val->intval - fuelgauge->pdata->capacity_min) * 1000 /
  		     (fuelgauge->capacity_max - fuelgauge->pdata->capacity_min));
  
  	pr_debug("%s: scaled capacity (%d.%d)
  ",
  		__func__, val->intval/10, val->intval%10);
  }
  
  /* capacity is integer */
  static void max77823_fg_get_atomic_capacity(
  	struct max77823_fuelgauge_data *fuelgauge,
  	union power_supply_propval *val)
  {
  	if (fuelgauge->pdata->capacity_calculation_type &
  		SEC_FUELGAUGE_CAPACITY_TYPE_ATOMIC) {
  	if (fuelgauge->capacity_old < val->intval)
  		val->intval = fuelgauge->capacity_old + 1;
  	else if (fuelgauge->capacity_old > val->intval)
  		val->intval = fuelgauge->capacity_old - 1;
  	}
  
  	/* keep SOC stable in abnormal status */
  	if (fuelgauge->pdata->capacity_calculation_type &
  		SEC_FUELGAUGE_CAPACITY_TYPE_SKIP_ABNORMAL) {
  		pr_debug("%s:is_charging=%d cable_type=%d
  ", __func__, fuelgauge->is_charging, fuelgauge->cable_type);
  		if (!fuelgauge->is_charging &&
  			fuelgauge->capacity_old < val->intval) {
  			pr_err("%s: capacity (old %d : new %d)
  ",
  				__func__, fuelgauge->capacity_old, val->intval);
  			val->intval = fuelgauge->capacity_old;
  		}
  	}
  
  	/* updated old capacity */
  	fuelgauge->capacity_old = val->intval;
  }
  
  static int max77823_fg_calculate_dynamic_scale(
  	struct max77823_fuelgauge_data *fuelgauge)
  {
  	union power_supply_propval raw_soc_val;
  
  #ifdef CONFIG_FUELGAUGE_MAX77823_VOLTAGE_TRACKING
  	raw_soc_val.intval = max77823_get_soc(fuelgauge) / 10;
  #else
  	raw_soc_val.intval = fg_read_percent(fuelgauge, SOCREP_REG) / 10;
  #endif
  
  	if (raw_soc_val.intval <
  		fuelgauge->pdata->capacity_max -
  		fuelgauge->pdata->capacity_max_margin) {
  		fuelgauge->capacity_max =
  			fuelgauge->pdata->capacity_max -
  			fuelgauge->pdata->capacity_max_margin;
  		pr_debug("%s: capacity_max (%d)", __func__,
  			 fuelgauge->capacity_max);
  	} else {
  		fuelgauge->capacity_max =
  			(raw_soc_val.intval >
  			fuelgauge->pdata->capacity_max +
  			fuelgauge->pdata->capacity_max_margin) ?
  			(fuelgauge->pdata->capacity_max +
  			fuelgauge->pdata->capacity_max_margin) :
  			raw_soc_val.intval;
  		pr_debug("%s: raw soc (%d)", __func__,
  			 fuelgauge->capacity_max);
  	}
  
  	fuelgauge->capacity_max =
  		(fuelgauge->capacity_max * 99 / 100);
  
  	/* update capacity_old for sec_fg_get_atomic_capacity algorithm */
  	fuelgauge->capacity_old = 100;
  
  	pr_info("%s: %d is used for capacity_max
  ",
  		__func__, fuelgauge->capacity_max);
  
  	return fuelgauge->capacity_max;
  }
  
  static int max77823_fg_property_is_writeable(struct power_supply *psy,
                                                  enum power_supply_property psp)
  {
          switch (psp) {
  	case POWER_SUPPLY_PROP_ONLINE:
                  return 1;
          default:
                  break;
          }
  
          return 0;
  }
  
  
  #ifdef CONFIG_FUELGAUGE_MAX77823_VOLTAGE_TRACKING
  static int max77823_fg_get_property(struct power_supply *psy,
  			     enum power_supply_property psp,
  			     union power_supply_propval *val)
  {
  	int ret;
  	struct max77823_fuelgauge_data *fuelgauge =
  		container_of(psy, struct max77823_fuelgauge_data, psy_fg);
  
  	switch (psp) {
  	case POWER_SUPPLY_PROP_STATUS:
  		val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
  		ret = max77823_get_status(fuelgauge);
  		if (ret >= 0)
  			val->intval = ret;
  		break;
  	case POWER_SUPPLY_PROP_CHARGE_FULL:
  		val->intval = 0;
  		ret = max77823_read_word(fuelgauge->i2c, FULLCAP_REG);
  		if (ret < 0)
  			return ret;
  		val->intval = ret * 1000 / 2;
  		break;
  	case POWER_SUPPLY_PROP_ONLINE:
  		val->intval = fuelgauge->cable_type;
  		pr_info("%s:is_charging=%d cable_type=%d
  ", __func__, fuelgauge->is_charging, fuelgauge->cable_type);
  		break;
  		/* Cell voltage (VCELL, mV) */
  	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  		val->intval = max77823_get_vcell(fuelgauge);
  		break;
  		/* Additional Voltage Information (uV) */
  	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
  		switch (val->intval) {
  		case SEC_BATTEY_VOLTAGE_AVERAGE:
  			val->intval = max77823_get_avgvcell(fuelgauge);
  			break;
  		case SEC_BATTEY_VOLTAGE_OCV:
  			val->intval = max77823_get_vfocv(fuelgauge);
  			break;
  		}
  		break;
  		/* Current (mA) */
  	case POWER_SUPPLY_PROP_CURRENT_NOW:
  		val->intval = 0;
  		break;
  		/* Average Current (mA) */
  	case POWER_SUPPLY_PROP_CURRENT_AVG:
  		val->intval = 0;
  		break;
  		/* SOC (%) */
  	case POWER_SUPPLY_PROP_CAPACITY:
  		if (val->intval == SEC_FUELGAUGE_CAPACITY_TYPE_RAW) {
  			val->intval = max77823_get_soc(fuelgauge);
  		} else {
  			val->intval = max77823_get_soc(fuelgauge) / 10;
  
  			if (fuelgauge->pdata->capacity_calculation_type &
  			    (SEC_FUELGAUGE_CAPACITY_TYPE_SCALE |
  			     SEC_FUELGAUGE_CAPACITY_TYPE_DYNAMIC_SCALE))
  				max77823_fg_get_scaled_capacity(fuelgauge, val);
  
  			/* capacity should be between 0% and 100%
  			 * (0.1% degree)
  			 */
  			if (val->intval > 1000)
  				val->intval = 1000;
  			if (val->intval < 0)
  				val->intval = 0;
  
  			/* get only integer part */
  			val->intval /= 10;
  
  			/* check whether doing the wake_unlock */
  			if ((val->intval > fuelgauge->pdata->fuel_alert_soc) &&
  			    fuelgauge->is_fuel_alerted) {
  				wake_unlock(&fuelgauge->fuel_alert_wake_lock);
  				max77823_fg_fuelalert_init(fuelgauge,
  					  fuelgauge->pdata->fuel_alert_soc);
  			}
  
  			/* (Only for atomic capacity)
  			 * In initial time, capacity_old is 0.
  			 * and in resume from sleep,
  			 * capacity_old is too different from actual soc.
  			 * should update capacity_old
  			 * by val->intval in booting or resume.
  			 */
  			if (fuelgauge->initial_update_of_soc) {
  				/* updated old capacity */
  				fuelgauge->capacity_old = val->intval;
  				fuelgauge->initial_update_of_soc = false;
  				break;
  			}
  
  			if (fuelgauge->pdata->capacity_calculation_type &
  			    (SEC_FUELGAUGE_CAPACITY_TYPE_ATOMIC |
  			     SEC_FUELGAUGE_CAPACITY_TYPE_SKIP_ABNORMAL))
  				max77823_fg_get_atomic_capacity(fuelgauge, val);
  		}
  		break;
  		/* Battery Temperature */
  	case POWER_SUPPLY_PROP_TEMP:
  		/* Target Temperature */
  	case POWER_SUPPLY_PROP_TEMP_AMBIENT:
  		val->intval = max77823_get_temperature(fuelgauge);
  		break;
  	default:
  		return false;
  	}
  	return true;
  }
  
  
  static int max77823_fg_set_property(struct power_supply *psy,
  			     enum power_supply_property psp,
  			     const union power_supply_propval *val)
  {
  	struct max77823_fuelgauge_data *fuelgauge =
  		container_of(psy, struct max77823_fuelgauge_data, psy_fg);
  
  	switch (psp) {
  	case POWER_SUPPLY_PROP_STATUS:
  		if (val->intval == POWER_SUPPLY_STATUS_FULL)
  			max77823_fg_full_charged(fuelgauge);
  		break;
  	case POWER_SUPPLY_PROP_CHARGE_FULL:
  		if (val->intval == POWER_SUPPLY_TYPE_BATTERY) {
  			if (fuelgauge->pdata->capacity_calculation_type &
  			    SEC_FUELGAUGE_CAPACITY_TYPE_DYNAMIC_SCALE)
  				max77823_fg_calculate_dynamic_scale(fuelgauge);
  		}
  		break;
  	case POWER_SUPPLY_PROP_ONLINE:
  		fuelgauge->cable_type = val->intval;
  		if (val->intval == POWER_SUPPLY_TYPE_BATTERY)
  			fuelgauge->is_charging = false;
  		else
  			fuelgauge->is_charging = true;
  		pr_info("%s:is_charging=%d cable_type=%d
  ", __func__, fuelgauge->is_charging, fuelgauge->cable_type);
  		break;
  		/* Battery Temperature */
  	case POWER_SUPPLY_PROP_CAPACITY:
  		if (val->intval == SEC_FUELGAUGE_CAPACITY_TYPE_RESET) {
  			fuelgauge->initial_update_of_soc = true;
  			if (!max77823_fg_reset(fuelgauge))
  				return -EINVAL;
  			else
  				break;
  		}
  		/* Battery Temperature */
  	case POWER_SUPPLY_PROP_TEMP:
  		/* Target Temperature */
  	case POWER_SUPPLY_PROP_TEMP_AMBIENT:
  		max77823_set_temperature(fuelgauge, val->intval);
  		break;
  	default:
  		return false;
  	}
  	return true;
  }
  #endif
  
  #ifdef CONFIG_FUELGAUGE_MAX77823_COULOMB_COUNTING
  static int max77823_fg_get_property(struct power_supply *psy,
  			     enum power_supply_property psp,
  			     union power_supply_propval *val)
  {
  	int ret;
  	struct max77823_fuelgauge_data *fuelgauge =
  		container_of(psy, struct max77823_fuelgauge_data, psy_fg);
  
  	switch (psp) {
  	case POWER_SUPPLY_PROP_STATUS:
  		val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
  		ret = max77823_get_status(fuelgauge);
  		if (ret >= 0)
  			val->intval = ret;
  		break;
  	case POWER_SUPPLY_PROP_CHARGE_FULL:
  		val->intval = 0;
  		ret = max77823_read_word(fuelgauge->i2c, FULLCAP_REG);
  		if (ret < 0)
  			return ret;
  		val->intval = ret * 1000 / 2;
  		break;
  	case POWER_SUPPLY_PROP_ONLINE:
  		val->intval = fuelgauge->cable_type;
  		pr_info("%s:is_charging=%d cable_type=%d
  ", __func__, fuelgauge->is_charging, fuelgauge->cable_type);
  		break;
  		/* Cell voltage (VCELL, mV) */
  	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  		val->intval = max77823_get_vcell(fuelgauge);
  		break;
  		/* Additional Voltage Information (mV) */
  	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
  		switch (val->intval) {
  		case SEC_BATTEY_VOLTAGE_OCV:
  			val->intval = max77823_get_vfocv(fuelgauge);
  			break;
  		case SEC_BATTEY_VOLTAGE_AVERAGE:
  		default:
  			val->intval = max77823_get_avgvcell(fuelgauge);
  			break;
  		}
  		break;
  		/* Current */
  	case POWER_SUPPLY_PROP_CURRENT_NOW:
  		val->intval = fg_read_current(fuelgauge);
  		break;
  		/* Average Current */
  	case POWER_SUPPLY_PROP_CURRENT_AVG:
  		val->intval = fg_read_avg_current(fuelgauge);
  		break;
  
  	case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
  		val->intval = fg_read_power(fuelgauge, DESIGNCAP_REG);
  		break;
  	case POWER_SUPPLY_PROP_ENERGY_FULL:
  		val->intval = fg_read_power(fuelgauge, FULLCAPREP_REG);
  		break;
  	case POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN:
  		val->intval = fg_read_power(fuelgauge, REMCAP_MIX_REG);	/* nothing to do with empty, stole for sec_battery */
  		break;
  	case POWER_SUPPLY_PROP_ENERGY_EMPTY:
  		val->intval = 0;
  		break;
  
  	case POWER_SUPPLY_PROP_ENERGY_NOW:
  		val->intval = fg_read_power(fuelgauge, REMCAP_REP_REG);
  		break;
  	case POWER_SUPPLY_PROP_ENERGY_AVG:
  		val->intval = fg_read_power(fuelgauge, REMCAP_AV_REG);
  		break;
  
  		/* SOC (%) */
  	case POWER_SUPPLY_PROP_CAPACITY:
  		if (val->intval == SEC_FUELGAUGE_CAPACITY_TYPE_RAW) {
  			val->intval = fg_read_percent(fuelgauge, SOCREP_REG);
  		} else {
  			val->intval = get_fuelgauge_soc(fuelgauge);
  
  			if (fuelgauge->pdata->capacity_calculation_type &
  			    (SEC_FUELGAUGE_CAPACITY_TYPE_SCALE |
  			     SEC_FUELGAUGE_CAPACITY_TYPE_DYNAMIC_SCALE))
  				max77823_fg_get_scaled_capacity(fuelgauge, val);
  
  			/* capacity should be between 0% and 100%
  			 * (0.1% degree)
  			 */
  			if (val->intval > 1000)
  				val->intval = 1000;
  			if (val->intval < 0)
  				val->intval = 0;
  
  			/* get only integer part */
  			val->intval /= 10;
  
  			/* check whether doing the wake_unlock */
  			if ((val->intval > fuelgauge->pdata->fuel_alert_soc) &&
  			    fuelgauge->is_fuel_alerted) {
  				wake_unlock(&fuelgauge->fuel_alert_wake_lock);
  				max77823_fg_fuelalert_init(fuelgauge,
  					  fuelgauge->pdata->fuel_alert_soc);
  			}
  
  			/* (Only for atomic capacity)
  			 * In initial time, capacity_old is 0.
  			 * and in resume from sleep,
  			 * capacity_old is too different from actual soc.
  			 * should update capacity_old
  			 * by val->intval in booting or resume.
  			 */
  			if (fuelgauge->initial_update_of_soc) {
  				/* updated old capacity */
  				fuelgauge->capacity_old = val->intval;
  				fuelgauge->initial_update_of_soc = false;
  				break;
  			}
  
  			if (fuelgauge->pdata->capacity_calculation_type &
  			    (SEC_FUELGAUGE_CAPACITY_TYPE_ATOMIC |
  			     SEC_FUELGAUGE_CAPACITY_TYPE_SKIP_ABNORMAL))
  				max77823_fg_get_atomic_capacity(fuelgauge, val);
  		}
  		break;
  		/* Battery Temperature */
  	case POWER_SUPPLY_PROP_TEMP:
  		/* Target Temperature */
  	case POWER_SUPPLY_PROP_TEMP_AMBIENT:
  		val->intval = fg_read_temp(fuelgauge);
  		break;
  	default:
  		return -EINVAL;
  	}
  	return 0;
  }
  
  static int max77823_fg_set_property(struct power_supply *psy,
  			     enum power_supply_property psp,
  			     const union power_supply_propval *val)
  {
  	struct max77823_fuelgauge_data *fuelgauge =
  		container_of(psy, struct max77823_fuelgauge_data, psy_fg);
  
  	switch (psp) {
  	case POWER_SUPPLY_PROP_STATUS:
  		if (val->intval == POWER_SUPPLY_STATUS_FULL)
  			max77823_fg_full_charged(fuelgauge);
  		break;
  	case POWER_SUPPLY_PROP_CHARGE_FULL:
  		if (val->intval == POWER_SUPPLY_TYPE_BATTERY) {
  			if (fuelgauge->pdata->capacity_calculation_type &
  			    SEC_FUELGAUGE_CAPACITY_TYPE_DYNAMIC_SCALE)
  				max77823_fg_calculate_dynamic_scale(fuelgauge);
  		}
  		break;
  	case POWER_SUPPLY_PROP_ONLINE:
  		fuelgauge->cable_type = val->intval;
  		if (val->intval == POWER_SUPPLY_TYPE_BATTERY) {
  			fuelgauge->is_charging = false;
  		} else {
  			fuelgauge->is_charging = true;
  
  			if (fuelgauge->info.is_low_batt_alarm) {
  				pr_info("%s: Reset low_batt_alarm
  ",
  					 __func__);
  				fuelgauge->info.is_low_batt_alarm = false;
  			}
  
  			reset_low_batt_comp_cnt(fuelgauge);
  		}
  		pr_info("%s:is_charging=%d cable_type=%d
  ", __func__, fuelgauge->is_charging, fuelgauge->cable_type);
  		break;
  		/* Battery Temperature */
  	case POWER_SUPPLY_PROP_CAPACITY:
  		if (val->intval == SEC_FUELGAUGE_CAPACITY_TYPE_RESET) {
  			fuelgauge->initial_update_of_soc = true;
  			if (!max77823_fg_reset(fuelgauge))
  				return -EINVAL;
  			else
  				break;
  		}
  	case POWER_SUPPLY_PROP_TEMP:
  		/* Target Temperature */
  	case POWER_SUPPLY_PROP_TEMP_AMBIENT:
  		fg_write_temp(fuelgauge, val->intval);
  		break;
  	case POWER_SUPPLY_PROP_ENERGY_NOW:
  		fg_reset_capacity_by_jig_connection(fuelgauge);
  		break;
  	default:
  		return -EINVAL;
  	}
  	return 0;
  }
  #endif
  
  static void max77823_fg_isr_work(struct work_struct *work)
  {
  	struct max77823_fuelgauge_data *fuelgauge =
  		container_of(work, struct max77823_fuelgauge_data, isr_work.work);
  
  	/* process for fuel gauge chip */
  	max77823_fg_fuelalert_process(fuelgauge, fuelgauge->is_fuel_alerted);
  
  	/* process for others */
  	if (fuelgauge->pdata->fuelalert_process != NULL)
  		fuelgauge->pdata->fuelalert_process(fuelgauge->is_fuel_alerted);
  }
  
  static irqreturn_t max77823_fg_irq_thread(int irq, void *irq_data)
  {
  	struct max77823_fuelgauge_data *fuelgauge = irq_data;
  	bool fuel_alerted;
  
  	if (fuelgauge->pdata->fuel_alert_soc >= 0) {
  		fuel_alerted =
  			max77823_fg_is_fuelalerted(fuelgauge);
  
  		pr_info("%s: Fuel-alert %salerted!
  ",
  			__func__, fuel_alerted ? "" : "NOT ");
  
  		fg_test_print(fuelgauge);
  
  		if (fuel_alerted == fuelgauge->is_fuel_alerted) {
  			if (!fuelgauge->pdata->repeated_fuelalert) {
  				pr_debug("%s: Fuel-alert Repeated (%d)
  ",
  					__func__, fuelgauge->is_fuel_alerted);
  				return IRQ_HANDLED;
  			}
  		}
  
  		if (fuel_alerted)
  			wake_lock(&fuelgauge->fuel_alert_wake_lock);
  		else
  			wake_unlock(&fuelgauge->fuel_alert_wake_lock);
  
  		schedule_delayed_work(&fuelgauge->isr_work, 0);
  
  		fuelgauge->is_fuel_alerted = fuel_alerted;
  	}
  
  	return IRQ_HANDLED;
  }
  
  static int max77823_fuelgauge_debugfs_show(struct seq_file *s, void *data)
  {
  	struct max77823_fuelgauge_data *fuelgauge = s->private;
  	int reg = 0;
  	u16 d[16];
  
  	seq_printf(s, "MAX77823 FUELGAUGE IC :
  ");
  	seq_printf(s, "===================
  ");
  	while (reg < 0x100) {
  		int i;
  		int base = reg;
  		for (i = 0; i < 0x10; i++)
  			d[i] = max77823_read_word(fuelgauge->i2c, reg++);
  
  		seq_printf(s, "%02x: %04x %04x %04x %04x %04x %04x %04x %04x  "
  				    "%04x %04x %04x %04x %04x %04x %04x %04x
  ",
  			base, d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],
  			d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]);
  		if (reg == 0x50)
  			reg = 0xb0;
  		else if (reg == 0xc0)
  			reg = 0xd0;
  		else if (reg == 0xe0)
  			reg = 0xf0;
  	}
  	return 0;
  }
  
  static int max77823_fuelgauge_debugfs_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, max77823_fuelgauge_debugfs_show, inode->i_private);
  }
  
  static const struct file_operations max77823_fuelgauge_debugfs_fops = {
  	.open           = max77823_fuelgauge_debugfs_open,
  	.read           = seq_read,
  	.llseek         = seq_lseek,
  	.release        = single_release,
  };
  
  #ifdef CONFIG_OF
  #define TFRAC_BITS 11
  static int calc_temp(int ain, int toff, int tgain, int tcurve)
  {
  	int x1;
  	int x = (toff << (TFRAC_BITS - 7)) + ((ain * tgain) >> (16 + 6 - TFRAC_BITS));
  	s64 t64;
  	int t;
  
  	x1 = x - (20 << TFRAC_BITS);
  	t64 = (tcurve * x1);
  	t = (t64 * x1) >> (10 + TFRAC_BITS + TFRAC_BITS - TFRAC_BITS);
  	if (x1 >= 0)
  		t = x + t;
  	else
  		t = x - t;
  	return t;
  }
  
  struct best_s {
  	u64 sum;
  	int tcurve;
  	int toff;
  	int tgain;
  };
  
  static u64 calc_error(int tcurve, int tgain, int toff, u32 *pairs, int length)
  {
  	u64 sum = 0;
  	int i;
  
  	/* calculate sum of error**2 */
  	for (i = 0; i < length; i += 2) {
  		int temp = pairs[i] << (TFRAC_BITS - 8);
  		int ain = pairs[i + 1];
  		int c = calc_temp(ain, toff, tgain, tcurve);
  		int err = temp - c;
  		u64 lerr;
  
  		if (err < 0)
  			err = -err;
  		lerr = err;
  		lerr = lerr * err;
  		sum += lerr;
  	}
  //	pr_info("%s: tcurve=%d, tgain=%d, toff=%d, sum=%lld
  ", __func__, tcurve, tgain, toff, sum);
  	return sum;
  }
  
  static void get_best_toff(struct best_s *best, int tgain, u32 *pairs, int length)
  {
  	int toff1 = best->toff;
  	int toff = toff1;
  	int best_toff = best->toff;
  	u64 best_sum = 0xffffffffffffffffL;
  	int change = -32;
  
  	while (1) {
  		u64 sum = calc_error(best->tcurve, tgain, toff, pairs, length);
  
  		if (best_sum >= sum) {
  			best_sum = sum;
  			best_toff = toff;
  		} else {
  			toff = best_toff;
  			if (change == -1) {
  				change = 16;
  			} else {
  				change >>= 1;
  				if (!change)
  					break;
  			}
  		}
  		toff += change;
  		if (change > 0) {
  			if (toff >= 32768) {
  				toff = 32767;
  				change = toff - best_toff;
  				if (!change)
  					break;
  			}
  		} else {
  			if (toff < -32768) {
  				toff = -32768;
  				change = toff - best_toff;
  				if (!change)
  					change = 16;
  			}
  		}
  	}
  
  	if (best->sum >= best_sum) {
  		best->sum = best_sum;
  		best->toff = best_toff;
  		best->tgain = tgain;
  		pr_info("%s: tcurve=%d, tgain=%d, toff=%d, sum=%lld
  ",
  			__func__, best->tcurve, tgain, best_toff, best_sum);
  	}
  }
  
  static void get_best_tgain(struct best_s *best, u32 *pairs, int length)
  {
  	int tgain = best->tgain;
  	int change = -32;
  
  	while (1) {
  		get_best_toff(best, tgain, pairs, length);
  
  		if (tgain != best->tgain) {
  			tgain = best->tgain;
  			if (change == -1) {
  				change = 16;
  			} else {
  				change >>= 1;
  				if (!change)
  					break;
  			}
  		}
  		tgain += change;
  		if (change > 0) {
  			if (tgain >= 32768) {
  				tgain = 32767;
  				change = tgain - best->tgain;
  				if (!change)
  					break;
  			}
  		} else {
  			if (tgain < -32768) {
  				tgain = -32768;
  				change = tgain - best->tgain;
  				if (!change)
  					change = 16;
  			}
  		}
  	}
  }
  
  static void calibrate_temp(struct sec_battery_platform_data *pdata, u32 *pairs, int length)
  {
  	int i;
  	struct best_s best;
  	int tcurve = 0;
  	int sx = 0;
  	int sy = 0;
  	s64 sxx = 0;
  	s64 sxy = 0;
  	s64 t;
  	s64 s;
  	int d;
  	int len = length >> 1;
  
  	for (i = 0; i < length; i += 2) {
  		int y = pairs[i];
  		int x = pairs[i + 1];
  
  		y = (y << 8) / 10;
  		sx += x;
  		sy += y;
  		sxx += x * x;
  		sxy += x * y;
  		pairs[i] = y;
  	}
  	t = sx;
  	t *= sy;
  	s = (sxy * len - t);		/* 24 fraction bits */
  	t = sx;
  	t *= sx;
  	d = (sxx * len - t) >> 16;	/* 16 fraction bits */
  	s = div64_s64(s, d); 		/* 8 fraction bits */
  	best.tcurve = 0;
  	best.tgain = s >> 2;	/* units 1/64, not 1/256*/
  	/* toff is units 1/128 not 1/256 */
  	best.toff = ((sy - (int)((best.tgain * (s64)sx) >> (6 + 16 - 8))) / len) >> 1;
  	best.sum = calc_error(best.tcurve, best.tgain, best.toff, pairs, length);
  	pr_info("%s: tcurve=%d, tgain=%d, toff=%d, sum=%lld
  ",
  		__func__, best.tcurve, best.tgain, best.toff, best.sum);
  
  	for (tcurve = 0; tcurve < 256; tcurve++) {
  		struct best_s b;
  
  		b.tcurve = tcurve;
  		b.tgain = best.tgain;
  		b.toff = best.toff;
  		b.sum = 0xffffffffffffffffL;
  		get_best_tgain(&b, pairs, length);
  
  		if (best.sum < b.sum)
  			break;
  		best = b;
  		pr_info("%s: tcurve=%d, tgain=%d, toff=%d, sum=%lld
  ",
  			__func__, best.tcurve, best.tgain, best.toff, best.sum);
  	}
  	pdata->tcurve = best.tcurve;
  	pdata->tgain = best.tgain;
  	pdata->toff = best.toff;
  
  	for (i = 0; i < length; i += 2) {
  		unsigned temp = (pairs[i] * 10) >> 8;
  		unsigned ain = pairs[i + 1];
  		unsigned c = calc_temp(ain, best.toff, best.tgain, best.tcurve);
  
  		pr_info("%s: %d, 0x%x, %d
  ", __func__, temp, ain,
  				(c * 10) >> TFRAC_BITS);
  	}
  }
  
  struct dt_data {
  	const char* const field;
  	int	offset;
  };
  
  #define BOFFSET(field) offsetof(struct sec_battery_platform_data, field)
  const struct dt_data dt_fields[] = {
  	{"fuelgauge,capacity_max", BOFFSET(capacity_max) },
  	{"fuelgauge,capacity_max_margin", BOFFSET(capacity_max_margin) },
  	{"fuelgauge,capacity_min", BOFFSET(capacity_min) },
  	{"fuelgauge,capacity_calculation_type", BOFFSET(capacity_calculation_type) },
  	{"fuelgauge,fuel_alert_soc", BOFFSET(fuel_alert_soc) },
  	{"empty_detect_voltage", BOFFSET(empty_detect_voltage) },
  	{"empty_recovery_voltage", BOFFSET(empty_recovery_voltage) },
  	{NULL, 0}
  };
  static int max77823_fuelgauge_parse_dt(
  		struct max77823_fuelgauge_data *fuelgauge,
  		struct device_node *np)
  {
  	struct sec_battery_platform_data *pdata = fuelgauge->pdata;
  	int ret;
  	const struct dt_data *dtd = dt_fields;
  	struct property *prop;
  	int length;
  	u32 pairs[64];
  
  	/* reset, irq gpio info */
  	if (np == NULL) {
  		pr_err("%s np NULL
  ", __func__);
  		return -1;
  	}
  
  	while (dtd->field) {
  		u32 *p = (u32 *)(((void *)pdata) + dtd->offset);
  		ret = of_property_read_u32(np, dtd->field, p);
  		if (ret < 0)
  			pr_err("%s: error reading %s(%d)
  ", __func__,
  					dtd->field, ret);
  		else
  			pr_info("%s: %s=%d
  ", __func__, dtd->field, *p);
  		dtd++;
  	}
  	pdata->repeated_fuelalert = of_property_read_bool(np,
  			"fuelgauge,repeated_fuelalert");
  	pr_info("%s: fg_irq: %d, repeated_fuelalert: %d
  ",
  			__func__, pdata->fg_irq,
  			pdata->repeated_fuelalert);
  
  	prop = of_find_property(np, "temp-disabled", &length);
  	pdata->temp_disabled = prop ? 1 : 0;
  
  	ret = of_property_read_u32_array(np, "temp-calibration", pairs, 3);
  	if (ret >= 0) {
  		pdata->tcurve = pairs[0];
  		pdata->tgain = pairs[1];
  		pdata->toff = pairs[2];
  		pr_info("%s: tcurve:%d, tgain:%d toff:%d
  ",
  				__func__, pdata->tcurve, pdata->tgain, pdata->toff);
  		return 0;
  	}
  	pr_err("%s: error reading temp-calibration %d
  ", __func__, ret);
  
  	prop = of_find_property(np, "temp-calibration-data", &length);
  	if (!prop) {
  		pr_err("%s: error reading temp-calibration-data
  ", __func__);
  		return 0;
  	}
  	length >>= 2;
  	length &= ~1;
  	if (length > ARRAY_SIZE(pairs))
  		length = ARRAY_SIZE(pairs);
  	ret = of_property_read_u32_array(np, "temp-calibration-data", pairs, length);
  	if (ret < 0) {
  		pr_err("%s: error reading temp-calibration-data %d
  ", __func__, ret);
  		return 0;
  	}
  	calibrate_temp(pdata, pairs, length);
  	return 0;
  }
  #endif
  
  static int max77823_fuelgauge_probe(struct platform_device *pdev)
  {
  	struct max77823_dev *max77823 = dev_get_drvdata(pdev->dev.parent);
  	struct max77823_platform_data *pdata = dev_get_platdata(max77823->dev);
  	struct max77823_fuelgauge_data *fuelgauge;
  	int ret = 0;
  	union power_supply_propval raw_soc_val;
  
  	pr_info("%s: MAX77823 Fuelgauge Driver Loading
  ", __func__);
  
  	fuelgauge = kzalloc(sizeof(*fuelgauge), GFP_KERNEL);
  	if (!fuelgauge)
  		return -ENOMEM;
  
  	pdata->fuelgauge_data = kzalloc(sizeof(sec_battery_platform_data_t), GFP_KERNEL);
  	if (!pdata->fuelgauge_data) {
  		kfree(fuelgauge);
  		return -ENOMEM;
  	}
  
  	mutex_init(&fuelgauge->fg_lock);
  
  	fuelgauge->dev = &pdev->dev;
  	fuelgauge->pdata = pdata->fuelgauge_data;
  	fuelgauge->i2c = max77823->fuelgauge;
  	fuelgauge->max77823_pdata = pdata;
  
  #if defined(CONFIG_OF)
  	ret = max77823_fuelgauge_parse_dt(fuelgauge, pdev->dev.of_node);
  	if (ret < 0) {
  		pr_err("%s:dt error! ret[%d]
  ", __func__, ret);
  		goto err_free;
  	}
  #endif
  	board_fuelgauge_init((void *)fuelgauge);
  
  	platform_set_drvdata(pdev, fuelgauge);
  
  	fuelgauge->psy_fg.name		= "max77823-fuelgauge";
  	fuelgauge->psy_fg.type		= POWER_SUPPLY_TYPE_UNKNOWN;
  	fuelgauge->psy_fg.get_property	= max77823_fg_get_property;
  	fuelgauge->psy_fg.set_property	= max77823_fg_set_property;
  	fuelgauge->psy_fg.properties	= max77823_fuelgauge_props;
  	fuelgauge->psy_fg.num_properties =
  		ARRAY_SIZE(max77823_fuelgauge_props);
  	fuelgauge->psy_fg.property_is_writeable  = max77823_fg_property_is_writeable;
  	fuelgauge->capacity_max = fuelgauge->pdata->capacity_max;
  #ifdef CONFIG_FUELGAUGE_MAX77823_VOLTAGE_TRACKING
  	raw_soc_val.intval = max77823_get_soc(fuelgauge) / 10;
  #else
  	raw_soc_val.intval = fg_read_percent(fuelgauge, SOCREP_REG) / 10;
  #endif
  
  	if(raw_soc_val.intval > fuelgauge->pdata->capacity_max)
  		max77823_fg_calculate_dynamic_scale(fuelgauge);
  
  	(void) debugfs_create_file("max77823-fuelgauge-regs",
  		S_IRUGO, NULL, (void *)fuelgauge, &max77823_fuelgauge_debugfs_fops);
  
  	if (!max77823_fg_init(fuelgauge)) {
  		pr_err("%s: Failed to Initialize Fuelgauge
  ", __func__);
  		goto err_free;
  	}
  
  	ret = power_supply_register(&pdev->dev, &fuelgauge->psy_fg);
  	if (ret) {
  		pr_err("%s: Failed to Register psy_fg
  ", __func__);
  		goto err_free;
  	}
  
  	fuelgauge->fg_irq = pdata->irq_base + MAX77823_FG_IRQ_ALERT;
  	pr_info("[%s]IRQ_BASE(%d) FG_IRQ(%d)
  ",
  		__func__, pdata->irq_base, fuelgauge->fg_irq);
  
  	if (fuelgauge->fg_irq) {
  		INIT_DELAYED_WORK(&fuelgauge->isr_work, max77823_fg_isr_work);
  
  		ret = request_threaded_irq(fuelgauge->fg_irq,
  				NULL, max77823_fg_irq_thread,
  			        IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
  				"fuelgauge-irq", fuelgauge);
  		if (ret) {
  			pr_err("%s: Failed to Request IRQ
  ", __func__);
  			goto err_supply_unreg;
  		}
  	}
  
  	fuelgauge->is_fuel_alerted = false;
  	if (fuelgauge->pdata->fuel_alert_soc >= 0) {
  		if (max77823_fg_fuelalert_init(fuelgauge,
  				       fuelgauge->pdata->fuel_alert_soc))
  			wake_lock_init(&fuelgauge->fuel_alert_wake_lock,
  				       WAKE_LOCK_SUSPEND, "fuel_alerted");
  		else {
  			pr_err("%s: Failed to Initialize Fuel-alert
  ",
  				__func__);
  			ret = -ENODEV;
  			goto err_irq;
  		}
  	}
  
  	fuelgauge->initial_update_of_soc = true;
  
  	pr_info("%s: MAX77823 Fuelgauge Driver Loaded
  ", __func__);
  	return 0;
  
  err_irq:
  	if (fuelgauge->fg_irq)
  		free_irq(fuelgauge->fg_irq, fuelgauge);
  err_supply_unreg:
  	power_supply_unregister(&fuelgauge->psy_fg);
  err_free:
  	mutex_destroy(&fuelgauge->fg_lock);
  	kfree(pdata->fuelgauge_data);
  	kfree(fuelgauge);
  
  	return ret;
  }
  
  static int max77823_fuelgauge_remove(struct platform_device *pdev)
  {
  	struct max77823_fuelgauge_data *fuelgauge =
  		platform_get_drvdata(pdev);
  
  	if (fuelgauge->pdata->fuel_alert_soc >= 0)
  		wake_lock_destroy(&fuelgauge->fuel_alert_wake_lock);
  
  	return 0;
  }
  
  static int max77823_fuelgauge_suspend(struct device *dev)
  {
  	return 0;
  }
  
  static int max77823_fuelgauge_resume(struct device *dev)
  {
  	struct max77823_fuelgauge_data *fuelgauge = dev_get_drvdata(dev);
  
  	fuelgauge->initial_update_of_soc = true;
  
  	return 0;
  }
  
  static void max77823_fuelgauge_shutdown(struct device *dev)
  {
  }
  
  #if defined(CONFIG_OF)
  static struct of_device_id max77823_fuelgauge_dt_ids[] = {
  	{ .compatible = "samsung,max77823-fuelgauge" },
  	{ }
  };
  MODULE_DEVICE_TABLE(of, max77823_fuelgauge_dt_ids);
  #endif /* CONFIG_OF */
  
  static SIMPLE_DEV_PM_OPS(max77823_fuelgauge_pm_ops, max77823_fuelgauge_suspend,
  			 max77823_fuelgauge_resume);
  
  static struct platform_driver max77823_fuelgauge_driver = {
  	.driver = {
  		   .name = "max77823-fuelgauge",
  		   .owner = THIS_MODULE,
  #ifdef CONFIG_PM
  		   .pm = &max77823_fuelgauge_pm_ops,
  #endif
  		.shutdown = max77823_fuelgauge_shutdown,
  #if defined(CONFIG_OF)
  		.of_match_table	= max77823_fuelgauge_dt_ids,
  #endif /* CONFIG_OF */
  		   },
  	.probe	= max77823_fuelgauge_probe,
  	.remove	= max77823_fuelgauge_remove,
  };
  
  static int __init max77823_fuelgauge_init(void)
  {
  	pr_info("%s: 
  ", __func__);
  	return platform_driver_register(&max77823_fuelgauge_driver);
  }
  
  static void __exit max77823_fuelgauge_exit(void)
  {
  	platform_driver_unregister(&max77823_fuelgauge_driver);
  }
  module_init(max77823_fuelgauge_init);
  module_exit(max77823_fuelgauge_exit);
  
  MODULE_DESCRIPTION("Samsung MAX778023 Fuel Gauge Driver");
  MODULE_AUTHOR("Samsung Electronics");
  MODULE_LICENSE("GPL");
  MODULE_ALIAS("platform:max77823-fuelgauge");